Table of Contents

Strip Charts Source Code

Where the strip charts are built, and the routes and step fields they read. What they show and how they behave is Strip Charts.

Source Code Path

See HiNC App Anatomy for git repository links.

Web Application

HiNC-2025-webservice (Quasar CLI SPA):

  • wwwroot-src/src/components/execution/charts/StripChartGroupBar.vue — the group bar drawn on the open chart tab; wwwroot-src/src/components/execution/SessionInfoPanel.vue — the Panel Layout tab, whose two boxes tick the ID rows.
  • wwwroot-src/src/components/execution/charts/BaseStripChart.vue — shared strip-chart skeleton; idRowKeys and chartIdRows, the ID rows ticked and their data from the answer's idRows.
  • wwwroot-src/src/components/execution/charts/UplotChart.vue — uplot wrapper; yMinTickStep, the least step between y ticks (a percent axis' 0.01 %), which leaves out the increments that are no whole multiple of it and widens an auto-fit range narrower than it, and the tick increment it hands the y formatter; ID_ROW_PX, idRowSegments and drawIdRows, the ID rows over the plot.
  • wwwroot-src/src/utils/stripFormat.ts — the charts' text of a value: percentText, the one text of a percent (PERCENT_FLOOR, 0.01 %, under which a nonzero value prints <0.01%), isPercentUnit, quantityText (a % unit's value times its scale through percentText, any other through formatGeneral, a whole number from 10 000 up, two or three decimals down to 0.01 and an exponent under it), formatRangeWith (a min ~ max, once when the two ends print alike) and percentAxisText, a tick's or a range bound's percent with the decimals its step needs, two at most; the clock formats beside them.
  • wwwroot-src/src/utils/unitScale.ts — unitScaleOf (the scale a server field gives, 1 for anything but a positive number), shownInUnit and storedFromUnit, a range bound between the values' own units and the number the input shows and takes.
  • wwwroot-src/src/components/execution/charts/PluralStripAvailabilityChart.vue — availability chart.
  • wwwroot-src/src/components/execution/charts/PluralStripRoughnessChart.vue — surface-roughness chart.
  • wwwroot-src/src/components/execution/charts/StripIndividualChart.vue — aspect-picker individual chart.
  • wwwroot-src/src/api/clStrip.ts — typed REST wrappers for the range calls.
  • wwwroot-src/src/api/executionCharts.ts — the strip-chart fetch, with its 30 s deadline (STRIP_CHART_TIMEOUT_MS) and the caller's abort signal, over fetchWithTimeout in wwwroot-src/src/api/http.ts; the whitelist parses of colorTree and the colour guide's tree (anything malformed reads as none), and of the scales beside the units (StripChartItem.scale, StripColorTreeLeaf.valueScale, StepPropertyInfo.scale, ColorRule.unitLabel and scale), and of idRows (parseIdRows: a known key, once, with one value a bucket, else left out); inspectingKeyAnnouncement.
  • wwwroot-src/src/i18n/en/charts.ts — the empty-state strings under charts.empty, the picker's groups under charts.inspect, and the Colors dropdown's tree strings and notes under charts.coloring; wwwroot-src/src/components/execution/charts/colorTreeNotes.ts — a note's text.
  • wwwroot-src/src/composables/useClStripHub.ts — singleton hub wrapper (the same ref-counting pattern as the other execution hubs).
  • wwwroot-src/src/composables/useFeatureSegment.ts — the machining-segment selection the right-click menu and the Block Info Panel share: the request, and the answer held while the window shows the segment.
  • wwwroot-src/src/composables/useStripChartConfig.ts — the Y-range and colour-guide state, colorGuideTree among it, the guide's answers applied in request order.
  • wwwroot-src/src/composables/useStripChartGroup.ts — the reload tick and the hovered x.
  • wwwroot-src/src/components/execution/charts/stripGroupBarLayout.ts — the group bar's row count at the panel's width, which the page's floor follows.
  • wwwroot-src/src/components/execution/charts/stripIcons.ts — the reset button's arrow_range path.
  • wwwroot-src/src/pages/ExecutionPage.vue — sessionInfoFillFloor, from that row count, the chart card and the ID rows ticked (idRowsPx).
  • Execution/ExecutionChartsController.cs — strip-chart data:
    • GET /api/execution/strip-chart?aspect=Availability|SurfaceRoughness|Individual&xValueCategory=IndexByTime|IndexByStep&widthHint=…&dispBegin=…&dispEnd=…&inspectingKey=…&idRows=ToolId,FileNo → { xs, indexes, items:[{ key, label, unit, scale, min, max, minIndexes, maxIndexes, isCategorical, labelPrefix, valueLabels, idColors, colorTree }], idRows:[{ key, labelPrefix, min, max, runs }], isXTicksRangeMode, dispBegin, absDispEnd, count }. indexes holds a step a bucket: raw (isXTicksRangeMode false) the point's own; downsampled the next bucket's first step, the last bucket's the window's last step — except at a hole on the time axis (positions without a step between two built steps): its break point's entry is the hole's last position in a raw answer, and in a downsampled one the bucket before the hole has the hole's first position and the break's own bucket the step after the hole; minIndexes / maxIndexes (null raw) the step each bucket's min / max was read at, −1 for none. unit, the legend's suffix and the Y axis title, is display text — for the Individual aspect the unit as Step Properties prints it (SelectedStepInfoService.UnitLabel: mm/min, empty for none), not the PhysicsUnit name; % for a ratio and for the breakage probability, and for Availability's five ratios, whose legend then adds no suffix and whose axis no title. scale is the factor the chart multiplies a value by before it prints it in unit (SelectedStepInfoService.UnitScale): 100 for a ratio, 1 for any other item. min and max stay the engine's values, a ratio's as the ratio, and a range typed for the item's axis is divided by scale before it is sent. The Color Index chart's picked key rides the inspectingKey query parameter of that same call. The Individual aspect answers only the project's inspecting key (LocalProjectService.InspectingKey: every step keeps that key's value in its inspecting slot, which the series reads; an MC.<axis> key of a wrap-around rotary axis — the axes RotaryReadout.ModuloAxes names, Common/RotaryReadout.cs — is served folded into [0°, 360°) as the controller's position screen shows it, rounded to 0.001° first, the fold applied to each step's value before a bucket's min / max are taken, on the slot path and the registry-getter path alike, while the slot, the step and the step file keep the continuous angle, and every other key is served as it is): another key answers the empty payload with pending: true, and a key that is not a step property of the project answers it with unresolvedKey: true. While the interface hides the physics, a physics key answers the empty payload, and the full built-in MachiningState, the project's key, answers it with pending: true every time (while its no-physics tree is registered), so that the client follows step-properties' currentKey, MachiningStateGeometry, which this aspect serves as the stand-in (Step Colors REST). A key the play has no value under on any step (LocalProjectService.StepKeyAbsence.Keys: the spindle's keys in a play without a spindle capability to read against) answers the empty payload as well, without pending, whatever the physics: step-properties lists it no more, and its currentKey names the key served in its place (Step Colors REST). The Availability aspect leaves such keys' series out, so in a play without a spindle capability its items are the stress ratio and the thermal stress ratio alone. After POST /api/execution/inspecting-key { inspectingKey } (→ { success, currentKey, messages }) the host fills every step's slot for the new key, and a read that met a step not yet filled answers pending: true with NaN there, beside inspectingGeneration, the generation the values were read under; pending is true as well when that generation moved under the walk. The chart reads again on the next Updated broadcast until pending is false. A script reads a key the same way: post it, read until pending is false (items empty with pending true means the key is not the project's — another client posted its own — but for MachiningState while the physics is hidden, where the script reads currentKey of step-properties and asks for that key; POST inspecting-key‘s own currentKey is the key stored, for any hidden physics key; items empty with pending false is the key in absentKeys of step-properties, which the script follows to currentKey the same way), and when done, while the project's key is still the one posted, post back the key the project held before, which GET /api/execution/strip-chart-item-config without a key answers as inspectingKey, since the key is saved with the project. isCategorical is true on an item whose value is an ID (ToolId, FileNo, a cutter zone, a color tree's key). For a tree's key the inspecting slot holds the step's leaf id packed with the leaf's value, and the series is the lane of that leaf (CompiledStepColorTree.Leaf.Lane: the tree's first leaf the highest lane, its last leaf 0) — the registry is asked once a request whether the key is a tree's, and for its compiled tree — with NaN, a gap, for a step in no leaf; the registry, the 3D view, Step Properties and the step file read the leaf id. Such an item's labelPrefix is its CategoryLabelPrefix(API) — T for the tool ID, empty for the file number and a tree's key — and its idColors is { colors, noValueColor }: colors maps every integer in the answer's min / max — for a tree's key every lane of the tree instead, a lane no step of the window fell into included — keyed by its decimal string, to the #RRGGBB the 3D view paints it with, the selected guide's GetIdRgb(API): for the tool ID and the file number the ID's own discrete colour, for a tree's lane the hue the tree gives the lane's leaf (IdHues(API)). noValueColor is the colour the 3D view gives a step without an ID, which the chart itself leaves as a gap. idColors is filled only while the project's selected colour guide is that key's FuncDiscreteColorGuide(API) — for the no-physics built-in tree standing in for MachiningState, the full tree's (Step Colors REST) — so the chart never shows colours the 3D view is not painting; a pick, or a Colors guide change, fetches again once the server has made it. labelPrefix and idColors are null on every other item, and min / max keep their shape. colorTree is null on every item but a tree's, where it is { key, name, origin, standsInFor, editTreeId, leaves, holdingLanes, undecidedLanes, leafStepIndex, leafValues, leafTotals, noValueTotals, notes }, each per-bucket array aligned with xs, field by field on Step Colors REST. idRows, the query parameter, names the ID rows the chart draws over its plot, comma separated: ToolId, FileNo, both or none (omitted or empty; any other name is passed over, a name given twice counts once). The answer's idRows holds one entry for each, in the order asked, read in the same walk as the items and bucketed as they are, on every aspect and whatever the items are — a row is no item: it adds no series and no legend row: key; labelPrefix, the key's CategoryLabelPrefix (T for the tool ID, empty for the file number); min / max, one a bucket aligned with xs, the lowest and highest value of the key on the bucket's steps — the values the Individual chart of that key draws — NaN for a bucket without a step or a value; and runs, one a bucket, the number of the run the bucket's last step with a value belongs to, a run being a stretch of steps of one value counted over the window's steps in strip order from 0 (a step without a value changes nothing), −1 for a bucket without a value. A bucket whose min and max differ holds a change of tool (or of file) inside it; runs tells one stretch from the next where the buckets’ edges, which move at every poll of a growing strip, cannot. The two keys are read straight off the step (IdRowReaders: the motion step's ToolId; FileNoOf, the file index of the step's sentence plus one, read without building a sentence), not through the registry's boxed getter, since every strip chart asks for the tool row by default on every poll. idRows is empty when none was asked for, and in an empty answer.
    • GET /api/execution/step-properties → { success, currentKey, keys:[{ key, name, shortName, unit, unitLabel, scale, source, group, builtInTree, isMapping, isCategorical }], absentKeys, generation } — the property picker's list; absentKeys is { reason, file, fault, keys } while the play has no value under some keys on any step, null else: reason notSet (no capability set and no file referenced), fileUnreadable (file the referenced capability file's name, its .default marker left out), noContinuousCondition or cacheNotBuilt (fault what building the speed cache threw), keys the keys in ordinal order — every key [NeedsSpindleCapability] marks for the first two, the fifteen that need the speed cache for the other two — none of which keys lists (BuiltInTreeNotes.AbsentKeysView; Step Colors REST); group is engineering for a tree's key and science otherwise, builtInTree marks HiNC's own trees. unit is the PhysicsUnit name (mmdmin, None for none), unitLabel the picker's caption, the unit as Step Properties prints it (mm/min, empty for none; % for a ratio and a percent), scale 100 for a ratio and 1 for any other key, which the Color Index chart's ticks and range inputs read the inspected key's values through, before its data lands too; source is colorTree for a tree's key, else builtIn (the step's own fields and the MC. keys), projectVariable, training or session, as the color trees' key options say it. isCategorical — true for ToolId, FileNo, StressCriticalZone, StressOnsetZone and a tree's key — puts the header in its ID mode as soon as the key is picked; generation, the registry generation the list was read at, makes the picker read it again when the execution status names another. A currentKey standing in for a hidden physics key, or for a key of absentKeys, is never a tree's, but for MachiningStateGeometry standing in for the full built-in tree MachiningState, itself a physics key (Step Colors REST).
    • GET / POST /api/execution/strip-chart-item-config — a key's Y-range config, saved with the project, in the key's own values (a ratio's as the ratio); with no key, the project's inspecting key's.
    • GET / POST /api/execution/color-guide — the Colors dropdown's state, one payload for both: the selected key, the guides, the tone functions, the range rule { floor, ceiling, ratioRgbFunc, unitLabel, scale } (the floor and ceiling in the key's own values, a ratio's as the ratio, beside the selected key's unit and scale, % and 100 for a ratio, which the dropdown shows and takes them in), and tree — { key, name, origin, editTreeId, leaves, notes }, the leaves in colorTree.leaves' shape — while the selected key is a tree's, else null.
  • Execution/SelectedStepInfoService.cs — UnitLabel, the unit as display text that unit and unitLabel share, and UnitScale, the factor behind scale, valueScale and the range rule's scale (UnitConvertUtil.DisplayScale: 100 for PhysicsUnit.ratio).
  • Environments/PresentCatalogService.cs — ResolveValueLabels, the value names an item's valueLabels and a tree leaf's carry; wwwroot-src/src/utils/valueLabels.ts — their whitelist parse, for an item, a tree leaf and a Step Colors key option, and a value's name (valueLabelOf), which a value leaf's legend row prints.
  • Execution/StepColorTreeController.cs — SourceOf, the classification behind source.
  • Execution/ClStripController.cs — range manipulation at /api/execution/cl-strip/* (the server-side counterparts of the pointer handlers described under Strip Charts Behavior):
    • GET range — snapshot { success, dispBegin, dispEnd, absDispEnd, count, selectedIndex, enteredIndex, physicsRevision }.
    • POST disp-range body { dispBegin, dispEnd, pinEnd }, and POST zoom-range. A dispEnd of -1 follows the strip's end, and so does one at or past the count, unless pinEnd (default false) is set, which pins the end at the count, or the end is pinned there already and the count still equals it. disp-range, wheel, pan and zoom-range answer { success, dispBegin, dispEnd, absDispEnd, count }, so a dispEnd equal to count reads as an end pinned at the strip's end.
    • POST wheel body { scale, xPositionPercentage, xValueCategory }.
    • POST pan body { xOffsetPercentage, xValueCategory }. Legacy feelingRatio=2.
    • POST select-step body { stepIndex } → ClStrip.SetSelectedPos(...).
    • POST enter-step body { stepIndex } (nullable) → ClStrip.SetEnteredPos(...).
    • POST select-feature-segment body { stepIndex, boundary, gapLength_mm } — boundary "Touch" (the default) or "Feature", gapLength_mm optional, read under Touch alone, 5 when absent — sets the window to the segment the step lies in (FeatureSegmentSelector.TryGetFeatureSegment, found outside the WindowLock the window calls share — under Feature the search may read NC files —, then SetDispBegin and SetDispEnd(end, sender, true) under it), as a rubber-band zoom sets it by hand, a segment at the strip's end pinned there (the stick toggle off) until disp-range { 0, -1 }; it selects no step.
      • Touch: the run of touched steps (MachiningStep.IsTouched) the step is in or belongs to — an untouched step belongs to the cut it is joined to at feed, every step from it to the cut not rapid and no tool change or work-coordinate change between two consecutive ones: the cut before it first (the step is that cut's exit, its line running on past the stock), else the cut after it (its approach); in a rapid travel between two cuts it belongs to the next cut, and to the previous one only when no cut follows — with every untouched gap between two such runs taken in whose travel is under gapLength_mm and that holds no rapid step and no tool change or work-coordinate change, its travel being the length of the path through its steps from the cut before it: the distances between consecutive steps' tip points on the workpiece, where each step's motion ends (MachineMotionStep.GeomCl), summed over the moves into the gap's steps, the path the strip draws where its positions stand on their steps — the move into the next cut not counted, a move to or from a step without a motion pair adding none, and a return the sweep valve builds no step for (back along the same line onto the pose before the last) leaving no position, so that the move into the step after it is read from the step before the return and a rapid return of one step is not read for a rapid move —, not the steps' MovingLength_mm, whose motion pair spans two steps on a straight run (the endpoint keeps the tool change among the gap marks, so a tool change's jump of the tip enters no travel here; FeatureSegmentOptions.GapLength_mm counts the jump out of the cut before the gap or between two of its steps for a caller whose GapMarks leaves the tool change out); then the whole untouched run on either side, so the segment runs from the first step after the previous cut to the last step before the next one, the retract, the travel, a tool change and the approach included.
      • Feature: from the nearest tool change, rotary indexing or sequence number at the step or before it, to the step before the next one. A sequence number is a block whose text begins with an N word while the previous step's block begins with none: the step's own block, or one between the two steps' blocks that builds no step, such as an N on a line of its own, read off the NC file (a relative path under the project's folder, IMachiningService.BaseDirectory, as the play reads it) only where each block is a line of its own in one pass over one file (one fileIndex), the later two or more lines past the earlier, and the file still holds both at the lines they were played from — not after an edit that moved either of those two lines (one that added or removed a line before the later) or changed either, until a replay (one that rewrote lines between them in place, adding and removing none, is read as the file now stands), and for inline NC code, whose title is read as its path (under the project's folder when relative), from the file the title names, not the text played; the four files asked for last are kept, a file answered from what was kept counting as asked — the latest first, a new version in place of the old one, a fifth file in place of the oldest —, each read again only once its length or last write time has changed; a file no longer at its path — renamed, moved away, a recorded play reviewed where its NC files are not — holds no line. The files are read with the strip's lock released (the read side of StripPosesClearLock: a clear waiting for it holds back every reader after it, a canvas frame's display among them): a walk under the lock reads no file, stops where the lines between two blocks lie in a file this call has not read, as at a mark, and notes the file; the lock is released, the noted files are read, and the walk is made again over the strip as it then stands, until a walk lacks no file — the eighth reads what it still lacks under the lock. No walk's search goes further on a side than the segment's bound there or the first file it lacks; under RotaryIndexing an untouched run the search comes to is read whole for its two ends (each step's touch alone), and a run that turns, other than the one that begins the strip, for its indexing mark too. Where a tool change or a work-coordinate change already parts two steps, no file is asked for the lines between them. A run's indexing mark gives way first to a mark asked for that needs no file anywhere in the run or at its ends — a tool change, a work-coordinate change, a block that begins with its own N —, and only where none stands are the lines between the run's blocks read for an N: a pair whose file the walk lacks leaves the indexing mark in place on that walk, the file noted and the walk made again with it. A pass begins where the play jumps — a GOTO's target, a loop's next round, the block after a WHILE or FOR loop, the block an IF jumps to over a branch it does not run, the block a return names (M99 P) —, at each call of a subprogram and each repetition a section repeat makes (REPEAT, CALL LBL … REP), and where the file is played again; the end of a REPEAT … UNTIL loop, an IF's branch running on into what follows and a section or a subprogram the program runs into with no call begin none — so a jump's label on a line of its own (N22 of GOTO 22) that the play runs into from the block before it marks there as an operation's number does, while a jump to it begins a pass and the label marks nothing —, and a return that names no block (a plain M99, M17, RET, LBL 0, END PGM) and the end of a section repeat go on at the block after the call or the repeat, in the pass of its line: a line between is read across a call whose subprogram built no step, and not after a repeated section that built one. The mark is the first step at or after it. A program that numbers every block (the shipped samples) has no such mark.
      • A rotary indexing is a rotary machine coordinate turning by more than 5° (FeatureSegmentOptions.RotaryIndexingTolerance_deg) over an untouched run, between the touched steps on its two sides (the run's last built step where no cut follows it), not step by step; a run that begins the strip has none, the strip's first step bounding it already and the turn into the first cut's orientation belonging to that cut's feature, with its tool change and its approach; a simultaneous five-axis cut is no mark. Feature marks it where the turning begins — the run's first step whose axes have left the cut's, else the next cut's first step — so the exit and the travel before the turn stay with the feature before, and a run that also carries another mark asked for — a tool change, a sequence number, a work-coordinate change — has that mark alone; Touch reads it between a gap's two cuts and between an untouched step and the cut it would join. A work-coordinate change is the blocks' CoordinateOffset.CoordinateId differing, read off the block's parse result: a recorded play's review holds its blocks as SentenceSnapshots, which keep no parse result, so none is read there, and under Touch a short feed gap across a G54 to G55 change is taken in where the play kept it out. A position without its step yet — a play in progress — ends the search on that side.
      • → { success, dispBegin, dispEnd, absDispEnd, count, segmentBegin, segmentEnd, anchorStepIndex, boundary, beginLine, endLine }: segmentEnd is one past the segment's last step, the strip's count when the segment reaches its end; anchorStepIndex the touched step the segment was found from under Touch, the step asked for under Feature; boundary its name; beginLine and endLine the first and last step's block as GET api/NcProgram/sentence-of-step gives it, { stepIndex, sentenceIndex, fileIndex, lineIndex, lineNo, filePath, blockText }, null for a step without a block.
      • A refusal is { success: false, reason, message } with reason NoStrip (no strip), NoBoundary (a boundary number that is none), with count NoStep (an index off the strip), StepNotBuiltYet (its step not built yet: a play in progress, a stopped play's tail) and NoSegment (under Touch, no touched step reached without crossing a step not built yet: none on the strip — a play without stock, say — or the steps around still being built), or Error; the window stays. A body that does not bind (none, another boundary name) is the [ApiController] 400.
  • Execution/ClStripHub.cs + Execution/ClStripBroadcastService.cs — SignalR at /clStripHub. Broadcasts to every client DispRangeChanged(snapshot), StepSelected({ stepIndex }) (not raised when the selected step is selected again), StepEntered({ stepIndex }), Updated(snapshot) and StepPhysicsRecomputed({ begin, end }), the range a step-physics recompute replaced. One LooseRunner per channel coalesces re-broadcasts — a burst collapses into the latest, and a slow Updated cannot starve a StepSelected; each chart's single-flight load loop and its 500 ms floor handle the rest of the rate-limiting. The same service relays a sixth channel over the other hub: a click on the tool path (ClStrip.PosClicked, raised on the render thread) is sent as StepClicked on /renderingHub to the clicking canvas's connection only, through a runner of its own that keeps the latest click per engine.

HiAPI Engine

  • HiMech/CutterLocations/ClStrips/ClStrip.cs — the window (a dispEnd of -1 follows the strip's end, one equal to the count is pinned at it: SetDispEnd(int, object, bool), select-feature-segment's too) and the chart range the time-axis operations scale or move (UpdateChartRangeByDispSegment, UpdateDispSegmentByChartRange).
  • HiMech/Numerical/StepSelectionUtils/FeatureSegmentSelector.cs — the segment a step lies in, by its touches or by the feature marks (FeatureSegmentBoundary, FeatureMark, FeatureSegmentOptions), which select-feature-segment sets as the window.
  • HiMech/Coloring/FuncDiscreteColorGuide.cs — the one-colour-per-ID guide, with a hue table for a color tree's leaves (IdHues); its GetIdRgb gives the colours idColors carries.
  • HiMech/MachiningSteps/PresentAttribute.cs — IsCategorical and CategoryLabelPrefix, the fields isCategorical and labelPrefix are read from, and Unit, the key's unit unit and scale follow.
  • HiMech/Geom/UnitUtils/PhysicsUnit.cs — ratio (a share, one at 100 %) and percent (a value already in percent), the two units printed %; HiMech/Geom/UnitUtils/UnitConvertUtil.cs — DisplayScale, 100 for a ratio and 1 for any other unit, and IsPercent.
  • HiMech/MachiningSteps/MachiningStep.cs — the marks themselves: ToolId is an ID with the prefix T, FileNo an ID with none, and so are StressCriticalZone and StressOnsetZone, whose values are CutterBeamZone members (HiMech/Milling/Cutters/CutterBeamZone.cs), read as their numbers (HiMech/MachiningSteps/StepPresentCatalog.cs).
  • HiMech/NcParsers/Dependencys/RotaryReadoutUtil.cs — the fold of a wrap-around rotary axis' machine coordinate into [0°, 360°) at a display resolution, and the IsModularRotary predicate of IMachineAxisConfig that picks the axes.
  • HiNc/MachiningProcs/LocalProjectService.cs — SelectAndBuildColorGuide: picking an ID key gives the 3D view the one-colour-per-ID guide, the selection idColors waits for; a color tree's key gets one built with the tree's hue table, and a tree's guide left under a key that is no tree's any more gives way to the guide the entry's kind calls for.
  • HiNc/MachiningProcs/LocalProjectService.ProjectStepColorTrees.cs — the color trees, the project's and a script's, registered as categorical step properties with no label prefix, and TryGetStepColorTree, the compiled tree an answer reads, a built-in tree's too (HiNc/MachiningProcs/LocalProjectService.BuiltInStepColorTrees.cs registers those); HiNc/MachiningProcs/StepColorTreeSlot.cs — the leaf id and the leaf's value packed into one slot value, which the series unpacks.
  • HiNc/MachiningProcs/CompiledStepColorTree.cs — a compiled tree's leaves in tree order, each with its lane (Leaf.Lane, the first leaf the highest), its hue and Leaf.SameStepsAsId, which the lanes and leaves follow, and FindHoldingAfter, the leaves that hold beside a step's own, which holdingLanes follows; HiNc/MachiningProcs/StepColorTreeHoldingReader.cs reads them, and their values, for one answer without a step-cache read a step.

See Also