@beehexa/hexasync-template-model 2608.21.4 → 2610.3.1

package/dist/collapseRule.js

@@ -0,0 +1,87 @@
+/**
+ * The loop-collapse retention rule, vendored from core.api — Story 8.9, AD-32(b).
+ *
+ * ### Why this file is a COPY and not an implementation
+ *
+ * `ExecutionEvidenceAccumulator` in core.api decides which occurrences of a step survive a run and which fold into a
+ * range. The canvas has to draw the same reading, or the inspector and the diagram describe two different runs. AD-32(b)
+ * says neither owner may decide that rule alone, and AD-28 bars a CI job spanning the two repositories — so the rule is
+ * published there as `hexasync.steps/Manifests/collapse-rule-manifest.json`, byte-copied here to
+ * `manifests/collapse-rule.json`, and pinned on both sides:
+ *
+ * | change | what fails |
+ * | --- | --- |
+ * | the accumulator's retention behaviour | `CollapseRuleManifestAtddTests` in core.api — it runs the accumulator and reads the numbers back out |
+ * | the constants below | `story89LoopCollapse.atdd.spec.ts` — it reads the vendored manifest off disk and compares |
+ * | the vendored manifest goes stale | the same spec, from the other direction |
+ *
+ * This is Story 7.2's `worker-step-roster.json` pattern, deliberately unchanged.
+ *
+ * ### Why the constants are NAMED here and not read at runtime
+ *
+ * `template-model` runs in a webview and in a browser bundle, so it cannot read a file, and a JSON import would put a
+ * bundler-specific assertion in a published library's entry point. The numbers are therefore declared as constants and
+ * the vendored JSON is the thing a TEST compares them against — which is also the only place a comparison is useful,
+ * because a mismatch is a build-time defect, never a runtime condition a caller can handle.
+ *
+ * ⚠️ The accumulator has **no named threshold constants at all** — `StepState` encodes retention structurally with a
+ * first-success flag plus a two-slot slide, so "the fourth success" is emergent behaviour rather than a number anyone
+ * typed there. That is exactly why these constants must be pinned to the manifest instead of "kept in sync by reading
+ * the C#": there is nothing in the C# to read.
+ */
+/** The evidence envelope schema these thresholds describe. */
+export const COLLAPSE_RULE_SCHEMA_VERSION = 2;
+/** The first success of a step key always stays full. */
+export const RETAINED_FIRST_SUCCESSES = 1;
+/** The trailing successes that stay full — the accumulator's two-slot slide. */
+export const RETAINED_LATEST_SUCCESSES = 2;
+/**
+ * The step-local success ordinal on which compaction FIRST fires.
+ *
+ * Not an independent number: the first success plus the latest two are already full, so the next success is the first
+ * one that can push an older body into a range. Stated as a constant because a renderer sizing a fixture needs it, and
+ * derived from the two above so it cannot drift from them.
+ */
+export const FIRST_COMPACTED_SUCCESS_ORDINAL = RETAINED_FIRST_SUCCESSES + RETAINED_LATEST_SUCCESSES + 1;
+/** Every failure stays full. A failure never folds into a range, whatever its neighbours did. */
+export const FAILURES_RETAINED = true;
+/**
+ * How the six fields below are compared — ordinal (case-sensitive), with two nulls counting as equal.
+ *
+ * Mirrored from the manifest rather than left as prose, because a comparison rule the manifest publishes and neither
+ * side pins is a rule the accumulator can stop following with every test on both sides still green.
+ */
+export const RANGE_IDENTITY_COMPARISON = 'ordinal';
+export const RANGE_IDENTITY_NULLS_EQUAL = true;
+/**
+ * What "adjacent" means when a range is extended rather than opened: the occurrence's global index is exactly one past
+ * the range's last, and its step-local occurrence is exactly one past the range's last.
+ */
+export const ADJACENCY_GLOBAL_INDEX_GAP = 1;
+export const ADJACENCY_STEP_LOCAL_OCCURRENCE_GAP = 1;
+/** A range id is minted once and does NOT change as the range extends — which is why an entry carries it. */
+export const RANGE_ID_STABLE_ON_EXTENSION = true;
+/**
+ * The six fields a range compares to decide whether an occurrence extends it, in the tuple's declared order.
+ *
+ * Case-sensitive (ordinal) with nulls equal, which is what `HasSameRoute` does. The renderer never compares these
+ * itself — the producer does, in core.api — but the list is what a fixture and a review have to agree on, and a plan
+ * whose ranges were folded on five fields is a different reading of the run.
+ */
+export const RANGE_IDENTITY_FIELDS = [
+    'stepKey',
+    'providerId',
+    'connectionId',
+    'flow',
+    'nextTarget',
+    'outcomeClass',
+];
+/** The two `orderedTimeline` kinds, in the manifest's order. There is no third. */
+export const TIMELINE_KINDS = ['occurrence', 'range'];
+/** How the accumulator mints a range id, and never re-mints it once the range extends. */
+export const RANGE_ID_FORMAT = 'range-{firstGlobalIndex}';
+/** Does this entry describe a folded run rather than one retained occurrence? Narrows, so `rangeId` is reachable. */
+export function isCollapsedRange(entry) {
+    return entry.kind === 'range';
+}
+//# sourceMappingURL=collapseRule.js.map

package/dist/collapseRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapseRule.js","sourceRoot":"","sources":["../src/collapseRule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC;AAE9C,yDAAyD;AACzD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C,gFAAgF;AAChF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAC1C,wBAAwB,GAAG,yBAAyB,GAAG,CAAC,CAAC;AAE3D,iGAAiG;AACjG,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,SAAS,CAAC;AACnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,CAAC;AAE/C;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAC5C,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAErD,6GAA6G;AAC7G,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,SAAS;IACT,YAAY;IACZ,cAAc;IACd,MAAM;IACN,YAAY;IACZ,cAAc;CACN,CAAC;AAEX,mFAAmF;AACnF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,OAAO,CAAU,CAAC;AAE/D,0FAA0F;AAC1F,MAAM,CAAC,MAAM,eAAe,GAAG,0BAA0B,CAAC;AAsD1D,qHAAqH;AACrH,MAAM,UAAU,gBAAgB,CAAC,KAAsB;IACrD,OAAO,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC;AAChC,CAAC"}

package/dist/flowRender.d.ts

@@ -1,10 +1,26 @@
+import type { OccurrencePlan } from './collapseRule.js';
+import { type NodeLabelAnatomy } from './stepGlyph.js';
 /** A node as a renderer needs to see it — neither flow package's shape, deliberately. */
 export interface RenderNode {
     /** The AD-33 canonical address. Projected to a mermaid id here, never by the caller. */
     readonly address: string;
     /** What the box says. */
     readonly label: string;
-    /** Draw it as a decision diamond. */
+    /** Composer-owned structure. Its presence, not `label` byte shape, enables Mermaid markdown. */
+    readonly labelAnatomy?: NodeLabelAnatomy;
+    /**
+     * Label for the loose host fidelity. When absent, both fidelities intentionally use `label`.
+     *
+     * The emitter selects between the two; hosts never rewrite a generated definition.
+     */
+    readonly looseLabel?: string;
+    /** Loose-fidelity composer structure. Falls back with `looseLabel` when absent. */
+    readonly looseLabelAnatomy?: NodeLabelAnatomy;
+    /** Authoritative worker runtime type. Shape classification never parses the label or icon family. */
+    readonly type?: string;
+    /** Child-family DOM hook used by loose hosts. Unknown or absent families use the neutral class. */
+    readonly iconFamily?: string;
+    /** Draw it as a branch/condition. */
     readonly decides?: boolean;
     /** Draw it as a stadium — a terminal, an unresolved target. */
     readonly terminal?: boolean;
@@ -21,28 +37,268 @@ export interface RenderGroup {
     readonly nodes: readonly RenderNode[];
 }
 export type FlowDirection = 'TD' | 'LR';
+export type RenderFidelity = 'strict' | 'loose';
+export type NodeTreatment = 'flow-start' | 'flow-end' | 'process' | 'branch' | 'subroutine' | 'delay' | 'exception' | 'unimplemented';
+/** The complete, ordered shape vocabulary. No renderer path may invent another treatment. */
+export declare const APPROVED_NODE_TREATMENTS: readonly ["flow-start", "flow-end", "process", "branch", "subroutine", "delay", "exception", "unimplemented"];
+/**
+ * The hard boundary between deterministic definition generation and host DOM decoration.
+ *
+ * Exported as data so adapters and contract tests can share one inventory instead of describing the boundary in
+ * prose that drifts. Stage 3 may make generated nodes operable; every visible or structural byte belongs here.
+ */
+export declare const FLOW_RENDER_STAGE_OWNERSHIP: {
+    readonly generate: readonly ['shape', 'nodeId', 'labelText', 'accTitle', 'accDescr', 'iconClass', 'nodeStyle', 'edge', 'linkStyle', 'edgeColor', 'edgeDash', 'direction', 'repeatBadge', 'errorMarker'];
+    readonly decorate: readonly ['interaction'];
+};
+/**
+ * The nine runtime executors whose authoritative Epic 7 evidence records `NotImplementedException`.
+ *
+ * This is an explicit roster subset, never a name or family regex. `WorkerStepType` keeps every member tied to the
+ * vendored 51-row manifest vocabulary. Begin and End remain in the subset but terminal treatment takes precedence.
+ */
+export declare const UNIMPLEMENTED_WORKER_STEP_TYPES: readonly ["Begin", "Composite", "cURL", "End", "GraphQL", "Liquid", "OData", "QueryDSL", "Restful"];
+/** Classify treatment from model facts only; labels and icon families are deliberately irrelevant. */
+export declare function classifyNodeTreatment(node: Pick<RenderNode, 'type' | 'decides' | 'terminal'>): NodeTreatment;
+/**
+ * A run's reading of the drawing — ONE vocabulary, keyed by node address (AD-22, Story 10.4).
+ *
+ * Story 10.4 retired the two-state lists (`traversed`, `errored`, `colors`, and Story 8.7's `notTaken`) that stood
+ * beside this map: two overlay vocabularies reaching one emitter meant edges were styled from one and nodes from the
+ * other. Every reading those lists drew is now a `nodes` entry — see `RenderNodeOverlay` for the mapping.
+ */
 export interface RenderOverlay {
-    /** Addresses a run walked through. */
-    readonly traversed?: readonly string[];
-    /** Addresses a run failed at. */
-    readonly errored?: readonly string[];
     /**
-     * Supplied by the caller, not chosen here.
+     * The TYPED per-node overlay (AD-22), keyed by node address — never by step key.
+     *
+     * Each entry resolves ONE way, through `resolveNodeState`:
+     *  - WITH a `state`: the state's treatment, exactly as Story 8.8 draws it. Colour overrides are honoured; width,
+     *    marker and dash follow the state; `roles.opacity` only retunes a state that is already dimmed.
+     *  - WITHOUT a `state` but with a valid `roles.stroke`: a ROLES-ONLY entry, which draws exactly its roles (see
+     *    `RenderNodeOverlayRoles`). This is how a producer that knows which roles to draw, but can prove no state, says so.
+     *  - Any other stateless entry draws no node style. Its `repeat` badge is still drawn.
+     *
+     * **Authority comes from a `state`.** When at least one CALLER entry that names a drawn address carries a `state`
+     * (any value — an unknown one reads as `indeterminate`), the typed reading is chart-wide: every drawn node draws a
+     * style, defaulting to `indeterminate`, kind styles are suppressed, and `accDescr` states every node's reading. A
+     * chart where some nodes carry a run reading and others carry none would leave a reader unable to tell "not reached"
+     * from "not described". Roles-only entries and badge-only entries make no state claim, so they never take the chart:
+     * a node without an entry keeps its kind style, and a roles-only node never ALSO gets its kind style.
+     *
+     * **Edges are derived from these entries** — there is no edge field. Per drawn, deduped edge:
+     *  1. its target is DECLINED (`branchNotTaken`, or a stateless entry with `roles.dash`) — dashed in `notTakenStroke`;
+     *  2. both ends are REACHED (`ranOk`/`ranFailed`, or a drawn roles-only entry) — the stroke of the end drawn at
+     *     `emphasis`, target first, else the target's stroke;
+     *  3. otherwise the neutral `edge` role.
      *
-     * dashboard's live values come from its theme; the extension's webview themes its own. A renderer that hardcoded a
-     * colour would be wrong in one of light or dark — which is exactly why the extension delegates to a stylesheet.
+     * An address no group drew is ignored in silence.
+     *
+     * ⚠ **`RenderOptions.nodeColors` does NOT reach the state pass.** `nodeColors` names the base and kind roles; the
+     * five state readings are a separate closed set, and `STATE_ROLES` carries DESIGN.md's light palette only. A host on
+     * a dark theme overrides state colours through `roles`, resolved to literal hex at its own boundary.
      */
-    readonly colors?: {
-        readonly traversed?: string;
-        readonly errored?: string;
-    };
+    readonly nodes?: Readonly<Record<string, RenderNodeOverlay>>;
+}
+export interface RenderNodeColors {
+    /** Opaque node fill. Hexagons accept only the six-digit form. */
+    readonly fill: string;
+    /** Solid border for an unimplemented kind when no run state owns the stroke. */
+    readonly nodeBorder: string;
+    /** Solid border for an exception kind when no run state owns the stroke. */
+    readonly failStroke: string;
+    /** Every edge the run neither walked nor declined. */
+    readonly edge: string;
+    /** The edge entering a branch the run declined — the canvas's only dashed line. */
+    readonly notTakenStroke: string;
+    /** Edge-label glyphs. */
+    readonly edgeLabelText: string;
+    /** The opaque plate an edge label sits on, so the line does not strike through the text. */
+    readonly edgeLabelBg: string;
+}
+/** Deterministic approved light palette; valid host-resolved values may override these roles. */
+export declare const APPROVED_NODE_COLORS: {
+    readonly fill: '#ffffff';
+    readonly nodeBorder: '#64748b';
+    readonly failStroke: '#b91c1c';
+    readonly edge: '#64748b';
+    readonly notTakenStroke: '#475569';
+    readonly edgeLabelText: '#334155';
+    readonly edgeLabelBg: '#ffffff';
+};
+/**
+ * The declared line-work roles (DESIGN.md `strokes:`). Blueprint carries state in the LINE, so weight and pattern
+ * are roles, not values a render path picks.
+ *
+ * They live here as data because FR59 forbids a width or dash-array literal inside an emitter function: a width literal
+ * typed into one of three emit sites is exactly how the shipped emitter ended up with three copies of one decision.
+ */
+export declare const STROKE_ROLES: {
+    /** Every node outline and every edge. */
+    readonly hairline: '1px';
+    /** The failed node's outline, and nothing else on the canvas. */
+    readonly emphasis: '2px';
+    /** Dash array for the branch-not-taken stroke. RUN STATE ONLY. */
+    readonly dash: '6 3';
+};
+export type StrokeRole = keyof typeof STROKE_ROLES;
+/**
+ * The run-state vocabulary: FOUR states plus ONE drawn reading, never five states.
+ *
+ * `indeterminate` is deliberately a member of the same union — it is what the emitter draws for a node whose state
+ * cannot be determined — but the spine's State convention (`ARCHITECTURE-SPINE.md` line 237) counts it separately,
+ * and `story88RunStates.atdd.spec.ts` asserts that shape so nobody grows a fifth state by adding a row here.
+ */
+export type RunState = 'ranOk' | 'ranFailed' | 'neverReached' | 'branchNotTaken' | 'indeterminate';
+/** The four states DESIGN.md's state table draws as rows; `indeterminate` is the fifth reading, not a fifth state. */
+export declare const RUN_STATES: readonly ["ranOk", "ranFailed", "neverReached", "branchNotTaken"];
+/** The drawn reading for a node the producer could not place. Counted apart from `RUN_STATES` on purpose. */
+export declare const INDETERMINATE_RUN_STATE: "indeterminate";
+/**
+ * The role map one node's entry draws with (AD-22's `roles` map). It means two things, chosen by the entry's `state`.
+ *
+ * Colours are always literal six-digit hex — the same grammar `overlayColor` enforces for every other overlay colour,
+ * since a stroke value also reaches a polygon fill. Widths are declared ROLE NAMES (`hairline`/`emphasis`), never
+ * measurements, so a caller cannot invent a third weight.
+ *
+ * **Beside a `state`**, these are OVERRIDES of that state's treatment. Colours are honoured; `width`, `dash` and
+ * `marker` follow the state and are ignored (the failure signals a reader without colour vision has cannot be moved
+ * by a caller); `opacity` only retunes a state that is already dimmed. Anything invalid falls back to the state's
+ * declared role rather than dropping the statement: a half-drawn state reads as a DIFFERENT state.
+ *
+ * **Without a `state`**, a valid `stroke` makes the entry ROLES-ONLY, and it draws exactly these roles and nothing
+ * else: `stroke` as given; `width`, else `hairline`; `fill`, else the resolved `RenderNodeColors.fill`; `title` as the
+ * label colour only if valid; `opacity` only if valid; a dash only if `dash`; the error marker only if `marker`. It
+ * claims no state, so it never takes the chart's authority and `accDescr` states no reading for it. An invalid or
+ * absent `stroke` draws no node style at all — the node keeps its kind style and its edges stay neutral. A stateless
+ * `dash: true` still marks the node DECLINED for its inbound edges, with or without a stroke.
+ *
+ * Migrating from the retired lists: `traversed` + `colors.traversed` → `{ roles: { stroke, width: 'hairline' } }`;
+ * `errored` + `colors.errored` → `{ roles: { stroke, width: 'emphasis' } }`; `notTaken` → `{ roles: { dash: true } }`
+ * (or `{ state: 'branchNotTaken' }` for a producer that can prove it).
+ */
+export interface RenderNodeOverlayRoles {
+    readonly stroke?: string;
+    readonly fill?: string;
+    /** Label colour. Mermaid paints ONE colour over the whole label — see `resolveNodeState`. */
+    readonly title?: string;
+    /** Accepted, recorded, and NOT emitted separately. Kept so the caller's role map is complete. */
+    readonly description?: string;
+    /** Honoured on a roles-only entry; beside a `state` it follows the state. */
+    readonly width?: Extract<StrokeRole, 'hairline' | 'emphasis'>;
+    /** Honoured on a stateless entry; beside a `state` it follows the state. */
+    readonly dash?: boolean;
+    /**
+     * `'0'`–`'1'` as a decimal string, `'0'` excluded. Beside a `state` it only retunes a state that is ALREADY dimmed
+     * (`neverReached`): it cannot dim a state DESIGN.md says is never dimmed, and it cannot undim one.
+     */
+    readonly opacity?: string;
+    /** Honoured on a roles-only entry; beside a `state` it follows the state. */
+    readonly marker?: boolean;
 }
+/** One node's run reading: what the run did to it, how many times, and the roles it draws with. */
+export interface RenderNodeOverlay {
+    readonly state?: RunState;
+    /**
+     * Occurrence count. Absent, `1`, `0`, negative or non-integer draws NO badge — a malformed badge would be a
+     * factual claim about the run, and `×0` or `×1.5` is not one the generator can make.
+     */
+    readonly repeat?: number;
+    readonly roles?: RenderNodeOverlayRoles;
+}
+/**
+ * The five drawn readings, resolved from DESIGN.md's closed light palette (`colors:` 9-88, `node-*` components
+ * 171-195, the state table 389-400).
+ *
+ * Data, not code, for the same reason as `STROKE_ROLES`: FR59 forbids a colour, width, dash or opacity literal
+ * inside an emitter function. `opacity: '0.7'` is the ONLY numeric opacity in DESIGN.md (`node-unreached` line 187)
+ * and it exists once, here.
+ *
+ * Read the columns against the matrix they came from:
+ *  - **failed** is the only `emphasis`, the only `marker`, and the only non-white fill. All three unconditional.
+ *  - **never reached** is SOLID with a fully visible border and recedes by muted text + `opacity` on the card.
+ *  - **branch not taken** is DASHED at full neutral contrast and is NEVER dimmed.
+ *  - **indeterminate** is the neutral pair and carries nothing else, so it stays clickable and unremarkable.
+ */
+export declare const STATE_ROLES: {
+    readonly ranOk: {
+        readonly stroke: '#c2410c';
+        readonly fill: "#ffffff";
+        readonly title: '#0f172a';
+        readonly description: '#475569';
+        readonly width: 'hairline';
+        readonly dash: false;
+        readonly opacity: undefined;
+        readonly marker: false;
+    };
+    readonly ranFailed: {
+        readonly stroke: "#b91c1c";
+        readonly fill: '#fee2e2';
+        readonly title: '#991b1b';
+        readonly description: '#7f1d1d';
+        readonly width: 'emphasis';
+        readonly dash: false;
+        readonly opacity: undefined;
+        readonly marker: true;
+    };
+    readonly neverReached: {
+        readonly stroke: '#7c8899';
+        readonly fill: '#f8fafc';
+        readonly title: '#64748b';
+        readonly description: '#64748b';
+        readonly width: 'hairline';
+        readonly dash: false;
+        readonly opacity: '0.7';
+        readonly marker: false;
+    };
+    readonly branchNotTaken: {
+        readonly stroke: "#475569";
+        readonly fill: "#ffffff";
+        readonly title: '#334155';
+        readonly description: '#475569';
+        readonly width: 'hairline';
+        readonly dash: true;
+        readonly opacity: undefined;
+        readonly marker: false;
+    };
+    readonly indeterminate: {
+        readonly stroke: "#64748b";
+        readonly fill: "#ffffff";
+        readonly title: '#0f172a';
+        readonly description: '#475569';
+        readonly width: 'hairline';
+        readonly dash: false;
+        readonly opacity: undefined;
+        readonly marker: false;
+    };
+};
+/**
+ * The count badge's declared roles (DESIGN.md `count-badge` 218-222, `rounded.full`).
+ *
+ * Exported as DATA and not emitted as a `style` property, because Mermaid 12 has no way to paint a plate behind one
+ * span of a node label: the badge reaches the definition as label TEXT (`×997`) in the node's single label colour.
+ * A host that draws its own legend or inspector chip reads the plate roles from here, so the two surfaces cannot
+ * disagree about what a badge looks like. Emitting it as label text is what AD-23 requires anyway — run-state
+ * content is stage 1's, and `securityLevel: 'strict'` routes a label through DOMPurify.
+ */
+export declare const REPEAT_BADGE_ROLES: {
+    readonly background: '#ffffff';
+    readonly foreground: '#9a3412';
+    readonly border: '#c2410c';
+    readonly borderWidth: "1px";
+    readonly radius: '9999px';
+};
 export interface RenderOptions {
+    /**
+     * Label fidelity is a generator input. Mermaid `securityLevel` remains a host concern and must not fork emission.
+     */
+    readonly fidelity?: RenderFidelity;
     readonly direction?: FlowDirection;
     /** One chart with a subgraph per group, versus one flat chart. */
     readonly multiStage?: boolean;
     /** Run highlighting. An ARGUMENT, never state on the model (AD-29). */
     readonly overlay?: RenderOverlay;
+    /** Valid role-resolved overrides for the deterministic approved node colors. */
+    readonly nodeColors?: Partial<RenderNodeColors>;
     /**
      * Emitted as `classDef`/`class` rather than a per-element style, for a consumer whose stylesheet owns the colour.
      * Carries no colour of its own — see rule 3.
@@ -61,24 +317,114 @@ export interface RenderOptions {
      * pusher steps" is the true sentence.
      */
     readonly emptyLabel?: string;
+    /**
+     * What a RUN did to each drawn step, keyed by node address — Story 8.9's occurrence dimension.
+     *
+     * A TYPED PARAMETER, never an evidence envelope (FR26): the generator does not parse the envelope and cannot be made
+     * to. With no plan the expansion is the identity function and these bytes are what they were before Story 8.9
+     * existed, which is what FR40 requires of the CLI compose report, the VS Code preview and the report renderer — none
+     * of which has a run.
+     *
+     * The two flow adapters expand ahead of this call, because the expansion has to see their stage edges too; it is
+     * honoured here as well so a caller rendering groups directly cannot pass a plan and silently get nothing.
+     */
+    readonly occurrences?: OccurrencePlan;
+    /**
+     * The overlay entries an occurrence expansion DERIVED — today, a `repeat` on each collapsed range so it draws `×N`.
+     *
+     * ⛔ Deliberately NOT part of `overlay.nodes`, and the separation is load-bearing. `overlay.nodes` naming any drawn
+     * address makes the TYPED overlay authoritative for every node in the chart (see `RenderOverlay.nodes`), which
+     * suppresses kind styling chart-wide and makes `accDescr` state a run reading for every node. Routing a derived
+     * badge through it meant that collapsing ONE loop stripped the exception node's red border from an unrelated part of
+     * the drawing and told a screen-reader user the run state of every node was unknown. A plan alone must never do that.
+     *
+     * Produced by `expandOccurrences`; the two flow adapters pass it through because they expand before calling here.
+     * A caller's own `overlay.nodes` entry for the same address wins field by field.
+     */
+    readonly occurrenceOverlay?: Readonly<Record<string, RenderNodeOverlay>>;
+    /**
+     * The host's `maxTextSize`, in characters. Over it, the definition is REFUSED rather than returned.
+     *
+     * ⛔ Measured 2026-09-28 (`story89NodeCeiling.atdd.spec.ts`), and the reason this option exists at all: Mermaid's
+     * `maxTextSize` default is 50 000 characters, and over it `mermaid.render()` **resolves successfully with an SVG
+     * containing ONE node**. `mermaid.parse()` resolves too. So a host that validates with `parse` sees nothing wrong and
+     * draws a diagram that is not the workflow — the failure is silent, and the generator is the only place it can be
+     * caught, because by the time a host has the string the information that it was truncated is gone.
+     *
+     * Absent by default: a budget the caller did not state is not a budget the generator may invent, and every existing
+     * surface keeps its bytes. `MERMAID_DEFAULT_MAX_TEXT_SIZE` is the value a host using Mermaid's own default passes.
+     */
+    readonly maxTextSize?: number;
+}
+/**
+ * Mermaid's own `maxTextSize` default, measured against 12.0.0 rather than read from a changelog.
+ *
+ * Exported as data because the number is the whole finding: 305 nodes (49 620 chars) of the measurement fixture draw
+ * fully and 310 (50 445 chars) draw one node. The ceiling is therefore a CHARACTER budget and scales with label
+ * length — a workflow with long step names hits it sooner, and Story 8.7's `accDescr`, which lists every node, spends
+ * part of the same budget.
+ */
+export declare const MERMAID_DEFAULT_MAX_TEXT_SIZE = 50000;
+/** A definition's character cost against a budget. */
+export interface DefinitionBudget {
+    readonly characters: number;
+    readonly budget: number;
+    readonly overBudget: boolean;
 }
 /**
- * A label, safe inside `["…"]`.
+ * What a definition costs, for a caller that wants to REPORT rather than to be refused.
  *
- * ⚠️ Escaping lives HERE, and Story 4.2's review is why it is written down: the frontend port moved escaping out of
- * the model layer without recording that it had moved, and **4 real labels carry a raw newline**
- * (`ShoplinePublicApp.yaml`). A renderer that forgets breaks a real connector's diagram.
+ * The same arithmetic `renderMermaid` applies to `maxTextSize`, exported so a host can warn, offer to raise its own
+ * `maxTextSize`, or split a chart — all of which are better answers than an exception, and none of which the generator
+ * can choose on a caller's behalf.
+ */
+export declare function measureDefinitionBudget(definition: string, budget?: number): DefinitionBudget;
+/**
+ * The refusal. Carries the numbers, because "too big" without them tells a host nothing it can act on.
  *
- * The `&` replacement comes FIRST, or the entities the later rules produce would themselves be re-escaped.
+ * A throw and not a truncated string: the alternative the measurement documents — hand the host the oversized
+ * definition and let Mermaid quietly draw one node — is the exact failure this exists to prevent, and a caller that
+ * would rather warn than fail has `measureDefinitionBudget` and simply does not pass `maxTextSize`.
  */
+export declare class DefinitionOverBudgetError extends Error {
+    readonly budgetReport: DefinitionBudget;
+    constructor(budgetReport: DefinitionBudget);
+}
+/** A public label escaped as plain text; only structural anatomy can enable Mermaid markdown. */
 export declare function escapeLabel(value: string): string;
 /**
  * The diagram.
  *
  * Deterministic for a given `(groups, edges, opts)`: every list is emitted in the order given, duplicates are
  * collapsed by first appearance, and nothing consults the clock or the environment.
+ *
+ * The font each host must pin (AD-32(a)): this generator emits no font. A host picks one font string and passes
+ * it to mermaid as both `fontFamily` and `themeVariables.fontFamily` (mermaid copies the former into the latter
+ * only when the latter is unset), and makes the canvas container's CSS `font-family` resolve to that same string,
+ * so the boxes mermaid measures match the text the host paints. Write the string in CSS-canonical form (unquoted
+ * family names) so the resolved CSS value is byte-equal to what mermaid received. Known hosts:
+ * - dashboard-v2 flow canvas: `Inter, -apple-system, system-ui, sans-serif` (`typography.fontFamily.sans`), set
+ *   on both mermaid keys and on the render container.
+ * - VS Code webview (`src/webview/flowDiagram.ts`): `var(--vscode-font-family)`, which is also the preview body
+ *   CSS (`previewHtml.ts`).
+ * - Report page (`hexasync-template-report-render` `renderHtml.ts`): not pinned yet — it passes no font, so mermaid
+ *   uses its default while the body paints `-apple-system, Segoe UI, …`.
  */
-export declare function renderMermaid(groups: readonly RenderGroup[], edges: readonly RenderEdge[], opts?: RenderOptions): string;
+export declare function renderMermaid(authoredGroups: readonly RenderGroup[], authoredEdges: readonly RenderEdge[], opts?: RenderOptions): string;
+/** The definition, plus what the expansion learned about it that a host cannot recover from a string. */
+export interface RenderedFlow {
+    readonly definition: string;
+    /**
+     * The addresses of the collapsed-range nodes the definition drew, in drawing order.
+     *
+     * It has to LEAVE this function or it is not usable: a range is not a step, it has no YAML behind it, and
+     * `MermaidDiagramViewer` stamps `role="button"` on everything in `clickableNodeIds` (FR75, UX-DR57). A host that had
+     * to re-run the expansion to learn the set would be deriving the drawing twice and could disagree with itself.
+     */
+    readonly collapsedRanges: readonly string[];
+}
+/** `renderMermaid`, for a caller that also needs the occurrence facts the drawing carries. */
+export declare function renderMermaidWithOccurrences(authoredGroups: readonly RenderGroup[], authoredEdges: readonly RenderEdge[], opts?: RenderOptions): RenderedFlow;
 /**
  * A titled section with a fenced diagram, and nothing else (rule 3).
  *

package/dist/flowRender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowRender.d.ts","sourceRoot":"","sources":["../src/flowRender.ts"],"names":[],"mappings":"AA2CA,yFAAyF;AACzF,MAAM,WAAW,UAAU;IACzB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,sEAAsE;AACtE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,CAAC;AAExC,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;IACnC,kEAAkE;IAClE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS;QAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;KACvC,EAAE,CAAC;IACJ;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjD;AAsFD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,IAAI,GAAE,aAAkB,GACvB,MAAM,CAiIR;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,IAAI,GAAE,aAAkB,GACvB,MAAM,CAiBR"}
+{"version":3,"file":"flowRender.d.ts","sourceRoot":"","sources":["../src/flowRender.ts"],"names":[],"mappings":"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"}