@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

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

@@ -0,0 +1,63 @@
+import type { CompileDiagnostic } from "../compiler/compile.js";
+import { type DeclaredArtifact } from "./artifacts.js";
+import { type ModelReference } from "./actor-models.js";
+import { type CausalityGraph } from "./causality-graph.js";
+import { type ControlFlowGraph } from "./flow-graph.js";
+import { type HandoffGraph } from "./handoff-graph.js";
+import type { AnalysisCore } from "./core.js";
+import type { SiteGraph } from "./types.js";
+/**
+ * Result of analyzing a workflow script: the same diagnostics `compileWorkflowScript`
+ * produces, plus the analysis core and its two projected views.
+ *
+ * `ok` means "submittable": any diagnostic clears it. The core and the graphs are present
+ * whenever the script was analyzable at all, which is *almost* the same thing — the one
+ * diagnostic that leaves them in place is {@link FANOUT_ACTOR_NAME_CODE} (a static actor
+ * name inside a fan-out). That clause describes a **run-time** failure, not something that
+ * stops the analysis: the shape is perfectly analyzable, and withholding the graph would
+ * hide the picture exactly when the author needs it to see which fan-out to fix. So:
+ * graphs present ⟸ ok, but not the converse.
+ */
+export interface AnalyzeResult {
+    diagnostics: CompileDiagnostic[];
+    ok: boolean;
+    /**
+     * The all-in-one analysis artifact: taint
+     * facts + temporal trace, position-free. `graph` and `causality` are pure projections
+     * of it — deriving them again later needs the core only, never the script.
+     */
+    core?: AnalysisCore;
+    graph?: SiteGraph;
+    /** The presentation-level happens-before view. */
+    causality?: CausalityGraph;
+    /** Where execution can go next, per occurrence and per phase. */
+    flow?: ControlFlowGraph;
+    /** Who takes part in each phase and who hands off to whom. */
+    handoff?: HandoffGraph;
+    /**
+     * 脚本声明的**用户面产物**：`[{id, kind}]`，去重、按 id
+     * 排序。与 world.run 的命令集同族的编译产物——运行前就能说出这个工作流会产出什么。
+     * 与图不同，它在诊断非空时**照常给出**（它是从站点表直接读的事实，不依赖解释）。
+     */
+    declaredArtifacts: DeclaredArtifact[];
+    /**
+     * 脚本能交给子代理的每个模型名，每处出现一条（docs/dynamic-workflow/authoring.md「Choosing a
+     * model per subagent」）。launch 工具在确认窗之前把它们对着宿主的模型目录解析
+     * （docs/dynamic-workflow/launch.md「Models the script names」）。与 `declaredArtifacts` 同规：
+     * 编译不过时是空数组，authoring 诊断在场时照常给出。
+     */
+    modelReferences: ModelReference[];
+}
+/**
+ * Typecheck a workflow script and, when clean, interpret it. The pipeline is
+ * createWorkflowProgram -> collectSites (the site-table substrate) -> interpret (the
+ * fused taint-fixpoint + temporal walk, minting the {@link AnalysisCore}) ->
+ * projectSiteGraph / projectCausalityGraph (pure projections of the core).
+ *
+ * Between the site table and the interpretation runs the facade-siting check
+ * ({@link collectFacadeMisuse}): a facade callable that escapes into value space has
+ * no site, so the graph cannot represent it. Its diagnostics are surfaced exactly like
+ * typechecker diagnostics — `ok: false`, graphs withheld.
+ */
+export declare function analyzeWorkflowScript(scriptText: string): AnalyzeResult;
+//# sourceMappingURL=analyze.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/analysis/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIhE,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIpF,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG5E,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,EAAE,EAAE,OAAO,CAAC;IACZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,kDAAkD;IAClD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,iEAAiE;IACjE,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;;OAIG;IACH,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC;;;;;OAKG;IACH,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,CAqEvE"}

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

@@ -0,0 +1,92 @@
+import { collectDiagnostics, createWorkflowProgram } from "../compiler/compile.js";
+import { collectSites } from "./sites.js";
+import { collectFacadeMisuse } from "./facade-misuse.js";
+import { collectWorldRunCommands } from "./world-run.js";
+import { collectArtifactDeclarations } from "./artifacts.js";
+import { collectPhaseMarkerDiagnostics } from "./phases.js";
+import { collectHoleDiagnostics } from "./hole-sites.js";
+import { collectDuplicateActorNames, FANOUT_ACTOR_NAME_CODE } from "./actor-names.js";
+import { collectActorModels } from "./actor-models.js";
+import { interpret } from "./interpret.js";
+import { projectSiteGraph } from "./graph.js";
+import { projectCausalityGraph } from "./causality-graph.js";
+import { projectControlFlow } from "./flow-graph.js";
+import { projectHandoffGraph } from "./handoff-graph.js";
+/**
+ * Typecheck a workflow script and, when clean, interpret it. The pipeline is
+ * createWorkflowProgram -> collectSites (the site-table substrate) -> interpret (the
+ * fused taint-fixpoint + temporal walk, minting the {@link AnalysisCore}) ->
+ * projectSiteGraph / projectCausalityGraph (pure projections of the core).
+ *
+ * Between the site table and the interpretation runs the facade-siting check
+ * ({@link collectFacadeMisuse}): a facade callable that escapes into value space has
+ * no site, so the graph cannot represent it. Its diagnostics are surfaced exactly like
+ * typechecker diagnostics — `ok: false`, graphs withheld.
+ */
+export function analyzeWorkflowScript(scriptText) {
+    const workflow = createWorkflowProgram(scriptText);
+    const diagnostics = collectDiagnostics(workflow.program);
+    // 编译不过 / facade 逃逸时连站点表都不可信，产物清单只能是空的（缺省而不是缺席：读者
+    // 拿到的永远是一个数组，不必在每个消费点分辨"没有产物"与"没能分析"）。
+    if (diagnostics.length > 0) {
+        return { declaredArtifacts: [], diagnostics, modelReferences: [], ok: false };
+    }
+    const table = collectSites(workflow);
+    const misuse = collectFacadeMisuse(workflow, table);
+    if (misuse.length > 0) {
+        return { declaredArtifacts: [], diagnostics: misuse, modelReferences: [], ok: false };
+    }
+    // world.run 的字面量 cmd 检查与 misuse 同席：一个运行期才成形的命令没有可展示的授权
+    // 对象（确认窗展示的命令集在编译期闭合），所以它和「facade 调用必须有站点」一样是
+    // 编译期教改写的那类错误。phase 标记同理：非字面量
+    // 名字与非语句位置的标记都没有可指的东西。
+    // 字面量 actor 重名同席：规则的正门在运行期（引擎 createActor 的 DuplicateActorName），
+    // 这一趟只是把字面量能看穿的那部分提前到便宜的一侧。
+    // 三趟一起报——作者一次就能看全要改什么。
+    const worldRun = collectWorldRunCommands(workflow, table);
+    // 产物的编译期规则同席：id 是编译期字面量、标签指向一个
+    // 已声明的预置、同 id 不横跨两种成员——三条都是「运行期才炸不如现在就教改写」的那一类。
+    const artifacts = collectArtifactDeclarations(workflow, table);
+    // 子代理模型名集合的封闭性（9010）同席：一个运行期才成形的模型名没有可在确认窗之前解析、
+    // 展示的对象（docs/dynamic-workflow/authoring.md「Choosing a model per subagent」）。
+    const models = collectActorModels(workflow, table);
+    const authoring = [
+        ...worldRun.diagnostics,
+        ...artifacts.diagnostics,
+        ...models.diagnostics,
+        ...collectPhaseMarkerDiagnostics(workflow, table),
+        // 留白的编译期规则（9012）同席（docs/dynamic-workflow/authoring.md「Holes」）。
+        ...collectHoleDiagnostics(workflow, table),
+        ...collectDuplicateActorNames(workflow, table),
+    ];
+    // fan-out 里的静态 actor 名（9006）是这批里唯一**不扣下图**的一条：它说的是这个脚本跑起来
+    // 会撞 DuplicateActorName，而不是「这段代码没法分析」——形状本身完全可分析，把图扣下来只会
+    // 在作者最需要看图定位是哪个 fan-out 的时候把图拿走。它照常清掉 `ok`（提交仍被挡住）。
+    // 顺带的好处：分析语料因此还能钉住「fan-out 里的静态名」这个形状的图产物，否则一条挡路的
+    // 编译期诊断会让它自己的形状在语料里变得不可表达。
+    const withholding = authoring.filter((d) => d.code !== FANOUT_ACTOR_NAME_CODE);
+    if (withholding.length > 0) {
+        return {
+            declaredArtifacts: artifacts.declaredArtifacts,
+            diagnostics: authoring,
+            modelReferences: models.references,
+            ok: false,
+        };
+    }
+    // One interpretation feeds everything: the core carries the taint facts AND the
+    // temporal trace, and both graphs project off it without touching the AST again.
+    const core = interpret(workflow, table);
+    const graph = projectSiteGraph(core);
+    const causality = projectCausalityGraph(core, graph);
+    return {
+        causality,
+        core,
+        declaredArtifacts: artifacts.declaredArtifacts,
+        diagnostics: authoring,
+        flow: projectControlFlow(core),
+        graph,
+        handoff: projectHandoffGraph(core, causality, graph),
+        modelReferences: models.references,
+        ok: authoring.length === 0,
+    };
+}

package/vendor/dynamic-workflow/analysis/array-methods.d.ts

@@ -0,0 +1,21 @@
+import ts from "typescript";
+import type { IterationCandidate } from "./sites.js";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+/**
+ * Per-element callback calls (the callback registry's `each` entries — `map` / `forEach` /
+ * `reduce` / … on a receiver, `Array.from(xs, fn)`) promoted to fan-out relays: `iterated`
+ * fans out to the callback's element parameter(s), the callback body runs in a
+ * `cand@<order>` region, and its return joins back. `evalCall` dispatches here via
+ * `candByCall`.
+ *
+ * Two callback shapes, one contract:
+ *  - an INLINE literal is evaluated in place with its parameters bound directly (it is not a
+ *    tracked function — the callback IS the body);
+ *  - any other expression (`xs.map(review)`, `xs.map(this.f)`) is evaluated to its function
+ *    values and those tracked functions are applied with registry-shaped positional actuals,
+ *    recorded as `argument` applications at the call so the ordering walk inlines the same
+ *    bodies inside the same `fanout` region.
+ */
+export declare function handleArrayMethod(ev: Evaluator, node: ts.CallExpression, cand: IterationCandidate, ctx: EvalContext): AbstractValue;
+//# sourceMappingURL=array-methods.d.ts.map

package/vendor/dynamic-workflow/analysis/array-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-methods.d.ts","sourceRoot":"","sources":["../../src/analysis/array-methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,SAAS,EACb,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,WAAW,GACf,aAAa,CAkGf"}

package/vendor/dynamic-workflow/analysis/array-methods.js

@@ -0,0 +1,132 @@
+import ts from "typescript";
+import { addOcc, cloneValue, collapse, emptyValue, mergeInto, provisionalFanoutId, unionValues, } from "./domain.js";
+import { applyCallbackFns } from "./calls.js";
+/**
+ * Per-element callback calls (the callback registry's `each` entries — `map` / `forEach` /
+ * `reduce` / … on a receiver, `Array.from(xs, fn)`) promoted to fan-out relays: `iterated`
+ * fans out to the callback's element parameter(s), the callback body runs in a
+ * `cand@<order>` region, and its return joins back. `evalCall` dispatches here via
+ * `candByCall`.
+ *
+ * Two callback shapes, one contract:
+ *  - an INLINE literal is evaluated in place with its parameters bound directly (it is not a
+ *    tracked function — the callback IS the body);
+ *  - any other expression (`xs.map(review)`, `xs.map(this.f)`) is evaluated to its function
+ *    values and those tracked functions are applied with registry-shaped positional actuals,
+ *    recorded as `argument` applications at the call so the ordering walk inlines the same
+ *    bodies inside the same `fanout` region.
+ */
+export function handleArrayMethod(ev, node, cand, ctx) {
+    const semantics = cand.semantics;
+    const iterated = collapse(ev.evalExpr(cand.iterated, ctx));
+    const fanoutId = provisionalFanoutId(cand.order);
+    const promoted = ev.s.promotedOrders.has(cand.order);
+    if (promoted)
+        ev.s.mergeSink(ev.s.fanoutInVal, fanoutId, iterated);
+    const element = cloneValue(iterated);
+    if (promoted)
+        addOcc(element, { exact: true, site: fanoutId });
+    const regionStack = [...ctx.regionStack, `cand@${cand.order}`];
+    const isReduce = semantics?.accumulatorParam !== undefined;
+    const elementParams = semantics?.elementParams ?? [0];
+    const wholeParams = semantics?.wholeParams ?? [2];
+    // The accumulator (reduce): initial-value argument ∪ the callback return chained across
+    // fixpoint passes. The callback return is a FRESH local each fixpoint pass and is
+    // empty when we bind the param, so binding acc from it directly never carries the callback's
+    // return taint — sequential ask-chaining through the accumulator would be silently dropped. A
+    // persistent per-candidate accumulator (seeded from prior passes' returns) lets the
+    // accumulator's taint reach the body and converge like everything else.
+    // With NO initial-value argument the accumulator starts as element 0 at runtime, so
+    // the seed is the element value (not empty) — otherwise the first element's taint never
+    // reaches the body through the accumulator.
+    const seedArg = node.arguments[1];
+    const accumulator = () => {
+        const chain = ev.s.reduceAccOf(cand.order);
+        const seedPlace = seedArg === undefined ? undefined : ev.resolvePlace(seedArg);
+        if (seedPlace !== undefined) {
+            // The initial value is a PLACE: at runtime the accumulator IS that object until the
+            // callback returns something else (`acc.items.push(item)` fills the seed), so alias acc
+            // to the live seed. JOIN the cross-pass callback-return chain into it — never replace:
+            // for a reduce that returns a FRESH object each iteration, losing the chain component
+            // would drop the accumulator's carried taint. Spurious later writes into the seed are a
+            // sound over-approximation — a cloned seed would instead keep
+            // `acc.items.push` from reaching the live seed.
+            if (mergeInto(seedPlace, chain))
+                ev.s.changed = true;
+            return { place: seedPlace, value: seedPlace };
+        }
+        const initial = seedArg === undefined ? element : ev.evalExpr(seedArg, ctx);
+        return { value: unionValues(initial, chain) };
+    };
+    const callbackReturn = emptyValue();
+    const cb = cand.callback;
+    if (cb !== undefined) {
+        const cbCtx = {
+            onReturn: (value) => void mergeInto(callbackReturn, value),
+            regionStack,
+        };
+        if (isReduce)
+            bindCallbackParam(ev, cb, semantics?.accumulatorParam ?? 0, accumulator().value, cbCtx);
+        // Element parameters bind the fanned-out element; the standard whole-collection parameter
+        // (the third of `map`-likes) IS the receiver at runtime, so it binds the same fanned-out
+        // value: reads of it inside the promoted callback are downstream of the fan-out, same as
+        // element reads. A positional index parameter stays unbound — it carries no element data
+        // (same convention as a ternary condition / computed key), so it originates no data edge.
+        elementParams.forEach((index, i) => bindCallbackParam(ev, cb, index, i === 0 ? element : cloneValue(element), cbCtx));
+        for (const index of wholeParams)
+            bindCallbackParam(ev, cb, index, cloneValue(element), cbCtx);
+        if (ts.isBlock(cb.body)) {
+            for (const stmt of cb.body.statements)
+                ev.visit(stmt, cbCtx);
+        }
+        else {
+            mergeInto(callbackReturn, ev.evalExpr(cb.body, cbCtx));
+        }
+    }
+    else if (cand.callbackExpr !== undefined) {
+        // Non-literal callback: apply every script function the argument holds, per element, with
+        // the registry's positional shape. An untracked value (`xs.map(Boolean)`) applies nothing;
+        // the element still flows to the result as it did before.
+        const fns = [...ev.evalExpr(cand.callbackExpr, ctx).fns].filter((fn) => ev.s.fnId.has(fn));
+        if (fns.length > 0) {
+            const slots = Math.max(-1, ...elementParams, ...wholeParams, semantics?.accumulatorParam ?? -1) + 1;
+            const actuals = Array.from({ length: slots }, () => emptyValue());
+            if (isReduce)
+                actuals[semantics?.accumulatorParam ?? 0] = accumulator().value;
+            for (const index of elementParams)
+                actuals[index] = cloneValue(element);
+            for (const index of wholeParams)
+                actuals[index] = cloneValue(element);
+            mergeInto(callbackReturn, applyCallbackFns(ev, fns, actuals, regionStack, node));
+        }
+    }
+    // Element-mutation write-back: the element parameter may-aliases the collection's elements
+    // (they are references at runtime), so a field written through it (`x.note = t`) must reach
+    // the collection. Weak-merge the element's FIELD effects (collapsed) into the collection
+    // place's occs — a later `xs[k].note` read smears them out. Only element FIELDS propagate:
+    // the element's seed occs and fan-out label live in `occs`, so they never flow back (no
+    // fan-out self-label).
+    const collectionPlace = ev.resolvePlace(cand.iterated);
+    if (collectionPlace !== undefined) {
+        for (const field of element.fields.values()) {
+            if (mergeInto(collectionPlace, collapse(field)))
+                ev.s.changed = true;
+        }
+    }
+    // Thread this pass's callback return into the persistent accumulator so the next
+    // pass's accumulator param observes it (drives the reduce chain to a fixpoint).
+    if (isReduce)
+        ev.s.mergeReduceAcc(cand.order, callbackReturn);
+    // Result: callback return ∪ element value (the fan-out label already rides on element).
+    return unionValues(callbackReturn, element);
+}
+function bindCallbackParam(ev, cb, index, value, ctx) {
+    const param = cb.parameters[index];
+    if (param === undefined)
+        return;
+    // Route through the Evaluator's pattern machinery so a binding-pattern parameter
+    // (`.map(({ q }) => …)`, `.then(([x, y]) => …)`) binds its extracted names. The
+    // old identifier-only guard silently bound nothing for a destructured param, dropping
+    // both the element's taint and the fan-out label into every read of the pattern's names.
+    ev.bindPattern(param.name, value, ctx);
+}

package/vendor/dynamic-workflow/analysis/artifact-types.d.ts

@@ -0,0 +1,39 @@
+import type { WorkflowProgram } from "../compiler/compile.js";
+import type { SiteTable } from "./sites.js";
+/**
+ * Producer-side artifact types for data edges. Every data edge's `from` is a producer
+ * site (ask / world-read / join / fan-out) with a statically known artifact type; this
+ * module computes that type as a human-readable string, plus per-port types for joins
+ * over a static array literal. Semantics is PROVENANCE: an edge means "a value computed
+ * from A's output feeds B", so the label is A's artifact type — not a claim about the
+ * concrete wire value.
+ *
+ * The type names come from the live checker's {@link ts.TypeChecker.typeToString} today;
+ * schema synthesis will later upgrade these to synthesized-schema names.
+ * Uninformative labels (`any`/`unknown`/`never`/`void`) are omitted so a meaningless
+ * string is never drawn.
+ */
+/** Per-site artifact types and per-port join element types. */
+export interface ArtifactTypes {
+    /**
+     * Whole-value artifact type per site, keyed by site id. Ask/world-read/join sites use
+     * their final ids (`ask#1`); fan-out candidates are keyed by their PROVISIONAL id
+     * (`fan-out@order`, see {@link provisionalFanoutId}) — the same key the taint pass
+     * stamps into occurrences, so graph assembly looks them up before the `fan-out#N`
+     * rename.
+     */
+    siteType: Map<string, string>;
+    /**
+     * Per-element awaited types of a join over a static array literal, keyed by join id.
+     * Index i is the type of array element i (the join input at port i), or `undefined`
+     * when that element's type is unknowable/uninformative. Absent for joins whose
+     * argument is not a static array literal (no ports exist).
+     */
+    joinPortTypes: Map<string, (string | undefined)[]>;
+}
+/**
+ * Compute artifact types for every producer site in the table. Pure over the checker and
+ * the AST refs the site table already resolved.
+ */
+export declare function computeArtifactTypes(workflow: WorkflowProgram, table: SiteTable): ArtifactTypes;
+//# sourceMappingURL=artifact-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-types.d.ts","sourceRoot":"","sources":["../../src/analysis/artifact-types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;;;;;;;;;GAYG;AAEH,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CACpD;AAeD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,GAAG,aAAa,CAoG/F"}

package/vendor/dynamic-workflow/analysis/artifact-types.js

@@ -0,0 +1,114 @@
+import ts from "typescript";
+import { provisionalFanoutId } from "./domain.js";
+/** typeToString flags: a named interface prints as its name (`Flaky`), no `…` truncation. */
+const FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation;
+/** Rendered type names that carry no information and must not be drawn as a label. */
+const UNINFORMATIVE = new Set(["any", "unknown", "never", "void"]);
+/**
+ * Cap on fan-out array-level unwrapping. Nested maps (`map` of `map`) nest arrays
+ * arbitrarily; a fixed bound keeps the peel finite against pathological/cyclic generic
+ * types, matching the taint domain's `VALUE_DEPTH_CAP` discipline.
+ */
+const FANOUT_UNWRAP_CAP = 8;
+/**
+ * Compute artifact types for every producer site in the table. Pure over the checker and
+ * the AST refs the site table already resolved.
+ */
+export function computeArtifactTypes(workflow, table) {
+    const checker = workflow.program.getTypeChecker();
+    const siteType = new Map();
+    const joinPortTypes = new Map();
+    const renderRaw = (type) => checker.typeToString(type, undefined, FORMAT_FLAGS);
+    const render = (type) => {
+        if (type === undefined)
+            return undefined;
+        const text = renderRaw(type);
+        return UNINFORMATIVE.has(text) ? undefined : text;
+    };
+    const set = (id, type) => {
+        const text = render(type);
+        if (text !== undefined)
+            siteType.set(id, text);
+    };
+    // The awaited (resolved) type of a call's own type — `Node<T>`/`Promise<T>` -> `T`.
+    const awaitedOf = (node) => checker.getAwaitedType(checker.getTypeAtLocation(node));
+    // The element type of a genuine `Array<T>`/`ReadonlyArray<T>`, else undefined. We test
+    // the reference target's symbol rather than `getNumberIndexType`, because a `string`
+    // (and a string-literal union) is number-indexable too — indexing one would wrongly
+    // "peel" `("yes" | "no")[]` into `string[][]`.
+    const arrayElement = (type) => {
+        const name = type.target?.symbol?.name;
+        if (name !== "Array" && name !== "ReadonlyArray")
+            return undefined;
+        const args = checker.getTypeArguments(type);
+        return args.length > 0 ? args[0] : undefined;
+    };
+    // A fan-out's collected artifact type. The awaited whole call type of a `.map` is the
+    // mapped array (`Node<Review>[]`, or `Node<string>[][]` for nested maps); that leaks the
+    // facade promise wrapper into a user-facing label, so we peel array levels to a fixed
+    // point — awaiting the element at each level (`Node<Review>` -> `Review`) — and rebuild
+    // the `[]` suffixes, so `Node<Review>[]` -> `Review[]` and `Node<string>[][]` ->
+    // `string[][]`. A top-level union/intersection innermost element is parenthesized
+    // (`(A | B)[]`) to stay well-formed. Falls back to the whole-type rendering when the
+    // type is not array-like or the peeled element is uninformative. Joins need no such
+    // unwrap: `Promise.all`'s `Awaited<>` already resolves recursively.
+    const fanoutType = (call) => {
+        const whole = awaitedOf(call);
+        if (whole === undefined)
+            return undefined;
+        const wholeText = render(whole);
+        let type = whole;
+        let depth = 0;
+        while (depth < FANOUT_UNWRAP_CAP) {
+            const element = arrayElement(type);
+            if (element === undefined)
+                break;
+            type = checker.getAwaitedType(element) ?? element;
+            depth += 1;
+        }
+        if (depth === 0)
+            return wholeText; // not array-like: keep the whole rendering
+        const elementText = render(type);
+        if (elementText === undefined)
+            return wholeText; // uninformative element: fall back
+        const base = /\s[|&]\s/.test(elementText) ? `(${elementText})` : elementText;
+        return `${base}${"[]".repeat(depth)}`;
+    };
+    // ask: an explicit `ask<Flaky>` type argument is the artifact type directly; otherwise
+    // the awaited return type (`Node<T>` -> `T`, default `T = string`).
+    for (const site of table.asks) {
+        const typeArg = site.call.typeArguments?.[0];
+        const type = typeArg !== undefined ? checker.getTypeFromTypeNode(typeArg) : awaitedOf(site.call);
+        set(site.id, type);
+    }
+    // world-read: the awaited call type (`string` for read, `string[]` for glob).
+    for (const site of table.worldReads)
+        set(site.id, awaitedOf(site.call));
+    // open hole: the explicit type argument is the contract (9012 requires it); a filled hole is
+    // not a producer site, its body's own sites are.
+    for (const site of table.holes) {
+        if (site.body === undefined && site.typeArg !== undefined) {
+            set(site.id, checker.getTypeFromTypeNode(site.typeArg));
+        }
+    }
+    // join: the awaited whole type (a tuple for a static array literal, an array otherwise),
+    // plus per-element awaited types when the argument is a static array literal.
+    for (const site of table.joins) {
+        set(site.id, awaitedOf(site.call));
+        if (site.arg !== undefined && ts.isArrayLiteralExpression(site.arg)) {
+            joinPortTypes.set(site.id, site.arg.elements.map((element) => render(awaitedOf(element))));
+        }
+    }
+    // fan-out: array-method candidates take the collected artifact type of the whole call
+    // expression (the callback's parent), with the facade promise wrapper unwrapped off the
+    // element (see {@link fanoutType}). `for...of` candidates have no call expression, and
+    // `void` results (e.g. `forEach`) fall out via the uninformative filter.
+    for (const cand of table.iterations) {
+        if (cand.form !== "array-method" || cand.call === undefined)
+            continue;
+        const text = fanoutType(cand.call);
+        if (text !== undefined)
+            siteType.set(provisionalFanoutId(cand.order), text);
+    }
+    return { joinPortTypes, siteType };
+}

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

@@ -0,0 +1,67 @@
+/**
+ * 产物（artifact）的编译期收集与诊断。
+ *
+ * ⚠ 术语：本模块的 artifact 是**用户面产物**——脚本经 `artifact.*` 发布给用户看的文件 /
+ * markdown / 预置看板。同目录下的 `artifact-types.ts` 说的是**另一个** artifact：站点的
+ * 类型化输出值（给模型看的）。两者不相干。
+ *
+ * 产物两件：
+ *
+ * 1. `declaredArtifacts`（编译产物，照 `collectWorldRunCommands` 的 `commands`）：脚本声明的
+ *    产物清单 `[{id, kind}]`，去重、按 id 排序。中枢与检视器据它在**运行前**就能说出这个
+ *    工作流会产出什么。
+ * 2. 定位诊断（facade-misuse 同族）：id 必须是编译期字面量，标签必须指向一个已声明的预置，
+ *    同一个 id 不能横跨两个成员种类，预置声明不该长在循环体 / 回调 / 条件分支里。
+ *
+ * 为什么 id 必须是编译期字面量（与 `world.run` 的 cmd、`phase` 的 name 同一姿态）：一个运行期
+ * 才成形的 id 没有可展示的对象——它既进不了「将产出」清单，也让「同 id 两种种类」这类规则
+ * 只剩运行期一条路。教改写发生在便宜的那一侧。
+ *
+ * 与运行期的分工：这一趟只做**字面量能看穿的那一半**。真正的门在引擎——`ArtifactKindMismatch`
+ * /`ArtifactRedeclared`/`ArtifactUndeclared`/`ArtifactCapExceeded` 都在运行期兜底，因为
+ * 声明的**执行顺序**（哪个先跑到）静态看不出来。所以本模块**只会漏报、不会误报**，
+ * 唯一的例外是提升诊断（见 {@link ARTIFACT_HOISTING_CODE}）。
+ */
+import type { CompileDiagnostic, WorkflowProgram } from "../compiler/compile.js";
+import { type ArtifactOp } from "../facade/registry.js";
+import { type SiteTable } from "./sites.js";
+/**
+ * 产物的编译期诊断码（9001 = facade-siting、9002 = schema、9003 = world-run、9004 = phase、
+ * 9005/9006 = actor 名，顺延）。覆盖：非字面量 / 空 / 超长 / 非法字符的 id、同 id 跨种类复用、
+ * `report` 标签的三种错法。全部是**静态确定**的错误——没有一条会误伤一份合法脚本。
+ */
+export declare const ARTIFACT_DECLARATION_CODE = 9007;
+/**
+ * 预置声明长在循环体 / 回调 / 条件分支里（「声明提到顶层，一次即可」），单独一个码而不是
+ * 复用 9007，理由与 9005/9006 的分家完全相同：**确定性不同**。
+ *
+ * 循环里以**相同 spec** 重复声明在运行期其实是幂等 no-op，所以这条子句理论上会误报。接受它
+ * 的理由是代价不对称——修复是免费的（把声明挪到脚本顶部），而不报的代价是一个看板声明藏在
+ * 第三层回调里，读者要跑一遍才知道它到底声明了没有。读端（fixture 语料、未来的宽松档）
+ * 因此需要能把它与 9007 区分开，而按错误文本分流是本仓库处处禁止的。
+ */
+export declare const ARTIFACT_HOISTING_CODE = 9008;
+/**
+ * 两个**不同的** id 都写了字面量 `primary: true`。
+ * 与 9008 同一种确定性：互斥分支里各标一个在运行期跑得通，但卡与侧板只会带头一个交付物，
+ * 说不清哪个是的脚本没写完。只认字面量 `true`；算出来的旗子留给引擎的 `ArtifactPrimaryConflict`。
+ */
+export declare const ARTIFACT_PRIMARY_CONFLICT_CODE = 9009;
+/** 脚本声明的一个产物：id 与它的成员种类。 */
+export interface DeclaredArtifact {
+    id: string;
+    /** 成员种类（`file` / `markdown` / `chart` / `table` / `metrics` / `board`）。 */
+    kind: ArtifactOp;
+}
+export interface ArtifactDeclarations {
+    /** 脚本声明的产物清单：去重、按 id 字典序（`declaredCommands` 的同形产物）。 */
+    declaredArtifacts: DeclaredArtifact[];
+    /** 定位诊断；非空即脚本不可提交。 */
+    diagnostics: CompileDiagnostic[];
+}
+/**
+ * 收集产物清单与诊断。非空诊断即脚本不可提交（`analyzeWorkflowScript` 与 world.run / phase /
+ * actor 名的编译期规则同席）。
+ */
+export declare function collectArtifactDeclarations(workflow: WorkflowProgram, table: SiteTable): ArtifactDeclarations;
+//# sourceMappingURL=artifacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/analysis/artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAa,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE5F,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAuC,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEjF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,OAAO,CAAC;AAEnD,4BAA4B;AAC5B,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,2EAA2E;IAC3E,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,sBAAsB;IACtB,WAAW,EAAE,iBAAiB,EAAE,CAAC;CAClC;AAkCD;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,SAAS,GACf,oBAAoB,CAwItB"}