@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/dist/testing/memory-fs.js

@@ -0,0 +1,102 @@
+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}`);
+    error.code = "ENOENT";
+    error.errno = -2;
+    error.path = path;
+    error.syscall = syscall;
+    if (dest !== undefined) {
+        error.dest = dest;
+    }
+    return error;
+}
+export function createMemoryFs(files = {}) {
+    const contents = new Map(Object.entries(files).map(([path, value]) => [path, Buffer.from(value, "utf8")]));
+    const changeLog = [];
+    return {
+        async readFile(path, encoding = "utf8") {
+            const value = contents.get(path);
+            if (value === undefined) {
+                throw missingFileError("open", path);
+            }
+            return value.toString(encoding);
+        },
+        async writeFile(path, value, options) {
+            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) {
+            return contents.has(path);
+        },
+        async lstat(path) {
+            if (!contents.has(path)) {
+                throw missingFileError("lstat", path);
+            }
+            return { isSymbolicLink: () => false };
+        },
+        async rename(fromPath, toPath) {
+            const value = contents.get(fromPath);
+            if (value === undefined) {
+                throw missingFileError("rename", fromPath, toPath);
+            }
+            if (fromPath !== toPath) {
+                contents.set(toPath, value);
+                contents.delete(fromPath);
+            }
+            changeLog.push({ op: "rename", path: fromPath, to: toPath });
+        },
+        async unlink(path) {
+            if (!contents.delete(path)) {
+                throw missingFileError("unlink", path);
+            }
+            changeLog.push({ op: "unlink", path });
+        },
+        snapshot() {
+            return Object.fromEntries(Array.from(contents, ([path, value]) => [path, value.toString("utf8")]));
+        },
+        changes() {
+            return changeLog.map((change) => ({ ...change }));
+        }
+    };
+}

package/node_modules/toolcraft/dist/testing/parity.d.ts

@@ -0,0 +1,25 @@
+import type { Command, Group, HandlerFs } from "../index.js";
+export interface SurfaceOutcome {
+    ok: boolean;
+    value: unknown;
+    error: unknown;
+}
+export interface ParityResult {
+    sdk: SurfaceOutcome;
+    mcp: SurfaceOutcome;
+    cli: SurfaceOutcome;
+    agree: boolean;
+    diff?: string;
+}
+export interface ParityOptions<TServices extends object> {
+    services: TServices;
+    env?: Record<string, string>;
+    fs: HandlerFs;
+    fetch: typeof globalThis.fetch;
+    apiVersion?: string;
+}
+export interface ParityCommand {
+    command: Command<any, any, any, any>;
+    path: string[];
+}
+export declare function runParity<TServices extends object>(root: Group<any>, resolved: ParityCommand, params: Record<string, unknown>, options: ParityOptions<TServices>): Promise<ParityResult>;

package/node_modules/toolcraft/dist/testing/parity.js

@@ -0,0 +1,428 @@
+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.`);
+        this.name = "SurfaceScopeError";
+    }
+}
+function splitWords(value) {
+    const words = [];
+    let current = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        const lower = char.toLowerCase();
+        const upper = char.toUpperCase();
+        const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
+        if (isSeparator) {
+            if (current.length > 0) {
+                words.push(current.toLowerCase());
+                current = "";
+            }
+            continue;
+        }
+        const isUppercase = char !== lower && char === upper;
+        const previous = value[index - 1];
+        const next = value[index + 1];
+        const previousIsLowercase = previous !== undefined &&
+            previous === previous.toLowerCase() &&
+            previous !== previous.toUpperCase();
+        const nextIsLowercase = next !== undefined && next === next.toLowerCase() && next !== next.toUpperCase();
+        if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
+            words.push(current.toLowerCase());
+            current = char;
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        words.push(current.toLowerCase());
+    }
+    return words;
+}
+function formatName(value, casing) {
+    const words = splitWords(value);
+    if (casing === "camel") {
+        return words
+            .map((word, index) => index === 0 ? word : `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`)
+            .join("");
+    }
+    return words.join(casing === "kebab" ? "-" : "_");
+}
+function unwrapOptional(schema) {
+    return schema.kind === "optional" ? unwrapOptional(schema.inner) : schema;
+}
+function mapUnknownMCPObject(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [formatName(key, "snake"), child]));
+}
+function filterParams(schema, params, surface) {
+    const filtered = filterSchemaForScope(schema, surface);
+    if (filtered?.kind !== "object") {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(filtered.shape).flatMap(([key, childSchema]) => {
+        const value = params[key];
+        if (value === undefined) {
+            return [];
+        }
+        const unwrapped = unwrapOptional(childSchema);
+        if (unwrapped.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            return [[key, filterParams(unwrapped, value, surface)]];
+        }
+        return [[key, value]];
+    }));
+}
+function mapMCPValue(schema, value) {
+    const unwrapped = unwrapOptional(schema);
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (unwrapped.kind) {
+        case "array":
+            return Array.isArray(value) ? value.map((item) => mapMCPValue(unwrapped.item, item)) : value;
+        case "object": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+                const childSchema = unwrapped.shape[key];
+                return [
+                    formatName(key, "snake"),
+                    childSchema === undefined ? child : mapMCPValue(childSchema, child)
+                ];
+            }));
+        }
+        case "record":
+            return typeof value === "object" && !Array.isArray(value)
+                ? Object.fromEntries(Object.entries(value).map(([key, child]) => [key, mapMCPValue(unwrapped.value, child)]))
+                : value;
+        case "oneOf": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const discriminator = objectValue[unwrapped.discriminator];
+            const branch = typeof discriminator === "string" ? unwrapped.branches[discriminator] : undefined;
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "union": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const branch = unwrapped.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(objectValue, key)));
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "boolean":
+        case "enum":
+        case "json":
+        case "number":
+        case "string":
+            return value;
+    }
+}
+function success(value) {
+    return { ok: true, value, error: undefined };
+}
+function failure(error) {
+    return { ok: false, value: undefined, error };
+}
+async function runSDK(root, resolved, params, options) {
+    if (!resolved.command.scope.includes("sdk")) {
+        return failure(new SurfaceScopeError("sdk", resolved.path));
+    }
+    try {
+        let member = createSDK(root, options);
+        for (const segment of resolved.path) {
+            member = member[formatName(segment, "camel")];
+        }
+        if (typeof member !== "function") {
+            throw new Error(`SDK command "${resolved.path.join(".")}" is not callable.`);
+        }
+        return success(await member(filterParams(resolved.command.params, params, "sdk")));
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function parseMcpValue(result, reference) {
+    if (result.structuredContent !== undefined) {
+        return result.structuredContent;
+    }
+    const text = result.content
+        .filter((item) => item.type === "text" && item.text !== undefined)
+        .map((item) => item.text)
+        .join("\n");
+    if (text.length === 0) {
+        return undefined;
+    }
+    if (reference?.ok === true && isDeepStrictEqual(text, reference.value)) {
+        return text;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function runMCP(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("mcp")) {
+        return failure(new SurfaceScopeError("mcp", resolved.path));
+    }
+    const server = createMCPServer(root, {
+        ...options,
+        name: `${root.name}-parity`,
+        version: "0.0.0",
+        casing: "snake"
+    });
+    const client = new McpClient({
+        clientInfo: { name: "toolcraft-parity", version: "0.0.0" }
+    });
+    const pair = await createSdkTestPair(server, () => client);
+    try {
+        const toolName = [root.name, ...resolved.path]
+            .map((segment) => formatName(segment, "snake"))
+            .join("__");
+        const argumentsValue = mapMCPValue(resolved.command.params, filterParams(resolved.command.params, params, "mcp"));
+        const result = await client.callTool({ name: toolName, arguments: argumentsValue });
+        return success(parseMcpValue(result, reference));
+    }
+    catch (error) {
+        if (error instanceof McpError && error.code === ERROR_INVALID_PARAMS) {
+            return failure(new UserError(error.message));
+        }
+        return failure(error);
+    }
+    finally {
+        await pair.cleanup();
+    }
+}
+function valueAtPath(value, path) {
+    return path.reduce((current, segment) => typeof current === "object" && current !== null
+        ? current[segment]
+        : undefined, value);
+}
+function appendCLIValue(argv, flag, value) {
+    if (typeof value === "boolean") {
+        argv.push(value ? flag : `--no-${flag.slice(2)}`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        argv.push(flag, ...value.map((item) => String(item)));
+        return;
+    }
+    argv.push(flag, typeof value === "object" ? JSON.stringify(value) : String(value));
+}
+function appendCLIFlags(argv, schema, params, positionals, sourcePath = [], flagPath = []) {
+    for (const [key, rawSchema] of Object.entries(schema.shape)) {
+        const nextSourcePath = [...sourcePath, key];
+        const nextFlagPath = [...flagPath, formatName(key, "kebab")];
+        const displayPath = nextSourcePath.join(".");
+        const value = params[key];
+        if (value === undefined || positionals.has(displayPath)) {
+            continue;
+        }
+        const childSchema = unwrapOptional(rawSchema);
+        if (childSchema.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            appendCLIFlags(argv, childSchema, value, positionals, nextSourcePath, nextFlagPath);
+            continue;
+        }
+        if (childSchema.kind === "record" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            for (const [recordKey, recordValue] of Object.entries(value)) {
+                appendCLIValue(argv, `--${[...nextFlagPath, recordKey].join(".")}`, recordValue);
+            }
+            continue;
+        }
+        appendCLIValue(argv, `--${nextFlagPath.join(".")}`, value);
+    }
+}
+function buildCLIArgv(root, resolved, params) {
+    const visibleParams = filterParams(resolved.command.params, params, "cli");
+    const argv = ["node", root.name, ...resolved.path.map((segment) => formatName(segment, "kebab"))];
+    for (const positional of resolved.command.positional) {
+        const value = valueAtPath(visibleParams, positional.split("."));
+        if (Array.isArray(value)) {
+            argv.push(...value.map((item) => String(item)));
+        }
+        else if (value !== undefined) {
+            argv.push(String(value));
+        }
+    }
+    appendCLIFlags(argv, filterSchemaForScope(resolved.command.params, "cli"), visibleParams, new Set(resolved.command.positional));
+    argv.push("--output", "json", "--debug");
+    return argv;
+}
+function parseCLIValue(entries, reference) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(entry);
+            if (reference?.ok !== true || isDeepStrictEqual(parsed, reference.value)) {
+                return parsed;
+            }
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed) &&
+                Object.keys(parsed).length === 1 &&
+                Object.prototype.hasOwnProperty.call(parsed, "result") &&
+                isDeepStrictEqual(parsed.result, reference.value)) {
+                return reference.value;
+            }
+            if ((reference.value === null || reference.value === undefined) &&
+                isDeepStrictEqual(parsed, { ok: true })) {
+                return reference.value;
+            }
+            return parsed;
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries.at(-1);
+}
+function parseCLIError(entries) {
+    const message = entries.at(-1) ?? "CLI command failed.";
+    const lines = message.split("\n");
+    const lastLine = lines.at(-1) ?? "";
+    if (lastLine.startsWith("Run ") && lastLine.endsWith(" --help for usage.")) {
+        lines.pop();
+    }
+    return new UserError(lines.join("\n"));
+}
+async function runCLISurface(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("cli")) {
+        return failure(new SurfaceScopeError("cli", resolved.path));
+    }
+    const entries = [];
+    const previousExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+        await runCLI(root, {
+            ...options,
+            argv: buildCLIArgv(root, resolved, params),
+            controls: { debug: true, output: true },
+            outputEmitter: (entry) => entries.push(entry)
+        });
+        if (process.exitCode !== undefined && process.exitCode !== 0) {
+            return failure(parseCLIError(entries));
+        }
+        return success(parseCLIValue(entries, reference));
+    }
+    catch (error) {
+        return failure(error);
+    }
+    finally {
+        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) {
+    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: typeof error === "string" ? error : formatDiagnosticValue(error)
+    };
+}
+function outcomesAgree(left, right) {
+    if (left.ok !== right.ok) {
+        return false;
+    }
+    if (left.ok) {
+        return isDeepStrictEqual(left.value, right.value);
+    }
+    return isDeepStrictEqual(errorIdentity(left.error), errorIdentity(right.error));
+}
+function describeOutcome(surface, outcome) {
+    if (outcome.ok) {
+        return `${surface}: ok ${formatDiagnosticValue(outcome.value)}`;
+    }
+    const error = errorIdentity(outcome.error);
+    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);
+    const mcp = await runMCP(root, resolved, params, options, sdk);
+    const cli = await runCLISurface(root, resolved, params, options, sdk);
+    const agree = outcomesAgree(sdk, mcp) && outcomesAgree(sdk, cli);
+    return {
+        sdk,
+        mcp,
+        cli,
+        agree,
+        ...(agree
+            ? {}
+            : {
+                diff: [
+                    `Surface outcomes differ for "${resolved.path.join(" ")}".`,
+                    describeOutcome("sdk", sdk),
+                    describeOutcome("mcp", mcp),
+                    describeOutcome("cli", cli)
+                ].join("\n")
+            })
+    };
+}

package/node_modules/toolcraft/dist/testing/render-capture.d.ts

@@ -0,0 +1,6 @@
+import type { RenderPrimitives } from "../index.js";
+export interface RenderCapture {
+    primitives: RenderPrimitives;
+    output(): string;
+}
+export declare function createRenderCapture(outputFormat?: string): RenderCapture;

package/node_modules/toolcraft/dist/testing/render-capture.js

@@ -0,0 +1,55 @@
+import { createLogger, light, renderTable, stripAnsi, withOutputFormat } from "toolcraft-design";
+const captureWidth = 80;
+function withoutColors(theme) {
+    return {
+        header: (text) => stripAnsi(theme.header(text)),
+        divider: (text) => stripAnsi(theme.divider(text)),
+        prompt: (text) => stripAnsi(theme.prompt(text)),
+        number: (text) => stripAnsi(theme.number(text)),
+        intro: (text) => stripAnsi(theme.intro(text)),
+        resolvedSymbol: stripAnsi(theme.resolvedSymbol),
+        errorSymbol: stripAnsi(theme.errorSymbol),
+        accent: (text) => stripAnsi(theme.accent(text)),
+        muted: (text) => stripAnsi(theme.muted(text)),
+        success: (text) => stripAnsi(theme.success(text)),
+        warning: (text) => stripAnsi(theme.warning(text)),
+        error: (text) => stripAnsi(theme.error(text)),
+        info: (text) => stripAnsi(theme.info(text)),
+        badge: (text) => stripAnsi(theme.badge(text)),
+        styles: {
+            accent: { ...theme.styles.accent },
+            muted: { ...theme.styles.muted },
+            success: { ...theme.styles.success },
+            warning: { ...theme.styles.warning },
+            error: { ...theme.styles.error },
+            info: { ...theme.styles.info }
+        }
+    };
+}
+function createCaptureTheme() {
+    return {
+        ...withoutColors(light),
+        intro: (text) => ` Poe - ${text} `
+    };
+}
+export function createRenderCapture(outputFormat = "rich") {
+    const output = [];
+    const captureTheme = createCaptureTheme();
+    const emit = (message) => {
+        output.push(stripAnsi(message));
+    };
+    return {
+        primitives: {
+            logger: createLogger(emit),
+            renderTable: (options) => withOutputFormat("terminal", () => stripAnsi(renderTable({
+                ...options,
+                theme: withoutColors(options.theme),
+                maxWidth: captureWidth
+            }))),
+            getTheme: () => captureTheme,
+            note: (message, title) => emit(title === undefined ? message : `${title}\n${message}`),
+            outputFormat
+        },
+        output: () => output.join("\n")
+    };
+}

package/node_modules/toolcraft/dist/tiny-mcp-client.d.ts

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/node_modules/toolcraft/dist/tiny-mcp-client.js

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/node_modules/toolcraft/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;

package/node_modules/toolcraft/dist/union-validation.js

@@ -0,0 +1,36 @@
+import { isPlainRecord } from "toolcraft-schema";
+export function validateUnionSchema(schema, value, label, errors, validateBranch) {
+    if (!isPlainRecord(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an object${typeof value === "object" && value !== null && !Array.isArray(value) ? ", got non-plain object" : ""}.`
+        });
+        return value;
+    }
+    const matches = [];
+    const branchFailures = [];
+    for (const [index, branch] of schema.branches.entries()) {
+        const branchErrors = [];
+        const normalized = validateBranch(branch, branchErrors);
+        if (branchErrors.length === 0) {
+            matches.push(normalized);
+        }
+        else {
+            const firstError = branchErrors[0];
+            branchFailures.push({ ...firstError, message: `Branch ${index + 1}: ${firstError.message}` });
+        }
+    }
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length === 0) {
+        errors.push({ path: label, message: `No union branch matched for "${label}".` }, ...branchFailures);
+    }
+    else {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected exactly one union branch, but matched ${matches.length}.`
+        });
+    }
+    return value;
+}

package/node_modules/toolcraft/dist/user-error.d.ts

@@ -1,6 +1,14 @@
 export declare class UserError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
+/**
+ * Detects user errors by name as well as identity, so an instance created in
+ * another bundle (for example `@poe-code/user-error`, thrown by packages that do
+ * not depend on toolcraft) is still rendered as guidance where `instanceof`
+ * would fail - while a genuine `UserError` stays one even if its name was
+ * overwritten.
+ */
+export declare function isUserError(error: unknown): error is Error;
 export declare class ToolcraftBugError extends Error {
     constructor(message: string);
 }