@linxiraos/pi-omptype 1.0.0

package/dist/types/typebox.d.ts

@@ -0,0 +1,212 @@
+import type { EmbeddableSchema } from "./ir.js";
+import { type NarrowContext, type Type as OmpType, type ToJsonSchemaOptions } 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 | AnySchema;
+}
+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>;
+}
+/**
+ * Erased schema surface accepted anywhere this facade takes a schema, native
+ * omptype schemas included (those carry no legacy compat members).
+ *
+ * Members use method syntax so parameter positions stay bivariant: the typed
+ * {@link TTyped} form is invariant in its static type (its `in`/`out`
+ * validators are), so a concrete `TString` is not assignable to
+ * `TTyped<unknown>`. Erasing here is what keeps `TString`, `TObject<…>` and
+ * friends assignable to a plain schema annotation.
+ */
+export interface AnySchema extends EmbeddableSchema {
+    (data: unknown): unknown;
+    readonly infer: unknown;
+    readonly hasSteps: boolean;
+    toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
+}
+/**
+ * Every schema this facade returns: the TypeBox `TSchema` analog. Erased like
+ * {@link AnySchema}, plus the legacy compat members builder results carry.
+ */
+export interface TSchema extends AnySchema {
+    /** TypeBox compatibility validator used by legacy extension loaders. */
+    __validator(data: unknown): unknown;
+    /** Zod-style compatibility parser used by legacy extensions. */
+    safeParse(input: unknown): TypeBoxSafeParseResult<unknown>;
+}
+/** Schema carrying a statically known type; every `TXxx` alias resolves here. */
+export type TTyped<T> = OmpType<T> & LegacyTypeBoxCompat<T>;
+export type Static<T extends AnySchema> = T["infer"];
+export type TAny = TTyped<unknown>;
+export type TUnknown = TTyped<unknown>;
+export type TNever = TTyped<never>;
+export type TNull = TTyped<null>;
+export type TString = TTyped<string>;
+export type TNumber = TTyped<number>;
+export type TInteger = TTyped<number>;
+export type TBoolean = TTyped<boolean>;
+export type TLiteral<V extends string | number | boolean | null> = TTyped<V>;
+export type TArray<E extends AnySchema> = TTyped<Static<E>[]>;
+export type TTuple<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<{
+    -readonly [K in keyof E]: Static<E[K]>;
+}>;
+export type TOptional<E extends AnySchema> = TTyped<Static<E> | undefined> & {
+    readonly [OPTIONAL_INNER]: E;
+};
+export type TUnion<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<Static<E[number]>>;
+export type TIntersect<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<UnionToIntersection<Static<E[number]>>>;
+export type TEnum<E extends readonly (string | number)[] = readonly (string | number)[]> = TTyped<E[number]>;
+export type TRecord<K extends AnySchema, V extends AnySchema> = TTyped<Record<Extract<Static<K>, PropertyKey>, Static<V>>>;
+export type TNullable<E extends AnySchema> = TTyped<Static<E> | null>;
+export type TReadonly<E extends AnySchema> = TTyped<Readonly<Static<E>>>;
+export type TUnsafe<T = unknown> = TTyped<T>;
+type OptionalKeys<P extends Record<string, AnySchema>> = {
+    [K in keyof P]-?: P[K] extends {
+        readonly [OPTIONAL_INNER]: AnySchema;
+    } ? K : never;
+}[keyof P];
+type RequiredKeys<P extends Record<string, AnySchema>> = Exclude<keyof P, OptionalKeys<P>>;
+type ObjectStatic<P extends Record<string, AnySchema>> = {
+    [K in RequiredKeys<P>]: Static<P[K]>;
+} & {
+    [K in OptionalKeys<P>]?: Exclude<Static<P[K]>, undefined>;
+};
+export type TObject<P extends Record<string, AnySchema> = Record<string, AnySchema>> = TTyped<ObjectStatic<P>>;
+type RequiredProps<P extends Record<string, AnySchema>> = {
+    [K in keyof P]: P[K] extends TOptional<infer E> ? E : P[K];
+};
+interface RuntimeType<T> extends OmpType<T> {
+    [OPTIONAL_INNER]?: AnySchema;
+    [OBJECT_INFO]?: ObjectInfo;
+    describe(description: string): RuntimeType<T>;
+    default(value: T | (() => T)): RuntimeType<T>;
+    or<schema extends AnySchema>(schema: schema): RuntimeType<T | Static<schema>>;
+    and<schema extends AnySchema>(schema: schema): RuntimeType<T & Static<schema>>;
+    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, AnySchema>;
+    additionalProperties?: boolean | AnySchema;
+};
+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 AnySchema[]>(schemas: E, opts?: Meta): TUnion<E>;
+declare function tIntersect<const E extends readonly AnySchema[]>(schemas: E, opts?: Meta): TTyped<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): TTyped<E extends readonly (infer V)[] ? V : E[keyof E]>;
+declare function tArray<E extends AnySchema>(item: E, opts?: ArrayOpts): TArray<E>;
+declare function tTuple<const E extends readonly AnySchema[]>(items: E, opts?: Meta): TTuple<E>;
+declare function tObject<const P extends Record<string, AnySchema>>(properties: P, opts?: ObjectOpts): TObject<P>;
+declare function tRecord<K extends AnySchema, V extends AnySchema>(key: K, value: V, opts?: Meta): TRecord<K, V>;
+declare function tOptional<E extends AnySchema>(schema: E, opts?: Meta): TOptional<E>;
+declare function tNullable<E extends AnySchema>(schema: E, opts?: Meta): TTyped<Static<E> | null>;
+declare function tPartial<P extends Record<string, AnySchema>>(schema: TObject<P>): TTyped<Partial<ObjectStatic<P>>>;
+declare function tRequired<P extends Record<string, AnySchema>>(schema: TObject<P>): TObject<RequiredProps<P>>;
+declare function tPick<P extends Record<string, AnySchema>, const K extends readonly (keyof P)[]>(schema: TObject<P>, keys: K): TObject<Pick<P, K[number]>>;
+declare function tOmit<P extends Record<string, AnySchema>, 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, AnySchema>>[]>(schemas: E, opts?: ObjectOpts): TTyped<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 AnySchema>(schema: E) => TReadonly<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 AnySchema>(schema: E) => TReadonly<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, unknown> {
+    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,71 @@
+{
+	"type": "module",
+	"name": "@linxiraos/pi-omptype",
+	"version": "1.0.0",
+	"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/Linxira-OS/linxira-zeta.git",
+		"directory": "packages/omptype"
+	},
+	"bugs": {
+		"url": "https://github.com/can1357/oh-my-pi/issues"
+	},
+	"keywords": [
+		"schema",
+		"validation",
+		"arktype",
+		"jit"
+	],
+	"main": "./dist/js/index.js",
+	"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",
+		"bench": "bun bench/bench.ts"
+	},
+	"devDependencies": {
+		"@ark/attest": "0.56.3",
+		"@ark/schema": "0.56.2",
+		"@ark/util": "0.56.2",
+		"@sinclair/typebox": "^0.34.0",
+		"@types/bun": "^1.3.14",
+		"arkregex": "0.0.8",
+		"arktype": "2.2.3"
+	},
+	"engines": {
+		"node": ">=20",
+		"bun": ">=1.3.14"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"CHANGELOG.md",
+		"dist/types",
+		"dist/js"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"bun": "./src/index.ts",
+			"default": "./dist/js/index.js"
+		},
+		"./*": {
+			"types": "./dist/types/*.d.ts",
+			"bun": "./src/*.ts",
+			"default": "./dist/js/*.js"
+		},
+		"./*.js": {
+			"types": "./dist/types/*.d.ts",
+			"bun": "./src/*.ts",
+			"default": "./dist/js/*.js"
+		}
+	}
+}

package/src/ark.ts

@@ -0,0 +1,20 @@
+/**
+ * ArkType compatibility facade — `@linxiraos/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 "@linxiraos/pi-omptype/ark"` and nothing else changes. New code should
+ * import `@linxiraos/pi-omptype` directly.
+ *
+ * Compatibility affordance: `ArkError` / `ArkErrors` alias `OmpError` /
+ * `OmpErrors`. All schema builders, including recursive `scope()`, are
+ * re-exported unchanged.
+ */
+import { OmpError, OmpErrors } from "./errors";
+
+export * from "./index";
+
+export const ArkError = OmpError;
+export type ArkError = OmpError;
+export const ArkErrors = OmpErrors;
+export type ArkErrors = OmpErrors;