@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

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

@@ -0,0 +1,31 @@
+import ts from "typescript";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+/**
+ * Destructuring / aliasing bind machinery, split out of the core evaluator (taint.ts) like
+ * the call/relay rules in calls.ts and the assignment rules in assign.ts — same `Evaluator`
+ * instance, free-function shape. Declarations, for-of/for-in initializers and callback
+ * parameters all route through {@link bindPattern}.
+ */
+/**
+ * Bind a destructuring pattern (or a single name). When `sourcePlace` is a LIVE place,
+ * pattern elements selecting a statically-known field ALIAS to that live field (the
+ * extracted binding and the container share one object), so `const { o } = wrap; o.f = t`
+ * is visible through `wrap.o`. See {@link extractField} for the seed-on-absent handling
+ * that preserves opaque containers' collapse-fallback flow. Rest elements and non-place
+ * sources keep value semantics (a folded / field-selected clone).
+ */
+export declare function bindPattern(ev: Evaluator, name: ts.BindingName, value: AbstractValue, ctx: EvalContext, sourcePlace?: AbstractValue): void;
+/**
+ * The live field at `key` of a place, for destructuring aliasing. An existing field is
+ * returned as-is (a real sub-object). An ABSENT field is created and SEEDED with the
+ * container's own occurrences + placeholders (occs-only) — exactly what a read of the
+ * field would collapse to on an opaque container (`const { feedback } = review`), so the
+ * extraction never drops taint; and because it is now a shared field, a later write
+ * through the extracted binding lands where the container sees it too. Never re-seeds an
+ * existing field (that would over-smear a precise sub-object).
+ */
+export declare function extractField(ev: Evaluator, container: AbstractValue, key: string): AbstractValue;
+/** Read a statically-known field with smear-on-read, else collapse (exact preserved). */
+export declare function selectField(value: AbstractValue, key: string): AbstractValue;
+//# sourceMappingURL=patterns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.d.ts","sourceRoot":"","sources":["../../src/analysis/patterns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,SAAS,EACb,IAAI,EAAE,EAAE,CAAC,WAAW,EACpB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,WAAW,EAChB,WAAW,CAAC,EAAE,aAAa,GAC1B,IAAI,CAsCN;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAShG;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAE5E"}

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

@@ -0,0 +1,94 @@
+import ts from "typescript";
+import { addOcc, addPlaceholder, bindingPropertyKey, collapse, emptyValue, mergeInto, readField, } from "./domain.js";
+/**
+ * Destructuring / aliasing bind machinery, split out of the core evaluator (taint.ts) like
+ * the call/relay rules in calls.ts and the assignment rules in assign.ts — same `Evaluator`
+ * instance, free-function shape. Declarations, for-of/for-in initializers and callback
+ * parameters all route through {@link bindPattern}.
+ */
+/**
+ * Bind a destructuring pattern (or a single name). When `sourcePlace` is a LIVE place,
+ * pattern elements selecting a statically-known field ALIAS to that live field (the
+ * extracted binding and the container share one object), so `const { o } = wrap; o.f = t`
+ * is visible through `wrap.o`. See {@link extractField} for the seed-on-absent handling
+ * that preserves opaque containers' collapse-fallback flow. Rest elements and non-place
+ * sources keep value semantics (a folded / field-selected clone).
+ */
+export function bindPattern(ev, name, value, ctx, sourcePlace) {
+    if (ts.isIdentifier(name)) {
+        const sym = ev.checker.getSymbolAtLocation(name);
+        if (sym !== undefined)
+            ev.s.bindSymbol(sym, value);
+        return;
+    }
+    if (ts.isObjectBindingPattern(name)) {
+        for (const element of name.elements) {
+            if (element.dotDotDotToken !== undefined) {
+                bindPattern(ev, element.name, collapse(value), ctx); // rest: fold, exact preserved (value semantics)
+                continue;
+            }
+            const key = bindingPropertyKey(element);
+            if (sourcePlace !== undefined && key !== undefined) {
+                bindPatternElement(ev, element.name, extractField(ev, sourcePlace, key), element.initializer, ctx);
+            }
+            else {
+                bindPattern(ev, element.name, key === undefined ? collapse(value) : selectField(value, key), ctx);
+            }
+        }
+        return;
+    }
+    let index = 0;
+    for (const element of name.elements) {
+        if (ts.isOmittedExpression(element)) {
+            index += 1;
+            continue;
+        }
+        if (element.dotDotDotToken !== undefined) {
+            bindPattern(ev, element.name, collapse(value), ctx); // rest: value semantics
+            continue;
+        }
+        if (sourcePlace !== undefined) {
+            bindPatternElement(ev, element.name, extractField(ev, sourcePlace, String(index)), element.initializer, ctx);
+        }
+        else {
+            bindPattern(ev, element.name, selectField(value, String(index)), ctx);
+        }
+        index += 1;
+    }
+}
+/**
+ * Bind one destructuring element to a LIVE field: a default initializer weak-merges into
+ * the field (runtime may bind either the field or the default — a sound over-approx), and
+ * the field is passed as both value and source so nested patterns keep aliasing.
+ */
+function bindPatternElement(ev, name, field, initializer, ctx) {
+    if (initializer !== undefined && mergeInto(field, ev.evalExpr(initializer, ctx)))
+        ev.s.changed = true;
+    bindPattern(ev, name, field, ctx, field);
+}
+/**
+ * The live field at `key` of a place, for destructuring aliasing. An existing field is
+ * returned as-is (a real sub-object). An ABSENT field is created and SEEDED with the
+ * container's own occurrences + placeholders (occs-only) — exactly what a read of the
+ * field would collapse to on an opaque container (`const { feedback } = review`), so the
+ * extraction never drops taint; and because it is now a shared field, a later write
+ * through the extracted binding lands where the container sees it too. Never re-seeds an
+ * existing field (that would over-smear a precise sub-object).
+ */
+export function extractField(ev, container, key) {
+    const existing = container.fields.get(key);
+    if (existing !== undefined)
+        return existing;
+    const field = emptyValue();
+    for (const occ of container.occs.values())
+        addOcc(field, occ);
+    for (const ph of container.phs.values())
+        addPlaceholder(field, ph);
+    container.fields.set(key, field);
+    ev.s.changed = true;
+    return field;
+}
+/** Read a statically-known field with smear-on-read, else collapse (exact preserved). */
+export function selectField(value, key) {
+    return readField(value, key);
+}

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

@@ -0,0 +1,47 @@
+import type { OrderEvent, PhaseInfo } from "./causality-order.js";
+import { type OrderKind } from "./causality-reduce.js";
+import type { CausalityGraph, Certainty } from "./causality-graph.js";
+/** 认领关系：谁属于哪个阶段，以及该认领有多确定。全部按**站点 id** 键。 */
+interface PhaseClaims {
+    /** 站点 -> 认领它的阶段，按 issue 顺序去重。 */
+    bySite: Map<string, string[]>;
+    /** `${site}|${phase}` -> 该阶段内部的认领 certainty。 */
+    certainty: Map<string, Certainty>;
+    /** 阶段 -> 首个成员 issue 的时钟位置；商图事实的排序键。 */
+    position: Map<string, number>;
+    /** `${site}|${phase}` -> 该站点在该阶段的首次 / 末次 issue 位置（时间可行性判定）。 */
+    firstIssue: Map<string, number>;
+    lastIssue: Map<string, number>;
+}
+/** 商图的输入：归约后的 step 边（sink 边已剔除），certainty 已按端点继承过。 */
+export interface PhaseSourceFact {
+    from: string;
+    to: string;
+    kind: OrderKind;
+    certainty: Certainty;
+    /** carry 边改型前的底层 kind；carry 最小化按它判见证强度。 */
+    carryOf?: Exclude<OrderKind, "carry">;
+    /**
+     * 见证这条事实的 issue 事件所在的阶段集（只有 await 屏障产生的 seq 事实带它；见
+     * causality-graph.ts 的 `Fact.toPhases`）。头端收窄按 {@link headPhasesOf}。
+     */
+    toPhases?: ReadonlySet<string>;
+}
+/**
+ * 从 issue 事件读出认领关系。issue 是 step 的身份时刻，所以这一趟就是全部的归属逻辑。
+ *
+ * 每个 (站点, 阶段) 的 certainty 单独推导：该阶段内**存在**一次区域链确定的 issue，且该
+ * step 不是 control 边的目标。逐字对应 causality-graph.ts 的 `certaintyOf`，只是把「所有
+ * issue」换成「该阶段的 issue」——共享 helper 在 preflight（顶层）与 gate（循环+分支内）
+ * 各一份拷贝时，两份的 certainty 因此可以不同，这正是拷贝要单独推导的理由。
+ */
+export declare function collectPhaseClaims(events: readonly OrderEvent[], steps: ReadonlySet<string>, certainChain: (chain: readonly string[]) => boolean, controlled: ReadonlySet<string>): PhaseClaims;
+/**
+ * 把阶段词汇表加到完成的因果图上：拷贝、`Step.phase`、阶段表、阶段边。
+ *
+ * 在 `expandMaySetLanes` **之后**运行（对车道拷贝逐份认领），且与它同为「对成品图的机械
+ * 改写」：步骤集、车道、region、step 边的既有内容都不重算。
+ */
+export declare function projectPhaseGraph(graph: CausalityGraph, phases: readonly PhaseInfo[], claims: PhaseClaims, facts: readonly PhaseSourceFact[], sharesIteration: (a: string, b: string) => boolean): CausalityGraph;
+export {};
+//# sourceMappingURL=phase-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"phase-graph.d.ts","sourceRoot":"","sources":["../../src/analysis/phase-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAA0B,MAAM,sBAAsB,CAAC;AAuB9F,6CAA6C;AAC7C,UAAU,WAAW;IACnB,iCAAiC;IACjC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9B,gDAAgD;IAChD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,uCAAuC;IACvC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,+DAA+D;IAC/D,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,sDAAsD;AACtD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAChC;AAiBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,UAAU,EAAE,EAC7B,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,EACnD,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,WAAW,CA+Bb;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,eAAe,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,GACjD,cAAc,CAoOhB"}

package/vendor/dynamic-workflow/analysis/phase-graph.js

@@ -0,0 +1,334 @@
+import { UNPHASED_ID } from "./constants.js";
+import { KIND_RANK, reduceOrdering } from "./causality-reduce.js";
+/**
+ * 阶段视图：作者用 `phase("名字")` 标记施加的分组，以及它在因果图上的**商图**
+ *
+ * 因果图本体一字不动——这里只做两件事，都是对已完成的图的机械改写：
+ *
+ *  - **跨阶段拷贝**：被 k>1 个阶段认领的 step 变成 k 份拷贝（`~` 后缀 id + `source` 联
+ *    key，与 may-set 车道拷贝同机制、同分隔符），使「每个 step 恰有一个 phase」的全划分
+ *    成立；
+ *  - **商图**：归约后的 step 边按认领关系投影到阶段对上，去重后跑同一个
+ *    {@link reduceOrdering}。
+ *
+ * 零标记脚本这里整体是恒等函数：三个字段全部缺席，既有快照逐字节不动。这不是优化，是
+ * 契约——UI 的视图切换条件就是「阶段词汇表在场与否」。
+ *
+ * 单独一个模块而不是塞进 causality-graph.ts：那份文件已经在 max-lines 上，而阶段是它
+ * 上面的一层视图，正如因果图是站点图上面的一层视图。
+ */
+/** 拷贝 id 分隔符：与 may-set 车道拷贝同一个（两种展开叠加时形如 `ask#2~actor#1~phase#2`）。 */
+const COPY_SEPARATOR = "~";
+/**
+ * 一条边的头端应落在哪些阶段上：**有来源信息就取交集，没有就全展开**。
+ *
+ * 拷贝改写与商图投影必须用同一条规则，否则 `phaseEdges` 和下钻里的 step 边会讲两个不同的
+ * 故事——这是把两个消费者绑在一个函数上的全部理由。
+ *
+ * 交集在实践中等于 `toPhases` 自己（屏障事实的见证阶段必然是头站点的认领阶段），交集写出来
+ * 是为了让「阶段被丢弃/收窄」这类上游变化不会把边挂到不存在的阶段上。
+ */
+function headPhasesOf(claiming, toPhases) {
+    if (toPhases === undefined)
+        return [...claiming];
+    const narrowed = claiming.filter((phase) => toPhases.has(phase));
+    return narrowed.length > 0 ? narrowed : [...claiming];
+}
+/**
+ * 从 issue 事件读出认领关系。issue 是 step 的身份时刻，所以这一趟就是全部的归属逻辑。
+ *
+ * 每个 (站点, 阶段) 的 certainty 单独推导：该阶段内**存在**一次区域链确定的 issue，且该
+ * step 不是 control 边的目标。逐字对应 causality-graph.ts 的 `certaintyOf`，只是把「所有
+ * issue」换成「该阶段的 issue」——共享 helper 在 preflight（顶层）与 gate（循环+分支内）
+ * 各一份拷贝时，两份的 certainty 因此可以不同，这正是拷贝要单独推导的理由。
+ */
+export function collectPhaseClaims(events, steps, certainChain, controlled) {
+    const bySite = new Map();
+    const position = new Map();
+    const firstIssue = new Map();
+    const lastIssue = new Map();
+    const certainSeen = new Set();
+    // 与 causality-graph.ts 同一个时钟：每个 issue 事件走一格，不论它是否落在图里的 step 上。
+    let clock = 0;
+    for (const event of events) {
+        if (event.at !== "issue")
+            continue;
+        const at = clock;
+        clock += 1;
+        if (!steps.has(event.step))
+            continue;
+        const claiming = bySite.get(event.step);
+        if (claiming === undefined)
+            bySite.set(event.step, [event.phase]);
+        else if (!claiming.includes(event.phase))
+            claiming.push(event.phase);
+        if (!position.has(event.phase))
+            position.set(event.phase, at);
+        const key = `${event.step}|${event.phase}`;
+        if (!firstIssue.has(key))
+            firstIssue.set(key, at);
+        lastIssue.set(key, at);
+        if (certainChain(event.regions))
+            certainSeen.add(key);
+    }
+    const certainty = new Map();
+    for (const [site, claiming] of bySite) {
+        for (const phase of claiming) {
+            const key = `${site}|${phase}`;
+            certainty.set(key, certainSeen.has(key) && !controlled.has(site) ? "always" : "maybe");
+        }
+    }
+    return { bySite, certainty, firstIssue, lastIssue, position };
+}
+/**
+ * 把阶段词汇表加到完成的因果图上：拷贝、`Step.phase`、阶段表、阶段边。
+ *
+ * 在 `expandMaySetLanes` **之后**运行（对车道拷贝逐份认领），且与它同为「对成品图的机械
+ * 改写」：步骤集、车道、region、step 边的既有内容都不重算。
+ */
+export function projectPhaseGraph(graph, phases, claims, facts, sharesIteration) {
+    if (phases.length === 0)
+        return graph; // 零标记 → 零词汇表，图逐字节不动
+    const claimsOf = (siteId) => claims.bySite.get(siteId) ?? [UNPHASED_ID];
+    const certaintyOfClaim = (siteId, phase) => claims.certainty.get(`${siteId}|${phase}`) ?? "maybe";
+    /**
+     * 时间可行性：一条 a→b 的边能不能落在拷贝对 (a@P, b@Q) 上。
+     *
+     * 每份阶段拷贝**占据一个时间位置**，这是它与 may-set 车道拷贝的根本差别——车道拷贝同 rank
+     * 并排，全展开不会断言任何顺序；阶段拷贝全展开会断言假的顺序（「gate 的 bench settle 在
+     * preflight 的 bench issue 之前」）。而这里的信息 walk 是有的：每个 (站点, 阶段) 的 issue
+     * 位置。多序是被许可的方向，错序不是。
+     *
+     * 两条通道，或关系：
+     *  - **位置**：b 在 Q 里至少有一次 issue 落在 a 在 P 里首次 issue 之后；
+     *  - **重复**：两个站点共享一个封闭迭代区域。这条**不是可选项**——第 k 轮的生产者喂第
+     *    k+1 轮的拷贝，位置上是「在前」而实际可实现（reduce-accumulator 的教训）。去掉它，
+     *    跨阶段的循环携带数据会整片消失，而那是凭空造出并发，唯一被禁止的方向。
+     *
+     * 与 causality-graph.ts 的 `realizableCarry` 共用同一个 `sharesIteration`：同一个关系上的
+     * 同一个问题，两处不能各答一次。
+     */
+    const admits = (from, fromPhase, to, toPhase) => {
+        const firstFrom = claims.firstIssue.get(`${from}|${fromPhase}`);
+        const lastTo = claims.lastIssue.get(`${to}|${toPhase}`);
+        if (firstFrom === undefined || lastTo === undefined)
+            return true; // 无位置可判：不拦
+        return lastTo > firstFrom || sharesIteration(from, to);
+    };
+    /**
+     * 受时间可行性约束的 kind。`carry` 不在内：它自己的可实现性在 `realizableCarry` 已经判过，
+     * 而且 carry 断言的就是「下一轮」，位置比较对它无意义。`fifo` 不在内：车道规则已经决定了
+     * 它，且同站点的两份拷贝共享车道、确实彼此 FIFO 排序。
+     */
+    const ADMITTED_KINDS = new Set(["data", "control", "seq"]);
+    // --- 1. 跨阶段拷贝 ---------------------------------------------------------------
+    // 拷贝是 **both-run，不是候选**——不要顺手按 may-set 拷贝的类比改成 maybe。站点真的从
+    // 两个调用方各自发出（共享 helper 在 preflight 与 gate 各跑一次），两份都会执行；每份的
+    // certainty 只反映**它自己那个阶段**的认领有多确定，不表示「二者之一」。
+    //
+    // `region` 与 `repeat` 是**站点级事实**（取自站点首次 issue），故意不按阶段重算：拷贝是
+    // 对成品图的机械改写，重算区域归属要的是每阶段一份的 region 树，那是另一个决定。所以
+    // gate 那份 bench 拷贝带着 preflight 首个 issue 的 `region` 和 `stack`——不要在没有决定
+    // 的情况下把它「修好」。
+    const copiesOf = new Map();
+    for (const step of graph.steps) {
+        const siteId = step.source ?? step.id;
+        const claiming = claimsOf(siteId);
+        if (claiming.length < 2)
+            continue;
+        copiesOf.set(step.id, claiming.map((phase) => ({
+            ...step,
+            certainty: weakest([step.certainty, certaintyOfClaim(siteId, phase)]),
+            id: `${step.id}${COPY_SEPARATOR}${phase}`,
+            phase,
+            // `source` 是运行时实际上报的站点 id，**只设一次**：车道拷贝已经带上了，沿用。
+            source: siteId,
+        })));
+    }
+    const steps = graph.steps.flatMap((step) => {
+        const copies = copiesOf.get(step.id);
+        if (copies !== undefined)
+            return copies;
+        // k = 1：认领唯一，所以该阶段的 certainty 与 step 自己的逐字相等（全部 issue 都在
+        // 这个阶段里），不必覆盖。
+        return [{ ...step, phase: claimsOf(step.source ?? step.id)[0] }];
+    });
+    // --- 2. 边改写：镜像 expandMaySetLanes 的机制 --------------------------------------
+    const stepById = new Map(graph.steps.map((step) => [step.id, step]));
+    const siteOf = (id) => {
+        const step = stepById.get(id);
+        return step === undefined ? id : (step.source ?? step.id);
+    };
+    // 事实的来源信息按**站点对**索引（事实先于两种拷贝存在，且每个有序对只有一条），所以
+    // 车道拷贝的边先折算回站点对再查。
+    const provenance = new Map();
+    for (const fact of facts) {
+        if (fact.toPhases !== undefined)
+            provenance.set(`${fact.from}|${fact.to}`, fact.toPhases);
+    }
+    const endpointsOf = (id, toPhases) => {
+        const copies = copiesOf.get(id);
+        if (copies !== undefined) {
+            const heads = new Set(headPhasesOf(claimsOf(siteOf(id)), toPhases));
+            return copies
+                .filter((copy) => heads.has(copy.phase))
+                .map((copy) => ({
+                certainty: copy.certainty,
+                id: copy.id,
+                lane: copy.lane,
+                phase: copy.phase,
+            }));
+        }
+        const step = stepById.get(id);
+        return [
+            {
+                certainty: step?.certainty ?? "maybe",
+                id,
+                lane: step?.lane,
+                phase: claimsOf(siteOf(id))[0],
+            },
+        ];
+    };
+    const edges = [];
+    for (const edge of graph.edges) {
+        // 两端都不是拷贝 → 原样保留。这条早退也是「零标记逐字节不变」的构造性保证：单端点对
+        // 从不经过下面任何一条规则。
+        if (!copiesOf.has(edge.from) && !copiesOf.has(edge.to)) {
+            edges.push(edge);
+            continue;
+        }
+        const fromSite = siteOf(edge.from);
+        const toSite = siteOf(edge.to);
+        // 尾端不按 provenance 收窄（settle 事件不带阶段），但**尾端同样受时间可行性约束**——
+        // 这就是那条尾侧伪边（拷贝排在产出它自己实参的那个 ask 之前）的归宿。
+        const pairs = [];
+        const admitted = [];
+        for (const tail of endpointsOf(edge.from)) {
+            for (const head of endpointsOf(edge.to, provenance.get(`${fromSite}|${toSite}`))) {
+                // fifo 按车道匹配，与车道展开同一条规则。同站点的阶段拷贝共享车道，所以它们之间的
+                // fifo 边幸存——这是对的：一个站点的两次发出确实彼此 FIFO 排序。
+                if (edge.kind === "fifo" && tail.lane !== head.lane)
+                    continue;
+                // 同一份拷贝到自己：只有原边本来就是自边时才成立（不同站点的拷贝 id 不可能相等），
+                // 所以这是把不变量写下来，不是语料里到达过的分支。
+                if (tail.id === head.id && edge.from !== edge.to)
+                    continue;
+                const pair = {
+                    certainty: weakest([edge.certainty, tail.certainty, head.certainty]),
+                    from: tail.id,
+                    to: head.id,
+                };
+                pairs.push(pair);
+                if (!ADMITTED_KINDS.has(edge.kind) || admits(fromSite, tail.phase, toSite, head.phase)) {
+                    admitted.push(pair);
+                }
+            }
+        }
+        // 全被拦下 → 退回全展开，与 {@link headPhasesOf} 同一个姿态：一条真实的序在哪儿都不
+        // 可实现，说明位置判断误导了我们，而静默删掉一条真实的序就是凭空造出并发。
+        for (const pair of admitted.length > 0 ? admitted : pairs) {
+            edges.push({ ...edge, ...pair });
+        }
+    }
+    // --- 3. 阶段表：有成员的阶段，unphased 排最前 -------------------------------------
+    const members = new Set(steps.map((step) => step.phase));
+    const phaseList = [];
+    if (members.has(UNPHASED_ID))
+        phaseList.push({ id: UNPHASED_ID });
+    for (const phase of phases) {
+        // 成员为零的阶段丢掉（may-set 收窄可能把某阶段的全部 step 拿走）——空节点没有家可指。
+        if (!members.has(phase.id))
+            continue;
+        phaseList.push({
+            id: phase.id,
+            loc: phase.loc,
+            name: phase.name,
+            ...(phase.fill === undefined ? {} : { fill: phase.fill }),
+        });
+    }
+    const live = new Set(phaseList.map((phase) => phase.id));
+    // --- 4. 商图：在认领关系上算，不依赖拷贝的物化 ------------------------------------
+    const quotient = [];
+    for (const fact of facts) {
+        // 与拷贝改写逐条同规则：头端收窄（{@link headPhasesOf}）+ 时间可行性（{@link admits}），
+        // 且同样只在至少一端被拷贝时生效。两个消费者不能各讲一个故事——`phaseEdges` 与下钻里的
+        // step 边讲的必须是同一件事。
+        const tails = claimsOf(fact.from);
+        const heads = headPhasesOf(claimsOf(fact.to), fact.toPhases);
+        const copied = tails.length > 1 || claimsOf(fact.to).length > 1;
+        const gated = copied && ADMITTED_KINDS.has(fact.kind);
+        const pairs = [];
+        const admitted = [];
+        for (const from of tails) {
+            for (const to of heads) {
+                pairs.push({ from, to });
+                if (!gated || admits(fact.from, from, fact.to, to))
+                    admitted.push({ from, to });
+            }
+        }
+        for (const { from, to } of admitted.length > 0 ? admitted : pairs) {
+            if (!live.has(from) || !live.has(to))
+                continue;
+            // 阶段内序不出图；阶段内的 carry 是「循环整个住在一个阶段里」的画法，留成自环。
+            if (from === to && fact.kind !== "carry")
+                continue;
+            quotient.push({
+                certainty: fact.certainty,
+                from,
+                kind: fact.kind,
+                to,
+                ...(fact.carryOf === undefined ? {} : { carryOf: fact.carryOf }),
+            });
+        }
+    }
+    const position = (id) => claims.position.get(id) ?? 0;
+    const deduped = dedupePhaseFacts(quotient).sort((a, b) => position(a.from) - position(b.from) ||
+        position(a.to) - position(b.to) ||
+        a.kind.localeCompare(b.kind));
+    // 阶段边不携带 `exact`：那是 data 边的 taint 见证位，在商上无定义。
+    const phaseEdges = reduceOrdering(deduped).map((fact) => ({
+        certainty: fact.certainty,
+        from: fact.from,
+        kind: fact.kind,
+        to: fact.to,
+    }));
+    const sink = graph.sink;
+    return {
+        edges,
+        lanes: graph.lanes,
+        phaseEdges,
+        phases: phaseList,
+        regions: graph.regions,
+        steps,
+        // 阶段级 sink 边不出图（UI 由 fedBy step 的 phase 推导），但 fedBy 自己要跟着拷贝走。
+        ...(sink === undefined
+            ? {}
+            : { sink: { fedBy: sink.fedBy.flatMap((id) => endpointsOf(id).map((end) => end.id)) } }),
+    };
+}
+/**
+ * 每个有序阶段对留一条事实：kind 取最强（{@link KIND_RANK}）、certainty maybe-wins——
+ * **逐字镜像 step 级 `dedupeFacts`**，一致性优先（「任一 always 见证即 always」在商上
+ * 语义更准）。
+ */
+function dedupePhaseFacts(facts) {
+    const byPair = new Map();
+    for (const fact of facts) {
+        const key = `${fact.from}|${fact.to}`;
+        const existing = byPair.get(key);
+        if (existing === undefined) {
+            byPair.set(key, { ...fact });
+            continue;
+        }
+        if (KIND_RANK[fact.kind] > KIND_RANK[existing.kind])
+            existing.kind = fact.kind;
+        if (existing.carryOf === undefined && fact.carryOf !== undefined)
+            existing.carryOf = fact.carryOf;
+        if (fact.certainty === "maybe")
+            existing.certainty = "maybe";
+    }
+    return [...byPair.values()];
+}
+function weakest(values) {
+    return values.includes("maybe") ? "maybe" : "always";
+}

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

@@ -0,0 +1,24 @@
+/**
+ * `phase("…")` 标记的编译期校验。
+ *
+ * 两条规则，同一个理由——**标记必须在提交前就说清楚它指的是什么**。名字是编译期字面量，
+ * 因为阶段集在确认窗上被展示（与 `world.run` 的 cmd 同姿态：运行期才成形的名字没有可展示
+ * 的对象）；调用必须是独立语句，因为标记的意义就是「从这里到块尾」，一个待在初始化器/
+ * 实参/三元臂里的标记没有可指的范围。两条都是**定位诊断**而不是运行期兜底：教改写发生在
+ * 便宜的那一侧。
+ *
+ * 别名逃逸（`const p = phase`）不在这里——`phase` 是 facade 函数声明，facade-misuse 的
+ * pass 1 已经拒绝任何非直接调用位置的引用。
+ */
+import type { CompileDiagnostic, WorkflowProgram } from "../compiler/compile.js";
+import type { SiteTable } from "./sites.js";
+/** phase 标记的诊断码（9001 = facade-siting、9002 = schema、9003 = world-run，顺延）。 */
+export declare const PHASE_MARKER_CODE = 9004;
+/**
+ * 校验收集到的 phase 标记。非空即脚本不可提交（`analyzeWorkflowScript` 与 misuse /
+ * world.run 同席处理）。
+ *
+ * 一个标记可以同时犯两条（`const x = phase(bad)`），两条都报：作者一次就能看全要改什么。
+ */
+export declare function collectPhaseMarkerDiagnostics(workflow: WorkflowProgram, table: SiteTable): CompileDiagnostic[];
+//# sourceMappingURL=phases.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"phases.d.ts","sourceRoot":"","sources":["../../src/analysis/phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAa,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC5F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAmBtC;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,SAAS,GACf,iBAAiB,EAAE,CAsBrB"}

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

@@ -0,0 +1,54 @@
+/**
+ * `phase("…")` 标记的编译期校验。
+ *
+ * 两条规则，同一个理由——**标记必须在提交前就说清楚它指的是什么**。名字是编译期字面量，
+ * 因为阶段集在确认窗上被展示（与 `world.run` 的 cmd 同姿态：运行期才成形的名字没有可展示
+ * 的对象）；调用必须是独立语句，因为标记的意义就是「从这里到块尾」，一个待在初始化器/
+ * 实参/三元臂里的标记没有可指的范围。两条都是**定位诊断**而不是运行期兜底：教改写发生在
+ * 便宜的那一侧。
+ *
+ * 别名逃逸（`const p = phase`）不在这里——`phase` 是 facade 函数声明，facade-misuse 的
+ * pass 1 已经拒绝任何非直接调用位置的引用。
+ */
+import ts from "typescript";
+/** phase 标记的诊断码（9001 = facade-siting、9002 = schema、9003 = world-run，顺延）。 */
+export const PHASE_MARKER_CODE = 9004;
+const LITERAL_MESSAGE = 'phase()\'s argument must be a compile-time string literal ("gate" or a no-substitution ' +
+    "template): the script's phase names are fixed when it is submitted, because they label " +
+    "the graph the user confirms before anything runs. Write the name inline — a name that " +
+    "only exists at run time cannot be drawn.";
+const EMPTY_MESSAGE = 'phase("") has no name to show: the phase label is what the confirmation graph draws. ' +
+    'Give the group a word ("preflight", "gate", "wrap-up"), or drop the marker — a script ' +
+    "with no markers is perfectly legal and is drawn step by step.";
+const STATEMENT_MESSAGE = 'phase("…") must stand alone as its own statement. The marker claims the rest of the block ' +
+    "it stands in, so one in expression position (a variable initializer, an argument, a " +
+    "ternary arm) has no rest-of-block to claim. Put the call on its own line at the head of " +
+    "the steps it names.";
+/**
+ * 校验收集到的 phase 标记。非空即脚本不可提交（`analyzeWorkflowScript` 与 misuse /
+ * world.run 同席处理）。
+ *
+ * 一个标记可以同时犯两条（`const x = phase(bad)`），两条都报：作者一次就能看全要改什么。
+ */
+export function collectPhaseMarkerDiagnostics(workflow, table) {
+    const diagnostics = [];
+    const push = (loc, message) => {
+        diagnostics.push({ code: PHASE_MARKER_CODE, column: loc.column, line: loc.line, message });
+    };
+    for (const marker of table.phases) {
+        // 名字的诊断落在**出问题的那个表达式**上（缺席时退回调用位置）：作者要改的是那一处。
+        const nameLoc = marker.nameExpr === undefined
+            ? marker.loc
+            : workflow.toScriptLoc(marker.nameExpr.getStart(workflow.scriptFile));
+        if (marker.name === undefined) {
+            push(nameLoc, LITERAL_MESSAGE);
+        }
+        else if (marker.name.trim() === "") {
+            push(nameLoc, EMPTY_MESSAGE);
+        }
+        if (!ts.isExpressionStatement(marker.call.parent)) {
+            push(marker.loc, STATEMENT_MESSAGE);
+        }
+    }
+    return diagnostics;
+}

package/vendor/dynamic-workflow/analysis/promise-ops.d.ts

@@ -0,0 +1,52 @@
+import ts from "typescript";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+/**
+ * `new UnknownThing(args)` (a non-class callee: `new Promise(exec)`, `new Set([x])`): the
+ * union of the argument collapses (exact preserved, "strings launder nothing"), PLUS the
+ * unknown-call keystone — function-valued args are pessimistically applied (their return
+ * summary joins the result) — PLUS the promise-executor rule: whatever a function arg feeds
+ * to invocations of its OWN parameters joins the result (`new Promise((resolve) =>
+ * resolve(draft))` resolves to `draft`; a `reject(x)` arg lands in the pot too, an
+ * over-approximation of the rejection path). Generic: `new X(fn)` may invoke fn and capture
+ * what fn's params receive — never special-cased by name.
+ */
+export declare function handleNewUnknown(ev: Evaluator, node: ts.NewExpression, ctx: EvalContext): AbstractValue;
+/**
+ * `await e`: model awaiting a thenable = invoking its `then`. When the awaited value carries
+ * a tracked `then` method, the promise resolves to whatever that method feeds its continuation
+ * callback (`appliedCallbackTaint`): a custom thenable whose `then(onOk)` calls
+ * `draft.then(onOk)` resolves to `draft`. When no `then` fn is visible (a plain settled value,
+ * or a thenable collapsed past field-sensitivity), the operand's own taint already flows
+ * through unchanged — the await is a passthrough, as before.
+ *
+ * Both exits also RECORD the returned value as the settle oracle for this await. Recording only; the value returned to
+ * the evaluator is untouched, so no transfer rule changes.
+ */
+export declare function evalAwait(ev: Evaluator, node: ts.AwaitExpression, ctx: EvalContext): AbstractValue;
+/** `Promise.reject(x)` — a rejected promise. Await unwraps it as a THROW, so feed collapse(x)
+ * into the global thrown set (read by every catch binding). Returns collapse(x) as before
+ * (the unknown-call result), so nothing on the resolved path regresses. */
+export declare function handlePromiseReject(ev: Evaluator, node: ts.CallExpression, ctx: EvalContext): AbstractValue;
+/** `Promise.reject` on the global Promise (textual match, mirroring {@link isJsonStringify}). */
+export declare function isPromiseReject(access: ts.PropertyAccessExpression): boolean;
+/**
+ * Apply a script-local constructor `id` for a `new C(args)` (or a `super(args)` in a
+ * derived ctor): record the actuals as the constructor's parameter placeholders and
+ * write parameter mutations back into place actuals, exactly like an ordinary direct
+ * call. The constructor's OWN body (which writes `this.x = param`) is evaluated in the
+ * function pass, so the shared instance picks up the placeholder there; here we only
+ * seed the actuals. The instance itself is returned by the caller (NewExpression), never
+ * this call's result. A direct `new`/`super` keeps exactness (no clearing).
+ */
+export declare function applyConstructor(ev: Evaluator, id: number, ctx: EvalContext, argVals: AbstractValue[], argPlaces?: (AbstractValue | undefined)[], site?: ts.Node): void;
+/**
+ * Apply an UNRESOLVABLE-heritage constructor (`new D()` where `class D extends mix(Base)`):
+ * the base class is produced by a mixin CALL we cannot resolve statically, so the inherited
+ * constructor is unreachable. Sound over-approximation: the ctor may store any argument in any
+ * field, so smear the collapsed (INEXACT) args into the instance's container-level taint —
+ * surfaced by every field read via smear-on-read — and pessimistically apply function-valued
+ * args (the keystone: the base ctor may invoke them). Never a drop.
+ */
+export declare function applyMixinConstructor(ev: Evaluator, ctx: EvalContext, instance: AbstractValue, argVals: AbstractValue[]): void;
+//# sourceMappingURL=promise-ops.d.ts.map

package/vendor/dynamic-workflow/analysis/promise-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-ops.d.ts","sourceRoot":"","sources":["../../src/analysis/promise-ops.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAuBzD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAevG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAgBlG;AAED;;2EAE2E;AAC3E,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAK3G;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,MAAM,EAAE,EAAE,CAAC,wBAAwB,GAAG,OAAO,CAE5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,SAAS,EACb,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,aAAa,EAAE,EACxB,SAAS,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EACzC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,GACb,IAAI,CAEN;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,aAAa,EAAE,GACvB,IAAI,CAMN"}