@oh-my-pi/omptype 17.2.6

package/dist/types/typebox.d.ts

@@ -0,0 +1,184 @@
+import { type NarrowContext, type Type as OmpType } from "./type.js";
+export interface Meta {
+    title?: string;
+    description?: string;
+    default?: unknown;
+    examples?: unknown[];
+    [key: string]: unknown;
+}
+export interface StringOpts extends Meta {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+}
+export interface NumberOpts extends Meta {
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+}
+export interface ArrayOpts extends Meta {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+}
+export interface ObjectOpts extends Meta {
+    additionalProperties?: boolean | TSchema;
+}
+declare const OPTIONAL_INNER: unique symbol;
+declare const OBJECT_INFO: unique symbol;
+export interface TypeBoxValidationFailure {
+    message: string;
+}
+export type TypeBoxSafeParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: TypeBoxValidationFailure;
+};
+interface LegacyTypeBoxCompat<T> {
+    /** TypeBox compatibility validator used by legacy extension loaders. */
+    __validator(data: unknown): T | TypeBoxValidationFailure;
+    /** Zod-style compatibility parser used by legacy extensions. */
+    safeParse(input: unknown): TypeBoxSafeParseResult<T>;
+}
+export type TSchema<T = unknown> = OmpType<T> & LegacyTypeBoxCompat<T>;
+export type Static<T extends TSchema> = T["infer"];
+export type TAny = TSchema<unknown>;
+export type TUnknown = TSchema<unknown>;
+export type TNever = TSchema<never>;
+export type TNull = TSchema<null>;
+export type TString = TSchema<string>;
+export type TNumber = TSchema<number>;
+export type TInteger = TSchema<number>;
+export type TBoolean = TSchema<boolean>;
+export type TLiteral<V extends string | number | boolean | null> = TSchema<V>;
+export type TArray<E extends TSchema> = TSchema<Static<E>[]>;
+export type TTuple<E extends readonly TSchema[] = readonly TSchema[]> = TSchema<{
+    -readonly [K in keyof E]: Static<E[K]>;
+}>;
+export type TOptional<E extends TSchema> = TSchema<Static<E> | undefined> & {
+    readonly [OPTIONAL_INNER]: E;
+};
+export type TUnion<E extends readonly TSchema[] = readonly TSchema[]> = TSchema<Static<E[number]>>;
+export type TIntersect<E extends readonly TSchema[] = readonly TSchema[]> = TSchema<UnionToIntersection<Static<E[number]>>>;
+export type TEnum<E extends readonly (string | number)[] = readonly (string | number)[]> = TSchema<E[number]>;
+export type TRecord<K extends TSchema, V extends TSchema> = TSchema<Record<Extract<Static<K>, PropertyKey>, Static<V>>>;
+export type TNullable<E extends TSchema> = TSchema<Static<E> | null>;
+export type TReadonly<E extends TSchema> = TSchema<Readonly<Static<E>>>;
+export type TUnsafe<T = unknown> = TSchema<T>;
+type OptionalKeys<P extends Record<string, TSchema>> = {
+    [K in keyof P]-?: P[K] extends {
+        readonly [OPTIONAL_INNER]: TSchema;
+    } ? K : never;
+}[keyof P];
+type RequiredKeys<P extends Record<string, TSchema>> = Exclude<keyof P, OptionalKeys<P>>;
+type ObjectStatic<P extends Record<string, TSchema>> = {
+    [K in RequiredKeys<P>]: Static<P[K]>;
+} & {
+    [K in OptionalKeys<P>]?: Exclude<Static<P[K]>, undefined>;
+};
+export type TObject<P extends Record<string, TSchema> = Record<string, TSchema>> = TSchema<ObjectStatic<P>>;
+type RequiredProps<P extends Record<string, TSchema>> = {
+    [K in keyof P]: P[K] extends TOptional<infer E> ? E : P[K];
+};
+interface RuntimeType<T> extends OmpType<T> {
+    [OPTIONAL_INNER]?: TSchema;
+    [OBJECT_INFO]?: ObjectInfo;
+    describe(description: string): RuntimeType<T>;
+    default(value: T | (() => T)): RuntimeType<T>;
+    or<R>(schema: OmpType<R>): RuntimeType<T | R>;
+    and<R>(schema: OmpType<R>): RuntimeType<T & R>;
+    array(): RuntimeType<T[]>;
+    atLeastLength(bound: number): RuntimeType<T>;
+    atMostLength(bound: number): RuntimeType<T>;
+    atLeast(bound: number): RuntimeType<T>;
+    atMost(bound: number): RuntimeType<T>;
+    narrow<N extends T>(predicate: (value: T, ctx: NarrowContext) => value is N): RuntimeType<N>;
+    narrow(predicate: (value: T, ctx: NarrowContext) => boolean): RuntimeType<T>;
+}
+type CompatRuntime<T> = RuntimeType<T> & LegacyTypeBoxCompat<T>;
+type ObjectInfo = {
+    props: Record<string, TSchema>;
+    additionalProperties?: boolean | TSchema;
+};
+declare function tString(opts?: StringOpts): TString;
+declare function tLiteral<const V extends string | number | boolean | null>(value: V, opts?: Meta): TLiteral<V>;
+declare function tNever(opts?: Meta): TNever;
+declare function tUnion<const E extends readonly TSchema[]>(schemas: E, opts?: Meta): TUnion<E>;
+declare function tIntersect<const E extends readonly TSchema[]>(schemas: E, opts?: Meta): TSchema<UnionToIntersection<Static<E[number]>>>;
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+declare function tEnum<const E extends Record<string, string | number> | readonly (string | number)[]>(values: E, opts?: Meta): TSchema<E extends readonly (infer V)[] ? V : E[keyof E]>;
+declare function tArray<E extends TSchema>(item: E, opts?: ArrayOpts): TArray<E>;
+declare function tTuple<const E extends readonly TSchema[]>(items: E, opts?: Meta): TTuple<E>;
+declare function tObject<const P extends Record<string, TSchema>>(properties: P, opts?: ObjectOpts): TObject<P>;
+declare function tRecord<K extends TSchema, V extends TSchema>(key: K, value: V, opts?: Meta): TRecord<K, V>;
+declare function tOptional<E extends TSchema>(schema: E, opts?: Meta): TOptional<E>;
+declare function tNullable<E extends TSchema>(schema: E, opts?: Meta): TSchema<Static<E> | null>;
+declare function tPartial<P extends Record<string, TSchema>>(schema: TObject<P>): TSchema<Partial<ObjectStatic<P>>>;
+declare function tRequired<P extends Record<string, TSchema>>(schema: TObject<P>): TObject<RequiredProps<P>>;
+declare function tPick<P extends Record<string, TSchema>, const K extends readonly (keyof P)[]>(schema: TObject<P>, keys: K): TObject<Pick<P, K[number]>>;
+declare function tOmit<P extends Record<string, TSchema>, const K extends readonly (keyof P)[]>(schema: TObject<P>, keys: K): TObject<Omit<P, K[number]>>;
+declare function tComposite<const E extends readonly TObject<Record<string, TSchema>>[]>(schemas: E, opts?: ObjectOpts): TSchema<UnionToIntersection<Static<E[number]>>>;
+declare function tUnsafe<T = unknown>(_jsonSchema?: Record<string, unknown>): TUnsafe<T>;
+export declare const Type: {
+    readonly String: typeof tString;
+    readonly Number: (opts?: NumberOpts) => TNumber;
+    readonly Integer: (opts?: NumberOpts) => TNumber;
+    readonly Boolean: (opts?: Meta) => CompatRuntime<boolean>;
+    readonly Null: (opts?: Meta) => CompatRuntime<null>;
+    readonly Any: (opts?: Meta) => CompatRuntime<unknown>;
+    readonly Unknown: (opts?: Meta) => CompatRuntime<unknown>;
+    readonly Never: typeof tNever;
+    readonly Literal: typeof tLiteral;
+    readonly Union: typeof tUnion;
+    readonly Intersect: typeof tIntersect;
+    readonly Enum: typeof tEnum;
+    readonly Array: typeof tArray;
+    readonly Tuple: typeof tTuple;
+    readonly Object: typeof tObject;
+    readonly Record: typeof tRecord;
+    readonly Optional: typeof tOptional;
+    readonly Nullable: typeof tNullable;
+    readonly Readonly: <E extends TSchema>(schema: E) => E;
+    readonly Partial: typeof tPartial;
+    readonly Required: typeof tRequired;
+    readonly Pick: typeof tPick;
+    readonly Omit: typeof tOmit;
+    readonly Composite: typeof tComposite;
+    readonly Unsafe: typeof tUnsafe;
+};
+export type TypeBuilder = typeof Type;
+declare const _default: {
+    Type: {
+        readonly String: typeof tString;
+        readonly Number: (opts?: NumberOpts) => TNumber;
+        readonly Integer: (opts?: NumberOpts) => TNumber;
+        readonly Boolean: (opts?: Meta) => CompatRuntime<boolean>;
+        readonly Null: (opts?: Meta) => CompatRuntime<null>;
+        readonly Any: (opts?: Meta) => CompatRuntime<unknown>;
+        readonly Unknown: (opts?: Meta) => CompatRuntime<unknown>;
+        readonly Never: typeof tNever;
+        readonly Literal: typeof tLiteral;
+        readonly Union: typeof tUnion;
+        readonly Intersect: typeof tIntersect;
+        readonly Enum: typeof tEnum;
+        readonly Array: typeof tArray;
+        readonly Tuple: typeof tTuple;
+        readonly Object: typeof tObject;
+        readonly Record: typeof tRecord;
+        readonly Optional: typeof tOptional;
+        readonly Nullable: typeof tNullable;
+        readonly Readonly: <E extends TSchema>(schema: E) => E;
+        readonly Partial: typeof tPartial;
+        readonly Required: typeof tRequired;
+        readonly Pick: typeof tPick;
+        readonly Omit: typeof tOmit;
+        readonly Composite: typeof tComposite;
+        readonly Unsafe: typeof tUnsafe;
+    };
+};
+export default _default;

package/dist/types/zod.d.ts

@@ -0,0 +1,100 @@
+import { type Type } from "./type.js";
+interface OptionalSchemaMarker {
+    readonly _optional: true;
+}
+interface RefineOptions {
+    message?: string;
+    error?: string;
+}
+export interface ZodLikeIssue {
+    path: PropertyKey[];
+    message: string;
+}
+export type ZodLikeSafeParseResult<Out> = {
+    success: true;
+    data: Out;
+} | {
+    success: false;
+    error: {
+        message: string;
+        issues: ZodLikeIssue[];
+    };
+};
+/** A callable omptype schema carrying the Zod-v4-style fluent surface. */
+export interface ZodLikeSchema<out Out> extends Type<Out> {
+    readonly _output: Out;
+    /** @internal Used while composing object property IR. */
+    readonly isOptional: boolean;
+    parse(value: unknown): Out;
+    safeParse(value: unknown): ZodLikeSafeParseResult<Out>;
+    min(bound: number): ZodLikeSchema<Out>;
+    max(bound: number): ZodLikeSchema<Out>;
+    int(): ZodLikeSchema<Out>;
+    positive(): ZodLikeSchema<Out>;
+    nonnegative(): ZodLikeSchema<Out>;
+    regex(expression: RegExp, message?: string): ZodLikeSchema<Out>;
+    url(): ZodLikeSchema<Out>;
+    optional(): ZodLikeSchema<Out | undefined> & OptionalSchemaMarker;
+    nullable(): ZodLikeSchema<Out | null>;
+    default(value: Exclude<Out, undefined> | (() => Exclude<Out, undefined>)): ZodLikeSchema<Exclude<Out, undefined>>;
+    describe(description: string): ZodLikeSchema<Out>;
+    refine(predicate: (value: Out) => unknown, messageOrOptions?: string | RefineOptions): ZodLikeSchema<Out>;
+    transform<Next>(transformer: (value: Out) => Next): ZodLikeSchema<Next>;
+    catch(fallback: Out | (() => Out)): ZodLikeSchema<Out>;
+    strict(): ZodLikeSchema<Out>;
+    passthrough(): ZodLikeSchema<Out & Record<string, unknown>>;
+    strip(): ZodLikeSchema<Out>;
+    partial(): Out extends object ? ZodLikeSchema<Partial<Out>> : ZodLikeSchema<Out>;
+}
+export type infer<T> = T extends {
+    readonly _output: infer Out;
+} ? Out : never;
+type SchemaOutput<Schema> = Schema extends {
+    readonly _output: infer Out;
+} ? Out : never;
+type Shape = Readonly<Record<string, ZodLikeSchema<unknown>>>;
+type ObjectOutput<S extends Shape> = {
+    -readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? never : K]: SchemaOutput<S[K]>;
+} & {
+    -readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? K : never]?: SchemaOutput<S[K]>;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+type UnionOutput<Schemas extends readonly ZodLikeSchema<unknown>[]> = SchemaOutput<Schemas[number]>;
+export declare const string: () => ZodLikeSchema<string>;
+export declare const number: () => ZodLikeSchema<number>;
+export declare const boolean: () => ZodLikeSchema<boolean>;
+export declare const literal: <const Value>(value: Value) => ZodLikeSchema<Value>;
+declare const enumSchema: <const Values extends readonly [string, ...string[]]>(values: Values) => ZodLikeSchema<Values[number]>;
+export { enumSchema as enum };
+export declare const union: <const Schemas extends readonly [ZodLikeSchema<unknown>, ZodLikeSchema<unknown>, ...ZodLikeSchema<unknown>[]]>(schemas: Schemas) => ZodLikeSchema<UnionOutput<Schemas>>;
+export declare const array: <Element>(element: ZodLikeSchema<Element>) => ZodLikeSchema<Element[]>;
+export declare const object: <const S extends Shape>(shape: S) => ZodLikeSchema<Simplify<ObjectOutput<S>>>;
+export declare const record: <Key extends string, Value>(keySchema: ZodLikeSchema<Key>, valueSchema: ZodLikeSchema<Value>) => ZodLikeSchema<Record<string, Value>>;
+export declare const unknown: () => ZodLikeSchema<unknown>;
+export declare const any: () => ZodLikeSchema<unknown>;
+declare const nullSchema: () => ZodLikeSchema<null>;
+declare const undefinedSchema: () => ZodLikeSchema<undefined>;
+export { nullSchema as null, undefinedSchema as undefined };
+/** Runtime `z.*` facade, merged with the `z.infer` type namespace below. */
+export declare const z: {
+    string: typeof string;
+    number: typeof number;
+    boolean: typeof boolean;
+    literal: typeof literal;
+    enum: typeof enumSchema;
+    union: typeof union;
+    array: typeof array;
+    object: typeof object;
+    record: typeof record;
+    unknown: typeof unknown;
+    any: typeof any;
+    null: typeof nullSchema;
+    undefined: typeof undefinedSchema;
+};
+export declare namespace z {
+    type infer<Schema> = Schema extends {
+        readonly _output: infer Out;
+    } ? Out : never;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+	"type": "module",
+	"name": "@oh-my-pi/omptype",
+	"version": "17.2.6",
+	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
+	"homepage": "https://omp.sh",
+	"author": "Can Boluk",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/omptype"
+	},
+	"bugs": {
+		"url": "https://github.com/can1357/oh-my-pi/issues"
+	},
+	"keywords": [
+		"schema",
+		"validation",
+		"arktype",
+		"jit"
+	],
+	"main": "./src/index.ts",
+	"types": "./dist/types/index.d.ts",
+	"scripts": {
+		"check": "biome check . && bun run check:types",
+		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"lint": "biome lint .",
+		"fix": "biome check --write --unsafe .",
+		"fmt": "biome format --write .",
+		"test": "bun test --parallel"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.14"
+	},
+	"engines": {
+		"bun": ">=1.3.14"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"CHANGELOG.md",
+		"dist/types"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./src/index.ts"
+		},
+		"./*": {
+			"types": "./dist/types/*.d.ts",
+			"import": "./src/*.ts"
+		},
+		"./*.js": "./src/*.ts"
+	}
+}

package/src/ark.ts

@@ -0,0 +1,30 @@
+/**
+ * ArkType compatibility facade — `@oh-my-pi/omptype/ark`.
+ *
+ * Lets code written against arktype keep its imports and names while running
+ * on the omptype lazy-JIT runtime: swap `from "arktype"` for
+ * `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.
+ */
+import { OmpError, OmpErrors, OmpTypeError } from "./errors";
+import { type } from "./type";
+
+export * from "./index";
+
+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 };
+}