@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/analysis/flow-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-tree.d.ts","sourceRoot":"","sources":["../../src/analysis/flow-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE7C,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CAAE,CA4BhG"}

package/vendor/dynamic-workflow/analysis/flow-tree.js

@@ -0,0 +1,33 @@
+/** Rebuild the tree from the leaf stream, and index every region by id. */
+export function buildTree(trace) {
+    const byId = new Map();
+    for (const region of trace.regions) {
+        byId.set(region.id, { children: [], first: Number.POSITIVE_INFINITY, region, type: "region" });
+    }
+    for (const region of trace.regions) {
+        if (region.parent === undefined)
+            continue;
+        byId.get(region.parent)?.children.push(byId.get(region.id));
+    }
+    trace.events.forEach((event, index) => {
+        const home = event.regions[event.regions.length - 1] ?? trace.root;
+        byId.get(home)?.children.push({ event, index, type: "leaf" });
+    });
+    // Bottom-up: each child is ordered (and its `first` cached) BEFORE the parent sorts, so
+    // the comparator reads a number instead of re-walking the subtree. A comparator that
+    // called `order(child)` itself would re-sort and re-walk the whole subtree on every
+    // comparison — exponential in nesting depth (a 2,500-region trace of inlined helpers
+    // took 45 s before the projection had produced a single edge).
+    const firstOf = (node) => (node.type === "leaf" ? node.index : node.first);
+    const order = (node) => {
+        if (node.type === "leaf")
+            return node.index;
+        for (const child of node.children)
+            node.first = Math.min(node.first, order(child));
+        node.children.sort((a, b) => firstOf(a) - firstOf(b));
+        return node.first;
+    };
+    const root = byId.get(trace.root);
+    order(root);
+    return { byId, root };
+}

package/vendor/dynamic-workflow/analysis/graph.d.ts

@@ -0,0 +1,5 @@
+import type { AnalysisCore } from "./core.js";
+import type { SiteGraph } from "./types.js";
+/** Project the site graph off the core. */
+export declare function projectSiteGraph(core: AnalysisCore): SiteGraph;
+//# sourceMappingURL=graph.d.ts.map

package/vendor/dynamic-workflow/analysis/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/analysis/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAA6B,MAAM,WAAW,CAAC;AAGzE,OAAO,KAAK,EAAuB,SAAS,EAAY,MAAM,YAAY,CAAC;AAuB3E,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAwI9D"}

package/vendor/dynamic-workflow/analysis/graph.js

@@ -0,0 +1,199 @@
+import { isActorSite } from "./core.js";
+/**
+ * The site-graph projection: graph assembly and edge emission over the
+ * {@link AnalysisCore} —
+ * data edges from each label's site to the sink reading it, the
+ * pairwise context relation over asks sharing an actor, dedup, source completion,
+ * and relay pruning.
+ *
+ * A PURE projection: everything
+ * position- or checker-shaped — `within` containment, fan-out ordinal renames,
+ * artifact types — was digested at core minting (interpret.ts), so this module
+ * never imports `typescript` and never sees the AST. The core's ids are final
+ * (`fan-out#N`), and its type keys match.
+ */
+const SOURCE_NODE = { id: "source", kind: "source", label: "source" };
+const SINK_NODE = { id: "sink", kind: "sink", label: "sink" };
+/** Project the site graph off the core. */
+export function projectSiteGraph(core) {
+    const { facts, sites, types } = core;
+    const fanoutNodes = sites.fanouts.map((site) => {
+        const artifactType = types.siteType.get(site.id);
+        return {
+            id: site.id,
+            kind: "fan-out",
+            label: site.label,
+            loc: site.loc,
+            order: site.order,
+            ...(site.within === undefined ? {} : { within: site.within }),
+            ...(artifactType === undefined ? {} : { artifactType }),
+        };
+    });
+    // Ask nodes carry their actor-lane membership: the deduped actor site ids their
+    // receiver resolves to, ordered by actor source order.
+    const actorOrder = new Map(sites.actors.map((actor) => [actor.id, actor.order]));
+    const askActors = (id) => [...new Set((facts.askActor.get(id) ?? []).map((occ) => occ.site))].sort((a, b) => (actorOrder.get(a) ?? 0) - (actorOrder.get(b) ?? 0));
+    const siteNodes = [
+        ...sites.asks.map((site) => {
+            const actors = askActors(site.id);
+            const artifactType = types.siteType.get(site.id);
+            return {
+                id: site.id,
+                kind: "ask",
+                label: site.label,
+                ...(site.labelPattern === undefined ? {} : { labelPattern: site.labelPattern }),
+                loc: site.loc,
+                order: site.order,
+                ...(actors.length > 0 ? { actors } : {}),
+                ...(site.within === undefined ? {} : { within: site.within }),
+                ...(artifactType === undefined ? {} : { artifactType }),
+            };
+        }),
+        ...sites.worldReads.map((site) => plainNode(site, "world-read", types)),
+        ...sites.joins.map((site) => plainNode(site, "join", types)),
+        ...fanoutNodes,
+        // 开放的留白是一个节点：名字是标签，类型实参是它的产物类型（docs/analysis.md「Sites」）。
+        ...sites.holes.map((site) => plainNode({ ...site, label: site.name }, "hole", types)),
+    ].sort((a, b) => a.order - b.order);
+    const edges = [];
+    // Resolve the producer's artifact type for a data edge. Port refinement applies ONLY
+    // to edges OUT OF a join (the from-side is a join and the occurrence selected an
+    // element port): the join's per-element type, falling back to its whole tuple/array
+    // type when that element's type is unknown. Edges INTO a join (`intoJoin`) also carry
+    // a `port`, but there it is the join's INPUT position — the edge takes the producer's
+    // (from-side) whole artifact type, never a port lookup.
+    const edgeType = (from, occ, intoJoin) => {
+        const whole = types.siteType.get(from);
+        if (!intoJoin && occ.port !== undefined) {
+            const ports = types.joinPortTypes.get(from);
+            if (ports !== undefined)
+                return ports[occ.port] ?? whole;
+        }
+        return whole;
+    };
+    const dataEdge = (from, to, occ, intoJoin = false) => {
+        const type = edgeType(from, occ, intoJoin);
+        edges.push({
+            exact: occ.exact,
+            from,
+            kind: "data",
+            to,
+            ...(occ.port === undefined ? {} : { port: occ.port }),
+            ...(type === undefined ? {} : { type }),
+        });
+    };
+    // 1. Data edges into every sink.
+    for (const [askId, occs] of facts.askData)
+        for (const occ of occs)
+            dataEdge(occ.site, askId, occ);
+    for (const [worldId, occs] of facts.worldReadData)
+        for (const occ of occs)
+            dataEdge(occ.site, worldId, occ);
+    for (const [joinId, occs] of facts.joinIn)
+        for (const occ of occs)
+            dataEdge(occ.site, joinId, occ, true);
+    for (const [fanoutId, occs] of facts.fanoutIn)
+        for (const occ of occs)
+            dataEdge(occ.site, fanoutId, occ);
+    for (const [holeId, occs] of facts.holeData)
+        for (const occ of occs)
+            dataEdge(occ.site, holeId, occ);
+    for (const occ of facts.returnData)
+        dataEdge(occ.site, "sink", occ);
+    // 2. Context edges: pairwise over asks whose actor sets intersect, earlier -> later.
+    const askOrder = new Map(sites.asks.map((site) => [site.id, site.order]));
+    const contextAsks = sites.asks
+        .map((site) => ({ actors: facts.askActor.get(site.id) ?? [], id: site.id }))
+        .filter((entry) => entry.actors.length > 0);
+    for (let i = 0; i < contextAsks.length; i += 1) {
+        for (let j = i + 1; j < contextAsks.length; j += 1) {
+            const a = contextAsks[i];
+            const b = contextAsks[j];
+            if (a === undefined || b === undefined)
+                continue;
+            if (!actorsIntersect(a.actors, b.actors))
+                continue;
+            const [from, to] = (askOrder.get(a.id) ?? 0) <= (askOrder.get(b.id) ?? 0) ? [a.id, b.id] : [b.id, a.id];
+            edges.push({ exact: contextExact(a.actors, b.actors), from, kind: "context", to });
+        }
+    }
+    // 3. Deduplicate by (from, to, kind, port); exact is the OR over witnesses.
+    const deduped = dedupeEdges(edges);
+    // 4. Source completion: ask/world-read/fan-out nodes with no incoming data edge.
+    const hasIncomingData = new Set();
+    for (const edge of deduped)
+        if (edge.kind === "data")
+            hasIncomingData.add(edge.to);
+    for (const node of siteNodes) {
+        if (node.kind === "join")
+            continue;
+        if (!hasIncomingData.has(node.id)) {
+            deduped.push({ exact: true, from: "source", kind: "data", to: node.id });
+        }
+    }
+    // 5. Prune relay nodes (join / fan-out) that ended up with no incident edges.
+    const incident = new Set();
+    for (const edge of deduped) {
+        incident.add(edge.from);
+        incident.add(edge.to);
+    }
+    const keptNodes = siteNodes.filter((node) => (node.kind !== "join" && node.kind !== "fan-out") || incident.has(node.id));
+    // 6. Node order: source, sites in source order (fan-outs merged by order), sink.
+    const nodes = [SOURCE_NODE, ...keptNodes.map(stripOrder), SINK_NODE];
+    const actors = sites.actors.map((actor) => ({
+        id: actor.id,
+        loc: actor.loc,
+        ...(actor.name === undefined ? {} : { name: actor.name }),
+        ...(actor.namePattern === undefined ? {} : { namePattern: actor.namePattern }),
+        ...(actor.within === undefined ? {} : { within: actor.within }),
+    }));
+    return { actors, edges: deduped, nodes };
+}
+function plainNode(site, kind, types) {
+    const artifactType = types.siteType.get(site.id);
+    return {
+        id: site.id,
+        kind,
+        label: site.label,
+        loc: site.loc,
+        order: site.order,
+        ...(site.within === undefined ? {} : { within: site.within }),
+        ...(artifactType === undefined ? {} : { artifactType }),
+    };
+}
+function stripOrder({ order: _order, ...node }) {
+    return node;
+}
+function actorsIntersect(a, b) {
+    const sites = new Set(a.map((occ) => occ.site));
+    return b.some((occ) => sites.has(occ.site));
+}
+/** Context exact iff both actor sets are the same singleton and both occs are exact. */
+function contextExact(a, b) {
+    if (a.length !== 1 || b.length !== 1)
+        return false;
+    const [oa] = a;
+    const [ob] = b;
+    return oa !== undefined && ob !== undefined && oa.site === ob.site && oa.exact && ob.exact;
+}
+function dedupeEdges(edges) {
+    const byKey = new Map();
+    for (const edge of edges) {
+        if (isActorSite(edge.from) && edge.kind === "data")
+            continue; // actor labels never make data edges
+        const key = `${edge.from}|${edge.to}|${edge.kind}|${edge.port ?? ""}`;
+        const existing = byKey.get(key);
+        if (existing === undefined) {
+            byKey.set(key, { ...edge });
+        }
+        else {
+            if (edge.exact && !existing.exact)
+                existing.exact = true;
+            // Type is deterministic per (from, port), so witnesses agree; keep the first
+            // non-undefined one (a widened witness path can lack the type another kept).
+            if (existing.type === undefined && edge.type !== undefined)
+                existing.type = edge.type;
+        }
+    }
+    return [...byKey.values()];
+}

package/vendor/dynamic-workflow/analysis/handoff-graph.d.ts

@@ -0,0 +1,48 @@
+import type { AnalysisCore } from "./core.js";
+import type { CausalityGraph } from "./causality-graph.js";
+import type { SiteGraph } from "./types.js";
+/**
+ * 交接图：板面第二层的主体。每个阶段
+ * 的**参与者**是一张卡——该阶段里有 step 的每条车道一张（子代理、工作区、未解析），fan-out
+ * 家族在基数已知时按成员出卡；卡之间的**交接**边是因果图（已按类型归约）的阶段内边按卡取商、
+ * 去自环、再做无类型贪心不可约归约的结果。与其他每一种箭头同义：runs after。
+ *
+ * 一个 PURE 投影：只读 core（fan-out 基数与 actor 的 `within` 链）、因果图（step 的车道、
+ * 阶段、边的 kind）与站点图（`data` 边的产物类型，检视器素材）。不 import `typescript`。
+ */
+export interface HandoffParticipant {
+    /** `${phase}:${lane}`，家族成员 `${phase}:${lane}[${index}]`。 */
+    id: string;
+    /** 阶段 id；脚本无阶段词汇时恒为 `unphased`。 */
+    phase: string;
+    /** 车道 id：actor 站点 id、`workspace` 或 `unknown`。 */
+    lane: string;
+    /** 该阶段内落在这条车道上的 step id，源码序，至少一个。 */
+    steps: string[];
+    /** 字面量基数展开出的成员。 */
+    member?: {
+        index: number;
+        of: number;
+    };
+    /** 基数未知（或超过展开上限）的家族：一张卡代表全部成员。 */
+    many?: true;
+}
+export interface Handoff {
+    from: string;
+    to: string;
+    /** 全部贡献边都是循环回边（carry）。 */
+    back?: true;
+    /** 阶段内 from 卡的站点 → to 卡的站点的 `data` 边产物类型，按贡献序去重。 */
+    types?: string[];
+}
+export interface HandoffGraph {
+    participants: HandoffParticipant[];
+    handoffs: Handoff[];
+}
+/** 无阶段词汇时的唯一阶段 id；与因果图的兜底阶段同名。 */
+export declare const UNPHASED = "unphased";
+/** 家族按成员出卡的上限：多重性超过它按 `many` 处理。 */
+export declare const FANOUT_EXPAND_CAP = 8;
+/** Project the hand-off graph off the core, the causality graph and the site graph. */
+export declare function projectHandoffGraph(core: AnalysisCore, causality: CausalityGraph, sites: SiteGraph): HandoffGraph;
+//# sourceMappingURL=handoff-graph.d.ts.map

package/vendor/dynamic-workflow/analysis/handoff-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-graph.d.ts","sourceRoot":"","sources":["../../src/analysis/handoff-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAQ,MAAM,sBAAsB,CAAC;AAGjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;GAQG;AAEH,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,mBAAmB;IACnB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,kCAAkC;IAClC,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,kBAAkB,EAAE,CAAC;IACnC,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,kCAAkC;AAClC,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,oCAAoC;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAQnC,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,YAAY,CAgIjH"}

package/vendor/dynamic-workflow/analysis/heap-ops.d.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+/**
+ * In-place heap-mutation transfers: `Object.assign` and the receiver-mutating array /
+ * collection methods (`push`, `Map.set`, …). Extracted from calls.ts (pure move, no
+ * behavior change) to keep that file under the line cap.
+ */
+/** `Object.assign` — a free function (not a method) that mutates its target in place. */
+export declare function isObjectAssign(access: ts.PropertyAccessExpression): boolean;
+export declare function handleHeapMutator(ev: Evaluator, node: ts.CallExpression, access: ts.PropertyAccessExpression, ctx: EvalContext): AbstractValue;
+/** `Object.assign(target, ...sources)`: merge each source into the target's live value. */
+export declare function handleObjectAssign(ev: Evaluator, node: ts.CallExpression, ctx: EvalContext): AbstractValue;
+//# sourceMappingURL=heap-ops.d.ts.map

package/vendor/dynamic-workflow/analysis/heap-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-ops.d.ts","sourceRoot":"","sources":["../../src/analysis/heap-ops.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAqE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEpH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;GAIG;AAEH,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC,wBAAwB,GAAG,OAAO,CAE3E;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,SAAS,EACb,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,MAAM,EAAE,EAAE,CAAC,wBAAwB,EACnC,GAAG,EAAE,WAAW,GACf,aAAa,CAyBf;AAED,2FAA2F;AAC3F,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAuB1G"}

package/vendor/dynamic-workflow/analysis/heap-ops.js

@@ -0,0 +1,70 @@
+import ts from "typescript";
+import { adoptFields, collapse, emptyValue, mergeInto, replayMayAliasMerge } from "./domain.js";
+import { mergeIntoRootIdentifier } from "./assign.js";
+/**
+ * In-place heap-mutation transfers: `Object.assign` and the receiver-mutating array /
+ * collection methods (`push`, `Map.set`, …). Extracted from calls.ts (pure move, no
+ * behavior change) to keep that file under the line cap.
+ */
+/** `Object.assign` — a free function (not a method) that mutates its target in place. */
+export function isObjectAssign(access) {
+    return ts.isIdentifier(access.expression) && access.expression.text === "Object" && access.name.text === "assign";
+}
+export function handleHeapMutator(ev, node, access, ctx) {
+    // Resolve the receiver to its LIVE value so a mutator on a nested place
+    // (`wrap.items.push(x)`, `state.map.set(k, v)`) writes the shared container, visible
+    // through every alias. `Map.set`/`Set.add` fold their args in the same way as the
+    // array mutators (key taint included — a sound over-approximation).
+    const container = ev.resolvePlace(access.expression, true);
+    // An unresolvable receiver (computed element access `state.buffers[i].push(x)`,
+    // a call result `log().push(x)`) used to skip BOTH halves of the transfer — the argument
+    // taint merged nowhere (a silent total drop of the flow) and the receiver expression was
+    // never evaluated, so a facade sink sitting in receiver position was never visited at
+    // all. Mirror writeTarget's unresolvable-receiver path (assign.ts): evaluate the receiver
+    // for effect and smear each argument into the chain's root identifier.
+    if (container === undefined)
+        ev.evalExpr(access.expression, ctx);
+    for (const arg of node.arguments) {
+        const argVal = collapse(ev.evalExpr(arg, ctx));
+        if (container !== undefined) {
+            if (mergeInto(container, argVal))
+                ev.s.changed = true;
+            // A conditional-binding / join-element receiver mutated in place reaches every
+            // candidate place it may BE (weak, inexact).
+            if (replayMayAliasMerge(container, argVal))
+                ev.s.changed = true;
+        }
+        else {
+            mergeIntoRootIdentifier(ev, access.expression, argVal);
+        }
+    }
+    return emptyValue();
+}
+/** `Object.assign(target, ...sources)`: merge each source into the target's live value. */
+export function handleObjectAssign(ev, node, ctx) {
+    const [targetArg, ...sources] = node.arguments;
+    if (targetArg === undefined)
+        return emptyValue();
+    const targetLive = ev.resolvePlace(targetArg, true);
+    const result = ev.evalExpr(targetArg, ctx); // Object.assign returns the target
+    for (const src of sources) {
+        const srcPlace = ev.resolvePlace(src);
+        const srcVal = srcPlace ?? ev.evalExpr(src, ctx);
+        if (targetLive !== undefined) {
+            // Object.assign shallow-copies: an object-valued source field is copied by
+            // REFERENCE, so after the call `target.f` and `src.f` are one shared object and a
+            // write through either is visible through the other. When the source is a place,
+            // adopt its field objects by reference; container-level occs (and any non-place
+            // source, e.g. `{ f: secret }`) still weak-merge in as before, so
+            // `Object.assign(target, { f: secret })` makes `target.f` observe secret.
+            // The old deep `mergeInto` materialized independent target
+            // fields, so a mutation through target's shared sub-object was invisible via src.
+            if (srcPlace !== undefined && adoptFields(targetLive, srcPlace))
+                ev.s.changed = true;
+            if (mergeInto(targetLive, srcVal))
+                ev.s.changed = true;
+        }
+        mergeInto(result, srcVal);
+    }
+    return result;
+}

package/vendor/dynamic-workflow/analysis/hole-id.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 留白站点 id（docs/analysis.md「Sites」的 Hole sites 段）：`hole#<8 位十六进制>`，键是留白的
+ * **名字**（FNV-1a 32 位，按 Unicode 码点，名字先 trim），与它嵌套在哪一层无关。
+ *
+ * 为什么不是位置计数器：补全在脚本中间插入代码，任何按位置编号的方案都会让插入点之后的留白
+ * 改号，而 journal 键、ask spec、站点阶段表都靠 id 在补全后幸存。为什么不再是外层 id 前缀
+ * （2026-09-28 之前的 `hole#1/hole#1/ask#1`）：每嵌套一层长 7 个字符，接龙式补全（每一步在
+ * 结尾再留一个留白）八九步就顶到协议里 64 字符的 id 上界，而这条上界是对的——协议载荷必须
+ * 有界。名字在整个有效脚本里唯一（9012），所以名字键既在补全前后稳定，又不随深度增长。两个
+ * 不同名字撞到同一哈希由 9012 报出（32 位、一个脚本至多几十个留白，概率约 1e-7），从不猜。
+ *
+ * 函数体里的站点仍带 `<holeId>/` 前缀（`hole#a91f3c07/ask#1`），但只带**一层**：体内再留的
+ * 留白自己又是 `hole#<hash>`，它体内的站点带它自己的前缀。嵌套关系不再写在 id 里，而是站点
+ * 表上的 `fill` 字段（HoleSite.fill：包着它的那个留白）。
+ */
+/** 留白 id 里十六进制的位数；协议侧的 id 上界（64）与它无关，这里只是让 id 短而固定。 */
+export declare const HOLE_ID_HEX_LENGTH = 8;
+/** 留白站点 id 的形状。UI 与稳定性复核靠它认出「这个 id 是一个留白」。 */
+export declare const HOLE_SITE_ID_PATTERN: RegExp;
+/** 从留白的名字铸站点 id。名字先 trim（唯一性也按 trim 后比较）。 */
+export declare function holeSiteId(name: string): string;
+export declare function isHoleSiteId(id: string): boolean;
+/**
+ * 一个站点 id 所属的留白：`hole#x/ask#1` → `hole#x`；一个留白自己的 id 或体外的 id → undefined。
+ * 只看一层前缀（id 里只有一层）；留白自己属于哪个留白要问站点表的 `fill`。
+ */
+export declare function holePrefixOf(siteId: string): string | undefined;
+//# sourceMappingURL=hole-id.d.ts.map

package/vendor/dynamic-workflow/analysis/hole-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hole-id.d.ts","sourceRoot":"","sources":["../../src/analysis/hole-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,uDAAuD;AACvD,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,8CAA8C;AAC9C,eAAO,MAAM,oBAAoB,QAAwB,CAAC;AAE1D,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG/D"}

package/vendor/dynamic-workflow/analysis/hole-id.js

@@ -0,0 +1,41 @@
+/**
+ * 留白站点 id（docs/analysis.md「Sites」的 Hole sites 段）：`hole#<8 位十六进制>`，键是留白的
+ * **名字**（FNV-1a 32 位，按 Unicode 码点，名字先 trim），与它嵌套在哪一层无关。
+ *
+ * 为什么不是位置计数器：补全在脚本中间插入代码，任何按位置编号的方案都会让插入点之后的留白
+ * 改号，而 journal 键、ask spec、站点阶段表都靠 id 在补全后幸存。为什么不再是外层 id 前缀
+ * （2026-09-28 之前的 `hole#1/hole#1/ask#1`）：每嵌套一层长 7 个字符，接龙式补全（每一步在
+ * 结尾再留一个留白）八九步就顶到协议里 64 字符的 id 上界，而这条上界是对的——协议载荷必须
+ * 有界。名字在整个有效脚本里唯一（9012），所以名字键既在补全前后稳定，又不随深度增长。两个
+ * 不同名字撞到同一哈希由 9012 报出（32 位、一个脚本至多几十个留白，概率约 1e-7），从不猜。
+ *
+ * 函数体里的站点仍带 `<holeId>/` 前缀（`hole#a91f3c07/ask#1`），但只带**一层**：体内再留的
+ * 留白自己又是 `hole#<hash>`，它体内的站点带它自己的前缀。嵌套关系不再写在 id 里，而是站点
+ * 表上的 `fill` 字段（HoleSite.fill：包着它的那个留白）。
+ */
+const FNV_OFFSET = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+/** 留白 id 里十六进制的位数；协议侧的 id 上界（64）与它无关，这里只是让 id 短而固定。 */
+export const HOLE_ID_HEX_LENGTH = 8;
+/** 留白站点 id 的形状。UI 与稳定性复核靠它认出「这个 id 是一个留白」。 */
+export const HOLE_SITE_ID_PATTERN = /^hole#[0-9a-f]{8}$/u;
+/** 从留白的名字铸站点 id。名字先 trim（唯一性也按 trim 后比较）。 */
+export function holeSiteId(name) {
+    let hash = FNV_OFFSET;
+    for (const char of name.trim()) {
+        hash ^= char.codePointAt(0) ?? 0;
+        hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+    return `hole#${hash.toString(16).padStart(HOLE_ID_HEX_LENGTH, "0")}`;
+}
+export function isHoleSiteId(id) {
+    return HOLE_SITE_ID_PATTERN.test(id);
+}
+/**
+ * 一个站点 id 所属的留白：`hole#x/ask#1` → `hole#x`；一个留白自己的 id 或体外的 id → undefined。
+ * 只看一层前缀（id 里只有一层）；留白自己属于哪个留白要问站点表的 `fill`。
+ */
+export function holePrefixOf(siteId) {
+    const cut = siteId.indexOf("/");
+    return cut < 0 ? undefined : siteId.slice(0, cut);
+}

package/vendor/dynamic-workflow/analysis/hole-sites.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 留白站点（docs/dynamic-workflow/authoring.md「Holes: `hole<T>()`」，docs/analysis.md「Sites」）：
+ * 站点的构造（三个重载的实参分派、tail 判定）与编译期规则 9012。
+ *
+ * 9012 的每条规则都是「运行期才炸不如现在就教改写」的那一类（与 9003 / 9004 同席）：
+ *  - 类型实参必须显式写出：T 是补全被检查的契约，推断出的 `unknown` 不是契约；
+ *  - 名字是非空字面量、≤128 字符，且在脚本的留白与阶段标记中**唯一**（嵌套补全也算）：名字
+ *    是留白的阶段名与每个界面显示的身份——两个标记同名是一个阶段，两个留白同名却是两个缺口；
+ *  - 调用必须被 await：没等值的留白会让脚本越过一个还没有值的缺口；
+ *  - 不能落在 fan-out **回调**里（数组方法的回调，提升与否都算）：元素并发跑，补全得在它们
+ *    已经在跑的时候写。`for...of` 体**允许**：带 await 的 for...of 是顺序的——第一轮停在留白，
+ *    补全到了，后面每轮跑函数体，正是「循环里的留白补全一次、每轮跑一遍」那一条；
+ *  - 函数体不得引用留白之后才声明的绑定：函数体是编译器不检查「先用后声明」的闭包，引用
+ *    后面的 `const` 到运行期才 TDZ 抛错；
+ *  - 函数体必须是内联的函数字面量：lowering 要把它原样打印成补全文本，一个标识符没有文本可打。
+ */
+import ts from "typescript";
+import type { CompileDiagnostic, ScriptLoc, WorkflowProgram } from "../compiler/compile.js";
+import type { HoleSite, SiteTable } from "./sites.js";
+/** 留白规则的诊断码（9001 = facade-siting、…、9010 = 模型名，顺延）。 */
+export declare const HOLE_CODE = 9012;
+/** 留白名的长度上限：与阶段名同规（docs/dynamic-workflow/authoring.md「Holes」）。 */
+export declare const HOLE_NAME_MAX_CHARS = 128;
+/**
+ * 从一个已按声明判定为 facade `hole` 的调用构造站点。三个重载的分派只看实参形状：第二实参是
+ * 函数字面量即函数体，否则是提示；第三实参（若有）是函数体。非字面量的函数体既不算提示也不算
+ * 函数体——留给 9012 报「必须内联」。
+ */
+export declare function holeSiteOf(call: ts.CallExpression, id: string, order: number, loc: ScriptLoc, funcDepth: number, fill: string | undefined): HoleSite;
+/** 校验收集到的留白站点。非空即脚本不可提交（`analyzeWorkflowScript` 与 misuse 同席）。 */
+export declare function collectHoleDiagnostics(workflow: WorkflowProgram, table: SiteTable): CompileDiagnostic[];
+//# sourceMappingURL=hole-sites.d.ts.map

package/vendor/dynamic-workflow/analysis/hole-sites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hole-sites.d.ts","sourceRoot":"","sources":["../../src/analysis/hole-sites.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC5F,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGtD,sDAAsD;AACtD,eAAO,MAAM,SAAS,OAAO,CAAC;AAE9B,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAmEvC;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,SAAS,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,QAAQ,CAmBV;AAkBD,iEAAiE;AACjE,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,SAAS,GACf,iBAAiB,EAAE,CA+DrB"}