@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/dist/sdk.js

@@ -1,27 +1,23 @@
-import { access, lstat, readFile, rename, unlink, writeFile } from "node:fs/promises";
+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 { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
-import { invokeWithHumanInLoop } from "./human-in-loop/index.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";
-const RESERVED_SERVICE_NAMES = new Set([
-    "params",
-    "secrets",
-    "fetch",
-    "fs",
-    "env",
-    "diagnostics",
-    "progress",
-    "runtimeOptions",
-    "root"
-]);
-const RESERVED_SERVICE_NAMES_MESSAGE = "Available reserved names: params, secrets, fetch, fs, env, diagnostics, progress, runtimeOptions, root.";
+import { createEnv, createFs, validateServices } from "./runtime/io.js";
+import { createManagedStream } from "./stream.js";
+export { mergeApprovalsRoot };
 function splitWords(value) {
     const words = [];
     let current = "";
@@ -70,43 +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 createFs() {
-    return {
-        readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents, options) => {
-            await writeFile(path, contents, options);
-        },
-        exists: async (path) => {
-            try {
-                await access(path);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-        lstat: async (path) => lstat(path),
-        rename: async (fromPath, toPath) => rename(fromPath, toPath),
-        unlink: async (path) => unlink(path)
-    };
-}
-function createEnv(values = process.env) {
-    return {
-        get(key) {
-            return values[key];
-        }
-    };
-}
-function validateServices(services) {
-    for (const name of Object.keys(services)) {
-        if (RESERVED_SERVICE_NAMES.has(name)) {
-            throw new Error(`Service name "${name}" is reserved. Choose a different name. ${RESERVED_SERVICE_NAMES_MESSAGE}`);
-        }
-    }
-}
 function formatAvailableList(values) {
     return `Available: ${[...values].sort().join(", ")}.`;
 }
@@ -128,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;
     }
@@ -182,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)}.`
@@ -201,42 +276,32 @@ function validateSchemaValue(schema, value, label, errors) {
             ]));
         }
         case "oneOf": {
-            if (!isPlainObject(value)) {
-                return value;
-            }
-            const discriminator = value[unwrappedSchema.discriminator];
-            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
-            if (branch === undefined) {
+            const resolved = resolveDiscriminatedBranch(unwrappedSchema, value, formatSegment(unwrappedSchema.discriminator), label, errors);
+            if (resolved === 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)) {
@@ -260,8 +325,11 @@ function validateArrayConstraints(schema, value, label, errors) {
         });
     }
 }
-function validateObjectSchema(schema, value, label, errors) {
-    if (!isPlainObject(value)) {
+export function validateObjectSchema(schema, value, label, errors) {
+    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)}.`
@@ -295,10 +363,10 @@ 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
@@ -306,6 +374,13 @@ 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}".` });
@@ -320,21 +395,6 @@ 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);
@@ -354,7 +414,8 @@ function defineMember(target, key, value) {
 }
 export function createSDK(root, options = {}) {
     enableSourceMaps();
-    const mergedRoot = options.approvals === true ? mergeApprovalsGroup(root) : root;
+    const mergedRoot = mergeApprovalsRoot(root, options);
+    assertHumanInLoopWired(mergedRoot, options.humanInLoop);
     if (!hasMcpProxyGroups(mergedRoot)) {
         return createResolvedSDK(mergedRoot, options);
     }
@@ -362,7 +423,7 @@ export function createSDK(root, options = {}) {
 }
 function createResolvedSDK(root, options = {}) {
     const services = options.services ?? {};
-    const runtimeOptions = options.humanInLoop ?? {};
+    const humanInLoop = options.humanInLoop;
     const runtimeFetch = options.fetch ?? globalThis.fetch;
     const diagnostics = createRuntimeLogger({
         level: options.logLevel,
@@ -374,39 +435,104 @@ 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({
+                    eventSchema: node.stream.event,
+                    ...streamOptions,
+                    async create(signal, status) {
+                        const commandPath = [...path, node.name].join(".");
+                        let secrets;
+                        let validatedParams;
+                        try {
+                            secrets = resolveCommandSecrets(node, options.env);
+                            const baseContext = {
+                                ...services,
+                                humanInLoop,
+                                root,
+                                secrets,
+                                fetch: runtimeFetch,
+                                fs: createFs(options.fs),
+                                env: createEnv(options.env),
+                                diagnostics,
+                                progress(message) {
+                                    diagnostics.emit({ level: "info", message, category: "progress" });
+                                }
+                            };
+                            await assertCommandRequirements(node, { ...baseContext, params: undefined }, { apiVersion: options.apiVersion, env: options.env });
+                            const paramsSchema = filterSchemaForScope(node.params, "sdk");
+                            if (paramsSchema === undefined || paramsSchema.kind !== "object") {
+                                throw new ToolcraftBugError(`command "${node.name}" must define an object params schema for SDK.`);
+                            }
+                            validatedParams = validateSDKArguments(paramsSchema, params);
+                            return await node.handler({
+                                ...baseContext,
+                                params: validatedParams,
+                                signal,
+                                status,
+                                async refreshSecrets() {
+                                    return resolveCommandSecrets(node, options.env);
+                                }
+                            });
+                        }
+                        catch (error) {
+                            await writeErrorReport({
+                                command: node,
+                                commandPath,
+                                env: process.env,
+                                error,
+                                errorReports: options.errorReports,
+                                params: validatedParams,
+                                projectRoot: options.projectRoot,
+                                secrets
+                            });
+                            throw error;
+                        }
+                    }
+                });
             }
             return async (params) => {
                 const commandPath = [...path, node.name].join(".");
                 let secrets;
                 let validatedParams;
                 try {
-                    secrets = resolveCommandSecrets(node);
+                    secrets = resolveCommandSecrets(node, options.env);
                     const baseContext = {
                         ...services,
-                        runtimeOptions,
+                        humanInLoop,
                         root,
                         secrets,
                         fetch: runtimeFetch,
-                        fs: createFs(),
-                        env: createEnv(),
+                        fs: createFs(options.fs),
+                        env: createEnv(options.env),
                         diagnostics,
                         progress(message) {
                             diagnostics.emit({ level: "info", message, category: "progress" });
                         }
                     };
                     await assertCommandRequirements(node, { ...baseContext, params: undefined }, {
-                        apiVersion: options.apiVersion
+                        apiVersion: options.apiVersion,
+                        env: options.env
                     });
                     const paramsSchema = filterSchemaForScope(node.params, "sdk");
                     if (paramsSchema === undefined || paramsSchema.kind !== "object") {
                         throw new ToolcraftBugError(`command "${node.name}" must define an object params schema for SDK.`);
                     }
                     validatedParams = validateSDKArguments(paramsSchema, params);
-                    return await invokeWithHumanInLoop(node, {
+                    const handlerContext = {
                         ...baseContext,
                         params: validatedParams
-                    }, runtimeOptions, commandPath);
+                    };
+                    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({
@@ -436,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;
                 }
             }
@@ -461,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/node_modules/toolcraft/dist/stream.d.ts

@@ -0,0 +1,19 @@
+import { type AnySchema, type Static } from "toolcraft-schema";
+export type StreamStatusType = "connected" | "progress" | "reconnecting";
+export interface StreamStatusEvent {
+    type: StreamStatusType;
+    message?: string;
+}
+export interface StreamConsumerOptions {
+    signal?: AbortSignal;
+    onStatus?: (event: StreamStatusEvent) => void;
+}
+export interface ToolcraftStream<TEvent> extends AsyncIterable<TEvent> {
+    readonly signal: AbortSignal;
+    cancel(reason?: unknown): Promise<void>;
+}
+export interface ManagedStreamOptions<TSchema extends AnySchema> extends StreamConsumerOptions {
+    eventSchema: TSchema;
+    create(signal: AbortSignal, status: (event: StreamStatusEvent) => void): Promise<AsyncIterable<Static<TSchema>>>;
+}
+export declare function createManagedStream<TSchema extends AnySchema>(options: ManagedStreamOptions<TSchema>): ToolcraftStream<Static<TSchema>>;

package/node_modules/toolcraft/dist/stream.js

@@ -0,0 +1,93 @@
+import { validate } from "toolcraft-schema";
+import { UserError } from "./user-error.js";
+function validationMessage(schema, value) {
+    const result = validate(schema, value);
+    return result.ok ? undefined : result.issues.map((issue) => issue.message).join("; ");
+}
+export function createManagedStream(options) {
+    const controller = new AbortController();
+    let iteratorPromise;
+    let closePromise;
+    let done = false;
+    const getIterator = () => {
+        iteratorPromise ??= Promise.resolve()
+            .then(() => options.create(controller.signal, (event) => options.onStatus?.(event)))
+            .then((iterable) => iterable[Symbol.asyncIterator]());
+        return iteratorPromise;
+    };
+    const close = (reason) => {
+        if (closePromise !== undefined) {
+            return closePromise;
+        }
+        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).catch(() => undefined);
+    };
+    if (options.signal?.aborted === true) {
+        abortFromConsumer();
+    }
+    else {
+        options.signal?.addEventListener("abort", abortFromConsumer, { once: true });
+    }
+    const stream = {
+        signal: controller.signal,
+        cancel: close,
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    if (done || controller.signal.aborted) {
+                        await close(controller.signal.reason);
+                        return { done: true, value: undefined };
+                    }
+                    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);
+                        return { done: true, value: undefined };
+                    }
+                    const message = validationMessage(options.eventSchema, result.value);
+                    if (message !== undefined) {
+                        await close(new UserError(message));
+                        throw new UserError(message);
+                    }
+                    return { done: false, value: result.value };
+                },
+                async return() {
+                    await close();
+                    return { done: true, value: undefined };
+                },
+                async throw(error) {
+                    await close(error);
+                    throw error;
+                }
+            };
+        }
+    };
+    return stream;
+}

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

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

package/node_modules/toolcraft/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]";
+    }
+}