MAIDR JavaScript API
    Preparing search index...

    Class FlowTrace

    Trace implementation for sankey, alluvial and chord diagrams.

    These charts encode weighted flow between nodes, and they exist to show routing and proportion at once: where a quantity comes from, where it splits, and how much is lost at each hop. That is a question about topology, and topology is the thing a flat reading is worst at. A sighted reader traces a ribbon in a second; MAIDR's grid had no equivalent action at all, and unlike most gaps there was no partial reading available either -- the chart is a graph and the model was a grid.

    Following a ribbon is the primary move, and it is on the keys that already exist. A sankey is drawn as columns of nodes with flow running left to right, so the arrows are given the chart's own geometry:

    • right follows the largest flow out of this node, to the next column;
    • left follows the largest flow in, back upstream;
    • up and down walk the other nodes stacked in this column.

    That is both the drawing and MAIDR's ordinary reading of its arrows -- left and right move along, up and down move between -- so nothing has to be relearned. The largest flow is the default because it is the ribbon an eye follows: the widest band leaving a node is the one the chart is drawing attention to. Every other flow is one rotor away.

    The edge is announced, not just the node it lands on. A move that said only "Electricity, 34" would have withheld the entire content of the step -- which flow was taken, how big it was, and what share of this node's output it represents. So the trace remembers the edge it arrived by and announces it: Coal to Electricity, 34, 60.7% of Coal.

    Stages are the drawing's columns, and a cycle is answered honestly. A producer that knows where it drew each node says so (FlowOptions.columns). Otherwise a node's column is its longest distance from a source, which is how these layouts are commonly built. A chord diagram is cyclic and has no such thing, so when the graph does not sort, every node goes in one stage: the ribbons still follow, and nothing is claimed about an ordering the data does not have.

    Nodes are derived from the edges. A flow list names both of its ends, so a separate node list would be a second source of truth for something the edges already say -- the treemap's reasoning about paths, applied to a graph.

    Hierarchy (View Summary)

    Implements

    Index

    Constructors

    Properties

    observers: Observer<TraceState>[]
    isWarning: boolean
    isComputingStateAt: boolean

    True while AbstractTrace.getStateAt computes state at a temporarily moved cursor. Enforces (structurally, not just by documentation) that state getters never notify observers.

    id: string
    type: TraceType
    title: string
    name: string | undefined

    What this layer is, when the producer named it. See MaidrLayer.name.

    layer: MaidrLayer
    supportsExtrema: true

    ] and [ go to the busiest and the quietest node, and the Go To dialog lists them: see FlowTrace.getExtremaTargets. Unrelated to moveToExtreme, which follows the dominant path to its end.

    movable: MovableGraph
    highlightValues: SVGElement[][] | null

    highlightValues[row][col], or null for the whole trace when it highlights nothing.

    A single cell may also be null, meaning the chart drew no element there. That is a narrower claim than the trace-wide null: the rest of the grid still highlights, and only this position falls back to the out-of-bounds state. A Google Charts calendar is the case it exists for -- its first and last columns are ragged, so a handful of grid positions have no rect at all while every other day does (#1174).

    Accessors

    • get isInitialEntry(): boolean

      Returns boolean

    • set isInitialEntry(value: boolean): void

      Parameters

      • value: boolean

      Returns void

    • get row(): number

      Returns number

    • set row(value: number): void

      Parameters

      • value: number

      Returns void

    • get col(): number

      Returns number

    • set col(value: number): void

      Parameters

      • value: number

      Returns void

    • get categoriesRunDown(): boolean

      Whether this trace's grid lists its categories as columns while the chart draws them one above another: a horizontal bar, dot, lollipop, funnel, dumbbell or forest chart. Its arrow keys are then turned to follow the drawing (keyDirection), as a horizontal box plot's already were: Up and Down move between the categories, and Left and Right along one, between the series, ends or sections drawn across it.

      Returns boolean

      False here; true on the traces of that shape drawn on their side

    • get xAxis(): string

      The x axis's name, falling back to a generic one the layer authored none.

      A getter rather than a field set in the constructor: the fallback is a translated word, and a trace outlives a language change — a name resolved once at construction would keep the language the chart was built in.

      Returns string

    • get yAxis(): string

      The y axis's name, or a generic one. See xAxis.

      Returns string

    • get z(): string

      The z axis's name, or a generic one. See xAxis.

      Returns string

    • get isEmptyAtCursor(): boolean

      Whether the cursor has no point to report.

      Read from dimension rather than from any one trace's data, because that is the one shape every trace already answers in. It is also evaluated at the cursor — LineTrace returns the current series' length as cols — so this covers a ragged layer, where one series has points and another has none, and not only a layer that is empty throughout.

      Returns boolean

      True when there is nothing at (row, col) to describe

    • get state(): TraceState

      Gets the current state of the trace including audio, braille, text, and highlight information.

      Returns TraceState

      The current TraceState

    • get outOfBoundsState(): TraceEmptyState

      The state pushed to observers when navigation leaves the data.

      Declared as TraceEmptyState rather than the whole TraceState union because that is what every implementation actually returns — the accessor exists so AbstractPlot.notifyOutOfBounds has an empty state to push. Narrowing it here is what lets the braille and highlight callers hand the value straight on: those states accept the empty trace shape but not a populated one, so a wider declaration would force each of them to cast, and a cast is exactly what stops the compiler from noticing if an override ever starts returning a populated state.

      Returns TraceEmptyState

      The empty trace state, positioned for out-of-bounds audio panning.

    • get hasMultiPoints(): boolean

      Returns boolean

    • get layerLabel(): string

      How this layer names itself in the description dialog's layer tabs.

      The producer's name when there is one, and the chart-type label otherwise — the same fallback order TextService.layerIdentity uses for the spoken layer-switch announcement, so a tab and the announcement single out the same layer by the same name. The two differ only in register: the announcement says "point plot" where the dialog says "Scatter Plot", because that written form is what the dialog's own Chart Type line has always shown and a tab sitting above it should agree with it.

      Returns string

    • get placeAxisLabel(): string

      Returns string

      Trace.placeAxisLabel

    • get guide(): ChartGuide | undefined

      A plain-language introduction to this layer's chart type, for the description dialog. See chartGuide.

      A layer that names its own chart type never gets the trace type's: that guide explains the type the chart is read as, which is not what the chart is, and a gantt's tasks, dates and project plans said of a packet's bit fields are false. It gets the guide to the diagram it names (MaidrLayer.diagramType), or the one it gives to its own chart (MaidrLayer.typeGuide), or none.

      Returns ChartGuide | undefined

    • get orientationLabel(): string | undefined

      Which way this chart is drawn, or undefined for a type that has no orientation to speak of.

      Entering the chart already announces it -- "This is a maidr plot of type: horizontal bar" -- but the description dialog said only "Chart Type: Bar Chart", and for the box, violin and boxen families the orientation also silently reverses the order of the rows in the table underneath, because their constructors reverse the groups when the chart is horizontal. A reader comparing the table with what they walked had no way to know why the two disagreed.

      Exposed here, and read once by the description service, rather than pushed as a stat by each of the thirty-odd traces that has one. Named apart from the bar and distribution families' own orientation fields, which hold the declared* value and default it to vertical for every type -- including the ones that have no orientation at all.

      Returns string | undefined

      horizontal or vertical, or undefined when the type has no orientation to report.

    • get valueSpan(): number

      How far the layer's measured values spread: its largest less its smallest, or 0 with fewer than two. The scale at which [, ] and the Go To dialog read two values as one extreme (MathUtil.nearlyEqualInRange).

      Read from values, the numbers the layer is sounded and brailled from; a trace whose extrema rank something else says so by overriding it.

      Returns number

      The span, never negative

    • get traceType(): TraceType

      The trace's chart type. Lightweight alternative to reading state.traceType, which eagerly computes the full audio/braille/text/ highlight state just to expose this one string.

      Returns TraceType

    • get level(): "trace"

      Returns "trace"

      Trace.level

    • get values(): number[][]

      Returns number[][]

    • get highlightedPointIndices(): readonly number[]

      The ribbon the highlight currently covers, as an index into this layer's data array.

      This is highlight answered in a renderer-neutral currency. A flow chart drawn on a canvas has no SVG elements for selectors to reach, and an adapter that rebuilt the stage layering to find the node itself would drift from assignStages silently -- so the trace names the ribbon by the position it occupies in the flow array the adapter supplied, and the adapter inverts that against its own extraction walk.

      Derived from highlightedRibbon, the same expression highlight picks its ribbon by, so the canvas highlight and the SVG highlight cannot name different ribbons.

      Deliberately not gated on SVG availability: a canvas chart has no elements by definition, and that is the case this exists to serve.

      Returns readonly number[]

      One index into layer.data, or nothing when the cursor is on no node or on a node no ribbon was drawn for.

    Methods

    • Runs action with this element's observers muted.

      A cursor move normally is the announcement -- moveToIndex notifies, and everything downstream of it speaks, brailles and highlights. That is wrong for a move the reader did not make and is not waiting to hear: the description dialog's layer tabs relocate the reader in the chart while the modal is open, and the trace's announcement would land in the same live region the dialog is using, so one of the two is dropped. The caller announces afterwards, once, when the reader is back on the chart.

      Nesting is safe and the flag is restored on every path, including a throw, because a flag left raised would silence the chart for good.

      Parameters

      • action: () => void

        The moves to make in silence

      Returns void

    • Gets safe row and column indices to prevent accessing undefined values

      Returns { row: number; col: number }

      Object with safe row and column indices

    • The rotor's LOWER and HIGHER VALUE search. The base is a no-op that reports the boundary: a trace that can compare overrides it, and supportsCompareMode offers the two modes exactly where it does.

      Parameters

      • _direction: "left" | "right" | "up" | "down"
      • _type: "lower" | "higher"

      Returns boolean

    • Parameters

      • a: number

        Utility function to compare point values for rotor functionality

      • b: number
      • type: "lower" | "higher"

      Returns boolean

      boolean value

    • Rotor compare search along one row of numeric values.

      Steps from the current column in the given direction and moves to the first value that satisfies the comparison; reports the rotor boundary when nothing further qualifies. For the traces whose values are a plain numeric grid indexed [row][col]; a trace with a richer layout (the bar's orientation-normalised rows, the candlestick's segments) keeps its own.

      Parameters

      • rowValues: readonly number[]

        The values of the row being searched

      • direction: "left" | "right"

        Which way to search

      • type: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      True when a matching value was found and moved to

    • Whether the rotor offers its lower and higher value modes on this trace.

      Exactly when the trace overrides moveToNextCompareValue. The base search is a no-op that reports a boundary, so offering the modes without one told a reader "No lower value found" with a lower value beside them, or said nothing at all; tying the offer to the search keeps the two from drifting apart again. A subclass can still override this to withhold the modes (scatter, whose arrows walk points rather than values), and a trace that compares only through the rotor's arrow methods must override it to offer them.

      Returns boolean

    • Returns the display name for the default data navigation mode. Override to provide a trace-specific name (e.g., "ROW AND COLUMN NAVIGATION" for scatter).

      Returns string

    • The rotor's lower and higher value search, Up: on a chart drawn on its side, along the categories toward the one drawn above, as Up moves. Elsewhere the rotor reads Up as Right.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved

    • The rotor's search, Down: toward the category drawn below. See moveUpRotor.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved

    • The rotor, Left: on a chart drawn on its side, the plain move along the category, as a horizontal box plot's rotor moves along its box. The search runs along the categories, which Up and Down walk there.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved. False at the end of the category -- on a chart of one series, always -- so the rotor says there is nothing further that way; it reported true, and the rotor said nothing.

    • The rotor, Right. See moveLeftRotor.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved, false at the end of the category

    • The direction to move the grid for a key, which is the key's own except on a trace whose categories run down the page. There the grid's columns are drawn one above another and its rows across them, so Up and Down step the columns, toward the category drawn above or below, and Right and Left step the rows. On a horizontal bar chart Right and Left moved down and up the page between the bars, and Up and Down said there was no more data: the other way round from a horizontal box plot or violin.

      Parameters

      Returns MovableDirection

      The direction to move the grid in

    • Whether the first category is drawn above the last.

      Producers list a horizontal chart's categories both ways: matplotlib, ggplot2, base R and Plotly draw the first at the bottom, and Highcharts, ApexCharts, Vega-Lite, seaborn and most hand-drawn charts at the top. So it is measured, as a Gantt chart measures its lanes, from the marks the highlight holds: in the first row that has two, the first category's mark is above the last one's, or below it. Measured on every vertical key, an autoplay step included, rather than once. That is two boxes a key, however many categories the chart has: the two marks are found from the ends of the row, and the read forces at most the layout the highlight's move would cause before the next paint. An answer kept from the first key was kept from a chart not yet laid out, or one since re-rendered the other way round, and a cache would have to be cleared on every redraw and resize to avoid that.

      Where nothing can be measured now, the last measurement holds, so a chart hidden for a moment does not turn the keys round under the reader. Where nothing has ever been measured -- a chart drawn to a canvas, one with no highlight, one not laid out yet, or one category -- the layer's MaidrLayer.firstCategory says where the first is drawn. Without it, the first is taken to be at the bottom, as row 0 of a grid is, and Up moves to the next.

      Returns boolean

      True when the first category is drawn at the top

    • The format the layer's author declared for an axis, or null when they declared none.

      For a number the description states rather than tabulates. The table reads each column through the axis's declared format, and so does every announcement, but a stat printed the raw number: a margin drawn as a percentage was "Min value: 0.12" over a table and a cursor saying 12%. Null rather than the default format when nothing was declared, so a chart nobody formatted reads as it did, which is the rule the table follows.

      Taken from FormatUtil.axisFormat, as the announcements and the table take theirs, so a histogram's bin edges read with the same decimals in all three.

      Parameters

      • axis: AxisType

        The axis whose format to read

      Returns FormatFunction | null

      The format, or null when the layer declared none

    • Get all highlight SVG elements for this trace Used by HighlightService for high contrast mode

      Returns SVGElement[]

      Array of all SVG elements, or empty array if none

    • The chart's own element a marker this trace drew stands for, where the trace marks a point with a dot of its own rather than with a copy of the mark. None by default.

      Parameters

      • _marker: SVGElement

        A marker in this trace's highlight values

      Returns SVGElement | null

      The element the marker stands for, or null

    • Get all original (visible) SVG elements for this trace. These are the actual rendered elements, not the hidden clones used for highlighting. Used by HighlightService for high contrast mode color changes.

      Returns SVGElement[]

      Array of all original SVG elements, or empty array if none

    • Computes the trace state at an arbitrary position without moving the user's cursor or notifying observers. Used by monitor mode to sonify and announce a newly appended point while the user stays put.

      The state getters read this.row/this.col internally, so the cursor is moved temporarily and always restored in a finally block — this method is the single owner of that pattern.

      Re-entrancy hazard: this is only safe because the entire call chain is synchronous (no await points), so timers (e.g. autoplay ticks) cannot interleave before the finally-restore, and state getters never notify observers. If a getter ever becomes async or triggers notifications, callers could observe the temporary cursor.

      Parameters

      • row: number

        The row of the position to compute state for

      • col: number

        The column of the position to compute state for

      Returns TraceState

      The trace state at the requested position

    • Returns a human-readable label for this trace's chart type (e.g., 'Bar Chart', 'Scatter Plot') for display in the description modal. Falls back to the raw layer type if no mapping is registered.

      Returns string

    • What the entry instruction calls this chart: the name the layer gives its own chart type (MaidrLayer.diagramType or MaidrLayer.typeLabel), or the trace's word.

      A trace that names itself -- a line "single line" or "multiline", a radar "polar area" -- passes its word through here, so a layer that names its chart type is called by that name whichever trace reads it, and the instruction a reader hears once in the chart says what the one built from the layer before it said.

      Parameters

      • own: string

        The trace's word for its type

      Returns string

      The word the instruction uses

    • Builds the axes object for the description state, carrying only the axes the layer actually authored a label for. Subclasses should call this instead of constructing the axes object inline so charts without a real z dimension don't surface the placeholder default.

      Every axis is gated, not just z. xAxis and yAxis fall back to the literal 'X' and 'Y' when the JSON authors no label -- legal, and common in adapter-generated specs -- and the dialog rendered that as "X: X", a line that says nothing twice. The figure-level branch of the description already showed only authored labels (DescriptionService.getFigureAxes), so gating here is what makes the two levels of the same dialog follow one rule.

      Blankness is tested with trim(), the same rule named applies when it decides whether to substitute the fallback in the first place. A whitespace-only z label is truthy but blank, so the untrimmed guard used to pass it through and then print the 'Level' placeholder the guard existed to keep out.

      Returns { x?: string; y?: string; z?: string }

    • Whether the cursor stands on an extremum target, for a trace whose cursor its row and column do not hold: a scatter plot in point navigation keeps a point's index instead. Null leaves the answer to the row and column, which is how every other trace's cursor is read.

      Parameters

      Returns boolean | null

      True or false where the trace keeps its cursor elsewhere, and otherwise null

    • Returns true if this trace supports intersection navigation mode. Opt-in per trace type: override to return true (possibly conditionally, e.g. based on data shape) for trace types that expose point intersections between series. Intersection navigation is a trace-level capability — it has no meaning at the figure or subplot level, which is why it lives on AbstractTrace rather than AbstractPlot.

      Returns boolean

    • Returns true if this trace supports point-by-point navigation mode. Opt-in per trace type: override to return true for traces that expose individual data points navigable in reading order (left/right) and column-major order (up/down). Currently only ScatterTrace.

      Returns boolean

    • Notifies the trace that the rotor is entering or leaving INTERSECTION_MODE. Default is a no-op; line-style traces don't need to track mode state because their state output is unchanged by the rotor mode. Traces whose audio/text output differs in intersection mode (e.g. ScatterTrace, which normally plays the whole x-column as a chord and must instead focus a single point) override this to flip an internal flag.

      Parameters

      • _enabled: boolean

        True when entering intersection mode, false when leaving.

      Returns void

    • Notifies the trace which of its getRotorFilterUnits the rotor is on, or null when it is on none of them. Default is a no-op: a unit usually changes only where Left and Right go, which moveToRotorFilter answers. A trace whose unit also changes what Control with them should reach -- a tree's Level, where Left and Right walk the whole level -- overrides this, because the jump is not routed through the rotor.

      Parameters

      Returns void

    • Moves to the object the list knows by this key, announcing it through the usual observer chain.

      Looks the key up in a list built now rather than trusting a cell the dialog was handed when it opened, so a chart whose data changed under the dialog moves the reader to the object they chose or nowhere at all.

      Parameters

      • key: string

        The key the object list gave the object

      Returns boolean

      True when the cursor moved, false when no object has the key or its cell cannot be reached

    • Why this layer has no extremum for [, ] and G to go to, where that is by design: what the layer lacks, as a phrase in the reader's language, which the refusal says after it says there is nothing to go to. Null where the layer has extrema, or has none only because of its data.

      Asked with the extreme a bracket key wants, a layer that has one of the two by design and not the other can say why for the one it lacks, as a ROC curve does for [. G, which lists both, asks without one.

      Parameters

      • Optional_extreme: "min" | "max"

        The extreme [ ('min') or ] ('max') asked for, or nothing for the layer as a whole

      Returns string | null

      The reason, or null

    • Whether a mark of this trace sits at exactly this X, as moveToXValue finds one before it falls back to the nearest.

      A layer switch asks this to choose between the two X values a position can offer (see Trace.getAlternateXValue). Reads the x of each point; a trace that keeps its X some other way answers false unless it says otherwise, and the switch then carries what it always carried.

      Parameters

      • xValue: XValue

        The X a layer switch would carry

      Returns boolean

      True when some point's x is exactly xValue

    • How this layer's x axis writes an x: through the format the layer declares for it, or null where it declares none.

      A layer switch carries a number this way to a layer that holds the same place as text (see Subplot.carriedXValue).

      Parameters

      • xValue: XValue

        An x of this layer's

      Returns string | null

      Its reading, or null

    • The x of this layer's that its axis writes as reading: the first in the order the points are held, or null where the layer declares no x format or none of its x reads that way.

      A layer switch carries text this way to a layer that holds the same place as a number its axis formats (see Subplot.carriedXValue).

      Parameters

      • reading: string

        The text another layer holds the place as

      Returns XValue | null

      The x, or null

    • Moves the active point to the pointer location and returns directional guidance toward the nearest data geometry in a single call.

      Combining both operations avoids running findNearestPoint twice per pointermove event — important on dense plots where the scan is the hot path.

      Parameters

      • x: number

        Screen-space x position of the pointer/finger

      • y: number

        Screen-space y position of the pointer/finger

      Returns PointerGuidanceState | null

      Guidance state relative to nearest point, or null when unavailable

    • Moves the trace to the nearest point when the pointer is within its bounds and the trace is not already focused on that point.

      onCurve is intentionally non-optional: the caller has already paid the cost of isPointInBounds to assemble guidance state, and forcing subclasses to accept the value makes the contract explicit so a future override cannot silently recompute (or worse, ignore) it.

      Subclasses override this to customise hover-driven navigation:

      • Box / ViolinBox no-op the move while still surfacing guidance.
      • Scatter switches into column navigation mode before delegating.

      Parameters

      Returns void

    • Checks if the specified coordinates are within bounds of the element.

      Parameters

      • x: number

        The x-coordinate

      • y: number

        The y-coordinate

      • element: NearestPoint

        Object containing the SVG element and its position

        • element: SVGElement
        • row: number
        • col: number
        • centerX: number
        • centerY: number

      Returns boolean

      True if the point is in bounds, false otherwise

    • Why there is no end, or no start, to jump to from the node the cursor is on, when that is because the largest flows go round in a cycle.

      Control + Right follows the largest flow out of each node to where the flows run out, and Control + Left the largest flow in. Where that route loops, nothing ends it, and Right and Left go round the loop for as long as they are pressed -- so the jump says so rather than landing on a node the next arrow moves on from. The edge signal would be no better: it says the cursor is at the end, and the next arrow moves.

      Before the reader has entered the chart the jump lands on the first node, as on every other chart, so there is no refusal to make yet.

      Parameters

      • direction: "FORWARD" | "BACKWARD"

        Which way the jump goes

      Returns string | null

      What to tell the reader, or null when the route has an end, or no first step, which the edge signal answers

    • Control and an arrow, by the same rule as moveOnce: on a chart drawn on its side, Control + Up and Down go to the top and the bottom category, and Control + Left and Right to the first and the last series.

      Parameters

      Returns boolean

      Whether the cursor moved

    • Offers the flows on either side of the current node.

      The arrows follow the largest ribbon, which is the one the chart draws attention to; everything else is here. Withheld where nothing branches, since a mode whose only answer is the move the arrows already make is not worth a keystroke.

      Returns readonly RotorFilterUnit[]

      The flow units alongside whatever else is offered

    • Moves within an active rotor filter unit along the filtered axis.

      Called by RotorNavigationService when the current rotor mode is one of this trace's getRotorFilterUnits. Filter units navigate a single axis, so only left/right are dispatched here — the service announces up/down as unavailable without calling the model (matching intersection mode). Implementations should move to the nearest point matching the unit identified by key and notify observers, returning true; when no such point exists they should call notifyRotorBounds and return false.

      Default is a no-op that reports bounds, so a trace advertising a filter unit but forgetting to implement movement fails safe (announces "no point found") rather than moving unexpectedly.

      Parameters

      • key: string
      • direction: "left" | "right"

      Returns boolean

      True if the cursor moved, false otherwise

    • Every node, for the o list, stage by stage and down each stage, which is the order the arrows reach them in.

      Each node is listed with its throughput, the amount every move announces. A chart in stages opens on them, because the stages are what a sankey is read by -- where the quantity starts, where it goes next -- and can be narrowed to one. A chord diagram, or any flow that cycles, has one stage holding everything and no order to read it in, so its list opens on the busiest node instead.

      Returns ChartObjectList | null

      The list, or null on a chart with no flows

    • The ribbons as the chart drew them, all of them, for a renderer that wants the shape rather than the highlight. Empty when the selectors did not resolve, so a caller can fall back in one check.

      Returns SVGElement[]

    • Removes every ribbon clone, not only the ones the highlight covers.

      AbstractTrace.dispose() walks highlightValues, which holds one ribbon per node; a ribbon that is nobody's widest is referenced only from ribbons, and left in the chart it accumulated on every focus cycle and live-data rebuild.

      Returns void

    • The busiest and the quietest nodes, for ], [ and the Go To dialog.

      A node's value is its throughput, what every move announces and the pitch plays, and the busiest is the one the description names. Every node holding an extreme is offered, stage by stage and down each stage, so a tie is walked. A throughput is a sum of flows, so two that are equal on paper can differ in the last bit; they tie within a billionth of the range the throughputs span, valueSpan, as every layer's extremes do, while flows that are small in their own units, 1e-12 and 5e-11, stay apart, their range being small too. The service that walks the ties compares them again within the same span. They carried a rankValue once, which the service ties within a billionth of the value itself, and it dropped the nodes of 2.0001 that this offered beside those of 2 on a chart whose throughputs reach a million.

      Returns ExtremaTarget[]

      The targets, or none for a chart with no node