@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/vendor/dynamic-workflow/analysis/causality-graph-lanes.js

@@ -0,0 +1,161 @@
+import { KIND_RANK } from "./causality-reduce.js";
+import { holePrefixOf } from "./hole-id.js";
+import { UNKNOWN_LANE, WORKSPACE_LANE, } from "./causality-graph-types.js";
+// causality-graph.ts 顶到 oxlint max-lines 上限（400 行），把成品图上的机械改写与
+// 事实层的小工具（may-set 车道展开 expandMaySetLanes 及其两个常量、dedupeFacts、weakest）拆到
+// 本文件；公开面仍从 causality-graph.ts 导出。本文件不 import `typescript`。
+/**
+ * Upper bound on an expandable may-set. Past it the step keeps its single card: a capped
+ * may-set FALLS BACK rather than truncating, since dropping candidates would assert
+ * something the analysis cannot. The cap keeps the multiplication (k steps, up to k² on a
+ * self-carry) well inside the payload limits of 64 steps / 256 edges.
+ */
+const MAY_SET_LANE_CAP = 4;
+/** Copy id separator: collides with neither `ask#3/2` nor the runtime's `ask#3@7`. */
+const COPY_SEPARATOR = "~";
+/**
+ * The LAST pass: rewrite a may-set step into one copy per candidate lane.
+ *
+ * `(cond ? a : b).ask(p)` is the same program as `cond ? a.ask(p) : b.ask(p)`, and the
+ * analyzer already draws the second form as one `maybe` step per lane. Drawing the first
+ * form as a single card made the picture depend on where the ternary sits, and on a
+ * script whose every ask is a may-set it left candidate lanes with no homed step at all —
+ * which the mermaid emitter culls, erasing an actor from the workflow.
+ *
+ * This runs AFTER ordering and reduction by contract: reduction never sees copies, so
+ * every reduction rule and its corpus behaviour are unchanged and this stays a mechanical
+ * rewrite of the finished graph.
+ */
+export function expandMaySetLanes(graph) {
+    const copiesOf = new Map();
+    for (const step of graph.steps) {
+        const lanes = step.lanes ?? [];
+        if (lanes.length < 2 || lanes.length > MAY_SET_LANE_CAP)
+            continue;
+        // `workspace` cannot occur in a may-set and `unknown` is only ever a lone lane, so
+        // this guard is the invariant written down rather than a case the corpus reaches.
+        if (lanes.some((lane) => lane === WORKSPACE_LANE || lane === UNKNOWN_LANE))
+            continue;
+        copiesOf.set(step.id, lanes.map((lane) => ({
+            ...step,
+            // The ask always runs; each copy may not. Certainty is per-node and the node
+            // changed meaning, so this is the one field overridden rather than inherited.
+            certainty: "maybe",
+            id: `${step.id}${COPY_SEPARATOR}${lane}`,
+            lane,
+            source: step.id,
+        })));
+    }
+    if (copiesOf.size === 0)
+        return graph;
+    // An endpoint stands for either a step's copies, in `lanes` order, or the step itself.
+    // The lane and the certainty ride along: `fifo` matches pairs on the lane, and every
+    // rewritten edge re-derives its certainty from the endpoints it actually connects.
+    const stepById = new Map(graph.steps.map((step) => [step.id, step]));
+    const endpointsOf = (id) => {
+        const copies = copiesOf.get(id);
+        if (copies !== undefined) {
+            return copies.map((copy) => ({ certainty: copy.certainty, id: copy.id, lane: copy.lane }));
+        }
+        const step = stepById.get(id);
+        return [{ certainty: step?.certainty, id, lane: step?.lane }];
+    };
+    const edges = [];
+    for (const edge of graph.edges) {
+        if (!copiesOf.has(edge.from) && !copiesOf.has(edge.to)) {
+            // Untouched pair: the main pass already applied endpoint inheritance to it and
+            // `weakest` is idempotent, so re-deriving here would be a no-op.
+            edges.push(edge);
+            continue;
+        }
+        // A `fifo` edge exists only because two steps MAY share a mailbox, so a copy on lane
+        // M has no mailbox relation to anything on lane L != M and the cross-lane pairs are
+        // garbage ink; if nothing matches, the edge goes. Every other kind fans out fully:
+        // taint cannot tell which candidate produced or consumed a value, and restricting it
+        // would invent precision. A self-`carry` therefore becomes the full k×k product — the
+        // cross pairs AND the per-copy self-loops, since the analysis cannot rule out the same
+        // candidate being selected in consecutive iterations.
+        for (const tail of endpointsOf(edge.from)) {
+            for (const head of endpointsOf(edge.to)) {
+                if (edge.kind === "fifo" && tail.lane !== head.lane)
+                    continue;
+                edges.push({
+                    ...edge,
+                    // Endpoint inheritance, re-applied to the copies rather than a special case: a
+                    // copy is `maybe`, so every edge incident to one weakens. This is what keeps
+                    // refactoring invariance honest — the branch form `cond ? a.ask(p) : b.ask(p)`
+                    // already yields `maybe` steps and `maybe` edges into them, and the expanded
+                    // ternary must agree or the two identical programs draw different certainty.
+                    certainty: weakest([
+                        edge.certainty,
+                        tail.certainty ?? edge.certainty,
+                        head.certainty ?? edge.certainty,
+                    ]),
+                    from: tail.id,
+                    to: head.id,
+                });
+            }
+        }
+    }
+    const steps = graph.steps.flatMap((step) => copiesOf.get(step.id) ?? [step]);
+    const sink = graph.sink;
+    return {
+        edges,
+        lanes: graph.lanes,
+        regions: graph.regions,
+        steps,
+        ...(sink === undefined
+            ? {}
+            : { sink: { fedBy: sink.fedBy.flatMap((id) => endpointsOf(id).map((end) => end.id)) } }),
+    };
+}
+/** Collapse facts to one edge per ordered pair, keeping the strongest claim. */
+export function dedupeFacts(facts) {
+    const byPair = new Map();
+    for (const fact of facts) {
+        const key = `${fact.from}|${fact.to}`;
+        const existing = byPair.get(key);
+        if (existing === undefined) {
+            // The phase set is cloned, not aliased: the merge below mutates it in place and the
+            // input facts must stay untouched.
+            byPair.set(key, {
+                ...fact,
+                ...(fact.toPhases === undefined ? {} : { toPhases: new Set(fact.toPhases) }),
+            });
+            continue;
+        }
+        if (KIND_RANK[fact.kind] > KIND_RANK[existing.kind])
+            existing.kind = fact.kind;
+        if (fact.exact !== undefined && existing.exact === undefined)
+            existing.exact = fact.exact;
+        else if (fact.exact === true)
+            existing.exact = true;
+        if (fact.certainty === "maybe")
+            existing.certainty = "maybe";
+        // 一条不经跳转就成立的事实让这一对回到普通前向边：全部贡献都只能靠下一轮，才算回边。
+        if (fact.viaJump !== true)
+            delete existing.viaJump;
+        // ABSENT DOMINATES: one contributing fact with no provenance means the merged fact has
+        // none, so it fans out fully. A `data` fact (never provenanced, and fanning out by
+        // contract) merging onto a provenanced `seq` fact must not inherit that narrowing —
+        // the pair is then ordered for reasons the barrier witness does not account for.
+        if (fact.toPhases === undefined)
+            delete existing.toPhases;
+        else if (existing.toPhases !== undefined) {
+            for (const phase of fact.toPhases)
+                existing.toPhases.add(phase);
+        }
+    }
+    return [...byPair.values()];
+}
+export function weakest(values) {
+    return values.includes("maybe") ? "maybe" : "always";
+}
+/**
+ * 写下这个站点的那次补全：站点 id 的 `hole#<hash>/` 前缀（只有一层，hole-id.ts）；体外的站点
+ * 没有。留白自己的 id 不带前缀——它属于哪个留白记在站点表的 `fill` 上，调用方自己查
+ * （docs/analysis.md「Sites」）。
+ */
+export function fillOf(siteId) {
+    return holePrefixOf(siteId);
+}

package/vendor/dynamic-workflow/analysis/causality-graph-types.d.ts

@@ -0,0 +1,163 @@
+import type { RegionKind } from "./constants.js";
+import type { OrderKind } from "./causality-reduce.js";
+import type { SiteLoc, NamePattern } from "./types.js";
+/** `hole`: an OPEN `hole<T>()` — the script waits there for the main agent's fill. */
+export type StepKind = "ask" | "world-read" | "hole";
+export type Certainty = "always" | "maybe";
+/** The single lane every `files.*` read runs in. */
+export declare const WORKSPACE_LANE = "workspace";
+/** The main agent's lane: where every open hole waits (docs/analysis.md「Sites」). */
+export declare const MAIN_LANE = "main";
+/** Lane of an ask whose receiver the analysis could not resolve to any actor site. */
+export declare const UNKNOWN_LANE = "unknown";
+/** The terminal marker: the artifact the script returns. */
+export declare const SINK_ID = "sink";
+export interface Step {
+    /** A site id (`ask#3`, `world-read#1`); it is also the runtime instance's key. */
+    id: string;
+    kind: StepKind;
+    label: string;
+    /** `label` 只拿到兜底串时，内联 `agent()` receiver 的模板形状。 */
+    labelPattern?: NamePattern;
+    loc: SiteLoc;
+    /** Actor site id, or `workspace` / `unknown`. For an unexpanded may-set, `lanes[0]`. */
+    lane: string;
+    /** Present only when the ask receiver is dynamically selected: the candidate lanes. */
+    lanes?: string[];
+    /**
+     * The step this one was expanded from, emitted only on a may-set copy (see
+     * `expandMaySetLanes` in causality-graph-lanes.ts). It is the site id a runtime instance
+     * actually reports, which is what makes it the live overlay's join key (`source ?? id`
+     * against `node.siteId`, narrowed by `node.actorSiteId === lane`).
+     *
+     * This composes with future per-callsite specialization rather than competing with it. Once
+     * specialization lands, the expanded-from id IS the specialized site id —
+     * `ask#3/2~actor#1` carries source `ask#3/2` — so the join stays stable under both
+     * features. On a copy the field means "the site the runtime reports", NOT "the site
+     * before specialization".
+     */
+    source?: string;
+    /** Innermost enclosing region id. */
+    region: string;
+    certainty: Certainty;
+    /**
+     * The author-declared phase this step belongs to (`phase#2`, or the reserved
+     * `unphased`). Present only when the script declares at least one `phase()` marker, in
+     * which case EVERY step carries one — a step claimed by k>1 phases is expanded into k
+     * copies to keep the partition total (see phase-graph.ts).
+     */
+    phase?: string;
+    /**
+     * How this step's instances relate when an enclosing region repeats:
+     *   `stack`  — they coexist, which is the one multiplicity cue (stacked cards);
+     *   `serial` — they follow one another, already visible as the cycle-closing arrow.
+     * Absent when the step runs at most once. Finding: the cue splits on
+     * CONCURRENCY, not cardinality — a step is `serial` exactly when a barrier inside
+     * the repeating region settles it, or when a fixed actor's mailbox serializes it.
+     */
+    repeat?: "stack" | "serial";
+    /**
+     * The filled hole whose body wrote this step: the `hole#<hash>/` prefix of its site id, or,
+     * for an open hole (whose id is a bare name key), the site table's `fill`. Absent outside
+     * every fill.
+     */
+    fill?: string;
+}
+export interface Region {
+    id: string;
+    kind: RegionKind;
+    parent?: string;
+    loc?: SiteLoc;
+    /** Derivable literal round count of a `for`; model-only, never displayed. */
+    bound?: number;
+    label?: string;
+}
+export interface OrderEdge {
+    from: string;
+    to: string;
+    kind: OrderKind;
+    certainty: Certainty;
+    /** `data` edges only: the taint witness path's exactness bit. Model-only. */
+    exact?: boolean;
+}
+export interface Lane {
+    id: string;
+    /** The author's verbatim word, when `agent()` was given a literal. Never a reconstruction. */
+    name?: string;
+    /**
+     * `name` 缺席而 `agent()` 首参是带洞的模板串时，那个名字的静态形状。省略号在渲染时才加。
+     */
+    namePattern?: NamePattern;
+    loc?: SiteLoc;
+    /**
+     * Enclosing iteration regions of the `agent()` call, outermost first. A non-empty
+     * list makes the lane a family — one fresh actor per element — and nested iterations
+     * MULTIPLY, so multiplicity is the product and a single id cannot express it.
+     */
+    families?: string[];
+}
+/**
+ * An author-declared phase: a name for a group of steps, and the position of the marker
+ * that opened it. The synthetic fallback `unphased` carries neither — the UI shows a
+ * localized word for it, exactly as it does for the `workspace` / `unknown` lanes.
+ */
+export interface Phase {
+    id: string;
+    name?: string;
+    loc?: SiteLoc;
+    /** The filled hole whose body wrote this phase (a filled hole's own phase names itself). */
+    fill?: string;
+}
+export interface CausalityGraph {
+    steps: Step[];
+    regions: Region[];
+    lanes: Lane[];
+    edges: OrderEdge[];
+    /** Step ids whose artifacts reach the script's return; absent when it returns nothing. */
+    sink?: {
+        fedBy: string[];
+    };
+    /**
+     * The phase vocabulary, present TOGETHER WITH `phaseEdges` and `Step.phase` or not at
+     * all: a script with no `phase()` markers gets none of the three and its graph is
+     * byte-identical to what it was before the feature. `unphased` first when it has
+     * members, then the author's phases in first-reach order.
+     */
+    phases?: Phase[];
+    /** The quotient of `edges` by the phase partition. Never carries `exact`. */
+    phaseEdges?: OrderEdge[];
+}
+/** 投影内部的有序事实（去重、回边定型、归约的输入）；不在包的公开面上。 */
+export interface Fact {
+    from: string;
+    to: string;
+    kind: OrderKind;
+    certainty: Certainty;
+    exact?: boolean;
+    /** carry 边的底层 kind（改型前的前向 kind）；carry 最小化按它判见证强度。 */
+    carryOf?: Exclude<OrderKind, "carry">;
+    /**
+     * 见证这条事实的 issue 事件所在的阶段集（**只有 await 屏障产生的 seq 事实**带它）。
+     * 阶段拷贝按它收窄边的头端：屏障事实是在某一次具体 issue 上被见证的，而当前「一站点一步」
+     * 的设计把同一站点在不同调用点的多次 issue 合成了一个 step，丢掉这个来源就会
+     * 把「gate 的 bench 发出前 cargo test 已 settle」当成 preflight 的 bench 也成立——
+     * 一条方向错误的时间断言（多序是被许可的，错序不是）。
+     *
+     * 缺席 = 无来源信息 = 头端全展开（data/control/fifo 与区域重复事实按契约全展开）。
+     *
+     * 尾端没有对称的来源信息（settle 事件不带阶段），但**尾侧不再是缺口**：阶段拷贝的时间
+     * 可行性判定（phase-graph.ts 的 `admits`）按位置对**两端**一视同仁地拦截，所以「拷贝排
+     * 在产出它自己实参的那个 step 之前」这类伪边由那条规则消掉，不靠这里的来源信息。
+     */
+    toPhases?: Set<string>;
+    /**
+     * 这条 `seq` 事实只能靠**下一轮**成立：`from` 在一个以 `continue` 结束的分支臂里发出，
+     * `to` 在同一个循环体里更靠后的位置。线性的时间走查按 may 语义会继续走完循环体，于是
+     * 把「fixer@k 先于 juries@k+1」记成了同一轮的前向顺序；控制流投影对同一处给的是
+     * `loop via=continue`。带此标记的事实在回边定型时按 carry 处理（配对里全部事实都带才算，
+     * 见 `dedupeFacts`，causality-graph-lanes.ts）。以 `break` 结束的臂更强：其中的 step 根本
+     * 不可能先于同一循环里后面的 step，那样的事实直接不发。
+     */
+    viaJump?: true;
+}
+//# sourceMappingURL=causality-graph-types.d.ts.map

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

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

package/vendor/dynamic-workflow/analysis/causality-graph-types.js

@@ -0,0 +1,8 @@
+/** The single lane every `files.*` read runs in. */
+export const WORKSPACE_LANE = "workspace";
+/** The main agent's lane: where every open hole waits (docs/analysis.md「Sites」). */
+export const MAIN_LANE = "main";
+/** Lane of an ask whose receiver the analysis could not resolve to any actor site. */
+export const UNKNOWN_LANE = "unknown";
+/** The terminal marker: the artifact the script returns. */
+export const SINK_ID = "sink";

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

@@ -0,0 +1,39 @@
+import type { AnalysisCore } from "./core.js";
+import { type RegionKind } from "./constants.js";
+import { type OrderKind } from "./causality-reduce.js";
+import type { SiteGraph } from "./types.js";
+import type { CausalityGraph } from "./causality-graph-types.js";
+/** Re-exported so the causality vocabulary is importable from one module. */
+export type { NamePattern } from "./types.js";
+export { MAIN_LANE, SINK_ID, UNKNOWN_LANE, WORKSPACE_LANE } from "./causality-graph-types.js";
+export type { CausalityGraph, Certainty, Lane, OrderEdge } from "./causality-graph-types.js";
+export type { Phase, Region, Step, StepKind } from "./causality-graph-types.js";
+/**
+ * The causality graph: a partial order over workflow STEPS, with actors as lanes and
+ * `happens-before` as its edges. This is the presentation-level view the GUI draws.
+ * The graph uses these rules:
+ *
+ *   - a **step** is one facade operation that takes time (an `ask`, a `files.*` read);
+ *   - an **actor** is an attribute of a step (a lane), never a node — any quotient by
+ *     actor destroys the order this graph exists to show;
+ *   - an **edge** means "runs after", and records WHY internally (`data` / `control` /
+ *     `fifo` / `seq` / `carry`) while rendering as one indistinguishable arrow;
+ *   - **regions** (`loop` / `fanout` / `branch`) are internal: they drive reduction and
+ *     the multiplicity cues, and none of them draws a container.
+ *
+ * The taint analysis and the temporal walk both ran inside the fused interpreter
+ * (interpret.ts); this module is a PURE projection of the {@link AnalysisCore} they
+ * produced, plus the projected site graph: the core's sites give the steps, the site
+ * graph's `data` edges answer "does B's argument carry A's output?", and the core's
+ * `trace` supplies everything temporal. No `typescript` import, no AST.
+ *
+ * Phase 1 scope: one step per ask/world-read site —
+ * per-call-site specialization (`ask#3/2`) lands with the execution engine in phase 3, so
+ * `Step.callPath` is not emitted yet. Await resolution is syntactic, with full-barrier widening as the fallback. The one exception to one-step-per-site is
+ * {@link expandMaySetLanes}, the final pass: a dynamically-selected receiver becomes one
+ * copy per candidate lane, and `Step.source` names the site they came from.
+ */
+export type { OrderKind, RegionKind };
+/** Project the causality graph off the core plus the (projected) site graph. */
+export declare function projectCausalityGraph(core: AnalysisCore, site: SiteGraph): CausalityGraph;
+//# sourceMappingURL=causality-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causality-graph.d.ts","sourceRoot":"","sources":["../../src/analysis/causality-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAA0B,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAMvE,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,YAAY,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAyB,MAAM,4BAA4B,CAAC;AAIxF,6EAA6E;AAC7E,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC9F,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC7F,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEtC,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,cAAc,CAogBzF"}