toolcraft 0.0.232 → 0.0.233

package/dist/sdk.js

@@ -1,16 +1,23 @@
 import "./node-require-shim.js";
+import { cloneDefaultValue, formatIssues, isJsonValue, isPlainRecord, nativeJsonSchema, unicodeLength, validate as validateSchema } from "toolcraft-schema";
 import { ToolcraftBugError, UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
 import { writeErrorReport } from "./error-report.js";
 import { assertHumanInLoopWired, mergeApprovalsRoot } from "./human-in-loop/wiring.js";
 import { hasMcpProxyGroups, resolveMcpProxies } from "./mcp-proxy.js";
+import { isMCPResult } from "./mcp-result.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
+import { validateAppliedDefault } from "./applied-default.js";
 import { filterSchemaForScope } from "./schema-scope.js";
+import { validateCasedSchemaMembers } from "./schema-member-names.js";
 import { enableSourceMaps } from "./stack-trim.js";
 import { suggest } from "./suggest.js";
 import { throwValidationErrors } from "./validation-errors.js";
+import { resolveDiscriminatedBranch } from "./discriminator.js";
+import { validateUnionSchema } from "./union-validation.js";
 import { createRuntimeLogger } from "./runtime-logging.js";
 import { createEnv, createFs, validateServices } from "./runtime/io.js";
 import { createManagedStream } from "./stream.js";
+export { mergeApprovalsRoot };
 function splitWords(value) {
     const words = [];
     let current = "";
@@ -59,9 +66,6 @@ function unwrapOptional(schema) {
 function isOptional(schema) {
     return schema.kind === "optional";
 }
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function formatAvailableList(values) {
     return `Available: ${[...values].sort().join(", ")}.`;
 }
@@ -83,15 +87,121 @@ function describeReceived(value) {
     if (Array.isArray(value))
         return `array(${value.length})`;
     if (typeof value === "object")
-        return "object";
+        return isPlainRecord(value) ? "object" : "non-plain object";
     if (typeof value === "string") {
         const s = value.length > 40 ? `${value.slice(0, 40)}…` : value;
         return `${JSON.stringify(s)}`;
     }
-    return JSON.stringify(value);
+    if (typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") {
+        return typeof value;
+    }
+    return String(value);
+}
+function nativeSDKFields(schema) {
+    const shapes = schema.kind === "object" ? [schema.shape]
+        : schema.kind === "union" ? schema.branches.map((branch) => branch.shape)
+            : schema.kind === "oneOf" ? Object.values(schema.branches).map((branch) => branch.shape) : [];
+    return new Map(shapes.flatMap((shape) => Object.entries(shape).map(([key, child]) => [formatSegment(key), [key, child]])));
+}
+function omitNativeOptionalUndefined(schema, value, depth = 0, budget = { nodes: 10_000 }) {
+    if (depth > 64 || --budget.nodes < 0)
+        return value;
+    const canonical = unwrapOptional(schema);
+    if (canonical.kind === "array" && Array.isArray(value)) {
+        if (value.length > 10_000)
+            return value;
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        for (let index = 0; index < value.length; index++) {
+            const property = descriptors[String(index)];
+            if (property !== undefined && "value" in property) {
+                property.value = omitNativeOptionalUndefined(canonical.item, property.value, depth + 1, budget);
+            }
+        }
+        const output = Object.defineProperties([], descriptors);
+        Object.setPrototypeOf(output, Object.getPrototypeOf(value));
+        return output;
+    }
+    if (canonical.kind === "record" && isPlainRecord(value)) {
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        for (const property of Object.values(descriptors))
+            if ("value" in property) {
+                property.value = omitNativeOptionalUndefined(canonical.value, property.value, depth + 1, budget);
+            }
+        return Object.create(Object.getPrototypeOf(value), descriptors);
+    }
+    if (!isPlainRecord(value) || (canonical.kind !== "object" && canonical.kind !== "union" && canonical.kind !== "oneOf"))
+        return value;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const [inputKey, [, field]] of nativeSDKFields(canonical)) {
+        const property = descriptors[inputKey];
+        if (property === undefined || !("value" in property))
+            continue;
+        if (property.value === undefined && isOptional(field))
+            delete descriptors[inputKey];
+        else
+            property.value = omitNativeOptionalUndefined(field, property.value, depth + 1, budget);
+    }
+    return Object.create(Object.getPrototypeOf(value), descriptors);
+}
+function normalizeNativeSDKKeys(schema, value) {
+    const canonical = unwrapOptional(schema);
+    if (canonical.kind === "array" && Array.isArray(value)) {
+        return value.map((item) => normalizeNativeSDKKeys(canonical.item, item));
+    }
+    if (canonical.kind === "record" && isPlainRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalizeNativeSDKKeys(canonical.value, item)]));
+    }
+    if ((canonical.kind === "object" || canonical.kind === "union" || canonical.kind === "oneOf") && isPlainRecord(value)) {
+        const fields = nativeSDKFields(canonical);
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            const field = fields.get(key);
+            const outputKey = field?.[0] ?? key;
+            if (Object.hasOwn(result, outputKey))
+                throw new UserError(`Multiple parameters map to "${outputKey}".`);
+            Object.defineProperty(result, outputKey, {
+                value: field === undefined ? item : normalizeNativeSDKKeys(field[1], item),
+                enumerable: true, configurable: true, writable: true
+            });
+        }
+        if (canonical.kind === "object") {
+            for (const [key, child] of Object.entries(canonical.shape)) {
+                const field = unwrapOptional(child);
+                if (!Object.hasOwn(result, key) && field.default !== undefined)
+                    Object.defineProperty(result, key, {
+                        value: normalizeNativeSDKKeys(field, cloneDefaultValue(field.default)),
+                        enumerable: true, configurable: true, writable: true
+                    });
+            }
+        }
+        return result;
+    }
+    return value;
+}
+function validateNativeSDKValue(schema, value, label, errors) {
+    value = omitNativeOptionalUndefined(schema, value);
+    if (!isJsonValue(value)) {
+        errors.push({ path: label, message: `Invalid value for "${label}". Expected a JSON value.` });
+        return value;
+    }
+    const normalized = normalizeNativeSDKKeys(schema, value);
+    const validation = validateSchema(schema, normalized);
+    if (!validation.ok) {
+        errors.push(...validation.issues.map((issue) => ({
+            path: [label, ...issue.path].filter((part) => part !== "").join("."),
+            message: formatIssues([issue])
+        })));
+    }
+    return normalized;
 }
 function validateSchemaValue(schema, value, label, errors) {
     const unwrappedSchema = unwrapOptional(schema);
+    if (isOptional(schema) && value === undefined) {
+        return validateAppliedDefault(unwrappedSchema, label, errors);
+    }
+    if (unwrappedSchema[nativeJsonSchema] !== undefined) {
+        return validateNativeSDKValue(unwrappedSchema, value, label, errors);
+    }
     if (value === null && unwrappedSchema.nullable === true) {
         return null;
     }
@@ -137,13 +247,23 @@ function validateSchemaValue(schema, value, label, errors) {
                 return value;
             }
             validateArrayConstraints(unwrappedSchema, value, label, errors);
-            return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`, errors));
+            return Array.from({ length: value.length }, (_item, index) => validateSchemaValue(unwrappedSchema.item, value[index], `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, label, errors);
-        case "json":
+        case "json": {
+            const validation = validateSchema(unwrappedSchema, value);
+            if (!validation.ok) {
+                for (const issue of validation.issues) {
+                    errors.push({
+                        path: label,
+                        message: `Invalid value for "${label}". Expected a JSON value, got ${issue.received}.`
+                    });
+                }
+            }
             return value;
+        }
         case "record": {
-            if (!isPlainObject(value)) {
+            if (!isPlainRecord(value)) {
                 errors.push({
                     path: label,
                     message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
@@ -156,42 +276,32 @@ function validateSchemaValue(schema, value, label, errors) {
             ]));
         }
         case "oneOf": {
-            if (!isPlainObject(value)) {
+            const resolved = resolveDiscriminatedBranch(unwrappedSchema, value, formatSegment(unwrappedSchema.discriminator), label, errors);
+            if (resolved === undefined) {
                 return value;
             }
-            const discriminator = value[unwrappedSchema.discriminator];
-            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
-            if (branch === undefined) {
-                return value;
-            }
-            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
-            void ignoredDiscriminator;
             return {
-                [unwrappedSchema.discriminator]: discriminator,
-                ...validateObjectSchema(branch, branchValue, label, errors)
+                ...validateObjectSchema(resolved.branch, resolved.value, label, errors),
+                [unwrappedSchema.discriminator]: resolved.discriminator
             };
         }
         case "union": {
-            if (!isPlainObject(value)) {
-                return value;
-            }
-            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
-                Object.prototype.hasOwnProperty.call(value, formatSegment(key))));
-            return branch === undefined ? value : validateObjectSchema(branch, value, label, errors);
+            return validateUnionSchema(unwrappedSchema, value, label, errors, (branch, branchErrors) => validateObjectSchema(branch, value, label, branchErrors));
         }
     }
 }
 function validateStringConstraints(schema, value, label, errors) {
-    if (schema.minLength !== undefined && value.length < schema.minLength) {
+    const length = unicodeLength(value);
+    if (schema.minLength !== undefined && length < schema.minLength) {
         errors.push({
             path: label,
-            message: `Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`
+            message: `Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${length}.`
         });
     }
-    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+    if (schema.maxLength !== undefined && length > schema.maxLength) {
         errors.push({
             path: label,
-            message: `Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`
+            message: `Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${length}.`
         });
     }
     if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
@@ -216,7 +326,10 @@ function validateArrayConstraints(schema, value, label, errors) {
     }
 }
 export function validateObjectSchema(schema, value, label, errors) {
-    if (!isPlainObject(value)) {
+    if (schema[nativeJsonSchema] !== undefined) {
+        return validateNativeSDKValue(schema, value, label, errors);
+    }
+    if (!isPlainRecord(value)) {
         errors.push({
             path: label,
             message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
@@ -250,10 +363,10 @@ export function validateObjectSchema(schema, value, label, errors) {
         const childSchema = unwrapOptional(rawChildSchema);
         const hasValue = Object.prototype.hasOwnProperty.call(value, inputKey);
         const fieldLabel = label.length === 0 ? inputKey : `${label}.${inputKey}`;
-        if (!hasValue) {
+        if (!hasValue || (isOptional(rawChildSchema) && value[inputKey] === undefined)) {
             if (childSchema.default !== undefined) {
                 Object.defineProperty(result, outputKey, {
-                    value: childSchema.default,
+                    value: validateAppliedDefault(childSchema, fieldLabel, errors),
                     enumerable: true,
                     configurable: true,
                     writable: true
@@ -261,6 +374,13 @@ export function validateObjectSchema(schema, value, label, errors) {
                 continue;
             }
             if (isOptional(rawChildSchema)) {
+                if (inputKey !== outputKey && Object.hasOwn(result, outputKey)) {
+                    const aliasLabel = label.length === 0 ? outputKey : `${label}.${outputKey}`;
+                    errors.push({
+                        path: aliasLabel,
+                        message: `Unexpected parameter "${aliasLabel}". Use "${fieldLabel}" for this declared parameter.`
+                    });
+                }
                 continue;
             }
             errors.push({ path: fieldLabel, message: `Missing required parameter "${fieldLabel}".` });
@@ -275,21 +395,6 @@ export function validateObjectSchema(schema, value, label, errors) {
     }
     return result;
 }
-function validateUniqueSDKParameterMembers(schema) {
-    const sourceKeysByMember = new Map();
-    for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
-        const member = formatSegment(key);
-        const existingKey = sourceKeysByMember.get(member);
-        if (existingKey !== undefined) {
-            throw new UserError(`Parameters "${existingKey}" and "${key}" use conflicting SDK member "${member}".`);
-        }
-        sourceKeysByMember.set(member, key);
-        const childSchema = unwrapOptional(rawChildSchema);
-        if (childSchema.kind === "object") {
-            validateUniqueSDKParameterMembers(childSchema);
-        }
-    }
-}
 function validateSDKArguments(schema, argumentsValue) {
     const errors = [];
     const result = validateObjectSchema(schema, argumentsValue ?? {}, "", errors);
@@ -330,7 +435,7 @@ function createResolvedSDK(root, options = {}) {
         if (node.kind === "command") {
             const sdkParamsSchema = filterSchemaForScope(node.params, "sdk");
             if (sdkParamsSchema?.kind === "object") {
-                validateUniqueSDKParameterMembers(sdkParamsSchema);
+                validateCasedSchemaMembers(sdkParamsSchema, formatSegment, "SDK member");
             }
             if (node.stream !== undefined) {
                 return (params, streamOptions = {}) => createManagedStream({
@@ -419,9 +524,15 @@ function createResolvedSDK(root, options = {}) {
                         ...baseContext,
                         params: validatedParams
                     };
-                    return humanInLoop === undefined
+                    const result = humanInLoop === undefined
                         ? await node.handler(handlerContext)
                         : await humanInLoop.invoke(node, handlerContext, commandPath);
+                    if (node.result !== undefined && isMCPResult(result) && result.isError === true) {
+                        const text = result.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+                        const message = text || (result.structuredContent === undefined ? "Upstream tool failed." : JSON.stringify(result.structuredContent));
+                        throw new UserError(message, { cause: result });
+                    }
+                    return result;
                 }
                 catch (error) {
                     await writeErrorReport({
@@ -451,7 +562,7 @@ function createResolvedSDK(root, options = {}) {
             }
             else {
                 childValue = build(child, nextPath);
-                if (!isPlainObject(childValue) || Object.keys(childValue).length === 0) {
+                if (!isPlainRecord(childValue) || Object.keys(childValue).length === 0) {
                     continue;
                 }
             }
@@ -476,7 +587,10 @@ function createDeferredSDK(root, options) {
         sdkPromise ??= (async () => {
             await resolveMcpProxies(root, { projectRoot: options.projectRoot });
             return createResolvedSDK(root, options);
-        })();
+        })().catch((error) => {
+            sdkPromise = undefined;
+            throw error;
+        });
         return sdkPromise;
     };
     const resolvePath = async (path) => {

package/dist/stream.js

@@ -6,39 +6,32 @@ function validationMessage(schema, value) {
 }
 export function createManagedStream(options) {
     const controller = new AbortController();
-    let iterator;
     let iteratorPromise;
     let closePromise;
     let done = false;
-    const getIterator = async () => {
-        if (iterator !== undefined) {
-            return iterator;
-        }
-        iteratorPromise ??= options
-            .create(controller.signal, (event) => options.onStatus?.(event))
+    const getIterator = () => {
+        iteratorPromise ??= Promise.resolve()
+            .then(() => options.create(controller.signal, (event) => options.onStatus?.(event)))
             .then((iterable) => iterable[Symbol.asyncIterator]());
-        iterator = await iteratorPromise;
-        return iterator;
+        return iteratorPromise;
     };
-    const close = async (reason) => {
+    const close = (reason) => {
         if (closePromise !== undefined) {
             return closePromise;
         }
-        closePromise = (async () => {
-            controller.abort(reason);
-            options.signal?.removeEventListener("abort", abortFromConsumer);
-            if (done || (iterator === undefined && iteratorPromise === undefined)) {
-                done = true;
-                return;
-            }
-            const activeIterator = await getIterator();
-            done = true;
-            await activeIterator.return?.();
-        })();
+        const closingIterator = done ? undefined : iteratorPromise;
+        done = true;
+        options.signal?.removeEventListener("abort", abortFromConsumer);
+        closePromise = closingIterator === undefined
+            ? Promise.resolve()
+            : closingIterator.then(async (activeIterator) => {
+                await activeIterator.return?.();
+            }, () => undefined);
+        controller.abort(reason);
         return closePromise;
     };
     const abortFromConsumer = () => {
-        void close(options.signal?.reason);
+        void close(options.signal?.reason).catch(() => undefined);
     };
     if (options.signal?.aborted === true) {
         abortFromConsumer();
@@ -56,15 +49,23 @@ export function createManagedStream(options) {
                         await close(controller.signal.reason);
                         return { done: true, value: undefined };
                     }
-                    const activeIterator = await getIterator();
                     let result;
                     try {
+                        const activeIterator = await getIterator();
+                        if (done || controller.signal.aborted) {
+                            await close(controller.signal.reason);
+                            return { done: true, value: undefined };
+                        }
                         result = await activeIterator.next();
                     }
                     catch (error) {
                         await close(error);
                         throw error;
                     }
+                    if (controller.signal.aborted) {
+                        await close(controller.signal.reason);
+                        return { done: true, value: undefined };
+                    }
                     if (result.done === true) {
                         done = true;
                         options.signal?.removeEventListener("abort", abortFromConsumer);

package/dist/testing/diagnostic-value.d.ts

@@ -0,0 +1 @@
+export declare function formatDiagnosticValue(value: unknown): string;

package/dist/testing/diagnostic-value.js

@@ -0,0 +1,57 @@
+import { types } from "node:util";
+export function formatDiagnosticValue(value) {
+    const ancestors = new WeakSet();
+    let remaining = 100;
+    function render(current, depth) {
+        if (remaining <= 0)
+            return "…";
+        remaining -= 1;
+        if (current === null)
+            return "null";
+        if (current === undefined)
+            return "undefined";
+        if (typeof current === "string") {
+            return JSON.stringify(current.length > 1000 ? `${current.slice(0, 1000)}…` : current);
+        }
+        if (typeof current === "function")
+            return "[Function]";
+        if (typeof current === "bigint")
+            return `${current}n`;
+        if (typeof current !== "object")
+            return Object.is(current, -0) ? "-0" : String(current);
+        if (types.isProxy(current))
+            return "[Proxy]";
+        if (ancestors.has(current))
+            return "[Circular]";
+        const array = Array.isArray(current);
+        if (depth >= 4)
+            return array ? "[Array]" : "[Object]";
+        const keys = array
+            ? Array.from({ length: Math.min(current.length, 25) }, (_value, index) => String(index))
+            : Object.keys(current);
+        const count = array ? current.length : keys.length;
+        ancestors.add(current);
+        try {
+            const entries = keys.slice(0, 25).map((key) => {
+                const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                const rendered = descriptor === undefined
+                    ? "[Empty]"
+                    : "value" in descriptor ? render(descriptor.value, depth + 1) : "[Accessor]";
+                return array ? rendered : `${JSON.stringify(key)}:${rendered}`;
+            });
+            if (count > entries.length)
+                entries.push("…");
+            return array ? `[${entries.join(",")}]` : `{${entries.join(",")}}`;
+        }
+        finally {
+            ancestors.delete(current);
+        }
+    }
+    try {
+        const rendered = render(value, 0);
+        return rendered.length > 4000 ? `${rendered.slice(0, 4000)}…` : rendered;
+    }
+    catch {
+        return "[Uninspectable]";
+    }
+}

package/dist/testing/fakes.js

@@ -11,7 +11,7 @@ export function fakeService(stubs = {}) {
             }
             const stub = Reflect.get(target, property, receiver);
             if (typeof stub !== "function") {
-                if (stub !== undefined) {
+                if (stub !== undefined || property === "then") {
                     return stub;
                 }
                 return (...args) => {
@@ -63,6 +63,7 @@ export function fakeFetch(routes) {
     const fetch = async (input, init) => {
         const request = new Request(input, init);
         calls.push(request);
+        request.signal.throwIfAborted();
         const route = routes.find((candidate) => routeMatches(candidate, request));
         if (route === undefined) {
             const configuredRoutes = routes.map(routeDescription).join(", ") || "none";

package/dist/testing/harness.js

@@ -199,6 +199,7 @@ export function createCommandTestHarness(root, options = {}) {
                     env: Object.fromEntries(Object.entries(options.env ?? {}).flatMap(([key, value]) => value === undefined ? [] : [[key, value]])),
                     fs: memoryFs,
                     fetch: runtimeFetch,
+                    apiVersion: options.apiVersion,
                     logLevel: options.logLevel,
                     outputEmitter(entry) {
                         stdout += entry;

package/dist/testing/memory-fs.js

@@ -1,3 +1,9 @@
+const writeModes = new Map([
+    ...["r", "rs", "sr"].map((flag) => [flag, "read"]),
+    ...["r+", "rs+", "sr+"].map((flag) => [flag, "update"]),
+    ...["w", "w+", "wx", "xw", "wx+", "xw+"].map((flag) => [flag, "replace"]),
+    ...["a", "a+", "ax", "xa", "ax+", "xa+", "as", "sa", "as+", "sa+"].map((flag) => [flag, "append"])
+]);
 function missingFileError(syscall, path, dest) {
     const target = dest === undefined ? `'${path}'` : `'${path}' -> '${dest}'`;
     const error = new Error(`ENOENT: no such file or directory, ${syscall} ${target}`);
@@ -22,7 +28,42 @@ export function createMemoryFs(files = {}) {
             return value.toString(encoding);
         },
         async writeFile(path, value, options) {
-            contents.set(path, Buffer.from(value, options?.encoding ?? "utf8"));
+            const bytes = Buffer.from(value, options?.encoding ?? "utf8");
+            const flag = options?.flag || "w";
+            const mode = writeModes.get(flag);
+            if (mode === undefined) {
+                throw Object.assign(new TypeError(`The argument 'flags' is invalid. Received '${flag}'`), {
+                    code: "ERR_INVALID_ARG_VALUE"
+                });
+            }
+            const previous = contents.get(path);
+            if (flag.includes("x") && previous !== undefined) {
+                throw Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), {
+                    code: "EEXIST",
+                    errno: -17,
+                    syscall: "open",
+                    path
+                });
+            }
+            if ((mode === "read" || mode === "update") && previous === undefined) {
+                throw missingFileError("open", path);
+            }
+            if (mode === "read" && bytes.length > 0) {
+                throw Object.assign(new Error("EBADF: bad file descriptor, write"), {
+                    code: "EBADF",
+                    errno: -9,
+                    syscall: "write"
+                });
+            }
+            if (mode === "append" && previous !== undefined) {
+                contents.set(path, Buffer.concat([previous, bytes]));
+            }
+            else if (mode === "update" && previous !== undefined) {
+                contents.set(path, Buffer.concat([bytes, previous.subarray(bytes.length)]));
+            }
+            else if (mode !== "read") {
+                contents.set(path, bytes);
+            }
             changeLog.push({ op: "writeFile", path });
         },
         async exists(path) {

package/dist/testing/parity.js

@@ -1,10 +1,11 @@
-import { isDeepStrictEqual } from "node:util";
+import { isDeepStrictEqual, types } from "node:util";
 import { McpClient, McpError, ERROR_INVALID_PARAMS, createSdkTestPair } from "tiny-mcp-client";
 import { runCLI } from "../cli.js";
 import { UserError } from "../index.js";
 import { createMCPServer } from "../mcp.js";
 import { filterSchemaForScope } from "../schema-scope.js";
 import { createSDK } from "../sdk.js";
+import { formatDiagnosticValue } from "./diagnostic-value.js";
 class SurfaceScopeError extends Error {
     constructor(surface, path) {
         super(`Command "${path.join(" ")}" is filtered out of the ${surface} surface.`);
@@ -338,11 +339,53 @@ async function runCLISurface(root, resolved, params, options, reference) {
         process.exitCode = previousExitCode;
     }
 }
+const domExceptionMessageGetter = typeof DOMException === "undefined"
+    ? undefined
+    : Object.getOwnPropertyDescriptor(DOMException.prototype, "message")?.get;
+function nativeDOMExceptionMessage(error) {
+    if (typeof error !== "object" || error === null || types.isProxy(error))
+        return undefined;
+    try {
+        return domExceptionMessageGetter?.call(error);
+    }
+    catch {
+        return undefined;
+    }
+}
+function propertyDescriptor(value, name) {
+    let current = value;
+    while (current !== null &&
+        (typeof current === "object" || typeof current === "function") &&
+        !types.isProxy(current)) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, name);
+        if (descriptor !== undefined)
+            return descriptor;
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+}
 function errorIdentity(error) {
-    if (error instanceof Error) {
-        return { name: error.constructor.name, message: error.message };
+    const domMessage = nativeDOMExceptionMessage(error);
+    if (types.isNativeError(error) || domMessage !== undefined) {
+        const prototype = Object.getPrototypeOf(error);
+        const constructor = propertyDescriptor(prototype, "constructor")?.value;
+        const name = typeof constructor === "function" && !types.isProxy(constructor)
+            ? Object.getOwnPropertyDescriptor(constructor, "name")?.value
+            : undefined;
+        const descriptor = propertyDescriptor(error, "message");
+        const message = descriptor === undefined
+            ? ""
+            : "value" in descriptor
+                ? typeof descriptor.value === "string" ? descriptor.value : formatDiagnosticValue(descriptor.value)
+                : descriptor.get === domExceptionMessageGetter && domMessage !== undefined
+                    ? domMessage
+                    : "[Accessor]";
+        return { name: typeof name === "string" ? name : "Error", message };
     }
-    return { name: typeof error, message: String(error) };
+    return {
+        name: typeof error,
+        message: typeof error === "string" ? error : formatDiagnosticValue(error)
+    };
 }
 function outcomesAgree(left, right) {
     if (left.ok !== right.ok) {
@@ -355,10 +398,11 @@ function outcomesAgree(left, right) {
 }
 function describeOutcome(surface, outcome) {
     if (outcome.ok) {
-        return `${surface}: ok ${JSON.stringify(outcome.value)}`;
+        return `${surface}: ok ${formatDiagnosticValue(outcome.value)}`;
     }
     const error = errorIdentity(outcome.error);
-    return `${surface}: error ${error.name}: ${error.message}`;
+    const description = `${surface}: error ${error.name}: ${error.message}`;
+    return description.length > 4000 ? `${description.slice(0, 4000)}…` : description;
 }
 export async function runParity(root, resolved, params, options) {
     const sdk = await runSDK(root, resolved, params, options);

package/dist/union-validation.d.ts

@@ -0,0 +1,5 @@
+import { type AnySchema, type ObjectSchema } from "toolcraft-schema";
+import type { ValidationError } from "./validation-errors.js";
+export declare function validateUnionSchema(schema: Extract<AnySchema, {
+    kind: "union";
+}>, value: unknown, label: string, errors: ValidationError[], validateBranch: (branch: ObjectSchema<any>, branchErrors: ValidationError[]) => Record<string, unknown>): unknown;