@oh-my-pi/omptype 17.2.6 → 17.2.7

package/dist/types/errors.d.ts

@@ -7,21 +7,38 @@
  * 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 data: unknown;
+    readonly expected: string;
+    readonly actual: string;
+    readonly problem: string;
+}
+/** Per-schema overrides for validation error text. */
+export interface ErrorConfig {
+    readonly expected?: string | ((context: ErrorContext) => string);
+    readonly actual?: string | ((context: ErrorContext) => string);
+    readonly problem?: string | ((context: ErrorContext) => string);
+    readonly message?: string | ((context: ErrorContext) => string);
+}
 /** 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);
+    /** 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>)`. */
@@ -33,19 +50,37 @@ export declare class OmpError {
 /** 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.
+ * 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.
  */
-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;
+    /** 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 0(): OmpError;
+    static single(path: PropertyKey[], expected: string, data: unknown, config?: ErrorConfig): OmpErrors;
+    /** Prefix the 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 the failure. */
+    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. */
     get summary(): string;
     toString(): string;
-    /** Throw a `TraversalError` carrying the summary. */
+    /** Throw a `TraversalError` carrying this result. */
     throw(): never;
 }
 /** Error thrown by `Type.assert` on invalid input. */
@@ -61,3 +96,4 @@ export declare class TraversalError extends Error {
 export declare class OmpTypeError extends Error {
     constructor(message: string);
 }
+export {};

package/dist/types/index.d.ts

@@ -1,10 +1,9 @@
 /**
  * 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 "./infer.js";

package/dist/types/infer.d.ts

@@ -1,49 +1,126 @@
-/** 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".
+ */
+interface PrimitiveMap {
+    string: string;
+    "string.url": string;
+    number: number;
+    "number.integer": number;
+    boolean: boolean;
+    null: null;
+    undefined: undefined;
+    unknown: unknown;
+    any: unknown;
+    object: object;
+    bigint: bigint;
+    symbol: symbol;
+    Date: Date;
+    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;
+/**
+ * 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] : InferUtility<s> extends infer utility ? [utility] extends [never] ? InferMemberFallback<s> : utility : unknown;
+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>;
 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> = 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>;
+/** 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;
+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 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 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 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 for fluent branches; never inspects embedded schema types. */
-export type InferObjectLiteral<def extends object> = Simplify<LiteralRequiredProperties<def> & LiteralOptionalProperties<def>>;
+/** Object-literal-only inference that does not inspect embedded schema internals. */
+export type InferObjectLiteral<def extends object> = Simplify<LiteralRequired<def> & LiteralOptional<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
@@ -12,6 +12,8 @@ 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;
+/** 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 +23,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,13 @@
  * consumed by the interpreter (`interp.ts`), the JIT compiler (`compile.ts`),
  * and the JSON Schema emitter (`json-schema.ts`).
  */
+import { 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;
+interface IRAnalysis {
+    [kMorph]?: boolean;
+}
 /**
  * The parser-facing surface of an embedded `Type` instance.
  * `type.ts` implements this on every schema it creates.
@@ -31,7 +36,32 @@ export interface EmbeddableSchema {
 }
 /** 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;
+}
+/** 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 +76,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 +100,7 @@ export type IR = {
     xmin?: boolean;
     xmax?: boolean;
     int?: boolean;
+    divisor?: number;
     desc?: string;
 } | {
     k: "lit";
@@ -73,25 +110,52 @@ 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;
     extras: Extras;
     desc?: string;
+} | {
+    k: "refine";
+    base: IR;
+    pred: (value: unknown) => boolean;
+    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;
     opt: boolean;
@@ -102,14 +166,19 @@ export interface PropIR {
     hasDefault?: 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 a named scope alias to its lazy IR reference. */
+export type AliasResolver = (name: string) => IR | undefined;
 /** 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;
 /** True when validating `ir` can produce an output different from its input. */
 export declare function hasMorph(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,13 @@
 import type { IR } from "./ir.js";
 export interface JsonSchemaOptions {
     description?: string;
+    target?: string;
+    dialect?: string;
+    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;