@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/properties.js

@@ -0,0 +1,129 @@
+import { compileGraph } from "./compiler.js";
+import { evaluateSchema } from "./evaluate.js";
+import { isObject } from "./utils.js";
+function referenceNodes(graph, node) {
+    if (!isObject(node.schema))
+        return [];
+    return ["$ref", "$dynamicRef", "$recursiveRef"].flatMap(keyword => typeof node.schema === "object" && typeof node.schema[keyword] === "string"
+        ? [graph.resolve(node, node.schema[keyword])] : []);
+}
+function ignoresSiblings(node) {
+    return node.dialect === "draft7" && isObject(node.schema) && typeof node.schema.$ref === "string";
+}
+function requiredFor(graph, node, name, ancestors = new Set()) {
+    if (!isObject(node.schema) || ancestors.has(node))
+        return false;
+    const next = new Set(ancestors).add(node);
+    const referenced = referenceNodes(graph, node).some(target => requiredFor(graph, target, name, next));
+    if (ignoresSiblings(node))
+        return referenced;
+    if (referenced || (Array.isArray(node.schema.required) && node.schema.required.includes(name)))
+        return true;
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        const branches = node.schema[keyword];
+        if (!Array.isArray(branches))
+            continue;
+        const requirements = branches.map((_branch, index) => {
+            const child = node.children.get(`${keyword}/${index}`);
+            return child !== undefined && requiredFor(graph, child, name, next);
+        });
+        if (keyword === "allOf" ? requirements.some(Boolean) : requirements.every(Boolean))
+            return true;
+    }
+    return false;
+}
+function annotationSchemas(graph, root) {
+    const seen = new Set();
+    const schemas = [];
+    const visit = (node) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (!ignoresSiblings(node))
+            schemas.push(structuredClone(node.schema));
+        for (const target of referenceNodes(graph, node))
+            visit(target);
+        if (ignoresSiblings(node) || !isObject(node.schema))
+            return;
+        for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+            const branches = node.schema[keyword];
+            if (!Array.isArray(branches))
+                continue;
+            branches.forEach((_branch, index) => {
+                const child = node.children.get(`${keyword}/${index}`);
+                if (child)
+                    visit(child);
+            });
+        }
+    };
+    visit(root);
+    return schemas;
+}
+/** Project names and candidate validators while retaining the native reference graph.
+ * Property hints cover declarations in refs, compositions and conditional branches;
+ * full object validation remains necessary for branch-dependent constraints. */
+export function projectJsonSchemaProperties(schema, options = {}) {
+    const graph = compileGraph(structuredClone(schema), {
+        ...options, ...(options.registry === undefined ? {} : { registry: structuredClone(options.registry) })
+    });
+    const declarations = new Map();
+    const seen = new Set();
+    const visit = (node) => {
+        if (seen.has(node) || !isObject(node.schema))
+            return;
+        seen.add(node);
+        for (const target of referenceNodes(graph, node))
+            visit(target);
+        if (ignoresSiblings(node))
+            return;
+        if (isObject(node.schema.properties)) {
+            for (const name of Object.keys(node.schema.properties)) {
+                const child = node.children.get(`properties/${name}`);
+                if (!child)
+                    continue;
+                const sources = declarations.get(name) ?? new Set();
+                sources.add(child);
+                declarations.set(name, sources);
+            }
+        }
+        for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+            const branches = node.schema[keyword];
+            if (!Array.isArray(branches))
+                continue;
+            branches.forEach((_branch, index) => {
+                const child = node.children.get(`${keyword}/${index}`);
+                if (child)
+                    visit(child);
+            });
+        }
+        for (const keyword of ["then", "else", "dependentSchemas", "dependencies"]) {
+            if ((keyword === "dependentSchemas" || keyword === "dependencies") && isObject(node.schema[keyword])) {
+                for (const key of Object.keys(node.schema[keyword])) {
+                    const child = node.children.get(`${keyword}/${key}`);
+                    if (child)
+                        visit(child);
+                }
+            }
+            else {
+                const child = node.children.get(keyword);
+                if (child)
+                    visit(child);
+            }
+        }
+    };
+    visit(graph.root);
+    return [...declarations.keys()].sort().map(name => {
+        const sources = [...declarations.get(name)];
+        return {
+            name,
+            required: requiredFor(graph, graph.root, name),
+            schemas: sources.flatMap(node => annotationSchemas(graph, node)),
+            validate(value) {
+                const results = sources.map(node => evaluateSchema({ ...graph, root: node }, value));
+                if (results.some(result => result.valid))
+                    return { ok: true, value };
+                return { ok: false, issues: results.flatMap(result => result.issues) };
+            }
+        };
+    });
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/types.d.ts

@@ -0,0 +1,34 @@
+import type { ValidationIssue, ValidationResult } from "../validate.js";
+export type JsonSchemaRegistry = Record<string, unknown>;
+export interface CompileJsonSchemaOptions {
+    registry?: JsonSchemaRegistry;
+    formats?: Readonly<Record<string, (value: string) => boolean>>;
+}
+export interface CompiledJsonSchema {
+    validate(value: unknown): ValidationResult<unknown>;
+}
+export type Dialect = "draft7" | "draft2020-12";
+export type SchemaObject = Record<string, unknown>;
+export type JsonSchema = boolean | SchemaObject;
+export interface SchemaNode {
+    schema: JsonSchema;
+    documentId: string;
+    dialect: Dialect;
+    baseUri: string;
+    resourceUri: string;
+    resourceRoot: SchemaNode;
+    pointer: string;
+    validationVocabulary: boolean;
+    children: Map<string, SchemaNode>;
+}
+export interface EvaluationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    evaluatedProperties: Set<string>;
+    evaluatedItems: Set<number>;
+}
+export interface EvaluationContext {
+    instancePath: readonly string[];
+    dynamicScope: readonly SchemaNode[];
+    activePairs: Map<SchemaNode, Set<unknown>>;
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/utils.d.ts

@@ -0,0 +1,19 @@
+import type { ValidationIssue } from "../validate.js";
+import type { Dialect, EvaluationResult, JsonSchema, SchemaObject } from "./types.js";
+export declare function isSchema(value: unknown): value is JsonSchema;
+export declare function isObject(value: unknown): value is SchemaObject;
+export declare function dialectFor(schema: SchemaObject, inherited: Dialect): Dialect;
+export declare function resolveUri(reference: string, baseUri: string): string;
+export declare function withoutFragment(uri: string): string;
+export declare function fragmentOf(uri: string): string;
+export declare function escapePointer(value: string): string;
+export declare function decodePointer(value: string): string;
+export declare function deepEqual(left: unknown, right: unknown): boolean;
+export declare function receivedType(value: unknown): string;
+export declare function issue(path: readonly string[], expected: string, value: unknown, message: string, keyword?: string): ValidationIssue;
+export declare function validResult(): EvaluationResult;
+export declare function invalidResult(problem: ValidationIssue): EvaluationResult;
+export declare function mergeResults(results: readonly EvaluationResult[]): EvaluationResult;
+export declare function typeMatches(type: string, value: unknown): boolean;
+export declare function unicodeLength(value: string): number;
+export declare function isMultipleOf(value: number, divisor: number): boolean;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/utils.js

@@ -0,0 +1,174 @@
+export function isSchema(value) {
+    return typeof value === "boolean" || isObject(value);
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function dialectFor(schema, inherited) {
+    const dialect = schema.$schema;
+    if (typeof dialect !== "string") {
+        return inherited;
+    }
+    if (dialect.includes("draft-07")) {
+        return "draft7";
+    }
+    if (dialect.includes("2020-12")) {
+        return "draft2020-12";
+    }
+    return inherited;
+}
+export function resolveUri(reference, baseUri) {
+    if (typeof URL === "undefined" && (reference === "" || reference.startsWith("#"))) {
+        return `${withoutFragment(baseUri)}${reference}`;
+    }
+    try {
+        return new URL(reference, baseUri).href;
+    }
+    catch {
+        throw new Error(`Invalid schema URI: ${reference}`);
+    }
+}
+export function withoutFragment(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? uri : uri.slice(0, index);
+}
+export function fragmentOf(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? "" : uri.slice(index + 1);
+}
+export function escapePointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function decodePointer(value) {
+    return decodeURIComponent(value).replaceAll("~1", "/").replaceAll("~0", "~");
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (typeof left !== typeof right || left === null || right === null) {
+        return false;
+    }
+    if (Array.isArray(left)) {
+        return (Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => deepEqual(value, right[index])));
+    }
+    if (isObject(left) && isObject(right)) {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])));
+    }
+    return false;
+}
+export function receivedType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return "integer";
+    }
+    return typeof value;
+}
+export function issue(path, expected, value, message, keyword = keywordFor(expected)) {
+    return { path, expected, received: receivedType(value), message, keyword };
+}
+function keywordFor(expected) {
+    if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
+        return "type";
+    }
+    if (expected.startsWith("multiple of"))
+        return "multipleOf";
+    if (expected.startsWith("length <="))
+        return "maxLength";
+    if (expected.startsWith("length >="))
+        return "minLength";
+    if (expected.startsWith("pattern "))
+        return "pattern";
+    if (expected.startsWith("items <="))
+        return "maxItems";
+    if (expected.startsWith("items >="))
+        return "minItems";
+    if (expected === "unique items")
+        return "uniqueItems";
+    if (expected.startsWith("properties <="))
+        return "maxProperties";
+    if (expected.startsWith("properties >="))
+        return "minProperties";
+    if (expected.startsWith("<= "))
+        return "maximum";
+    if (expected.startsWith(">= "))
+        return "minimum";
+    if (expected.startsWith("< "))
+        return "exclusiveMaximum";
+    if (expected.startsWith("> "))
+        return "exclusiveMinimum";
+    if (expected === "valid schema")
+        return "false schema";
+    return expected;
+}
+export function validResult() {
+    return {
+        valid: true,
+        issues: [],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function invalidResult(problem) {
+    return {
+        valid: false,
+        issues: [problem],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function mergeResults(results) {
+    const merged = validResult();
+    for (const result of results) {
+        merged.valid &&= result.valid;
+        merged.issues.push(...result.issues);
+        for (const key of result.evaluatedProperties) {
+            merged.evaluatedProperties.add(key);
+        }
+        for (const index of result.evaluatedItems) {
+            merged.evaluatedItems.add(index);
+        }
+    }
+    return merged;
+}
+export function typeMatches(type, value) {
+    switch (type) {
+        case "null":
+            return value === null;
+        case "boolean":
+            return typeof value === "boolean";
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "string":
+            return typeof value === "string";
+        default:
+            return true;
+    }
+}
+export function unicodeLength(value) {
+    return [...value].length;
+}
+export function isMultipleOf(value, divisor) {
+    if (divisor === 0) {
+        return false;
+    }
+    const quotient = value / divisor;
+    return (Math.abs(quotient - Math.round(quotient)) <=
+        Number.EPSILON * Math.max(1, Math.abs(quotient)) * 4);
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema-document.d.ts

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "./index.js";
+export interface JsonSchemaDocumentOptions {
+    id?: string;
+    title?: string;
+    description?: string;
+    schema?: string;
+}
+export type JsonSchemaDocument = JsonSchema & {
+    $schema: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+};
+export declare function createJsonSchemaDocument(jsonSchema: JsonSchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema-document.js

@@ -0,0 +1,17 @@
+export function createJsonSchemaDocument(jsonSchema, options = {}) {
+    const { id, schema: schemaUri = "https://json-schema.org/draft/2020-12/schema", ...metadata } = options;
+    const document = {
+        $schema: schemaUri,
+        ...jsonSchema
+    };
+    if (id !== undefined) {
+        document.$id = id;
+    }
+    if (metadata.title !== undefined) {
+        document.title = metadata.title;
+    }
+    if (metadata.description !== undefined) {
+        document.description = metadata.description;
+    }
+    return document;
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json.compile-check.js

@@ -0,0 +1,2 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Json();

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json.d.ts

@@ -0,0 +1,23 @@
+import { type Standardized } from "./standard.js";
+import type { SchemaBase } from "./index.js";
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+export interface JsonValueSchema extends SchemaBase<"json", JsonValue> {
+    readonly kind: "json";
+    readonly const?: JsonValue;
+    readonly enum?: readonly JsonValue[];
+}
+type ConfiguredJson<TOptions> = JsonValueSchema & (TOptions extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? unknown : {
+    readonly default: JsonValue;
+} : unknown);
+export declare function Json<const TOptions extends Omit<JsonValueSchema, "kind"> = Record<never, never>>(options?: TOptions): Standardized<ConfiguredJson<TOptions>>;
+export interface JsonValueValidationOptions {
+    readonly maxNodes?: number;
+    readonly maxDepth?: number;
+}
+export declare function isJsonValue(value: unknown, options?: JsonValueValidationOptions): boolean;
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json.js

@@ -0,0 +1,81 @@
+import { withStandardSchema } from "./standard.js";
+export function Json(options = {}) {
+    return withStandardSchema({
+        kind: "json",
+        ...options,
+    });
+}
+export function isJsonValue(value, options = {}) {
+    const maxNodes = options.maxNodes ?? 10_000;
+    const maxDepth = options.maxDepth ?? 64;
+    if (maxNodes !== Infinity && (!Number.isSafeInteger(maxNodes) || maxNodes < 1))
+        throw new Error("maxNodes must be a positive safe integer");
+    if (maxDepth !== Infinity && (!Number.isSafeInteger(maxDepth) || maxDepth < 0))
+        throw new Error("maxDepth must be a nonnegative safe integer or Infinity");
+    const ancestors = new Set();
+    const stack = [];
+    function* properties(item) {
+        if (Array.isArray(item)) {
+            for (let index = 0; index < item.length; index++)
+                yield Object.getOwnPropertyDescriptor(item, String(index));
+        }
+        else
+            for (const key in item) {
+                const property = Object.getOwnPropertyDescriptor(item, key);
+                if (property !== undefined)
+                    yield property;
+            }
+    }
+    let nodes = 0;
+    let item = value, depth = 0;
+    while (true) {
+        if (++nodes > maxNodes || depth > maxDepth)
+            return false;
+        if (item !== null && typeof item !== "string" && typeof item !== "boolean") {
+            if (typeof item === "number") {
+                if (!Number.isFinite(item))
+                    return false;
+            }
+            else {
+                if (typeof item !== "object" || ancestors.has(item))
+                    return false;
+                if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype &&
+                    Object.getPrototypeOf(item) !== null)
+                    return false;
+                let hookOwner = item;
+                let prototypeDepth = 0;
+                while (hookOwner !== null) {
+                    if (++prototypeDepth > 64)
+                        return false;
+                    const serializationHook = Object.getOwnPropertyDescriptor(hookOwner, "toJSON");
+                    if (serializationHook !== undefined) {
+                        if (!("value" in serializationHook) || typeof serializationHook.value === "function")
+                            return false;
+                        break;
+                    }
+                    hookOwner = Object.getPrototypeOf(hookOwner);
+                }
+                if (Array.isArray(item) && item.length > maxNodes - nodes)
+                    return false;
+                ancestors.add(item);
+                stack.push({ owner: item, children: properties(item), depth });
+            }
+        }
+        let next;
+        while (stack.length) {
+            const frame = stack[stack.length - 1];
+            next = frame.children.next();
+            if (!next.done) {
+                if (next.value === undefined || !("value" in next.value))
+                    return false;
+                item = next.value.value;
+                depth = frame.depth + 1;
+                break;
+            }
+            ancestors.delete(frame.owner);
+            stack.pop();
+        }
+        if (!stack.length)
+            return true;
+    }
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/native-json-schema.d.ts

@@ -0,0 +1,13 @@
+import { type Standardized } from "./standard.js";
+import type { AnySchema, JsonSchema } from "./index.js";
+import type { CompiledJsonSchema } from "./json-schema/types.js";
+export declare const nativeJsonSchema: unique symbol;
+export type NativeSchema = AnySchema & {
+    [nativeJsonSchema]?: {
+        document: JsonSchema;
+        validator: CompiledJsonSchema;
+    };
+};
+export declare function withJsonSchema<T extends AnySchema>(projection: T, document: object): Standardized<T & {
+    [nativeJsonSchema]: NonNullable<NativeSchema[typeof nativeJsonSchema]>;
+}>;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/native-json-schema.js

@@ -0,0 +1,12 @@
+import { withStandardSchema } from "./standard.js";
+import { isJsonValue } from "./json.js";
+import { compileJsonSchema } from "./json-schema/index.js";
+export const nativeJsonSchema = Symbol("toolcraft.nativeJsonSchema");
+export function withJsonSchema(projection, document) {
+    if (!isJsonValue(document) || Array.isArray(document)) {
+        throw new Error("Native JSON Schema must be a JSON object");
+    }
+    const snapshot = structuredClone(document);
+    const validator = compileJsonSchema(snapshot);
+    return withStandardSchema({ ...projection, [nativeJsonSchema]: { document: snapshot, validator } });
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/oneof.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/oneof.compile-check.js

@@ -0,0 +1,12 @@
+import { S } from "./index.js";
+const ignoredSchema = S.OneOf({
+    discriminator: "kind",
+    branches: {
+        text: S.Object({
+            value: S.String(),
+        }),
+        count: S.Object({
+            value: S.Number(),
+        }),
+    },
+});

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/oneof.d.ts

@@ -0,0 +1,16 @@
+import { type Standardized } from "./standard.js";
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type OneOfStatic<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string> = {
+    [TBranchName in keyof TBranches & string]: Omit<Static<TBranches[TBranchName]>, TDiscriminator> & {
+        [TFieldName in TDiscriminator]: TBranchName;
+    };
+}[keyof TBranches & string];
+export interface OneOfSchema<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string = string> extends SchemaBase<"oneOf", OneOfStatic<TBranches, TDiscriminator>> {
+    readonly discriminator: TDiscriminator;
+    readonly branches: TBranches;
+}
+export declare function OneOf<TDiscriminator extends string, TBranches extends Record<string, ObjectSchema<any>>>(config: {
+    discriminator: TDiscriminator;
+    branches: TBranches;
+}): Standardized<OneOfSchema<TBranches, TDiscriminator>>;
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/oneof.js

@@ -0,0 +1,19 @@
+import { withStandardSchema } from "./standard.js";
+function assertValidBranches(branches, discriminator) {
+    if (Object.keys(branches).length === 0) {
+        throw new Error("OneOf schema requires at least one branch");
+    }
+    for (const [branchName, branch] of Object.entries(branches)) {
+        if (Object.prototype.hasOwnProperty.call(branch.shape, discriminator)) {
+            throw new Error(`OneOf branch "${branchName}" must not declare discriminator field "${discriminator}".`);
+        }
+    }
+}
+export function OneOf(config) {
+    assertValidBranches(config.branches, config.discriminator);
+    return withStandardSchema({
+        kind: "oneOf",
+        discriminator: config.discriminator,
+        branches: config.branches,
+    });
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/record.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/record.compile-check.js

@@ -0,0 +1,2 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Record(S.String());

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/record.d.ts

@@ -0,0 +1,6 @@
+import { type Standardized } from "./standard.js";
+import type { AnySchema, SchemaBase, Static } from "./index.js";
+export interface RecordSchema<TValue extends AnySchema> extends SchemaBase<"record", Record<string, Static<TValue>>> {
+    readonly value: TValue;
+}
+export declare function Record<TValue extends AnySchema>(value: TValue): Standardized<RecordSchema<TValue>>;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/record.js

@@ -0,0 +1,7 @@
+import { withStandardSchema } from "./standard.js";
+export function Record(value) {
+    return withStandardSchema({
+        kind: "record",
+        value,
+    });
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/standard.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/standard.compile-check.js

@@ -0,0 +1,20 @@
+import { S, withJsonSchema, withStandardSchema, toJsonSchema } from "./index.js";
+const ignoredSchema = S.Object({
+    query: S.String(),
+    limit: S.Optional(S.Number({ default: 10 })),
+    note: S.Optional(S.String()),
+    nested: S.Array(S.Object({ enabled: S.Optional(S.Boolean({ default: true })) })),
+    nullable: S.String({ nullable: true })
+});
+// @ts-expect-error A parsed default is always present.
+const ignoredMissingDefault = { query: "x", nested: [], nullable: null };
+const ignoredNullableDefault = S.Optional(S.String({ nullable: true, default: "x" }));
+const ignoredUnionSchema = S.Union([S.Object({ a: S.Optional(S.Number({ default: 1 })) }), S.Object({ b: S.String() })]);
+const ignoredTaggedSchema = S.OneOf({ discriminator: "kind", branches: { text: S.Object({ text: S.Optional(S.String({ default: "x" })) }) } });
+const ignoredNative = withJsonSchema(S.Object({ count: S.Optional(S.Number({ default: 1 })) }), { type: "object" });
+toJsonSchema(withStandardSchema(descriptor));
+const ignoredJsonDefault = S.Object({ data: S.Optional(S.Json({ default: null })) });
+const ignoredUndefinedDefaults = S.Object({
+    count: S.Optional(S.Number({ default: undefined })),
+    data: S.Optional(S.Json({ default: undefined }))
+});