@oh-my-pi/omptype 17.2.6 → 17.2.7

package/dist/types/type.d.ts

@@ -1,6 +1,7 @@
-import { OmpErrors } from "./errors.js";
-import type { InferDef, InferObjectLiteral, InferString } from "./infer.js";
-import { type Def, hasMorph, type IR, IR_BRAND } from "./ir.js";
+import { type ErrorConfig, OmpErrors } from "./errors.js";
+import type { InferDef, InferDefIn, InferObjectLiteral, InferString } from "./infer.js";
+import { type Constructor, type Def, hasMorph, type IR, IR_BRAND } from "./ir.js";
+import { type JsonSchemaOptions } from "./json-schema.js";
 /** Context passed to `.narrow()` / `.pipe()` callbacks. */
 export interface NarrowContext {
     /** Record `must be <expectation>` and signal failure. */
@@ -8,20 +9,39 @@ export interface NarrowContext {
     /** Record a custom problem and signal failure. */
     reject(problem: string): false;
 }
-/** Options accepted by `Type.toJsonSchema` (ArkType-compatible; emission is always draft 2020-12). */
-export interface ToJsonSchemaOptions {
-    target?: string;
-    dialect?: string;
-    fallback?: (ctx: {
-        base: Record<string, unknown>;
-    }) => unknown;
+/** Schema metadata and validation-message overrides accepted by `.configure()`. */
+export interface SchemaConfig extends ErrorConfig {
+    readonly description?: string;
+}
+/** Options accepted by `Type.toJsonSchema`. */
+export interface ToJsonSchemaOptions extends JsonSchemaOptions {
 }
-interface SchemaInference<out t> {
+declare const brand: unique symbol;
+/** Inference-only nominal brand attached by `.brand(name)`. */
+export type Brand<t, name extends string> = t & {
+    readonly [brand]: name;
+};
+interface SchemaInference<out t, i = t> {
     readonly [IR_BRAND]: true;
     readonly infer: t;
+    readonly inferIn: i;
+}
+/** Property descriptor exposed by object schemas and consumed by `.map()`. */
+export interface TypeProperty {
+    readonly kind: "required" | "optional";
+    readonly key: PropertyKey;
+    readonly value: FluentType<unknown>;
+    readonly default?: unknown;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+/** Structural node returned by `.select()`. */
+export interface SelectedNode {
+    readonly kind: string;
+    readonly node: IR;
+    readonly unit?: unknown;
 }
 /** A compiled schema: callable validator plus composition methods. */
-export interface Type<out t = unknown> {
+export interface Type<out t = unknown, i = t> {
     (data: unknown): t | OmpErrors;
     readonly [IR_BRAND]: true;
     /** Structural IR (base type; runtime steps live in `steps`). */
@@ -36,65 +56,234 @@ export interface Type<out t = unknown> {
     /** Inference-only output type (no runtime value). */
     readonly infer: t;
     /** Inference-only input type (no runtime value). */
-    readonly inferIn: t;
+    readonly inferIn: i;
     /** Structural + narrow check without running pipes. */
-    allows(data: unknown): data is t;
+    allows(data: unknown): data is i;
     /** Validate and return output, throwing `TraversalError` on failure. */
     assert(data: unknown): t;
-    /** JSON Schema (draft 2020-12) for this schema's structural base. */
+    /** Validate a statically typed input and return its output. */
+    from(data: i): t;
+    /** JSON Schema for this schema's structural base. */
     toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
 }
-/** Schema returned by omptype builders, with precise object-literal composition inference. */
-export interface FluentType<t = unknown> extends Type<t> {
-    describe(description: string): FluentType<t>;
-    default(value: t | (() => t)): FluentType<t>;
-    or<r>(def: SchemaInference<r>): FluentType<t | r>;
-    or<const def extends string>(def: def): FluentType<t | InferString<def>>;
-    or<const def extends Record<string, unknown>>(def: def): FluentType<t | InferObjectLiteral<def>>;
+type MergeTypes<left, right> = left extends object ? right extends object ? Omit<left, keyof right> & right : right : right;
+interface FluentMethods<t, i> {
+    describe(description: string): FluentType<t, i>;
+    configure(config: SchemaConfig): FluentType<t, i>;
+    default(value: t | (() => t)): FluentType<t, i>;
+    optional(): readonly [SchemaInference<t, i>, "?"];
+    or<r, ri>(def: SchemaInference<r, ri>): FluentType<t | r, i | ri>;
+    or<const def extends string>(def: def): FluentType<t | InferString<def>, i | InferString<def>>;
+    or<const def extends Record<string, unknown>>(def: def): FluentType<t | InferObjectLiteral<def>, i | InferObjectLiteral<def>>;
     or(def: Def): FluentType<unknown>;
-    and<r>(def: SchemaInference<r>): FluentType<t & r>;
-    and<const def extends Record<string, unknown>>(def: def): FluentType<t & InferObjectLiteral<def>>;
+    and<r, ri>(def: SchemaInference<r, ri>): FluentType<t & r, i & ri>;
+    and<const def extends Record<string, unknown>>(def: def): FluentType<t & InferObjectLiteral<def>, i & InferObjectLiteral<def>>;
     and(def: Def): FluentType<unknown>;
-    array(): FluentType<t[]>;
-    atLeastLength(bound: number): FluentType<t>;
-    atMostLength(bound: number): FluentType<t>;
-    atLeast(bound: number): FluentType<t>;
-    atMost(bound: number): FluentType<t>;
-    pipe<r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>>;
-    narrow<narrowed extends t>(fn: (data: t, ctx: NarrowContext) => data is narrowed): FluentType<narrowed>;
-    narrow(fn: (data: t, ctx: NarrowContext) => boolean): FluentType<t>;
+    equals(def: Def): boolean;
+    ifEquals(def: Def): FluentType<t, i> | undefined;
+    extends(def: Def): boolean;
+    overlaps(def: Def): boolean;
+    distribute<r>(mapper: (branch: FluentType<unknown>) => SchemaInference<r>): FluentType<r>;
+    select(kind: string): readonly SelectedNode[];
+    array(): FluentType<t[], i[]>;
+    atLeastLength(bound: number): FluentType<t, i>;
+    atMostLength(bound: number): FluentType<t, i>;
+    moreThanLength(bound: number): FluentType<t, i>;
+    lessThanLength(bound: number): FluentType<t, i>;
+    exactlyLength(bound: number): FluentType<t, i>;
+    atLeast(bound: number): FluentType<t, i>;
+    atMost(bound: number): FluentType<t, i>;
+    moreThan(bound: number): FluentType<t, i>;
+    lessThan(bound: number): FluentType<t, i>;
+    divisibleBy(divisor: number): FluentType<t, i>;
+    positive(): FluentType<t, i>;
+    negative(): FluentType<t, i>;
+    nonNegative(): FluentType<t, i>;
+    nonPositive(): FluentType<t, i>;
+    matching(pattern: RegExp): FluentType<t, i>;
+    atOrAfter(bound: Date): FluentType<t, i>;
+    atOrBefore(bound: Date): FluentType<t, i>;
+    laterThan(bound: Date): FluentType<t, i>;
+    earlierThan(bound: Date): FluentType<t, i>;
+    pipe<r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>, i>;
+    to<const def>(def: def): FluentType<InferDef<def>, i>;
+    filter<narrowed extends i>(fn: (data: i, ctx: NarrowContext) => data is narrowed): FluentType<t, narrowed>;
+    filter(fn: (data: i, ctx: NarrowContext) => boolean): FluentType<t, i>;
+    narrow<narrowed extends t>(fn: (data: t, ctx: NarrowContext) => data is narrowed): FluentType<narrowed, i>;
+    narrow(fn: (data: t, ctx: NarrowContext) => boolean): FluentType<t, i>;
+    brand<const name extends string>(name: name): FluentType<Brand<t, name>, i>;
+    as<castTo>(): FluentType<castTo, i>;
+    extract<r, ri>(def: SchemaInference<r, ri>): FluentType<Extract<t, r>, Extract<i, ri>>;
+    extract<const def extends string>(def: def): FluentType<Extract<t, InferString<def>>, Extract<i, InferString<def>>>;
+    extract(def: Def): FluentType<unknown>;
+    exclude<r, ri>(def: SchemaInference<r, ri>): FluentType<Exclude<t, r>, Exclude<i, ri>>;
+    exclude<const def extends string>(def: def): FluentType<Exclude<t, InferString<def>>, Exclude<i, InferString<def>>>;
+    exclude(def: Def): FluentType<unknown>;
+    onUndeclaredKey(behavior: "ignore" | "reject" | "delete"): FluentType<t, i>;
+    onDeepUndeclaredKey(behavior: "ignore" | "reject" | "delete"): FluentType<t, i>;
 }
+type InputObject<i> = i extends object ? i : object;
+interface ObjectMethods<t extends object, i> {
+    readonly props: readonly TypeProperty[];
+    map(mapper: (property: TypeProperty) => TypeProperty | readonly TypeProperty[]): FluentType<Record<PropertyKey, unknown>>;
+    keyof(): FluentType<Extract<keyof t, PropertyKey>, Extract<keyof InputObject<i>, PropertyKey>>;
+    get<key extends keyof t>(key: key): FluentType<t[key], key extends keyof InputObject<i> ? InputObject<i>[key] : unknown>;
+    pick<const keys extends readonly (keyof t)[]>(...keys: keys): FluentType<Pick<t, keys[number]>, Pick<InputObject<i>, Extract<keys[number], keyof InputObject<i>>>>;
+    omit<const keys extends readonly (keyof t)[]>(...keys: keys): FluentType<Omit<t, keys[number]>, Omit<InputObject<i>, Extract<keys[number], keyof InputObject<i>>>>;
+    partial(): FluentType<Partial<t>, Partial<InputObject<i>>>;
+    required(): FluentType<Required<t>, Required<InputObject<i>>>;
+    merge<r, ri>(def: SchemaInference<r, ri>): FluentType<MergeTypes<t, r>, MergeTypes<i, ri>>;
+    merge<const def extends Record<string, unknown>>(def: def): FluentType<MergeTypes<t, InferObjectLiteral<def>>, MergeTypes<i, InferObjectLiteral<def>>>;
+    merge(def: Def): FluentType<unknown>;
+}
+type ObjectMethodsFor<t, i> = [t] extends [never] ? unknown : [t] extends [readonly unknown[]] ? unknown : [t] extends [object] ? ObjectMethods<t & object, i> : unknown;
+/** Callable schema with fluent methods specialized to its output and input. */
+export type FluentType<t = unknown, i = t> = Type<t, i> & FluentMethods<t, i> & ObjectMethodsFor<t, i>;
 /** Runtime constructor-like value used by ArkType-compatible `instanceof Type` checks. */
 export declare const Type: () => void;
 /**
- * The `type()` builder: parses a definition into a callable schema.
- *
- * The `const def` generic drives static inference (`typeof schema.infer`);
- * the runtime is definition-shape-agnostic, hence the cast.
+ * Parse a definition into a callable schema with distinct input/output inference.
  */
-export declare function type<const def>(def: def): FluentType<InferDef<def>>;
+export declare function type<const def>(def: def): FluentType<InferDef<def>, InferDefIn<def>>;
+/** String keyword with a parser that morphs validated text to another output. */
+export interface ParsedStringKeyword<parsed> extends FluentType<string> {
+    readonly parse: FluentType<parsed, string>;
+}
+/** Morphing string keyword paired with its non-morphing preformatted validator. */
+export interface PreformattedKeyword extends FluentType<string, string> {
+    readonly preformatted: FluentType<string>;
+}
+/** Base64 keyword with its URL-safe alphabet variant. */
+export interface Base64Keyword extends FluentType<string> {
+    readonly url: FluentType<string>;
+}
+/** Date-string keyword family. */
+export interface DateStringKeyword extends ParsedStringKeyword<Date> {
+    readonly iso: ParsedStringKeyword<Date>;
+    readonly epoch: ParsedStringKeyword<Date>;
+}
+/** IP address keyword family. */
+export interface IpKeyword extends FluentType<string> {
+    readonly v4: FluentType<string>;
+    readonly v6: FluentType<string>;
+}
+/** UUID keyword family. */
+export interface UuidKeyword extends FluentType<string> {
+    readonly v1: FluentType<string>;
+    readonly v2: FluentType<string>;
+    readonly v3: FluentType<string>;
+    readonly v4: FluentType<string>;
+    readonly v5: FluentType<string>;
+    readonly v6: FluentType<string>;
+    readonly v7: FluentType<string>;
+    readonly v8: FluentType<string>;
+}
+/** String normalization keyword family. */
+export interface NormalizeKeyword extends PreformattedKeyword {
+    readonly NFC: PreformattedKeyword;
+    readonly NFD: PreformattedKeyword;
+    readonly NFKC: PreformattedKeyword;
+    readonly NFKD: PreformattedKeyword;
+}
+/** Runtime string parsers exposed under `type.parse`. */
+export interface ParseKeyword {
+    readonly number: FluentType<number, string>;
+    readonly integer: FluentType<number, string>;
+    readonly json: FluentType<unknown, string>;
+    readonly date: FluentType<Date, string>;
+    readonly url: FluentType<URL, string>;
+    readonly boolean: FluentType<boolean, string>;
+    readonly bigint: FluentType<bigint, string>;
+}
+/** Full string keyword module attached to `type.string`. */
+export interface StringKeyword extends FluentType<string> {
+    readonly alpha: FluentType<string>;
+    readonly alphanumeric: FluentType<string>;
+    readonly base64: Base64Keyword;
+    readonly capitalize: PreformattedKeyword;
+    readonly creditCard: FluentType<string>;
+    readonly date: DateStringKeyword;
+    readonly digits: FluentType<string>;
+    readonly email: FluentType<string>;
+    readonly hex: FluentType<string>;
+    readonly integer: ParsedStringKeyword<number>;
+    readonly ip: IpKeyword;
+    readonly json: ParsedStringKeyword<unknown>;
+    readonly lower: PreformattedKeyword;
+    readonly normalize: NormalizeKeyword;
+    readonly numeric: ParsedStringKeyword<number>;
+    readonly regex: FluentType<string>;
+    readonly semver: FluentType<string>;
+    readonly trim: PreformattedKeyword;
+    readonly upper: PreformattedKeyword;
+    readonly url: ParsedStringKeyword<URL>;
+    readonly uuid: UuidKeyword;
+}
+/** Number keyword module attached to `type.number`. */
+export interface NumberKeyword extends FluentType<number> {
+    readonly integer: FluentType<number>;
+}
+type Constructed<ctor> = ctor extends abstract new (...args: never[]) => infer instance ? instance : never;
 export declare namespace type {
     /** Error aggregate returned by failed validations (`result instanceof type.errors`). */
     const errors: typeof OmpErrors;
     type errors = OmpErrors;
-    /** Keyword statics for fluent building, e.g. `type.number.atLeast(5)`. */
-    const string: FluentType<string>;
-    const number: FluentType<number>;
-    const boolean: FluentType<boolean>;
-    const unknown: FluentType<unknown>;
-    /** Union of literal values from a runtime array (`type.enumerated(...list)`). */
+    /** String validator and its refinement/morph keyword module. */
+    const string: StringKeyword;
+    /** Runtime parser keyword family. */
+    const parse: ParseKeyword;
+    /** Number validator with integer refinement. */
+    const number: NumberKeyword;
+    /** Boolean validator. */
+    const boolean: FluentType<boolean, boolean>;
+    /** Bigint validator. */
+    const bigint: FluentType<bigint, bigint>;
+    /** Symbol validator. */
+    const symbol: FluentType<symbol, symbol>;
+    /** Non-null object validator. */
+    const object: FluentType<object, object>;
+    /** Unknown validator. */
+    const unknown: FluentType<unknown, unknown>;
+    /** Alias of the unknown validator. */
+    const any: FluentType<unknown, unknown>;
+    /** Validator that rejects every value. */
+    const never: FluentType<never, never>;
+    /** Date instance validator. */
+    const Date: FluentType<Date, Date>;
+    /** Validate instances of `ctor`. */
+    function instanceOf<const ctor extends Constructor>(ctor: ctor): FluentType<Constructed<ctor>>;
+    /** Validate one exact unit value. */
+    function unit<const value>(value: value): FluentType<value>;
+    /** Union of literal values from a runtime array. */
     function enumerated<const values extends readonly unknown[]>(...values: values): FluentType<values[number]>;
-    /** Untyped builder for runtime-assembled definitions (`type.raw({...})`). */
+    /** Build a first-match dispatcher from schema-expression keys and a `default` case. */
+    function match<const cases extends Record<string, unknown>>(cases: cases): (value: unknown) => unknown;
+    /** Preserve a definition's literal type while authoring reusable modules. */
+    function define<const definition>(definition: definition): definition;
+    /** Build a lazy named scope from aliases and recursive definitions. */
+    function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
+    /** Compile a named schema module whose definitions may reference each other. */
+    function module<const definitions extends Record<string, unknown>>(definitions: definitions): {
+        [name in keyof definitions]: Type<InferDef<definitions[name]>, InferDefIn<definitions[name]>>;
+    };
+    /** Build a runtime generic whose parameter names are supplied as `"<t, u>"`. */
+    function generic<const definition>(parameters: string, definition: definition): (...arguments_: readonly unknown[]) => BaseType;
+    /** Untyped builder for runtime-assembled definitions. */
     function raw(def: unknown): BaseType;
 }
 export interface ScopeOptions {
     jitless?: boolean;
 }
-/** ArkType-compatible scope wrapper; omptype's global builder is already lazy. */
-export declare function scope(_aliases: Record<string, unknown>, _options?: ScopeOptions): {
-    type: typeof type;
-};
+/** Callable builder bound to one alias scope. */
+export type ScopedBuilder = <const definition>(definition: definition) => FluentType<InferDef<definition>, InferDefIn<definition>>;
+/** Named schema scope with a scoped builder and compiled module export. */
+export interface TypeScope {
+    readonly type: ScopedBuilder;
+    export(): Record<string, BaseType>;
+}
+/** Build a scope whose aliases resolve lazily, including recursive cycles. */
+export declare function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
 /** A schema whose output type is not statically known (`type.raw` results). */
-export type BaseType = FluentType<unknown>;
+export type BaseType = FluentType<unknown, unknown>;
 /** `hasMorph` re-export for diagnostics/tooling. */
 export { hasMorph };

package/dist/types/zod.d.ts

@@ -21,7 +21,7 @@ export type ZodLikeSafeParseResult<Out> = {
     };
 };
 /** A callable omptype schema carrying the Zod-v4-style fluent surface. */
-export interface ZodLikeSchema<out Out> extends Type<Out> {
+export interface ZodLikeSchema<out Out> extends Type<Out, unknown> {
     readonly _output: Out;
     /** @internal Used while composing object property IR. */
     readonly isOptional: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omptype",
-	"version": "17.2.6",
+	"version": "17.2.7",
 	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -20,7 +20,7 @@
 		"arktype",
 		"jit"
 	],
-	"main": "./src/index.ts",
+	"main": "./dist/js/index.js",
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
 		"check": "biome check . && bun run check:types",
@@ -28,29 +28,41 @@
 		"lint": "biome lint .",
 		"fix": "biome check --write --unsafe .",
 		"fmt": "biome format --write .",
-		"test": "bun test --parallel"
+		"test": "bun test --parallel",
+		"bench": "bun bench/bench.ts"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.14"
+		"@sinclair/typebox": "^0.34.0",
+		"@types/bun": "^1.3.14",
+		"arktype": "2.2.3",
+		"zod": "^4"
 	},
 	"engines": {
+		"node": ">=20",
 		"bun": ">=1.3.14"
 	},
 	"files": [
 		"src",
 		"README.md",
 		"CHANGELOG.md",
-		"dist/types"
+		"dist/types",
+		"dist/js"
 	],
 	"exports": {
 		".": {
 			"types": "./dist/types/index.d.ts",
-			"import": "./src/index.ts"
+			"bun": "./src/index.ts",
+			"default": "./dist/js/index.js"
 		},
 		"./*": {
 			"types": "./dist/types/*.d.ts",
-			"import": "./src/*.ts"
+			"bun": "./src/*.ts",
+			"default": "./dist/js/*.js"
 		},
-		"./*.js": "./src/*.ts"
+		"./*.js": {
+			"types": "./dist/types/*.d.ts",
+			"bun": "./src/*.ts",
+			"default": "./dist/js/*.js"
+		}
 	}
 }

package/src/ark.ts

@@ -6,13 +6,11 @@
  * `from "@oh-my-pi/omptype/ark"` and nothing else changes. New code should
  * import `@oh-my-pi/omptype` directly.
  *
- * Compatibility affordances beyond the plain re-export:
- * - `ArkError` / `ArkErrors` alias `OmpError` / `OmpErrors`.
- * - `scope()` (alias-free form only) returns `{ type }`; the `jitless` flag is
- *   obsolete — omptype always starts interpreted and JIT-compiles lazily.
+ * Compatibility affordance: `ArkError` / `ArkErrors` alias `OmpError` /
+ * `OmpErrors`. All schema builders, including recursive `scope()`, are
+ * re-exported unchanged.
  */
-import { OmpError, OmpErrors, OmpTypeError } from "./errors";
-import { type } from "./type";
+import { OmpError, OmpErrors } from "./errors";
 
 export * from "./index";
 
@@ -20,11 +18,3 @@ export const ArkError = OmpError;
 export type ArkError = OmpError;
 export const ArkErrors = OmpErrors;
 export type ArkErrors = OmpErrors;
-
-/** ArkType `scope()` shim: only the alias-free `scope({}, config?)` form is supported. */
-export function scope(aliases: Record<string, never>, _config?: { jitless?: boolean }): { type: typeof type } {
-	for (const key in aliases) {
-		throw new OmpTypeError(`scope aliases are not supported (found "${key}"); define types directly`);
-	}
-	return { type };
-}