@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

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

@@ -0,0 +1,215 @@
+/**
+ * 留白站点（docs/dynamic-workflow/authoring.md「Holes: `hole<T>()`」，docs/analysis.md「Sites」）：
+ * 站点的构造（三个重载的实参分派、tail 判定）与编译期规则 9012。
+ *
+ * 9012 的每条规则都是「运行期才炸不如现在就教改写」的那一类（与 9003 / 9004 同席）：
+ *  - 类型实参必须显式写出：T 是补全被检查的契约，推断出的 `unknown` 不是契约；
+ *  - 名字是非空字面量、≤128 字符，且在脚本的留白与阶段标记中**唯一**（嵌套补全也算）：名字
+ *    是留白的阶段名与每个界面显示的身份——两个标记同名是一个阶段，两个留白同名却是两个缺口；
+ *  - 调用必须被 await：没等值的留白会让脚本越过一个还没有值的缺口；
+ *  - 不能落在 fan-out **回调**里（数组方法的回调，提升与否都算）：元素并发跑，补全得在它们
+ *    已经在跑的时候写。`for...of` 体**允许**：带 await 的 for...of 是顺序的——第一轮停在留白，
+ *    补全到了，后面每轮跑函数体，正是「循环里的留白补全一次、每轮跑一遍」那一条；
+ *  - 函数体不得引用留白之后才声明的绑定：函数体是编译器不检查「先用后声明」的闭包，引用
+ *    后面的 `const` 到运行期才 TDZ 抛错；
+ *  - 函数体必须是内联的函数字面量：lowering 要把它原样打印成补全文本，一个标识符没有文本可打。
+ */
+import ts from "typescript";
+import { literalText } from "./sites-labels.js";
+/** 留白规则的诊断码（9001 = facade-siting、…、9010 = 模型名，顺延）。 */
+export const HOLE_CODE = 9012;
+/** 留白名的长度上限：与阶段名同规（docs/dynamic-workflow/authoring.md「Holes」）。 */
+export const HOLE_NAME_MAX_CHARS = 128;
+const TYPE_MESSAGE = "hole() needs an explicit type argument (hole<Plan>(...)): the type is the contract the " +
+    "fill is compiled against, and an inferred unknown is no contract. Write what the rest of " +
+    "the script needs from the hole.";
+const NAME_LITERAL_MESSAGE = "hole()'s name must be a compile-time string literal: it is the hole's phase name and the " +
+    "identity every surface shows (the station, the notification, the fill file). Write it inline.";
+const NAME_EMPTY_MESSAGE = 'hole("") has no name to show. Give the gap a word in the user\'s language ("决定分组", ' +
+    '"choose the plan"); it labels the station and the notification.';
+const NAME_LONG_MESSAGE = `hole()'s name is longer than ${HOLE_NAME_MAX_CHARS} characters; a phase name is a label, not a paragraph.`;
+const AWAIT_MESSAGE = "hole() must be awaited where it is called (await hole<T>(...) or return await hole<T>(...)): " +
+    "the script must not run past a gap that has no value yet.";
+const FANOUT_MESSAGE = "hole() cannot stand inside a fan-out callback (xs.map(...), Promise.all(xs.map(...)) and the " +
+    "other per-element array methods): the elements run concurrently, so its fill would have to " +
+    "be written while they are already running. Hoist the decision out of the callback, or use a " +
+    "loop (for, for...of, while), where one round waits and the fill runs in every later round.";
+const BODY_INLINE_MESSAGE = "hole()'s body must be an inline async arrow (async () => { ... }): a fill is spliced into the " +
+    "script as text, so a function held in a variable has nothing to splice.";
+/** 名字撞车的文案：撞的是标记还是另一个留白，说清楚。 */
+function duplicateMessage(name, other) {
+    return other === "hole"
+        ? `two holes are named "${name}"; a hole's name is its identity and must be unique among the script's holes and phase markers.`
+        : `hole "${name}" shares its name with a phase("${name}") marker; a hole is a phase of its own, so the name must be unique among holes and markers.`;
+}
+/** 两个不同名字的哈希撞车（hole-id.ts）：极罕见，但绝不猜——改一个名字就过。 */
+function idCollisionMessage(name, other) {
+    return (`hole "${name}" and hole "${other}" hash to the same site id; rename one of them ` +
+        "(any change to the name gives it a new id).");
+}
+function lateBindingMessage(name) {
+    return (`the hole's body reads "${name}", which is declared after the hole. The body runs at the ` +
+        "hole, before that declaration executes, so the read would throw at run time. Declare it " +
+        "before the hole, or compute it inside the body.");
+}
+function isFunctionLiteral(expr) {
+    return expr !== undefined && (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr));
+}
+/** 调用是不是顶层 `return` 的操作数（`return await hole(...)` 或 `return hole(...)`）。 */
+function isTailPosition(call) {
+    const parent = call.parent;
+    if (ts.isReturnStatement(parent))
+        return true;
+    return ts.isAwaitExpression(parent) && ts.isReturnStatement(parent.parent);
+}
+/**
+ * 从一个已按声明判定为 facade `hole` 的调用构造站点。三个重载的分派只看实参形状：第二实参是
+ * 函数字面量即函数体，否则是提示；第三实参（若有）是函数体。非字面量的函数体既不算提示也不算
+ * 函数体——留给 9012 报「必须内联」。
+ */
+export function holeSiteOf(call, id, order, loc, funcDepth, fill) {
+    const [first, second, third] = call.arguments;
+    const body = isFunctionLiteral(second) ? second : isFunctionLiteral(third) ? third : undefined;
+    const prompt = second !== undefined && body !== second ? second : undefined;
+    const typeArg = call.typeArguments?.[0];
+    const name = literalText(first);
+    return {
+        call,
+        ...(fill === undefined ? {} : { fill }),
+        id,
+        loc,
+        ...(name === undefined ? {} : { name }),
+        nameExpr: first,
+        order,
+        ...(prompt === undefined ? {} : { prompt }),
+        ...(body === undefined ? {} : { body }),
+        tail: funcDepth === 0 && isTailPosition(call),
+        ...(typeArg === undefined ? {} : { typeArg, typeText: typeArg.getText() }),
+    };
+}
+/** `node` 是否整体落在 `span` 节点的源码范围内。 */
+function within(node, span, scriptFile) {
+    return span.getStart(scriptFile) <= node.getStart(scriptFile) && node.getEnd() <= span.getEnd();
+}
+/**
+ * 声明是否会被提升到作用域顶部，因而「先用后声明」在运行期无害：`function` 与 `var`。
+ * `let` / `const` / `class` / `enum` 都不是（TDZ 或空对象），引用它们就是运行期错误。
+ */
+function isHoisted(declaration) {
+    if (ts.isFunctionDeclaration(declaration))
+        return true;
+    if (!ts.isVariableDeclaration(declaration))
+        return false;
+    const list = declaration.parent;
+    return ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.BlockScoped) === 0;
+}
+/** 校验收集到的留白站点。非空即脚本不可提交（`analyzeWorkflowScript` 与 misuse 同席）。 */
+export function collectHoleDiagnostics(workflow, table) {
+    const { program, scriptFile, toScriptLoc } = workflow;
+    const checker = program.getTypeChecker();
+    const diagnostics = [];
+    const push = (loc, message) => {
+        diagnostics.push({ code: HOLE_CODE, column: loc.column, line: loc.line, message });
+    };
+    const at = (node, fallback) => node === undefined ? fallback : toScriptLoc(node.getStart(scriptFile));
+    // 名字的唯一性跨留白与标记：标记先登记，所以任何与标记同名的留白都被报出，不论先后；两个
+    // 留白同名报在后一个上（源码序）。嵌套补全里的留白与标记也在表里，自然一并计入。
+    const seen = new Map();
+    for (const marker of table.phases) {
+        const name = marker.name?.trim();
+        if (name !== undefined && name !== "")
+            seen.set(name, "marker");
+    }
+    // 名字键的哈希撞车：同一个 id 只能属于一个名字（同名的重复已经由上面那条报过）。
+    const idOwner = new Map();
+    for (const site of [...table.holes].sort((a, b) => a.order - b.order)) {
+        const nameLoc = at(site.nameExpr, site.loc);
+        if (site.typeArg === undefined)
+            push(site.loc, TYPE_MESSAGE);
+        if (site.name === undefined)
+            push(nameLoc, NAME_LITERAL_MESSAGE);
+        else if (site.name.trim() === "")
+            push(nameLoc, NAME_EMPTY_MESSAGE);
+        else if (site.name.length > HOLE_NAME_MAX_CHARS)
+            push(nameLoc, NAME_LONG_MESSAGE);
+        else {
+            const name = site.name.trim();
+            const other = seen.get(name);
+            if (other !== undefined)
+                push(nameLoc, duplicateMessage(name, other));
+            else {
+                seen.set(name, "hole");
+                const owner = idOwner.get(site.id);
+                if (owner !== undefined && owner !== name)
+                    push(nameLoc, idCollisionMessage(name, owner));
+                else
+                    idOwner.set(site.id, name);
+            }
+        }
+        if (!ts.isAwaitExpression(site.call.parent))
+            push(site.loc, AWAIT_MESSAGE);
+        // 只有数组方法回调（提升与否都算）；for...of 的语句体是顺序的，留白可以站在里面。
+        const inCallback = table.iterations.some((cand) => cand.form === "array-method" && within(site.call, cand.body, scriptFile));
+        if (inCallback)
+            push(site.loc, FANOUT_MESSAGE);
+        // 非内联的函数体：第二实参不是提示（不是 string）且不是字面量，或第三实参不是字面量。
+        const [, second, third] = site.call.arguments;
+        const heldBody = (third !== undefined && site.body !== third ? third : undefined) ??
+            (second !== undefined && site.prompt === second && isCallable(second, checker)
+                ? second
+                : undefined);
+        if (heldBody !== undefined)
+            push(at(heldBody, site.loc), BODY_INLINE_MESSAGE);
+        if (site.body !== undefined) {
+            collectLateBindings(site.call, site.body, checker, scriptFile, (node, name) => push(at(node, site.loc), lateBindingMessage(name)));
+        }
+    }
+    return diagnostics;
+}
+function isCallable(expr, checker) {
+    return checker.getTypeAtLocation(expr).getCallSignatures().length > 0;
+}
+/**
+ * 函数体里每一个解析到「留白之后、函数体之外、不被提升」的脚本声明的标识符引用，每个绑定
+ * 报一次（首次引用处）。属性名与声明位不是引用，跳过。
+ */
+function collectLateBindings(call, body, checker, scriptFile, report) {
+    const holeStart = call.getStart(scriptFile);
+    const reported = new Set();
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && isValueReference(node)) {
+            const symbol = checker.getSymbolAtLocation(node);
+            if (symbol !== undefined && !reported.has(symbol)) {
+                const late = symbol.declarations?.some((decl) => decl.getSourceFile() === scriptFile &&
+                    !within(decl, body, scriptFile) &&
+                    decl.getStart(scriptFile) > holeStart &&
+                    !isHoisted(decl));
+                if (late === true) {
+                    reported.add(symbol);
+                    report(node, node.text);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(body.body);
+}
+/** 标识符是不是一次值引用（不是 `x.NAME` 的成员名、不是声明自己的名字、不是属性键）。 */
+function isValueReference(node) {
+    const parent = node.parent;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        return false;
+    if ((ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent)) && parent.name === node)
+        return false;
+    if (ts.isBindingElement(parent) && parent.propertyName === node)
+        return false;
+    if ((ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent)) &&
+        parent.name === node) {
+        return false;
+    }
+    return true;
+}

package/vendor/dynamic-workflow/analysis/hole-splice.d.ts

@@ -0,0 +1,45 @@
+import type { SiteTable } from "./sites.js";
+/**
+ * 补全服务的两件纯文本工具（execution-engine.md「The fill service's checks」）：把函数体拼进
+ * 留白调用、以及补全前后站点表的稳定性复核。两者都不碰引擎与 journal，run service 按序调用。
+ */
+/** 拼接结果：新文本、第一行插入行的脚本行号（1-based）与插入的行数。 */
+export interface SplicedHoleBody {
+    text: string;
+    insertedAtLine: number;
+    insertedLines: number;
+}
+/**
+ * 把 `body` 作为最后一个实参拼进留白调用：紧接在**最后一个实参的末尾**插入 `, async () => {\n<body>\n}`，
+ * 函数体每行按调用所在行的缩进再加两格，右花括号取调用的缩进。返回 `undefined` 当留白不在表里
+ * 或已经有函数体——补全一个已补全的留白不是拼接能表达的事。
+ *
+ * 插入点是最后一个实参的末尾而不是右括号之前：2026-09-28 首次实测里主代理按 prettier 的习惯写了
+ * `hole<T>(\n  "名",\n  \`提示\`,\n);`——提示后面带一个尾随逗号——在右括号前插入就得到 `, , async`，
+ * 四条语法错误全锚在草稿上，而草稿并没有错。接在实参末尾之后，原来的尾随逗号与换行留在函数体
+ * 之后（`}, \n)`），仍是合法调用；实参与右括号之间的注释同样原样保留。
+ *
+ * `insertedAtLine` 是第一条函数体行在新脚本里的行号（`, async () => {` 留在最后一个实参结束的那一
+ * 行上），`insertedLines` 是新增的换行数（函数体行数 + 右花括号那一行）：诊断按这两个数分到「补全
+ * 文件内」与「草稿内」。
+ */
+export declare function spliceHoleBody(scriptText: string, table: SiteTable, holeSiteId: string, body: string): SplicedHoleBody | undefined;
+/** 稳定性复核的结果：通过，或一句说明是哪个 id 在哪儿变了。 */
+export type SiteStability = {
+    ok: true;
+} | {
+    ok: false;
+    detail: string;
+};
+/**
+ * 补全前后站点表的稳定性（docs/analysis.md「Sites」的站点 id 稳定性规则，延伸到「加函数体」）：
+ * `before` 的每个 id（全部种类）都在 `after` 里，位置不变或——落在插入点之后时——行号整体后移
+ * `insertedLines`；`after` 里 `before` 没有的每个 id 都是这次补全写下的：带 `<holeSiteId>/`
+ * 前缀，或者是函数体里新留的留白（`fill` 链通到 `holeSiteId`）及其体内的站点。哪条不成立都是
+ * 宿主的错（分析器的编号规则被打破了），run 不能拿到它接不上的 id。
+ *
+ * 与插入点同一行、插入点之后的站点（`await hole(...); agent("a")` 写在一行）行号后移但列号
+ * 变了：那一行只比对行号。
+ */
+export declare function checkSiteStability(before: SiteTable, after: SiteTable, holeSiteId: string, insertedAtLine: number, insertedLines: number): SiteStability;
+//# sourceMappingURL=hole-splice.d.ts.map

package/vendor/dynamic-workflow/analysis/hole-splice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hole-splice.d.ts","sourceRoot":"","sources":["../../src/analysis/hole-splice.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;GAGG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,eAAe,GAAG,SAAS,CAmB7B;AAED,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAmBzE;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,aAAa,CAsCf"}

package/vendor/dynamic-workflow/analysis/hole-splice.js

@@ -0,0 +1,100 @@
+import { SCRIPT_PRELUDE_LENGTH } from "../compiler/compile.js";
+import { holePrefixOf } from "./hole-id.js";
+/** 函数体相对调用缩进再多缩的空格数。 */
+const BODY_EXTRA_INDENT = 2;
+/**
+ * 把 `body` 作为最后一个实参拼进留白调用：紧接在**最后一个实参的末尾**插入 `, async () => {\n<body>\n}`，
+ * 函数体每行按调用所在行的缩进再加两格，右花括号取调用的缩进。返回 `undefined` 当留白不在表里
+ * 或已经有函数体——补全一个已补全的留白不是拼接能表达的事。
+ *
+ * 插入点是最后一个实参的末尾而不是右括号之前：2026-09-28 首次实测里主代理按 prettier 的习惯写了
+ * `hole<T>(\n  "名",\n  \`提示\`,\n);`——提示后面带一个尾随逗号——在右括号前插入就得到 `, , async`，
+ * 四条语法错误全锚在草稿上，而草稿并没有错。接在实参末尾之后，原来的尾随逗号与换行留在函数体
+ * 之后（`}, \n)`），仍是合法调用；实参与右括号之间的注释同样原样保留。
+ *
+ * `insertedAtLine` 是第一条函数体行在新脚本里的行号（`, async () => {` 留在最后一个实参结束的那一
+ * 行上），`insertedLines` 是新增的换行数（函数体行数 + 右花括号那一行）：诊断按这两个数分到「补全
+ * 文件内」与「草稿内」。
+ */
+export function spliceHoleBody(scriptText, table, holeSiteId, body) {
+    const site = table.holes.find((hole) => hole.id === holeSiteId);
+    if (site === undefined || site.body !== undefined)
+        return undefined;
+    const lastArg = site.call.arguments[site.call.arguments.length - 1];
+    if (lastArg === undefined)
+        return undefined;
+    const insertAt = lastArg.getEnd() - SCRIPT_PRELUDE_LENGTH;
+    const lineStart = scriptText.lastIndexOf("\n", site.call.getStart() - SCRIPT_PRELUDE_LENGTH) + 1;
+    const indent = /^[ \t]*/.exec(scriptText.slice(lineStart))?.[0] ?? "";
+    const bodyIndent = `${indent}${" ".repeat(BODY_EXTRA_INDENT)}`;
+    const bodyLines = body.replace(/\r?\n$/, "").split(/\r?\n/);
+    const inserted = [
+        ", async () => {",
+        ...bodyLines.map((line) => (line.trim() === "" ? "" : `${bodyIndent}${line}`)),
+        `${indent}}`,
+    ];
+    const before = scriptText.slice(0, insertAt);
+    const text = `${before}${inserted.join("\n")}${scriptText.slice(insertAt)}`;
+    const callLine = before.split("\n").length; // 最后一个实参结束的那一行（1-based）
+    return { insertedAtLine: callLine + 1, insertedLines: inserted.length - 1, text };
+}
+function everySite(table) {
+    return [
+        ...table.asks,
+        ...table.actors,
+        ...table.worldReads,
+        ...table.joins,
+        ...table.reports,
+        ...table.artifacts,
+        ...table.holes,
+    ].map((site) => ({ id: site.id, loc: site.loc }));
+}
+/**
+ * 补全前后站点表的稳定性（docs/analysis.md「Sites」的站点 id 稳定性规则，延伸到「加函数体」）：
+ * `before` 的每个 id（全部种类）都在 `after` 里，位置不变或——落在插入点之后时——行号整体后移
+ * `insertedLines`；`after` 里 `before` 没有的每个 id 都是这次补全写下的：带 `<holeSiteId>/`
+ * 前缀，或者是函数体里新留的留白（`fill` 链通到 `holeSiteId`）及其体内的站点。哪条不成立都是
+ * 宿主的错（分析器的编号规则被打破了），run 不能拿到它接不上的 id。
+ *
+ * 与插入点同一行、插入点之后的站点（`await hole(...); agent("a")` 写在一行）行号后移但列号
+ * 变了：那一行只比对行号。
+ */
+export function checkSiteStability(before, after, holeSiteId, insertedAtLine, insertedLines) {
+    const afterById = new Map(everySite(after).map((site) => [site.id, site.loc]));
+    const parenLine = insertedAtLine - 1;
+    for (const site of everySite(before)) {
+        const moved = afterById.get(site.id);
+        if (moved === undefined)
+            return { detail: `site ${site.id} vanished after the fill`, ok: false };
+        const shifted = site.loc.line >= parenLine;
+        const expectedLine = shifted ? site.loc.line + insertedLines : site.loc.line;
+        const sameLine = moved.line === expectedLine || (site.loc.line === parenLine && moved.line === site.loc.line);
+        const sameColumn = site.loc.line === parenLine || moved.column === site.loc.column;
+        if (!sameLine || !sameColumn) {
+            return {
+                detail: `site ${site.id} moved from ${site.loc.line}:${site.loc.column} to ${moved.line}:${moved.column}` +
+                    ` (expected line ${expectedLine})`,
+                ok: false,
+            };
+        }
+    }
+    const known = new Set(everySite(before).map((site) => site.id));
+    // 这次补全写下的留白：`fill` 链一路通到被补全的留白（体内再留的、以及体内内联填好的）。
+    const fillOf = new Map(after.holes.map((hole) => [hole.id, hole.fill]));
+    const writtenByFill = (holeId) => {
+        for (let cur = holeId; cur !== undefined; cur = fillOf.get(cur)) {
+            if (cur === holeSiteId)
+                return true;
+        }
+        return false;
+    };
+    for (const site of everySite(after)) {
+        if (known.has(site.id))
+            continue;
+        const owner = holePrefixOf(site.id) ?? site.id;
+        if (!writtenByFill(owner)) {
+            return { detail: `site ${site.id} appeared outside the fill of ${holeSiteId}`, ok: false };
+        }
+    }
+    return { ok: true };
+}

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

@@ -0,0 +1,26 @@
+import type { WorkflowProgram } from "../compiler/compile.js";
+import type { SiteTable } from "./sites.js";
+import type { AnalysisCore } from "./core.js";
+/**
+ * The fused interpreter: ONE interpretation of
+ * the script that produces the {@link AnalysisCore}. Engine schedule:
+ *
+ *  1. the taint listener runs alone to a fixpoint ({@link Evaluator.converge} — global
+ *     env, placeholder summaries, semantics untouched);
+ *  2. ONE final temporal walk ({@link traceOrder}) rides the evaluation-order spine,
+ *     reading the converged state directly as its oracle ({@link TaintState.emitOracle})
+ *     — the settle-certainty judgements need converged facts, so logging events on
+ *     earlier iterations would be waste plus per-iteration state resets for nothing.
+ *     The order-insensitivity lemma makes this schedule safe: a gen-only, kill-free,
+ *     monotone fixpoint's result does not depend on visitation order, so the temporal
+ *     walk's evaluation order is not a second semantics.
+ *  3. minting ({@link mintCore}) digests everything position- or checker-shaped into
+ *     plain data: `within` containment resolved onto sites, provisional `fan-out@order`
+ *     ids renamed to final `fan-out#N` everywhere (occurrences and type keys included),
+ *     artifact types materialized as strings.
+ *
+ * Downstream, graph.ts / causality-graph.ts are pure projections of the core — no
+ * `typescript` import, no AST, no checker.
+ */
+export declare function interpret(workflow: WorkflowProgram, table: SiteTable): AnalysisCore;
+//# sourceMappingURL=interpret.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interpret.d.ts","sourceRoot":"","sources":["../../src/analysis/interpret.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C,OAAO,KAAK,EACV,YAAY,EASb,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,GAAG,YAAY,CAOnF"}

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

@@ -0,0 +1,200 @@
+import { provisionalFanoutId } from "./domain.js";
+import { computeArtifactTypes } from "./artifact-types.js";
+import { Evaluator } from "./taint.js";
+import { traceOrder } from "./causality-order.js";
+import { literalCardinality } from "./fanout-cardinality.js";
+/**
+ * The fused interpreter: ONE interpretation of
+ * the script that produces the {@link AnalysisCore}. Engine schedule:
+ *
+ *  1. the taint listener runs alone to a fixpoint ({@link Evaluator.converge} — global
+ *     env, placeholder summaries, semantics untouched);
+ *  2. ONE final temporal walk ({@link traceOrder}) rides the evaluation-order spine,
+ *     reading the converged state directly as its oracle ({@link TaintState.emitOracle})
+ *     — the settle-certainty judgements need converged facts, so logging events on
+ *     earlier iterations would be waste plus per-iteration state resets for nothing.
+ *     The order-insensitivity lemma makes this schedule safe: a gen-only, kill-free,
+ *     monotone fixpoint's result does not depend on visitation order, so the temporal
+ *     walk's evaluation order is not a second semantics.
+ *  3. minting ({@link mintCore}) digests everything position- or checker-shaped into
+ *     plain data: `within` containment resolved onto sites, provisional `fan-out@order`
+ *     ids renamed to final `fan-out#N` everywhere (occurrences and type keys included),
+ *     artifact types materialized as strings.
+ *
+ * Downstream, graph.ts / causality-graph.ts are pure projections of the core — no
+ * `typescript` import, no AST, no checker.
+ */
+export function interpret(workflow, table) {
+    const evaluator = new Evaluator(workflow, table);
+    evaluator.converge();
+    const facts = evaluator.s.emitFacts();
+    const oracle = evaluator.s.emitOracle();
+    const trace = traceOrder(workflow, table, oracle);
+    return mintCore(workflow, table, facts, trace, oracle.applications);
+}
+/** Mint the core: the one place raw offsets and the checker are still consulted. */
+function mintCore(workflow, table, facts, trace, applications) {
+    const { scriptFile } = workflow;
+    // Fan-out ordinals over promoted candidates (already source-ordered), and the rename
+    // from the taint pass's provisional ids. Moved here from graph assembly: the core
+    // speaks final ids only, the provisional vocabulary dies at this boundary.
+    const fanoutId = new Map();
+    facts.promoted.forEach((fanout, index) => fanoutId.set(fanout.id, `fan-out#${index + 1}`));
+    const rename = (site) => fanoutId.get(site) ?? site;
+    // Fan-out containment: a site executes once per element when it sits in a promoted
+    // candidate's BODY — lexically, or in the body of a function the candidate's body invokes
+    // (a named callback `xs.map(review)`, a helper called from the inline callback, and so on
+    // transitively, per the call oracle). "Nearest" = the innermost containing span, i.e. the
+    // one with the greatest start offset.
+    const spanOf = (node) => ({ end: node.getEnd(), start: node.getStart(scriptFile) });
+    const insideSpan = (pos, span) => span.start <= pos && pos < span.end;
+    const promotedSpans = [];
+    for (const cand of table.iterations) {
+        const id = fanoutId.get(provisionalFanoutId(cand.order));
+        if (id === undefined)
+            continue;
+        const seedSpans = [spanOf(cand.body)];
+        if (cand.call !== undefined) {
+            // A non-literal callback's body is the argument expression: no steps live in it, but
+            // the functions applied AT the call do.
+            for (const [fn, via] of applications.get(cand.call) ?? []) {
+                if (via === "argument")
+                    seedSpans.push(spanOf(fn));
+            }
+        }
+        // Closure: every function applied at a call site inside a span already in the set.
+        const spans = [...seedSpans];
+        const seen = new Set();
+        for (let i = 0; i < spans.length; i += 1) {
+            const span = spans[i];
+            for (const [site, fns] of applications) {
+                if (!insideSpan(site.getStart(scriptFile), span))
+                    continue;
+                for (const fn of fns.keys()) {
+                    if (seen.has(fn))
+                        continue;
+                    seen.add(fn);
+                    spans.push(spanOf(fn));
+                }
+            }
+        }
+        for (const span of spans)
+            promotedSpans.push({ id, ...span });
+    }
+    const within = (pos) => {
+        let best;
+        for (const span of promotedSpans) {
+            if (insideSpan(pos, span) && (best === undefined || span.start > best.start)) {
+                best = { id: span.id, start: span.start };
+            }
+        }
+        return best?.id;
+    };
+    const withinOf = (node) => {
+        const enclosing = within(node.getStart(scriptFile));
+        return enclosing === undefined ? {} : { within: enclosing };
+    };
+    const asks = table.asks.map((site) => ({
+        id: site.id,
+        label: site.label,
+        ...(site.labelPattern === undefined ? {} : { labelPattern: site.labelPattern }),
+        loc: site.loc,
+        order: site.order,
+        ...withinOf(site.call),
+    }));
+    const simple = (site) => ({
+        id: site.id,
+        label: site.label,
+        loc: site.loc,
+        order: site.order,
+        ...withinOf(site.call),
+    });
+    const actors = table.actors.map((site) => ({
+        id: site.id,
+        loc: site.loc,
+        ...(site.name === undefined ? {} : { name: site.name }),
+        ...(site.namePattern === undefined ? {} : { namePattern: site.namePattern }),
+        order: site.order,
+        ...withinOf(site.call),
+    }));
+    // A fan-out's own containment is anchored at its iterated expression, which sits
+    // outside its own body — so a candidate never reports itself, only an enclosing one.
+    const candByOrder = new Map(table.iterations.map((cand) => [cand.order, cand]));
+    const checker = workflow.program.getTypeChecker();
+    const fanouts = facts.promoted.map((fanout) => {
+        const cand = candByOrder.get(fanout.order);
+        // 字面量基数也是铸造期的事：它要看被迭代表达式的 AST 与绑定，投影只读一个数。
+        const cardinality = cand === undefined ? undefined : literalCardinality(cand.iterated, checker);
+        return {
+            id: fanoutId.get(fanout.id),
+            label: fanout.label,
+            loc: fanout.loc,
+            order: fanout.order,
+            ...(cand === undefined ? {} : withinOf(cand.iterated)),
+            ...(cardinality === undefined ? {} : { cardinality }),
+        };
+    });
+    // 只有开放的留白是站点（docs/analysis.md「Sites」）：已补全的留白是一个阶段，不是一步。
+    // 名字 / 类型缺席的留白在 9012 处已挡下，这里的兜底只是把不变量写下来。
+    const holes = table.holes
+        .filter((site) => site.body === undefined)
+        .map((site) => ({
+        ...(site.fill === undefined ? {} : { fill: site.fill }),
+        id: site.id,
+        loc: site.loc,
+        name: site.name ?? site.id,
+        order: site.order,
+        ...(site.tail ? { tail: true } : {}),
+        type: site.typeText ?? "unknown",
+        ...withinOf(site.call),
+    }));
+    const sites = {
+        actors,
+        asks,
+        fanouts,
+        holes,
+        joins: table.joins.map(simple),
+        worldReads: table.worldReads.map(simple),
+    };
+    return {
+        facts: mintFacts(facts, fanoutId, rename),
+        sites,
+        trace,
+        types: mintTypes(computeArtifactTypes(workflow, table), rename),
+    };
+}
+/** Rewrite every occurrence and every `fanoutIn` key to final ids; drop non-promoted
+ * fan-out sinks (a candidate that never promoted is a graph node in nothing — the same
+ * `continue` graph assembly used to apply at edge emission). */
+function mintFacts(facts, fanoutId, rename) {
+    const renameOccs = (occs) => occs.map((occ) => ({ exact: occ.exact, site: rename(occ.site), ...(occ.port === undefined ? {} : { port: occ.port }) }));
+    const renameMap = (map) => {
+        const out = new Map();
+        for (const [sink, occs] of map)
+            out.set(sink, renameOccs(occs));
+        return out;
+    };
+    const fanoutIn = new Map();
+    for (const [provId, occs] of facts.fanoutIn) {
+        const finalId = fanoutId.get(provId);
+        if (finalId === undefined)
+            continue;
+        fanoutIn.set(finalId, renameOccs(occs));
+    }
+    return {
+        askActor: renameMap(facts.askActor),
+        askData: renameMap(facts.askData),
+        fanoutIn,
+        holeData: renameMap(facts.holeData),
+        joinIn: renameMap(facts.joinIn),
+        returnData: renameOccs(facts.returnData),
+        worldReadData: renameMap(facts.worldReadData),
+    };
+}
+/** Rename the fan-out keys of the checker's type answers to final ids. */
+function mintTypes(types, rename) {
+    const siteType = new Map();
+    for (const [id, type] of types.siteType)
+        siteType.set(rename(id), type);
+    return { joinPortTypes: types.joinPortTypes, siteType };
+}

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

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+/**
+ * Array- and object-literal evaluation, split out of the core evaluator (taint.ts) like
+ * the call/relay rules in calls.ts — same `Evaluator` instance, free-function shape. A
+ * container literal is field-sensitive: a place element/property stores the LIVE value it
+ * denotes (aliasing), and spread copies its source's fields by reference (shallow copy).
+ *
+ * Both functions build a FRESH value for this pass; the evaluator hands it to
+ * `state.literalPlaceOf`, which adopts it on first sight and merges it into the persistent
+ * allocation-site place afterwards. So the value that flows on from a literal is storage
+ * that survives the pass (a callee may write through it), and the `changed` signal for a
+ * re-evaluation that grew is raised there — neither function touches `ev.s.changed`.
+ */
+export declare function evalArrayLiteral(ev: Evaluator, node: ts.ArrayLiteralExpression, ctx: EvalContext): AbstractValue;
+export declare function evalObjectLiteral(ev: Evaluator, node: ts.ObjectLiteralExpression, ctx: EvalContext): AbstractValue;
+//# sourceMappingURL=literals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../src/analysis/literals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;GAWG;AAEH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,sBAAsB,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAmBhH;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,uBAAuB,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAyDlH"}