@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

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

@@ -0,0 +1,225 @@
+import ts from "typescript";
+import { artifactRowOfSymbol, markerFunctionOfSymbol, worldReadOpOfSymbol, siteProducingFunctionOfSymbol, } from "../facade/registry.js";
+import { WORKFLOW_FUNCTION_NAME, } from "../compiler/compile.js";
+import { callbackSemanticsOf, isGlobalLibValue } from "./callbacks.js";
+import { actorName, actorNamePattern, askLabel, askLabelPattern, eachCandidate, forOfCandidate, isFacadeDeclared, literalText, resolveSymbol, SiteCounters, worldReadLabel, } from "./sites-labels.js";
+import { holeSiteOf } from "./hole-sites.js";
+import { holeSiteId } from "./hole-id.js";
+// 拆分：本文件顶到 oxlint max-lines 上限（400 行）。名字 / 标签辅助与符号解析
+// （resolveSymbol / isFacadeDeclared）搬到 sites-labels.ts；后两者原本就从这里导出，故原样
+// 再导出，既有的 `from "./sites.js"` 引用一个不改。站点类型留在本文件（五个模块按此路径导入）。
+export { isFacadeDeclared, resolveSymbol } from "./sites-labels.js";
+/** Collect the site table by walking the wrapped script's `__workflowScript__` body. */
+export function collectSites(workflow) {
+    const { program, scriptFile, toScriptLoc } = workflow;
+    const checker = program.getTypeChecker();
+    const body = findWorkflowBody(scriptFile);
+    const table = {
+        actors: [],
+        artifacts: [],
+        asks: [],
+        holes: [],
+        iterations: [],
+        joins: [],
+        phases: [],
+        reports: [],
+        topLevelReturns: [],
+        worldReads: [],
+    };
+    let order = 0;
+    const locOf = (node) => toScriptLoc(node.getStart(scriptFile));
+    // `ids` 是当前作用域的 per-kind 计数器组：顶层一套，每个留白函数体一套新的（带前缀）。
+    // 返回值只在收到一个**带函数体的留白**时非空：walk 据此给函数体换计数器。
+    const classify = (node, funcDepth, ids) => {
+        if (ts.isReturnStatement(node)) {
+            if (funcDepth === 0) {
+                table.topLevelReturns.push({ expression: node.expression, loc: locOf(node) });
+            }
+            return;
+        }
+        if (ts.isForOfStatement(node)) {
+            table.iterations.push(forOfCandidate(node, order++, locOf(node)));
+            return;
+        }
+        if (!ts.isCallExpression(node))
+            return;
+        if (ts.isPropertyAccessExpression(node.expression)) {
+            const access = node.expression;
+            const propSymbol = checker.getSymbolAtLocation(access.name);
+            if (isFacadeDeclared(propSymbol)) {
+                const name = access.name.text;
+                if (name === "ask") {
+                    const labelPattern = askLabelPattern(access.expression, checker);
+                    table.asks.push({
+                        call: node,
+                        id: ids.next("ask"),
+                        instructions: node.arguments[0],
+                        label: askLabel(access.expression, checker),
+                        ...(labelPattern === undefined ? {} : { labelPattern }),
+                        loc: toScriptLoc(access.name.getStart(scriptFile)),
+                        order: order++,
+                        receiver: access.expression,
+                    });
+                    return;
+                }
+                // 产物成员先于 world-read 判定，两张表互斥（同一个 (容器,成员) 不可能同时在两张
+                // 表里）。身份同样按**声明容器**取，不按名字：`artifact.table` 与脚本自己的某个
+                // `table` 方法只有声明能分辨。
+                const artifact = artifactRowOfSymbol(propSymbol);
+                if (artifact !== undefined) {
+                    const idExpr = node.arguments[0];
+                    const id = literalText(idExpr);
+                    table.artifacts.push({
+                        artifactIdExpr: idExpr,
+                        ...(id === undefined ? {} : { artifactId: id }),
+                        call: node,
+                        id: ids.next("artifact"),
+                        loc: toScriptLoc(access.name.getStart(scriptFile)),
+                        op: artifact.op,
+                        order: order++,
+                    });
+                    return;
+                }
+                // World-read identity comes from the registry, keyed on the member's DECLARING
+                // CONTAINER — never on its bare name. `git.log` collides with the top-level
+                // `log()` by name, so a bare-name test would either mint a world-read site for
+                // every progress message or drop `git.log`'s site entirely; a facade call with no
+                // site has no journal key, which is the exact unsoundness the facade-siting rule
+                // exists to prevent.
+                const op = worldReadOpOfSymbol(propSymbol);
+                if (op !== undefined) {
+                    table.worldReads.push({
+                        args: node.arguments,
+                        call: node,
+                        id: ids.next("world-read"),
+                        label: worldReadLabel(op, node.arguments[0]),
+                        loc: toScriptLoc(access.name.getStart(scriptFile)),
+                        op,
+                        order: order++,
+                    });
+                }
+                return;
+            }
+            const method = access.name.text;
+            if ((method === "all" || method === "allSettled") &&
+                isGlobalLibValue(access.expression, "Promise", checker, program)) {
+                table.joins.push({
+                    arg: node.arguments[0],
+                    call: node,
+                    id: ids.next("join"),
+                    label: "join",
+                    loc: toScriptLoc(access.name.getStart(scriptFile)),
+                    method,
+                    order: order++,
+                });
+                return;
+            }
+            // Per-element callback calls per the registry (`xs.map(fn)`, `Array.from(xs, fn)`, …)
+            // register as fan-out candidates whatever shape the callback argument has.
+            const semantics = callbackSemanticsOf(node, checker, program);
+            if (semantics?.multiplicity === "each") {
+                const candidate = eachCandidate(node, semantics, order, locOf(node));
+                if (candidate !== undefined) {
+                    order++;
+                    table.iterations.push(candidate);
+                }
+            }
+            return;
+        }
+        // Bare-callee call: the facade ones are `agent(...)` and `report(...)`. Which
+        // top-level functions produce sites lives in the registry, not here — `log()` is a
+        // bare facade call too, and the difference between it and `report()` is that a report
+        // has a journal row keyed by its site.
+        const calleeSymbol = resolveSymbol(node.expression, checker);
+        const fn = siteProducingFunctionOfSymbol(calleeSymbol);
+        if (fn === "agent") {
+            const name = actorName(node);
+            // pattern 只在真拿不到名字时才求：字面量名与绑定名都是**名字**，重建物不得顶掉它们。
+            const namePattern = name === undefined ? actorNamePattern(node) : undefined;
+            table.actors.push({
+                call: node,
+                id: ids.next("actor"),
+                loc: locOf(node),
+                name,
+                ...(namePattern === undefined ? {} : { namePattern }),
+                order: order++,
+            });
+            return;
+        }
+        if (fn === "report") {
+            // 第二实参是**产物标签**：只有无洞字面量才算标签，
+            // 其余（标识符、带洞模板）留给 artifacts 诊断趟按 artifactIdExpr 定位——绝不在这里
+            // 猜一个 id 出来，那会让一条指向不存在看板的 report 静默通过编译。
+            const tagExpr = node.arguments[1];
+            const tag = literalText(tagExpr);
+            table.reports.push({
+                artifactIdExpr: tagExpr,
+                ...(tag === undefined ? {} : { artifactId: tag }),
+                call: node,
+                id: ids.next("report"),
+                item: node.arguments[0],
+                loc: locOf(node),
+                order: order++,
+            });
+            return;
+        }
+        if (fn === "hole") {
+            // 留白（docs/analysis.md「Sites」的 Hole sites 段）：id 是名字键（hole-id.ts），占全局 order；
+            // 带函数体时交回给 walk，让函数体在一套**全新的、带前缀的**计数器下走查。名字不是字面量
+            // 时（9012，脚本提交不了）退回位置计数器，只为让诊断有个可定位的站点。
+            const holeName = literalText(node.arguments[0]);
+            const holeId = holeName === undefined ? ids.next("hole") : holeSiteId(holeName);
+            const site = holeSiteOf(node, holeId, order++, locOf(node), funcDepth, ids.holeId);
+            table.holes.push(site);
+            return site.body === undefined ? undefined : site;
+        }
+        // `phase("…")` is a marker, not a site: no id and no counter of any kind is consumed
+        // here (see PhaseMarkerSite). Resolved by declaration like the calls above — a
+        // script-local function named `phase` is somebody else's function.
+        if (markerFunctionOfSymbol(calleeSymbol) === "phase") {
+            const nameExpr = node.arguments[0];
+            const name = literalText(nameExpr);
+            table.phases.push({
+                call: node,
+                loc: locOf(node),
+                ...(name === undefined ? {} : { name }),
+                nameExpr,
+            });
+        }
+    };
+    const walk = (node, funcDepth, ids) => {
+        const hole = classify(node, funcDepth, ids);
+        const childDepth = funcDepth + (isFunctionLike(node) ? 1 : 0);
+        ts.forEachChild(node, (child) => walk(child, childDepth, hole !== undefined && child === hole.body ? ids.child(hole.id) : ids));
+    };
+    // 顶层一套计数器贯穿整个脚本体（每个语句都用同一套！）；留白函数体各自换一套带前缀的。
+    const topLevel = new SiteCounters();
+    for (const statement of body.statements)
+        walk(statement, 0, topLevel);
+    return table;
+}
+/**
+ * The authored script body: the wrapper function's block. Exported for the causality
+ * pass, which walks the same body in evaluation order. Read-only — it collects nothing
+ * into the site table, so site ids stay bit-for-bit identical.
+ */
+export function findWorkflowBody(scriptFile) {
+    for (const statement of scriptFile.statements) {
+        if (ts.isFunctionDeclaration(statement) &&
+            statement.name?.text === WORKFLOW_FUNCTION_NAME &&
+            statement.body !== undefined) {
+            return statement.body;
+        }
+    }
+    throw new Error(`workflow wrapper function ${WORKFLOW_FUNCTION_NAME} not found`);
+}
+/** True iff the node introduces its own function scope (a body that runs only when called). */
+export function isFunctionLike(node) {
+    return (ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node) ||
+        ts.isConstructorDeclaration(node));
+}

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

@@ -0,0 +1,254 @@
+import ts from "typescript";
+import type { WorkflowProgram } from "../compiler/compile.js";
+import type { HoleSite, IterationCandidate, SiteTable } from "./sites.js";
+import { type AbstractValue, type TaintFacts, type TaintOcc } from "./domain.js";
+/**
+ * The mutable fixpoint state of the taint pass: the site lookups, the global
+ * environment, function summaries, the reachability/promotion sets, and the sink
+ * accumulators. The evaluator (taint.ts) drives it; this module owns the storage,
+ * the monotone update primitives (each reports growth via `changed`), and the final
+ * placeholder-resolving emission of {@link TaintFacts}.
+ */
+/** How a function reached a call site: as the thing called, or as an argument a library may invoke. */
+export type ApplicationVia = "callee" | "argument";
+export declare class TaintState {
+    readonly table: SiteTable;
+    readonly checker: ts.TypeChecker;
+    readonly program: ts.Program;
+    readonly scriptFile: ts.SourceFile;
+    readonly body: ts.Block;
+    readonly askByCall: Map<ts.CallExpression, string>;
+    readonly askSites: Map<string, {
+        receiver: ts.Expression;
+        instructions: ts.Expression | undefined;
+    }>;
+    readonly worldByCall: Map<ts.CallExpression, {
+        id: string;
+        args: readonly ts.Expression[];
+    }>;
+    readonly joinByCall: Map<ts.CallExpression, {
+        id: string;
+        arg: ts.Expression | undefined;
+    }>;
+    readonly actorByCall: Map<ts.CallExpression, string>;
+    /** 留白调用 → 站点（开放与已补全都在；transfer 规则按有无 body 分派）。 */
+    readonly holeByCall: Map<ts.CallExpression, HoleSite>;
+    /** Per-element callback calls (`xs.map(fn)`, `Array.from(xs, fn)`, …), keyed by the CALL. */
+    readonly candByCall: Map<ts.CallExpression, IterationCandidate>;
+    readonly candByForOf: Map<ts.Node, IterationCandidate>;
+    /**
+     * THE CALL ORACLE: for every call / `new` /
+     * tagged-template node, the script-local functions this pass applied there and HOW —
+     * `callee` (the node's callee value held the function: direct call, through a parameter,
+     * a field, a class member) or `argument` (the node handed the function to a library callee
+     * that may invoke it: a registry entry or the keystone rule). Monotone like every other
+     * accumulator; read after convergence by the ordering walk, which inlines exactly these
+     * bodies at exactly these sites instead of guessing from syntax.
+     */
+    readonly applications: Map<ts.Node, Map<ts.Node, ApplicationVia>>;
+    /**
+     * The live abstract result of each `Promise.all` join call, keyed by the join CALL NODE
+     * and PERSISTENT across fixpoint passes (see {@link joinResultOf}). A join result IS a
+     * place whose element fields carry may-alias back-references to the (place) inputs, so
+     * resolvePlace returns it — letting `const [a, b] = await Promise.all([…])`
+     * destructure-alias the elements and a write through `res[k]` reach the original input.
+     */
+    readonly joinResults: Map<ts.CallExpression, AbstractValue>;
+    /**
+     * The live abstract place of each conditional expression used as a place
+     * (`flag ? box1 : box2`), keyed by the ConditionalExpression NODE and persistent across
+     * passes (see {@link condPlaceOf}). Same canonical-heap requirement as {@link joinResults}.
+     */
+    readonly condPlaces: Map<ts.ConditionalExpression, AbstractValue>;
+    /** Allocation-site places of container literals; see {@link literalPlaceOf}. */
+    readonly literalPlaces: Map<ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, AbstractValue>;
+    readonly fnId: Map<ts.Node, number>;
+    readonly fnParamSymbols: Map<number, (ts.Symbol | undefined)[]>;
+    readonly functions: ts.Node[];
+    readonly callbackNodes: Set<ts.Node>;
+    /**
+     * Object-literal set accessors, keyed by property name -> setter fn ids. Crude but
+     * sound: an assignment to ANY property of that name (on any object) records the
+     * assigned value as the setter's param-0 actual, so the setter body's flow is seen.
+     */
+    readonly settersByProp: Map<string, number[]>;
+    /**
+     * One shared abstract instance per class declaration/expression, keyed by the class
+     * node. Static AND instance members conflate into this ONE value (a deliberate sound
+     * over-approximation: per-instance and static/instance precision are out of scope, so
+     * a write through any instance, through `this`, or through the class name is visible
+     * through every other). Persistent across fixpoint passes — growth is signalled like
+     * any env slot.
+     */
+    readonly classInstances: Map<ts.Node, AbstractValue>;
+    /** Class declarations/expressions in the workflow body, in discovery order. */
+    readonly classes: ts.Node[];
+    readonly env: Map<ts.Symbol, AbstractValue>;
+    readonly summaries: Map<number, AbstractValue>;
+    readonly paramActuals: Map<string, AbstractValue>;
+    /**
+     * Per-placeholder-parameter set of values that MAY be passed to an INVOCATION of that
+     * parameter (keyed by `${fnId}:${param}`). Two capture sites (calls.ts handleUnknownCall):
+     * a direct call of a placeholder callee (`resolve(draft)` — resolve is param 0), and a
+     * placeholder-valued argument to an unknown call (`draft.then(onOk)` — the unknown `.then`
+     * may invoke onOk with the receiver pot). Consumed by the promise machinery: `new
+     * Unknown(fn)` and `await thenable` resolve to whatever fn's / then's callback params
+     * receive (the resolve/reject/continuation pattern). Distinct from {@link paramActuals},
+     * which records what a function receives when IT is called.
+     */
+    readonly phCallActuals: Map<string, AbstractValue>;
+    readonly reachSet: Set<string>;
+    readonly calledFns: Map<string, Set<number>>;
+    readonly promotedOrders: Set<number>;
+    /**
+     * Per-`reduce`-candidate accumulator taint (keyed by candidate `order`), carried
+     * ACROSS fixpoint passes. The callback-return value that reduce threads into the
+     * accumulator param is a fresh local each pass, so binding the param from it
+     * directly never observed the return taint; this persistent slot fixes that.
+     */
+    readonly reduceAcc: Map<number, AbstractValue>;
+    readonly askInstr: Map<string, AbstractValue>;
+    readonly askRecv: Map<string, AbstractValue>;
+    readonly worldRead: Map<string, AbstractValue>;
+    /** 开放留白的提示 sink（docs/analysis.md「Sites」：提示流入留白，如 ask 的 instructions）。 */
+    readonly holePrompt: Map<string, AbstractValue>;
+    readonly joinInByPort: Map<string, Map<number, AbstractValue>>;
+    readonly fanoutInVal: Map<string, AbstractValue>;
+    /**
+     * The ORACLE accumulators, keyed by source START OFFSET rather than by site id: the
+     * value each `await` operand carries, and the value each guard expression reads. They
+     * feed {@link emitOracle}, which only the temporal walk (causality-order.ts) consumes —
+     * nothing here changes a transfer rule, and a position keys nothing in the site
+     * vocabulary, which is what keeps the site-id stability rule untouched: no `order`
+     * counter and no per-kind counter is consulted.
+     */
+    readonly awaitVal: Map<number, AbstractValue>;
+    readonly guardVal: Map<number, AbstractValue>;
+    readonly returnVal: AbstractValue;
+    /**
+     * One script-global thrown-value set: every `throw` joins its operand into it and
+     * every `catch` binding reads all of it. A flow-insensitive over-approximation of
+     * exception routing — sound under gen-only, deliberately imprecise across disjoint
+     * `try` blocks. Persistent across passes so throws in one iteration reach catches
+     * in the next (fixpoint-safe).
+     */
+    readonly thrownVal: AbstractValue;
+    changed: boolean;
+    constructor(workflow: WorkflowProgram, table: SiteTable);
+    private buildLookups;
+    private collectFunctions;
+    /**
+     * Bind a symbol to an abstract value. A FRESH symbol ADOPTS the value object by
+     * reference (`env[sym] === value`); an already-bound slot weak-merges (sound smear).
+     * Adoption is what makes bindings alias rather than snapshot: passing a live place (env slot / live field) shares it, so a later
+     * write through any alias is visible through every other. Callers that must NOT
+     * alias pass a fresh clone/collapse (reads already return snapshots).
+     */
+    bindSymbol(sym: ts.Symbol, value: AbstractValue): void;
+    envSlot(sym: ts.Symbol): AbstractValue;
+    summaryOf(id: number): AbstractValue;
+    /** The shared abstract instance of a class node, created empty on demand (persistent). */
+    instanceOf(cls: ts.Node): AbstractValue;
+    /**
+     * The shared abstract result of a join call, created empty on demand (persistent).
+     *
+     * THE CANONICAL-HEAP INVARIANT: every value that models runtime storage — anything that
+     * can be aliased, written through, or referenced from a `mayAlias` set — is keyed by a
+     * static program point and lives across fixpoint passes; per-pass temporaries are
+     * snapshots only. handleJoin used to mint a FRESH result value each pass, so
+     * `Promise.all([Promise.all([…])])` added a never-before-seen object to the outer
+     * element's `mayAlias` set every pass. That set dedups by IDENTITY (domain.ts), so
+     * `changed` stayed true forever and the fixpoint hit ITERATION_CAP. Keying the result by
+     * the call node makes the identity stable, so the union saturates.
+     */
+    joinResultOf(call: ts.CallExpression): AbstractValue;
+    /**
+     * The shared abstract place of a conditional expression, created empty on demand
+     * (persistent). Same canonical-heap invariant as {@link joinResultOf}: a per-pass
+     * wrapper for `flag ? box1 : box2` diverged the fixpoint as soon as it became a
+     * `mayAlias` target — which a SYNTACTICALLY NESTED ternary place
+     * (`f2 ? (f ? box1 : box2) : box3`) does on every pass.
+     */
+    condPlaceOf(node: ts.ConditionalExpression): AbstractValue;
+    /**
+     * The allocation-site place of a container literal (`{…}` / `[…]`): the value its first
+     * evaluation produced, kept across passes and weak-merged with every re-evaluation
+     * (persistent). Same canonical-heap invariant as {@link joinResultOf}: a literal IS runtime
+     * storage — a callee writes through it (`fill([], v)`, `tag({ name }, t)` with
+     * `box.note = t`), a binding adopts it, a spread shares its fields — so a value recreated
+     * every pass can never settle once something persistent merges INTO it. The
+     * parameter write-back targeted the per-pass fresh literal, reported a change on every pass
+     * (the note it had just added was gone again), and the fixpoint hit ITERATION_CAP with no
+     * state growing at all. Any `f({ … })` whose callee mutates its parameter was affected.
+     *
+     * Adopting the first evaluation (rather than minting an empty slot) keeps the literal's
+     * aliasing: a field that stores a live place (`{ box }`, `[obj]`) keeps pointing at that
+     * slot, and later passes merge the same slot into itself — an identity no-op. Snapshot
+     * fields accumulate monotonically, exactly as an env slot bound to the literal always did.
+     */
+    literalPlaceOf(node: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, fresh: AbstractValue): AbstractValue;
+    mergeReturn(value: AbstractValue): void;
+    /** Join a thrown operand into the script-global thrown-value set. */
+    mergeThrown(value: AbstractValue): void;
+    /**
+     * Weak-merge into a keyed sink accumulator. Generic in the key so the oracle
+     * accumulators ({@link awaitVal} / {@link guardVal}), which are keyed by source offset
+     * rather than site id, share the one monotone update path every other sink uses.
+     */
+    mergeSink<K>(map: Map<K, AbstractValue>, id: K, value: AbstractValue): void;
+    mergeJoinIn(id: string, port: number, value: AbstractValue): void;
+    addParamActual(id: number, param: number, value: AbstractValue): void;
+    /** Record a value that may reach an invocation of the placeholder-parameter `key`. */
+    recordPhCall(key: string, value: AbstractValue): void;
+    /** The taint fed to invocations of a function's parameter `param`, if any. */
+    phCallActualsOf(id: number, param: number): AbstractValue | undefined;
+    /** The persistent accumulator taint for a `reduce` candidate (empty until seeded). */
+    reduceAccOf(order: number): AbstractValue;
+    /** Merge a pass's callback-return taint into a `reduce` candidate's accumulator. */
+    mergeReduceAcc(order: number, value: AbstractValue): void;
+    /**
+     * Record a call against EVERY enclosing region, mirroring {@link markFacade}.
+     * Recording only the innermost region left a caller function `fn@f`
+     * unmarked when its call to `g` happened inside an iteration candidate's callback
+     * (region `cand@N`). Reachability then never propagated `fn@f`, so a sibling
+     * candidate whose callback calls `f` failed to promote to a fan-out — an
+     * under-approximation (a dropped may-flow), which this analysis must never do.
+     */
+    markCalled(regionStack: string[], id: number): void;
+    /** Record that `fn` was applied at `site` (see {@link applications}). Not a fixpoint
+     * signal: applications feed no transfer rule, and the final pass re-records them all. */
+    recordApplication(site: ts.Node, fn: ts.Node, via: ApplicationVia): void;
+    /** Mark every enclosing region as reaching a facade site. */
+    markFacade(regionStack: string[]): void;
+    /** Propagate reachability across the call graph until it stops growing. */
+    propagateReachability(): void;
+    /** Promote iteration candidates whose body region reaches a facade site. */
+    recomputePromotion(): void;
+    emitFacts(): TaintFacts;
+    /**
+     * The ordering walk's oracle view, resolved directly off the CONVERGED interpreter
+     * state — the fused pass's replacement for the `awaitSettles`/`guardReads` members
+     * TaintFacts used to carry.
+     * Same keying (`node.getStart(scriptFile)` of the awaited/guard expression) and the
+     * SAME resolution pipeline as every artifact sink (placeholders expanded, collapsed,
+     * actor labels filtered) — so an awaited parameter still resolves to the union of the
+     * promises its callers passed in, across all call sites. That union is normative: the
+     * temporal walk must see today's context-INsensitive values bit-for-bit; caller-context
+     * precision is explicitly out of scope.
+     *
+     * Only meaningful after the fixpoint has converged; interpret.ts is the one caller.
+     */
+    emitOracle(): {
+        awaitSettles: Map<number, TaintOcc[]>;
+        guardReads: Map<number, TaintOcc[]>;
+        applications: ReadonlyMap<ts.Node, ReadonlyMap<ts.Node, ApplicationVia>>;
+    };
+    private resolveArtifact;
+    private resolveActor;
+    private resolveOccs;
+    /** Expand parameter placeholders to the union of actual arguments across all calls. */
+    private resolvePlaceholders;
+    private resolvePlaceholder;
+    bindPlaceholderParams(fn: ts.Node, id: number): void;
+}
+//# sourceMappingURL=state.d.ts.map

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

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