@beehexa/hexasync-template-model 2608.21.2 → 2610.3.1

package/dist/occurrenceExpansion.js

@@ -0,0 +1,230 @@
+/**
+ * One drawn node per retained occurrence, plus one per collapsed range — Story 8.9, FR64, U5 reading **B**.
+ *
+ * ### What this fixes
+ *
+ * The drawing had one node per AUTHORED step however many times a run executed it, so a step that ran 1000 times was
+ * indistinguishable from one that ran once except for a badge. U5 was answered on 2026-09-28 in favour of reading B:
+ * the canvas shows one node per retained occurrence plus one node per collapsed range, mirroring the accumulator's
+ * `orderedTimeline` exactly. Nothing in the generator could express that — `workerFlow`'s `addressOf` maps a step key
+ * to exactly ONE address, and an address had no occurrence dimension at all.
+ *
+ * ### Why a transform ABOVE the flow builders, and not a change inside them
+ *
+ * FR40 requires the no-evidence path to draw byte-identically to today, and `workerFlow` is where the CLI compose
+ * report and the VS Code preview both get their graph — neither has a run. Teaching `workerFlow` about evidence would
+ * put a conditional address scheme inside the one function that must not have one. A transform above it is conditional
+ * by construction: **no plan, no change** — and not merely "no visible change", but the same array references returned,
+ * so there is no path by which a no-run surface can gain an occurrence segment.
+ *
+ * ### Why the chain is the timeline
+ *
+ * The acceptance criterion names `orderedTimeline` as the artifact the drawing must mirror, and that list is precisely
+ * the run's order of retained occurrences and collapsed ranges. Chaining it reproduces the inspector's
+ * `1 → ×997 → 999 → 1000` on the canvas, which is what makes the two surfaces one story rather than two. The
+ * requirements do not state an edge topology for expanded nodes, so this is an inference — and it is the only reading
+ * that uses the artifact the criterion names.
+ *
+ * ### What this deliberately does NOT do
+ *
+ * It does not parse an evidence envelope. FR26 gives one internal shape sole ownership of the occurrence facts, so the
+ * plan arrives as a typed parameter (`OccurrencePlan`) and a producer — Epic 10's — converts. It also builds neither
+ * overlay producer, touches no host, and knows nothing about clickability: a collapsed range is reported back in
+ * `collapsedRanges` so a host can keep it out of `clickableNodeIds` (FR75, UX-DR57), which is a decision the host owns.
+ */
+import { nodeAddress, occurrenceSegment, occurrenceSegmentText, rangeSegmentText, } from './nodeAddress.js';
+const IDENTITY_OVERLAY = Object.freeze({});
+/**
+ * Combine a DERIVED overlay with a CALLER's, per field, with the caller's statement winning.
+ *
+ * ⛔ One function because three sites needed it and two of them had it backwards. `flowRender` merged
+ * `{...caller, ...derived}` and the adapters merged `{...derived, ...caller}`, so the same plan plus the same caller
+ * overlay lost the `×N` through one path and lost the caller's `ranFailed` through the other. Worse, both were
+ * WHOLE-OBJECT merges, so `{ repeat }` and `{ state }` could never coexist: a failed range could not carry its count.
+ *
+ * Per field, so a range that the producer says failed keeps both its state and its derived count, while a caller that
+ * states its own `repeat` still overrides the derived one.
+ */
+export function mergeNodeOverlays(derived, caller) {
+    if (derived === undefined || Object.keys(derived).length === 0)
+        return caller ?? IDENTITY_OVERLAY;
+    if (caller === undefined || Object.keys(caller).length === 0)
+        return derived;
+    const merged = { ...derived };
+    for (const [address, entry] of Object.entries(caller)) {
+        const own = merged[address];
+        merged[address] = own === undefined ? entry : { ...own, ...entry };
+    }
+    return merged;
+}
+const NO_RANGES = Object.freeze([]);
+/**
+ * The address of one entry in a node's timeline.
+ *
+ * Throws rather than falling back, and that is the whole point of the function existing. `nodeAddress` DROPS a refused
+ * segment, so a silent refusal here would return the AUTHORED address — and every occurrence of the step would collapse
+ * back onto it, deduped by `renderMermaid`'s own node dedupe, leaving a 1000-iteration run drawn as one node with no
+ * error anywhere. The failure has to be loud because its silent form is indistinguishable from correct output.
+ */
+function addressOfEntry(authored, entry) {
+    const text = entry.kind === 'range'
+        ? rangeSegmentText(entry.rangeId)
+        : occurrenceSegmentText(entry.ordinal);
+    const segment = occurrenceSegment(text);
+    if (segment === undefined) {
+        throw new Error(`Occurrence plan for "${authored}" produced the unusable occurrence segment "${text}" (${entry.kind}). ` +
+            'An occurrence segment is a single `:`-delimited segment of word characters joined by single underscores.');
+    }
+    return nodeAddress([{ kind: 'key', name: authored }, segment]);
+}
+/**
+ * Expand the authored graph against a run's occurrence plan.
+ *
+ * Pure, deterministic and total: the same `(groups, edges, plan)` always produces the same result, nothing consults
+ * the clock, and a plan naming a step no group drew is ignored in silence — exactly what an `overlay.nodes` entry does with
+ * an unknown address, because a producer that knows about a step the drawing dropped is the normal case, not an error.
+ *
+ * ⚠️ Call it BEFORE the definition string is built and before the collision check — which is what wiring it into the
+ * two flow adapters ahead of `renderFlowMermaid` achieves (FR64: *"collapsed before the definition string is built,
+ * not after and not by a host"*).
+ */
+export function expandOccurrences(groups, edges, plan) {
+    const identity = {
+        groups,
+        edges,
+        nodes: IDENTITY_OVERLAY,
+        collapsedRanges: NO_RANGES,
+        expanded: false,
+    };
+    if (plan === undefined)
+        return identity;
+    /**
+     * Only an address a group ACTUALLY DREW can expand, and only with at least one entry.
+     *
+     * Both halves matter. An undrawn key is the "plan names an undrawn step" row of the matrix. An empty entry list is
+     * the more dangerous one: expanding a node into nothing would delete a drawn step and, with it, every edge through
+     * it — a diagram that silently describes a different workflow. Nothing is the identity, not the empty set.
+     */
+    const drawn = new Set();
+    for (const group of groups)
+        for (const node of group.nodes)
+            drawn.add(node.address);
+    const expansions = new Map();
+    for (const [address, entries] of Object.entries(plan)) {
+        if (!drawn.has(address) || entries.length === 0)
+            continue;
+        expansions.set(address, entries);
+    }
+    if (expansions.size === 0)
+        return identity;
+    const addressesOf = new Map();
+    /**
+     * Every drawn address, expanded or not — the set a new one must not already be in.
+     *
+     * ⛔ Without this, a plan that repeats an ordinal, repeats a `rangeId`, or arrives unsorted mints the SAME address
+     * twice. `assertUniqueRenderedIds`'s escape hatch is exact-address equality, so the duplicate is not a collision to
+     * it; it falls through to `renderMermaid`'s node dedupe and a 1000-iteration run draws as one node — precisely the
+     * silent failure `addressOfEntry` throws to prevent, reached by a different door.
+     */
+    const claimed = new Set();
+    for (const group of groups) {
+        for (const node of group.nodes) {
+            if (!expansions.has(node.address))
+                claimed.add(node.address);
+        }
+    }
+    for (const [address, entries] of expansions) {
+        let previous;
+        for (const entry of entries) {
+            /**
+             * Ordinals ASCEND, strictly. A chain is the run's order, so a backwards or repeated ordinal would draw an arrow
+             * through time — the one topology this design rules out — and a repeated one also duplicates an address.
+             */
+            if (previous !== undefined && entry.ordinal <= previous.ordinal) {
+                throw new Error(`Occurrence plan for "${address}" is not in timeline order: ordinal ${entry.ordinal} follows ` +
+                    `${previous.ordinal}. A chain is the run's order, so ordinals must strictly ascend.`);
+            }
+            previous = entry;
+        }
+        const expandedAddresses = entries.map((entry) => addressOfEntry(address, entry));
+        for (const expandedAddress of expandedAddresses) {
+            if (claimed.has(expandedAddress)) {
+                throw new Error(`Occurrence plan for "${address}" mints the address "${expandedAddress}" twice. Two drawn nodes sharing ` +
+                    'one address are silently deduped into one, which would draw a repeated step as if it ran once.');
+            }
+            claimed.add(expandedAddress);
+        }
+        addressesOf.set(address, expandedAddresses);
+    }
+    const overlayNodes = {};
+    const collapsedRanges = [];
+    const expandedGroups = groups.map((group) => ({
+        ...group,
+        nodes: group.nodes.flatMap((node) => {
+            const entries = expansions.get(node.address);
+            if (entries === undefined)
+                return [node];
+            const addresses = addressesOf.get(node.address);
+            return entries.map((entry, index) => {
+                const address = addresses[index];
+                if (entry.kind === 'range') {
+                    collapsedRanges.push(address);
+                    // `repeat` is how a `×N` reaches a label (Story 8.8); the range keeps the step's shape and icon so the
+                    // chain reads as the same step, not as a foreign element spliced into it.
+                    overlayNodes[address] = { repeat: entry.count };
+                }
+                return { ...node, address };
+            });
+        }),
+    }));
+    /**
+     * Edges, in the order the documented expansion draws them: `A → B₁ → Bᵣ → B₉₉₉ → B₁₀₀₀ → C`.
+     *
+     * An inbound edge lands on the FIRST entry and an outbound edge leaves the LAST, because the chain is the run's
+     * order and any other choice would draw an arrow backwards through time. A node's chain is emitted immediately
+     * after the first authored edge that arrives at it, which is what puts the statements in timeline order for the
+     * ordinary single-entry case; a node with no inbound edge emits its chain up front. Order is deterministic either
+     * way, and `linkStyle` indices are assigned from the emitted sequence, so this is a byte-level decision.
+     */
+    const firstOf = (address) => addressesOf.get(address)?.[0] ?? address;
+    const lastOf = (address) => addressesOf.get(address)?.at(-1) ?? address;
+    const chainOf = (address) => {
+        const addresses = addressesOf.get(address) ?? [];
+        return addresses.slice(1).map((to, index) => ({ from: addresses[index], to }));
+    };
+    const inbound = new Set(edges.filter((edge) => edge.from !== edge.to).map((edge) => edge.to));
+    const chained = new Set();
+    const expandedEdges = [];
+    for (const address of addressesOf.keys()) {
+        if (inbound.has(address))
+            continue;
+        chained.add(address);
+        expandedEdges.push(...chainOf(address));
+    }
+    for (const edge of edges) {
+        /**
+         * An authored SELF-edge is dropped only where the CHAIN has already replaced it.
+         *
+         * `B → B` is how a looping step is authored. Once the run's iterations are drawn as a chain, rewriting that edge
+         * would emit `B₁₀₀₀ → B₁` — an arrow from the last occurrence back to the first, i.e. a claim that the run ended
+         * where it began. But a node that expanded to ONE entry has no chain, so dropping its self-edge would delete the
+         * only statement that the step loops at all; there it is rewritten onto that single occurrence, and a node with no
+         * plan entry is untouched.
+         */
+        if (edge.from === edge.to && (addressesOf.get(edge.from)?.length ?? 0) > 1)
+            continue;
+        expandedEdges.push({ ...edge, from: lastOf(edge.from), to: firstOf(edge.to) });
+        if (expansions.has(edge.to) && !chained.has(edge.to)) {
+            chained.add(edge.to);
+            expandedEdges.push(...chainOf(edge.to));
+        }
+    }
+    return {
+        groups: expandedGroups,
+        edges: expandedEdges,
+        nodes: overlayNodes,
+        collapsedRanges,
+        expanded: true,
+    };
+}
+//# sourceMappingURL=occurrenceExpansion.js.map

package/dist/occurrenceExpansion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"occurrenceExpansion.js","sourceRoot":"","sources":["../src/occurrenceExpansion.ts"],"names":[],"mappings":"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"}

package/dist/stepGlyph.d.ts

@@ -15,53 +15,266 @@
  *
  * ### Why a glyph and not the SVG set
  *
- * ⚠️ Stated rather than quietly downgraded. `ux/step-icons/` holds 12 authored SVGs, and they cannot go inside
- * a mermaid node here: the webview renders with `securityLevel: 'strict'`, which sanitises label HTML through
- * DOMPurify (`renderHtml.ts:493` records the same constraint for the report), and an inline `<svg>` does not
- * survive that. Raising it to `'loose'` to admit one would also admit mermaid's `click … call fn()` — which is
- * precisely why `flowDiagram.ts` chose strict.
+ * The authored SVGs cannot go inside a Mermaid node here: Mermaid 12 at `securityLevel: 'strict'` sanitises label
+ * HTML through DOMPurify, and an inline `<svg>` does not survive that. Raising strict hosts to `'loose'` would weaken
+ * their label boundary.
  *
- * So the icon slot is filled by a per-FAMILY unicode glyph, which survives sanitising, needs no asset
- * pipeline, and renders identically in the editor, the report and the browser host. The type name is drawn
- * beside it, so the glyph is a hint and never the only signal — that is the "fallback to text", present
- * always rather than only when something fails.
+ * Strict fidelity therefore keeps the parent-family Unicode glyph and the type text beside it, so the glyph is a
+ * hint and never the only signal. Loose fidelity uses a key-only label beside the child-family SVG mask exposed
+ * below. The renderer stamps the class hook; no SVG or icon class definition enters the Mermaid source.
+ */
+import type { RenderFidelity, RunState } from './flowRender.js';
+/** The ten coarse families whose Unicode glyphs remain usable in strict Mermaid hosts. */
+export type ParentStepFamily = 'call' | 'control' | 'orchestrate' | 'query' | 'state' | 'terminal' | 'transform' | 'ui' | 'wait' | 'write';
+/**
+ * Keep authored punctuation literal inside Mermaid 12 Markdown labels.
+ *
+ * Mermaid's SVG-label path drops Markdown `escape` tokens and does not decode numeric entities. U+FEFF is zero-width
+ * whitespace: bracketing authored Markdown punctuation with it makes the lexer keep the punctuation in ordinary text
+ * tokens while leaving the visible text unchanged. The renderer-owned bold delimiters are added afterwards.
  *
- * Wiring the real SVG set belongs with the shared step-icon package the toolchain PRD lists under
- * *"Unblocks"*, where a `<span class="step-icon step-icon--api">` and CSS can do it without loosening mermaid.
+ * It lives HERE, beside the composer, rather than in `flowRender.ts` where it started: the composer and the renderer
+ * must escape one heading identically or the same node gets two different labels depending on which surface built it,
+ * and the only way to guarantee that is one function. `flowRender.ts` imports it — never the other way round, because
+ * that is the dependency direction this package already has.
  */
+export declare function escapeMarkdownText(value: string): string;
+/** The sole result for absent or unknown worker vocabulary. */
+export declare const UNMAPPED_STEP_ICON: {
+    readonly family: 'unmapped';
+    readonly glyph: '□';
+};
+/** The approved 32 drawing families, rolled up to the strict-host glyph vocabulary. */
+export declare const STEP_FAMILY_PARENTS: {
+    readonly 'call.dialect': 'call';
+    readonly 'call.event': 'call';
+    readonly 'call.http': 'call';
+    readonly 'call.webhook': 'call';
+    readonly 'control.if': 'control';
+    readonly 'control.switch': 'control';
+    readonly 'orchestrate.composite': 'orchestrate';
+    readonly 'orchestrate.enqueue': 'orchestrate';
+    readonly 'orchestrate.pull': 'orchestrate';
+    readonly 'query.dsl': 'query';
+    readonly 'query.file': 'query';
+    readonly 'query.history': 'query';
+    readonly 'query.kv': 'query';
+    readonly 'query.metrics': 'query';
+    readonly 'query.record': 'query';
+    readonly 'query.sql': 'query';
+    readonly 'state.cache': 'state';
+    readonly 'state.item': 'state';
+    readonly 'state.kv': 'state';
+    readonly 'state.removal': 'state';
+    readonly 'state.task-data': 'state';
+    readonly 'terminal.begin': 'terminal';
+    readonly 'terminal.end': 'terminal';
+    readonly 'terminal.error': 'terminal';
+    readonly 'transform.decode': 'transform';
+    readonly 'transform.filter': 'transform';
+    readonly 'transform.template': 'transform';
+    readonly 'wait.sleep': 'wait';
+    readonly 'write.delete': 'write';
+    readonly 'write.index': 'write';
+    readonly 'write.push': 'write';
+    readonly 'write.seed': 'write';
+};
+export type WorkerStepFamily = keyof typeof STEP_FAMILY_PARENTS;
+/** Every id in Epic 7's authoritative 51/51 runtime roster, in manifest order. */
+export declare const WORKER_STEP_FAMILIES: {
+    readonly API: 'call.http';
+    readonly BASE64_TO_MIME_TYPE: 'transform.decode';
+    readonly Begin: 'terminal.begin';
+    readonly CACHE: 'state.cache';
+    readonly CHECK_FORMAT: 'transform.filter';
+    readonly Composite: 'orchestrate.composite';
+    readonly DIRECT_INDEX: 'write.index';
+    readonly DOWNLOAD_CSV: 'query.file';
+    readonly ENQUEUER: 'orchestrate.enqueue';
+    readonly EXCEL_READER: 'query.file';
+    readonly EXCEPTION: 'terminal.error';
+    readonly End: 'terminal.end';
+    readonly Error: 'terminal.error';
+    readonly FORWARD: 'transform.filter';
+    readonly GET_KEY_VALUE: 'query.kv';
+    readonly GraphQL: 'call.dialect';
+    readonly IF: 'control.if';
+    readonly IGNORE_ITEM: 'state.item';
+    readonly INVALIDATE_CACHE: 'state.cache';
+    readonly JSONata: 'transform.template';
+    readonly LOOKUP_STEP: 'query.history';
+    readonly Liquid: 'transform.template';
+    readonly METRIC_QUERY: 'query.metrics';
+    readonly OData: 'call.dialect';
+    readonly PUBLISH_EVENT: 'call.event';
+    readonly PULLER: 'orchestrate.pull';
+    readonly PUSHER: 'write.push';
+    readonly QUERY_MANY: 'query.record';
+    readonly QUERY_METRICS: 'query.metrics';
+    readonly QUERY_SINGLE: 'query.record';
+    readonly QueryDSL: 'query.dsl';
+    readonly REMOVE_DATA: 'write.delete';
+    readonly RESET_ITEM: 'state.item';
+    readonly RESOLVE_RAW_DATA: 'transform.decode';
+    readonly Restful: 'call.dialect';
+    readonly SAVE_TASK_DATA: 'state.task-data';
+    readonly SEED_DATA: 'write.seed';
+    readonly SET_KEY_VALUE: 'state.kv';
+    readonly SLEEP: 'wait.sleep';
+    readonly SQL: 'query.sql';
+    readonly SQL_PROXY: 'query.sql';
+    readonly SWITCH: 'control.switch';
+    readonly Scriban: 'transform.template';
+    readonly TRACK_FOR_REMOVAL: 'state.removal';
+    readonly UPDATE_ITEM_STATUS: 'state.item';
+    readonly UPDATE_ITEM_SYNC_PROCESS: 'state.item';
+    readonly UPDATE_TASK_DATA_STATUS: 'state.task-data';
+    readonly VALUES: 'transform.template';
+    readonly VERIFY_CACHED: 'state.cache';
+    readonly WEBHOOK_FORWARD: 'call.webhook';
+    readonly cURL: 'call.dialect';
+};
+export type WorkerStepType = keyof typeof WORKER_STEP_FAMILIES;
+export type StepTypeDomain = 'worker' | 'frontend';
+/** Resolve only the worker runtime domain. Unknown and absent values are deliberately neutral. */
+export declare function familyOfStepType(type: string | undefined): WorkerStepFamily | typeof UNMAPPED_STEP_ICON.family;
 /**
- * Which family a step type belongs to.
+ * Retained frontend-domain chain. Its meaningful fallback is existing frontend behavior and must not be used
+ * for worker ids.
+ */
+export declare function familyOfFrontendStepType(type: string): ParentStepFamily;
+/** Resolve a child or parent family to a strict-host glyph. */
+export declare function glyphOfStepFamily(family: string | undefined): string;
+/** Resolve a worker id through the explicit child-family map and parent rollup. */
+export declare function glyphOfStepType(type: string | undefined): string;
+/** Resolve a frontend id through the retained regex chain. */
+export declare function glyphOfFrontendStepType(type: string | undefined): string;
+export type StepIconAsset = {
+    readonly family: WorkerStepFamily | typeof UNMAPPED_STEP_ICON.family;
+    readonly parent: ParentStepFamily | typeof UNMAPPED_STEP_ICON.family;
+    readonly className: string;
+    readonly strictGlyph: string;
+    readonly looseMaskImage: string;
+    readonly tint: 'currentColor';
+};
+/** The dashboard tile anatomy. Hosts resolve these token names; the vocabulary never bakes in theme colours. */
+export declare const STEP_ICON_TILE: {
+    readonly alignment: 'left';
+    readonly shape: 'square';
+    readonly radiusToken: 'rounded.xl';
+    readonly backgroundToken: 'tile-bg';
+    readonly glyphToken: 'tile-glyph';
+};
+/** Normalize a family into the asset-backed class Mermaid copies to the rendered node group. */
+export declare function stepIconClassName(family: string | undefined): string;
+type StepIconAssetKey = WorkerStepFamily | typeof UNMAPPED_STEP_ICON.family;
+/**
+ * Complete local loose-host assets. Each mask is percent-encoded on first property access, so strict-only rendering
+ * pays only for class and glyph lookup.
+ */
+export declare const STEP_ICON_ASSETS: Readonly<Record<StepIconAssetKey, StepIconAsset>>;
+/**
+ * The in-node error marker: one glyph for a strict host, the approved drawing for a loose one.
+ *
+ * **Why `⚠` (U+26A0, Miscellaneous Symbols) and not a glyph from the three approved blocks.** `PARENT_GLYPHS`'
+ * Arrows / Geometric Shapes / Mathematical Operators rule exists so 32 FAMILY glyphs render in the fonts a webview
+ * receives; it does not cover a marker, and none of the three blocks contains an exclamation-in-triangle — the shape
+ * DESIGN.md names. U+26A0 was MEASURED surviving a Mermaid 12.0.0 strict-mode render inside a backtick-quoted
+ * markdown label on 2026-09-28, alongside `×` and `◆`, and it is the one glyph in the canvas's whole vocabulary whose
+ * absence would be obvious rather than silent (a failed node also carries `emphasis` width, a red stroke and a tinted
+ * fill, so the marker is never the only signal — `node-failed`'s three channels are independent by design).
  *
- * Matched on the type name because that is what both runtimes carry — a worker step's `displayType` and a
- * frontend step's `type` are the same idea spelled twice (AD-21 keeps the vocabularies apart, not the
- * concept). Unknown types get the neutral glyph rather than no glyph, so a box never loses its icon slot and
- * start shifting the text alignment of its neighbours.
+ * **The same glyph is used at BOTH fidelities.** Story 8.3 could split strict glyph from loose mask because the mask
+ * arrives through a class the host's own stylesheet paints; a run-state mark cannot, because AD-23 forbids any host
+ * CSS rule that carries run state onto a node. `looseMaskImage` is therefore exported for a loose host's LEGEND or
+ * inspector chrome — not for the node — and it reuses `terminal.error`'s approved path fragment rather than authoring
+ * a second exclamation-in-triangle.
  */
-export declare function familyOfStepType(type: string): string;
+export declare const RUN_STATE_ERROR_MARKER: {
+    readonly glyph: '⚠';
+    readonly className: string;
+    readonly looseMaskImage: string;
+    readonly tint: 'currentColor';
+};
+/** The multiplication sign the count badge reads with (`×997`). MEASURED surviving a strict-mode render. */
+export declare const REPEAT_BADGE_GLYPH = "\u00D7";
 /**
- * The glyph for a step type.
+ * The largest count the badge will draw.
  *
- * Empty for a step with NO type — there is no icon to stand in for, and a placeholder would render as a
- * second separator (`name · · KEY`), which is how this was caught.
+ * A bound, not a formatting choice: `Number.isInteger(1e21)` is TRUE, so an unbounded check drew `×1e+21` — the
+ * exponent notation JavaScript switches to above 1e20, which is not a count any reader can act on and not a claim
+ * about a run that the generator can stand behind. A billion occurrences is already far outside anything the
+ * accumulator can produce, so beyond it the honest answer is no badge.
  */
-export declare function glyphOfStepType(type: string | undefined): string;
+export declare const REPEAT_BADGE_MAX = 1000000000;
+/** Is this a count worth drawing? One predicate, so the label and the style pass can never disagree. */
+export declare function isCountableRepeat(repeat: number | undefined): repeat is number;
+/** `×N` for a count worth stating, and nothing at all otherwise. */
+export declare function repeatBadgeText(repeat: number | undefined): string | undefined;
+export declare function runStateAlternativeText(runState: {
+    readonly state?: RunState;
+    readonly repeat?: number;
+} | undefined): string;
+/** The run-state content one node's label carries. Absent members carry nothing, so a no-overlay label is unchanged. */
+export interface NodeRunStateContent {
+    readonly marker?: boolean;
+    readonly repeat?: number;
+}
+export interface NodeLabelInput {
+    readonly label?: string;
+    readonly name?: string;
+    readonly stepKey?: string;
+    readonly address: string;
+    readonly type?: string;
+    readonly displayType?: string;
+}
+/** Structured provenance consumed by the Mermaid renderer; arbitrary label bytes cannot impersonate it. */
+export interface NodeLabelAnatomy {
+    readonly icon?: string;
+    /**
+     * The in-node error marker, drawn RIGHT OF THE ICON TILE (DESIGN.md `markers.error`, `node-failed` line 176).
+     *
+     * A run-state slot on the label rather than a host decoration, because AD-23 makes run-state-carried content
+     * stage 1's and forbids stage 3 from carrying run state at all.
+     */
+    readonly marker?: string;
+    readonly heading: string;
+    readonly description?: string;
+    /** The repeat count as rendered text (`×997`), last in the card's reading order. */
+    readonly badge?: string;
+}
+export interface NodeLabelComposition {
+    readonly text: string;
+    readonly anatomy?: NodeLabelAnatomy;
+}
 /**
- * The three lines a reader needs, in the order the brainstorm asked for: name, then key, then type.
+ * Compose the shared node-card anatomy and its structural renderer provenance.
  *
- * ⚠️ ONE LINE, not `<br/>`, and that was measured rather than assumed. The first version used `<br/>`; the
- * shared renderer's `escapeLabel` turns `<` into `&lt;` — correctly, it is what stops an authored step name
- * injecting markup — so mermaid received `&lt;br/&gt;` and would have drawn it as visible text in every box.
- * Weakening `escapeLabel` to admit one tag would trade a real safety property for a cosmetic one.
+ * The label has two semantic text roles rather than a two-physical-line limit: the bold heading may wrap, and the
+ * upright key/type description follows it. Strict hosts keep a Unicode glyph and explicit type text; loose hosts
+ * reserve the icon through the node's family class and keep the key as their description.
  *
- * A junction (START/END) has its own label and no key or type — it returns unchanged, because decorating a
- * terminal with an empty key line would put a blank row in every diagram.
+ * Boundary whitespace is not visible content. Normalizing it here keeps a blank explicit label from defeating the
+ * name/key/address fallback or moving Mermaid's bold delimiters away from the heading.
+ */
+export declare function composeNodeLabelModel(node: NodeLabelInput, fidelity: RenderFidelity, domain: StepTypeDomain, iconFamily?: string, runState?: NodeRunStateContent): NodeLabelComposition;
+/** String-only compatibility surface; renderers use `composeNodeLabelModel` so provenance stays structural. */
+export declare function composeNodeLabel(node: NodeLabelInput, fidelity: RenderFidelity, domain: StepTypeDomain, iconFamily?: string): string;
+/**
+ * Screen-reader text for a node. The icon is deliberately absent: strict Unicode names are noisy, while loose masks
+ * are decorative. Fidelity and domain stay in the signature so callers can compose visual and accessible labels from
+ * the same inputs without branching.
  */
-export declare function composeNodeLabel(node: {
+export declare function composeAccessibleNodeLabel(node: {
     readonly label?: string;
     readonly name?: string;
     readonly stepKey?: string;
     readonly address: string;
     readonly type?: string;
     readonly displayType?: string;
+}, _fidelity: RenderFidelity, _domain: StepTypeDomain, runState?: {
+    readonly state?: RunState;
+    readonly repeat?: number;
 }): string;
+export {};
 //# sourceMappingURL=stepGlyph.d.ts.map

package/dist/stepGlyph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stepGlyph.d.ts","sourceRoot":"","sources":["../src/stepGlyph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA4CH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BrD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,MAAM,CAYT"}
+{"version":3,"file":"stepGlyph.d.ts","sourceRoot":"","sources":["../src/stepGlyph.ts"],"names":[],"mappings":"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"}