@beehexa/hexasync-template-worker-flow 2608.20.18 → 2608.20.32

package/dist/flow.d.ts

@@ -0,0 +1,163 @@
+import { type StageEdge, type StageDefinition, type WorkerCollection, type PullerKind } from './stages.js';
+/** Where a node came from in the authored source. Every field optional: an absent location is not a guessed one. */
+export interface NodeLocation {
+    /** The authored file, as the caller identifies files — a URI here, a path there. Never parsed by this package. */
+    readonly file?: string;
+    /** Zero-based, end-exclusive, in the caller's own coordinate system. */
+    readonly range?: {
+        readonly start: {
+            readonly line: number;
+            readonly character: number;
+        };
+        readonly end: {
+            readonly line: number;
+            readonly character: number;
+        };
+    };
+    /** The authored text, so a consumer can quote the node without re-reading the file. */
+    readonly sourceText?: string;
+}
+/** What the caller is asked to locate. Enough to find the node without knowing this package's internals. */
+export interface LocateRequest {
+    readonly collection: WorkerCollection;
+    readonly stage: string;
+    /** Absent for a synthesised node, which has no line of its own. */
+    readonly stepKey?: string;
+    readonly address: string;
+    /**
+     * For a SYNTHESISED node: the key of the step that produced it, and the path that reaches it (Jazz, 2026-08-17).
+     *
+     * ⛔ The junction's `locate` call passed neither, while `Junction.owner` and `Junction.path` sat in the same loop —
+     * so the only thing a locator could do with a diamond was decline, and the extension's did, on the stated grounds
+     * that the owner's own line *"would be a plausible-looking lie"*. It would be; the BRANCH's line is not, and the
+     * path is what identifies it. Reported as *"clicking the diamond should let me focus on the actual IF"*.
+     *
+     * `path` is relative to the step — `['data','if']`, `['next','then','if']`, `['next','expression']` — and its last
+     * segment may be SYNTHETIC (`expression`, `unknown`, `cycle`, `switch`): those name what the junction is, not a key
+     * the document holds. A locator resolves the longest authored prefix, which is why the whole path is handed over
+     * rather than a pre-trimmed one: only the reader of the file knows which segments it can see.
+     */
+    readonly ownerStepKey?: string;
+    readonly path?: readonly string[];
+}
+/** One node in the flow — a step, or a decision synthesised from a step's branch. */
+export interface FlowNode extends NodeLocation {
+    /** The AD-33 canonical address. Stable across any edit that renames nothing. */
+    readonly address: string;
+    /** `worker` on every node, deliberately — Story 4.2 AC-4 exists so no consumer merges the two domains. */
+    readonly runtime: 'worker';
+    readonly stage: string;
+    /** The step's declared type, when it declares one. 34 of 5,820 authored steps do not. */
+    readonly type?: string;
+    /**
+     * The step's human name, where it declares one.
+     *
+     * ⛔ Never captured, and **all three** baselines draw it: the CLI report emits
+     * `pushSteps_GET_SALES_RETURN_DETAIL["Get Sales Return Detail"]`, the extension
+     * `n0{"GET_SALES_RETURN_DETAIL<br/>Get Sales Return Detail"}`. Story 4.3 defended dropping it by citing
+     * `SHOW_CREATE_PROFILE_ERROR["Couldn't Start Profile Creation"]` — a FRONTEND node, which shows a name, so the
+     * evidence argued against the behaviour it was used to defend. Story 4.6 could not have reproduced its own baseline.
+     */
+    readonly name?: string;
+    /**
+     * An ENTRY step (`rootStep`, or `root`).
+     *
+     * For the renderer rather than for routing: a stage arrow must leave a terminal and land on an ENTRY, which is how
+     * dashboard chooses its target. Without this the renderer could only guess "first in document order" — the fourth
+     * stage geometry the Story 4.3 review found.
+     */
+    readonly isEntry?: boolean;
+    /**
+     * A branch point, drawn as a diamond.
+     *
+     * ⚠️ True on a SYNTHESISED node only (Story 4.1 review, HIGH-3). It used to be true on a branching step as well,
+     * so a renderer keyed on it drew two diamonds per branch. The baseline draws the step as a rectangle and the
+     * junction beside it, and that is what the arms leave.
+     */
+    readonly decides: boolean;
+    /**
+     * What a renderer writes inside a synthesised node: the condition text, the expression, or the unresolved target.
+     *
+     * Added by the review: without it, even the one junction the first version created could not carry the baseline's
+     * label (`cond.if`, or the expression verbatim), and the only candidate carrier was the unimplemented `locate`
+     * seam.
+     */
+    readonly label?: string;
+    /** For a synthesised node, which kind it is — so a renderer picks a shape without parsing the label. */
+    readonly junction?: 'if' | 'expression' | 'unknown';
+    /** For a step node, its authored key. Absent on a synthesised node, which has no key of its own. */
+    readonly stepKey?: string;
+    /** For a synthesised node, the address of the step that produced it. */
+    readonly owner?: string;
+}
+/** The whole model for one component. */
+export interface WorkerFlow {
+    readonly address: string;
+    readonly collection: WorkerCollection;
+    /** Reported, never used to choose the stage list. */
+    readonly pullerKind?: PullerKind;
+    readonly stages: readonly StageDefinition[];
+    readonly stageEdges: readonly StageEdge[];
+    /** Keyed by address, so a click resolves in one lookup. */
+    readonly nodes: readonly FlowNode[];
+    /** Edges between nodes, with both ends as ADDRESSES. Every end is indexed in `nodes`. */
+    readonly edges: readonly FlowEdgeAddressed[];
+    /**
+     * Step keys declared more than once in one stage, and therefore dropped.
+     *
+     * Present only when it happened, so a consumer that does not care reads nothing — but reported rather than
+     * swallowed: one corpus file does this, and a graph that is quietly smaller than the document is its own defect.
+     */
+    readonly duplicateStepKeys?: readonly {
+        readonly stage: string;
+        readonly key: string;
+    }[];
+}
+/** A route edge with both ends addressed, and its unresolved cases preserved. */
+export interface FlowEdgeAddressed {
+    readonly from: string;
+    /**
+     * Always present.
+     *
+     * ⚠️ This was optional, left over from before junctions existed: a dead end used to be an edge with no `to` and a
+     * `raw` string. Since the route graph absorbs every unresolved route into an `unknown` junction, both ends are always
+     * real nodes — the loop that builds these skips an edge it cannot address at all. A renderer could not consume the
+     * optional form without inventing a node for the missing end.
+     */
+    readonly to: string;
+    readonly label?: string;
+    readonly stage: string;
+}
+export interface WorkerFlowInput {
+    readonly collection: WorkerCollection;
+    /** The parsed component, authored form. */
+    readonly component: Record<string, unknown>;
+    /** Its `id`, authored — AD-33 keeps the token rather than a composed GUID. */
+    readonly componentId?: unknown;
+    /** Supplies file/range/sourceText for a node, or nothing. */
+    readonly locate?: (request: LocateRequest) => NodeLocation | undefined;
+}
+/**
+ * ⛔ `branchOf` was DELETED here (Story 4.1 review, MEDIUM-2).
+ *
+ * It decided independently of `routeEdges` what "branches" means, and the two disagreed: an `IF` whose `data`
+ * carried only `{ expression }` was meant to route through its `next` while `branchOf` synthesised a diamond anyway —
+ * an orphan node asserting a decision the document does not make. Two functions owning one concept, with only one of
+ * them the authority.
+ *
+ * ⚠️ **Correction (Story 4.7 review).** The route graph did NOT in fact route that case through `next` — it drew the
+ * diamond and dropped the `next` edge, orphaning its target, so this paragraph described the intent rather than the
+ * behaviour for two stories. `routeGraph.ts` now has the fallback its flat twin `routes.ts` always had. Deleting
+ * `branchOf` was still the right call; the claim about what survived it was just untrue until now.
+ *
+ * `routeGraph` is now that single authority: it decides where a junction belongs *while* placing the edge that
+ * reaches it, so a junction cannot exist without an arrow into it and an arrow cannot bypass one.
+ */
+/**
+ * The flow model and the node index for one component.
+ *
+ * One entry point, one route graph. Nodes and edges are both derived from that graph before returning, so neither
+ * can contain something the other does not know about — see the note on "one pass" above.
+ */
+export declare function workerFlow(input: WorkerFlowInput): WorkerFlow;
+//# sourceMappingURL=flow.d.ts.map

package/dist/flow.d.ts.map

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

package/dist/flow.js

@@ -0,0 +1,251 @@
+/**
+ * A worker component's flow and its node index, from ONE pass — Story 4.1 AC-3 and AC-4.
+ *
+ * ### Why one pass is an acceptance criterion rather than an optimisation
+ *
+ * AC-3: *"the diagram and the node index come from one pass"*. Two passes are how a synthesised node ends up in one
+ * and not the other — drawn but unaddressable, or addressable but undrawn. Either way a click resolves to nothing,
+ * and the failure is invisible until someone clicks. So `workerFlow` returns nodes and edges together and there is
+ * no second entry point that produces only one of them.
+ *
+ * ### Every node is addressed by AD-33, including the synthesised ones
+ *
+ * A step node is `<component>:<stage>:key_<stepKey>`. A **decision** node is the branch's own path —
+ * `<step>:next:if` or `<step>:data:if` — which is what makes it stable: the diamond keeps that address however many
+ * steps are added around it. The three previous schemes all numbered it (`_D_<n>`, `_IF_<n>`), so inserting a step
+ * above renumbered a node that nothing had renamed.
+ *
+ * A synthesised node carries `owner`, the address of the step that produced it, so a click on the diamond resolves
+ * to a real line in a real file (AC-3's *"the node reports the step that produced it"*).
+ *
+ * ### Source location arrives as DATA (AD-3)
+ *
+ * `file`, `range` and `sourceText` are supplied by a `locate` callback rather than read here. This package is core:
+ * it cannot open a file, and the extension bundles it into a host with no filesystem at all. Story 4.1 records that
+ * this half exists nowhere yet for a worker step — the only source-range machinery in any repo is dashboard's
+ * *frontend* path — so the seam is defined here and the producer is an adapter's job. A node whose location the
+ * caller cannot supply simply has none, which is the honest answer rather than a guessed line number.
+ */
+import { keySegment, identitySegment, nodeAddress, normalizeComponentKey, } from '@beehexa/hexasync-template-model';
+import { stagesPresent, stageEdges, pullerKindOf, } from './stages.js';
+import { routeGraph, junctionAddress } from './routeGraph.js';
+/**
+ * A boolean flag as authored — `true`, or the string a JSON-served profile may carry.
+ *
+ * Deliberately narrow: only the exact strings `'true'`/`'TRUE'` (any case, trimmed) count. `'1'`, `'yes'` and the like
+ * are NOT accepted, because widening a flag reader is how `'false'`-adjacent values start meaning true somewhere down
+ * the line — and no corpus or UI has ever written them for this field.
+ */
+function isTruthyFlag(value) {
+    return (value === true ||
+        (typeof value === 'string' && value.trim().toLowerCase() === 'true'));
+}
+/** A step's own `key`/`name`/`type`, read defensively: a document is untrusted input. */
+function stepOf(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const step = raw;
+    const key = typeof step.key === 'string' ? step.key : undefined;
+    if (key === undefined || key === '')
+        return undefined;
+    /**
+     * A step the composer DELETES is not in the flow (Story 4.1 review, HIGH-2).
+     *
+     * `!CHECK_EXISTS_ITEMS` is the corpus's one such key — `001-projects/continental-cosmetics/…/QuickBooksCategoryPusher.override.yaml`.
+     * AD-33 rule 6 stops the `!` reaching an address, and this used to be the whole treatment: the node was still
+     * created, and `identitySegment` refusing the segment silently re-addressed it onto its PARENT STAGE. Three
+     * consequences, all real: `addressMatches` then made every sibling step a descendant of the phantom, so clicking
+     * it selected the entire stage; the node reported a raw `stepKey` no composed document contains, disagreeing with
+     * its own normalised address; and two removed steps in one stage collapsed onto one byte-identical address.
+     *
+     * Rule 6 was adopted so an address is never minted for a node the composer deletes. Skipping the step is the only
+     * reading of that which also declines to mint the NODE.
+     */
+    if (normalizeComponentKey(key)?.removes === true)
+        return undefined;
+    const type = typeof step.displayType === 'string'
+        ? step.displayType
+        : typeof step.type === 'string'
+            ? step.type
+            : undefined;
+    const name = typeof step.name === 'string' && step.name.trim() !== ''
+        ? step.name.trim()
+        : undefined;
+    // `rootStep` is the worker spelling; `root` is the frontend's. Both accepted, since a document may use either.
+    //
+    // The STRING `'true'` counts. A YAML corpus writes a bare `rootStep: true` (5,060 of 5,060 occurrences), so a
+    // boolean-only test looks complete when read against the templates — but a profile served to a UI as JSON can carry
+    // the quoted form, and `dashboard-v2` types the field as `rootStep?: string` and tested `String(s.rootStep) ===
+    // 'true'` in the emitter this package replaced. A coercion like that is written because the strict test failed.
+    // Missing it does not error: entry detection just silently picks the first declared step, so an inter-stage arrow
+    // lands on the wrong node and the diagram still looks plausible.
+    const isEntry = isTruthyFlag(step.rootStep) || isTruthyFlag(step.root);
+    return {
+        key,
+        ...(step.next !== undefined ? { next: step.next } : {}),
+        ...(type !== undefined ? { stepType: type, type } : {}),
+        ...(step.data !== undefined ? { data: step.data } : {}),
+        ...(step.onError !== undefined ? { onError: step.onError } : {}),
+        /**
+         * `fromStep`, from the step or from its `data` — an Exception step is authored both ways.
+         *
+         * `data.fromStep` is the RUNTIME's own spelling: `ErrorExecutor` reads `$.data.fromStep` first and falls back to
+         * `$.fromStep`, and every `StepIteratorTests` fixture writes it under `data`. The report's `toFlowStep` accepted
+         * both; this read only the top level, so an Exception step authored the runtime's way lost its `|"Exception"|`
+         * back-edge entirely (Story 4.6 review, L1).
+         */
+        ...(typeof step.fromStep === 'string'
+            ? { fromStep: step.fromStep }
+            : typeof step.data?.fromStep ===
+                'string'
+                ? { fromStep: step.data.fromStep }
+                : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(isEntry ? { isEntry: true } : {}),
+    };
+}
+/**
+ * ⛔ `branchOf` was DELETED here (Story 4.1 review, MEDIUM-2).
+ *
+ * It decided independently of `routeEdges` what "branches" means, and the two disagreed: an `IF` whose `data`
+ * carried only `{ expression }` was meant to route through its `next` while `branchOf` synthesised a diamond anyway —
+ * an orphan node asserting a decision the document does not make. Two functions owning one concept, with only one of
+ * them the authority.
+ *
+ * ⚠️ **Correction (Story 4.7 review).** The route graph did NOT in fact route that case through `next` — it drew the
+ * diamond and dropped the `next` edge, orphaning its target, so this paragraph described the intent rather than the
+ * behaviour for two stories. `routeGraph.ts` now has the fallback its flat twin `routes.ts` always had. Deleting
+ * `branchOf` was still the right call; the claim about what survived it was just untrue until now.
+ *
+ * `routeGraph` is now that single authority: it decides where a junction belongs *while* placing the edge that
+ * reaches it, so a junction cannot exist without an arrow into it and an arrow cannot bypass one.
+ */
+/**
+ * The flow model and the node index for one component.
+ *
+ * One entry point, one route graph. Nodes and edges are both derived from that graph before returning, so neither
+ * can contain something the other does not know about — see the note on "one pass" above.
+ */
+export function workerFlow(input) {
+    const { collection, component, componentId, locate } = input;
+    const base = nodeAddress([
+        keySegment(collection),
+        identitySegment(componentId, 'id'),
+    ]);
+    const stages = stagesPresent(collection, component);
+    const nodes = [];
+    const edges = [];
+    const duplicates = [];
+    for (const stage of stages) {
+        const raw = component[stage.key];
+        const parsed = raw.map(stepOf).filter((s) => s !== undefined);
+        /**
+         * Steps are DE-DUPLICATED by key, and the duplicates are dropped (Story 4.1 review, HIGH-1).
+         *
+         * One corpus pusher — `001-projects/ru9/rubaby/partials/Pusher-SapoOmniOrder.yaml` — declares `key: CREATE`
+         * twice in one `pushSteps`, and it survives composition. Addressing both produced two nodes with ONE address,
+         * the second step's route attributed to the first node, and `addressForRenderedId` returning `undefined` — a
+         * click resolving to nothing, which is the failure this model's own docblock calls invisible until someone
+         * clicks.
+         *
+         * Dropped rather than disambiguated with a counter: a counter is what AD-33 exists to remove, and the runtime
+         * itself cannot address the second `CREATE` either — `next: CREATE` names the first. Reported so the caller can
+         * surface it, because a silently smaller graph is its own defect.
+         */
+        const steps = [];
+        for (const step of parsed) {
+            if (steps.some((s) => s.key === step.key)) {
+                duplicates.push({ stage: stage.key, key: String(step.key) });
+                continue;
+            }
+            steps.push(step);
+        }
+        /** Each step's address, and the map every edge end is resolved through. */
+        const addressOf = new Map();
+        for (const step of steps) {
+            addressOf.set(step.key, nodeAddress([
+                keySegment(base),
+                keySegment(stage.key),
+                identitySegment(step.key, 'key'),
+            ]));
+        }
+        const graph = routeGraph(steps);
+        const junctionOf = new Map();
+        for (const step of steps) {
+            const address = addressOf.get(step.key);
+            nodes.push({
+                address,
+                runtime: 'worker',
+                stage: stage.key,
+                ...(step.type !== undefined ? { type: step.type } : {}),
+                ...(step.name !== undefined ? { name: step.name } : {}),
+                ...(step.isEntry === true ? { isEntry: true } : {}),
+                // A step is never itself the diamond — see `decides`.
+                decides: false,
+                stepKey: step.key,
+                ...(locate?.({
+                    collection,
+                    stage: stage.key,
+                    stepKey: step.key,
+                    address,
+                }) ?? {}),
+            });
+        }
+        for (const point of graph.junctions) {
+            const owner = addressOf.get(point.owner);
+            if (owner === undefined)
+                continue;
+            const address = junctionAddress(owner, point.path);
+            junctionOf.set(`${point.owner} ${point.path.join(' ')}`, address);
+            nodes.push({
+                address,
+                runtime: 'worker',
+                stage: stage.key,
+                decides: point.kind !== 'unknown',
+                label: point.label,
+                junction: point.kind,
+                owner,
+                ...(locate?.({
+                    collection,
+                    stage: stage.key,
+                    address,
+                    // The step KEY, not its address: a locator reads a document, and the document names steps by key. It has the
+                    // address too (in `address`'s own prefix) and needs no help deriving it.
+                    ownerStepKey: point.owner,
+                    path: point.path,
+                }) ?? {}),
+            });
+        }
+        /** An edge end, as an address. */
+        const endAddress = (end) => end.kind === 'step'
+            ? addressOf.get(end.key)
+            : junctionOf.get(`${end.owner} ${end.path.join(' ')}`);
+        for (const edge of graph.edges) {
+            const from = endAddress(edge.from);
+            const to = endAddress(edge.to);
+            // Both ends are always indexed by construction; the guard keeps a dropped duplicate from producing a
+            // half-addressed edge rather than none.
+            if (from === undefined || to === undefined)
+                continue;
+            edges.push({
+                from,
+                to,
+                ...(edge.label !== undefined ? { label: edge.label } : {}),
+                stage: stage.key,
+            });
+        }
+    }
+    return {
+        address: base,
+        collection,
+        ...(collection === 'pullers'
+            ? { pullerKind: pullerKindOf(component) }
+            : {}),
+        stages,
+        stageEdges: stageEdges(collection, component),
+        nodes,
+        edges,
+        ...(duplicates.length > 0 ? { duplicateStepKeys: duplicates } : {}),
+    };
+}
+//# sourceMappingURL=flow.js.map

package/dist/flow.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The flow model for a worker component — one computation, every consumer (FR-15, FR-17, NFR-1).
+ *
+ * Three implementations answered *"what is this component's flow?"* independently: the CLI's report renderer, the
+ * VS Code extension's preview, and dashboard-v2's diagram. That is the defect Epic 4 exists to remove, and
+ * `golden-flows/` is the pre-migration measurement taken so each difference becomes a deliberate verdict rather
+ * than a surprise.
+ *
+ * ⛔ **CORE (AD-3)**: no filesystem, no `vscode`, no Node builtin. The extension bundles this into a web-worker host
+ * where none of them exist, so an authored file and location arrive as data.
+ *
+ * ⚠️ `check:web-bundle` is that rule's gate **in the extension's repo, not in this one** (Story 4.1 review, L1):
+ * Task 1 called it "a gate" and no such script exists here. What holds the rule up on this side is
+ * `lint:boundaries` (which classifies this package `core` from `package.json`'s `hexasync.layer`, itself now guarded
+ * by `apps/cli/src/__tests__/packageLayer.spec.ts`) plus the one-dependency manifest. The bundle check runs when the
+ * extension consumes this in Story 4.5.
+ */
+export { WORKER_STAGES, stagesPresent, stageEdges, pullerKindOf, type StagePhase, type StageDefinition, type WorkerCollection, type PullerKind, type StageEdge, } from './stages.js';
+export { routeEdges, quotedKeys, looksLikeExpression, type RoutableStep, type RouteEdge, } from './routes.js';
+export { workerFlow, type WorkerFlow, type WorkerFlowInput, type FlowNode, type FlowEdgeAddressed, type NodeLocation, type LocateRequest, } from './flow.js';
+export { routeGraph, junctionAddress, type RouteGraph, type Junction, type JunctionKind, type GraphEdge, type EdgeEnd, } from './routeGraph.js';
+export { renderMermaid, renderMarkdown } from './render.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,UAAU,EACV,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,UAAU,EACV,eAAe,EACf,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,OAAO,GACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * The flow model for a worker component — one computation, every consumer (FR-15, FR-17, NFR-1).
+ *
+ * Three implementations answered *"what is this component's flow?"* independently: the CLI's report renderer, the
+ * VS Code extension's preview, and dashboard-v2's diagram. That is the defect Epic 4 exists to remove, and
+ * `golden-flows/` is the pre-migration measurement taken so each difference becomes a deliberate verdict rather
+ * than a surprise.
+ *
+ * ⛔ **CORE (AD-3)**: no filesystem, no `vscode`, no Node builtin. The extension bundles this into a web-worker host
+ * where none of them exist, so an authored file and location arrive as data.
+ *
+ * ⚠️ `check:web-bundle` is that rule's gate **in the extension's repo, not in this one** (Story 4.1 review, L1):
+ * Task 1 called it "a gate" and no such script exists here. What holds the rule up on this side is
+ * `lint:boundaries` (which classifies this package `core` from `package.json`'s `hexasync.layer`, itself now guarded
+ * by `apps/cli/src/__tests__/packageLayer.spec.ts`) plus the one-dependency manifest. The bundle check runs when the
+ * extension consumes this in Story 4.5.
+ */
+export { WORKER_STAGES, stagesPresent, stageEdges, pullerKindOf, } from './stages.js';
+export { routeEdges, quotedKeys, looksLikeExpression, } from './routes.js';
+export { workerFlow, } from './flow.js';
+export { routeGraph, junctionAddress, } from './routeGraph.js';
+export { renderMermaid, renderMarkdown } from './render.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,YAAY,GAMb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,UAAU,EACV,mBAAmB,GAGpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,GAOX,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,UAAU,EACV,eAAe,GAMhB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/render.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `renderMermaid` / `renderMarkdown` for a worker flow — Story 4.3, `PACKAGE-CONTRACT.md` §5.
+ *
+ * Thin by design. The emission rules live in `hexasync-template-model`'s `flowRender`, because AD-21 forbids the two
+ * flow packages importing each other and the shared half has to live somewhere neither owns. This file's whole job is
+ * to say what a WORKER node looks like: which shape it takes, what its label reads, and how stages become subgraphs.
+ */
+import { type RenderOptions } from '@beehexa/hexasync-template-model';
+import type { WorkerFlow } from './flow.js';
+export declare function renderMermaid(flow: WorkerFlow, opts?: RenderOptions): string;
+/**
+ * Markdown for one component — `(flow, opts)`, matching the frontend twin and `PACKAGE-CONTRACT.md` §5.
+ *
+ * ⛔ This took `(flow, title, opts)` (Story 4.3 review, MEDIUM-1). §5 declares `renderMarkdown(model, opts?)`
+ * *"exported from both flow packages"*, so a caller written to the contract passed the options object into the `title`
+ * slot and it reached `escapeLabel`: **`TypeError: value.replace is not a function`**. TypeScript caught it for TS
+ * consumers; JS consumers and the "one renderer set, callable uniformly" premise did not.
+ *
+ * The title now comes from the model, which has everything needed: the collection and the component's authored id. A
+ * caller wanting its own wording passes `title`.
+ */
+export declare function renderMarkdown(flow: WorkerFlow, opts?: RenderOptions & {
+    readonly title?: string;
+}): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAmI5C,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE,aAAkB,GACvB,MAAM,CAMR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE,aAAa,GAAG;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACrD,MAAM,CAQR"}