@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

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

@@ -0,0 +1,154 @@
+import ts from "typescript";
+import { isGlobalLibValue } from "./callbacks.js";
+import { boundIdentifiers } from "./causality-order-functions.js";
+/** The frame a fresh settle lands in: the innermost open one. */
+export function currentFrame(state) {
+    return state.frames[state.frames.length - 1];
+}
+/** True iff some frame on the stack has settled `step` — the freshness test. */
+export function isVisiblySettled(state, step) {
+    return state.frames.some((frame) => frame.settled.has(step));
+}
+/** The strand an `issue` belongs to: the innermost one still being walked. */
+export function innermostOpenStrand(state) {
+    for (let i = state.strands.length - 1; i >= 0; i -= 1) {
+        const record = state.strands[i];
+        if (!record.closed)
+            return record;
+    }
+    return undefined;
+}
+/** Spawn a strand on `region`: record it and push its frame. */
+export function openStrand(state, region) {
+    const record = {
+        at: state.strands.length,
+        closed: false,
+        issued: new Set(),
+        region,
+        summary: new Set(),
+    };
+    state.strands.push(record);
+    state.frames.push({ region, settled: new Set() });
+    return record;
+}
+/** Close a strand: pop its frame and keep what it awaited as the strand's summary. */
+export function closeStrand(state, record) {
+    const frame = state.frames.pop();
+    record.summary = frame?.settled ?? new Set();
+    record.closed = true;
+}
+/** The walk's strand counter: the mark a caller takes before evaluating an expression. */
+export function strandMark(state) {
+    return state.strands.length;
+}
+/** Strand regions spawned at or after `mark`, in spawn order. */
+export function strandsSince(state, mark) {
+    return state.strands.filter((record) => record.at >= mark).map((record) => record.region);
+}
+/**
+ * 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 function bindStrands(state, name, regions) {
+    if (regions.length === 0)
+        return;
+    for (const identifier of boundIdentifiers(name)) {
+        const symbol = state.checker.getSymbolAtLocation(identifier);
+        if (symbol === undefined)
+            continue;
+        const set = state.strandsBySymbol.get(symbol) ?? new Set();
+        for (const region of regions)
+            set.add(region);
+        state.strandsBySymbol.set(symbol, set);
+    }
+}
+/** True iff the applied function carries the `async` modifier — what makes a body a strand. */
+export function isAsyncFunction(decl) {
+    const { modifiers } = decl;
+    return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+/** The promise combinators that adopt each argument, so each argument is an awaited position. */
+const COMBINATORS = new Set(["all", "allSettled", "race", "any"]);
+function isPromiseCombinator(state, node) {
+    const callee = node.expression;
+    if (!ts.isPropertyAccessExpression(callee) || !COMBINATORS.has(callee.name.text))
+        return false;
+    return isGlobalLibValue(callee.expression, "Promise", state.checker, state.program);
+}
+/**
+ * The identifiers in an AWAITED POSITION of an awaited expression: the operand itself,
+ * each argument of `Promise.all` / `allSettled` / `race` / `any`, each element of an array
+ * literal, a spread's operand, and through parentheses and type assertions. Every other
+ * expression is OPAQUE — this mirrors how the runtime adopts promises, and it is what
+ * keeps `await f(aWork.length)` from joining the strands `aWork` holds.
+ */
+function awaitedIdentifiers(state, operand) {
+    const out = [];
+    const scan = (node) => {
+        if (ts.isParenthesizedExpression(node) ||
+            ts.isAsExpression(node) ||
+            ts.isSatisfiesExpression(node) ||
+            ts.isNonNullExpression(node) ||
+            ts.isSpreadElement(node)) {
+            scan(node.expression);
+            return;
+        }
+        if (ts.isIdentifier(node)) {
+            out.push(node);
+            return;
+        }
+        if (ts.isArrayLiteralExpression(node)) {
+            for (const element of node.elements)
+                scan(element);
+            return;
+        }
+        if (ts.isCallExpression(node) && isPromiseCombinator(state, node)) {
+            for (const argument of node.arguments)
+                scan(argument);
+        }
+    };
+    scan(operand);
+    return out;
+}
+/**
+ * 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 function joinStrands(state, certain, maybe, awaited) {
+    const joins = { certain: [], maybe: [] };
+    const take = (region, side) => {
+        if (state.joined.has(region))
+            return;
+        state.joined.add(region);
+        side.push(region);
+    };
+    if (awaited !== undefined) {
+        for (const region of strandsSince(state, awaited.mark))
+            take(region, joins.certain);
+        for (const identifier of awaitedIdentifiers(state, awaited.operand)) {
+            const symbol = state.checker.getSymbolAtLocation(identifier);
+            const bound = symbol === undefined ? undefined : state.strandsBySymbol.get(symbol);
+            for (const region of bound ?? [])
+                take(region, joins.certain);
+        }
+    }
+    for (const record of state.strands) {
+        if (!record.closed || state.joined.has(record.region))
+            continue;
+        if (certain.some((step) => record.issued.has(step)))
+            take(record.region, joins.certain);
+        else if (maybe.some((step) => record.issued.has(step)))
+            take(record.region, joins.maybe);
+    }
+    return joins;
+}

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

@@ -0,0 +1,174 @@
+import type ts from "typescript";
+import type { ScriptLoc } from "../compiler/compile.js";
+import type { TaintOcc } from "./domain.js";
+import type { ApplicationVia } from "./state.js";
+import type { JumpKind, TraceRegionKind } from "./constants.js";
+/**
+ * The taint facts this walk reads, narrowed to the two members it actually uses so the
+ * ordering pass does not depend on the whole emission surface. Produced by
+ * `TaintState.emitOracle` off the CONVERGED interpreter state (interpret.ts).
+ * Both maps are keyed by `node.getStart(scriptFile)`.
+ */
+export interface OrderOracle {
+    /** Step occurrences the operand of each `await` carries. */
+    awaitSettles: Map<number, TaintOcc[]>;
+    /** Step occurrences each guard expression reads. */
+    guardReads: Map<number, TaintOcc[]>;
+    /**
+     * The call oracle: per call / `new` / tagged-template node, the script functions the
+     * interpreter applied there and how (`TaintState.applications`). The walk inlines exactly
+     * these bodies at exactly these sites.
+     */
+    applications: ReadonlyMap<ts.Node, ReadonlyMap<ts.Node, ApplicationVia>>;
+}
+export interface OrderRegion {
+    id: string;
+    kind: TraceRegionKind;
+    parent?: string;
+    loc?: ScriptLoc;
+    /** Derivable literal round count of a `for` loop; model-only (never displayed). */
+    bound?: number;
+    /** fanout: the iterated expression; loop: the recursive helper's name; call: the helper's name. */
+    label?: string;
+    /**
+     * True iff running the parent provably runs this region's body at least once: a
+     * `do…while` body, a `for` whose literal bound is positive, or an inlined call.
+     * Drives the certainty carve-out.
+     */
+    entered: boolean;
+    /** choice: one arm MUST run (if/else, ternary, switch with default). Absent = skippable. */
+    exhaustive?: boolean;
+    /**
+     * loop: a recursion SCC folded into a loop, not a loop statement. Only re-entrant calls
+     * (`recur` jumps) close it; its body completing normally is the helper returning.
+     */
+    recursive?: boolean;
+    /** choice: an arm completing normally continues into the next arm (switch). */
+    fallthrough?: boolean;
+    /**
+     * branch: a never-called function body the end-of-walk sweep placed here. It runs at
+     * an unknown point, if at all; its position in the stream is an artifact of the sweep.
+     */
+    detached?: boolean;
+    /**
+     * `call` / `fanout` only: this region is a STRAND — one asynchronous activation that
+     * runs alongside the body that spawned it (an inlined `async` body, or a deferred
+     * callback). Its `await`s suspend the strand, never the spawner, so the walk gives it a
+     * settled set of its own and the spawner learns of its completion only by awaiting its
+     * promise ({@link SettleEvent.joins}).
+     */
+    strand?: true;
+}
+/** A phase the walk reached: `phase#N` numbered by FIRST REACH of a new name. */
+export interface PhaseInfo {
+    id: string;
+    /** The author's verbatim word. Always present — a nameless marker never mints a phase. */
+    name: string;
+    /** The first marker that minted this phase; later same-name markers do not move it. */
+    loc: ScriptLoc;
+    /**
+     * The filled hole whose body wrote this phase (docs/analysis.md「Sites」): a marker or a hole
+     * (open or filled) inside a body carries the innermost enclosing filled hole's id. Absent
+     * outside every fill — a top-level hole's own phase has none.
+     */
+    fill?: string;
+}
+/** A step's request was sent (the facade call expression was evaluated). */
+export interface IssueEvent {
+    at: "issue";
+    step: string;
+    regions: readonly string[];
+    /**
+     * The phase current where the call was evaluated — {@link UNPHASED_ID} outside every
+     * marker's extent. Issue is the step's identity moment, so this is the whole of phase
+     * membership.
+     */
+    phase: string;
+}
+/** An `await` barrier: these steps' promises are known to have settled here. */
+export interface SettleEvent {
+    at: "settle";
+    /**
+     * EMPTY when the barrier only joined strands: awaiting a strand whose summary is
+     * already settled (or empty) settles nothing new, but the join itself is a control-flow
+     * fact — it is where the strand's parked exits reconnect — so the event is still
+     * recorded. Readers iterate `steps` and see nothing; readers of {@link joins} see the
+     * join. `maybe` is meaningless on such an event and is written `false`.
+     */
+    steps: readonly string[];
+    /**
+     * True when this settle is a MAY-claim rather than a certainty. Two sources: the
+     * barrier widened (nothing resolvable settled here, so everything in flight is assumed
+     * to have), or the oracle's witness set was ambiguous — several witnesses, of which
+     * exactly one settles at runtime, or a single inexact one smeared through a container.
+     */
+    maybe: boolean;
+    /** Region chain the barrier sits in — a loop's carry edge needs to know. */
+    regions: readonly string[];
+    /**
+     * The STRAND regions this barrier waits for, in join order: the strands whose promises
+     * the awaited expression names (spawned while it was evaluated, or bound to an
+     * identifier in an awaited position) plus the ones lifted because a settled step was
+     * issued inside them. A strand joins once — a second await of the same promise lists
+     * nothing. Absent when the barrier joins no strand.
+     */
+    joins?: string[];
+}
+/** An `agent()` call was evaluated — the lane's creation point, for family depth. */
+export interface ActorEvent {
+    at: "actor";
+    actor: string;
+    regions: readonly string[];
+    /**
+     * The phase current where the call was evaluated, as on {@link IssueEvent}: a lane's birth
+     * phase for the engine's lexical stamp (`collectSitePhases`). Not rendered in the core's
+     * text form — the `spawn` line predates it and the site-phase table has its own tests.
+     */
+    phase: string;
+}
+/** A `phase("…")` marker statement was evaluated: the current phase switched to `phase`. */
+export interface MarkEvent {
+    at: "mark";
+    /** The phase current from here to the end of the enclosing statement list. */
+    phase: string;
+    regions: readonly string[];
+}
+/**
+ * An unstructured transfer of control, with its target already resolved to a region id so
+ * projections never touch the AST: `continue`/`break` name the `loop` (or, for a `break`
+ * inside a switch, the `choice`); `return` names the enclosing `call` / `fanout` /
+ * detached body, else the root; `throw` names the enclosing `attempt`, else the root
+ * (uncaught); `recur` is a recursive call cut at re-entry, naming the SCC's `loop`.
+ */
+export interface JumpEvent {
+    at: "jump";
+    kind: JumpKind;
+    target: string;
+    regions: readonly string[];
+    /** The phase current where the jump was evaluated (a phase CFG edge leaves from here). */
+    phase: string;
+}
+export type OrderEvent = IssueEvent | SettleEvent | ActorEvent | MarkEvent | JumpEvent;
+/** `controllers`' answers decide whether the steps inside `region` are issued. */
+export interface ControlFact {
+    /** Controllers the analysis is sure of: a syntactic witness, or a singleton-exact one. */
+    controllers: readonly string[];
+    /** Controllers only the ambiguous half of the oracle claims; disjoint from the above. */
+    maybeControllers: readonly string[];
+    region: string;
+}
+export interface OrderTrace {
+    events: OrderEvent[];
+    regions: OrderRegion[];
+    controls: ControlFact[];
+    /** The root `seq` region id; every other region descends from it. */
+    root: string;
+    /**
+     * Phases the walk reached, in first-reach order. Empty for a script with no markers,
+     * which is what makes the whole phase vocabulary absent downstream. {@link UNPHASED_ID}
+     * is NOT listed here — it is synthetic, and the projection adds it only if it has
+     * members.
+     */
+    phases: PhaseInfo[];
+}
+//# sourceMappingURL=causality-order-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causality-order-types.d.ts","sourceRoot":"","sources":["../../src/analysis/causality-order-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOhE;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACtC,oDAAoD;IACpD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACpC;;;;OAIG;IACH,YAAY,EAAE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,GAAG,EAAE,SAAS,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,QAAQ,CAAC;IACb;;;;;;OAMG;IACH,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,4EAA4E;IAC5E,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qFAAqF;AACrF,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,4FAA4F;AAC5F,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvF,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,0FAA0F;IAC1F,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,yFAAyF;IACzF,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { type TraceState } from "./causality-order-state.js";
+/**
+ * Walk a statement list in order, threading the current phase with REST-OF-BLOCK
+ * extent: a marker statement re-points the local, every later statement in the list
+ * (and everything nested under it, inlined helper bodies included) inherits it, and the
+ * list's end restores what was current on entry. There is no other phase mechanism —
+ * every construct that holds a statement list routes through here.
+ *
+ * A marker NOT in a statement list (`if (x) phase("a");` without braces) is therefore
+ * inert: it has no rest-of-list to claim, which is the same "no effect, no diagnostic"
+ * status assigned to a marker at the tail of its block.
+ */
+export declare function walkStatements(state: TraceState, statements: readonly ts.Statement[], chain: readonly string[]): void;
+/** The node visitor: one evaluation-order step over `node`. Bound as `state.walk`. */
+export declare function walkNode(state: TraceState, node: ts.Node, chain: readonly string[]): void;
+//# sourceMappingURL=causality-order-walk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causality-order-walk.d.ts","sourceRoot":"","sources":["../../src/analysis/causality-order-walk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,4BAA4B,CAAC;AA+CpC;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,SAAS,EAAE,CAAC,SAAS,EAAE,EACnC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,IAAI,CAiBN;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CA0NzF"}

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

@@ -0,0 +1,282 @@
+import ts from "typescript";
+import { isFunctionLike } from "./sites.js";
+import { applyAt, walkCall } from "./causality-order-calls.js";
+import { walkLoop } from "./causality-order-loops.js";
+import { innermost, issuesSince, jump, locOf, openRegion, phaseIdOf, } from "./causality-order-state.js";
+import { barrier, bindSteps, recordControl, settlesAt } from "./causality-order-settle.js";
+import { bindStrands, strandMark, strandsSince } from "./causality-order-strands.js";
+// causality-order.ts 顶到 oxlint max-lines 上限（400 行），把节点访问器本体
+// （语句表走查、await / 赋值 / 短路 / 分支 / switch / try / 跳转的分支）拆到本文件；循环与
+// 调用两组各在同名兄弟模块。公开面仍从 causality-order.ts 导出。if 链的判定顺序与原文件
+// 逐字一致：`walkLoop` 占原来四个循环分支的位置，之后才落到 forEachChild 兜底。
+/** Open a guarded `branch` region and record its control dependence, if any. */
+function guarded(state, guard, node, chain) {
+    const id = openRegion(state, "branch", innermost(state, chain), {
+        entered: false,
+        loc: locOf(state, node),
+    });
+    if (guard !== undefined)
+        recordControl(state, guard, id);
+    return [...chain, id];
+}
+/**
+ * The region a `break` / `continue` transfers to. Labeled: the labeled statement's own
+ * region (a label on a plain block has none — such a jump is dropped, which reads as
+ * fall-through; no corpus fixture does this). Unlabeled: the nearest enclosing loop, or
+ * for `break` the nearest loop OR switch. Never crosses a function boundary — the
+ * language does not let it either.
+ */
+function jumpTargetOf(state, node) {
+    const { regionByStatement } = state;
+    const isBreak = ts.isBreakStatement(node);
+    for (let cur = node.parent; cur !== undefined && !isFunctionLike(cur); cur = cur.parent) {
+        if (node.label !== undefined) {
+            if (ts.isLabeledStatement(cur) && cur.label.text === node.label.text) {
+                return regionByStatement.get(cur.statement);
+            }
+            continue;
+        }
+        if (ts.isIterationStatement(cur, false))
+            return regionByStatement.get(cur);
+        if (isBreak && ts.isSwitchStatement(cur))
+            return regionByStatement.get(cur);
+    }
+    return undefined;
+}
+/**
+ * Walk a statement list in order, threading the current phase with REST-OF-BLOCK
+ * extent: a marker statement re-points the local, every later statement in the list
+ * (and everything nested under it, inlined helper bodies included) inherits it, and the
+ * list's end restores what was current on entry. There is no other phase mechanism —
+ * every construct that holds a statement list routes through here.
+ *
+ * A marker NOT in a statement list (`if (x) phase("a");` without braces) is therefore
+ * inert: it has no rest-of-list to claim, which is the same "no effect, no diagnostic"
+ * status assigned to a marker at the tail of its block.
+ */
+export function walkStatements(state, statements, chain) {
+    const outer = state.currentPhase;
+    for (const statement of statements) {
+        const marker = state.markerByStatement.get(statement);
+        if (marker !== undefined) {
+            const id = phaseIdOf(state, marker);
+            if (id !== undefined) {
+                state.currentPhase = id;
+                // The marker is a leaf of its own: a phase with no step is still a position
+                // control passes through (control-flow projection); phase MEMBERSHIP stays on
+                // issue events and does not read this.
+                state.events.push({ at: "mark", phase: id, regions: chain });
+            }
+        }
+        state.walk(statement, chain);
+    }
+    state.currentPhase = outer;
+}
+/** The node visitor: one evaluation-order step over `node`. Bound as `state.walk`. */
+export function walkNode(state, node, chain) {
+    const { events, regionByStatement, returnTargets, root, scriptFile, throwTargets, walk } = state;
+    // A function body runs when it is called, not where it is written; call sites
+    // inline it (see `applyAt` / `inlineBody`), and never-called bodies are swept up at the end.
+    if (isFunctionLike(node)) {
+        // Bug: the body is deferred, but a COMPUTED MEMBER NAME is not — `{ [await
+        // agent(..).ask(..)]() {} }` evaluates the key where it is written, at object
+        // construction. Bailing on the whole node left that ask unreached by the walk, so
+        // it fell through to the terminal synthetic issue and got a position at the very
+        // END of the script. A real forward edge out of it then looked like a back edge
+        // and was retyped `carry` (see emission-graph-computed-method-name-obj).
+        const { name } = node;
+        if (name !== undefined && ts.isComputedPropertyName(name))
+            walk(name.expression, chain);
+        return;
+    }
+    if (ts.isBlock(node)) {
+        // Ordering-wise identical to the `forEachChild` fallthrough; routed here so a
+        // marker's extent ends with the block (function bodies included).
+        walkStatements(state, node.statements, chain);
+        return;
+    }
+    if (ts.isAwaitExpression(node)) {
+        const mark = events.length;
+        const spawned = strandMark(state);
+        walk(node.expression, chain);
+        // The syntactic half (steps issued while evaluating the operand) is certain; the
+        // oracle adds whatever labels the awaited VALUE carries. The operand goes to the
+        // barrier as well: it is where the STRANDS this await joins are named.
+        const claim = settlesAt(state, node, node.getStart(scriptFile));
+        barrier(state, [...issuesSince(state, mark), ...claim.certain], claim.maybe, chain, {
+            mark: spawned,
+            operand: node.expression,
+        });
+        return;
+    }
+    if (ts.isCallExpression(node)) {
+        walkCall(state, node, chain);
+        return;
+    }
+    // `new C(args)` applies C's constructor (a script class) or a library constructor's
+    // callbacks (`new Promise(executor)`); a tagged template is the call `tag(strings, …)`.
+    // Both evaluate their operands first, then apply whatever the oracle recorded there.
+    if (ts.isNewExpression(node)) {
+        walk(node.expression, chain);
+        for (const argument of node.arguments ?? [])
+            walk(argument, chain);
+        applyAt(state, node, chain);
+        return;
+    }
+    if (ts.isTaggedTemplateExpression(node)) {
+        walk(node.tag, chain);
+        walk(node.template, chain);
+        applyAt(state, node, chain);
+        return;
+    }
+    if (ts.isVariableDeclaration(node)) {
+        if (node.initializer !== undefined) {
+            const mark = events.length;
+            const spawned = strandMark(state);
+            walk(node.initializer, chain);
+            bindSteps(state, node.name, issuesSince(state, mark));
+            bindStrands(state, node.name, strandsSince(state, spawned));
+        }
+        return;
+    }
+    if (ts.isBinaryExpression(node)) {
+        const operator = node.operatorToken.kind;
+        if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
+            operator === ts.SyntaxKind.BarBarToken ||
+            operator === ts.SyntaxKind.QuestionQuestionToken) {
+            // Short-circuit: the right operand is guarded by the left — a one-arm, skippable
+            // choice.
+            walk(node.left, chain);
+            const choice = [
+                ...chain,
+                openRegion(state, "choice", innermost(state, chain), {
+                    entered: true,
+                    loc: locOf(state, node),
+                }),
+            ];
+            walk(node.right, guarded(state, node.left, node.right, choice));
+            return;
+        }
+        if (operator === ts.SyntaxKind.EqualsToken) {
+            const mark = events.length;
+            const spawned = strandMark(state);
+            walk(node.right, chain);
+            if (ts.isIdentifier(node.left)) {
+                bindSteps(state, node.left, issuesSince(state, mark));
+                bindStrands(state, node.left, strandsSince(state, spawned));
+            }
+            walk(node.left, chain);
+            return;
+        }
+        walk(node.left, chain);
+        walk(node.right, chain);
+        return;
+    }
+    // Branching constructs open a `choice` group whose arms are the guarded `branch`
+    // regions. The group records what the arms alone cannot: whether one of them MUST run
+    // (`exhaustive`) and whether an arm falls into the next (`fallthrough`, switch only).
+    if (ts.isConditionalExpression(node)) {
+        walk(node.condition, chain);
+        const choice = [
+            ...chain,
+            openRegion(state, "choice", innermost(state, chain), {
+                entered: true,
+                exhaustive: true,
+                loc: locOf(state, node),
+            }),
+        ];
+        walk(node.whenTrue, guarded(state, node.condition, node.whenTrue, choice));
+        walk(node.whenFalse, guarded(state, node.condition, node.whenFalse, choice));
+        return;
+    }
+    if (ts.isIfStatement(node)) {
+        walk(node.expression, chain);
+        const choice = [
+            ...chain,
+            openRegion(state, "choice", innermost(state, chain), {
+                entered: true,
+                loc: locOf(state, node),
+                ...(node.elseStatement === undefined ? {} : { exhaustive: true }),
+            }),
+        ];
+        walk(node.thenStatement, guarded(state, node.expression, node.thenStatement, choice));
+        if (node.elseStatement !== undefined) {
+            walk(node.elseStatement, guarded(state, node.expression, node.elseStatement, choice));
+        }
+        return;
+    }
+    if (ts.isSwitchStatement(node)) {
+        walk(node.expression, chain);
+        const clauses = node.caseBlock.clauses;
+        const id = openRegion(state, "choice", innermost(state, chain), {
+            entered: true,
+            fallthrough: true,
+            loc: locOf(state, node),
+            ...(clauses.some((clause) => ts.isDefaultClause(clause)) ? { exhaustive: true } : {}),
+        });
+        const choice = [...chain, id];
+        regionByStatement.set(node, id); // `break` inside a clause exits the switch
+        for (const clause of clauses) {
+            if (ts.isCaseClause(clause))
+                walk(clause.expression, choice);
+            const inside = guarded(state, node.expression, clause, choice);
+            walkStatements(state, clause.statements, inside);
+        }
+        regionByStatement.delete(node);
+        return;
+    }
+    // Unstructured transfers: evaluate the operand first (`throw new Error(await x.ask())`
+    // issues a step), then record the jump with its target already resolved to a region.
+    if (ts.isReturnStatement(node)) {
+        if (node.expression !== undefined)
+            walk(node.expression, chain);
+        jump(state, "return", returnTargets[returnTargets.length - 1] ?? root, chain);
+        return;
+    }
+    if (ts.isThrowStatement(node)) {
+        walk(node.expression, chain);
+        jump(state, "throw", throwTargets[throwTargets.length - 1] ?? root, chain);
+        return;
+    }
+    if (ts.isBreakOrContinueStatement(node)) {
+        const target = jumpTargetOf(state, node);
+        if (target !== undefined)
+            jump(state, ts.isBreakStatement(node) ? "break" : "continue", target, chain);
+        return;
+    }
+    if (ts.isTryStatement(node)) {
+        const group = openRegion(state, "try", innermost(state, chain), {
+            entered: true,
+            loc: locOf(state, node),
+        });
+        const inGroup = [...chain, group];
+        const attempt = openRegion(state, "attempt", group, {
+            entered: true,
+            loc: locOf(state, node.tryBlock),
+        });
+        throwTargets.push(attempt);
+        walk(node.tryBlock, [...inGroup, attempt]);
+        throwTargets.pop();
+        if (node.catchClause !== undefined) {
+            // The clause's binding (`catch (e)`) declares nothing that issues; only the block
+            // is walked. A `throw` inside it resolves to the OUTER attempt — catch is a sibling
+            // of attempt, not a child.
+            const id = openRegion(state, "catch", group, {
+                entered: false,
+                loc: locOf(state, node.catchClause),
+            });
+            walk(node.catchClause.block, [...inGroup, id]);
+        }
+        if (node.finallyBlock !== undefined) {
+            const id = openRegion(state, "finally", group, {
+                entered: true,
+                loc: locOf(state, node.finallyBlock),
+            });
+            walk(node.finallyBlock, [...inGroup, id]);
+        }
+        return;
+    }
+    if (walkLoop(state, node, chain))
+        return;
+    ts.forEachChild(node, (child) => walk(child, chain));
+}