@loomwork/compiler 0.0.0-stage → 0.1.1

package/dist/runnerReach.js

@@ -0,0 +1,1809 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_STEP_FACTORIES = void 0;
+exports.stringLiteralValue = stringLiteralValue;
+exports.inferStepFactory = inferStepFactory;
+exports.analyzeReachNode = analyzeReachNode;
+exports.analyzeReachRegion = analyzeReachRegion;
+exports.analyzeRunnerReach = analyzeRunnerReach;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * First-party factories whose effect id is fixed and whose source is in a package (never followed
+ * through an import). `mcp.invoke` is `MCP_INVOKE_TOOL_ID` in `@loomwork/plugin-mcp` and `sandbox.eval` is
+ * `SANDBOX_TOOL_ID` in `@loomwork/sandbox` (re-exported by `@loomwork/plugin-sandbox`, ADR 0144); a test pins each to its package.
+ */
+exports.KNOWN_STEP_FACTORIES = {
+    mcpInvoke$: { fixed: "mcp.invoke" },
+    // `sandboxEval$(id, toolId = SANDBOX_TOOL_ID)` in `@loomwork/sandbox` (ADR 0144).
+    sandboxEval$: { argIndex: 1, default: "sandbox.eval" },
+};
+/** The string value of a property on an object literal, when it is a literal. */
+function stringProp(obj, name) {
+    for (const p of obj.properties) {
+        if (!typescript_1.default.isPropertyAssignment(p))
+            continue;
+        const key = typescript_1.default.isIdentifier(p.name) || typescript_1.default.isStringLiteral(p.name) ? p.name.text : undefined;
+        if (key !== name)
+            continue;
+        if (typescript_1.default.isStringLiteral(p.initializer) || typescript_1.default.isNoSubstitutionTemplateLiteral(p.initializer)) {
+            return p.initializer.text;
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/** Whether a property is present at all, regardless of whether its value is a literal. */
+function hasProp(obj, name) {
+    return obj.properties.some((p) => {
+        if (!typescript_1.default.isPropertyAssignment(p) && !typescript_1.default.isShorthandPropertyAssignment(p))
+            return false;
+        return (typescript_1.default.isIdentifier(p.name) || typescript_1.default.isStringLiteral(p.name)) && p.name.text === name;
+    });
+}
+/** A method call `<anything>.<name>(…)` — receiver-agnostic, like the determinism analyzer. */
+function methodCall(node, name) {
+    if (!typescript_1.default.isCallExpression(node))
+        return undefined;
+    const e = node.expression;
+    return typescript_1.default.isPropertyAccessExpression(e) && typescript_1.default.isIdentifier(e.name) && e.name.text === name
+        ? node
+        : undefined;
+}
+/**
+ * Collect `const NAME = anything$({ … toolId: "…" … })` bindings in this region.
+ *
+ * Shape-based rather than keyed to `step$` by name, so a project wrapper
+ * (`myStep$`, a re-export, a locally curried factory) resolves too. The
+ * discriminator is a string-literal `toolId`, which is the only thing that makes
+ * a binding useful here.
+ */
+function collectBindings(root) {
+    const bindings = new Map();
+    function visit(node) {
+        if (typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+            const init = node.initializer;
+            if (init !== undefined && typescript_1.default.isCallExpression(init) && init.arguments.length > 0) {
+                const arg = init.arguments[0];
+                if (arg !== undefined && typescript_1.default.isObjectLiteralExpression(arg)) {
+                    const toolId = stringProp(arg, "toolId");
+                    if (toolId !== undefined) {
+                        const stepId = stringProp(arg, "id");
+                        bindings.set(node.name.text, { toolId, ...(stepId !== undefined && { stepId }) });
+                    }
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(root);
+    return bindings;
+}
+/** The name a call's callee ends in: `ctx.run` / `ctx["run"]` / `run`, through `.call/.apply/.bind`. */
+function calleeMethodName(call) {
+    let e = unwrap(call.expression);
+    for (;;) {
+        if (typescript_1.default.isPropertyAccessExpression(e)) {
+            if (["call", "apply", "bind"].includes(e.name.text) &&
+                typescript_1.default.isPropertyAccessExpression(unwrap(e.expression)))
+                e = unwrap(e.expression);
+            else
+                return e.name.text;
+        }
+        else if (typescript_1.default.isElementAccessExpression(e)) {
+            const a = unwrap(e.argumentExpression);
+            return typescript_1.default.isStringLiteralLike(a) ? a.text : undefined;
+        }
+        else
+            return typescript_1.default.isIdentifier(e) ? e.text : undefined;
+    }
+}
+/**
+ * Whether a step object bound to `name` can change between its declaration and its use (ADR 0086,
+ * 2026-10-10 amendment). The only uses that cannot change it are: the declaration, an argument of a
+ * ctx method call (`ctx.run(s)`) or a ctx hand-off (`lib(ctx, s)`, L34), an element of an array literal (a `ctx.parallel` tuple), a spread
+ * copy, and a property READ. Anything else - a property assignment / `delete` / `++`, being handed to
+ * `Object.assign(s, ...)` or any other function, aliased, returned, stored in another object -
+ * makes the binding "not followed" (unresolved): a guess at `toolId` would name the wrong effect.
+ */
+function stepBindingEscapes(sourceFile, name, ctxNames, isLoomFlowBuilder = () => false) {
+    let escapes = false;
+    const strip = (n) => {
+        let top = n;
+        while (top.parent !== undefined &&
+            (typescript_1.default.isParenthesizedExpression(top.parent) ||
+                typescript_1.default.isAsExpression(top.parent) ||
+                typescript_1.default.isNonNullExpression(top.parent) ||
+                typescript_1.default.isSatisfiesExpression(top.parent)))
+            top = top.parent;
+        return top;
+    };
+    const isWriteTarget = (member) => {
+        let top = strip(member);
+        // Walk out of destructuring-assignment patterns: `[s.toolId] = …`, `({ a: s.toolId } = …)`.
+        while (top.parent !== undefined &&
+            (typescript_1.default.isArrayLiteralExpression(top.parent) ||
+                typescript_1.default.isPropertyAssignment(top.parent) ||
+                typescript_1.default.isShorthandPropertyAssignment(top.parent) ||
+                typescript_1.default.isSpreadElement(top.parent) ||
+                typescript_1.default.isSpreadAssignment(top.parent) ||
+                typescript_1.default.isObjectLiteralExpression(top.parent)))
+            top = strip(top.parent);
+        const p = top.parent;
+        if (p === undefined)
+            return false;
+        if (typescript_1.default.isBinaryExpression(p))
+            return (p.left === top &&
+                p.operatorToken.kind >= typescript_1.default.SyntaxKind.FirstAssignment &&
+                p.operatorToken.kind <= typescript_1.default.SyntaxKind.LastAssignment);
+        if (typescript_1.default.isDeleteExpression(p))
+            return true;
+        if (typescript_1.default.isPrefixUnaryExpression(p) || typescript_1.default.isPostfixUnaryExpression(p))
+            return (p.operator === typescript_1.default.SyntaxKind.PlusPlusToken || p.operator === typescript_1.default.SyntaxKind.MinusMinusToken);
+        // `for (s.toolId of xs)` / `for (s.toolId in o)`.
+        return (typescript_1.default.isForOfStatement(p) || typescript_1.default.isForInStatement(p)) && p.initializer === top;
+    };
+    const walk = (n) => {
+        if (escapes)
+            return;
+        if (typescript_1.default.isIdentifier(n) && n.text === name) {
+            const p = n.parent;
+            const top = strip(n);
+            const q = top.parent;
+            const isDecl = typescript_1.default.isVariableDeclaration(p) && p.name === n;
+            // `{ s: 1 }` key, `x.s` member name, `{ s }` shorthand is a VALUE use (handled by falling through).
+            const isNotAReference = (typescript_1.default.isPropertyAssignment(p) && p.name === n) ||
+                (typescript_1.default.isPropertyAccessExpression(p) && p.name === n) ||
+                (typescript_1.default.isPropertySignature(p) && p.name === n);
+            if (!isDecl && !isNotAReference) {
+                let ok = false;
+                // A ctx method call or a ctx hand-off (`lib(ctx, s)`, the declared-reach seam, L34) may take
+                // an argument: its step arguments are recorded for the callee's declaration.
+                const isCtxCall = (c) => {
+                    const m = calleeMethodName(c);
+                    return ((m !== undefined && CTX_METHODS.has(m)) ||
+                        c.arguments.some((a) => {
+                            const u = unwrap(a);
+                            return typescript_1.default.isIdentifier(u) && ctxNames.has(u.text);
+                        }));
+                };
+                if (q !== undefined &&
+                    typescript_1.default.isCallExpression(q) &&
+                    q.arguments.includes(top)) {
+                    ok = isCtxCall(q);
+                }
+                else if (q !== undefined && typescript_1.default.isArrayLiteralExpression(q)) {
+                    // A `ctx.parallel([[s, input]])` tuple: safe ONLY when the OUTERMOST enclosing array
+                    // literal is itself directly an argument of a ctx call. Bound, iterated, destructured or
+                    // spread (`const a = [s]`, `[s].forEach`, `f(...[s])`) it is an alias: an escape.
+                    let outer = q;
+                    for (;;) {
+                        const o = strip(outer);
+                        if (o.parent !== undefined && typescript_1.default.isArrayLiteralExpression(o.parent))
+                            outer = o.parent;
+                        else {
+                            outer = o;
+                            break;
+                        }
+                    }
+                    const host = outer.parent;
+                    if (host !== undefined &&
+                        typescript_1.default.isVariableDeclaration(host) &&
+                        host.initializer === outer &&
+                        typescript_1.default.isIdentifier(host.name) &&
+                        typescript_1.default.isVariableDeclarationList(host.parent) &&
+                        (host.parent.flags & typescript_1.default.NodeFlags.Const) !== 0) {
+                        // `const pairs = [[s, 1]]; ctx.parallel(pairs)`: the list is followed (rule 5) only if
+                        // the binding is used nowhere but as a direct ctx-call argument.
+                        const listName = host.name.text;
+                        let clean = true;
+                        const scan = (n) => {
+                            if (!clean)
+                                return;
+                            if (typescript_1.default.isIdentifier(n) && n.text === listName && n !== host.name) {
+                                const isKey = (typescript_1.default.isPropertyAssignment(n.parent) && n.parent.name === n) ||
+                                    (typescript_1.default.isPropertyAccessExpression(n.parent) && n.parent.name === n);
+                                const t = strip(n);
+                                const c = t.parent;
+                                if (!isKey &&
+                                    !(c !== undefined &&
+                                        typescript_1.default.isCallExpression(c) &&
+                                        c.arguments.includes(t) &&
+                                        isCtxCall(c)))
+                                    clean = false;
+                            }
+                            typescript_1.default.forEachChild(n, scan);
+                        };
+                        scan(sourceFile);
+                        ok = clean;
+                    }
+                    else if (host !== undefined &&
+                        typescript_1.default.isPropertyAssignment(host) &&
+                        host.initializer === outer &&
+                        propName(host.name) === "steps" &&
+                        typescript_1.default.isObjectLiteralExpression(strip(host.parent)) &&
+                        (() => {
+                            const lit = strip(host.parent);
+                            const call = lit.parent;
+                            return (call !== undefined &&
+                                typescript_1.default.isCallExpression(call) &&
+                                call.arguments[0] === lit &&
+                                isLoomFlowBuilder(call.expression));
+                        })()) {
+                        // `flow$({ steps: [s] })` DECLARES the step: loom's own `flow$` (imported unshadowed from
+                        // @loomwork/core / @loomwork/sdk) keeps the list and the runtime only reads it.
+                        ok = true;
+                    }
+                    else {
+                        ok =
+                            host !== undefined &&
+                                typescript_1.default.isCallExpression(host) &&
+                                host.arguments.includes(outer) &&
+                                isCtxCall(host);
+                    }
+                }
+                else if (q !== undefined && typescript_1.default.isSpreadAssignment(q))
+                    ok = true;
+                else if (q !== undefined &&
+                    (typescript_1.default.isPropertyAccessExpression(q) || typescript_1.default.isElementAccessExpression(q)) &&
+                    q.expression === top) {
+                    // A property READ is fine; a write through it, or a method call on it, is not.
+                    let chain = q;
+                    while (chain.parent !== undefined &&
+                        (typescript_1.default.isPropertyAccessExpression(chain.parent) ||
+                            typescript_1.default.isElementAccessExpression(chain.parent)) &&
+                        chain.parent.expression === chain)
+                        chain = chain.parent;
+                    const callee = strip(chain).parent;
+                    const isMethodCall = callee !== undefined &&
+                        typescript_1.default.isCallExpression(callee) &&
+                        callee.expression === strip(chain);
+                    ok = !isWriteTarget(chain) && !isMethodCall;
+                }
+                if (!ok)
+                    escapes = true;
+            }
+        }
+        typescript_1.default.forEachChild(n, walk);
+    };
+    walk(sourceFile);
+    return escapes;
+}
+/** Short, stable source text for an unresolved expression (bounded for log safety). */
+function exprText(node) {
+    if (typescript_1.default.isTaggedTemplateExpression(node))
+        return `${exprText(node.tag)}\`…\``;
+    const text = node.getText().replace(/\s+/g, " ").trim();
+    return text.length > 80 ? `${text.slice(0, 77)}…` : text;
+}
+function isFn(node) {
+    return (typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node) || typescript_1.default.isFunctionDeclaration(node));
+}
+/**
+ * Collect functions declared in this region by name (`function f(){}`,
+ * `const f = (s) => …`), so `ctx.decide("x", f)` can be followed when `f` is local.
+ *
+ * Resolution is by TEXTUAL name in one flat map, so a name is only followed when it is
+ * unambiguous: declared exactly once in the region (as a function, a variable, a
+ * parameter or a binding), with `const`/`function`, and never reassigned. Anything else
+ * is left out, which makes `ctx.decide("x", name)` unresolved rather than silently
+ * binding to whichever declaration came last.
+ */
+function collectFunctions(root) {
+    return scanDeclarations(root).fns;
+}
+/** Same unambiguity rule as {@link collectFunctions}, for any `const NAME = <initializer>`. */
+function collectConstInits(root) {
+    return scanDeclarations(root).inits;
+}
+function scanDeclarations(root) {
+    const fns = new Map();
+    const inits = new Map();
+    const declared = new Map();
+    const ambiguous = new Set();
+    const declare = (name) => {
+        declared.set(name, (declared.get(name) ?? 0) + 1);
+    };
+    function visit(node) {
+        if (typescript_1.default.isFunctionDeclaration(node) && node.name !== undefined) {
+            declare(node.name.text);
+            fns.set(node.name.text, node);
+        }
+        else if ((typescript_1.default.isClassDeclaration(node) ||
+            typescript_1.default.isClassExpression(node) ||
+            typescript_1.default.isEnumDeclaration(node) ||
+            typescript_1.default.isFunctionExpression(node)) &&
+            node.name !== undefined) {
+            declare(node.name.text);
+            ambiguous.add(node.name.text);
+        }
+        else if (typescript_1.default.isModuleDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+            declare(node.name.text);
+            ambiguous.add(node.name.text);
+        }
+        else if (typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+            declare(node.name.text);
+            const isConst = (typescript_1.default.getCombinedNodeFlags(node) & typescript_1.default.NodeFlags.Const) !== 0;
+            if (!isConst)
+                ambiguous.add(node.name.text);
+            if (node.initializer !== undefined &&
+                (typescript_1.default.isArrowFunction(node.initializer) || typescript_1.default.isFunctionExpression(node.initializer))) {
+                fns.set(node.name.text, node.initializer);
+            }
+            if (node.initializer !== undefined)
+                inits.set(node.name.text, node.initializer);
+        }
+        else if (typescript_1.default.isParameter(node) && typescript_1.default.isIdentifier(node.name)) {
+            declare(node.name.text);
+        }
+        else if (typescript_1.default.isBindingElement(node) && typescript_1.default.isIdentifier(node.name)) {
+            declare(node.name.text);
+        }
+        else if (typescript_1.default.isBinaryExpression(node) &&
+            node.operatorToken.kind >= typescript_1.default.SyntaxKind.FirstAssignment &&
+            node.operatorToken.kind <= typescript_1.default.SyntaxKind.LastAssignment &&
+            typescript_1.default.isIdentifier(node.left)) {
+            ambiguous.add(node.left.text);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(root);
+    for (const name of [...fns.keys()]) {
+        if (ambiguous.has(name) || (declared.get(name) ?? 0) > 1)
+            fns.delete(name);
+    }
+    for (const name of [...inits.keys()]) {
+        if (ambiguous.has(name) || (declared.get(name) ?? 0) > 1)
+            inits.delete(name);
+    }
+    return { fns, inits, declared, ambiguous };
+}
+/** Every name bound by a binding name (identifier or destructuring pattern). */
+function bindingNames(name, out) {
+    if (typescript_1.default.isIdentifier(name))
+        out.add(name.text);
+    else
+        for (const el of name.elements)
+            if (!typescript_1.default.isOmittedExpression(el))
+                bindingNames(el.name, out);
+}
+/** Every name declared anywhere inside `node` (parameters, variables, patterns, functions, classes). */
+function namesDeclaredWithin(node) {
+    const out = new Set();
+    const visit = (n) => {
+        if ((typescript_1.default.isVariableDeclaration(n) || typescript_1.default.isParameter(n) || typescript_1.default.isBindingElement(n)) && n.name)
+            bindingNames(n.name, out);
+        else if ((typescript_1.default.isFunctionDeclaration(n) ||
+            typescript_1.default.isFunctionExpression(n) ||
+            typescript_1.default.isClassDeclaration(n) ||
+            typescript_1.default.isClassExpression(n) ||
+            typescript_1.default.isEnumDeclaration(n)) &&
+            n.name !== undefined)
+            out.add(n.name.text);
+        typescript_1.default.forEachChild(n, visit);
+    };
+    visit(node);
+    return out;
+}
+/** Whether any identifier inside `e` is in `names`. */
+function mentionsAny(e, names) {
+    if (typescript_1.default.isIdentifier(e) && names.has(e.text))
+        return true;
+    return typescript_1.default.forEachChild(e, (c) => (mentionsAny(c, names) ? true : undefined)) === true;
+}
+/** Import bindings of a module: local name -> module specifier and the imported (exported) name. */
+/** Every local name an import binds (named, default and namespace; type-only included, harmlessly). */
+function allImportBindings(sf) {
+    const out = new Set();
+    for (const st of sf.statements) {
+        if (!typescript_1.default.isImportDeclaration(st))
+            continue;
+        const clause = st.importClause;
+        if (clause === undefined)
+            continue;
+        if (clause.name !== undefined)
+            out.add(clause.name.text);
+        const nb = clause.namedBindings;
+        if (nb === undefined)
+            continue;
+        if (typescript_1.default.isNamespaceImport(nb))
+            out.add(nb.name.text);
+        else
+            for (const el of nb.elements)
+                out.add(el.name.text);
+    }
+    return out;
+}
+function importedNames(sf) {
+    const out = new Map();
+    for (const st of sf.statements) {
+        if (!typescript_1.default.isImportDeclaration(st) || !typescript_1.default.isStringLiteral(st.moduleSpecifier))
+            continue;
+        const clause = st.importClause;
+        if (clause === undefined || clause.isTypeOnly)
+            continue;
+        const nb = clause.namedBindings;
+        if (nb !== undefined && typescript_1.default.isNamedImports(nb)) {
+            for (const el of nb.elements) {
+                if (el.isTypeOnly)
+                    continue;
+                out.set(el.name.text, {
+                    spec: st.moduleSpecifier.text,
+                    imported: (el.propertyName ?? el.name).text,
+                });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Module specifiers a {@link KNOWN_STEP_FACTORIES} entry may be imported from: its package, and
+ * `@loomwork/sdk` where the SDK re-exports it (`export * from "@loomwork/plugin-mcp"`; the sandbox plugin
+ * is only at the `@loomwork/sdk/sandbox` subpath).
+ */
+const KNOWN_FACTORY_SOURCES = {
+    mcpInvoke$: ["@loomwork/plugin-mcp", "@loomwork/sdk"],
+    sandboxEval$: ["@loomwork/plugin-sandbox", "@loomwork/sandbox", "@loomwork/sdk/sandbox"],
+};
+/** The string a literal-ish expression denotes (`"x"`, an expression-free template, `"x" as const`). */
+function stringLiteralValue(e) {
+    const u = unwrap(e);
+    return typescript_1.default.isStringLiteral(u) || typescript_1.default.isNoSubstitutionTemplateLiteral(u) ? u.text : undefined;
+}
+/**
+ * L37 - infer how a function yields a step's effect id, by SHAPE (like {@link collectBindings}):
+ * its single returned expression is a call whose first argument is an object literal with a
+ * `toolId` that is a constant (per `str`) or one of the function's plain parameters. Anything else
+ * (several returns, a spread, a computed toolId) is `undefined`, never a guess.
+ */
+function inferStepFactory(fn, rawStr) {
+    if (!isFn(fn) || fn.body === undefined)
+        return undefined;
+    // Names declared anywhere in the factory (parameters, body locals, nested scopes) shadow a
+    // module constant of the same name, so an expression that mentions one is never constant-folded.
+    const inner = namesDeclaredWithin(fn);
+    const str = (e) => mentionsAny(e, inner) ? undefined : rawStr(e);
+    let returned;
+    if (!typescript_1.default.isBlock(fn.body))
+        returned = fn.body;
+    else {
+        let count = 0;
+        const scan = (n) => {
+            if (isFn(n) || typescript_1.default.isMethodDeclaration(n) || typescript_1.default.isClassLike(n))
+                return;
+            if (typescript_1.default.isReturnStatement(n)) {
+                count++;
+                returned = n.expression;
+            }
+            typescript_1.default.forEachChild(n, scan);
+        };
+        typescript_1.default.forEachChild(fn.body, scan);
+        if (count !== 1)
+            return undefined;
+    }
+    if (returned === undefined)
+        return undefined;
+    const call = unwrap(returned);
+    if (!typescript_1.default.isCallExpression(call))
+        return undefined;
+    const arg = call.arguments[0];
+    if (arg === undefined || !typescript_1.default.isObjectLiteralExpression(arg))
+        return undefined;
+    const paramIndex = (name) => {
+        const i = fn.parameters.findIndex((p) => typescript_1.default.isIdentifier(p.name) && p.name.text === name);
+        const p = fn.parameters[i];
+        return i >= 0 && p !== undefined && p.dotDotDotToken === undefined ? i : undefined;
+    };
+    const viaParam = (i) => {
+        const init = fn.parameters[i]?.initializer;
+        const dflt = init === undefined ? undefined : str(init);
+        return { argIndex: i, ...(dflt !== undefined && { default: dflt }) };
+    };
+    for (const prop of arg.properties) {
+        if (typescript_1.default.isShorthandPropertyAssignment(prop) && prop.name.text === "toolId") {
+            const i = paramIndex("toolId");
+            return i === undefined ? undefined : viaParam(i);
+        }
+        if (typescript_1.default.isPropertyAssignment(prop) && propName(prop.name) === "toolId") {
+            const v = unwrap(prop.initializer);
+            if (typescript_1.default.isIdentifier(v)) {
+                const i = paramIndex(v.text);
+                if (i !== undefined)
+                    return viaParam(i);
+            }
+            const fixed = str(v);
+            return fixed !== undefined ? { fixed } : undefined;
+        }
+    }
+    return undefined;
+}
+/** ExecutionContext members whose VALUE, handed out, lets the receiver run or suspend the flow. */
+const CTX_METHODS = new Set(["run", "execute", "parallel", "suspend", "sleep", "sleepUntil"]);
+/** Strip parentheses and type-only wrappers. */
+function unwrap(e) {
+    let cur = e;
+    while (typescript_1.default.isParenthesizedExpression(cur) ||
+        typescript_1.default.isAsExpression(cur) ||
+        typescript_1.default.isNonNullExpression(cur) ||
+        typescript_1.default.isSatisfiesExpression(cur) ||
+        typescript_1.default.isTypeAssertionExpression(cur) ||
+        (typescript_1.default.isBinaryExpression(cur) && cur.operatorToken.kind === typescript_1.default.SyntaxKind.CommaToken)) {
+        cur = typescript_1.default.isBinaryExpression(cur) ? cur.right : cur.expression;
+    }
+    return cur;
+}
+/** A runner expression that is plainly not a function value (no refusal needed). */
+function isInertValue(e) {
+    return (e.kind === typescript_1.default.SyntaxKind.NullKeyword ||
+        e.kind === typescript_1.default.SyntaxKind.TrueKeyword ||
+        e.kind === typescript_1.default.SyntaxKind.FalseKeyword ||
+        typescript_1.default.isStringLiteralLike(e) ||
+        typescript_1.default.isNumericLiteral(e) ||
+        (typescript_1.default.isIdentifier(e) && e.text === "undefined"));
+}
+/**
+ * Runner functions declared in this region: a `runner:` property or `runner = …` class field
+ * (inline or a local identifier / shorthand), a `runner(ctx, …) {}` method, the second argument
+ * of `registerFlow(def, runner)`, or a function bound to a `…FlowRunner`-typed variable. Their
+ * FIRST parameter is the flow's ctx whatever it is called.
+ *
+ * A runner VALUE that is not a followable function is never silently skipped (round 2):
+ *  - a call (`withRetry(async (c) => …)`, `makeRunner(lib)`): every function-literal argument
+ *    (or local function passed by name) is treated as a runner, because a wrapper hands its ctx
+ *    to the callback; and the call itself is reported `runner not analysable` since the wrapper
+ *    may do anything else with ctx;
+ *  - an identifier is followed to a local function or a `const` initializer, else refused
+ *    (imported, ambiguous);
+ *  - anything else (member access, conditional branches that are not functions) is refused.
+ */
+function collectRunners(root, functions) {
+    const out = [];
+    /** Followed runners tied to a `flow$` definition (see {@link boundContext}). */
+    const bound = new Set();
+    let boundNow = false;
+    const isFlowCall = (e) => {
+        if (e === undefined)
+            return false;
+        const u = unwrap(e);
+        if (!typescript_1.default.isCallExpression(u))
+            return false;
+        const c = unwrap(u.expression);
+        return ((typescript_1.default.isIdentifier(c) ? c.text : typescript_1.default.isPropertyAccessExpression(c) ? c.name.text : "") ===
+            "flow$");
+    };
+    /** An expression that IS a `flow$(...)` call, or an identifier bound once to a `const` holding one. */
+    const isFlowDefinition = (e) => {
+        if (e === undefined)
+            return false;
+        const u = unwrap(e);
+        return isFlowCall(u) || (typescript_1.default.isIdentifier(u) && isFlowCall(inits.get(u.text)));
+    };
+    /** Does this object literal / class body also hold a flow definition (`definition: flow$(...)`)? */
+    const holdsDefinition = (container) => {
+        if (container === undefined)
+            return false;
+        if (typescript_1.default.isObjectLiteralExpression(container)) {
+            return container.properties.some((m) => (typescript_1.default.isPropertyAssignment(m) && isFlowDefinition(m.initializer)) ||
+                (typescript_1.default.isShorthandPropertyAssignment(m) && isFlowDefinition(m.name)));
+        }
+        if (typescript_1.default.isClassLike(container)) {
+            return container.members.some((m) => typescript_1.default.isPropertyDeclaration(m) && isFlowDefinition(m.initializer));
+        }
+        return false;
+    };
+    const markBound = (f) => {
+        if (boundNow)
+            bound.add(f);
+    };
+    const unresolved = [];
+    const inits = collectConstInits(root);
+    const seenValues = new Set();
+    const refuse = (e) => {
+        const text = `runner not analysable: ${exprText(e)}`;
+        if (!unresolved.includes(text))
+            unresolved.push(text);
+    };
+    const argFn = (a) => {
+        const u = unwrap(a);
+        if (isFn(u))
+            return u;
+        return typescript_1.default.isIdentifier(u) ? functions.get(u.text) : undefined;
+    };
+    /** The functions a factory returns, or undefined unless EVERY return is a followable function. */
+    function returnedFns(factory) {
+        const body = factory.body;
+        if (body === undefined)
+            return undefined;
+        const found = [];
+        let ok = true;
+        const take = (e) => {
+            const f = e === undefined ? undefined : argFn(e);
+            if (f === undefined)
+                ok = false;
+            else
+                found.push(f);
+        };
+        if (!typescript_1.default.isBlock(body))
+            take(body);
+        else {
+            const scan = (n) => {
+                if (isFn(n) || typescript_1.default.isMethodDeclaration(n) || typescript_1.default.isClassLike(n))
+                    return;
+                if (typescript_1.default.isReturnStatement(n))
+                    take(n.expression);
+                typescript_1.default.forEachChild(n, scan);
+            };
+            typescript_1.default.forEachChild(body, scan);
+        }
+        return ok && found.length > 0 ? found : undefined;
+    }
+    function runnerValue(e) {
+        if (e === undefined)
+            return;
+        const u = unwrap(e);
+        if (seenValues.has(u)) {
+            if (isFn(u))
+                markBound(u);
+            return;
+        }
+        seenValues.add(u);
+        if (isFn(u)) {
+            out.push(u);
+            markBound(u);
+        }
+        else if (isInertValue(u)) {
+            return;
+        }
+        else if (typescript_1.default.isIdentifier(u)) {
+            const f = functions.get(u.text);
+            const init = inits.get(u.text);
+            if (f !== undefined) {
+                out.push(f);
+                markBound(f);
+            }
+            else if (init !== undefined)
+                runnerValue(init);
+            else
+                refuse(u);
+        }
+        else if (typescript_1.default.isCallExpression(u) || typescript_1.default.isNewExpression(u)) {
+            for (const a of u.arguments ?? []) {
+                const f = argFn(a);
+                if (f !== undefined) {
+                    out.push(f);
+                    markBound(f);
+                }
+            }
+            // A LOCAL factory (`makeRunner(lib)` where `function makeRunner` is in this region) whose
+            // every return is a function: those returned functions are the runners, nothing hidden.
+            const callee = typescript_1.default.isCallExpression(u) ? unwrap(u.expression) : undefined;
+            const factory = callee !== undefined && typescript_1.default.isIdentifier(callee) ? functions.get(callee.text) : undefined;
+            const returned = factory === undefined ? undefined : returnedFns(factory);
+            if (returned !== undefined) {
+                out.push(...returned);
+                for (const r of returned)
+                    markBound(r);
+            }
+            else
+                refuse(u);
+        }
+        else if (typescript_1.default.isConditionalExpression(u)) {
+            runnerValue(u.whenTrue);
+            runnerValue(u.whenFalse);
+        }
+        else {
+            refuse(u);
+        }
+    }
+    function visit(node) {
+        const prevBound = boundNow;
+        boundNow = false;
+        if (typescript_1.default.isPropertyAssignment(node) && propName(node.name) === "runner") {
+            boundNow = holdsDefinition(node.parent);
+            runnerValue(node.initializer);
+        }
+        else if (typescript_1.default.isShorthandPropertyAssignment(node) && node.name.text === "runner") {
+            boundNow = holdsDefinition(node.parent);
+            runnerValue(node.name);
+        }
+        else if (typescript_1.default.isMethodDeclaration(node) && propName(node.name) === "runner") {
+            out.push(node);
+            boundNow = holdsDefinition(node.parent);
+            markBound(node);
+        }
+        else if (typescript_1.default.isPropertyDeclaration(node) && propName(node.name) === "runner") {
+            boundNow = holdsDefinition(node.parent);
+            runnerValue(node.initializer);
+        }
+        else if (typescript_1.default.isGetAccessorDeclaration(node) && propName(node.name) === "runner") {
+            // `get runner() { return async (c) => … }`: the returned function(s) are the runner, like a
+            // local factory; a getter returning anything else is refused, never silently skipped.
+            const returned = returnedFns(node);
+            if (returned !== undefined) {
+                out.push(...returned);
+                if (holdsDefinition(node.parent))
+                    for (const r of returned)
+                        bound.add(r);
+            }
+            else {
+                const text = "runner not analysable: get runner()";
+                if (!unresolved.includes(text))
+                    unresolved.push(text);
+            }
+        }
+        else if (typescript_1.default.isCallExpression(node) &&
+            (typescript_1.default.isIdentifier(node.expression)
+                ? node.expression.text
+                : typescript_1.default.isPropertyAccessExpression(node.expression)
+                    ? node.expression.name.text
+                    : "") === "registerFlow") {
+            // Bound only when the definition argument IS (or names) this module's `flow$` call.
+            boundNow = isFlowDefinition(node.arguments[0]);
+            runnerValue(node.arguments[1]);
+        }
+        else if (typescript_1.default.isVariableDeclaration(node) &&
+            node.type !== undefined &&
+            /FlowRunner\b/.test(node.type.getText())) {
+            runnerValue(node.initializer);
+        }
+        boundNow = false;
+        typescript_1.default.forEachChild(node, visit);
+        boundNow = prevBound;
+    }
+    visit(root);
+    return { runners: out, bound, unresolved };
+}
+function propName(n) {
+    return typescript_1.default.isIdentifier(n) || typescript_1.default.isStringLiteralLike(n) ? n.text : undefined;
+}
+/**
+ * L32 — names that denote a flow's execution context in this region. Textual and module-wide:
+ *  - `ctx`, a parameter typed `…ExecutionContext` (or a local alias of that type), and the
+ *    receiver of a `.decide/.suspend/.sleepUntil` call;
+ *  - the FIRST parameter of every runner (`collectRunners`), whatever it is called, with an
+ *    object pattern splitting into method values and a rest name (which IS the ctx);
+ *  - propagation to a fixpoint: a ctx name handed as argument i to a same-module function adds
+ *    that function's i-th parameter, and `const { …rest } = <ctx name>` adds the rest name.
+ * Over-reports by design (a textual name shadowed elsewhere is still treated as ctx).
+ */
+function collectCtx(root, functions) {
+    const names = new Set(["ctx"]);
+    const members = new Map();
+    const unresolved = new Set();
+    const methods = new Set(["decide", "suspend", "sleepUntil"]);
+    // Local type aliases that resolve to an ExecutionContext.
+    const ctxTypes = new Set();
+    const isCtxType = (t) => t !== undefined &&
+        typescript_1.default.isTypeReferenceNode(t) &&
+        (/ExecutionContext$/.test(t.typeName.getText()) || ctxTypes.has(t.typeName.getText()));
+    for (let grew = true; grew;) {
+        grew = false;
+        const scanTypes = (n) => {
+            if (typescript_1.default.isTypeAliasDeclaration(n) && !ctxTypes.has(n.name.text) && isCtxType(n.type)) {
+                ctxTypes.add(n.name.text);
+                grew = true;
+            }
+            typescript_1.default.forEachChild(n, scanTypes);
+        };
+        scanTypes(root);
+    }
+    // Worklist: every name is processed once per set it joins, against indexes built by ONE walk.
+    const queue = [];
+    const addName = (n) => {
+        if (!names.has(n)) {
+            names.add(n);
+            queue.push(n);
+        }
+    };
+    const addMember = (n, m) => {
+        if (!members.has(n)) {
+            members.set(n, m);
+            queue.push(n);
+        }
+    };
+    const bindPattern = (pattern) => {
+        for (const el of pattern.elements) {
+            if (el.dotDotDotToken !== undefined) {
+                if (typescript_1.default.isIdentifier(el.name))
+                    addName(el.name.text);
+                else
+                    unresolved.add(`ctx pattern ${exprText(el)}`);
+                continue;
+            }
+            const key = el.propertyName ?? el.name;
+            const keyText = typescript_1.default.isIdentifier(key) || typescript_1.default.isStringLiteralLike(key) ? key.text : undefined;
+            if (keyText === "decide")
+                continue; // L31 reports every decide alias
+            if (keyText === undefined || !typescript_1.default.isIdentifier(el.name)) {
+                unresolved.add(`ctx pattern ${exprText(el)}`);
+                continue;
+            }
+            addMember(el.name.text, keyText);
+        }
+    };
+    const bindParam = (p) => {
+        if (typescript_1.default.isIdentifier(p.name))
+            addName(p.name.text);
+        else if (typescript_1.default.isObjectBindingPattern(p.name))
+            bindPattern(p.name);
+        else
+            unresolved.add(`ctx parameter ${exprText(p.name)}`);
+    };
+    const found = collectRunners(root, functions);
+    for (const u of found.unresolved)
+        unresolved.add(u);
+    for (const r of found.runners) {
+        const first = r.parameters[0];
+        if (first !== undefined)
+            bindParam(first);
+    }
+    // One walk: seed names, and index the places a name can flow onward from.
+    /** identifier argument -> the same-module parameter it is handed to. */
+    const argUses = new Map();
+    /** identifier -> declarations initialised from it (`const { … } = n`, `const k = n`). */
+    const declUses = new Map();
+    const push = (m, k, v) => {
+        const list = m.get(k);
+        if (list === undefined)
+            m.set(k, [v]);
+        else
+            list.push(v);
+    };
+    function index(node) {
+        if (typescript_1.default.isCallExpression(node) &&
+            typescript_1.default.isPropertyAccessExpression(node.expression) &&
+            methods.has(node.expression.name.text) &&
+            typescript_1.default.isIdentifier(node.expression.expression)) {
+            addName(node.expression.expression.text);
+        }
+        else if (typescript_1.default.isParameter(node) && typescript_1.default.isIdentifier(node.name) && isCtxType(node.type)) {
+            addName(node.name.text);
+        }
+        if (typescript_1.default.isCallExpression(node) || typescript_1.default.isNewExpression(node)) {
+            const callee = unwrap(node.expression);
+            const fn = typescript_1.default.isIdentifier(callee) ? functions.get(callee.text) : undefined;
+            if (fn !== undefined) {
+                (node.arguments ?? []).forEach((arg, i) => {
+                    const a = unwrap(arg);
+                    const param = fn.parameters[i];
+                    if (typescript_1.default.isIdentifier(a) &&
+                        param !== undefined &&
+                        param.dotDotDotToken === undefined &&
+                        typescript_1.default.isIdentifier(param.name)) {
+                        push(argUses, a.text, param);
+                    }
+                });
+            }
+        }
+        else if (typescript_1.default.isVariableDeclaration(node) && node.initializer !== undefined) {
+            const init = unwrap(node.initializer);
+            const isConst = (typescript_1.default.getCombinedNodeFlags(node) & typescript_1.default.NodeFlags.Const) !== 0;
+            if (typescript_1.default.isIdentifier(init) &&
+                (typescript_1.default.isObjectBindingPattern(node.name) || (isConst && typescript_1.default.isIdentifier(node.name)))) {
+                push(declUses, init.text, node);
+            }
+        }
+        typescript_1.default.forEachChild(node, index);
+    }
+    index(root);
+    for (const n of [...names])
+        queue.push(n);
+    for (const n of members.keys())
+        queue.push(n);
+    while (queue.length > 0) {
+        const n = queue.pop();
+        const asName = names.has(n);
+        const m = members.get(n);
+        for (const param of argUses.get(n) ?? []) {
+            const pn = param.name.text;
+            if (asName)
+                addName(pn);
+            if (m !== undefined)
+                addMember(pn, m);
+        }
+        for (const decl of declUses.get(n) ?? []) {
+            if (typescript_1.default.isObjectBindingPattern(decl.name)) {
+                if (asName)
+                    bindPattern(decl.name);
+            }
+            else if (typescript_1.default.isIdentifier(decl.name)) {
+                if (asName)
+                    addName(decl.name.text);
+                if (m !== undefined)
+                    addMember(decl.name.text, m);
+            }
+        }
+    }
+    return {
+        names,
+        members,
+        unresolved,
+        runners: found.runners.length,
+        boundRunners: found.bound.size,
+    };
+}
+/** The leftmost identifier of a member/call chain (`planner` for `planner.a.b(c).d`). */
+function chainRoot(e) {
+    let cur = e;
+    for (;;) {
+        if (typescript_1.default.isIdentifier(cur))
+            return cur.text;
+        if (typescript_1.default.isPropertyAccessExpression(cur) || typescript_1.default.isElementAccessExpression(cur))
+            cur = cur.expression;
+        else if (typescript_1.default.isCallExpression(cur) || typescript_1.default.isNonNullExpression(cur))
+            cur = cur.expression;
+        else if (typescript_1.default.isParenthesizedExpression(cur))
+            cur = cur.expression;
+        else
+            return undefined;
+    }
+}
+/**
+ * Where does a value go? Climb through literals/spreads/wrappers to the call or `new` that
+ * receives it as an argument; `undefined` when the value is stored, returned or otherwise
+ * leaves through something other than an argument. `direct` is true when the value IS the
+ * argument (not wrapped in a literal/spread), with its index.
+ */
+function receivingCall(node) {
+    let child = node;
+    let direct = true;
+    let p = node.parent;
+    while (p !== undefined) {
+        if (typescript_1.default.isParenthesizedExpression(p) ||
+            typescript_1.default.isAsExpression(p) ||
+            typescript_1.default.isNonNullExpression(p) ||
+            typescript_1.default.isSatisfiesExpression(p) ||
+            typescript_1.default.isTypeAssertionExpression(p)) {
+            child = p;
+            p = p.parent;
+            continue;
+        }
+        if (typescript_1.default.isObjectLiteralExpression(p) ||
+            typescript_1.default.isArrayLiteralExpression(p) ||
+            typescript_1.default.isSpreadAssignment(p) ||
+            typescript_1.default.isSpreadElement(p) ||
+            typescript_1.default.isShorthandPropertyAssignment(p) ||
+            (typescript_1.default.isPropertyAssignment(p) && p.initializer === child)) {
+            direct = false;
+            child = p;
+            p = p.parent;
+            continue;
+        }
+        if (typescript_1.default.isCallExpression(p) || typescript_1.default.isNewExpression(p)) {
+            const index = p.arguments?.indexOf(child) ?? -1;
+            if (index >= 0)
+                return { call: p, direct, index };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/** Callees that run their first argument (or forward the rest) rather than being the real target. */
+const PASS_THROUGH = new Set([
+    "Reflect.apply",
+    "setTimeout",
+    "setInterval",
+    "setImmediate",
+    "queueMicrotask",
+    "process.nextTick",
+]);
+/** Analyze a parsed node (a flow runner body) for reachable steps and suspend points. */
+function analyzeReachNode(root, location, options = {}) {
+    return analyzeReachRegion(root, location, options).reach;
+}
+/**
+ * {@link analyzeReachNode} plus how many runner functions the region declares and the analysis
+ * followed, and how many of them are BOUND to a `flow$` definition: declared in the same object
+ * literal / class as a `flow$(...)` (or a const holding one), or passed to `registerFlow(def, …)`
+ * whose `def` is a `flow$` call or names one. An EMPTY reach is ambiguous on its own: "the runner
+ * reaches nothing" and "no runner of THIS flow is here" (an unrelated runner elsewhere in the
+ * module, or one registered from another module) look the same. A runner that is NOT followable is
+ * never silent (`unresolved`), so an empty reach with `boundRunners > 0` means the flow's own
+ * runner was read and reaches no step, suspend or ctx hand-off: a pure runner, analysed.
+ */
+function analyzeReachRegion(root, location, options = {}) {
+    const scan = scanDeclarations(root);
+    const functions = scan.fns;
+    const constInits = scan.inits;
+    const sourceFile = typescript_1.default.isSourceFile(root) ? root : root.getSourceFile();
+    const declaredAnywhere = scan.declared;
+    const imports = importedNames(sourceFile);
+    // An imported name that is ALSO declared somewhere in the module (a same-named local in another
+    // function) is ambiguous in BOTH directions: the use may be the import or the local, so neither
+    // the local function/const/binding nor the import may answer for it (-> unresolved).
+    const importBindings = allImportBindings(sourceFile);
+    for (const name of importBindings) {
+        functions.delete(name);
+        constInits.delete(name);
+    }
+    // A step binding is followed only when its name is declared exactly once, never reassigned: a
+    // shadowing parameter or a second same-named binding in another function makes it ambiguous.
+    const bindings = collectBindings(root);
+    for (const name of [...bindings.keys()]) {
+        if ((declaredAnywhere.get(name) ?? 0) !== 1 ||
+            scan.ambiguous.has(name) ||
+            importBindings.has(name))
+            bindings.delete(name);
+    }
+    /** A name with no declaration anywhere in the module: only then can it be the import binding. */
+    const unshadowed = (name) => (declaredAnywhere.get(name) ?? 0) === 0;
+    const importer = options.importResolver;
+    const steps = [];
+    const unresolved = [];
+    const suspends = [];
+    const escapes = [];
+    const escapeSeen = new Set();
+    const ctx = collectCtx(root, functions);
+    const ctxNames = ctx.names;
+    const at = location !== undefined ? { location } : {};
+    for (const expr of ctx.unresolved)
+        unresolved.push({ expr, kind: "step", ...at });
+    /**
+     * L37 - the string a constant expression denotes: a literal, an expression-free or
+     * all-constant template, `a + b`, or an identifier bound once to such a `const` in this module
+     * (or IMPORTED from a relative module, when an `importResolver` is supplied). `undefined` for
+     * anything else - never a guess.
+     */
+    const constString = (e, depth = 0) => {
+        if (depth > 8)
+            return undefined;
+        const u = unwrap(e);
+        if (typescript_1.default.isStringLiteral(u) || typescript_1.default.isNoSubstitutionTemplateLiteral(u))
+            return u.text;
+        if (typescript_1.default.isTemplateExpression(u)) {
+            let out = u.head.text;
+            for (const span of u.templateSpans) {
+                const v = constString(span.expression, depth + 1);
+                if (v === undefined)
+                    return undefined;
+                out += v + span.literal.text;
+            }
+            return out;
+        }
+        if (typescript_1.default.isBinaryExpression(u) && u.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+            const l = constString(u.left, depth + 1);
+            const r = l === undefined ? undefined : constString(u.right, depth + 1);
+            return l !== undefined && r !== undefined ? l + r : undefined;
+        }
+        if (typescript_1.default.isIdentifier(u)) {
+            // Also declared somewhere in this module, yet imported: which one the use means is unknown.
+            if (imports.has(u.text) && !unshadowed(u.text))
+                return undefined;
+            const init = constInits.get(u.text);
+            if (init !== undefined)
+                return constString(init, depth + 1);
+            return unshadowed(u.text) ? importer?.(u.text)?.value : undefined;
+        }
+        return undefined;
+    };
+    /** A string property of an object literal, constant-resolved (`toolId: LLM_X`). */
+    const constProp = (obj, name) => {
+        // JS takes the LAST duplicate key, and a spread AFTER the key may override it: neither is
+        // authoritative, so the property is unresolved (a spread BEFORE the key is fine).
+        let found;
+        let count = 0;
+        let spreadAfter = false;
+        for (const p of obj.properties) {
+            if (typescript_1.default.isSpreadAssignment(p)) {
+                if (count > 0)
+                    spreadAfter = true;
+                continue;
+            }
+            if (typescript_1.default.isPropertyAssignment(p) && propName(p.name) === name) {
+                count++;
+                found = constString(p.initializer);
+            }
+            else if (typescript_1.default.isShorthandPropertyAssignment(p) && p.name.text === name) {
+                count++;
+                found = constString(p.name);
+            }
+        }
+        return count === 1 && !spreadAfter ? found : undefined;
+    };
+    /**
+     * L37 - a step-producing call: the shape-based `anything$({ toolId })` first, then a factory
+     * (same-module function, imported function, or a first-party one in {@link KNOWN_STEP_FACTORIES})
+     * whose effect id is fixed or one of its arguments. The step ID may be templated (`tool:${i}`):
+     * verify needs the EFFECT id.
+     */
+    const resolveCall = (call) => {
+        const first = call.arguments[0];
+        if (first !== undefined && typescript_1.default.isObjectLiteralExpression(first)) {
+            const toolId = constProp(first, "toolId");
+            if (toolId !== undefined) {
+                const stepId = constProp(first, "id");
+                return { toolId, ...(stepId !== undefined && { stepId }) };
+            }
+        }
+        const callee = unwrap(call.expression);
+        // A step with NO `toolId` dispatches its own id: the runtime resolves `step.toolId ?? step.id`
+        // (WorkflowRuntime). Followed only for `step$` itself (an unshadowed import from @loomwork/core or
+        // @loomwork/sdk, any alias) whose object has no `toolId` key and no spread: a wrapper might add one.
+        if (first !== undefined &&
+            typescript_1.default.isObjectLiteralExpression(first) &&
+            typescript_1.default.isIdentifier(callee) &&
+            unshadowed(callee.text) &&
+            first.properties.every((p) => !typescript_1.default.isSpreadAssignment(p) &&
+                !typescript_1.default.isMethodDeclaration(p) &&
+                !(p.name !== undefined && propName(p.name) === "toolId") &&
+                !(p.name !== undefined && typescript_1.default.isComputedPropertyName(p.name)))) {
+            const imp = imports.get(callee.text);
+            if (imp?.imported === "step$" &&
+                (imp.spec === "@loomwork/core" || imp.spec === "@loomwork/sdk")) {
+                const id = constProp(first, "id");
+                return id === undefined ? undefined : { toolId: id, stepId: id };
+            }
+        }
+        const name = typescript_1.default.isIdentifier(callee)
+            ? callee.text
+            : typescript_1.default.isPropertyAccessExpression(callee)
+                ? callee.name.text
+                : undefined;
+        if (name === undefined || call.arguments.some((a) => typescript_1.default.isSpreadElement(a)))
+            return undefined;
+        let shape;
+        const local = typescript_1.default.isIdentifier(callee) ? functions.get(name) : undefined;
+        if (local !== undefined)
+            shape = inferStepFactory(local, constString);
+        else if (!typescript_1.default.isIdentifier(callee) || !unshadowed(name))
+            shape = undefined;
+        else {
+            // A bare, undeclared name: the import binding. A relative wrapper is followed through the
+            // importer; a first-party factory only when imported from its own package (or the SDK).
+            const imp = imports.get(name);
+            shape = importer?.(name)?.factory;
+            if (shape === undefined &&
+                imp !== undefined &&
+                Object.hasOwn(exports.KNOWN_STEP_FACTORIES, imp.imported) &&
+                KNOWN_FACTORY_SOURCES[imp.imported]?.includes(imp.spec) === true) {
+                shape = exports.KNOWN_STEP_FACTORIES[imp.imported];
+            }
+        }
+        if (shape === undefined)
+            return undefined;
+        if ("fixed" in shape)
+            return { toolId: shape.fixed };
+        const arg = call.arguments[shape.argIndex];
+        const toolId = arg === undefined ? shape.default : constString(arg);
+        return toolId === undefined ? undefined : { toolId };
+    };
+    /**
+     * Resolve a `ctx.run` / `ctx.parallel` / hand-off step target to a tool, or `undefined` when it
+     * cannot be (reported unresolved by the caller - never silently dropped).
+     */
+    const isLoomFlowBuilder = (callee) => {
+        const c = unwrap(callee);
+        if (!typescript_1.default.isIdentifier(c) || !unshadowed(c.text))
+            return false;
+        const imp = imports.get(c.text);
+        return (imp?.imported === "flow$" && (imp.spec === "@loomwork/core" || imp.spec === "@loomwork/sdk"));
+    };
+    const escapeCache = new Map();
+    const resolveTarget = (target, depth = 0) => {
+        const t = unwrap(target);
+        if (typescript_1.default.isIdentifier(t)) {
+            // A step object that is mutated, aliased or handed to another function may no longer be what
+            // its declaration says (ADR 0086 amendment 2026-10-10): not followed, never guessed.
+            let escapes = escapeCache.get(t.text);
+            if (escapes === undefined) {
+                escapes = stepBindingEscapes(sourceFile, t.text, ctxNames, isLoomFlowBuilder);
+                escapeCache.set(t.text, escapes);
+            }
+            if (escapes)
+                return undefined;
+            const bound = bindings.get(t.text);
+            if (bound !== undefined)
+                return bound;
+            const init = constInits.get(t.text);
+            return init !== undefined && depth < 4 ? resolveTarget(init, depth + 1) : undefined;
+        }
+        if (typescript_1.default.isObjectLiteralExpression(t)) {
+            const toolId = constProp(t, "toolId");
+            if (toolId === undefined)
+                return undefined;
+            const stepId = constProp(t, "id");
+            return { toolId, ...(stepId !== undefined && { stepId }) };
+        }
+        if (typescript_1.default.isCallExpression(t))
+            return resolveCall(t);
+        return undefined;
+    };
+    const stripCallish = (c) => {
+        let cur = unwrap(c);
+        while (typescript_1.default.isPropertyAccessExpression(cur) &&
+            ["call", "apply", "bind"].includes(cur.name.text)) {
+            cur = unwrap(cur.expression);
+        }
+        return cur;
+    };
+    const isPlainChain = (e) => typescript_1.default.isIdentifier(e) || (typescript_1.default.isPropertyAccessExpression(e) && isPlainChain(e.expression));
+    /**
+     * L34 - the hand-off's arguments (at most the first 8) that resolve to a step.
+     */
+    function escapeArgs(site) {
+        const out = [];
+        (site.arguments ?? []).slice(0, 8).forEach((a, index) => {
+            const step = resolveTarget(a);
+            if (step !== undefined)
+                out.push({ index, step });
+        });
+        return out;
+    }
+    /**
+     * Record a hand-off to whatever `site` calls. `.call/.apply/.bind` on the callee is stripped
+     * and a pass-through (`Reflect.apply(lib, …)`, `setTimeout(lib, …)`) is unwrapped to its real
+     * target when that is a plain name; otherwise the hand-off is reported unresolved. A
+     * same-module callee is already analysed for a `decide` alias; for ctx or a ctx method it is
+     * reported (the value is wrapped or the parameter cannot be followed).
+     */
+    function recordEscape(site, via, member) {
+        const handed = via === "decide" ? "ctx.decide" : member !== undefined ? `ctx.${member}` : "ctx";
+        let callee = unwrap(site.expression);
+        const direct = exprText(callee);
+        if (!PASS_THROUGH.has(direct))
+            callee = stripCallish(callee);
+        if (PASS_THROUGH.has(direct)) {
+            const target = site.arguments?.[0] === undefined ? undefined : stripCallish(site.arguments[0]);
+            if (target === undefined || !isPlainChain(target)) {
+                unresolved.push({
+                    expr: `${handed} handed through ${direct} (target not static)`,
+                    kind: "step",
+                    ...at,
+                });
+                return;
+            }
+            callee = target;
+        }
+        else if (/^Promise\./.test(direct)) {
+            unresolved.push({ expr: `${handed} handed to ${direct}`, kind: "step", ...at });
+            return;
+        }
+        if (typescript_1.default.isIdentifier(callee) && functions.has(callee.text)) {
+            if (via === "decide")
+                return;
+            unresolved.push({
+                expr: `${handed} handed to same-module ${callee.text} in a shape that is not followed`,
+                kind: "step",
+                ...at,
+            });
+            return;
+        }
+        const text = exprText(callee);
+        const rootName = chainRoot(callee);
+        // The receiving callee is itself the ctx (`ctx.emit("x", ctx)`, `setTimeout(ctx.run, 0)`,
+        // `Reflect.apply(ctx.run, ctx, [step])`): there is no outside code to look up a declaration
+        // for, and `verify.reach["ctx"]` would be nonsense. The call is a ctx-method call whose
+        // argument this walk does not resolve, so refuse it (once per callee).
+        if (rootName !== undefined && (ctxNames.has(rootName) || ctx.members.has(rootName))) {
+            const key = `ctx-rooted:${text}`;
+            if (escapeSeen.has(key))
+                return;
+            escapeSeen.add(key);
+            unresolved.push({
+                expr: `ctx value handed to ctx-rooted ${text} (not resolved)`,
+                kind: "step",
+                ...at,
+            });
+            return;
+        }
+        // L34 - the other arguments, for a whole-ctx hand-off made directly (not through a
+        // pass-through, whose arguments are not the callee's).
+        const args = via === "ctx" && member === undefined && !PASS_THROUGH.has(direct)
+            ? escapeArgs(site)
+            : undefined;
+        const key = `${via}:${member ?? ""}:${text}:${args === undefined ? "" : JSON.stringify(args)}`;
+        if (escapeSeen.has(key))
+            return;
+        escapeSeen.add(key);
+        escapes.push({
+            callee: text,
+            ...(rootName !== undefined && { root: rootName }),
+            via,
+            ...(member !== undefined && { member }),
+            ...(args !== undefined && args.length > 0 && { args }),
+            ...at,
+        });
+    }
+    /** Route a ctx (or ctx-member) VALUE at `node` to its receiving callee, or report it stored. */
+    function routeValue(node, member) {
+        const recv = receivingCall(node);
+        if (recv === undefined) {
+            const what = member !== undefined ? `ctx.${member}` : "ctx";
+            // A value interpolated into a tagged template reads as the whole tagged expression.
+            let where = node.parent;
+            for (let p = node.parent; p !== undefined; p = p.parent) {
+                if (typescript_1.default.isTaggedTemplateExpression(p)) {
+                    where = p;
+                    break;
+                }
+                if (!typescript_1.default.isTemplateSpan(p) && !typescript_1.default.isTemplateExpression(p))
+                    break;
+            }
+            unresolved.push({ expr: `${what} stored as ${exprText(where)}`, kind: "step", ...at });
+            return;
+        }
+        // Direct hand-off to a same-module function: its i-th parameter was added to the ctx
+        // names (propagation) and its body is walked here, so it is followed — but only for the
+        // ctx itself, and only when the parameter is a plain identifier.
+        const callee = unwrap(recv.call.expression);
+        if (member === undefined && typescript_1.default.isIdentifier(callee) && functions.has(callee.text)) {
+            const fn = functions.get(callee.text);
+            const param = fn?.parameters[recv.index];
+            if (recv.direct &&
+                param !== undefined &&
+                param.dotDotDotToken === undefined &&
+                typescript_1.default.isIdentifier(param.name)) {
+                return;
+            }
+            unresolved.push({
+                expr: `ctx handed to same-module ${callee.text} where the parameter cannot be followed`,
+                kind: "step",
+                ...at,
+            });
+            return;
+        }
+        recordEscape(recv.call, "ctx", member);
+    }
+    /**
+     * `ctx.<m>` / `ctx["m"]`. A direct call is the normal path (the walk analyses it). A method
+     * taken as a VALUE (`lib(ctx.run)`, `ctx.run.bind(ctx)`, `ctx.run.call(ctx, step)`) hands the
+     * receiver the ability to run or suspend the flow: an escape like `ctx.decide`.
+     */
+    function flagCtxMember(access) {
+        let member;
+        if (typescript_1.default.isPropertyAccessExpression(access))
+            member = access.name.text;
+        else if (typescript_1.default.isStringLiteralLike(access.argumentExpression))
+            member = access.argumentExpression.text;
+        else {
+            unresolved.push({ expr: `ctx dynamic member ${exprText(access)}`, kind: "step", ...at });
+            return;
+        }
+        if (member === "decide" || !CTX_METHODS.has(member))
+            return; // L31 / data properties
+        // The expression the member value flows out of, skipping wrappers.
+        let top = access;
+        while (top.parent !== undefined &&
+            (typescript_1.default.isParenthesizedExpression(top.parent) ||
+                typescript_1.default.isNonNullExpression(top.parent) ||
+                typescript_1.default.isAsExpression(top.parent))) {
+            top = top.parent;
+        }
+        const parent = top.parent;
+        if (parent !== undefined && typescript_1.default.isCallExpression(parent) && parent.expression === top) {
+            // Direct call. Property form is analysed by the receiver-agnostic walk; the
+            // element-access form is not, so do it here.
+            if (typescript_1.default.isElementAccessExpression(access)) {
+                if (member === "run")
+                    visitRun(parent);
+                else if (member === "parallel")
+                    visitParallel(parent);
+                else if (member === "suspend")
+                    visitSuspend(parent);
+            }
+            return;
+        }
+        if (parent !== undefined &&
+            typescript_1.default.isPropertyAccessExpression(parent) &&
+            parent.expression === top) {
+            const op = parent.name.text;
+            const gp = parent.parent;
+            const called = gp !== undefined && typescript_1.default.isCallExpression(gp) && gp.expression === parent;
+            if (called && (op === "call" || op === "apply")) {
+                if (op === "call" && member === "run")
+                    visitRun(gp, 1);
+                else if (op === "call" && member === "parallel")
+                    visitParallel(gp, 1);
+                else if (op === "call" && member === "suspend")
+                    visitSuspend(gp, 1);
+                else if (op === "apply" &&
+                    (member === "run" || member === "suspend" || member === "parallel")) {
+                    unresolved.push({
+                        expr: `ctx.${member}.apply(…)`,
+                        kind: member === "suspend" ? "suspend" : "step",
+                        ...at,
+                    });
+                }
+                return;
+            }
+            if (called && op === "bind") {
+                routeValue(gp, member);
+                return;
+            }
+            return; // `ctx.run.length` and the like
+        }
+        routeValue(top, member);
+    }
+    /** A reference to the execution context (or a method taken off it) in a value position. */
+    function flagCtxReference(node, kind) {
+        const parent = node.parent;
+        if ((typescript_1.default.isPropertyAccessExpression(parent) && parent.name === node) ||
+            (typescript_1.default.isPropertyAssignment(parent) && parent.name === node) ||
+            (typescript_1.default.isParameter(parent) && parent.name === node) ||
+            (typescript_1.default.isVariableDeclaration(parent) && parent.name === node) ||
+            (typescript_1.default.isBindingElement(parent) && (parent.name === node || parent.propertyName === node)) ||
+            typescript_1.default.isTypeOfExpression(parent) ||
+            (typescript_1.default.isBinaryExpression(parent) &&
+                [
+                    typescript_1.default.SyntaxKind.EqualsEqualsToken,
+                    typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken,
+                    typescript_1.default.SyntaxKind.ExclamationEqualsToken,
+                    typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken,
+                ].includes(parent.operatorToken.kind))) {
+            return;
+        }
+        // `const k = ctx` — a const alias is itself a ctx name (collectCtx), so it is followed
+        // rather than reported stored. `let`/reassigned stays stored-unresolved.
+        if (typescript_1.default.isVariableDeclaration(parent) &&
+            parent.initializer !== undefined &&
+            unwrap(parent.initializer) === node &&
+            typescript_1.default.isIdentifier(parent.name) &&
+            (typescript_1.default.getCombinedNodeFlags(parent) & typescript_1.default.NodeFlags.Const) !== 0) {
+            return;
+        }
+        if (kind === "method") {
+            const member = ctx.members.get(node.text);
+            if (typescript_1.default.isCallExpression(parent) && parent.expression === node) {
+                if (member === "run")
+                    visitRun(parent);
+                else if (member === "parallel")
+                    visitParallel(parent);
+                else if (member === "suspend")
+                    visitSuspend(parent);
+                return;
+            }
+            routeValue(node, member);
+            return;
+        }
+        if ((typescript_1.default.isPropertyAccessExpression(parent) || typescript_1.default.isElementAccessExpression(parent)) &&
+            parent.expression === node) {
+            flagCtxMember(parent);
+            return;
+        }
+        // `const { decide, …rest } = ctx` — `decide` is L31's, the rest names were bound as ctx.
+        if (typescript_1.default.isVariableDeclaration(parent) &&
+            parent.initializer === node &&
+            typescript_1.default.isObjectBindingPattern(parent.name)) {
+            return;
+        }
+        // `ctx.run.bind(ctx)` / `.call(ctx, …)`: the ctx argument belongs to the member call,
+        // which flagCtxMember already routes.
+        const recv = receivingCall(node);
+        if (recv !== undefined) {
+            const e = unwrap(recv.call.expression);
+            if (typescript_1.default.isPropertyAccessExpression(e) && ["bind", "call", "apply"].includes(e.name.text)) {
+                const m = unwrap(e.expression);
+                const mm = typescript_1.default.isPropertyAccessExpression(m) && typescript_1.default.isIdentifier(unwrap(m.expression))
+                    ? unwrap(m.expression).text
+                    : undefined;
+                if (mm !== undefined &&
+                    ctxNames.has(mm) &&
+                    CTX_METHODS.has(m.name.text))
+                    return;
+            }
+        }
+        routeValue(node);
+    }
+    function visitRun(call, argOffset = 0) {
+        const target = call.arguments[argOffset];
+        if (target === undefined)
+            return;
+        const ref = resolveTarget(target);
+        if (ref !== undefined) {
+            steps.push(ref);
+            return;
+        }
+        // An element access, a parameter, a factory whose effect id is not constant - all real and
+        // all unresolvable from this region alone.
+        unresolved.push({ expr: exprText(target), kind: "step", ...at });
+    }
+    /**
+     * L35 - `ctx.parallel([[step, input], …])`. Each tuple's first element is a `ctx.run` target,
+     * resolved the same way. A branch written as a callback is already walked (its `b.run(...)` is
+     * found like any `run`). A pair list that is not an array literal (or a const bound to one), a
+     * spread, or a branch that is neither a tuple nor a function is reported unresolved: the steps
+     * it holds cannot be seen, and an empty answer would read as "reaches nothing".
+     */
+    function listUsedBeyondParallel(name) {
+        let used = false;
+        const walk = (n) => {
+            if (used)
+                return;
+            if (typescript_1.default.isIdentifier(n) && n.text === name) {
+                let top = n;
+                while (top.parent !== undefined &&
+                    (typescript_1.default.isParenthesizedExpression(top.parent) ||
+                        typescript_1.default.isAsExpression(top.parent) ||
+                        typescript_1.default.isNonNullExpression(top.parent) ||
+                        typescript_1.default.isSatisfiesExpression(top.parent)))
+                    top = top.parent;
+                const p = n.parent;
+                const isDecl = typescript_1.default.isVariableDeclaration(p) && p.name === n;
+                const isMemberName = typescript_1.default.isPropertyAccessExpression(p) && p.name === n;
+                const isKey = (typescript_1.default.isPropertyAssignment(p) || typescript_1.default.isPropertySignature(p)) && p.name === n;
+                const isParallelArg = top.parent !== undefined &&
+                    typescript_1.default.isCallExpression(top.parent) &&
+                    methodCall(top.parent, "parallel") !== undefined &&
+                    top.parent.arguments.includes(top);
+                if (!isDecl && !isMemberName && !isKey && !isParallelArg)
+                    used = true;
+            }
+            typescript_1.default.forEachChild(n, walk);
+        };
+        walk(sourceFile);
+        return used;
+    }
+    function visitParallel(call, argOffset = 0) {
+        const arg = call.arguments[argOffset];
+        if (arg === undefined)
+            return;
+        let list = unwrap(arg);
+        if (typescript_1.default.isIdentifier(list)) {
+            const init = constInits.get(list.text);
+            if (init !== undefined) {
+                // A list that is also pushed to / passed on / iterated is not the literal it was bound to.
+                if (listUsedBeyondParallel(list.text)) {
+                    unresolved.push({ expr: `parallel(${exprText(arg)})`, kind: "step", ...at });
+                    return;
+                }
+                list = unwrap(init);
+            }
+        }
+        if (!typescript_1.default.isArrayLiteralExpression(list)) {
+            unresolved.push({ expr: `parallel(${exprText(arg)})`, kind: "step", ...at });
+            return;
+        }
+        for (const el of list.elements) {
+            if (typescript_1.default.isSpreadElement(el)) {
+                unresolved.push({ expr: `parallel(...${exprText(el.expression)})`, kind: "step", ...at });
+                continue;
+            }
+            const u = unwrap(el);
+            if (typescript_1.default.isArrayLiteralExpression(u)) {
+                const first = u.elements[0];
+                if (first === undefined || typescript_1.default.isSpreadElement(first)) {
+                    unresolved.push({ expr: `parallel branch ${exprText(u)}`, kind: "step", ...at });
+                    continue;
+                }
+                const ref = resolveTarget(first);
+                if (ref !== undefined)
+                    steps.push(ref);
+                else
+                    unresolved.push({ expr: exprText(first), kind: "step", ...at });
+            }
+            else if (isFn(u) || (typescript_1.default.isIdentifier(u) && functions.has(u.text))) {
+                // A callback branch: its body is part of this walk.
+            }
+            else {
+                unresolved.push({ expr: `parallel branch ${exprText(u)}`, kind: "step", ...at });
+            }
+        }
+    }
+    function visitSuspend(call, argOffset = 0) {
+        const condition = call.arguments[argOffset];
+        if (condition === undefined || !typescript_1.default.isObjectLiteralExpression(condition)) {
+            // A condition built elsewhere. Recording it as unresolved keeps a flow that
+            // suspends from looking like a flow that does not.
+            unresolved.push({
+                expr: condition === undefined ? "suspend()" : exprText(condition),
+                kind: "suspend",
+                ...at,
+            });
+            return;
+        }
+        const on = stringProp(condition, "on");
+        const correlationKey = stringProp(condition, "correlationKey");
+        suspends.push({
+            ...(on !== undefined && { id: on }),
+            ...(correlationKey !== undefined && { correlationKey }),
+            ...(hasProp(condition, "timeout") && { timed: true }),
+            ...(hasProp(condition, "wakeAt") && { wakeAt: true }),
+        });
+    }
+    /**
+     * L31 — a `ctx.decide(id, decider)` decider receives a scope whose
+     * `invokeTransient(toolId, …)` runs an effect as the deciding execution. Those calls
+     * are reached effects exactly like `ctx.run` targets, but live in a callback the
+     * `ctx.run` walk never classified.
+     *
+     * The scope is tracked by BINDING: the first parameter, either an identifier
+     * (`(scope) =>`) whose only permitted use is as the receiver of a called
+     * `.invokeTransient`, or an object pattern (`({ invokeTransient })`, with or without a
+     * rename) whose bound name may only be called. ANY other use — passing the scope on,
+     * aliasing it, `scope["invokeTransient"]`, a rest element — is reported as unresolved,
+     * because the call it hides cannot be seen. Name matching is textual: a nested
+     * function that shadows the scope's name is treated as the scope (over-reports, never
+     * under-reports).
+     */
+    function visitDecide(call) {
+        if (call.arguments.some((a) => typescript_1.default.isSpreadElement(a))) {
+            unresolved.push({
+                expr: `decide(${exprText(call.arguments[0] ?? call)})`,
+                kind: "step",
+                ...at,
+            });
+            return;
+        }
+        const decider = call.arguments[1];
+        if (decider === undefined)
+            return;
+        let fn;
+        if (isFn(decider))
+            fn = decider;
+        else if (typescript_1.default.isIdentifier(decider))
+            fn = functions.get(decider.text);
+        if (fn === undefined) {
+            // A decider whose body is not in this region (imported, returned from a factory,
+            // a member). It may take a scope and call anything; same treatment as an
+            // unresolvable `ctx.run` target.
+            unresolved.push({ expr: `decide(${exprText(decider)})`, kind: "step", ...at });
+            return;
+        }
+        const param = fn.parameters[0];
+        if (param === undefined || fn.body === undefined)
+            return; // never receives a scope
+        const scopeNames = new Set();
+        const callNames = new Set();
+        if (typescript_1.default.isIdentifier(param.name)) {
+            scopeNames.add(param.name.text);
+        }
+        else if (typescript_1.default.isObjectBindingPattern(param.name)) {
+            for (const el of param.name.elements) {
+                if (el.dotDotDotToken !== undefined) {
+                    unresolved.push({ expr: `decide scope rest ${exprText(el)}`, kind: "step", ...at });
+                    continue;
+                }
+                const key = el.propertyName ?? el.name;
+                const keyText = typescript_1.default.isIdentifier(key) || typescript_1.default.isStringLiteral(key) || typescript_1.default.isNoSubstitutionTemplateLiteral(key)
+                    ? key.text
+                    : undefined;
+                // A computed key could be anything; a nested pattern or non-identifier name
+                // could bind `invokeTransient` where the call cannot be followed.
+                const couldBind = keyText === "invokeTransient" || typescript_1.default.isComputedPropertyName(key);
+                if (!couldBind)
+                    continue;
+                if (keyText === "invokeTransient" && typescript_1.default.isIdentifier(el.name)) {
+                    callNames.add(el.name.text);
+                }
+                else {
+                    unresolved.push({ expr: `decide scope ${exprText(el)}`, kind: "step", ...at });
+                }
+            }
+        }
+        else {
+            unresolved.push({ expr: `decide(${exprText(param)})`, kind: "step", ...at });
+            return;
+        }
+        if (scopeNames.size === 0 && callNames.size === 0)
+            return;
+        const record = (c) => {
+            const first = c.arguments[0];
+            const id = first === undefined ? undefined : constString(first);
+            if (id !== undefined)
+                steps.push({ toolId: id, viaDecider: true });
+            else {
+                const arg = c.arguments[0];
+                unresolved.push({
+                    expr: `invokeTransient(${arg === undefined ? "" : exprText(arg)})`,
+                    kind: "step",
+                    ...at,
+                });
+            }
+        };
+        const escaped = (n) => {
+            unresolved.push({ expr: `decide scope used as ${exprText(n.parent)}`, kind: "step", ...at });
+        };
+        function scan(node) {
+            if (typescript_1.default.isIdentifier(node)) {
+                const parent = node.parent;
+                // Property names and declaration names are not references.
+                const isName = (typescript_1.default.isPropertyAccessExpression(parent) && parent.name === node) ||
+                    (typescript_1.default.isPropertyAssignment(parent) && parent.name === node) ||
+                    (typescript_1.default.isBindingElement(parent) && parent.propertyName === node);
+                if (!isName) {
+                    if (scopeNames.has(node.text)) {
+                        const grand = parent.parent;
+                        if (typescript_1.default.isPropertyAccessExpression(parent) &&
+                            parent.expression === node &&
+                            parent.name.text === "invokeTransient" &&
+                            grand !== undefined &&
+                            typescript_1.default.isCallExpression(grand) &&
+                            grand.expression === parent) {
+                            record(grand);
+                        }
+                        else {
+                            escaped(node);
+                        }
+                    }
+                    else if (callNames.has(node.text)) {
+                        if (typescript_1.default.isCallExpression(parent) && parent.expression === node)
+                            record(parent);
+                        else
+                            escaped(node);
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(node, scan);
+        }
+        scan(fn.body);
+    }
+    /**
+     * `ctx.decide` reached by any route other than a direct `<x>.decide(…)` call hides a
+     * decider this walk would have followed: `ctx.decide.bind(ctx)`, `const f = ctx.decide`,
+     * `const { decide } = ctx`, a `({ decide }) =>` runner parameter, `ctx["decide"](…)`.
+     * Receiver-agnostic like `methodCall`; reported as unresolved so the shape cannot pass
+     * vacuously.
+     */
+    function flagIndirectDecide(node) {
+        let hit = false;
+        if (typescript_1.default.isPropertyAccessExpression(node) && node.name.text === "decide") {
+            const p = node.parent;
+            hit = !(typescript_1.default.isCallExpression(p) && p.expression === node);
+        }
+        else if (typescript_1.default.isElementAccessExpression(node) &&
+            typescript_1.default.isStringLiteralLike(node.argumentExpression) &&
+            node.argumentExpression.text === "decide") {
+            hit = true;
+        }
+        else if (typescript_1.default.isBindingElement(node) && node.dotDotDotToken === undefined) {
+            const key = node.propertyName ?? node.name;
+            hit = (typescript_1.default.isIdentifier(key) || typescript_1.default.isStringLiteralLike(key)) && key.text === "decide";
+        }
+        if (!hit)
+            return;
+        // L32 — `lib({ decide: ctx.decide })` hands the decider seam to a callee a declaration may
+        // cover; every other alias shape has no callee to look up.
+        if (typescript_1.default.isPropertyAccessExpression(node)) {
+            const recv = receivingCall(node);
+            if (recv !== undefined) {
+                recordEscape(recv.call, "decide");
+                return;
+            }
+        }
+        unresolved.push({ expr: `decide alias ${exprText(node)}`, kind: "step", ...at });
+    }
+    function visit(node) {
+        const run = methodCall(node, "run");
+        if (run !== undefined)
+            visitRun(run);
+        const parallel = methodCall(node, "parallel");
+        if (parallel !== undefined)
+            visitParallel(parallel);
+        const decide = methodCall(node, "decide");
+        if (decide !== undefined)
+            visitDecide(decide);
+        else
+            flagIndirectDecide(node);
+        if (typescript_1.default.isIdentifier(node)) {
+            if (ctxNames.has(node.text))
+                flagCtxReference(node, "ctx");
+            else if (ctx.members.has(node.text))
+                flagCtxReference(node, "method");
+        }
+        const suspend = methodCall(node, "suspend");
+        if (suspend !== undefined)
+            visitSuspend(suspend);
+        // `ctx.sleep`/`sleepUntil` are deliberately NOT recorded. The kernel authors
+        // their condition (`on: TIMER_FIRED`, `wakeAt` always set), so treating them
+        // as user-authored suspend points would manufacture findings about code the
+        // developer never wrote.
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(root);
+    return {
+        reach: { steps, unresolved, suspends, ...(escapes.length > 0 && { escapes }) },
+        runners: ctx.runners,
+        boundRunners: ctx.boundRunners,
+    };
+}
+/**
+ * Analyze a source string (a flow runner / orchestration body). Feed the result
+ * to `@loomwork/verify` via `resolveVerifyInput({ runnerReachByFlow })`.
+ */
+function analyzeRunnerReach(source, location) {
+    const sf = typescript_1.default.createSourceFile("runner.ts", source, typescript_1.default.ScriptTarget.ESNext, true);
+    return analyzeReachNode(sf, location);
+}
+//# sourceMappingURL=runnerReach.js.map