@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

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

@@ -0,0 +1,55 @@
+import ts from "typescript";
+import type { JsonSchema } from "./types.js";
+/**
+ * 类型 → JSON Schema 的发射器（emitter），由 checker 的结构化视图驱动（泛型/别名/
+ * mapped/conditional 都已被 checker 展平）。
+ *
+ * 递归类型通过 `$defs`/`$ref` 表达：只有真正被自身（在合成栈上）再次引用到的类型才会
+ * 被提升为 def，非递归的具名类型仍就地内联，保证快照可读。识别办法是给每个复合类型
+ * 压一个栈帧，若发射其子树时再次进入同一 `ts.Type`，就把它标记为 requested 并返回
+ * `$ref`；栈帧结束时若被 requested 过，则登记进 defs。
+ *
+ * 不可 JSON 序列化的类型以 {@link SchemaRejection} 抛出，由合成侧转成定位到 ask 站点的
+ * 诊断（复用分析管线的诊断形状/UX）。
+ */
+/** 发射失败：携带原因与出错的 JSON 路径，供合成侧组装成定位诊断。 */
+export declare class SchemaRejection extends Error {
+    readonly reason: string;
+    readonly path: string;
+    constructor(reason: string, path: string);
+}
+export declare class SchemaEmitter {
+    private readonly checker;
+    private readonly location;
+    private readonly defs;
+    private readonly inProgress;
+    private readonly defName;
+    private readonly usedNames;
+    constructor(checker: ts.TypeChecker, location: ts.Node);
+    /** 发射顶层类型；若过程中产生了 def，则把 `$defs` 挂到根 schema 上。 */
+    emitTop(type: ts.Type): JsonSchema;
+    private emit;
+    /** 复合类型的栈帧包装：发射期间若被自身再次引用则提升为 def 并返回 `$ref`。 */
+    private composite;
+    /** 为一个类型分配稳定且唯一的 def 名（源自别名/符号名），惰性且去重。 */
+    private nameFor;
+    private booleanValue;
+    private emitUnion;
+    /** 一组成员类型 → enum（全为字面量时）或 anyOf。也被可选属性的去 undefined 路径复用。 */
+    emitMembers(members: readonly ts.Type[], path: string): JsonSchema;
+    /** 若所有成员都是字面量（string/number/boolean 字面量或 null），返回其取值数组。 */
+    private asLiterals;
+    /** 交叉类型：合并为一个 object（checker 已把成员属性合并到交叉类型上）。含原始类型成员
+     *  的品牌类型（如 `string & {__brand}`）按其原始类型发射。 */
+    private emitIntersection;
+    private emitObjectLike;
+    private emitObject;
+    /** 可选属性：从属性类型里剥掉 undefined 后再发射（可选性由 required 表达，不进类型）。 */
+    private emitOptional;
+    private emitArray;
+    private emitTuple;
+    private isArrayType;
+    private isTupleType;
+    private isThenable;
+}
+//# sourceMappingURL=emit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/schema/emit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AAGxD;;;;;;;;;;;GAWG;AAEH,yCAAyC;AACzC,qBAAa,eAAgB,SAAQ,KAAK;IAEtC,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM;gBADZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;CAKxB;AAgDD,qBAAa,aAAa;IAOtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAP3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4D;IACjF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;gBAG5B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,QAAQ,EAAE,EAAE,CAAC,IAAI;IAGpC,kDAAkD;IAClD,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,UAAU;IAQlC,OAAO,CAAC,IAAI;IAsCZ,iDAAiD;IACjD,OAAO,CAAC,SAAS;IAWjB,2CAA2C;IAC3C,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,SAAS;IAgBjB,4DAA4D;IAC5D,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAMlE,2DAA2D;IAC3D,OAAO,CAAC,UAAU;IAalB;iDAC6C;IAC7C,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,UAAU;IA0BlB,2DAA2D;IAC3D,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,SAAS;IAuBjB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,UAAU;CAMnB"}

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

@@ -0,0 +1,325 @@
+import ts from "typescript";
+import { harvestConstraints, mergeConstraints } from "./jsdoc.js";
+import { MAX_UNION_MEMBERS } from "./types.js";
+/**
+ * 类型 → JSON Schema 的发射器（emitter），由 checker 的结构化视图驱动（泛型/别名/
+ * mapped/conditional 都已被 checker 展平）。
+ *
+ * 递归类型通过 `$defs`/`$ref` 表达：只有真正被自身（在合成栈上）再次引用到的类型才会
+ * 被提升为 def，非递归的具名类型仍就地内联，保证快照可读。识别办法是给每个复合类型
+ * 压一个栈帧，若发射其子树时再次进入同一 `ts.Type`，就把它标记为 requested 并返回
+ * `$ref`；栈帧结束时若被 requested 过，则登记进 defs。
+ *
+ * 不可 JSON 序列化的类型以 {@link SchemaRejection} 抛出，由合成侧转成定位到 ask 站点的
+ * 诊断（复用分析管线的诊断形状/UX）。
+ */
+/** 发射失败：携带原因与出错的 JSON 路径，供合成侧组装成定位诊断。 */
+export class SchemaRejection extends Error {
+    reason;
+    path;
+    constructor(reason, path) {
+        super(reason);
+        this.reason = reason;
+        this.path = path;
+        this.name = "SchemaRejection";
+    }
+}
+/**
+ * 明确按名字拒绝的内建对象：它们是宿主对象/类实例，不是纯数据。Promise 也在此列，
+ * 给出比“函数类型”更清晰的诊断。用户自定义 class 由 SymbolFlags.Class 兜底。
+ */
+const REJECTED_BUILTINS = new Set([
+    "Date",
+    "RegExp",
+    "Map",
+    "WeakMap",
+    "ReadonlyMap",
+    "Set",
+    "WeakSet",
+    "ReadonlySet",
+    "Promise",
+    "Error",
+    "EvalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "DataView",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+]);
+/** 读取对象类型的 objectFlags（`ts.getObjectFlags` 未在公有 typings 暴露，这里直接取）。 */
+function objectFlagsOf(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0 ? type.objectFlags : 0;
+}
+export class SchemaEmitter {
+    checker;
+    location;
+    defs = new Map();
+    inProgress = new Map();
+    defName = new Map();
+    usedNames = new Set();
+    constructor(checker, location) {
+        this.checker = checker;
+        this.location = location;
+    }
+    /** 发射顶层类型；若过程中产生了 def，则把 `$defs` 挂到根 schema 上。 */
+    emitTop(type) {
+        const schema = this.emit(type, "$");
+        if (this.defs.size === 0)
+            return schema;
+        const $defs = {};
+        for (const { name, schema: defSchema } of this.defs.values())
+            $defs[name] = defSchema;
+        return { ...schema, $defs };
+    }
+    emit(type, path) {
+        const settled = this.defs.get(type);
+        if (settled !== undefined)
+            return { $ref: `#/$defs/${settled.name}` };
+        const frame = this.inProgress.get(type);
+        if (frame !== undefined) {
+            frame.requested = true;
+            return { $ref: `#/$defs/${this.nameFor(type)}` };
+        }
+        const flags = type.flags;
+        if (flags & ts.TypeFlags.Any) {
+            throw new SchemaRejection("type 'any' is not allowed; use 'unknown' or a concrete type", path);
+        }
+        if (flags & ts.TypeFlags.Unknown)
+            return {};
+        if (flags & ts.TypeFlags.Never)
+            throw new SchemaRejection("type 'never' cannot be represented", path);
+        if (flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) {
+            throw new SchemaRejection("'undefined' is only allowed on optional properties", path);
+        }
+        if (flags & ts.TypeFlags.Null)
+            return { type: "null" };
+        if (flags & ts.TypeFlags.BooleanLiteral)
+            return { const: this.booleanValue(type) };
+        if (flags & ts.TypeFlags.Boolean)
+            return { type: "boolean" };
+        if (flags & ts.TypeFlags.StringLiteral)
+            return { const: type.value };
+        if (flags & ts.TypeFlags.NumberLiteral)
+            return { const: type.value };
+        if (flags & ts.TypeFlags.String)
+            return { type: "string" };
+        if (flags & ts.TypeFlags.Number)
+            return { type: "number" };
+        if (flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral)) {
+            throw new SchemaRejection("'bigint' is not JSON-serializable", path);
+        }
+        if (flags & (ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol)) {
+            throw new SchemaRejection("'symbol' is not JSON-serializable", path);
+        }
+        if (type.isUnion())
+            return this.composite(type, () => this.emitUnion(type, path));
+        if (type.isIntersection())
+            return this.composite(type, () => this.emitIntersection(type, path));
+        if (flags & ts.TypeFlags.Object)
+            return this.composite(type, () => this.emitObjectLike(type, path));
+        throw new SchemaRejection("type is not JSON-serializable", path);
+    }
+    /** 复合类型的栈帧包装：发射期间若被自身再次引用则提升为 def 并返回 `$ref`。 */
+    composite(type, build) {
+        this.inProgress.set(type, { requested: false });
+        const schema = build();
+        const frame = this.inProgress.get(type);
+        this.inProgress.delete(type);
+        if (!frame.requested)
+            return schema;
+        const name = this.nameFor(type);
+        this.defs.set(type, { name, schema });
+        return { $ref: `#/$defs/${name}` };
+    }
+    /** 为一个类型分配稳定且唯一的 def 名（源自别名/符号名），惰性且去重。 */
+    nameFor(type) {
+        const cached = this.defName.get(type);
+        if (cached !== undefined)
+            return cached;
+        const base = type.aliasSymbol?.name ?? type.getSymbol()?.name ?? "Schema";
+        let name = base;
+        let suffix = 1;
+        while (this.usedNames.has(name)) {
+            suffix += 1;
+            name = `${base}${suffix}`;
+        }
+        this.usedNames.add(name);
+        this.defName.set(type, name);
+        return name;
+    }
+    booleanValue(type) {
+        return type.intrinsicName === "true";
+    }
+    emitUnion(type, path) {
+        const members = type.types;
+        if (members.length > MAX_UNION_MEMBERS) {
+            throw new SchemaRejection(`union has too many members (${members.length} > ${MAX_UNION_MEMBERS})`, path);
+        }
+        for (const member of members) {
+            if (member.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) {
+                throw new SchemaRejection("'undefined' is only allowed on optional properties", path);
+            }
+        }
+        return this.emitMembers(members, path);
+    }
+    /** 一组成员类型 → enum（全为字面量时）或 anyOf。也被可选属性的去 undefined 路径复用。 */
+    emitMembers(members, path) {
+        const literals = this.asLiterals(members);
+        if (literals !== undefined)
+            return { enum: literals };
+        return { anyOf: members.map((member, index) => this.emit(member, `${path}|${index}`)) };
+    }
+    /** 若所有成员都是字面量（string/number/boolean 字面量或 null），返回其取值数组。 */
+    asLiterals(members) {
+        const values = [];
+        for (const member of members) {
+            const flags = member.flags;
+            if (flags & ts.TypeFlags.StringLiteral)
+                values.push(member.value);
+            else if (flags & ts.TypeFlags.NumberLiteral)
+                values.push(member.value);
+            else if (flags & ts.TypeFlags.BooleanLiteral)
+                values.push(this.booleanValue(member));
+            else if (flags & ts.TypeFlags.Null)
+                values.push(null);
+            else
+                return undefined;
+        }
+        return values;
+    }
+    /** 交叉类型：合并为一个 object（checker 已把成员属性合并到交叉类型上）。含原始类型成员
+     *  的品牌类型（如 `string & {__brand}`）按其原始类型发射。 */
+    emitIntersection(type, path) {
+        for (const member of type.types) {
+            if (member.flags & ts.TypeFlags.String)
+                return { type: "string" };
+            if (member.flags & ts.TypeFlags.Number)
+                return { type: "number" };
+            if (member.flags & ts.TypeFlags.Boolean)
+                return { type: "boolean" };
+        }
+        if (type.getCallSignatures().length > 0) {
+            throw new SchemaRejection("function types are not JSON-serializable", path);
+        }
+        return this.emitObject(type, path);
+    }
+    emitObjectLike(type, path) {
+        if (this.isArrayType(type))
+            return this.emitArray(type, path);
+        if (this.isTupleType(type))
+            return this.emitTuple(type, path);
+        if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+            throw new SchemaRejection("function types are not JSON-serializable", path);
+        }
+        const name = type.getSymbol()?.getName();
+        if (name !== undefined && REJECTED_BUILTINS.has(name)) {
+            throw new SchemaRejection(`'${name}' is not JSON-serializable`, path);
+        }
+        if (((type.getSymbol()?.flags ?? 0) & ts.SymbolFlags.Class) !== 0) {
+            throw new SchemaRejection("class instances are not JSON-serializable", path);
+        }
+        if (this.isThenable(type)) {
+            throw new SchemaRejection("Promise/thenable values are not JSON-serializable", path);
+        }
+        return this.emitObject(type, path);
+    }
+    emitObject(type, path) {
+        const properties = {};
+        const required = [];
+        for (const prop of this.checker.getPropertiesOfType(type)) {
+            const optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+            const propPath = `${path}.${prop.name}`;
+            const propType = this.checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration ?? this.location);
+            const base = optional ? this.emitOptional(propType, propPath) : this.emit(propType, propPath);
+            properties[prop.name] = mergeConstraints(base, harvestConstraints(prop, this.checker));
+            if (!optional)
+                required.push(prop.name);
+        }
+        const schema = { type: "object" };
+        if (Object.keys(properties).length > 0)
+            schema.properties = properties;
+        if (required.length > 0)
+            schema.required = required;
+        // 闭合对象（无字符串索引签名）发射 additionalProperties: false。
+        // 注意这不是「忠于 TS」：TS 的对象类型在结构上是开放的（多余属性检查只对对象字面量
+        // 触发），`{a: string}` 本身接受多余键。这里选 false 的真正理由是校验 UX 与结构化
+        // 输出惯例：模型给出多余键几乎总是误解的信号，false 能把它变成一条清晰的修复提示，
+        // 也符合严格结构化输出的通行做法。带字符串索引签名（Record<string,T>）则用其值 schema。
+        const indexInfo = this.checker.getIndexInfoOfType(type, ts.IndexKind.String);
+        schema.additionalProperties = indexInfo !== undefined ? this.emit(indexInfo.type, `${path}[*]`) : false;
+        return schema;
+    }
+    /** 可选属性：从属性类型里剥掉 undefined 后再发射（可选性由 required 表达，不进类型）。 */
+    emitOptional(propType, path) {
+        if (!propType.isUnion())
+            return this.emit(propType, path);
+        const rest = propType.types.filter((member) => (member.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0);
+        if (rest.length === propType.types.length)
+            return this.emit(propType, path);
+        if (rest.length === 1)
+            return this.emit(rest[0], path);
+        return this.emitMembers(rest, path);
+    }
+    emitArray(type, path) {
+        const element = this.checker.getTypeArguments(type)[0];
+        const items = element !== undefined ? this.emit(element, `${path}[]`) : {};
+        return { type: "array", items };
+    }
+    emitTuple(type, path) {
+        const elementFlags = type.target.elementFlags;
+        const args = this.checker.getTypeArguments(type);
+        const prefixItems = [];
+        let minItems = 0;
+        let restItems;
+        for (let index = 0; index < args.length; index += 1) {
+            const flag = elementFlags[index] ?? ts.ElementFlags.Required;
+            const arg = args[index];
+            if (flag & ts.ElementFlags.Rest) {
+                restItems = this.emit(arg, `${path}[${index}]`);
+                continue;
+            }
+            const optional = (flag & ts.ElementFlags.Optional) !== 0;
+            prefixItems.push(optional ? this.emitOptional(arg, `${path}[${index}]`) : this.emit(arg, `${path}[${index}]`));
+            if (flag & ts.ElementFlags.Required)
+                minItems += 1;
+        }
+        const schema = { type: "array", prefixItems, minItems };
+        if (restItems !== undefined)
+            schema.items = restItems;
+        else
+            schema.maxItems = prefixItems.length;
+        return schema;
+    }
+    isArrayType(type) {
+        if ((objectFlagsOf(type) & ts.ObjectFlags.Reference) === 0)
+            return false;
+        const name = type.target.getSymbol()?.getName();
+        return name === "Array" || name === "ReadonlyArray";
+    }
+    isTupleType(type) {
+        if ((objectFlagsOf(type) & ts.ObjectFlags.Reference) === 0)
+            return false;
+        return ((type.target.objectFlags ?? 0) & ts.ObjectFlags.Tuple) !== 0;
+    }
+    isThenable(type) {
+        const then = this.checker.getPropertyOfType(type, "then");
+        if (then === undefined)
+            return false;
+        const thenType = this.checker.getTypeOfSymbolAtLocation(then, then.valueDeclaration ?? this.location);
+        return thenType.getCallSignatures().length > 0;
+    }
+}

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

@@ -0,0 +1,10 @@
+import ts from "typescript";
+import type { JsonSchema } from "./types.js";
+/**
+ * 采集一个符号上的 description 与约束标签，返回一个只含相关关键字的 schema 片段，
+ * 供合成侧合并进该符号对应的 schema。
+ */
+export declare function harvestConstraints(symbol: ts.Symbol, checker: ts.TypeChecker): Partial<JsonSchema>;
+/** 把采集到的片段合并进已有 schema：约束关键字补充上去，description 不覆盖已有值。 */
+export declare function mergeConstraints(schema: JsonSchema, extra: Partial<JsonSchema>): JsonSchema;
+//# sourceMappingURL=jsdoc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../src/schema/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AA+BxD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAQlG;AAkCD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAQ3F"}

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

@@ -0,0 +1,83 @@
+import ts from "typescript";
+/**
+ * JSDoc 采集：把符号（interface 成员、类型别名、ask 结果类型）上的文档注释与受支持的
+ * 约束标签抽成 JSON Schema 片段。
+ *
+ * - 文档正文 → `description`。
+ * - 标签子集 → 约束关键字：`@minimum @maximum @exclusiveMinimum @exclusiveMaximum
+ *   @minLength @maxLength @pattern @format @minItems @maxItems @default`。
+ *
+ * 子集之外的标签被静默忽略（不是错误）。
+ */
+/** 取数值的标签 → 对应的数值型关键字名。 */
+const NUMERIC_TAGS = {
+    exclusiveMaximum: "exclusiveMaximum",
+    exclusiveMinimum: "exclusiveMinimum",
+    maximum: "maximum",
+    maxItems: "maxItems",
+    maxLength: "maxLength",
+    minimum: "minimum",
+    minItems: "minItems",
+    minLength: "minLength",
+};
+/** 取字符串的标签 → 对应的字符串型关键字名。 */
+const STRING_TAGS = {
+    format: "format",
+    pattern: "pattern",
+};
+/**
+ * 采集一个符号上的 description 与约束标签，返回一个只含相关关键字的 schema 片段，
+ * 供合成侧合并进该符号对应的 schema。
+ */
+export function harvestConstraints(symbol, checker) {
+    const out = {};
+    const doc = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    if (doc.length > 0)
+        out.description = doc;
+    for (const tag of symbol.getJsDocTags(checker))
+        applyTag(out, tag);
+    return out;
+}
+function applyTag(out, tag) {
+    const raw = ts.displayPartsToString(tag.text).trim();
+    const numericKey = NUMERIC_TAGS[tag.name];
+    if (numericKey !== undefined) {
+        const value = Number(raw);
+        if (Number.isFinite(value))
+            out[numericKey] = value;
+        return;
+    }
+    const stringKey = STRING_TAGS[tag.name];
+    if (stringKey !== undefined) {
+        if (raw.length > 0)
+            out[stringKey] = raw;
+        return;
+    }
+    if (tag.name === "default") {
+        out.default = parseDefault(raw);
+    }
+    // 子集之外的标签：忽略。
+}
+/** `@default` 的值先按 JSON 解析（数字/布尔/对象/数组/带引号字符串），失败则当作裸字符串。 */
+function parseDefault(raw) {
+    if (raw.length === 0)
+        return "";
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** 把采集到的片段合并进已有 schema：约束关键字补充上去，description 不覆盖已有值。 */
+export function mergeConstraints(schema, extra) {
+    const merged = { ...schema };
+    for (const [key, value] of Object.entries(extra)) {
+        if (value === undefined)
+            continue;
+        if (key === "description" && merged.description !== undefined)
+            continue;
+        merged[key] = value;
+    }
+    return merged;
+}

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

@@ -0,0 +1,8 @@
+import type { JsonSchema } from "./types.js";
+/**
+ * 确定性序列化：把 schema 的对象键递归排序后再 JSON.stringify，保证快照稳定，与发射
+ * 时的插入顺序无关。数组（enum/required/prefixItems/anyOf 等）保持原有顺序不动 ——
+ * 它们的顺序是有意义的（且由 checker 的属性/成员顺序确定）。
+ */
+export declare function serializeSchema(schema: JsonSchema): string;
+//# sourceMappingURL=serialize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/schema/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE1D"}

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

@@ -0,0 +1,20 @@
+/**
+ * 确定性序列化：把 schema 的对象键递归排序后再 JSON.stringify，保证快照稳定，与发射
+ * 时的插入顺序无关。数组（enum/required/prefixItems/anyOf 等）保持原有顺序不动 ——
+ * 它们的顺序是有意义的（且由 checker 的属性/成员顺序确定）。
+ */
+export function serializeSchema(schema) {
+    return `${JSON.stringify(canonicalize(schema), null, 2)}\n`;
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = canonicalize(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}

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

@@ -0,0 +1,48 @@
+import type { CompileDiagnostic, WorkflowProgram } from "../compiler/compile.js";
+import { type SiteTable } from "../analysis/sites.js";
+import type { AskSpec } from "../engine/types.js";
+import type { JsonSchema } from "./types.js";
+/**
+ * Schema 合成（编译侧）：为每个「有类型」的 ask 站点，用 checker 的结构化视图把结果
+ * 类型 T 发射成纯 JSON Schema，按站点 id（如 `ask#1`）归档。
+ *
+ * 「有类型」判定：ask 显式带类型实参 `x.ask<T>(...)` 且 T 解析后不是原始 `string`。
+ * `ask()` 与 `ask<string>()` 都是「无类型」ask（结果即最终文本，不发射 schema）。
+ * 不可序列化的 T 以定位到 ask 站点的诊断拒绝（复用分析管线的 CompileDiagnostic 形状）。
+ *
+ * 同一趟里还检查 `report(item)` 的实参可序列化性——同一个发射器、同一条诊断通道，
+ * 理由见 {@link reportItemDiagnostics}。report 站点**不产出 schema**，只贡献诊断。
+ */
+export interface SchemaSynthesisResult {
+    /** 每个有类型 ask 站点的 JSON Schema，按站点 id 归档。 */
+    schemas: Record<string, JsonSchema>;
+    /** 拒绝性诊断，定位在对应 ask 站点。 */
+    diagnostics: CompileDiagnostic[];
+}
+/**
+ * 核心入口：在构建站点表的同一 checker 上，为每个有类型 ask 发射 schema。与
+ * docs 中 `synthesizeAskSchemas(program, siteTable)` 对应，这里取 {@link WorkflowProgram}
+ * 以便拿到 `toScriptLoc` 做定位诊断。
+ */
+export declare function synthesizeAskSchemas(workflow: WorkflowProgram, table: SiteTable): SchemaSynthesisResult;
+/**
+ * 便捷入口：从脚本文本一站式合成（typecheck → 站点表 → 合成）。给包内/引擎侧一个不必
+ * 自己拼装 program+table 的调用点；analyzeWorkflowScript 归 analysis 域所有，这里不触碰。
+ * 若脚本本身 typecheck 不通过，返回其编译诊断且不合成。
+ */
+export declare function synthesizeWorkflowSchemas(scriptText: string): SchemaSynthesisResult;
+/**
+ * 把站点表与合成出的 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 declare function buildAskSpecs(table: SiteTable, schemas: Record<string, JsonSchema>): Map<string, AskSpec>;
+//# sourceMappingURL=synthesize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"synthesize.d.ts","sourceRoot":"","sources":["../../src/schema/synthesize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC,0BAA0B;IAC1B,WAAW,EAAE,iBAAiB,EAAE,CAAC;CAClC;AAoBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,SAAS,GACf,qBAAqB,CA2BvB;AAwCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,qBAAqB,CAKnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzG"}