@oh-my-pi/omptype 17.2.7 → 17.2.9

package/dist/js/typebox.js

@@ -2,6 +2,12 @@ import { OmpTypeError } from "./errors.js";
 import { type } from "./type.js";
 const OPTIONAL_INNER = Symbol("omptype.typebox.optionalInner");
 const OBJECT_INFO = Symbol("omptype.typebox.objectInfo");
+function asRuntime(schema) {
+    return schema;
+}
+function asSchema(schema) {
+    return schema;
+}
 function validationFailure(message) {
     return { message };
 }
@@ -50,7 +56,7 @@ function checkFiniteOption(name, value) {
 function tString(opts) {
     checkFiniteOption("minLength", opts?.minLength);
     checkFiniteOption("maxLength", opts?.maxLength);
-    let schema = type.raw(opts?.format === "url" || opts?.format === "uri" ? "string.url" : "string");
+    let schema = asRuntime(type.raw(opts?.format === "url" || opts?.format === "uri" ? "string.url" : "string"));
     if (opts?.minLength !== undefined)
         schema = schema.atLeastLength(opts.minLength);
     if (opts?.maxLength !== undefined)
@@ -117,9 +123,22 @@ function tNumber(opts, integer = false) {
         upper = { value: opts.exclusiveMaximum, exclusive: true };
     }
     const keyword = integer ? "number.integer" : "number";
-    const lowerDsl = lower ? `${lower.value} ${lower.exclusive ? "<" : "<="} ` : "";
-    const upperDsl = upper ? ` ${upper.exclusive ? "<" : "<="} ${upper.value}` : "";
-    let schema = type.raw(`${lowerDsl}${keyword}${upperDsl}`);
+    // The `LO <= TYPE <= HI` range spelling requires both bounds; a min-only
+    // bound must use the postfix `TYPE >= LO` form (see parseBounded in ir.ts).
+    let src;
+    if (lower && upper) {
+        src = `${lower.value} ${lower.exclusive ? "<" : "<="} ${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
+    }
+    else if (lower) {
+        src = `${keyword} ${lower.exclusive ? ">" : ">="} ${lower.value}`;
+    }
+    else if (upper) {
+        src = `${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
+    }
+    else {
+        src = keyword;
+    }
+    let schema = asRuntime(type.raw(src));
     if (opts?.multipleOf !== undefined) {
         const divisor = opts.multipleOf;
         schema = schema.narrow((value, ctx) => {
@@ -131,24 +150,25 @@ function tNumber(opts, integer = false) {
     return applyMeta(schema, opts);
 }
 function tLiteral(value, opts) {
-    return applyMeta(type.enumerated(value), opts);
+    return applyMeta(asRuntime(type.enumerated(value)), opts);
 }
 function tNever(opts) {
-    return applyMeta(type.raw("unknown").narrow((_value, ctx) => ctx.mustBe("never")), opts);
+    return applyMeta(asRuntime(type.raw("unknown")).narrow((_value, ctx) => ctx.mustBe("never")), opts);
 }
 function tUnion(schemas, opts) {
     if (schemas.length === 0)
-        return tNever(opts);
-    let result = schemas[0];
+        return asSchema(tNever(opts));
+    let result = asRuntime(schemas[0]);
     for (let i = 1; i < schemas.length; i++)
         result = result.or(schemas[i]);
-    return applyMeta(result, opts);
+    return asSchema(applyMeta(result, opts));
 }
 function tIntersect(schemas, opts) {
-    if (schemas.length === 0)
-        return applyMeta(type.raw("unknown"), opts);
+    if (schemas.length === 0) {
+        return applyMeta(asRuntime(type.raw("unknown")), opts);
+    }
     const validateAll = () => {
-        const base = type.raw("unknown");
+        const base = asRuntime(type.raw("unknown"));
         return base.narrow((value, ctx) => {
             for (const schema of schemas) {
                 if (schema(value) instanceof type.errors)
@@ -159,7 +179,7 @@ function tIntersect(schemas, opts) {
     };
     if (schemas.some(schema => schema.hasSteps))
         return applyMeta(validateAll(), opts);
-    let result = schemas[0];
+    let result = asRuntime(schemas[0]);
     try {
         for (let i = 1; i < schemas.length; i++)
             result = result.and(schemas[i]);
@@ -169,7 +189,7 @@ function tIntersect(schemas, opts) {
             return applyMeta(validateAll(), opts);
         throw error;
     }
-    return applyMeta(result, opts);
+    return asSchema(applyMeta(result, opts));
 }
 function enumValues(values) {
     if (Array.isArray(values))
@@ -184,12 +204,12 @@ function enumValues(values) {
     return result;
 }
 function tEnum(values, opts) {
-    return applyMeta(type.enumerated(...enumValues(values)), opts);
+    return applyMeta(asRuntime(type.enumerated(...enumValues(values))), opts);
 }
 function tArray(item, opts) {
     checkFiniteOption("minItems", opts?.minItems);
     checkFiniteOption("maxItems", opts?.maxItems);
-    let schema = item.array();
+    let schema = asRuntime(item).array();
     if (opts?.minItems !== undefined)
         schema = schema.atLeastLength(opts.minItems);
     if (opts?.maxItems !== undefined)
@@ -221,7 +241,7 @@ function jsonEqual(left, right) {
     }
 }
 function tTuple(items, opts) {
-    const schema = type.raw("unknown").narrow((value, ctx) => {
+    const schema = asRuntime(type.raw("unknown")).narrow((value, ctx) => {
         if (!Array.isArray(value) || value.length !== items.length)
             return ctx.mustBe(`a tuple of length ${items.length}`);
         for (let i = 0; i < items.length; i++)
@@ -236,20 +256,24 @@ function tObject(properties, opts) {
     const props = {};
     for (const key in properties) {
         const schema = properties[key];
-        const inner = schema[OPTIONAL_INNER];
-        def[inner ? `${key}?` : key] = (inner ?? schema);
+        const inner = asRuntime(schema)[OPTIONAL_INNER];
+        // A defaulted `Type.Optional(...)` maps to a plain defaulted key:
+        // omptype (like ArkType) rejects `key?` with a default, and a default
+        // already makes the key omittable on input.
+        const optionalKey = inner !== undefined && !asRuntime(inner).hasDefault;
+        def[optionalKey ? `${key}?` : key] = inner ?? schema;
         props[key] = schema;
     }
     if (opts?.additionalProperties === false)
         def["+"] = "reject";
     else if (opts?.additionalProperties && opts.additionalProperties !== true)
         def["[string]"] = opts.additionalProperties;
-    const schema = applyMeta(type.raw(def), opts);
+    const schema = applyMeta(asRuntime(type.raw(def)), opts);
     schema[OBJECT_INFO] = { props, additionalProperties: opts?.additionalProperties };
     return schema;
 }
 function tRecord(key, value, opts) {
-    const base = type.raw({ "[string]": value }).narrow((record, ctx) => {
+    const base = asRuntime(type.raw({ "[string]": value })).narrow((record, ctx) => {
         for (const name in record)
             if (key(name) instanceof type.errors)
                 return ctx.mustBe("an object with valid record keys");
@@ -258,15 +282,15 @@ function tRecord(key, value, opts) {
     return applyMeta(base, opts);
 }
 function tOptional(schema, opts) {
-    const marker = applyMeta(schema.or(type.raw("undefined")), opts);
+    const marker = applyMeta(asRuntime(schema).or(asRuntime(type.raw("undefined"))), opts);
     marker[OPTIONAL_INNER] = schema;
     return marker;
 }
 function tNullable(schema, opts) {
-    return applyMeta(schema.or(type.raw("null")), opts);
+    return applyMeta(asRuntime(schema).or(asRuntime(type.raw("null"))), opts);
 }
 function requireObject(schema, operation) {
-    const info = schema[OBJECT_INFO];
+    const info = asRuntime(schema)[OBJECT_INFO];
     if (!info)
         throw new OmpTypeError(`Type.${operation} requires a schema created by Type.Object`);
     return info;
@@ -275,16 +299,14 @@ function tPartial(schema) {
     const info = requireObject(schema, "Partial");
     const props = {};
     for (const key in info.props)
-        props[key] = info.props[key][OPTIONAL_INNER]
-            ? info.props[key]
-            : tOptional(info.props[key]);
+        props[key] = asRuntime(info.props[key])[OPTIONAL_INNER] ? info.props[key] : tOptional(info.props[key]);
     return tObject(props, { additionalProperties: info.additionalProperties });
 }
 function tRequired(schema) {
     const info = requireObject(schema, "Required");
     const props = {};
     for (const key in info.props) {
-        props[key] = info.props[key][OPTIONAL_INNER] ?? info.props[key];
+        props[key] = asRuntime(info.props[key])[OPTIONAL_INNER] ?? info.props[key];
     }
     return tObject(props, { additionalProperties: info.additionalProperties });
 }
@@ -309,7 +331,7 @@ function tComposite(schemas, opts) {
     const props = {};
     for (const schema of schemas)
         Object.assign(props, requireObject(schema, "Composite").props);
-    return tObject(props, opts);
+    return asSchema(tObject(props, opts));
 }
 function tUnsafe(_jsonSchema = {}) {
     // Raw JSON Schema is accepted for source compatibility but is not retained or validated:
@@ -320,10 +342,10 @@ export const Type = {
     String: tString,
     Number: (opts) => tNumber(opts),
     Integer: (opts) => tNumber(opts, true),
-    Boolean: (opts) => applyMeta(type.raw("boolean"), opts),
-    Null: (opts) => applyMeta(type.raw("null"), opts),
-    Any: (opts) => applyMeta(type.raw("unknown"), opts),
-    Unknown: (opts) => applyMeta(type.raw("unknown"), opts),
+    Boolean: (opts) => applyMeta(asRuntime(type.raw("boolean")), opts),
+    Null: (opts) => applyMeta(asRuntime(type.raw("null")), opts),
+    Any: (opts) => applyMeta(asRuntime(type.raw("unknown")), opts),
+    Unknown: (opts) => applyMeta(asRuntime(type.raw("unknown")), opts),
     Never: tNever,
     Literal: tLiteral,
     Union: tUnion,
@@ -335,7 +357,7 @@ export const Type = {
     Record: tRecord,
     Optional: tOptional,
     Nullable: tNullable,
-    Readonly: (schema) => withLegacyCompat(schema),
+    Readonly: (schema) => asSchema(withLegacyCompat(asRuntime(schema))),
     Partial: tPartial,
     Required: tRequired,
     Pick: tPick,

package/dist/js/zod.js

@@ -15,8 +15,8 @@ function restrictBase(source, ir) {
     let next = source.hasSteps
         ? schemaFromIR({ k: "morph", input: ir, fn: value => source(value) })
         : schemaFromIR(ir);
-    if (source.description !== undefined)
-        next = next.describe(source.description);
+    if (source.ir.desc !== undefined)
+        next = next.describe(source.ir.desc);
     if (source.hasDefault)
         next = next.default(source.defaultValue);
     return next;

package/dist/types/compile.d.ts

@@ -2,6 +2,6 @@ import { type IR } from "./ir.js";
 /** Compile `ir` into a specialized validator. */
 export declare function compile(ir: IR): (value: unknown) => unknown;
 /** Compile `ir` into an allocation-free boolean validator. */
-export declare function compileAllows(ir: IR): (value: unknown) => boolean;
+export declare function compileAllows(ir: IR): (value: unknown) => value is unknown;
 /** Generated source for inspection/debugging. */
 export declare function compileToSource(ir: IR): string;

package/dist/types/errors.d.ts

@@ -11,17 +11,22 @@
 export interface ErrorContext {
     readonly code: string;
     readonly path: readonly PropertyKey[];
+    readonly propString: string;
     readonly data: unknown;
     readonly expected: string;
     readonly actual: string;
     readonly problem: string;
+    readonly description: string;
+    readonly rule?: unknown;
 }
 /** Per-schema overrides for validation error text. */
 export interface ErrorConfig {
     readonly expected?: string | ((context: ErrorContext) => string);
-    readonly actual?: string | ((context: ErrorContext) => string);
+    readonly actual?: string | ((data: unknown) => string);
     readonly problem?: string | ((context: ErrorContext) => string);
     readonly message?: string | ((context: ErrorContext) => string);
+    /** Internal: custom predicate expectations display the offending value rather than its domain. */
+    readonly preserveActual?: boolean;
 }
 /** A single validation failure at one path. */
 export declare class OmpError {
@@ -35,6 +40,10 @@ export declare class OmpError {
     path: PropertyKey[], expected: string, 
     /** The value that failed validation. */
     data: unknown, config?: ErrorConfig);
+    /** Prefix this failure when a nested schema delegates validation. */
+    prefix(key: PropertyKey): this;
+    /** Apply schema-local formatting to this failure. */
+    configure(config: ErrorConfig): this;
     /** Stable category for programmatic error handling. */
     get code(): string;
     /** Human-readable expectation, including a configured override. */
@@ -43,44 +52,36 @@ export declare class OmpError {
     get actual(): string;
     /** Path-less problem statement: `must be <expected> (was <actual>)`. */
     get problem(): string;
-    /** Full message including the path prefix. */
     get message(): string;
     toString(): string;
 }
 /** Sentinel for a required key that was absent (distinguishes from `undefined`). */
 export declare const MISSING: unique symbol;
 /**
- * Single-failure validation result with a lazy array-like entry.
- *
- * Validators fast-fail, so allocating an `Array` subclass and a separate entry
- * on every rejection only penalizes callers that inspect errors by identity.
- * Indexing, iteration, and `map` materialize the entry on demand.
+ * Validation failure result. The common single-error case remains lazy;
+ * traversal only materializes an entry array when a second error is appended.
  */
 type StoredPath = PropertyKey[] | PropertyKey | undefined;
 export declare class OmpErrors implements Iterable<OmpError> {
     #private;
-    /** Number of failures; omptype validators fast-fail on the first error. */
-    readonly length = 1;
     constructor(path: StoredPath, expected: string, data: unknown, config?: ErrorConfig);
-    /** First and only validation failure, materialized on demand. */
+    get length(): number;
     get 0(): OmpError;
     static single(path: PropertyKey[], expected: string, data: unknown, config?: ErrorConfig): OmpErrors;
-    /** Prefix the failure path with `key` when nesting sub-schemas. */
+    /** Append all failures from `other`, preserving traversal order. */
+    append(other: OmpErrors): this;
+    /** Prefix every failure path with `key` when nesting sub-schemas. */
     prefix(key: PropertyKey): this;
-    /** Apply schema-local message formatting without rebuilding the failure. */
+    /** Apply schema-local message formatting without rebuilding failures. */
     configure(config: ErrorConfig): this;
-    /** Index the failure by its dotted property path (`""` for the root). */
     get byPath(): Readonly<Record<string, OmpError>>;
-    /** Transform the failure entry into a plain array. */
     map<result>(fn: (error: OmpError, index: number, errors: OmpErrors) => result): result[];
-    /** Select the failure entry into a plain array. */
     filter(fn: (error: OmpError, index: number, errors: OmpErrors) => unknown): OmpError[];
-    /** Iterate over the single failure entry. */
     [Symbol.iterator](): IterableIterator<OmpError>;
-    /** Human-readable failure text, materialized only when requested. */
+    /** @internal Render multiple branch failures as alternatives rather than independent failures. */
+    asAlternatives(): this;
     get summary(): string;
     toString(): string;
-    /** Throw a `TraversalError` carrying this result. */
     throw(): never;
 }
 /** Error thrown by `Type.assert` on invalid input. */

package/dist/types/from-json-schema.d.ts

@@ -0,0 +1,9 @@
+import { type BaseType } from "./type.js";
+/**
+ * Build a callable omptype schema from a JSON Schema document.
+ *
+ * # Errors
+ * Throws {@link OmpTypeError} on malformed nodes, unresolvable `$ref`s, or
+ * types omptype cannot represent.
+ */
+export declare function fromJsonSchema(schema: unknown): BaseType;

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@
  * JSON Schema emission.
  */
 export * from "./errors.js";
+export * from "./from-json-schema.js";
 export * from "./infer.js";
 export * from "./ir.js";
 export * from "./json-schema.js";

package/dist/types/infer.d.ts

@@ -10,25 +10,47 @@ type Trim<s extends string> = TrimLeft<TrimRight<s>>;
  * `never` is intentionally absent: the parser rejects it and the fallback in
  * `InferMember` treats a missing entry as "not a primitive".
  */
+type ArkAny = ReturnType<typeof JSON.parse>;
 interface PrimitiveMap {
     string: string;
     "string.url": string;
     number: number;
     "number.integer": number;
+    "number.epoch": number;
+    "number.safe": number;
+    "number.NaN": number;
+    "number.Infinity": number;
+    "number.NegativeInfinity": number;
     boolean: boolean;
     null: null;
     undefined: undefined;
     unknown: unknown;
+    "unknown.any": ArkAny;
     any: unknown;
     object: object;
     bigint: bigint;
     symbol: symbol;
+    Key: PropertyKey;
     Date: Date;
+    Array: unknown[];
+    Function: Function;
+    RegExp: RegExp;
+    File: File;
+    Error: Error;
+    Set: Set<unknown>;
+    Map: Map<unknown, unknown>;
+    WeakSet: WeakSet<WeakKey>;
+    WeakMap: WeakMap<WeakKey, unknown>;
+    Promise: Promise<unknown>;
+    FormData: FormData;
+    "object.json": unknown;
     true: true;
     false: false;
 }
 type Merge<left, right> = left extends object ? right extends object ? Omit<left, keyof right> & right : never : never;
-type InferUtility<s extends string> = s extends `Record<${string},${infer value}>` ? Record<string, InferString<value>> : s extends `Array<${infer element}>` ? InferString<element>[] : s extends `Partial<${infer value}>` ? Partial<InferString<value>> : s extends `Required<${infer value}>` ? Required<InferString<value>> : s extends `Pick<${infer value},${infer keys}>` ? Pick<InferString<value>, Extract<InferString<keys>, keyof InferString<value>>> : s extends `Omit<${infer value},${infer keys}>` ? Omit<InferString<value>, Extract<InferString<keys>, keyof InferString<value>>> : s extends `Merge<${infer left},${infer right}>` ? Merge<InferString<left>, InferString<right>> : never;
+type InferUtility<s extends string> = s extends `Record<${string},${infer value}>` ? Record<string, InferString<value>> : s extends `Array<${infer element}>` | `Array.liftFrom<${infer element}>` ? InferString<element>[] : s extends `Partial<${infer value}>` ? Partial<InferString<value>> : s extends `Required<${infer value}>` ? Required<InferString<value>> : s extends `Pick<${infer value},${infer keys}>` ? Pick<InferString<value>, Extract<InferString<keys>, keyof InferString<value>>> : s extends `Omit<${infer value},${infer keys}>` ? Omit<InferString<value>, Extract<InferString<keys>, keyof InferString<value>>> : s extends `Merge<${infer left},${infer right}>` ? Merge<InferString<left>, InferString<right>> : never;
+/** Output types of morph (`.parse`) keywords; `never` when `s` is not one. */
+type InferParse<s extends string> = s extends "string.numeric.parse" | "string.integer.parse" | "parse.number" | "parse.integer" ? number : s extends "string.date.parse" | "string.date.iso.parse" | "string.date.epoch.parse" | "parse.date" ? Date : s extends "string.url.parse" | "parse.url" ? URL : s extends "string.json.parse" | "parse.json" ? unknown : s extends "object.json.stringify" ? string : s extends "FormData.parse" ? Record<string, Bun.FormDataEntryValue | Bun.FormDataEntryValue[]> : s extends "parse.boolean" ? boolean : s extends "parse.bigint" ? bigint : never;
 /**
  * Member inference as a flat false-branch chain: TypeScript tail-evaluates
  * chained conditionals in the false position, so this stays at constant
@@ -36,17 +58,21 @@ type InferUtility<s extends string> = s extends `Record<${string},${infer value}
  * fallback inside a true branch and accumulated depth per step.
  */
 type InferMember<member extends string> = Trim<member> extends infer s extends string ? InferMemberTrimmed<s> : unknown;
-type InferMemberTrimmed<s extends string> = s extends `(${infer inner})` ? InferString<inner> : s extends `${infer element}[]` ? InferMember<element>[] : s extends `'${infer literal}'` | `"${infer literal}"` ? literal : s extends `d'${string}'` | `d"${string}"` ? Date : s extends `\`${string}\`` ? string : s extends `/${string}/${string}` | `/${string}/` ? string : s extends `${infer literal extends number}` ? literal : s extends keyof PrimitiveMap ? PrimitiveMap[s] : InferUtility<s> extends infer utility ? [utility] extends [never] ? InferMemberFallback<s> : utility : unknown;
+type InferMemberTrimmed<s extends string> = s extends `(${infer inner})` ? InferString<inner> : s extends `${infer element}[]` ? InferMember<element>[] : s extends `'${infer literal}'` | `"${infer literal}"` ? literal : s extends `d'${string}'` | `d"${string}"` ? Date : s extends `\`${string}\`` ? string : s extends `/${string}/${string}` | `/${string}/` ? string : s extends `${infer literal extends number}` ? literal : s extends keyof PrimitiveMap ? PrimitiveMap[s] : [InferParse<s>] extends [never] ? InferUtility<s> extends infer utility ? [utility] extends [never] ? InferMemberFallback<s> : utility : unknown : InferParse<s>;
 type InferMemberFallback<s extends string> = s extends `string.${string}` ? string : s extends `${string}Date${string}` ? Date : s extends `${string}string${string}` ? string : s extends `${string}number${string}` ? number : unknown;
 /** Split unions without distributing over the accumulated members. */
 type InferUnion<s extends string, result = never> = s extends `${infer head}|${infer tail}` ? InferUnion<tail, result | InferMember<head>> : result | InferMember<s>;
+/** Input side of one union member: morph keywords accept their source type. */
+type InferMemberIn<member extends string> = Trim<member> extends infer s extends string ? s extends `${string}.parse` | `parse.${string}` ? string : InferMemberTrimmed<s> : unknown;
+/** Split unions on the input side without distributing over accumulated members. */
+type InferUnionIn<s extends string, result = never> = s extends `${infer head}|${infer tail}` ? InferUnionIn<tail, result | InferMemberIn<head>> : result | InferMemberIn<s>;
 type HasInlineDefault<s extends string> = s extends `${string}=${string}` ? s extends `${string}<${string}` | `${string}>${string}` ? false : true : false;
 type WithoutInlineDefault<s extends string> = HasInlineDefault<s> extends true ? (s extends `${infer base}=${string}` ? Trim<base> : s) : s;
-type InferStringOutput<s extends string> = s extends "string.numeric.parse" | "string.integer.parse" | "parse.number" | "parse.integer" ? number : s extends "string.date.parse" | "string.date.iso.parse" | "string.date.epoch.parse" | "parse.date" ? Date : s extends "string.url.parse" | "parse.url" ? URL : s extends "string.json.parse" | "parse.json" ? unknown : s extends "parse.boolean" ? boolean : s extends "parse.bigint" ? bigint : InferUnion<s>;
+type InferStringOutput<s extends string> = InferUnion<s>;
 /** String-DSL output inference. */
 export type InferString<s extends string> = WithoutInlineDefault<Trim<s>> extends infer trimmed extends string ? trimmed extends `${infer base}?` ? InferString<base> : trimmed extends `(${infer inner})[]` ? InferUnion<inner>[] : InferStringOutput<trimmed> : unknown;
 /** String-DSL input inference, preserving the source side of morph keywords. */
-export type InferStringIn<s extends string> = WithoutInlineDefault<Trim<s>> extends infer trimmed extends string ? trimmed extends `${string}.parse` | `parse.${string}` ? string : InferString<trimmed> : unknown;
+export type InferStringIn<s extends string> = WithoutInlineDefault<Trim<s>> extends infer trimmed extends string ? trimmed extends `${infer base}?` ? InferStringIn<base> : trimmed extends `(${infer inner})[]` ? InferUnionIn<inner>[] : InferUnionIn<trimmed> : unknown;
 type HasDefault<def> = def extends string ? HasInlineDefault<def> : def extends readonly [unknown, "=", unknown] ? true : def extends {
     readonly hasDefault: true;
 } ? true : false;
@@ -92,15 +118,28 @@ type InferObject<def extends object> = "[string]" extends keyof def ? [Definitio
 type InferObjectIn<def extends object> = "[string]" extends keyof def ? [DefinitionKeys<def>] extends [never] ? Record<string, DefBox<def["[string]"]>["in"]> : Simplify<InputRequired<def> & InputOptional<def> & InputSpread<def>> & InputIndex<def> : Simplify<InputRequired<def> & InputOptional<def> & InputSpread<def>>;
 /** Object-literal inference used by fluent composition overloads. */
 export type InferObjectDef<def extends object> = InferObject<def>;
-type InferLiteralDef<def> = def extends string ? InferString<def> : def extends object ? InferObjectLiteral<def> : unknown;
+type InferLiteralDef<def> = def extends {
+    readonly infer: infer output;
+} ? output : def extends string ? InferString<def> : def extends object ? InferObjectLiteral<def> : unknown;
+type InferLiteralDefIn<def> = def extends {
+    readonly inferIn: infer input;
+} ? input : def extends string ? InferStringIn<def> : def extends object ? InferObjectLiteralIn<def> : unknown;
 type LiteralRequired<def extends object> = {
     -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? HasDefault<def[key]> extends true ? PropName<key> : never : PropName<key>]-?: InferLiteralDef<UnwrapProperty<def[key]>>;
 };
 type LiteralOptional<def extends object> = {
     -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? HasDefault<def[key]> extends true ? never : PropName<key> : never]?: InferLiteralDef<UnwrapProperty<def[key]>>;
 };
-/** Object-literal-only inference that does not inspect embedded schema internals. */
+type LiteralRequiredIn<def extends object> = {
+    -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? never : HasDefault<def[key]> extends true ? never : PropName<key>]-?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
+};
+type LiteralOptionalIn<def extends object> = {
+    -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? PropName<key> : HasDefault<def[key]> extends true ? PropName<key> : never]?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
+};
+/** Object-literal inference that unwraps embedded schema values one level deep. */
 export type InferObjectLiteral<def extends object> = Simplify<LiteralRequired<def> & LiteralOptional<def>>;
+/** Input-side object-literal inference (embedded schemas contribute `inferIn`). */
+export type InferObjectLiteralIn<def extends object> = Simplify<LiteralRequiredIn<def> & LiteralOptionalIn<def>>;
 type InstanceOf<ctor> = ctor extends abstract new (...args: never[]) => infer instance ? instance : never;
 type SpreadOutput<def> = InferDef<def> extends readonly (infer element)[] ? element[] : never[];
 type SpreadInput<def> = InferDefIn<def> extends readonly (infer element)[] ? element[] : never[];

package/dist/types/interp.d.ts

@@ -10,8 +10,15 @@
  */
 import { OmpErrors } from "./errors.js";
 import { type IR } from "./ir.js";
-/** Validate `value` against `ir`; returns output value or `OmpErrors`. */
-export declare function walk(ir: IR, value: unknown): unknown;
+/** Return an independent runtime value for a prevalidated static default. */
+export declare function materializeDefault(payload: unknown): unknown;
+/**
+ * Validate `value` against `ir`; returns output value or `OmpErrors`.
+ * `path` seeds the traversal location so nested step callbacks observe
+ * absolute ctx.path values when a compiled parent delegates a subtree;
+ * resulting error paths are then already absolute.
+ */
+export declare function walk(ir: IR, value: unknown, path?: PropertyKey[]): unknown;
 /** True when a union failure can be replaced with a more specific nested error. */
 export declare function canRefineUnionFailure(member: IR): boolean;
 /**

package/dist/types/ir.d.ts

@@ -9,12 +9,26 @@
  * consumed by the interpreter (`interp.ts`), the JIT compiler (`compile.ts`),
  * and the JSON Schema emitter (`json-schema.ts`).
  */
-import { OmpErrors } from "./errors.js";
+import { type ErrorConfig, OmpErrors } from "./errors.js";
 /** Brand carried by `Type` instances so the parser can embed them in defs. */
 export declare const IR_BRAND: unique symbol;
 declare const kMorph: unique symbol;
+declare const kMorphOwner: unique symbol;
+declare const kAlias: unique symbol;
+declare const kAliasOwner: unique symbol;
+declare const kSimple: unique symbol;
+declare const kSimpleOwner: unique symbol;
 interface IRAnalysis {
     [kMorph]?: boolean;
+    [kMorphOwner]?: object;
+    [kAlias]?: boolean;
+    [kAliasOwner]?: object;
+    [kSimple]?: boolean;
+    [kSimpleOwner]?: object;
+    /** Node-local metadata used for shallow error formatting. */
+    cfg?: ErrorConfig;
+    /** True when `desc` was derived from the node itself rather than authored via `.describe()`. */
+    descAuto?: boolean;
 }
 /**
  * The parser-facing surface of an embedded `Type` instance.
@@ -26,13 +40,20 @@ export interface EmbeddableSchema {
     ir: IR;
     /** True when the schema carries `.pipe()`/`.narrow()` steps. */
     hasSteps: boolean;
+    /** Output IR of the last `.to(target)` step, when statically known. */
+    stepOut?: IR;
+    /** True when the last pipe step is bare — output shape statically unknown. */
+    opaqueOutput?: boolean;
     /** `.default()` payload; a function is a factory invoked per fill. */
     defaultValue?: unknown;
     hasDefault: boolean;
+    /** Precomputed output for a non-factory default after validation and morphs. */
+    defaultOutput?: unknown;
+    hasDefaultOutput?: boolean;
     /** `.describe()` annotation, emitted into JSON Schema. */
     description?: string;
     /** Full validate+morph pipeline (identical to calling the schema). */
-    run(value: unknown): unknown;
+    run(value: unknown, path?: readonly PropertyKey[]): unknown;
 }
 /** Policy for undeclared object keys. */
 export type Extras = "keep" | "reject" | "delete";
@@ -52,6 +73,8 @@ export interface TupleItemIR {
     def?: unknown;
     defFactory?: boolean;
     hasDefault?: boolean;
+    /** True once the default has been validated and static morph output precomputed. */
+    defValidated?: boolean;
 }
 /** Fixed, optional, variadic, and postfix tuple sequence. */
 export interface TupleIR {
@@ -124,12 +147,17 @@ export type IR = IRAnalysis & ({
     k: "object";
     props: PropIR[];
     index?: IR;
+    symbolIndex?: IR;
+    patternIndexes?: {
+        key: IR;
+        val: IR;
+    }[];
     extras: Extras;
     desc?: string;
 } | {
     k: "refine";
     base: IR;
-    pred: (value: unknown) => boolean;
+    pred: (value: unknown) => boolean | OmpErrors;
     expected: string;
     json?: Record<string, unknown>;
     desc?: string;
@@ -157,28 +185,51 @@ export type IR = IRAnalysis & ({
     desc?: string;
 });
 export interface PropIR {
-    key: string;
+    key: PropertyKey;
     opt: boolean;
     val: IR;
     /** Default payload (value, or factory when `defFactory`); missing key is filled. */
     def?: unknown;
     defFactory?: boolean;
     hasDefault?: boolean;
+    /** True once the default has been validated and static morph output precomputed. */
+    defValidated?: boolean;
 }
 /** Definition input accepted by `type()` and object property values. */
 export type Def = string | RegExp | Date | EmbeddableSchema | readonly unknown[] | {
     readonly [k: string]: unknown;
 };
-/** Resolve a named scope alias to its lazy IR reference. */
-export type AliasResolver = (name: string) => IR | undefined;
+/** Resolve named scope aliases and, when present, scoped generic invocations. */
+export interface AliasResolver {
+    (name: string): IR | undefined;
+    hasGeneric?(name: string): boolean;
+    generic?(name: string, arguments_: readonly IR[]): IR | undefined;
+}
+/** Declare that `resolve` only intercepts `this` (see THIS_ONLY_RESOLVERS). */
+export declare function markThisOnlyResolver(resolve: AliasResolver): void;
+/** Install the assignability comparator used by `Extract`/`Exclude`. */
+export declare function useAssignability(compare: (source: IR, target: IR) => boolean): void;
+/**
+ * Distribute `base` over its union members, keeping those assignable to
+ * `target` (`keepAssignable`) or those that are not (`Exclude`).
+ */
+export declare function distributeFilter(base: IR, target: IR, keepAssignable: boolean): IR;
 /** Embed a schema value: inline pure structure, keep `sub` nodes for stepped schemas. */
 export declare function embed(schema: EmbeddableSchema): IR;
 /** Build the runtime schema for an object's or tuple's keys. */
 export declare function keyOf(node: IR): IR;
 /** Parse a definition, optionally resolving names from an enclosing scope. */
 export declare function parseDef(def: unknown, resolve?: AliasResolver): IR;
+/** Whether `ir` needs no construction-time normalization or morph analysis. */
+export declare function isSimpleIR(ir: IR): boolean;
 /** True when validating `ir` can produce an output different from its input. */
 export declare function hasMorph(ir: IR): boolean;
+/**
+ * True when a traversal of `ir` can revisit nodes through recursive aliases,
+ * requiring cycle guards in the interpreter. Embedded sub-schemas run their
+ * own guarded traversal and are intentionally not inspected.
+ */
+export declare function hasAlias(ir: IR): boolean;
 /** Human-readable expectation for error messages, e.g. `"a string"`. */
 export declare function expectedOf(ir: IR): string;
 export {};

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

@@ -2,7 +2,16 @@ import type { IR } from "./ir.js";
 export interface JsonSchemaOptions {
     description?: string;
     target?: string;
-    dialect?: string;
+    dialect?: string | null;
+    /**
+     * Which side of morphs and defaults to describe:
+     * - `'input'` — accepted payloads: morphs emit their input shape, defaulted
+     *   properties are optional (with `default` annotations).
+     * - `'output'` — produced values: morphs emit their output shape, defaulted
+     *   properties are required (always present after validation).
+     * Unset keeps the hybrid legacy behavior (morph output, defaults optional).
+     */
+    io?: "input" | "output";
     fallback?: (context: {
         base: Record<string, unknown>;
     }) => unknown;