@ykdz/template 0.0.38 → 0.0.40

package/node_modules/@ykdz/cli-contract/dist/node.js

@@ -0,0 +1,109 @@
+/** 完整示例：https://github.com/YKDZ/cli-contract/tree/v0.2.1/packages/example */
+/// <reference types="node" preserve="true" />
+/**
+ * 将调用方提供的 Writable 接到核心输出端口，按核心选择的 stdout/stderr 路由写入。
+ * 每次写入等待 callback；write 返回 false 时还等待 drain，以承接执行内核的顺序与背压。
+ *
+ * 适配器不读取全局 process，也不关闭流、设置退出状态或接管 CLI 框架生命周期。
+ * 宿主应等待 executeCli 完成，再处理退出；写入异常交回调用方，不自动忽略 EPIPE。
+ */
+export function nodeCliOutput({ stdout, stderr, }) {
+    return (output) => writeNodeCliOutput(selectWritable(output, stdout, stderr));
+}
+/**
+ * 检查错误对象及其 cause 链是否携带 EPIPE，可用于识别 CliWriteError 保留的断管原因。
+ * 这里只检测断管，不吞掉异常、恢复写入或决定进程退出码；其他异常仍由宿主处理。
+ */
+export function isNodeBrokenPipe(error) {
+    const seen = new Set();
+    let current = error;
+    while (isObject(current) && !seen.has(current)) {
+        seen.add(current);
+        if (readProperty(current, "code") === "EPIPE")
+            return true;
+        current = readProperty(current, "cause");
+    }
+    return false;
+}
+function selectWritable(output, stdout, stderr) {
+    return {
+        writable: output.destination === "stdout" ? stdout : stderr,
+        chunk: output.chunk,
+    };
+}
+function writeNodeCliOutput({ writable, chunk, }) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let writeReturned = false;
+        let waitingForDrain = false;
+        let drainObserved = false;
+        let callbackObserved = false;
+        const cleanup = () => {
+            writable.removeListener("drain", onDrain);
+            writable.removeListener("error", onError);
+        };
+        const settle = (error, deferErrorCleanup = false) => {
+            if (settled)
+                return;
+            settled = true;
+            if (deferErrorCleanup) {
+                writable.removeListener("drain", onDrain);
+                queueMicrotask(cleanup);
+            }
+            else {
+                cleanup();
+            }
+            if (error === undefined || error === null)
+                resolve();
+            else
+                reject(error);
+        };
+        const completeWhenReady = () => {
+            if (writeReturned &&
+                callbackObserved &&
+                (!waitingForDrain || drainObserved)) {
+                settle();
+            }
+        };
+        const onDrain = () => {
+            drainObserved = true;
+            completeWhenReady();
+        };
+        const onError = (error) => {
+            if (settled) {
+                cleanup();
+                return;
+            }
+            settle(error);
+        };
+        const onCallback = (error) => {
+            if (error !== undefined && error !== null) {
+                settle(error, true);
+                return;
+            }
+            callbackObserved = true;
+            completeWhenReady();
+        };
+        writable.once("drain", onDrain);
+        writable.once("error", onError);
+        try {
+            waitingForDrain = !writable.write(chunk, onCallback);
+            writeReturned = true;
+            completeWhenReady();
+        }
+        catch (error) {
+            settle(error);
+        }
+    });
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function readProperty(value, key) {
+    try {
+        return Reflect.get(value, key);
+    }
+    catch {
+        return undefined;
+    }
+}

package/node_modules/@ykdz/cli-contract/dist/outcome-fact.d.ts

@@ -0,0 +1,162 @@
+import type { ContractSchema } from "#/contract-schema";
+declare const outcomeFactType: unique symbol;
+declare const textProjectionType: unique symbol;
+export interface TextLine {
+    readonly kind: "line";
+    readonly value: string;
+    readonly [textProjectionType]: true;
+}
+export interface TextLines {
+    readonly kind: "lines";
+    readonly lines: readonly string[];
+    readonly [textProjectionType]: true;
+}
+export interface SilentText {
+    readonly kind: "silent";
+    readonly [textProjectionType]: true;
+}
+export interface TextFragment {
+    readonly kind: "fragment";
+    readonly value: string;
+    readonly [textProjectionType]: true;
+}
+export type CompletionTextPresenter = () => TextLine | TextLines | SilentText;
+export type AtomicTextPresenter<Payload> = {
+    bivarianceHack(payload: Payload): TextLine | TextLines;
+}["bivarianceHack"];
+export type StreamTextPresenter<Payload> = {
+    bivarianceHack(payload: Payload): TextLine | TextFragment;
+}["bivarianceHack"];
+declare function createTextLine(value: string): TextLine;
+declare function createTextLines(values: readonly [string, ...string[]]): TextLines;
+declare function createTextFragment(value: string): TextFragment;
+/** 在呈现器中显式构造文本投影；这里只验证文本值，实际通道路由与分帧由执行内核负责。 */
+export declare const text: Readonly<{
+    /**
+     * 构造非空单行，拒绝 CR、LF、NUL；核心写出时追加恰好一个 LF。
+     * 适用于原子结果、流记录及流成功终态，呈现器应提供完整文本而不依赖核心补写文案。
+     */
+    line: typeof createTextLine;
+    /**
+     * 构造有序行组，至少一行非空；每行拒绝 CR、LF、NUL，空成员显式保留空白行。
+     * 核心用 LF 连接并追加一个终止 LF。用于原子结果、失败、流成功终态或帮助补充，
+     * 不用于流记录；例如 text.lines(["处理完成", "", "详细说明"])。
+     */
+    lines: typeof createTextLines;
+    /**
+     * 仅用于流记录中需要连续拼接的增量文本；必须非空且不含 NUL，可以含换行。
+     * 核心原样写出，不追加 LF，因此不承诺一行对应一条记录。
+     */
+    fragment: typeof createTextFragment;
+    /**
+     * completion 成功或流成功终态显式选择不写文本字节；仍须由呈现器返回此值。
+     * 省略呈现器不等于静默，data、failure 和流记录也不能用它代替输出。
+     */
+    silent: SilentText;
+}>;
+export declare function isIssuedTextProjection(value: unknown): value is TextLine | TextLines | TextFragment | SilentText;
+export type DataVariantDefinition<Payload = unknown, TextEnabled extends boolean = boolean> = {
+    readonly description: string;
+    readonly schema: ContractSchema<Payload>;
+    readonly exitCode: number;
+} & (TextEnabled extends true ? Readonly<{
+    readonly text: AtomicTextPresenter<Payload>;
+}> : TextEnabled extends false ? Readonly<{
+    readonly text?: never;
+}> : Readonly<{
+    readonly text?: AtomicTextPresenter<Payload>;
+}>);
+export type DataVariantDefinitions<TextEnabled extends boolean = boolean> = Readonly<Record<string, DataVariantDefinition<unknown, TextEnabled>>>;
+export type StreamRecordDefinition<Payload = unknown, TextEnabled extends boolean = boolean> = Readonly<{
+    readonly description: string;
+    readonly schema: ContractSchema<Payload>;
+}> & (TextEnabled extends true ? Readonly<{
+    readonly text: StreamTextPresenter<Payload>;
+}> : TextEnabled extends false ? Readonly<{
+    readonly text?: never;
+}> : Readonly<{
+    readonly text?: StreamTextPresenter<Payload>;
+}>);
+export type StreamRecordDefinitions<TextEnabled extends boolean = boolean> = Readonly<Record<string, StreamRecordDefinition<unknown, TextEnabled>>>;
+export type FailureVariantDefinition<Payload = unknown, TextEnabled extends boolean = boolean> = {
+    readonly description: string;
+    readonly schema: ContractSchema<Payload>;
+    readonly exitCode: number;
+} & (TextEnabled extends true ? Readonly<{
+    readonly text: AtomicTextPresenter<Payload>;
+}> : TextEnabled extends false ? Readonly<{
+    readonly text?: never;
+}> : Readonly<{
+    readonly text?: AtomicTextPresenter<Payload>;
+}>);
+export type FailureVariantDefinitions<TextEnabled extends boolean = boolean> = Readonly<Record<string, FailureVariantDefinition<unknown, TextEnabled>>>;
+export interface CompletionFact<Command extends string = string> {
+    readonly kind: "completion";
+    readonly command: Command;
+    readonly [outcomeFactType]: true;
+}
+export interface DataFact<Command extends string = string, Variant extends string = string, Data = unknown> {
+    readonly kind: "data";
+    readonly command: Command;
+    readonly variant: Variant;
+    readonly data: Data;
+    readonly [outcomeFactType]: true;
+}
+export interface FailureFact<Command extends string = string, Variant extends string = string, Data = unknown> {
+    readonly kind: "failure";
+    readonly command: Command;
+    readonly variant: Variant;
+    readonly data: Data;
+    readonly [outcomeFactType]: true;
+}
+export interface StreamRecordFact<Command extends string = string, Variant extends string = string, Data = unknown> {
+    readonly kind: "record";
+    readonly command: Command;
+    readonly variant: Variant;
+    readonly data: Data;
+    readonly [outcomeFactType]: true;
+}
+export interface StreamSuccessFact<Command extends string = string> {
+    readonly kind: "streamSuccess";
+    readonly command: Command;
+    readonly [outcomeFactType]: true;
+}
+export type OutcomeFact = CompletionFact | DataFact | FailureFact | StreamRecordFact | StreamSuccessFact;
+export interface CompletionOutcome<Command extends string> {
+    completion(): CompletionFact<Command>;
+}
+type DataVariantPayload<Variant> = Variant extends DataVariantDefinition<infer Payload> ? Payload : never;
+export type DataFactUnion<Command extends string, Variants extends DataVariantDefinitions> = {
+    readonly [Variant in keyof Variants & string]: DataFact<Command, Variant, DataVariantPayload<Variants[Variant]>>;
+}[keyof Variants & string];
+export type DataOutcome<Command extends string, Variants extends DataVariantDefinitions> = Readonly<{
+    readonly data: Readonly<{
+        [Variant in keyof Variants]: (payload: DataVariantPayload<Variants[Variant]>) => DataFact<Command, Variant & string, DataVariantPayload<Variants[Variant]>>;
+    }>;
+}>;
+type FailureVariantPayload<Variant> = Variant extends FailureVariantDefinition<infer Payload> ? Payload : never;
+export type FailureFactUnion<Command extends string, Failures extends FailureVariantDefinitions> = {
+    readonly [Variant in keyof Failures & string]: FailureFact<Command, Variant, FailureVariantPayload<Failures[Variant]>>;
+}[keyof Failures & string];
+export type FailureOutcome<Command extends string, Failures extends FailureVariantDefinitions> = Readonly<{
+    readonly failure: Readonly<{
+        [Variant in keyof Failures]: (payload: FailureVariantPayload<Failures[Variant]>) => FailureFact<Command, Variant & string, FailureVariantPayload<Failures[Variant]>>;
+    }>;
+}>;
+type StreamRecordPayload<Variant> = Variant extends StreamRecordDefinition<infer Payload> ? Payload : never;
+export type StreamRecordFactUnion<Command extends string, Records extends StreamRecordDefinitions> = {
+    readonly [Variant in keyof Records & string]: StreamRecordFact<Command, Variant, StreamRecordPayload<Records[Variant]>>;
+}[keyof Records & string];
+export type StreamOutcome<Command extends string, Records extends StreamRecordDefinitions> = Readonly<{
+    readonly record: Readonly<{
+        [Variant in keyof Records]: (payload: StreamRecordPayload<Records[Variant]>) => StreamRecordFact<Command, Variant & string, StreamRecordPayload<Records[Variant]>>;
+    }>;
+    streamSuccess(): StreamSuccessFact<Command>;
+}>;
+export declare function createCompletionFact<Command extends string>(command: Command, issuedOutcomeFacts: WeakSet<object>): CompletionFact<Command>;
+export declare function createDataFact<Command extends string, Variant extends string, Data>(command: Command, variant: Variant, data: Data, issuedOutcomeFacts: WeakSet<object>): DataFact<Command, Variant, Data>;
+export declare function createFailureFact<Command extends string, Variant extends string, Data>(command: Command, variant: Variant, data: Data, issuedOutcomeFacts: WeakSet<object>): FailureFact<Command, Variant, Data>;
+export declare function createStreamRecordFact<Command extends string, Variant extends string, Data>(command: Command, variant: Variant, data: Data, issuedOutcomeFacts: WeakSet<object>): StreamRecordFact<Command, Variant, Data>;
+export declare function createStreamSuccessFact<Command extends string>(command: Command, issuedOutcomeFacts: WeakSet<object>): StreamSuccessFact<Command>;
+export declare function isIssuedOutcomeFact(value: unknown, issuedOutcomeFacts: WeakSet<object>): value is OutcomeFact;
+export {};

package/node_modules/@ykdz/cli-contract/dist/outcome-fact.js

@@ -0,0 +1,113 @@
+const outcomeFactType = Symbol("OutcomeFact.type");
+const textProjectionType = Symbol("TextProjection.type");
+const issuedTextProjections = new WeakSet();
+/* oxlint-disable typescript/no-unsafe-type-assertion -- 文本投影仅由这些工厂签发，运行时身份由 WeakSet 核对。 */
+function createTextLine(value) {
+    if (value.length === 0 ||
+        value.includes("\r") ||
+        value.includes("\n") ||
+        value.includes("\0")) {
+        throw new TypeError("invalidTextLine");
+    }
+    const projection = Object.freeze({ kind: "line", value });
+    issuedTextProjections.add(projection);
+    return projection;
+}
+function createTextLines(values) {
+    if (!Array.isArray(values) ||
+        values.length === 0 ||
+        values.some((value) => typeof value !== "string" ||
+            value.includes("\r") ||
+            value.includes("\n") ||
+            value.includes("\0")) ||
+        values.every((value) => value.length === 0)) {
+        throw new TypeError("invalidTextLines");
+    }
+    const projection = Object.freeze({
+        kind: "lines",
+        lines: Object.freeze([...values]),
+    });
+    issuedTextProjections.add(projection);
+    return projection;
+}
+const silentProjection = Object.freeze({ kind: "silent" });
+issuedTextProjections.add(silentProjection);
+const silentText = silentProjection;
+function createTextFragment(value) {
+    if (value.length === 0 || value.includes("\0")) {
+        throw new TypeError("invalidTextFragment");
+    }
+    const projection = Object.freeze({ kind: "fragment", value });
+    issuedTextProjections.add(projection);
+    return projection;
+}
+/* oxlint-enable typescript/no-unsafe-type-assertion */
+/** 在呈现器中显式构造文本投影；这里只验证文本值，实际通道路由与分帧由执行内核负责。 */
+export const text = Object.freeze({
+    /**
+     * 构造非空单行，拒绝 CR、LF、NUL；核心写出时追加恰好一个 LF。
+     * 适用于原子结果、流记录及流成功终态，呈现器应提供完整文本而不依赖核心补写文案。
+     */
+    line: createTextLine,
+    /**
+     * 构造有序行组，至少一行非空；每行拒绝 CR、LF、NUL，空成员显式保留空白行。
+     * 核心用 LF 连接并追加一个终止 LF。用于原子结果、失败、流成功终态或帮助补充，
+     * 不用于流记录；例如 text.lines(["处理完成", "", "详细说明"])。
+     */
+    lines: createTextLines,
+    /**
+     * 仅用于流记录中需要连续拼接的增量文本；必须非空且不含 NUL，可以含换行。
+     * 核心原样写出，不追加 LF，因此不承诺一行对应一条记录。
+     */
+    fragment: createTextFragment,
+    /**
+     * completion 成功或流成功终态显式选择不写文本字节；仍须由呈现器返回此值。
+     * 省略呈现器不等于静默，data、failure 和流记录也不能用它代替输出。
+     */
+    silent: silentText,
+});
+export function isIssuedTextProjection(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        issuedTextProjections.has(value));
+}
+/* oxlint-disable typescript/no-unsafe-type-assertion -- 结果事实的私有类型品牌由签发工厂与 WeakSet 共同保证。 */
+export function createCompletionFact(command, issuedOutcomeFacts) {
+    const fact = Object.freeze({ kind: "completion", command });
+    issuedOutcomeFacts.add(fact);
+    return fact;
+}
+export function createDataFact(command, variant, data, issuedOutcomeFacts) {
+    const fact = Object.freeze({ kind: "data", command, variant, data });
+    issuedOutcomeFacts.add(fact);
+    return fact;
+}
+export function createFailureFact(command, variant, data, issuedOutcomeFacts) {
+    const fact = Object.freeze({
+        kind: "failure",
+        command,
+        variant,
+        data,
+    });
+    issuedOutcomeFacts.add(fact);
+    return fact;
+}
+export function createStreamRecordFact(command, variant, data, issuedOutcomeFacts) {
+    const fact = Object.freeze({
+        kind: "record",
+        command,
+        variant,
+        data,
+    });
+    issuedOutcomeFacts.add(fact);
+    return fact;
+}
+export function createStreamSuccessFact(command, issuedOutcomeFacts) {
+    const fact = Object.freeze({ kind: "streamSuccess", command });
+    issuedOutcomeFacts.add(fact);
+    return fact;
+}
+/* oxlint-enable typescript/no-unsafe-type-assertion */
+export function isIssuedOutcomeFact(value, issuedOutcomeFacts) {
+    return (typeof value === "object" && value !== null && issuedOutcomeFacts.has(value));
+}

package/node_modules/@ykdz/cli-contract/dist/outcome-wire.d.ts

@@ -0,0 +1,53 @@
+import type { JsonObject } from "#/contract-schema";
+export declare function createCompletionEnvelope<Command extends string>(command: Command): Readonly<{
+    schemaVersion: "1";
+    command: Command;
+    kind: "completion";
+}>;
+export declare function createCompletionWireSchema(command: string): JsonObject;
+export declare function createDataEnvelope<Command extends string, Variant extends string, Data>(command: Command, variant: Variant, data: Data): Readonly<{
+    schemaVersion: "1";
+    command: Command;
+    kind: "data";
+    variant: Variant;
+    data: Data;
+}>;
+export declare function createDataWireSchema(command: string, variant: string, dataSchema: JsonObject): JsonObject;
+export declare function createFailureEnvelope<Command extends string, Variant extends string, Data>(command: Command, variant: Variant, data: Data): Readonly<{
+    schemaVersion: "1";
+    command: Command;
+    kind: "failure";
+    variant: Variant;
+    data: Data;
+}>;
+export declare function createFailureWireSchema(command: string, variant: string, dataSchema: JsonObject): JsonObject;
+export declare function createStreamHeaderEnvelope<Command extends string>(command: Command): Readonly<{
+    schemaVersion: "1";
+    command: Command;
+    kind: "stream";
+}>;
+export declare function createStreamRecordEnvelope<Variant extends string, Data>(variant: Variant, data: Data): Readonly<{
+    kind: "record";
+    variant: Variant;
+    data: Data;
+}>;
+export declare function createStreamSuccessEnvelope(): Readonly<{
+    kind: "streamSuccess";
+}>;
+export declare function createStreamHeaderWireSchema(command: string): JsonObject;
+export declare function createStreamRecordWireSchema(variant: string, dataSchema: JsonObject): JsonObject;
+export declare function createStreamSuccessWireSchema(): JsonObject;
+export interface UsageFailureWireScope {
+    readonly command: string;
+    readonly usage: string;
+    readonly helpArgv: readonly string[];
+}
+export declare function createUsageFailureEnvelope<Command extends string>(command: Command, issues: unknown, usage: string, helpArgv: readonly string[]): Readonly<{
+    schemaVersion: "1";
+    command: Command;
+    kind: "usageFailure";
+    issues: unknown;
+    usage: string;
+    helpArgv: readonly string[];
+}>;
+export declare function createUsageFailureWireSchema(scopes: readonly UsageFailureWireScope[]): JsonObject;

package/node_modules/@ykdz/cli-contract/dist/outcome-wire.js

@@ -0,0 +1,189 @@
+const schemaVersion = "1";
+export function createCompletionEnvelope(command) {
+    return Object.freeze({
+        schemaVersion,
+        command,
+        kind: "completion",
+    });
+}
+export function createCompletionWireSchema(command) {
+    const envelope = createCompletionEnvelope(command);
+    return createEnvelopeSchema(envelope, {});
+}
+export function createDataEnvelope(command, variant, data) {
+    return createAtomicEnvelope(command, "data", variant, data);
+}
+export function createDataWireSchema(command, variant, dataSchema) {
+    const envelope = createDataEnvelope(command, variant, null);
+    return createEnvelopeSchema(envelope, { data: dataSchema });
+}
+export function createFailureEnvelope(command, variant, data) {
+    return createAtomicEnvelope(command, "failure", variant, data);
+}
+function createAtomicEnvelope(command, kind, variant, data) {
+    return Object.freeze({
+        schemaVersion,
+        command,
+        kind,
+        variant,
+        data,
+    });
+}
+export function createFailureWireSchema(command, variant, dataSchema) {
+    const envelope = createFailureEnvelope(command, variant, null);
+    return createEnvelopeSchema(envelope, { data: dataSchema });
+}
+export function createStreamHeaderEnvelope(command) {
+    return Object.freeze({ schemaVersion, command, kind: "stream" });
+}
+export function createStreamRecordEnvelope(variant, data) {
+    return Object.freeze({ kind: "record", variant, data });
+}
+export function createStreamSuccessEnvelope() {
+    return Object.freeze({ kind: "streamSuccess" });
+}
+export function createStreamHeaderWireSchema(command) {
+    return createEnvelopeSchema(createStreamHeaderEnvelope(command), {});
+}
+export function createStreamRecordWireSchema(variant, dataSchema) {
+    return createEnvelopeSchema(createStreamRecordEnvelope(variant, null), {
+        data: dataSchema,
+    });
+}
+export function createStreamSuccessWireSchema() {
+    return createEnvelopeSchema(createStreamSuccessEnvelope(), {});
+}
+export function createUsageFailureEnvelope(command, issues, usage, helpArgv) {
+    return Object.freeze({
+        schemaVersion,
+        command,
+        kind: "usageFailure",
+        issues,
+        usage,
+        helpArgv,
+    });
+}
+export function createUsageFailureWireSchema(scopes) {
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        oneOf: scopes.map(({ command, usage, helpArgv }) => createEnvelopeSchema(createUsageFailureEnvelope(command, null, usage, helpArgv), {
+            issues: {
+                items: { oneOf: usageIssueSchemas() },
+                minItems: 1,
+                type: "array",
+            },
+        })),
+    };
+}
+function usageIssueSchemas() {
+    const string = { type: "string" };
+    const position = { minimum: 0, type: "integer" };
+    const occurrence = objectSchema({ option: string, position }, [
+        "position",
+        "option",
+    ]);
+    const occurrences = (minimum) => ({
+        items: occurrence,
+        minItems: minimum,
+        type: "array",
+    });
+    const evidence = objectSchema({
+        message: string,
+        path: {
+            items: { oneOf: [string, { type: "number" }] },
+            type: "array",
+        },
+    }, ["message"]);
+    const constraintValue = objectSchema({
+        field: string,
+        value: { oneOf: [{ type: "boolean" }, string] },
+    }, ["field", "value"]);
+    const outputOccurrence = objectSchema({
+        format: { enum: ["structured", "text"] },
+        option: string,
+        position,
+    }, ["position", "option", "format"]);
+    return [
+        issueSchema("conflictingFlag", {
+            field: string,
+            negativeOccurrences: occurrences(1),
+            positiveOccurrences: occurrences(1),
+        }),
+        issueSchema("conflictingOutputFormat", {
+            occurrences: { items: outputOccurrence, minItems: 2, type: "array" },
+        }),
+        issueSchema("exclusiveUsageConstraint", {
+            fields: { items: string, minItems: 2, type: "array" },
+        }),
+        issueSchema("forbiddenUsageCombination", {
+            values: { items: constraintValue, minItems: 2, type: "array" },
+        }),
+        issueSchema("inputRejected", {
+            evidence: { items: evidence, minItems: 1, type: "array" },
+        }),
+        issueSchema("invalidFieldChoice", {
+            choices: { items: string, minItems: 1, type: "array" },
+            field: string,
+            position,
+            value: string,
+        }),
+        issueSchema("invalidOutputFormat", {
+            option: string,
+            position,
+            received: { oneOf: [string, { type: "null" }] },
+        }),
+        issueSchema("missingOptionValue", {
+            field: string,
+            option: string,
+            position,
+        }),
+        issueSchema("missingRequiredField", { field: string }),
+        issueSchema("repeatedOption", {
+            field: string,
+            occurrences: occurrences(2),
+        }),
+        issueSchema("requiredByUsageConstraint", {
+            field: string,
+            requires: string,
+        }),
+        issueSchema("unexpectedOptionValue", {
+            field: string,
+            option: string,
+            position,
+            value: string,
+        }),
+        issueSchema("unexpectedPositional", { position, value: string }),
+        issueSchema("unknownCommand", {
+            command: string,
+            position,
+            suggestedCommand: string,
+        }),
+        issueSchema("unknownOption", {
+            option: string,
+            position,
+            suggestedOption: string,
+        }),
+    ];
+}
+function issueSchema(code, properties) {
+    return objectSchema({ code: { const: code }, ...properties }, [
+        "code",
+        ...Object.keys(properties).filter((key) => key !== "suggestedCommand" && key !== "suggestedOption"),
+    ]);
+}
+function objectSchema(properties, required) {
+    return { additionalProperties: false, properties, required, type: "object" };
+}
+function createEnvelopeSchema(envelope, propertySchemas) {
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        additionalProperties: false,
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 闭合问题联合只生成 JSON Schema 的 JSON 值。
+        properties: Object.fromEntries(Object.entries(envelope).map(([key, value]) => [
+            key,
+            propertySchemas[key] ?? { const: value },
+        ])),
+        required: Object.keys(envelope),
+        type: "object",
+    };
+}

package/node_modules/@ykdz/cli-contract/dist/stream-variant-compiler.d.ts

@@ -0,0 +1,16 @@
+import type { ContractDefinitionIssue } from "#/contract-definition-error";
+import type { ContractSchema, JsonObject } from "#/contract-schema";
+import type { StreamRecordDefinition } from "#/outcome-fact";
+export type RuntimeStreamRecord = StreamRecordDefinition & {
+    readonly schema: ContractSchema;
+};
+export interface StreamRecordManifest {
+    readonly description: string;
+    readonly inputSchema: JsonObject;
+    readonly outputSchema: JsonObject;
+}
+export declare function compileStreamRecords(command: string, definitions: Readonly<Record<string, StreamRecordDefinition>>, issues: ContractDefinitionIssue[]): Readonly<{
+    readonly runtime: Readonly<Record<string, RuntimeStreamRecord>>;
+    readonly manifest: Readonly<Record<string, StreamRecordManifest>>;
+    readonly wire: Readonly<Record<string, JsonObject>>;
+}>;