@oh-my-pi/omptype 17.2.7 → 17.2.8

package/dist/types/typebox.d.ts

@@ -1,4 +1,5 @@
-import { type NarrowContext, type Type as OmpType } from "./type.js";
+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;
@@ -25,7 +26,7 @@ export interface ArrayOpts extends Meta {
     uniqueItems?: boolean;
 }
 export interface ObjectOpts extends Meta {
-    additionalProperties?: boolean | TSchema;
+    additionalProperties?: boolean | AnySchema;
 }
 declare const OPTIONAL_INNER: unique symbol;
 declare const OBJECT_INFO: unique symbol;
@@ -45,53 +46,80 @@ interface LegacyTypeBoxCompat<T> {
     /** 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<{
+/**
+ * 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 TSchema> = TSchema<Static<E> | undefined> & {
+export type TOptional<E extends AnySchema> = TTyped<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>> = {
+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]: TSchema;
+        readonly [OPTIONAL_INNER]: AnySchema;
     } ? K : never;
 }[keyof P];
-type RequiredKeys<P extends Record<string, TSchema>> = Exclude<keyof P, OptionalKeys<P>>;
-type ObjectStatic<P extends Record<string, TSchema>> = {
+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, TSchema> = Record<string, TSchema>> = TSchema<ObjectStatic<P>>;
-type RequiredProps<P extends Record<string, TSchema>> = {
+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]?: TSchema;
+    [OPTIONAL_INNER]?: AnySchema;
     [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>;
+    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>;
@@ -102,27 +130,27 @@ interface RuntimeType<T> extends OmpType<T> {
 }
 type CompatRuntime<T> = RuntimeType<T> & LegacyTypeBoxCompat<T>;
 type ObjectInfo = {
-    props: Record<string, TSchema>;
-    additionalProperties?: boolean | TSchema;
+    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 TSchema[]>(schemas: E, opts?: Meta): TUnion<E>;
-declare function tIntersect<const E extends readonly TSchema[]>(schemas: E, opts?: Meta): TSchema<UnionToIntersection<Static<E[number]>>>;
+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): 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 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;
@@ -143,7 +171,7 @@ export declare const Type: {
     readonly Record: typeof tRecord;
     readonly Optional: typeof tOptional;
     readonly Nullable: typeof tNullable;
-    readonly Readonly: <E extends TSchema>(schema: E) => E;
+    readonly Readonly: <E extends AnySchema>(schema: E) => TReadonly<E>;
     readonly Partial: typeof tPartial;
     readonly Required: typeof tRequired;
     readonly Pick: typeof tPick;
@@ -172,7 +200,7 @@ declare const _default: {
         readonly Record: typeof tRecord;
         readonly Optional: typeof tOptional;
         readonly Nullable: typeof tNullable;
-        readonly Readonly: <E extends TSchema>(schema: E) => E;
+        readonly Readonly: <E extends AnySchema>(schema: E) => TReadonly<E>;
         readonly Partial: typeof tPartial;
         readonly Required: typeof tRequired;
         readonly Pick: typeof tPick;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omptype",
-	"version": "17.2.7",
+	"version": "17.2.8",
 	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -32,8 +32,12 @@
 		"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",
 		"zod": "^4"
 	},