@oh-my-pi/omptype 17.2.6 → 17.2.8

package/dist/types/errors.d.ts

@@ -7,45 +7,81 @@
  * construction stores only the path, the expectation, and the offending value.
  * All human-readable strings are built lazily on property access.
  */
+/** Context supplied to configurable error formatters. */
+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 | ((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 {
+    #private;
     /** Property path from the root to the failing value (empty at root). */
     readonly path: PropertyKey[];
-    /** Human-readable expectation, e.g. `"a string"` or `"at most 3600"`. */
-    readonly expected: string;
     /** The value that failed validation. */
     readonly data: unknown;
     constructor(
     /** Property path from the root to the failing value (empty at root). */
-    path: PropertyKey[], 
-    /** Human-readable expectation, e.g. `"a string"` or `"at most 3600"`. */
-    expected: string, 
+    path: PropertyKey[], expected: string, 
     /** The value that failed validation. */
-    data: unknown);
+    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. */
+    get expected(): string;
     /** Short description of the received value, e.g. `"a number"` or `"missing"`. */
     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;
 /**
- * Aggregate of validation failures; the value returned by a schema call on
- * invalid input. Array-like so callers can `.map()` over entries.
+ * Validation failure result. The common single-error case remains lazy;
+ * traversal only materializes an entry array when a second error is appended.
  */
-export declare class OmpErrors extends Array<OmpError> {
-    static get [Symbol.species](): typeof Array;
-    /** Single-failure constructor used by generated validators. */
-    static single(path: PropertyKey[], expected: string, data: unknown): OmpErrors;
-    /** Prefix every entry's path with `key` (used when nesting sub-schemas). */
+type StoredPath = PropertyKey[] | PropertyKey | undefined;
+export declare class OmpErrors implements Iterable<OmpError> {
+    #private;
+    constructor(path: StoredPath, expected: string, data: unknown, config?: ErrorConfig);
+    get length(): number;
+    get 0(): OmpError;
+    static single(path: PropertyKey[], expected: string, data: unknown, config?: ErrorConfig): OmpErrors;
+    /** 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;
-    /** Human-readable digest of every failure, one per line. Built lazily. */
+    /** Apply schema-local message formatting without rebuilding failures. */
+    configure(config: ErrorConfig): this;
+    get byPath(): Readonly<Record<string, OmpError>>;
+    map<result>(fn: (error: OmpError, index: number, errors: OmpErrors) => result): result[];
+    filter(fn: (error: OmpError, index: number, errors: OmpErrors) => unknown): OmpError[];
+    [Symbol.iterator](): IterableIterator<OmpError>;
+    /** @internal Render multiple branch failures as alternatives rather than independent failures. */
+    asAlternatives(): this;
     get summary(): string;
     toString(): string;
-    /** Throw a `TraversalError` carrying the summary. */
     throw(): never;
 }
 /** Error thrown by `Type.assert` on invalid input. */
@@ -61,3 +97,4 @@ export declare class TraversalError extends Error {
 export declare class OmpTypeError extends Error {
     constructor(message: string);
 }
+export {};

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

@@ -1,12 +1,12 @@
 /**
  * omptype — ArkType-compatible schema validation with a lazy JIT runtime.
  *
- * Drop-in for the arktype surface this repo uses:
- * `type()`, `Type`, `type.errors` / `OmpErrors`, `type.enumerated()`,
- * `.or/.and/.array/.pipe/.narrow/.describe/.default/.allows/.assert/.toJsonSchema`,
- * plus `typeof schema.infer` static inference.
+ * ArkType-compatible `type()`/`Type`, keyword modules, recursive scopes,
+ * composition and morph APIs, structured errors, input/output inference, and
+ * 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

@@ -1,49 +1,165 @@
-/** Type-level output inference for the definition forms accepted by omptype. */
+/** Type-level input and output inference for definitions accepted by omptype. */
 type Whitespace = " " | "\n" | "\r" | "\t";
 type TrimLeft<s extends string> = s extends `${Whitespace}${infer rest}` ? TrimLeft<rest> : s;
 type TrimRight<s extends string> = s extends `${infer rest}${Whitespace}` ? TrimRight<rest> : s;
 type Trim<s extends string> = TrimLeft<TrimRight<s>>;
-type InferPrimitive<s extends string> = s extends "string" | "string.url" ? string : s extends "number" | "number.integer" ? number : s extends "boolean" ? boolean : s extends "null" ? null : s extends "undefined" ? undefined : s extends "unknown" ? unknown : s extends "object" ? object : s extends "bigint" ? bigint : s extends "true" ? true : s extends "false" ? false : never;
-type InferMember<member extends string> = Trim<member> extends infer s extends string ? s extends `${infer element}[]` ? InferMember<element>[] : s extends `'${infer literal}'` | `"${infer literal}"` ? literal : s extends `${infer literal extends number}` ? literal : InferPrimitive<s> extends infer primitive ? [primitive] extends [never] ? s extends `${string}string${string}` ? string : s extends `${string}number${string}` ? number : unknown : primitive : unknown : unknown;
-/** Split top-level unions without distributing over the accumulated members. */
+/**
+ * Flat keyword lookup. An indexed access is one instantiation level, unlike a
+ * nested conditional chain — this sits under every string-DSL property, so its
+ * depth is multiplied by every layer of object nesting above it.
+ * `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}>` | `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
+ * instantiation depth where the previous `extends infer` ladder nested every
+ * 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] : [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;
-/** String-DSL-only inference; safe inside recursive interfaces (never probes `Type`). */
-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>[] : InferUnion<trimmed> : unknown;
-type HasDefault<def> = def extends string ? HasInlineDefault<def> : def extends {
+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 `${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;
-type DefinitionKeys<def extends object> = Exclude<keyof def, "+" | "[string]">;
-/** Optional when the key carries a `?` suffix or the string value does (`limit: "number?"`). */
-type IsOptionalProp<key, def> = key extends `${string}?` ? true : def extends string ? Trim<def> extends `${string}?` ? true : false : false;
+type DefinitionKeys<def extends object> = Exclude<keyof def, "+" | "[string]" | "...">;
+type IsOptionalProp<key, def> = key extends `${string}?` ? true : def extends string ? Trim<def> extends `${string}?` ? true : false : def extends readonly [unknown, "?"] ? true : false;
 type PropName<key extends PropertyKey> = key extends `${infer name}?` ? name : key;
-type RequiredProperties<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>]-?: InferDef<def[key]>;
-};
-type OptionalProperties<def extends object> = {
-    -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? HasDefault<def[key]> extends true ? never : PropName<key> : never]?: InferDef<def[key]>;
-};
+type UnwrapProperty<def> = def extends readonly [infer value, "?" | "=", ...unknown[]] ? value : def;
 type Simplify<t> = {
     [key in keyof t]: t[key];
 };
-type PropertiesOf<def extends object> = Simplify<RequiredProperties<def> & OptionalProperties<def>>;
-type InferObject<def extends object> = "[string]" extends keyof def ? [DefinitionKeys<def>] extends [never] ? Record<string, InferDef<def["[string]"]>> : PropertiesOf<def> & Record<string, InferDef<def["[string]"]>> : PropertiesOf<def>;
-/** Object-literal inference for fluent composition without re-inspecting the containing `Type`. */
+type OutputRequired<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>]-?: InferDef<UnwrapProperty<def[key]>>;
+};
+type OutputOptional<def extends object> = {
+    -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? HasDefault<def[key]> extends true ? never : PropName<key> : never]?: InferDef<UnwrapProperty<def[key]>>;
+};
+type InputRequired<def extends object> = {
+    -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true ? never : HasDefault<def[key]> extends true ? never : PropName<key>]-?: InferDefIn<UnwrapProperty<def[key]>>;
+};
+type InputOptional<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]?: InferDefIn<UnwrapProperty<def[key]>>;
+};
+/**
+ * CYCLE SAFETY: when a fluent generic method is called on a schema whose def
+ * embeds other schemas, TypeScript instantiates `InferDef<def>` while `def`
+ * is still generic. `"..." extends keyof def` resolves TRUE under permissive
+ * instantiation (`keyof any` contains every literal), so spread/index members
+ * cannot be deferred by wrapper conditionals — a bare `InferDef<def["..."]>`
+ * member re-enters this expansion and instantiates without bound (TS2589).
+ * Interface members only instantiate when resolved, so routing the recursive
+ * reference through `DefBox` keeps generic instantiation shallow: it stops at
+ * a type reference plus an indexed access instead of expanding `InferDef`.
+ */
+interface DefBox<def> {
+    readonly out: InferDef<def>;
+    readonly in: InferDefIn<def>;
+}
+type OutputSpread<def extends object> = "..." extends keyof def ? DefBox<def["..."]>["out"] : unknown;
+type InputSpread<def extends object> = "..." extends keyof def ? DefBox<def["..."]>["in"] : unknown;
+type OutputIndex<def extends object> = "[string]" extends keyof def ? Record<string, DefBox<def["[string]"]>["out"]> : unknown;
+type InputIndex<def extends object> = "[string]" extends keyof def ? Record<string, DefBox<def["[string]"]>["in"]> : unknown;
+type InferObject<def extends object> = "[string]" extends keyof def ? [DefinitionKeys<def>] extends [never] ? Record<string, DefBox<def["[string]"]>["out"]> : Simplify<OutputRequired<def> & OutputOptional<def> & OutputSpread<def>> & OutputIndex<def> : Simplify<OutputRequired<def> & OutputOptional<def> & OutputSpread<def>>;
+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 LiteralRequiredProperties<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<def[key]>;
+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]>>;
+};
+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 LiteralOptionalProperties<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<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-only inference for fluent branches; never inspects embedded schema types. */
-export type InferObjectLiteral<def extends object> = Simplify<LiteralRequiredProperties<def> & LiteralOptionalProperties<def>>;
+/** 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[];
+type InferTupleOutput<defs extends readonly unknown[], result extends unknown[] = []> = defs extends readonly [] ? result : defs extends readonly ["...", infer spread, ...infer rest] ? [...result, ...SpreadOutput<spread>, ...InferTupleOutput<rest>] : defs extends readonly [infer head, ...infer rest] ? head extends readonly [infer value, "?"] ? InferTupleOutput<rest, [...result, InferDef<value>?]> : head extends readonly [infer value, "=", unknown] ? InferTupleOutput<rest, [...result, InferDef<value>]> : InferTupleOutput<rest, [...result, InferDef<head>]> : result;
+type InferTupleInput<defs extends readonly unknown[], result extends unknown[] = []> = defs extends readonly [] ? result : defs extends readonly ["...", infer spread, ...infer rest] ? [...result, ...SpreadInput<spread>, ...InferTupleInput<rest>] : defs extends readonly [infer head, ...infer rest] ? head extends readonly [infer value, "?" | "=", ...unknown[]] ? InferTupleInput<rest, [...result, InferDefIn<value>?]> : InferTupleInput<rest, [...result, InferDefIn<head>]> : result;
+/**
+ * True only for `any` (`1 & any` is `any`; `0 extends any` holds). During
+ * relation checking TypeScript instantiates these aliases permissively with
+ * every type parameter replaced by `any`, and under `any` the object branch
+ * recurses forever (`any["..."]` is `any` again). Cutting `any` off up front
+ * makes permissive instantiation terminate immediately, mirroring ArkType's
+ * `anyOrNever` guards.
+ */
+type IsAny<def> = 0 extends 1 & def ? true : false;
 /** Infer the validated output type produced by a definition. */
-export type InferDef<def = unknown> = def extends {
-    infer: infer output;
-} ? output : def extends string ? InferString<def> : def extends readonly [infer element, "[]"] ? InferDef<element>[] : def extends object ? InferObject<def> : unknown;
-/** Input-side defaults and morphs are not distinguished yet. */
-export type InferDefIn<def = unknown> = InferDef<def>;
+export type InferDef<def = unknown> = IsAny<def> extends true ? unknown : def extends {
+    readonly infer: infer output;
+} ? output : def extends string ? InferString<def> : def extends RegExp ? string : def extends readonly [infer element, "[]"] ? InferDef<element>[] : def extends readonly [infer left, "|", infer right] ? InferDef<left> | InferDef<right> : def extends readonly [infer left, "&", infer right] ? InferDef<left> & InferDef<right> : def extends readonly [unknown, "=>", (...args: never[]) => infer output] ? output : def extends readonly [unknown, "|>", infer output] ? InferDef<output> : def extends readonly [infer base, ":", unknown] | readonly [infer base, "@", unknown] ? InferDef<base> : def extends readonly ["keyof", infer base] ? keyof InferDef<base> : def extends readonly ["instanceof", ...infer constructors] ? InstanceOf<constructors[number]> : def extends readonly ["===", ...infer values] ? values[number] : def extends readonly unknown[] ? InferTupleOutput<def> : def extends object ? InferObject<def> : unknown;
+/** Infer values accepted before defaults and morphs are applied. */
+export type InferDefIn<def = unknown> = IsAny<def> extends true ? unknown : def extends {
+    readonly inferIn: infer input;
+} ? input : def extends string ? InferStringIn<def> : def extends RegExp ? string : def extends readonly [infer element, "[]"] ? InferDefIn<element>[] : def extends readonly [infer left, "|", infer right] ? InferDefIn<left> | InferDefIn<right> : def extends readonly [infer left, "&", infer right] ? InferDefIn<left> & InferDefIn<right> : def extends readonly [infer input, "=>", unknown] | readonly [infer input, "|>", unknown] ? InferDefIn<input> : def extends readonly [infer base, ":", unknown] | readonly [infer base, "@", unknown] ? InferDefIn<base> : def extends readonly ["keyof", infer base] ? keyof InferDefIn<base> : def extends readonly ["instanceof", ...infer constructors] ? InstanceOf<constructors[number]> : def extends readonly ["===", ...infer values] ? values[number] : def extends readonly unknown[] ? InferTupleInput<def> : def extends object ? InferObjectIn<def> : unknown;
 export {};

package/dist/types/interp.d.ts

@@ -1,6 +1,6 @@
 /**
- * Tree-walking validator used for a schema's first few calls (before the JIT
- * compiler kicks in) and as the fallback for IR shapes the compiler declines.
+ * Tree-walking validator used for a schema's first few calls and as the
+ * targeted fallback for recursive or predicate-only JIT subtrees.
  *
  * Semantics must stay in lockstep with `compile.ts`:
  * - success returns the output value; the input is returned as-is unless the
@@ -10,8 +10,17 @@
  */
 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;
 /**
  * Detailed failure for a union: descend into the member the value was clearly
  * aimed at — unique runtime-kind match, else an object member whose literal
@@ -21,4 +30,4 @@ export declare function walk(ir: IR, value: unknown): unknown;
  */
 export declare function unionFail(ir: IR & {
     k: "union";
-}, v: unknown, path: PropertyKey[]): OmpErrors;
+}, v: unknown, path: PropertyKey[], expected?: string): OmpErrors;

package/dist/types/ir.d.ts

@@ -9,8 +9,27 @@
  * consumed by the interpreter (`interp.ts`), the JIT compiler (`compile.ts`),
  * and the JSON Schema emitter (`json-schema.ts`).
  */
+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.
  * `type.ts` implements this on every schema it creates.
@@ -21,17 +40,51 @@ 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";
-export type IR = {
+/** Constructor accepted by `type.instanceOf` and tuple `instanceof` expressions. */
+export type Constructor = abstract new (...args: never[]) => object;
+/** Context available to in-definition morph callbacks. */
+export interface MorphContext {
+    /** Return a validation error at the current path. */
+    error(expectation: string): OmpErrors;
+    /** Alias of `error` matching ArkType's rejection vocabulary. */
+    reject(expectation: string): OmpErrors;
+}
+/** One fixed tuple position, optionally absent or defaulted. */
+export interface TupleItemIR {
+    val: IR;
+    opt: boolean;
+    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 {
+    k: "tuple";
+    prefix: TupleItemIR[];
+    variadic?: IR;
+    postfix: IR[];
+    desc?: string;
+}
+export type IR = IRAnalysis & ({
     k: "unknown";
     desc?: string;
 } | {
@@ -46,6 +99,12 @@ export type IR = {
 } | {
     k: "bigint";
     desc?: string;
+} | {
+    k: "symbol";
+    desc?: string;
+} | {
+    k: "never";
+    desc?: string;
 }
 /** Any non-null object (the bare `object` keyword). */
  | {
@@ -64,6 +123,7 @@ export type IR = {
     xmin?: boolean;
     xmax?: boolean;
     int?: boolean;
+    divisor?: number;
     desc?: string;
 } | {
     k: "lit";
@@ -73,43 +133,103 @@ export type IR = {
     k: "union";
     members: IR[];
     desc?: string;
+} | {
+    k: "intersection";
+    members: IR[];
+    desc?: string;
 } | {
     k: "array";
     el: IR;
     min?: number;
     max?: number;
     desc?: string;
-} | {
+} | TupleIR | {
     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 | OmpErrors;
+    expected: string;
+    json?: Record<string, unknown>;
+    desc?: string;
+} | {
+    k: "morph";
+    input: IR;
+    fn: (value: unknown, context: MorphContext) => unknown;
+    out?: IR;
+    desc?: string;
+} | {
+    k: "instance";
+    ctor: Constructor;
+    expected: string;
+    desc?: string;
+} | {
+    k: "alias";
+    name: string;
+    resolve: () => IR;
+    desc?: string;
 }
 /** Embedded schema with runtime steps; validated by calling `run`. */
  | {
     k: "sub";
     schema: EmbeddableSchema;
     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 | EmbeddableSchema | readonly Def[] | {
-    readonly [k: string]: Def;
+export type Def = string | RegExp | Date | EmbeddableSchema | readonly unknown[] | {
+    readonly [k: string]: unknown;
 };
+/** 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;
-/** Parse a definition (string DSL, object literal, tuple, or embedded schema) into IR. */
-export declare function parseDef(def: Def): 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

@@ -1,8 +1,22 @@
 import type { IR } from "./ir.js";
 export interface JsonSchemaOptions {
     description?: string;
+    target?: 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;
 }
 type JsonSchema = Record<string, unknown>;
-/** Emit the draft-2020-12 JSON Schema represented by an IR tree. */
+/** Emit the requested JSON Schema dialect represented by an IR tree. */
 export declare function irToJsonSchema(ir: IR, options?: JsonSchemaOptions): JsonSchema;
 export {};

package/dist/types/keywords.d.ts

@@ -0,0 +1,7 @@
+import type { IR } from "./ir.js";
+/** Lower a built-in keyword into fresh validation IR. */
+export declare function keywordIR(name: string): IR | undefined;
+/** Lower a regular expression into a string refinement. */
+export declare function patternIR(regex: RegExp): IR;
+/** Lower an ArkType-style template literal into a string pattern. */
+export declare function templateIR(source: string): IR;