@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/analysis/causality-order-settle.js

@@ -0,0 +1,263 @@
+import ts from "typescript";
+import { isFunctionLike } from "./sites.js";
+import { boundIdentifiers } from "./causality-order-functions.js";
+import { currentFrame, isVisiblySettled, joinStrands, } from "./causality-order-strands.js";
+const NO_CLAIM = { certain: [], maybe: [] };
+/**
+ * The iteration constructs (loop statements and iteration-candidate callbacks) that
+ * lexically enclose a node, memoized. Repetition is what makes a settle of a
+ * not-yet-issued step realizable, so this is the test {@link admissionOf} needs.
+ */
+function iterationAncestorsOf(state, node) {
+    const cached = state.iterationAncestorCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const out = new Set();
+    for (let cur = node.parent; cur !== undefined; cur = cur.parent) {
+        if (ts.isForStatement(cur) ||
+            ts.isForOfStatement(cur) ||
+            ts.isForInStatement(cur) ||
+            ts.isWhileStatement(cur) ||
+            ts.isDoStatement(cur) ||
+            state.candByCallback.has(cur) ||
+            state.eachCallbackFns.has(cur)) {
+            out.add(cur);
+        }
+    }
+    state.iterationAncestorCache.set(node, out);
+    return out;
+}
+/**
+ * THE TEMPORAL INVARIANT: a promise cannot settle before its request issues. The oracle
+ * is flow-INsensitive while this walk is flow-sensitive, so an occurrence set can name a
+ * step that has not been issued at this point in evaluation order, and settling it here
+ * would be a temporally impossible event. Returns HOW the witness was admitted, because
+ * the two ways carry different certainty (see {@link claimAt}).
+ *
+ * Bug this fixes: in async-promise-double-await-mutate, `first.steps.push(extra)` merges
+ * ask#2's label into the very slot `plan` denotes, so the EARLIER `await plan` read
+ * {ask#1, ask#2}. That phantom settle of ask#2 both cost the await its singleton-exact
+ * certainty and emitted `ask#2 -> ask#3 seq maybe`, which dedupeFacts' min-certainty
+ * merge then used to demote a true `data always` edge.
+ *
+ * The `repetition` carve-out is not optional. A step issued LATER IN THE WALK but sharing
+ * an enclosing iteration construct with the await is realizable by REPETITION: iteration
+ * k's promise settles at iteration k+1's await, which is exactly the loop-carried settle
+ * the oracle exists to find (reduce-accumulator awaits the accumulator, i.e. the previous
+ * round's ask, before issuing this round's). A bare `issued.has(step)` test drops it, the
+ * barrier falls through to a widening that finds nothing pending inside the region, and
+ * the step loses its `serial` cue for a `stack` that claims N concurrent instances the
+ * script serializes — trading a model-only certainty bit for a wrong cue that is DRAWN.
+ * This mirrors `realizableCarry` in causality-graph.ts, which decides backwards edges by
+ * the same "a shared iteration region is what repetition can realize" rule.
+ */
+function admissionOf(state, awaitNode, step) {
+    if (state.issued.has(step))
+        return "issued";
+    const call = state.callByStep.get(step);
+    if (call === undefined)
+        return undefined;
+    const enclosing = iterationAncestorsOf(state, awaitNode);
+    if (enclosing.size === 0)
+        return undefined;
+    for (const ancestor of iterationAncestorsOf(state, call)) {
+        if (enclosing.has(ancestor))
+            return "repetition";
+    }
+    return undefined;
+}
+/**
+ * Read one oracle position and split it by the SETTLE-CERTAINTY RULE: a singleton exact
+ * witness is certain, anything else is a may-claim.
+ *
+ * `admit` applies the temporal invariant ({@link admissionOf}) BEFORE the singleton
+ * judgement, and that order is load-bearing: dropping a phantom witness is what lets the
+ * surviving set be a singleton and settle certainly. Judging first and filtering after
+ * would leave the phantom's vote counted.
+ *
+ * A witness admitted by REPETITION never settles certainly, even as a singleton exact
+ * one, because the ordering it would claim fails at BOTH ends of the loop: the first
+ * iteration awaits the initial value and settles nothing, and the last iteration's issue
+ * escapes the loop unawaited (the head await of iteration k+1 never runs), so that
+ * instance is still pending afterwards. A certain claim there would assert a post-loop
+ * ordering the final instance violates — over-ordering as a may-claim is the licensed
+ * direction, over-CERTAINTY on a real edge is not. `order-loop-head-await-tail-issue`
+ * pins it. The demotion costs the multiplicity cue nothing: `settledInside` records the
+ * step whatever the event's certainty, so a `serial` cue survives it.
+ *
+ * Guard lookups pass no `admit` — see the note on {@link controllersOf}.
+ */
+function claimAt(state, map, at, admit) {
+    const occs = (map.get(at) ?? []).filter((occ) => state.realSteps.has(occ.site));
+    // Dedupe by site, OR-ing exactness the way the domain's own addOcc merges witnesses.
+    // `certainOk` is per-SITE: admission is a property of the site, not of an occurrence.
+    const bySite = new Map();
+    for (const occ of occs) {
+        const how = admit === undefined ? "issued" : admit(occ.site);
+        if (how === undefined)
+            continue; // temporally impossible at this point in the walk
+        const existing = bySite.get(occ.site);
+        if (existing === undefined)
+            bySite.set(occ.site, { certainOk: how === "issued", exact: occ.exact });
+        else
+            existing.exact = existing.exact || occ.exact;
+    }
+    const sites = [...bySite.keys()];
+    if (sites.length === 0)
+        return NO_CLAIM;
+    const only = sites[0];
+    const solo = bySite.get(only);
+    if (sites.length === 1 && solo.exact && solo.certainOk)
+        return { certain: [only], maybe: [] };
+    return { certain: [], maybe: sites };
+}
+export function settlesAt(state, node, at) {
+    return claimAt(state, state.oracle.awaitSettles, at, (step) => admissionOf(state, node, step));
+}
+/**
+ * An `await` barrier over the union of what the two halves resolved, plus the summaries of
+ * the STRANDS it joins: `certain` settles as a certainty, `maybe` as a may-claim (a step
+ * claimed by both counts as certain). Steps already settled IN A VISIBLE FRAME drop out,
+ * and a claim that has entirely settled already is a no-op. Widening is reached only when
+ * the claim and every joined summary were empty to begin with.
+ *
+ * The already-settled no-op is not new; what changed is that it became REACHABLE. Before
+ * the settle oracle, an indirect await (`await held`, `await p` in a helper, a second await of
+ * one promise) resolved to the empty set, so every such await fell through to widening and
+ * manufactured `seq maybe` claims over unrelated steps still in flight. The oracle makes
+ * the claim non-empty, so the no-op catches it and those spurious barriers disappear —
+ * which is why several async-promise-* snapshots got STRONGER certainties once the oracle
+ * landed rather than gaining edges.
+ *
+ * Two frame rules carry the strand model:
+ * freshness is judged against EVERY frame on the stack, because a step the spawner
+ * already awaited is settled for the strands it spawns; fresh steps are recorded in the
+ * CURRENT frame alone, because this activation's await tells the spawner nothing.
+ * `awaited` is the operand this barrier stands over, which {@link joinStrands} scans for
+ * the promises it names; a barrier with no operand (a deferred callback's receiver
+ * prologue) can still LIFT a strand out of its own claim.
+ */
+export function barrier(state, certain, maybe, chain, awaited) {
+    const { events, issued } = state;
+    const joins = joinStrands(state, certain, maybe, awaited);
+    const summaryOf = (regions) => regions.flatMap((region) => [
+        ...(state.strands.find((record) => record.region === region)?.summary ?? []),
+    ]);
+    // A joined strand contributes what IT awaited: syntactically joined certainly, lifted
+    // with the certainty of the claim that lifted it.
+    const allCertain = [...certain, ...summaryOf(joins.certain)];
+    const allMaybe = [...maybe, ...summaryOf(joins.maybe)];
+    const joined = [...joins.certain, ...joins.maybe];
+    const frame = currentFrame(state);
+    const freshCertain = [];
+    for (const step of allCertain) {
+        if (!isVisiblySettled(state, step) && !freshCertain.includes(step))
+            freshCertain.push(step);
+    }
+    for (const step of freshCertain)
+        frame.settled.add(step);
+    const freshMaybe = [];
+    for (const step of allMaybe) {
+        if (!isVisiblySettled(state, step) && !freshMaybe.includes(step))
+            freshMaybe.push(step);
+    }
+    for (const step of freshMaybe)
+        frame.settled.add(step);
+    // `joins` rides the FIRST event this barrier emits: it is a property of the barrier, not
+    // of either certainty side, and the control-flow projection reads it as one set.
+    const withJoins = joined.length === 0 ? {} : { joins: joined };
+    if (freshCertain.length > 0) {
+        events.push({ at: "settle", maybe: false, regions: chain, steps: freshCertain, ...withJoins });
+    }
+    if (freshMaybe.length > 0) {
+        events.push({
+            at: "settle",
+            maybe: true,
+            regions: chain,
+            steps: freshMaybe,
+            ...(freshCertain.length > 0 ? {} : withJoins),
+        });
+    }
+    if (freshCertain.length > 0 || freshMaybe.length > 0)
+        return;
+    // Nothing fresh to settle, but a join is a control-flow fact of its own: it is where the
+    // strand's parked exits reconnect, so it is recorded even with no steps to its name.
+    const joinOnly = () => {
+        if (joined.length === 0)
+            return;
+        events.push({ at: "settle", joins: joined, maybe: false, regions: chain, steps: [] });
+    };
+    if (allCertain.length > 0 || allMaybe.length > 0) {
+        joinOnly(); // already settled: adds no step
+        return;
+    }
+    // Widened barrier: neither half resolved anything, so assume everything in flight
+    // settled. Over-orders (understates parallelism), never invents concurrency.
+    const pending = [...issued].filter((step) => !isVisiblySettled(state, step));
+    if (pending.length === 0) {
+        joinOnly();
+        return;
+    }
+    for (const step of pending)
+        frame.settled.add(step);
+    events.push({ at: "settle", maybe: true, regions: chain, steps: pending, ...withJoins });
+}
+export function bindSteps(state, name, steps) {
+    if (steps.length === 0)
+        return;
+    for (const identifier of boundIdentifiers(name)) {
+        const symbol = state.checker.getSymbolAtLocation(identifier);
+        if (symbol === undefined)
+            continue;
+        const set = state.stepsBySymbol.get(symbol) ?? new Set();
+        for (const step of steps)
+            set.add(step);
+        state.stepsBySymbol.set(symbol, set);
+    }
+}
+/**
+ * Steps whose answers the guard expression reads, as the UNION of the syntactic
+ * `stepsBySymbol` scan (certain witnesses) and the taint oracle's `guardReads`. A step
+ * both sides claim counts once, as certain.
+ *
+ * Do not "simplify" this into the oracle alone. The scan is the ONLY side that sees an
+ * implicit flow — `const flag = (await ask()) ? 1 : 2; if (flag)` taints nothing, because
+ * a condition never joins the data contract — and the oracle is the only side that sees a
+ * derived binding (`const ok = t.escalate`), whose declaration issues nothing for the
+ * scan to record. Dropping either half silently loses a `control` edge; both cases are
+ * pinned (order-implicit-flow-guard, order-derived-guard-control).
+ */
+function controllersOf(state, guard) {
+    const controllers = [];
+    const scan = (node) => {
+        if (isFunctionLike(node))
+            return;
+        if (ts.isIdentifier(node)) {
+            const symbol = state.checker.getSymbolAtLocation(node);
+            const steps = symbol === undefined ? undefined : state.stepsBySymbol.get(symbol);
+            if (steps !== undefined) {
+                for (const step of steps)
+                    if (!controllers.includes(step))
+                        controllers.push(step);
+            }
+            return;
+        }
+        ts.forEachChild(node, scan);
+    };
+    scan(guard);
+    const claim = claimAt(state, state.oracle.guardReads, guard.getStart(state.scriptFile));
+    for (const step of claim.certain)
+        if (!controllers.includes(step))
+            controllers.push(step);
+    return {
+        controllers,
+        maybeControllers: claim.maybe.filter((step) => !controllers.includes(step)),
+    };
+}
+/** Record a guard's control dependence against a region, when it has any. */
+export function recordControl(state, guard, region) {
+    const { controllers, maybeControllers } = controllersOf(state, guard);
+    if (controllers.length > 0 || maybeControllers.length > 0) {
+        state.controls.push({ controllers, maybeControllers, region });
+    }
+}

package/vendor/dynamic-workflow/analysis/causality-order-state.d.ts

@@ -0,0 +1,110 @@
+import ts from "typescript";
+import type { ScriptLoc, WorkflowProgram } from "../compiler/compile.js";
+import { type HoleSite, type IterationCandidate, type PhaseMarkerSite, type SiteTable } from "./sites.js";
+import type { ApplicationVia } from "./state.js";
+import { type JumpKind, type TraceRegionKind } from "./constants.js";
+import type { ControlFact, OrderEvent, OrderOracle, OrderRegion, PhaseInfo } from "./causality-order-types.js";
+import { type ScriptFunction } from "./causality-order-functions.js";
+import { type Frame, type StrandRecord } from "./causality-order-strands.js";
+/** The walk's whole shared state: what `traceOrder` used to hold in closure. */
+export interface TraceState {
+    readonly scriptFile: ts.SourceFile;
+    readonly program: ts.Program;
+    readonly checker: ts.TypeChecker;
+    readonly toScriptLoc: WorkflowProgram["toScriptLoc"];
+    readonly oracle: OrderOracle;
+    readonly body: ts.Block;
+    readonly askByCall: ReadonlyMap<ts.Node, string>;
+    readonly readByCall: ReadonlyMap<ts.Node, string>;
+    readonly actorByCall: ReadonlyMap<ts.Node, string>;
+    /** `hole<T>()` calls by CALL node, open and filled (causality-order-holes.ts). */
+    readonly holeByCall: ReadonlyMap<ts.Node, HoleSite>;
+    /** Per-element callback calls by CALL node (the fan-out region opens there). */
+    readonly candByCall: ReadonlyMap<ts.Node, IterationCandidate>;
+    /** Their inline literals (an iteration construct for the admission test). */
+    readonly candByCallback: ReadonlyMap<ts.Node, IterationCandidate>;
+    /**
+     * A function applied per element at a candidate call (`xs.map(review)`) encloses its
+     * steps in an iteration exactly as an inline callback literal does.
+     */
+    readonly eachCallbackFns: ReadonlySet<ts.Node>;
+    readonly recursive: ReadonlySet<ts.Node>;
+    /**
+     * Only real steps can be ordered. An occurrence set may also carry join and fan-out
+     * labels, which are relays, not things that take time.
+     */
+    readonly realSteps: ReadonlySet<string>;
+    readonly callByStep: ReadonlyMap<string, ts.Node>;
+    readonly iterationAncestorCache: Map<ts.Node, Set<ts.Node>>;
+    readonly events: OrderEvent[];
+    readonly regions: OrderRegion[];
+    readonly controls: ControlFact[];
+    readonly counters: Map<TraceRegionKind, number>;
+    readonly issued: Set<string>;
+    readonly frames: Frame[];
+    /** Every strand the walk spawned, in spawn order; `joined` is the ones already awaited. */
+    readonly strands: StrandRecord[];
+    readonly joined: Set<string>;
+    /** Which strands a variable may hold the promise of — the syntactic half of the join. */
+    readonly strandsBySymbol: Map<ts.Symbol, Set<string>>;
+    readonly returnTargets: string[];
+    readonly throwTargets: string[];
+    readonly regionByStatement: Map<ts.Node, string>;
+    /** decl -> the `loop` region its SCC entry opened; where a re-entrant call `recur`s to. */
+    readonly sccLoopByDecl: Map<ts.Node, string>;
+    /**
+     * Which steps a variable may hold the answer of. The syntactic half of the control
+     * relation: it catches implicit flows the taint oracle cannot see, because a condition
+     * never joins the data contract (`const flag = (await ask()) ? 1 : 2` taints nothing).
+     */
+    readonly stepsBySymbol: Map<ts.Symbol, Set<string>>;
+    readonly walkedFns: Set<ts.Node>;
+    readonly fnStack: ts.Node[];
+    readonly markerByStatement: ReadonlyMap<ts.Node, PhaseMarkerSite>;
+    readonly phases: PhaseInfo[];
+    readonly phaseIdByName: Map<string, string>;
+    /** Hole phases already minted (a hole in a helper is reached per call, minted once). */
+    readonly holePhases: Set<string>;
+    /**
+     * The filled holes whose bodies the walk is inside, innermost last: every phase minted
+     * while the stack is non-empty carries its top as `fill` ({@link PhaseInfo.fill}).
+     */
+    readonly fillStack: string[];
+    currentPhase: string;
+    /** The root `seq` region id; every other region descends from it. */
+    readonly root: string;
+    /** The node visitor, bound to this state so every module can recurse without a cycle. */
+    readonly walk: (node: ts.Node, chain: readonly string[]) => void;
+}
+/** The script functions the oracle says `node` applies, by `via`, in recording order. */
+export declare function applicationsAt(state: Pick<TraceState, "oracle" | "scriptFile">, node: ts.Node, via: ApplicationVia): ScriptFunction[];
+export declare function openRegion(state: Pick<TraceState, "counters" | "regions">, kind: TraceRegionKind, parent: string | undefined, extra: {
+    entered: boolean;
+    loc?: ScriptLoc;
+    bound?: number;
+    label?: string;
+    exhaustive?: boolean;
+    fallthrough?: boolean;
+    detached?: boolean;
+    recursive?: boolean;
+    strand?: true;
+}): string;
+/** Build the state and index the site table; `walk` is the node visitor to bind. */
+export declare function createTraceState(workflow: WorkflowProgram, table: SiteTable, oracle: OrderOracle, walk: (state: TraceState, node: ts.Node, chain: readonly string[]) => void): TraceState;
+export declare function locOf(state: TraceState, node: ts.Node): ScriptLoc;
+export declare function innermost(state: TraceState, chain: readonly string[]): string;
+export declare function issue(state: TraceState, step: string, chain: readonly string[]): void;
+export declare function jump(state: TraceState, kind: JumpKind, target: string, chain: readonly string[]): void;
+/** Step ids issued by events at or after `mark`, in issue order, deduped. */
+export declare function issuesSince(state: TraceState, mark: number): string[];
+/**
+ * The id a marker names. Same name → same id (names are the key, unlike an actor's);
+ * a new name mints `phase#N` at FIRST REACH, so numbering follows evaluation order and
+ * a marker in dead code the walk never reaches mints nothing.
+ *
+ * A marker whose name the collector could not read (non-literal, empty) mints nothing
+ * and leaves the current phase alone: those are diagnostics (9004) and the script never
+ * reaches this pass, so this is the invariant written down rather than a fallback.
+ */
+export declare function phaseIdOf(state: TraceState, marker: PhaseMarkerSite): string | undefined;
+//# sourceMappingURL=causality-order-state.d.ts.map

package/vendor/dynamic-workflow/analysis/causality-order-state.d.ts.map

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

package/vendor/dynamic-workflow/analysis/causality-order-state.js

@@ -0,0 +1,162 @@
+import ts from "typescript";
+import { findWorkflowBody, } from "./sites.js";
+import { UNPHASED_ID } from "./constants.js";
+import { asScriptFunction, collectRecursiveFunctions, } from "./causality-order-functions.js";
+import { innermostOpenStrand } from "./causality-order-strands.js";
+/** The script functions the oracle says `node` applies, by `via`, in recording order. */
+export function applicationsAt(state, node, via) {
+    const out = [];
+    for (const [fn, how] of state.oracle.applications.get(node) ?? []) {
+        if (how !== via)
+            continue;
+        const decl = asScriptFunction(fn, state.scriptFile);
+        if (decl !== undefined)
+            out.push(decl);
+    }
+    return out;
+}
+export function openRegion(state, kind, parent, extra) {
+    const next = (state.counters.get(kind) ?? 0) + 1;
+    state.counters.set(kind, next);
+    const id = `${kind}#${next}`;
+    state.regions.push({ id, kind, ...(parent === undefined ? {} : { parent }), ...extra });
+    return id;
+}
+/** Build the state and index the site table; `walk` is the node visitor to bind. */
+export function createTraceState(workflow, table, oracle, walk) {
+    const { program, scriptFile, toScriptLoc } = workflow;
+    const checker = program.getTypeChecker();
+    const body = findWorkflowBody(scriptFile);
+    const askByCall = new Map(table.asks.map((site) => [site.call, site.id]));
+    const readByCall = new Map(table.worldReads.map((site) => [site.call, site.id]));
+    const actorByCall = new Map(table.actors.map((site) => [site.call, site.id]));
+    const holeByCall = new Map(table.holes.map((site) => [site.call, site]));
+    // 只有开放的留白是一步（docs/analysis.md「Sites」）：已补全的留白由它的函数体在原地代表。
+    const openHoles = table.holes.filter((site) => site.body === undefined);
+    const candByCall = new Map();
+    const candByCallback = new Map();
+    for (const cand of table.iterations) {
+        if (cand.call !== undefined)
+            candByCall.set(cand.call, cand);
+        if (cand.callback !== undefined)
+            candByCallback.set(cand.callback, cand);
+    }
+    const eachCallbackFns = new Set();
+    for (const call of candByCall.keys()) {
+        for (const fn of applicationsAt({ oracle, scriptFile }, call, "argument"))
+            eachCallbackFns.add(fn);
+    }
+    const recursive = collectRecursiveFunctions(scriptFile, checker, oracle.applications);
+    const realSteps = new Set([
+        ...table.asks.map((site) => site.id),
+        ...table.worldReads.map((site) => site.id),
+        ...openHoles.map((site) => site.id),
+    ]);
+    const callByStep = new Map([
+        ...table.asks.map((site) => [site.id, site.call]),
+        ...table.worldReads.map((site) => [site.id, site.call]),
+        ...openHoles.map((site) => [site.id, site.call]),
+    ]);
+    const markerByStatement = new Map();
+    for (const marker of table.phases) {
+        if (ts.isExpressionStatement(marker.call.parent))
+            markerByStatement.set(marker.call.parent, marker);
+    }
+    const regions = [];
+    const counters = new Map();
+    const root = openRegion({ counters, regions }, "seq", undefined, { entered: true });
+    const state = {
+        actorByCall,
+        askByCall,
+        body,
+        callByStep,
+        candByCall,
+        candByCallback,
+        checker,
+        controls: [],
+        counters,
+        currentPhase: UNPHASED_ID,
+        eachCallbackFns,
+        events: [],
+        fillStack: [],
+        fnStack: [],
+        frames: [{ region: root, settled: new Set() }],
+        holeByCall,
+        holePhases: new Set(),
+        issued: new Set(),
+        iterationAncestorCache: new Map(),
+        joined: new Set(),
+        markerByStatement,
+        oracle,
+        phaseIdByName: new Map(),
+        phases: [],
+        program,
+        readByCall,
+        realSteps,
+        recursive,
+        regionByStatement: new Map(),
+        regions,
+        returnTargets: [],
+        root,
+        sccLoopByDecl: new Map(),
+        scriptFile,
+        stepsBySymbol: new Map(),
+        strands: [],
+        strandsBySymbol: new Map(),
+        throwTargets: [],
+        toScriptLoc,
+        walk: (node, chain) => walk(state, node, chain),
+        walkedFns: new Set(),
+    };
+    return state;
+}
+export function locOf(state, node) {
+    return state.toScriptLoc(node.getStart(state.scriptFile));
+}
+export function innermost(state, chain) {
+    return chain[chain.length - 1] ?? state.root;
+}
+export function issue(state, step, chain) {
+    state.issued.add(step);
+    // The strand this issue happened in owns the step for the LIFT rule: awaiting a promise
+    // that carries this step's label is evidence that that activation has completed.
+    innermostOpenStrand(state)?.issued.add(step);
+    state.events.push({ at: "issue", phase: state.currentPhase, regions: chain, step });
+}
+export function jump(state, kind, target, chain) {
+    state.events.push({ at: "jump", kind, phase: state.currentPhase, regions: chain, target });
+}
+/** Step ids issued by events at or after `mark`, in issue order, deduped. */
+export function issuesSince(state, mark) {
+    const out = [];
+    for (let i = mark; i < state.events.length; i += 1) {
+        const event = state.events[i];
+        if (event.at === "issue" && !out.includes(event.step))
+            out.push(event.step);
+    }
+    return out;
+}
+/**
+ * The id a marker names. Same name → same id (names are the key, unlike an actor's);
+ * a new name mints `phase#N` at FIRST REACH, so numbering follows evaluation order and
+ * a marker in dead code the walk never reaches mints nothing.
+ *
+ * A marker whose name the collector could not read (non-literal, empty) mints nothing
+ * and leaves the current phase alone: those are diagnostics (9004) and the script never
+ * reaches this pass, so this is the invariant written down rather than a fallback.
+ */
+export function phaseIdOf(state, marker) {
+    const name = marker.name?.trim();
+    if (name === undefined || name === "")
+        return undefined;
+    const existing = state.phaseIdByName.get(name);
+    if (existing !== undefined)
+        return existing;
+    // 编号只数标记铸出的阶段：留白的阶段以站点 id 为 id、不进 phaseIdByName，所以夹在中间的留白
+    // 不会让 `phase#N` 跳号。
+    const id = `phase#${state.phaseIdByName.size + 1}`;
+    state.phaseIdByName.set(name, id);
+    const fill = state.fillStack[state.fillStack.length - 1];
+    state.phases.push({ id, loc: marker.loc, name, ...(fill === undefined ? {} : { fill }) });
+    return id;
+}

package/vendor/dynamic-workflow/analysis/causality-order-strands.d.ts

@@ -0,0 +1,79 @@
+import ts from "typescript";
+import type { TraceState } from "./causality-order-state.js";
+/**
+ * One open activation's settled set. The root body is the first frame and is never a
+ * strand; every strand pushes one more. A step is settled FROM A FRAME'S VIEW when some
+ * frame on the stack holds it — which is the whole of the fix: a barrier inside a strand
+ * no longer settles anything for the spawner, because the spawner's frame is below it and
+ * the strand's frame is popped when the strand closes.
+ */
+export interface Frame {
+    readonly region: string;
+    readonly settled: Set<string>;
+}
+/** One strand the walk spawned, in spawn order. */
+export interface StrandRecord {
+    /** The `call` / `fanout` region that IS the strand. */
+    readonly region: string;
+    /**
+     * Spawn order: this record's own index in `state.strands`. A barrier joins every strand
+     * with `at >= the count it saw when it took its mark`, which is "spawned while the
+     * operand was evaluated". Deliberately NOT an event index: a strand that emits no event
+     * before the await inside it would then tie with that await's mark, and the barrier
+     * would join the very strand it stands in (`await ask()` as the first statement of an
+     * `async` helper settled the helper's own summary into its own frame).
+     */
+    readonly at: number;
+    /** Steps issued inside it (the innermost open strand at each issue) — the lift rule. */
+    readonly issued: Set<string>;
+    /** What the strand itself awaited: its frame's settled set at close. */
+    summary: ReadonlySet<string>;
+    /** False until the body finished. Only a CLOSED strand can be lifted. */
+    closed: boolean;
+}
+/** The awaited expression a barrier stands over, with the strand count it started at. */
+export interface AwaitedOperand {
+    /** `state.strands.length` where the operand's evaluation began. */
+    mark: number;
+    operand: ts.Expression;
+}
+/** The frame a fresh settle lands in: the innermost open one. */
+export declare function currentFrame(state: TraceState): Frame;
+/** True iff some frame on the stack has settled `step` — the freshness test. */
+export declare function isVisiblySettled(state: TraceState, step: string): boolean;
+/** The strand an `issue` belongs to: the innermost one still being walked. */
+export declare function innermostOpenStrand(state: TraceState): StrandRecord | undefined;
+/** Spawn a strand on `region`: record it and push its frame. */
+export declare function openStrand(state: TraceState, region: string): StrandRecord;
+/** Close a strand: pop its frame and keep what it awaited as the strand's summary. */
+export declare function closeStrand(state: TraceState, record: StrandRecord): void;
+/** The walk's strand counter: the mark a caller takes before evaluating an expression. */
+export declare function strandMark(state: TraceState): number;
+/** Strand regions spawned at or after `mark`, in spawn order. */
+export declare function strandsSince(state: TraceState, mark: number): string[];
+/**
+ * Bind strand regions to the identifiers a declaration or assignment introduces — the
+ * syntactic half of the join, the exact shape `bindSteps` gives steps and for the same
+ * reason: `const work = ids.map(async …)` issues nothing at the declaration, so only the
+ * binding can tell a later `await Promise.all(work)` which strands `work` stands for.
+ */
+export declare function bindStrands(state: TraceState, name: ts.BindingName, regions: readonly string[]): void;
+/** True iff the applied function carries the `async` modifier — what makes a body a strand. */
+export declare function isAsyncFunction(decl: ts.Node): boolean;
+/**
+ * The strands a barrier waits for, split by the certainty each one's summary settles with,
+ * and MARKED JOINED so a second await of the same promise adds nothing (exactly as a
+ * second settle of one step already does).
+ *
+ * Two ways in. SYNTACTIC — spawned while the operand was evaluated, or bound to an
+ * identifier in an awaited position of it — settles the summary certainly: the await
+ * provably waits for that activation. LIFTED — a closed, not-yet-joined strand one of whose
+ * issued steps this barrier claims — settles it with the certainty the claim came in with:
+ * the promise reached the await through a container or a helper, and all we know is that
+ * something the strand issued has settled.
+ */
+export declare function joinStrands(state: TraceState, certain: readonly string[], maybe: readonly string[], awaited: AwaitedOperand | undefined): {
+    certain: string[];
+    maybe: string[];
+};
+//# sourceMappingURL=causality-order-strands.d.ts.map

package/vendor/dynamic-workflow/analysis/causality-order-strands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"causality-order-strands.d.ts","sourceRoot":"","sources":["../../src/analysis/causality-order-strands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAQ7D;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,wEAAwE;IACxE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,yFAAyF;AACzF,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC;CACxB;AAED,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAErD;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,GAAG,SAAS,CAM/E;AAED,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAW1E;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAIzE;AAED,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEpD;AAED,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,EAAE,CAAC,WAAW,EACpB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,IAAI,CASN;AAED,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAGtD;AA+CD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,cAAc,GAAG,SAAS,GAClC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAqBxC"}