@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/vendor/dynamic-workflow/schema/synthesize.js

@@ -0,0 +1,138 @@
+import ts from "typescript";
+import { collectSites } from "../analysis/sites.js";
+import { createWorkflowProgram, collectDiagnostics } from "../compiler/compile.js";
+import { SchemaEmitter, SchemaRejection } from "./emit.js";
+import { harvestConstraints, mergeConstraints } from "./jsdoc.js";
+import { SCHEMA_DIAGNOSTIC_CODE } from "./types.js";
+/**
+ * ask 站点的结果类型 T，若为「无类型」ask 则返回 undefined。这是 typed-ask 判定的
+ * 唯一真源：站点表（analysis/sites.ts）只保留 `call: ts.CallExpression`，不带 typed 标记，
+ * 故在此从 checker 解析。无类型 = T 解析为原始 `string`（`ask()` 的默认实参与显式
+ * `ask<string>()` 都属此列；`type A = string; ask<A>()` 也会被 checker 解析为原始 string）。
+ *
+ * 保持模块内私有：下游（lowering/引擎/驱动）不需要独立谓词——一次成功启动的 run 必然零
+ * 诊断，故 `siteId in schemas` 就是 typed-ask 的判定式。但**不要**据此就用 schemas 的键去
+ * 构造引擎的 askSpecs：那样 untyped 站点会整个缺席，而引擎把缺席当接线错误硬失败。
+ * 构造 askSpecs 一律走 {@link buildAskSpecs}（按站点表遍历）。
+ */
+function askResultType(checker, call) {
+    const typeNode = call.typeArguments?.[0];
+    if (typeNode === undefined)
+        return undefined;
+    const type = checker.getTypeFromTypeNode(typeNode);
+    return (type.flags & ts.TypeFlags.String) !== 0 ? undefined : type;
+}
+/**
+ * 核心入口：在构建站点表的同一 checker 上，为每个有类型 ask 发射 schema。与
+ * docs 中 `synthesizeAskSchemas(program, siteTable)` 对应，这里取 {@link WorkflowProgram}
+ * 以便拿到 `toScriptLoc` 做定位诊断。
+ */
+export function synthesizeAskSchemas(workflow, table) {
+    const checker = workflow.program.getTypeChecker();
+    const schemas = {};
+    const diagnostics = [];
+    for (const site of table.asks) {
+        const type = askResultType(checker, site.call);
+        if (type === undefined)
+            continue; // 无类型 ask：结果即最终文本，不发射 schema
+        try {
+            const typeNode = site.call.typeArguments[0];
+            const emitter = new SchemaEmitter(checker, typeNode);
+            schemas[site.id] = attachTopDoc(emitter.emitTop(type), type, checker);
+        }
+        catch (error) {
+            if (!(error instanceof SchemaRejection))
+                throw error;
+            diagnostics.push({
+                code: SCHEMA_DIAGNOSTIC_CODE,
+                column: site.loc.column,
+                line: site.loc.line,
+                message: rejectionMessage(error, "ask result type"),
+            });
+        }
+    }
+    for (const site of table.reports)
+        diagnostics.push(...reportItemDiagnostics(checker, site));
+    return { diagnostics, schemas };
+}
+/**
+ * `report(item)` 的实参可序列化性检查。
+ *
+ * 为什么与 ask 的 schema 合成走**同一趟 checker walk、同一个发射器、同一条诊断通道**：
+ * 被 report 的 item 与一个 artifact 因为完全相同的理由跨越 journal 与协议边界，所以判定
+ * "什么算可序列化"必须是同一个答案。另建一个平行的检查器，等于开始维护第二份真相——
+ * 而两份真相分歧的那天，只会在某个 run 的 Results 面板上显示成一个 `{}`。
+ *
+ * 与 ask 的两点差别：
+ *   1. **不产出 schema**。report 没有校验对象——没有模型要按它提交什么，item 是脚本自己
+ *      算出来的值。这里只要"能不能序列化"这个是非判断，发射出的 schema 直接丢掉。
+ *   2. 类型取自**实参表达式**而非类型实参。facade 把参数声明成 `unknown`（`unknown` 在
+ *      发射器里是合法的 any-JSON），所以问的是"你实际递进来的那个值是什么类型"。
+ *      `report(x)` 中 x 若是 `unknown` 或普通 JSON 形状则通过，是 `Date`/函数/类实例
+ *      /Promise 则在调用点被定位拒绝。
+ */
+function reportItemDiagnostics(checker, site) {
+    // 实参缺席由 typecheck 负责报错（facade 的 `item` 是必填参数），这里无事可做。
+    if (site.item === undefined)
+        return [];
+    try {
+        new SchemaEmitter(checker, site.item).emitTop(checker.getTypeAtLocation(site.item));
+        return [];
+    }
+    catch (error) {
+        if (!(error instanceof SchemaRejection))
+            throw error;
+        return [
+            {
+                code: SCHEMA_DIAGNOSTIC_CODE,
+                column: site.loc.column,
+                line: site.loc.line,
+                message: rejectionMessage(error, "report item type"),
+            },
+        ];
+    }
+}
+/**
+ * 便捷入口：从脚本文本一站式合成（typecheck → 站点表 → 合成）。给包内/引擎侧一个不必
+ * 自己拼装 program+table 的调用点；analyzeWorkflowScript 归 analysis 域所有，这里不触碰。
+ * 若脚本本身 typecheck 不通过，返回其编译诊断且不合成。
+ */
+export function synthesizeWorkflowSchemas(scriptText) {
+    const workflow = createWorkflowProgram(scriptText);
+    const compileDiagnostics = collectDiagnostics(workflow.program);
+    if (compileDiagnostics.length > 0)
+        return { diagnostics: compileDiagnostics, schemas: {} };
+    return synthesizeAskSchemas(workflow, collectSites(workflow));
+}
+/**
+ * 把站点表与合成出的 schemas 组装成引擎的 `askSpecs`。
+ *
+ * **为什么按 `table.asks` 遍历而不是按 `schemas` 的键**：schemas 只为 typed 站点发射
+ * （untyped ask 的结果就是末轮文本，不发射 schema），而引擎要求 askSpecs 覆盖**每一个**
+ * ask 站点——站点缺席被当作接线错误硬失败（`MissingAskSpec`），因为站点表与 schema 合成
+ * 出自同一次编译，缺席只可能是两份产物被拼在了一起。所以 untyped 站点必须显式记为
+ * `{ typed: false }`，而不是靠"查不到就当 untyped"的兜底：那条兜底会把 typed ask 静默
+ * 降级——不注册 submit_result、拿末轮文本当结果、schema 校验整个消失。
+ *
+ * 这个构造是正确性关键且只有一种写法，因此收在这里一处：调用方（run service、测试装配）
+ * 一律用它，不要各自实现。站点表是身份的唯一真源——schemas 里对不上任何站点的键被忽略。
+ */
+export function buildAskSpecs(table, schemas) {
+    const specs = new Map();
+    for (const site of table.asks) {
+        const schema = schemas[site.id];
+        specs.set(site.id, schema === undefined ? { typed: false } : { typed: true, schema });
+    }
+    return specs;
+}
+/** 顶层类型的 description/约束：源自其别名或符号（具名 interface/type alias）。 */
+function attachTopDoc(schema, type, checker) {
+    const symbol = type.aliasSymbol ?? type.getSymbol();
+    if (symbol === undefined)
+        return schema;
+    return mergeConstraints(schema, harvestConstraints(symbol, checker));
+}
+function rejectionMessage(error, subject) {
+    const where = error.path !== "$" && error.path.length > 0 ? ` (at ${error.path})` : "";
+    return `unsupported ${subject}: ${error.reason}${where}`;
+}

package/vendor/dynamic-workflow/schema/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * schema 子系统的共享词汇：我们「发射（emit）」的 JSON Schema 子集类型，以及校验器
+ * 产出的违规（violation）模型。这里的 {@link JsonSchema} 不是通用 JSON Schema —— 它
+ * 精确对应 {@link synthesizeAskSchemas} 会产出的关键字集合，校验器也只理解这一子集。
+ */
+/** 任意合法 JSON 值。const/enum/default 里出现的字面量都用它表达。 */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** 我们会发射的 JSON Schema 基础类型标签。`integer` 校验器支持但合成侧不会主动产出。 */
+export type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "null" | "array" | "object";
+/**
+ * 我们发射的 JSON Schema 子集。字段是可选关键字的并集：一个具体 schema 只会用到其中
+ * 与其形状相关的少数几个（例如 object schema 用 properties/required/additionalProperties，
+ * 而 union 用 enum 或 anyOf）。校验器只处理这里出现的关键字。
+ */
+export interface JsonSchema {
+    type?: JsonSchemaType | JsonSchemaType[];
+    const?: JsonValue;
+    enum?: JsonValue[];
+    anyOf?: JsonSchema[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    prefixItems?: JsonSchema[];
+    minItems?: number;
+    maxItems?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    description?: string;
+    default?: JsonValue;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+}
+/**
+ * 校验器产出的单条违规，设计成可直接进入修复用的 tool_result：一行一条，包含
+ * JSON 路径、期望（expected）与实得（got）。
+ */
+export interface Violation {
+    /** 违规所在位置的 JSON 路径，形如 `$`、`$.foo`、`$.items[0]`。 */
+    path: string;
+    /** 期望的形状/取值的简短描述。 */
+    expected: string;
+    /** 实际取到的值的简短描述。 */
+    got: string;
+}
+/** 合成侧诊断码。9001 已被 facade-siting 规则占用（见 analysis/sites.ts）。 */
+export declare const SCHEMA_DIAGNOSTIC_CODE = 9002;
+/**
+ * union 成员数量上限。超过即视为“病态宽 union”并在 ask 站点报诊断。
+ *
+ * 取 100：既能容纳合理的枚举（状态码、国家码等常见枚举都远低于此），又能挡住
+ * 明显是失控类型的情况。同时作用于字面量 union（→ enum）与一般 union（→ anyOf）的成员数。
+ *
+ * 现实中触发它的通常不是手写的巨型 union，而是 checker 展开模板字面量类型（template
+ * literal type）后产生的笛卡尔积——例如 `` `${Dir}-${Size}` `` 会被展开成所有组合的
+ * 字面量 union，几个维度一交叉就会爆炸。
+ */
+export declare const MAX_UNION_MEMBERS = 100;
+//# sourceMappingURL=types.d.ts.map

package/vendor/dynamic-workflow/schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mDAAmD;AACnD,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,2DAA2D;AAC3D,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,MAAM,GACN,OAAO,GACP,QAAQ,CAAC;AAEb;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAEzB,IAAI,CAAC,EAAE,cAAc,GAAG,cAAc,EAAE,CAAC;IACzC,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAE5C,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,SAAS,CAAC;IAEpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB;IACnB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,8DAA8D;AAC9D,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC"}

package/vendor/dynamic-workflow/schema/types.js

@@ -0,0 +1,18 @@
+/**
+ * schema 子系统的共享词汇：我们「发射（emit）」的 JSON Schema 子集类型，以及校验器
+ * 产出的违规（violation）模型。这里的 {@link JsonSchema} 不是通用 JSON Schema —— 它
+ * 精确对应 {@link synthesizeAskSchemas} 会产出的关键字集合，校验器也只理解这一子集。
+ */
+/** 合成侧诊断码。9001 已被 facade-siting 规则占用（见 analysis/sites.ts）。 */
+export const SCHEMA_DIAGNOSTIC_CODE = 9002;
+/**
+ * union 成员数量上限。超过即视为“病态宽 union”并在 ask 站点报诊断。
+ *
+ * 取 100：既能容纳合理的枚举（状态码、国家码等常见枚举都远低于此），又能挡住
+ * 明显是失控类型的情况。同时作用于字面量 union（→ enum）与一般 union（→ anyOf）的成员数。
+ *
+ * 现实中触发它的通常不是手写的巨型 union，而是 checker 展开模板字面量类型（template
+ * literal type）后产生的笛卡尔积——例如 `` `${Dir}-${Size}` `` 会被展开成所有组合的
+ * 字面量 union，几个维度一交叉就会爆炸。
+ */
+export const MAX_UNION_MEMBERS = 100;

package/vendor/dynamic-workflow/schema/validate.d.ts

@@ -0,0 +1,15 @@
+import type { JsonSchema, Violation } from "./types.js";
+/**
+ * 纯校验器，覆盖范围恰好是 {@link synthesizeAskSchemas} 会发射的 JSON Schema 子集
+ * （不是通用 JSON Schema）。产出违规列表，每条设计成可直接进修复用 tool_result：
+ * 一行 JSON 路径 + 期望 + 实得。
+ *
+ * 空 schema `{}`（unknown 的许可式 schema）匹配任意合法 JSON。`$ref` 在传入的根 schema
+ * 的 `$defs` 内解析。
+ */
+export declare function validate(schema: JsonSchema, value: unknown): Violation[];
+/** 把一条违规格式化为单行：`<path>: expected <expected>, got <got>`。 */
+export declare function formatViolation(violation: Violation): string;
+/** 把违规列表格式化为多行文本（每行一条）。 */
+export declare function formatViolations(violations: readonly Violation[]): string;
+//# sourceMappingURL=validate.d.ts.map

package/vendor/dynamic-workflow/schema/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/schema/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkB,SAAS,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;;;GAOG;AAEH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,CAIxE;AAED,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAE5D;AAED,2BAA2B;AAC3B,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAEzE"}

package/vendor/dynamic-workflow/schema/validate.js

@@ -0,0 +1,213 @@
+/**
+ * 纯校验器，覆盖范围恰好是 {@link synthesizeAskSchemas} 会发射的 JSON Schema 子集
+ * （不是通用 JSON Schema）。产出违规列表，每条设计成可直接进修复用 tool_result：
+ * 一行 JSON 路径 + 期望 + 实得。
+ *
+ * 空 schema `{}`（unknown 的许可式 schema）匹配任意合法 JSON。`$ref` 在传入的根 schema
+ * 的 `$defs` 内解析。
+ */
+export function validate(schema, value) {
+    const violations = [];
+    check(schema, value, "$", schema, violations);
+    return violations;
+}
+/** 把一条违规格式化为单行：`<path>: expected <expected>, got <got>`。 */
+export function formatViolation(violation) {
+    return `${violation.path}: expected ${violation.expected}, got ${violation.got}`;
+}
+/** 把违规列表格式化为多行文本（每行一条）。 */
+export function formatViolations(violations) {
+    return violations.map(formatViolation).join("\n");
+}
+function check(schema, value, path, root, out) {
+    if (schema.$ref !== undefined) {
+        const resolved = resolveRef(root, schema.$ref);
+        if (resolved === undefined) {
+            out.push({ expected: `schema ${schema.$ref}`, got: "unresolved $ref", path });
+            return;
+        }
+        check(resolved, value, path, root, out);
+        return;
+    }
+    if ("const" in schema) {
+        if (!deepEqual(value, schema.const)) {
+            out.push({ expected: describeValue(schema.const), got: describeValue(value), path });
+        }
+        return;
+    }
+    if (schema.enum !== undefined) {
+        if (!schema.enum.some((candidate) => deepEqual(value, candidate))) {
+            out.push({ expected: `one of ${schema.enum.map((v) => describeValue(v)).join(", ")}`, got: describeValue(value), path });
+        }
+        return;
+    }
+    if (schema.anyOf !== undefined) {
+        const matched = schema.anyOf.some((branch) => {
+            const trial = [];
+            check(branch, value, path, root, trial);
+            return trial.length === 0;
+        });
+        if (!matched) {
+            out.push({ expected: `one of ${schema.anyOf.length} variants`, got: describeValue(value), path });
+        }
+        return;
+    }
+    if (schema.type !== undefined && !typeMatches(schema.type, value)) {
+        out.push({ expected: typeName(schema.type), got: describeValue(value), path });
+        return;
+    }
+    if (schema.type === "object")
+        checkObject(schema, value, path, root, out);
+    if (schema.type === "array")
+        checkArray(schema, value, path, root, out);
+    if (typeof value === "string")
+        checkString(schema, value, path, out);
+    if (typeof value === "number")
+        checkNumber(schema, value, path, out);
+}
+function checkObject(schema, value, path, root, out) {
+    for (const key of schema.required ?? []) {
+        if (!Object.prototype.hasOwnProperty.call(value, key)) {
+            out.push({ expected: "present", got: "missing", path: `${path}.${key}` });
+        }
+    }
+    const properties = schema.properties ?? {};
+    for (const [key, propValue] of Object.entries(value)) {
+        const propSchema = properties[key];
+        if (propSchema !== undefined) {
+            check(propSchema, propValue, `${path}.${key}`, root, out);
+            continue;
+        }
+        const additional = schema.additionalProperties;
+        if (additional === false) {
+            out.push({ expected: "no additional property", got: describeValue(propValue), path: `${path}.${key}` });
+        }
+        else if (additional !== undefined && additional !== true) {
+            check(additional, propValue, `${path}.${key}`, root, out);
+        }
+    }
+}
+function checkArray(schema, value, path, root, out) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        out.push({ expected: `at least ${schema.minItems} items`, got: `array(${value.length})`, path });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        out.push({ expected: `at most ${schema.maxItems} items`, got: `array(${value.length})`, path });
+    }
+    if (schema.prefixItems !== undefined) {
+        schema.prefixItems.forEach((itemSchema, index) => {
+            if (index < value.length)
+                check(itemSchema, value[index], `${path}[${index}]`, root, out);
+        });
+        if (schema.items !== undefined) {
+            for (let index = schema.prefixItems.length; index < value.length; index += 1) {
+                check(schema.items, value[index], `${path}[${index}]`, root, out);
+            }
+        }
+        return;
+    }
+    if (schema.items !== undefined) {
+        value.forEach((item, index) => check(schema.items, item, `${path}[${index}]`, root, out));
+    }
+}
+function checkString(schema, value, path, out) {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        out.push({ expected: `string length >= ${schema.minLength}`, got: `length ${value.length}`, path });
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        out.push({ expected: `string length <= ${schema.maxLength}`, got: `length ${value.length}`, path });
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+        out.push({ expected: `match /${schema.pattern}/`, got: describeValue(value), path });
+    }
+}
+function checkNumber(schema, value, path, out) {
+    if (schema.type === "integer" && !Number.isInteger(value)) {
+        out.push({ expected: "integer", got: `number ${value}`, path });
+    }
+    if (schema.minimum !== undefined && value < schema.minimum) {
+        out.push({ expected: `>= ${schema.minimum}`, got: `number ${value}`, path });
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+        out.push({ expected: `<= ${schema.maximum}`, got: `number ${value}`, path });
+    }
+    if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+        out.push({ expected: `> ${schema.exclusiveMinimum}`, got: `number ${value}`, path });
+    }
+    if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum) {
+        out.push({ expected: `< ${schema.exclusiveMaximum}`, got: `number ${value}`, path });
+    }
+}
+function typeMatches(type, value) {
+    const types = Array.isArray(type) ? type : [type];
+    return types.some((candidate) => matchesOne(candidate, value));
+}
+function matchesOne(type, value) {
+    switch (type) {
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isFinite(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+}
+function typeName(type) {
+    return Array.isArray(type) ? type.join(" | ") : type;
+}
+function resolveRef(root, ref) {
+    const match = /^#\/\$defs\/(.+)$/.exec(ref);
+    if (match === null)
+        return undefined;
+    return root.$defs?.[match[1]];
+}
+/** JSON 深相等：基础值、数组、纯对象。用于 const/enum 比较。 */
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key) => Object.prototype.hasOwnProperty.call(b, key) &&
+            deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+/** 值的简短描述，用于 got/expected：类型 + 精简取值。 */
+function describeValue(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return `array(${value.length})`;
+    switch (typeof value) {
+        case "string": {
+            const shown = value.length > 20 ? `${value.slice(0, 20)}…` : value;
+            return `string ${JSON.stringify(shown)}`;
+        }
+        case "number":
+            return `number ${value}`;
+        case "boolean":
+            return `boolean ${value}`;
+        case "object":
+            return "object";
+        case "undefined":
+            return "undefined";
+        default:
+            return typeof value;
+    }
+}

package/vendor/dynamic-workflow/testing/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `@zcode/dynamic-workflow/testing`：面向 JournalStorePort 实现方的共享测试资产。
+ * 只在消费方的测试进程里执行（vitest 是本包的 devDependency，不进入运行时依赖）。
+ */
+export { runJournalStoreContract } from "./journal-contract.js";
+//# sourceMappingURL=index.d.ts.map

package/vendor/dynamic-workflow/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

package/vendor/dynamic-workflow/testing/index.js

@@ -0,0 +1,5 @@
+/**
+ * `@zcode/dynamic-workflow/testing`：面向 JournalStorePort 实现方的共享测试资产。
+ * 只在消费方的测试进程里执行（vitest 是本包的 devDependency，不进入运行时依赖）。
+ */
+export { runJournalStoreContract } from "./journal-contract.js";

package/vendor/dynamic-workflow/testing/journal-contract-artifacts.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把用户面产物行（kind: "artifact"、artifactId 列、report 标签）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerArtifactCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-artifacts.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-artifacts.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAyB,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAG9F,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAsM3E"}