@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/vendor/dynamic-workflow/analysis/facade-misuse.js

@@ -0,0 +1,350 @@
+import ts from "typescript";
+import { FACADE_FILE_NAME } from "../facade/dts.js";
+import { facadeContainerOf, isSiteProducing, SITE_MEMBER_NAMES } from "../facade/registry.js";
+import { findWorkflowBody } from "./domain.js";
+import { isFacadeDeclared, resolveSymbol } from "./sites.js";
+/**
+ * The facade-siting diagnostic. Kept in its own module,
+ * a sibling of the site-table substrate: this is an
+ * analysis diagnostic, not part of the shared table, and it walks the body in a
+ * different shape (every reference / conversion, not just call sites).
+ */
+/**
+ * Package-local diagnostic code for the facade-siting rule. Not a TS diagnostic code
+ * (those come from the checker); this marks an analysis diagnostic produced by
+ * {@link collectFacadeMisuse}. Kept out of the TS code space to stay unambiguous.
+ */
+export const FACADE_SITING_CODE = 9001;
+/** Depth cap for the structural facade-site walk; scripts nest shallowly, cyclic types converge. */
+const FACADE_SITE_DEPTH = 4;
+/**
+ * Assignment operators whose right-hand side flows a value into the left-hand slot's
+ * declared type: plain `=` and the logical compounds `||=`/`&&=`/`??=`. Arithmetic
+ * compounds (`+=`, …) coerce and cannot carry a facade handle into a facade-typed slot,
+ * so they are not conversion boundaries.
+ */
+const VALUE_ASSIGNMENT_OPS = new Set([
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/**
+ * The facade-siting diagnostic: facade callables are second-class — `agent`, `Agent.ask`,
+ * `files.glob`/`files.read`, `artifact.file`/`artifact.chart`, and `log` may appear only as the
+ * callee of a direct call. Any other reference (aliasing `const spawn = agent`, method
+ * extraction `const f = planner.ask`, `.bind`/`.call`/`.apply` receivers, passing a
+ * facade function as an argument) destroys site identity: journal keys, replay, and
+ * the GUI all key off static site ids, and a facade call reachable only through an
+ * escaped function value has no site. Widening cannot represent it and silently
+ * dropping it would be unsound, so it is rejected at compile time.
+ *
+ * Three passes over the workflow body:
+ *
+ *   1. Reference scan — every identifier / property-access whose checker-resolved
+ *      symbol is a facade callable, in any position other than the callee of a direct
+ *      call; PLUS every destructuring binding/assignment that extracts a facade
+ *      callable off its containing object (see {@link flagExtractedMember}).
+ *   2. Defense in depth — any direct CallExpression whose callee resolves to a
+ *      site-producing facade callable but that never registered as a site (catches
+ *      escape forms the reference scan misses).
+ *   3. Retyping boundary — any conversion of a value that carries a site-producing
+ *      facade member (`Agent.ask`, `files.glob`/`read`) to a type that does NOT (a
+ *      structurally-compatible local interface, `any`, `unknown`). TypeScript resolves
+ *      members by *declared type*, so `const d = planner as Askable; d.ask(...)` or
+ *      `function run(a: Askable) { a.ask(...) }; run(planner)` makes `.ask` resolve to
+ *      the local declaration — pass 1 sees a non-facade symbol, pass 2's resolved
+ *      signature points at the local interface: no site, no diagnostic, and the real
+ *      facade call runs unsited. Enforced at the conversion boundary
+ *      (`as`/`satisfies`, argument→parameter, return, annotated binding) rather than by
+ *      tracking value provenance through the cast (see {@link facadeSiteMember}).
+ *
+ * Destructuring extraction: `const { ask } = planner`, `const { read }
+ * = files`, renamed `{ ask: f }`, nested `{ p: { ask } }`, parameter `function f({ ask }:
+ * Agent)`, and assignment `({ ask } = planner)` are all method extraction — the destructured
+ * twin of the already-rejected `const f = planner.ask`. A shorthand binding identifier
+ * resolves to the freshly-declared LOCAL (not the facade method), so the identifier scan is
+ * blind; and routing the value through a script-locally-typed helper hides the eventual call
+ * from Pass 2's signature check too. Both holes close by flagging at the EXTRACTION site
+ * (see {@link scanRefs}): resolve the source property on the destructured value's type and
+ * reject a facade callable.
+ */
+export function collectFacadeMisuse(workflow, table) {
+    const { program, scriptFile, toScriptLoc } = workflow;
+    const checker = program.getTypeChecker();
+    const body = findWorkflowBody(scriptFile);
+    const diagnostics = [];
+    const flag = (at, name) => {
+        const loc = toScriptLoc(at.getStart(scriptFile));
+        diagnostics.push({
+            code: FACADE_SITING_CODE,
+            column: loc.column,
+            line: loc.line,
+            message: `facade function '${name}' may only be called directly; ` +
+                `taking a reference to it defeats site identity (journal and replay key off call sites)`,
+        });
+    };
+    // Resolve the source property a destructuring form pulls off its containing object
+    // (`{ ask } = planner` -> `ask` on Agent) and flag it when facade-callable. Flags at
+    // `nameNode`; a renamed form's property name is also seen by the identifier scan below,
+    // so both may flag the same spot — the trailing dedupe collapses that.
+    const flagExtractedMember = (nameNode, containerType) => {
+        if (!ts.isIdentifier(nameNode) && !ts.isStringLiteralLike(nameNode))
+            return;
+        const property = checker.getPropertyOfType(containerType, nameNode.text);
+        if (isFacadeCallable(property))
+            flag(nameNode, nameNode.text);
+    };
+    // Pass 1: reference scan.
+    const scanRefs = (node) => {
+        if (ts.isPropertyAccessExpression(node)) {
+            const symbol = resolveSymbol(node.name, checker);
+            if (isFacadeCallable(symbol) && !isDirectCallee(node))
+                flag(node.name, symbol.name);
+        }
+        else if (ts.isIdentifier(node) && !isPropertyAccessName(node)) {
+            const symbol = resolveSymbol(node, checker);
+            if (isFacadeCallable(symbol) && !isDirectCallee(node))
+                flag(node, symbol.name);
+        }
+        else if (ts.isBindingElement(node) && ts.isObjectBindingPattern(node.parent)) {
+            // Destructuring EXTRACTION off an object binding pattern (`const { ask } = planner`,
+            // renamed, nested, or parameter): the container is the binding pattern's type, and a
+            // renamed element carries the source property name, a shorthand its own bound name.
+            flagExtractedMember(node.propertyName ?? node.name, checker.getTypeAtLocation(node.parent));
+        }
+        else if (ts.isShorthandPropertyAssignment(node) && ts.isBinaryExpression(node.parent.parent)) {
+            // Destructuring ASSIGNMENT `({ ask } = planner)`: the object literal is the assignment
+            // target (its LHS), and the source property lives on the right-hand side's type.
+            const assign = node.parent.parent;
+            if (assign.left === node.parent && assign.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                flagExtractedMember(node.name, checker.getTypeAtLocation(assign.right));
+            }
+        }
+        ts.forEachChild(node, scanRefs);
+    };
+    // Pass 2: defense in depth — a direct facade call the collector did not site.
+    // `report` sites belong in here for the same reason `agent` sites do: `report` is
+    // site-producing (registry), so a sited direct call must not be flagged, while a
+    // report call the collector somehow missed must be.
+    const sited = new Set([
+        ...table.asks.map((site) => site.call),
+        ...table.actors.map((site) => site.call),
+        ...table.worldReads.map((site) => site.call),
+        ...table.reports.map((site) => site.call),
+        // 产物站点与 report 同席：它们产生站点（registry），
+        // 所以已 site 的直接调用不得被误报，而收集漏掉的那一次必须被报出来。
+        ...table.artifacts.map((site) => site.call),
+        ...table.joins.map((site) => site.call),
+        // 留白同席：`hole` 产生站点（registry），已 site 的直接调用不得误报。
+        ...table.holes.map((site) => site.call),
+    ]);
+    const scanCalls = (node) => {
+        if (ts.isCallExpression(node) && !sited.has(node)) {
+            // Resolve through the CALL's signature, not the callee's symbol: a computed
+            // member access (`files["read"]`) has no callee symbol, but the resolved
+            // signature still points at the facade method declaration. The (container, member)
+            // pair — not the bare member name — decides whether the callee is site-producing:
+            // `git.log` is, the top-level `log()` is not, and they share a name. Keying on the
+            // name alone would flag every unsited `log("progress")` call as misuse.
+            const callee = facadeCallee(node, checker);
+            if (callee !== undefined && isSiteProducing(callee.container, callee.member)) {
+                flag(node.expression, callee.member);
+            }
+        }
+        ts.forEachChild(node, scanCalls);
+    };
+    // Pass 3: retyping boundary. A value that really is an `Agent`/`files` (its type
+    // carries a site-producing facade member) converted to a type that carries none
+    // launders the site. Anchored at the escaping value expression; the reported name is
+    // the member the disguised type exposes locally (what the author calls through), so
+    // the message reads as "'.ask' can no longer be a facade call here".
+    const flagRetype = (at, name) => {
+        const loc = toScriptLoc(at.getStart(scriptFile));
+        diagnostics.push({
+            code: FACADE_SITING_CODE,
+            column: loc.column,
+            line: loc.line,
+            message: `facade function '${name}' may only be called directly; retyping a facade value to a ` +
+                `structurally-compatible non-facade type escapes site identity ` +
+                `(the disguised '.${name}(...)' resolves to the local type and runs unsited)`,
+        });
+    };
+    const checkConversion = (valueExpr, destType) => {
+        if (destType === undefined)
+            return;
+        const laundered = facadeSiteMember(checker.getTypeAtLocation(valueExpr), checker);
+        if (laundered === undefined)
+            return;
+        if (facadeSiteMember(destType, checker) !== undefined)
+            return;
+        const viaDest = [...SITE_MEMBER_NAMES].find((name) => destType.getProperty(name) !== undefined);
+        flagRetype(valueExpr, viaDest ?? laundered);
+    };
+    const scanRetyping = (node) => {
+        if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+            checkConversion(node.expression, checker.getTypeFromTypeNode(node.type));
+        }
+        else if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+            for (const arg of node.arguments ?? [])
+                checkConversion(arg, checker.getContextualType(arg));
+        }
+        else if (ts.isReturnStatement(node) && node.expression !== undefined) {
+            checkConversion(node.expression, checker.getContextualType(node.expression));
+        }
+        else if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+            checkConversion(node.body, checker.getContextualType(node.body));
+        }
+        else if (ts.isVariableDeclaration(node) &&
+            node.type !== undefined &&
+            node.initializer !== undefined) {
+            checkConversion(node.initializer, checker.getTypeFromTypeNode(node.type));
+        }
+        else if (ts.isBinaryExpression(node) &&
+            VALUE_ASSIGNMENT_OPS.has(node.operatorToken.kind) &&
+            (ts.isIdentifier(node.left) ||
+                ts.isPropertyAccessExpression(node.left) ||
+                ts.isElementAccessExpression(node.left))) {
+            // Assignment into an already-typed slot (`d = planner` on `let d: Askable`,
+            // `slot.a = planner`, `arr[0] = planner`). Destructuring-pattern targets are
+            // ArrayLiteral/ObjectLiteral LHS — pass 1 handles extraction there, so they are
+            // excluded above. An evolving-any binding is narrowed to the real type at its use
+            // (the call stays sited), so it is not a laundering boundary; an explicit `: any`
+            // annotation is (the call runs unsited), so only the implicit case is skipped.
+            const destType = checker.getTypeAtLocation(node.left);
+            if (!isEvolvingAny(node.left, destType, checker))
+                checkConversion(node.right, destType);
+        }
+        ts.forEachChild(node, scanRetyping);
+    };
+    for (const statement of body.statements)
+        scanRefs(statement);
+    for (const statement of body.statements)
+        scanCalls(statement);
+    for (const statement of body.statements)
+        scanRetyping(statement);
+    // Dedupe: the passes can, in principle, name the same escape at the same spot.
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = `${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** True iff the symbol is a facade-declared function or method (a callable). */
+function isFacadeCallable(symbol) {
+    return (isFacadeDeclared(symbol) &&
+        symbol !== undefined &&
+        (symbol.flags & (ts.SymbolFlags.Function | ts.SymbolFlags.Method)) !== 0);
+}
+/**
+ * The first site-producing facade member reachable in `type` (the world-read registry's
+ * members plus `ask`, as declared in the facade `.d.ts`), or undefined. Walks the type
+ * directly, then union / intersection constituents, type arguments (`Agent[]`,
+ * `Promise<Agent>`), and properties (a container holding a facade value), depth- and
+ * cycle-bounded.
+ *
+ * This is the "is this value really an `Agent` / the `files` object" test the retyping
+ * boundary keys off. It deliberately keys on the *site member*, not on any facade-
+ * declared symbol: an artifact result carries no site member — a `Node<T>` exposes only
+ * `then`, an awaited result is a primitive — so retyping ask/read RESULTS stays legal,
+ * while retyping the receiver that would resolve `.ask`/`.read` to a facade site is caught.
+ *
+ * **Bare member names are sound HERE, unlike in passes 1 and 2, and the next task relies on
+ * the difference.** Identity is not decided by the name: the name is looked up as a PROPERTY
+ * OF A TYPE and then run through `isFacadeDeclared`. Property resolution against a type is
+ * already declaration-based, so `SITE_MEMBER_NAMES` supplies candidate keys and the
+ * facade-declared check is the identity test. The top-level `log` is a function declaration,
+ * not a property of any facade type, so `git.log`'s arrival cannot make a `log` property
+ * resolve to it. The invariant this rests on: **no two facade containers declare the same
+ * member name** — a collision would keep the boolean answer correct but make the RETURNED
+ * name (which the diagnostic message quotes) ambiguous. `files.grep` and the `git.*` members
+ * keep that invariant; breaking it would mean threading the container through here too.
+ */
+function facadeSiteMember(type, checker, seen = new Set(), depth = 0) {
+    if (depth > FACADE_SITE_DEPTH || seen.has(type))
+        return undefined;
+    seen.add(type);
+    for (const name of SITE_MEMBER_NAMES) {
+        if (isFacadeDeclared(type.getProperty(name)))
+            return name;
+    }
+    if (type.isUnionOrIntersection()) {
+        for (const constituent of type.types) {
+            const found = facadeSiteMember(constituent, checker, seen, depth + 1);
+            if (found !== undefined)
+                return found;
+        }
+    }
+    for (const arg of typeArguments(type, checker)) {
+        const found = facadeSiteMember(arg, checker, seen, depth + 1);
+        if (found !== undefined)
+            return found;
+    }
+    for (const property of type.getProperties()) {
+        if (property.valueDeclaration === undefined)
+            continue;
+        const propType = checker.getTypeOfSymbolAtLocation(property, property.valueDeclaration);
+        const found = facadeSiteMember(propType, checker, seen, depth + 1);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+/** Instantiated type arguments of an object reference (`Agent[]`, `Node<Agent>`); [] otherwise. */
+function typeArguments(type, checker) {
+    if ((type.flags & ts.TypeFlags.Object) === 0)
+        return [];
+    if ((type.objectFlags & ts.ObjectFlags.Reference) === 0)
+        return [];
+    return checker.getTypeArguments(type);
+}
+/**
+ * True iff `left` is an evolving-any binding (`let x;` with no annotation, typed `any`).
+ * Such a binding narrows to the assigned type at its use, so a facade call through it
+ * stays sited — it is not a laundering boundary. An explicit `: any`/`: unknown`
+ * annotation is a different case (the call runs unsited) and is NOT skipped.
+ */
+function isEvolvingAny(left, leftType, checker) {
+    if ((leftType.flags & ts.TypeFlags.Any) === 0 || !ts.isIdentifier(left))
+        return false;
+    const declaration = checker.getSymbolAtLocation(left)?.valueDeclaration;
+    return (declaration !== undefined &&
+        ts.isVariableDeclaration(declaration) &&
+        declaration.type === undefined);
+}
+/**
+ * The facade callable a call resolves to, as a (declaring container, member) pair — or
+ * undefined if the call does not resolve into the facade `.d.ts`. Resolving through the
+ * signature — not the callee expression's symbol — is what lets the defense-in-depth pass
+ * see a computed member callee (`files["read"](x)`), whose callee has no symbol but whose
+ * resolved signature is still the facade method. The container comes from the same
+ * declaration (`files.read` → `"files"`; a top-level `agent()` → undefined), so the caller
+ * can ask the registry rather than matching a bare name.
+ */
+function facadeCallee(call, checker) {
+    const declaration = checker.getResolvedSignature(call)?.declaration;
+    if (declaration === undefined || declaration.getSourceFile().fileName !== FACADE_FILE_NAME) {
+        return undefined;
+    }
+    const name = declaration.name;
+    if (name === undefined || !ts.isIdentifier(name))
+        return undefined;
+    return { container: facadeContainerOf(declaration), member: name.text };
+}
+/** True iff `node` is the member name of a property access (`x.NAME`), not a value. */
+function isPropertyAccessName(node) {
+    return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+}
+/**
+ * True iff `node` is the callee expression of a direct call (`f(...)`, `x.m(...)`).
+ * Distinct from `domain.isDirectCallee` (which asks whether an expression is a callable
+ * literal for exactness): here "direct" is the syntactic siting position — the one spot a
+ * facade callable is allowed to appear.
+ */
+function isDirectCallee(node) {
+    const parent = node.parent;
+    return ts.isCallExpression(parent) && parent.expression === node;
+}

package/vendor/dynamic-workflow/analysis/fanout-cardinality.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+/**
+ * fan-out 的**字面量基数**：
+ * 被迭代的表达式是无展开元素的数组字面量，或一个只初始化一次、从未被写入的 `const`
+ * 绑定到这样的字面量时，基数 = 字面量长度；其余一律 `undefined`。
+ *
+ * 这是**铸造期**（interpret.ts）的工作——它要看 AST 与 checker，而投影不许再看代码。
+ * 原则是宁缺毋滥：任何不确定都给缺席，交接图随之画一张 `many` 卡，绝不猜一个数。
+ */
+export declare function literalCardinality(iterated: ts.Expression, checker: ts.TypeChecker): number | undefined;
+//# sourceMappingURL=fanout-cardinality.d.ts.map

package/vendor/dynamic-workflow/analysis/fanout-cardinality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fanout-cardinality.d.ts","sourceRoot":"","sources":["../../src/analysis/fanout-cardinality.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAiBvG"}

package/vendor/dynamic-workflow/analysis/fanout-cardinality.js

@@ -0,0 +1,121 @@
+import ts from "typescript";
+/**
+ * fan-out 的**字面量基数**：
+ * 被迭代的表达式是无展开元素的数组字面量，或一个只初始化一次、从未被写入的 `const`
+ * 绑定到这样的字面量时，基数 = 字面量长度；其余一律 `undefined`。
+ *
+ * 这是**铸造期**（interpret.ts）的工作——它要看 AST 与 checker，而投影不许再看代码。
+ * 原则是宁缺毋滥：任何不确定都给缺席，交接图随之画一张 `many` 卡，绝不猜一个数。
+ */
+export function literalCardinality(iterated, checker) {
+    const expr = unwrap(iterated);
+    if (ts.isArrayLiteralExpression(expr))
+        return spreadFreeLength(expr);
+    if (!ts.isIdentifier(expr))
+        return undefined;
+    const symbol = checker.getSymbolAtLocation(expr);
+    const decl = symbol?.valueDeclaration;
+    if (symbol === undefined || decl === undefined || !ts.isVariableDeclaration(decl))
+        return undefined;
+    if (!ts.isIdentifier(decl.name))
+        return undefined;
+    const list = decl.parent;
+    if (!ts.isVariableDeclarationList(list) || (list.flags & ts.NodeFlags.Const) === 0)
+        return undefined;
+    if (decl.initializer === undefined)
+        return undefined;
+    const init = unwrap(decl.initializer);
+    if (!ts.isArrayLiteralExpression(init))
+        return undefined;
+    const length = spreadFreeLength(init);
+    if (length === undefined)
+        return undefined;
+    return isEverWritten(symbol, decl.getSourceFile(), checker) ? undefined : length;
+}
+/** `(xs)`, `xs as const`, `xs!`, `xs satisfies T` 都是同一个数组。 */
+function unwrap(expr) {
+    let current = expr;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current))
+            current = current.expression;
+        else if (ts.isAsExpression(current) || ts.isSatisfiesExpression(current))
+            current = current.expression;
+        else if (ts.isNonNullExpression(current))
+            current = current.expression;
+        else if (ts.isTypeAssertionExpression(current))
+            current = current.expression;
+        else
+            return current;
+    }
+}
+function spreadFreeLength(literal) {
+    if (literal.elements.some((element) => ts.isSpreadElement(element) || ts.isOmittedExpression(element))) {
+        return undefined;
+    }
+    return literal.elements.length > 0 ? literal.elements.length : undefined;
+}
+/** 就地改变数组内容的方法：经它们调用过的绑定不再是字面量长度。 */
+const MUTATORS = new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "length"]);
+/**
+ * 该绑定是否被写过：`xs.push(…)` 之类的就地方法、`xs[i] = …` / `xs[i]++`、`xs.length = 0`，
+ * 以及（虽然 `const` 已禁止）对名字本身的赋值。别名（`const ys = xs; ys.push()`）与把数组
+ * 传进函数不在检查范围——只看这三类写；它们之外的形状本来就会给出缺席以外的答案。
+ */
+function isEverWritten(symbol, file, checker) {
+    let written = false;
+    const visit = (node) => {
+        if (written)
+            return;
+        if (ts.isIdentifier(node) && node.parent !== undefined && checker.getSymbolAtLocation(node) === symbol) {
+            if (isWriteReference(node))
+                written = true;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return written;
+}
+function isWriteReference(id) {
+    const parent = id.parent;
+    // 声明处本身不是写。
+    if (ts.isVariableDeclaration(parent) && parent.name === id)
+        return false;
+    // xs.push(...) / xs.length = 0
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === id) {
+        const name = parent.name.text;
+        if (!MUTATORS.has(name))
+            return false;
+        if (name === "length")
+            return isAssignmentTarget(parent);
+        return ts.isCallExpression(parent.parent) && parent.parent.expression === parent;
+    }
+    // xs[i] = ... / xs[i]++ / delete xs[i]
+    if (ts.isElementAccessExpression(parent) && parent.expression === id)
+        return isAssignmentTarget(parent);
+    // xs = ... （const 下类型错误，但仍算写）
+    return isAssignmentTarget(id);
+}
+function isAssignmentTarget(node) {
+    const parent = node.parent;
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+        const op = parent.operatorToken.kind;
+        return op >= ts.SyntaxKind.FirstAssignment && op <= ts.SyntaxKind.LastAssignment;
+    }
+    if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) {
+        return parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken;
+    }
+    if (ts.isDeleteExpression(parent))
+        return true;
+    // 解构赋值目标：[xs[0]] = ... / ({ a: xs[0] } = ...)
+    if (ts.isArrayLiteralExpression(parent) || ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent)) {
+        let up = parent;
+        while (ts.isArrayLiteralExpression(up) || ts.isObjectLiteralExpression(up) || ts.isPropertyAssignment(up) || ts.isShorthandPropertyAssignment(up) || ts.isSpreadElement(up)) {
+            up = up.parent;
+        }
+        return ts.isBinaryExpression(up) && up.operatorToken.kind === ts.SyntaxKind.EqualsToken && up.left !== undefined && containsNode(up.left, node);
+    }
+    return false;
+}
+function containsNode(root, target) {
+    return target.pos >= root.pos && target.end <= root.end;
+}

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

@@ -0,0 +1,113 @@
+import type { ScriptLoc } from "../compiler/compile.js";
+import type { AnalysisCore } from "./core.js";
+/**
+ * The control-flow projection: "where can
+ * execution go next", as opposed to the causality graph's "what must precede what".
+ *
+ * Input is the core's trace read as a STRUCTURED CONTROL TREE (flow-tree.ts): regions are
+ * the inner nodes, events the leaves in pre-order, and each leaf's `regions` chain names
+ * its ancestors. The walk already resolved everything that needed the AST — arm grouping (`choice`), helper
+ * boundaries (`call`), try parts, and every `jump`'s target region — so this module is a
+ * pure function of the core and must not import `typescript`.
+ *
+ * Nodes are OCCURRENCES (each `issue` leaf, each `mark` leaf), not sites: a helper called
+ * twice contributes two nodes for one step id. The phase quotient (`phaseEdges`) folds
+ * them back by phase. Neither level is transitively reduced — a CFG never is.
+ *
+ * The graph is CONCURRENT: a `strand` region (an asynchronous activation the walk inlined)
+ * is entered by a `fork` and left by a `join` at the barrier that awaits its promise, not
+ * at its spawn point. Its exits wait in the strand park (flow-strands.ts) in between, and a
+ * `mark` reached while strands are parked records their phases as `alongside` — a node
+ * fact, because "an earlier phase is still running here" is not a transfer of control and
+ * cannot be read off the edges once they fold.
+ */
+export type FlowNodeKind = "issue" | "mark";
+export interface FlowNode {
+    /** `${step}@${k}` — the k-th issue of that step; `${phase}@${k}` for a mark. */
+    id: string;
+    kind: FlowNodeKind;
+    /** issue: the step's site id. */
+    site?: string;
+    /** The phase current at this leaf (a mark's is the phase it switched TO). */
+    phase: string;
+    /**
+     * mark only: the phases whose strands are still running when this marker is entered —
+     * every strand parked here, minus this node's own phase and minus any strand the marker
+     * sits inside. In the trace's phase-table order, absent when empty. Flow-insensitive
+     * across choice arms, like the walk's `issued` set: over-claiming "may run alongside" is
+     * the licensed direction.
+     */
+    alongside?: string[];
+    /** Inside a never-called body the sweep placed: runs at an unknown point, if at all. */
+    detached?: true;
+}
+export type FlowEdgeKind = "next" | "branch" | "loop" | "exit" | "fork" | "join" | "jump" | "throw" | "may-throw";
+export type FlowVia = "continue" | "break" | "return" | "recur";
+export interface FlowEdge {
+    from: string;
+    to: string;
+    kind: FlowEdgeKind;
+    /** The jump statement kind behind a `loop` / `exit` / `jump` / `join` edge, when any. */
+    via?: FlowVia;
+}
+export interface FlowPhase {
+    id: string;
+    /** Absent for {@link UNPHASED_ID}. */
+    name?: string;
+    /** The first marker that minted the phase; absent for {@link UNPHASED_ID}. */
+    loc?: ScriptLoc;
+    /**
+     * Phases whose strands were still running when this one was entered: the union of
+     * {@link FlowNode.alongside} over the phase's mark nodes, in phase-table order, absent
+     * when empty. All-or-nothing with the rest of the phase vocabulary.
+     */
+    alongside?: string[];
+    /** The filled hole whose body wrote this phase (a hole's own phase names the hole enclosing it). */
+    fill?: string;
+}
+/**
+ * An OPEN hole as the display lists it (docs/dynamic-workflow/presentation.md, `holes`): the
+ * station the rail draws dashed ahead of the run. `phase` is where the hole STANDS — the
+ * phase of its issue node, the hole's own memberless phase being `siteId` itself.
+ */
+export interface FlowHole {
+    siteId: string;
+    name: string;
+    /** The author's spelling of the type argument. */
+    type: string;
+    phase?: string;
+    /** The tail form `return await hole<T>(...)`: the script's end is open. */
+    tail?: true;
+}
+/** Terminal node ids. `sink` is the causality graph's sink: the script completed normally. */
+export declare const FLOW_ENTRY = "entry";
+export declare const FLOW_SINK = "sink";
+export declare const FLOW_ABORT = "abort";
+export interface ControlFlowGraph {
+    /** Leaf-stream order; detached nodes last (the sweep runs after the main walk). */
+    nodes: FlowNode[];
+    /** Canonical order: by from-node, to-node, kind, via; `entry` first, terminals last. */
+    edges: FlowEdge[];
+    /**
+     * The phase quotient, present iff the script declares a phase (all-or-nothing, exactly
+     * like the causality graph's `phaseEdges`). Same-phase edges dissolve except `loop`
+     * back edges, which stay as self-loops.
+     */
+    phaseEdges?: FlowEdge[];
+    /** Phases that appear on some node, in first-reach order, {@link UNPHASED_ID} first. */
+    phases?: FlowPhase[];
+    /** The open holes in source order; present iff the script has one (see {@link FlowHole}). */
+    holes?: FlowHole[];
+}
+/**
+ * A dangling exit: the edge it will make once it learns where control goes next. Exported
+ * for flow-strands.ts only — a strand's exits leave this module to wait for their join —
+ * and deliberately not re-exported from the package barrels.
+ */
+export interface Src {
+    from: string;
+    kind: FlowEdgeKind;
+    via?: FlowVia;
+}
+export declare function projectControlFlow(core: AnalysisCore): ControlFlowGraph;
+//# sourceMappingURL=flow-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flow-graph.d.ts","sourceRoot":"","sources":["../../src/analysis/flow-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAK9C;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5C,MAAM,WAAW,QAAQ;IACvB,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,QAAQ,GACR,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,WAAW,CAAC;AAEhB,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,yFAAyF;IACzF,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oGAAoG;IACpG,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,8FAA8F;AAC9F,eAAO,MAAM,UAAU,UAAU,CAAC;AAClC,eAAO,MAAM,SAAS,SAAS,CAAC;AAChC,eAAO,MAAM,UAAU,UAAU,CAAC;AAElC,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,wFAAwF;IACxF,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC;IACxB,wFAAwF;IACxF,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,6FAA6F;IAC7F,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;CACpB;AAID;;;;GAIG;AACH,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAkED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,CA6UvE"}