@ykdz/template 0.0.37 → 0.0.40

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

@@ -0,0 +1,708 @@
+import { createCompletionFact, createDataFact, createFailureFact, createStreamRecordFact, createStreamSuccessFact, formatFieldUsage, getCompiledCli, isCompiledExecutable, isIssuedOutcomeFact, usageFailureHelpArgv, } from "#/cli-contract";
+import { invocationBelongsTo, } from "#/cli-invocation";
+import { CliWriteError } from "#/cli-write-error";
+import { ContractExecutionError, } from "#/contract-execution-error";
+import { copyJsonValue } from "#/json-value";
+import { isIssuedTextProjection } from "#/outcome-fact";
+import { createCompletionEnvelope, createDataEnvelope, createFailureEnvelope, createStreamHeaderEnvelope, createStreamRecordEnvelope, createStreamSuccessEnvelope, createUsageFailureEnvelope, } from "#/outcome-wire";
+/**
+ * 执行同一契约签发的调用：验证 raw input，将模式的验证结果和宿主依赖交给 handler，
+ * 再验证、投影结果并顺序等待宿主写入。帮助、版本和用法失败不执行业务 handler。
+ *
+ * 宿主负责参数来源、依赖构造、输出端口和真实进程退出；应 await 本函数，
+ * 等可控写入完成后再使用终止结果的 exitCode，不能提前结束进程。
+ *
+ * 消费者模式、handler、generator 或呈现器抛出的值保留原始身份；核心检测的契约违反
+ * 使用 ContractExecutionError，输出端口失败使用 CliWriteError。执行拒绝时不自动写诊断，
+ * 活动流会执行必要清理，已经写出的合法前缀不会撤回，也不会追加伪造的成功终态。
+ */
+// oxlint-disable-next-line typescript/consistent-return
+export async function executeCli(cliContract, options) {
+    const compiled = getCompiledCli(cliContract);
+    if (!invocationBelongsTo(options.invocation, cliContract)) {
+        throw new ContractExecutionError([
+            {
+                code: "invocationContractMismatch",
+                expectedCommand: compiled.root,
+                receivedCommand: options.invocation.command,
+            },
+        ]);
+    }
+    const command = compiled.commands[options.invocation.command];
+    if (command === undefined) {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    switch (options.invocation.kind) {
+        case "help": {
+            await writeCliOutput(options.write, {
+                destination: "stdout",
+                chunk: createHelpText(compiled, command),
+            });
+            return Object.freeze({
+                kind: "help",
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+                command: command.id,
+                exitCode: 0,
+            });
+        }
+        case "version": {
+            const version = compiled.contract.grammar.controls.version;
+            if (version === undefined) {
+                throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+            }
+            await writeCliOutput(options.write, {
+                destination: "stdout",
+                chunk: `${version.value}\n`,
+            });
+            return Object.freeze({
+                kind: "version",
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+                command: command.id,
+                exitCode: 0,
+            });
+        }
+        case "usageFailure": {
+            await writeUsageFailure(compiled, options.write, {
+                command: command.id,
+                issues: options.invocation.issues,
+                usage: options.invocation.usage.synopsis,
+            });
+            return Object.freeze({
+                kind: "usageFailure",
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 命令来自当前 Contract 的编译树，泛型身份在此恢复。
+                command: command.id,
+                issues: options.invocation.issues,
+                exitCode: compiled.usageFailureExitCode,
+            });
+        }
+        case "parsed": {
+            if (!isCompiledExecutable(command)) {
+                throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+            }
+            const validation = validateSynchronously(command.input, options.invocation.input, { command: command.id, location: "input" });
+            if (validation.issues !== undefined) {
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+                const issues = Object.freeze([
+                    Object.freeze({
+                        code: "inputRejected",
+                        evidence: Object.freeze(validation.issues.map(normalizeSchemaIssueEvidence)),
+                    }),
+                ]);
+                await writeUsageFailure(compiled, options.write, {
+                    command: command.id,
+                    issues,
+                    usage: command.usage.synopsis,
+                });
+                return Object.freeze({
+                    kind: "usageFailure",
+                    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 命令来自当前 Contract 的编译树，泛型身份在此恢复。
+                    command: command.id,
+                    issues,
+                    exitCode: compiled.usageFailureExitCode,
+                });
+            }
+            return executeApplicationResult(command, validation.value, options, options.invocation.outputFormat);
+        }
+    }
+}
+function createHelpText(compiled, command) {
+    const headings = compiled.contract.grammar.controls.help.headings;
+    const wording = compiled.contract.grammar.controls.help.wording;
+    const segments = [command.description];
+    const commands = Object.values(compiled.commands).filter((candidate) => candidate.parent === command.id);
+    const fields = isCommandGroup(command) ? [] : command.fields;
+    const usageConstraints = isCommandGroup(command)
+        ? []
+        : command.usageConstraints;
+    const positionalFields = fields.filter((field) => field.kind === "positional" || field.kind === "variadicPositional");
+    const optionFields = fields.filter((field) => field.kind !== "positional" && field.kind !== "variadicPositional");
+    const options = [
+        ...optionFields.map((field) => formatHelpField(field, wording)),
+        ...formatCoreControls(compiled),
+    ];
+    appendHelpSegment(segments, headings?.usage, [
+        helpLine(command.usage.synopsis),
+    ]);
+    appendHelpSegment(segments, headings?.commands, commands.map((candidate) => helpDetail(`${[candidate.name, ...candidate.aliases].join(", ")}${isCommandGroup(candidate) ? ` <${requireHelpFactWording(wording?.commandPlaceholder)}>` : ""}`, candidate.description)));
+    appendHelpSegment(segments, headings?.arguments, positionalFields.map((field) => formatHelpField(field, wording)));
+    appendHelpSegment(segments, headings?.options, options);
+    appendHelpSegment(segments, headings?.constraints, usageConstraints.map((constraint) => helpLine(formatUsageConstraint(constraint, wording))));
+    appendHelpSegment(segments, headings?.supplement, command.helpSupplement === undefined
+        ? []
+        : [{ kind: "lines", lines: command.helpSupplement }]);
+    return `${segments.join("\n\n")}\n`;
+}
+function isCommandGroup(command) {
+    return command.kind === "rootGroup" || command.kind === "commandGroup";
+}
+function helpLine(value) {
+    return { kind: "line", value };
+}
+function helpDetail(summary, detail) {
+    return { kind: "detail", summary, detail };
+}
+function appendHelpSegment(segments, heading, entries) {
+    if (entries.length === 0)
+        return;
+    const lines = heading === undefined ? [] : [heading];
+    for (const entry of entries) {
+        if (entry.kind === "line")
+            lines.push(`  ${entry.value}`);
+        else if (entry.kind === "detail")
+            lines.push(`  ${entry.summary}`, `    ${entry.detail}`);
+        else
+            lines.push(...entry.lines.map((line) => (line === "" ? "" : `  ${line}`)));
+    }
+    segments.push(lines.join("\n"));
+}
+function formatCoreControls(compiled) {
+    const help = compiled.contract.grammar.controls.help;
+    const version = compiled.contract.grammar.controls.version;
+    const output = compiled.contract.grammar.controls.output;
+    const versionEntry = version === undefined
+        ? undefined
+        : version.description === undefined
+            ? helpLine([version.longOption, version.shortAlias]
+                .filter((spelling) => spelling !== undefined)
+                .join(", "))
+            : helpDetail([version.longOption, version.shortAlias]
+                .filter((spelling) => spelling !== undefined)
+                .join(", "), version.description);
+    return [
+        helpLine([help.longOption, help.shortAlias]
+            .filter((spelling) => spelling !== undefined)
+            .join(", ")),
+        ...(versionEntry === undefined ? [] : [versionEntry]),
+        ...(output.selector === undefined
+            ? []
+            : [
+                helpLine(`${output.selector} <${output.formats.join("|")}> ${renderHelpFactTemplate(help.wording?.choices, { choices: output.formats.map((format) => JSON.stringify(format)).join(", ") })} ${renderHelpFactTemplate(help.wording?.default, { value: JSON.stringify(output.defaultFormat) })}`),
+            ]),
+        ...Object.entries(output.compatibilityFlags ?? {}).map(([flag, format]) => helpLine(output.selector === undefined
+            ? `${flag} = ${format}`
+            : `${flag} = ${output.selector} ${format}`)),
+    ];
+}
+async function writeUsageFailure(compiled, write, failure) {
+    await writeCliOutput(write, {
+        destination: "stderr",
+        chunk: `${JSON.stringify(createUsageFailureEnvelope(failure.command, failure.issues, failure.usage, usageFailureHelpArgv(compiled.commands, failure.command)))}\n`,
+    });
+}
+function formatUsageConstraint(constraint, wording) {
+    if (constraint.kind === "requires")
+        return renderHelpFactTemplate(wording?.requires, {
+            field: constraint.field,
+            requires: constraint.requires,
+        });
+    if (constraint.kind === "exclusive")
+        return renderHelpFactTemplate(wording?.exclusive, {
+            fields: constraint.fields.join(", "),
+        });
+    return renderHelpFactTemplate(wording?.forbiddenCombination, {
+        values: constraint.values
+            .map(({ field, value }) => `${field}=${JSON.stringify(value)}`)
+            .join(", "),
+    });
+}
+function renderHelpFactTemplate(template, values) {
+    const factTemplate = requireHelpFactWording(template);
+    return factTemplate.replace(/\{([A-Za-z][A-Za-z0-9]*)\}/g, (_match, key) => {
+        const value = values[key];
+        if (value === undefined) {
+            throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+        }
+        return value;
+    });
+}
+function requireHelpFactWording(value) {
+    if (value === undefined) {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    return value;
+}
+function formatHelpField(field, wording) {
+    const cardinality = formatFieldUsage(field, true);
+    const choices = field.choices === undefined
+        ? ""
+        : ` ${renderHelpFactTemplate(wording?.choices, { choices: field.choices.map((choice) => JSON.stringify(choice)).join(", ") })}`;
+    const defaultValue = field.default === undefined
+        ? ""
+        : ` ${renderHelpFactTemplate(wording?.default, { value: JSON.stringify(field.default) })}`;
+    return helpDetail(`${cardinality}${choices}${defaultValue}`, field.description);
+}
+async function executeApplicationResult(compiled, input, options, outputFormat) {
+    const issuedOutcomeFacts = new WeakSet();
+    const successOutcome = compiled.success.kind === "completion"
+        ? {
+            completion: () => createCompletionFact(compiled.id, issuedOutcomeFacts),
+        }
+        : compiled.success.kind === "data"
+            ? {
+                data: Object.freeze(Object.fromEntries(Object.keys(compiled.success.variants).map((variant) => [
+                    variant,
+                    (payload) => createDataFact(compiled.id, variant, payload, issuedOutcomeFacts),
+                ]))),
+            }
+            : {
+                record: Object.freeze(Object.fromEntries(Object.keys(compiled.success.records).map((variant) => [
+                    variant,
+                    (payload) => createStreamRecordFact(compiled.id, variant, payload, issuedOutcomeFacts),
+                ]))),
+                streamSuccess: () => createStreamSuccessFact(compiled.id, issuedOutcomeFacts),
+            };
+    const outcome = Object.freeze({
+        ...successOutcome,
+        failure: Object.freeze(Object.fromEntries(Object.keys(compiled.failures).map((variant) => [
+            variant,
+            (payload) => createFailureFact(compiled.id, variant, payload, issuedOutcomeFacts),
+        ]))),
+    });
+    if (typeof compiled.handler !== "function") {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    const handlerResult = compiled.handler({
+        input,
+        dependencies: options.dependencies,
+        outcome,
+    });
+    if (compiled.success.kind === "stream") {
+        const generator = requireAsyncGenerator(handlerResult, compiled.id);
+        return executeStreamResult(compiled, generator, issuedOutcomeFacts, options, outputFormat);
+    }
+    const result = await handlerResult;
+    const projected = projectApplicationFact(compiled, result, issuedOutcomeFacts, outputFormat, "atomic");
+    await writeProjectedOutput(options.write, projected.output);
+    return Object.freeze({
+        kind: "applicationResult",
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 命令来自当前 Contract 的编译树，泛型身份在此恢复。
+        command: compiled.id,
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 结果经该命令的结果模式验证并由本次执行签发。
+        result: projected.result,
+        exitCode: projected.exitCode,
+    });
+}
+function requireAsyncGenerator(value, command) {
+    if (!hasAsyncGeneratorProtocol(value)) {
+        throwExecutionIssue({
+            code: "streamHandlerMustReturnAsyncGenerator",
+            command,
+        });
+    }
+    return value;
+}
+function hasAsyncGeneratorProtocol(value) {
+    try {
+        return (typeof value === "object" &&
+            value !== null &&
+            Symbol.asyncIterator in value &&
+            typeof value[Symbol.asyncIterator] === "function" &&
+            "next" in value &&
+            typeof value.next === "function" &&
+            "return" in value &&
+            typeof value.return === "function");
+    }
+    catch {
+        return false;
+    }
+}
+async function writeCliOutput(write, output) {
+    try {
+        await write(output);
+    }
+    catch (cause) {
+        throw new CliWriteError(output.destination, cause);
+    }
+}
+async function executeStreamResult(compiled, generator, issuedOutcomeFacts, options, outputFormat) {
+    if (compiled.success.kind !== "stream") {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    let active = true;
+    try {
+        if (outputFormat === "structured") {
+            await writeCliOutput(options.write, {
+                destination: "stdout",
+                chunk: `${JSON.stringify(createStreamHeaderEnvelope(compiled.id))}\n`,
+            });
+        }
+        for (;;) {
+            const step = await generator.next();
+            if (!step.done) {
+                const projected = projectApplicationFact(compiled, step.value, issuedOutcomeFacts, outputFormat, "record");
+                await writeProjectedOutput(options.write, projected.output);
+                continue;
+            }
+            active = false;
+            const projected = projectApplicationFact(compiled, step.value, issuedOutcomeFacts, outputFormat, "terminal");
+            await writeProjectedOutput(options.write, projected.output);
+            return Object.freeze({
+                kind: "applicationResult",
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 命令来自当前 Contract 的编译树，泛型身份在此恢复。
+                command: compiled.id,
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- 结果经该命令的结果模式验证并由本次执行签发。
+                result: projected.result,
+                exitCode: projected.exitCode,
+            });
+        }
+    }
+    catch (cause) {
+        if (active && typeof generator.return === "function") {
+            try {
+                await generator.return(undefined);
+            }
+            catch {
+                // 清理异常不能掩盖触发中断的写入或程序缺陷。
+            }
+        }
+        throw cause;
+    }
+}
+async function writeProjectedOutput(write, output) {
+    if (output !== undefined)
+        await writeCliOutput(write, output);
+}
+function projectApplicationFact(compiled, value, issuedOutcomeFacts, outputFormat, phase) {
+    if (!isIssuedOutcomeFact(value, issuedOutcomeFacts)) {
+        throwExecutionIssue({ code: "invalidOutcomeFact", command: compiled.id });
+    }
+    const result = value;
+    if (phase === "record") {
+        if (result.kind !== "record" || compiled.success.kind !== "stream") {
+            throwExecutionIssue({
+                code: "outcomeKindMismatch",
+                command: compiled.id,
+                expected: "stream",
+                received: result.kind,
+            });
+        }
+        const record = compiled.success.records[result.variant];
+        if (record === undefined) {
+            throwExecutionIssue({
+                code: "undeclaredOutcomeVariant",
+                command: compiled.id,
+                location: "record",
+                variant: result.variant,
+            });
+        }
+        const data = projectAtomicData(record.schema, result.data, {
+            command: compiled.id,
+            location: "record",
+            variant: result.variant,
+        });
+        const chunk = outputFormat === "structured"
+            ? `${JSON.stringify(createStreamRecordEnvelope(result.variant, data))}\n`
+            : formatStreamRecordText(record.text, data);
+        return { result, output: { destination: "stdout", chunk }, exitCode: 0 };
+    }
+    if (phase === "terminal" && result.kind === "streamSuccess") {
+        if (compiled.success.kind !== "stream") {
+            throwExecutionIssue({
+                code: "outcomeKindMismatch",
+                command: compiled.id,
+                expected: "stream",
+                received: result.kind,
+            });
+        }
+        let chunk;
+        if (outputFormat === "structured")
+            chunk = `${JSON.stringify(createStreamSuccessEnvelope())}\n`;
+        else {
+            const presenter = compiled.success.text;
+            if (typeof presenter !== "function")
+                throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+            chunk = formatCompletionText(presenter());
+        }
+        return {
+            result,
+            output: chunk === "" ? undefined : { destination: "stdout", chunk },
+            exitCode: 0,
+        };
+    }
+    if (phase === "terminal" && result.kind !== "failure") {
+        throwExecutionIssue({
+            code: "outcomeKindMismatch",
+            command: compiled.id,
+            expected: "stream",
+            received: result.kind,
+        });
+    }
+    if (result.kind === "failure") {
+        const failure = compiled.failures[result.variant];
+        if (failure === undefined) {
+            throwExecutionIssue({
+                code: "undeclaredOutcomeVariant",
+                command: compiled.id,
+                location: "failure",
+                variant: result.variant,
+            });
+        }
+        const data = projectAtomicData(failure.schema, result.data, {
+            command: compiled.id,
+            location: "failure",
+            variant: result.variant,
+        });
+        const normalized = createFailureFact(compiled.id, result.variant, data, issuedOutcomeFacts);
+        if (outputFormat === "text") {
+            const presenter = failure.text;
+            if (typeof presenter !== "function") {
+                throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+            }
+            return {
+                result: normalized,
+                output: {
+                    destination: "stderr",
+                    chunk: formatAtomicText(presenter(data)),
+                },
+                exitCode: failure.exitCode,
+            };
+        }
+        return {
+            result: normalized,
+            output: {
+                destination: "stderr",
+                chunk: `${JSON.stringify(createFailureEnvelope(compiled.id, result.variant, data))}\n`,
+            },
+            exitCode: failure.exitCode,
+        };
+    }
+    if (compiled.success.kind === "completion") {
+        if (result.kind !== "completion") {
+            throwExecutionIssue({
+                code: "outcomeKindMismatch",
+                command: compiled.id,
+                expected: "completion",
+                received: result.kind,
+            });
+        }
+        if (outputFormat === "text") {
+            const presenter = compiled.success.text;
+            if (typeof presenter !== "function") {
+                throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+            }
+            const chunk = formatCompletionText(presenter());
+            return {
+                result,
+                output: chunk === "" ? undefined : { destination: "stdout", chunk },
+                exitCode: 0,
+            };
+        }
+        return {
+            result,
+            output: {
+                destination: "stdout",
+                chunk: `${JSON.stringify(createCompletionEnvelope(compiled.id))}\n`,
+            },
+            exitCode: 0,
+        };
+    }
+    if (compiled.success.kind !== "data" || result.kind !== "data") {
+        throwExecutionIssue({
+            code: "outcomeKindMismatch",
+            command: compiled.id,
+            expected: "data",
+            received: result.kind,
+        });
+    }
+    const variant = compiled.success.variants[result.variant];
+    if (variant === undefined) {
+        throwExecutionIssue({
+            code: "undeclaredOutcomeVariant",
+            command: compiled.id,
+            location: "data",
+            variant: result.variant,
+        });
+    }
+    const data = projectAtomicData(variant.schema, result.data, {
+        command: compiled.id,
+        location: "data",
+        variant: result.variant,
+    });
+    const normalized = createDataFact(compiled.id, result.variant, data, issuedOutcomeFacts);
+    if (outputFormat === "text") {
+        const presenter = variant.text;
+        if (typeof presenter !== "function") {
+            throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+        }
+        return {
+            result: normalized,
+            output: {
+                destination: "stdout",
+                chunk: formatAtomicText(presenter(data)),
+            },
+            exitCode: variant.exitCode,
+        };
+    }
+    return {
+        result: normalized,
+        output: {
+            destination: "stdout",
+            chunk: `${JSON.stringify(createDataEnvelope(compiled.id, result.variant, data))}\n`,
+        },
+        exitCode: variant.exitCode,
+    };
+}
+function formatCompletionText(value) {
+    if (isSilentText(value))
+        return "";
+    return formatAtomicText(value);
+}
+function formatTextLine(value) {
+    if (!isIssuedTextProjection(value) ||
+        value.kind !== "line" ||
+        typeof value.value !== "string" ||
+        value.value.length === 0 ||
+        value.value.includes("\r") ||
+        value.value.includes("\n") ||
+        value.value.includes("\0")) {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    return `${value.value}\n`;
+}
+function formatAtomicText(value) {
+    if (isIssuedTextProjection(value) && value.kind === "lines") {
+        return formatTextLines(value.lines);
+    }
+    return formatTextLine(value);
+}
+function formatTextLines(value) {
+    if (!Array.isArray(value) ||
+        value.every((line) => typeof line === "string" && line.length === 0) ||
+        value.some((line) => typeof line !== "string" ||
+            line.includes("\r") ||
+            line.includes("\n") ||
+            line.includes("\0"))) {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    return `${value.join("\n")}\n`;
+}
+function formatStreamRecordText(presenter, data) {
+    if (typeof presenter !== "function") {
+        throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+    }
+    const value = presenter(data);
+    if (isIssuedTextProjection(value) && value.kind === "fragment") {
+        if (typeof value.value !== "string" ||
+            value.value.length === 0 ||
+            value.value.includes("\0")) {
+            throw new ContractExecutionError([{ code: "invalidCliContract" }]);
+        }
+        return value.value;
+    }
+    return formatTextLine(value);
+}
+function isSilentText(value) {
+    return isIssuedTextProjection(value) && value.kind === "silent";
+}
+// oxlint-disable-next-line typescript/consistent-return -- 验证失败分支通过 throwExecutionIssue 以 never 终止。
+function projectAtomicData(schema, value, target) {
+    const validation = validateSynchronously(schema, value, target);
+    if (validation.issues !== undefined) {
+        throwExecutionIssue({
+            code: "outputSchemaRejected",
+            ...target,
+            expected: "schemaAccepted",
+            received: "schemaRejected",
+        });
+    }
+    try {
+        return copyJsonValue(validation.value);
+    }
+    catch {
+        throwExecutionIssue({
+            code: "invalidJsonValue",
+            ...target,
+            expected: "jsonValue",
+            received: "nonJsonValue",
+        });
+    }
+}
+function validateSynchronously(schema, value, target) {
+    const result = schema["~standard"].validate(value);
+    if (isPromise(result)) {
+        throwExecutionIssue({
+            code: "asynchronousSchemaValidation",
+            ...target,
+            expected: "synchronousStandardResult",
+            received: "promise",
+        });
+    }
+    if (!isStandardResult(result)) {
+        throwExecutionIssue({
+            code: "invalidStandardResult",
+            ...target,
+            expected: "standardResult",
+            received: describeValueKind(result),
+        });
+    }
+    return result;
+}
+function describeValueKind(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function throwExecutionIssue(issue) {
+    throw new ContractExecutionError([issue]);
+}
+function isStandardResult(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    if (!("issues" in value) || value.issues === undefined) {
+        return "value" in value;
+    }
+    return (!("value" in value) &&
+        Array.isArray(value.issues) &&
+        value.issues.length > 0 &&
+        value.issues.every(isStandardIssue));
+}
+function isStandardIssue(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        !("message" in value) ||
+        typeof value.message !== "string") {
+        return false;
+    }
+    if (!("path" in value) || value.path === undefined) {
+        return true;
+    }
+    return (Array.isArray(value.path) &&
+        value.path.every((segment) => {
+            const key = typeof segment === "object" && segment !== null && "key" in segment
+                ? segment.key
+                : segment;
+            return (typeof key === "string" ||
+                typeof key === "number" ||
+                typeof key === "symbol");
+        }));
+}
+function normalizeSchemaIssueEvidence(issue) {
+    const path = normalizeSchemaPath(issue.path);
+    return Object.freeze(path === undefined
+        ? { message: issue.message }
+        : { message: issue.message, path });
+}
+function normalizeSchemaPath(path) {
+    if (path === undefined) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const segment of path) {
+        const key = typeof segment === "object" && segment !== null ? segment.key : segment;
+        if (typeof key !== "string" &&
+            !(typeof key === "number" && Number.isFinite(key))) {
+            return undefined;
+        }
+        normalized.push(key);
+    }
+    return Object.freeze(normalized);
+}
+function isPromise(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}