@oh-my-pi/omptype 18.11.3 → 18.12.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [18.12.0] - 2026-10-17
+
+### Fixed
+
+- Fixed TypeBox numeric bounds written in exponent notation throwing during schema construction, while preserving validation and nested JSON Schema constraints ([#15925](https://github.com/can1357/oh-my-pi/pull/15925) by [@jchanghong023](https://github.com/jchanghong023)).
+- Fixed importing local JSON Schema definition references containing URI percent encoding or JSON Pointer escapes ([#15926](https://github.com/can1357/oh-my-pi/pull/15926) by [@jchanghong023](https://github.com/jchanghong023)).
+
 ## [18.2.1] - 2026-09-15
 
 ### Added

package/dist/js/from-json-schema.js

@@ -12,6 +12,7 @@
  * omptype IR and passes the rest through.
  */
 import { OmpTypeError } from "./errors.js";
+import { parseLocalRefPointer } from "./local-ref.js";
 import { IR_BRAND } from "./ir.js";
 import { keywordIR, patternIR } from "./keywords.js";
 import { type } from "./type.js";
@@ -40,11 +41,11 @@ class Importer {
             target = this.#root;
         }
         else {
-            const defsMatch = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref);
-            if (defsMatch === null)
+            const pointer = parseLocalRefPointer(ref);
+            if (pointer === undefined || pointer.length !== 2 || (pointer[0] !== "$defs" && pointer[0] !== "definitions"))
                 throw new OmpTypeError(`unsupported $ref: ${ref}`);
-            const defs = this.#root[defsMatch[1]];
-            target = typeof defs === "object" && defs !== null ? defs[defsMatch[2]] : undefined;
+            const defs = this.#root[pointer[0]];
+            target = typeof defs === "object" && defs !== null ? defs[pointer[1]] : undefined;
             if (target === undefined)
                 throw new OmpTypeError(`unresolved $ref: ${ref}`);
         }

package/dist/js/index.js

@@ -10,4 +10,5 @@ export * from "./from-json-schema.js";
 export * from "./infer.js";
 export * from "./ir.js";
 export * from "./json-schema.js";
+export * from "./local-ref.js";
 export * from "./type.js";

package/dist/js/local-ref.js

@@ -0,0 +1,43 @@
+/**
+ * Shared parsing for local `$ref` URI fragments (RFC 6901 JSON Pointers).
+ * omptype's JSON Schema importer and pi-ai's schema resolvers decode refs
+ * through these helpers so percent-encoded, pointer-escaped, and empty tokens
+ * resolve identically everywhere.
+ */
+/**
+ * Parse a local `$ref` URI fragment into decoded JSON Pointer tokens:
+ * percent-decode the fragment, split on `/`, then unescape `~1`/`~0` per
+ * token. Returns `[]` for the root ref `#`, and `undefined` for non-local
+ * refs or fragments that do not percent-decode.
+ */
+export function parseLocalRefPointer(ref) {
+    if (!ref.startsWith("#"))
+        return undefined;
+    let pointer;
+    try {
+        pointer = decodeURIComponent(ref.slice(1));
+    }
+    catch {
+        return undefined;
+    }
+    if (pointer.length > 0 && !pointer.startsWith("/"))
+        return undefined;
+    return pointer
+        .split("/")
+        .slice(1)
+        .map(token => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/**
+ * Encode JSON Pointer tokens back into a local `$ref` URI fragment — the
+ * inverse of {@link parseLocalRefPointer}.
+ */
+export function formatLocalRefPointer(tokens) {
+    if (tokens.length === 0)
+        return "#";
+    // `$` and the other URI sub-delims `encodeURIComponent` escapes are legal
+    // in fragments, so keep `$defs` readable; `%` stays encoded to round-trip.
+    const encoded = tokens
+        .map(token => encodeURIComponent(token.replace(/~/g, "~0").replace(/\//g, "~1")))
+        .map(token => token.replace(/%24/g, "$"));
+    return `#/${encoded.join("/")}`;
+}

package/dist/js/typebox.js

@@ -129,22 +129,19 @@ function tNumber(opts, integer = false) {
         upper = { value: opts.exclusiveMaximum, exclusive: true };
     }
     const keyword = integer ? "number.integer" : "number";
-    // The `LO <= TYPE <= HI` range spelling requires both bounds; a min-only
-    // bound must use the postfix `TYPE >= LO` form (see parseBounded in ir.ts).
-    let src;
-    if (lower && upper) {
-        src = `${lower.value} ${lower.exclusive ? "<" : "<="} ${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
+    if (lower &&
+        upper &&
+        (lower.value > upper.value || (lower.value === upper.value && (lower.exclusive || upper.exclusive)))) {
+        throw new OmpTypeError("numeric range is unsatisfiable");
     }
-    else if (lower) {
-        src = `${keyword} ${lower.exclusive ? ">" : ">="} ${lower.value}`;
-    }
-    else if (upper) {
-        src = `${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
-    }
-    else {
-        src = keyword;
-    }
-    let schema = asRuntime(type.raw(src));
+    // Fluent bounds write min/max straight into the IR, so decimal and
+    // exponent-form bounds share one path that renders the same structured
+    // errors; the DSL's decimal-only literals cannot spell the exponent form.
+    let schema = asRuntime(type.raw(keyword));
+    if (lower)
+        schema = lower.exclusive ? schema.moreThan(lower.value) : schema.atLeast(lower.value);
+    if (upper)
+        schema = upper.exclusive ? schema.lessThan(upper.value) : schema.atMost(upper.value);
     if (opts?.multipleOf !== undefined) {
         const divisor = opts.multipleOf;
         schema = schema.narrow((value, ctx) => {

package/dist/types/index.d.ts

@@ -10,4 +10,5 @@ export * from "./from-json-schema.js";
 export * from "./infer.js";
 export * from "./ir.js";
 export * from "./json-schema.js";
+export * from "./local-ref.js";
 export * from "./type.js";

package/dist/types/local-ref.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared parsing for local `$ref` URI fragments (RFC 6901 JSON Pointers).
+ * omptype's JSON Schema importer and pi-ai's schema resolvers decode refs
+ * through these helpers so percent-encoded, pointer-escaped, and empty tokens
+ * resolve identically everywhere.
+ */
+/**
+ * Parse a local `$ref` URI fragment into decoded JSON Pointer tokens:
+ * percent-decode the fragment, split on `/`, then unescape `~1`/`~0` per
+ * token. Returns `[]` for the root ref `#`, and `undefined` for non-local
+ * refs or fragments that do not percent-decode.
+ */
+export declare function parseLocalRefPointer(ref: string): string[] | undefined;
+/**
+ * Encode JSON Pointer tokens back into a local `$ref` URI fragment — the
+ * inverse of {@link parseLocalRefPointer}.
+ */
+export declare function formatLocalRefPointer(tokens: readonly string[]): string;

package/dist/types/typebox.d.ts

@@ -125,6 +125,8 @@ interface RuntimeType<T> extends OmpType<T> {
     atMostLength(bound: number): RuntimeType<T>;
     atLeast(bound: number): RuntimeType<T>;
     atMost(bound: number): RuntimeType<T>;
+    moreThan(bound: number): RuntimeType<T>;
+    lessThan(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>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omptype",
-	"version": "18.11.3",
+	"version": "18.12.1",
 	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
 	"homepage": "https://omp.sh",
 	"author": {

package/src/from-json-schema.ts

@@ -12,6 +12,7 @@
  * omptype IR and passes the rest through.
  */
 import { OmpTypeError } from "./errors";
+import { parseLocalRefPointer } from "./local-ref";
 import { type EmbeddableSchema, type IR, IR_BRAND, type PropIR, type TupleItemIR } from "./ir";
 import { keywordIR, patternIR } from "./keywords";
 import { type BaseType, type } from "./type";
@@ -45,10 +46,11 @@ class Importer {
 		if (ref === "#") {
 			target = this.#root;
 		} else {
-			const defsMatch = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref);
-			if (defsMatch === null) throw new OmpTypeError(`unsupported $ref: ${ref}`);
-			const defs = this.#root[defsMatch[1]];
-			target = typeof defs === "object" && defs !== null ? (defs as JsonSchema)[defsMatch[2]] : undefined;
+			const pointer = parseLocalRefPointer(ref);
+			if (pointer === undefined || pointer.length !== 2 || (pointer[0] !== "$defs" && pointer[0] !== "definitions"))
+				throw new OmpTypeError(`unsupported $ref: ${ref}`);
+			const defs = this.#root[pointer[0]];
+			target = typeof defs === "object" && defs !== null ? (defs as JsonSchema)[pointer[1]!] : undefined;
 			if (target === undefined) throw new OmpTypeError(`unresolved $ref: ${ref}`);
 		}
 

package/src/index.ts

@@ -10,4 +10,5 @@ export * from "./from-json-schema";
 export * from "./infer";
 export * from "./ir";
 export * from "./json-schema";
+export * from "./local-ref";
 export * from "./type";

package/src/local-ref.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared parsing for local `$ref` URI fragments (RFC 6901 JSON Pointers).
+ * omptype's JSON Schema importer and pi-ai's schema resolvers decode refs
+ * through these helpers so percent-encoded, pointer-escaped, and empty tokens
+ * resolve identically everywhere.
+ */
+
+/**
+ * Parse a local `$ref` URI fragment into decoded JSON Pointer tokens:
+ * percent-decode the fragment, split on `/`, then unescape `~1`/`~0` per
+ * token. Returns `[]` for the root ref `#`, and `undefined` for non-local
+ * refs or fragments that do not percent-decode.
+ */
+export function parseLocalRefPointer(ref: string): string[] | undefined {
+	if (!ref.startsWith("#")) return undefined;
+	let pointer: string;
+	try {
+		pointer = decodeURIComponent(ref.slice(1));
+	} catch {
+		return undefined;
+	}
+	if (pointer.length > 0 && !pointer.startsWith("/")) return undefined;
+	return pointer
+		.split("/")
+		.slice(1)
+		.map(token => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+
+/**
+ * Encode JSON Pointer tokens back into a local `$ref` URI fragment — the
+ * inverse of {@link parseLocalRefPointer}.
+ */
+export function formatLocalRefPointer(tokens: readonly string[]): string {
+	if (tokens.length === 0) return "#";
+	// `$` and the other URI sub-delims `encodeURIComponent` escapes are legal
+	// in fragments, so keep `$defs` readable; `%` stays encoded to round-trip.
+	const encoded = tokens
+		.map(token => encodeURIComponent(token.replace(/~/g, "~0").replace(/\//g, "~1")))
+		.map(token => token.replace(/%24/g, "$"));
+	return `#/${encoded.join("/")}`;
+}

package/src/typebox.ts

@@ -135,6 +135,8 @@ interface RuntimeType<T> extends OmpType<T> {
 	atMostLength(bound: number): RuntimeType<T>;
 	atLeast(bound: number): RuntimeType<T>;
 	atMost(bound: number): RuntimeType<T>;
+	moreThan(bound: number): RuntimeType<T>;
+	lessThan(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>;
 }
@@ -271,19 +273,19 @@ function tNumber(opts?: NumberOpts, integer = false): TNumber {
 		upper = { value: opts.exclusiveMaximum, exclusive: true };
 	}
 	const keyword = integer ? "number.integer" : "number";
-	// The `LO <= TYPE <= HI` range spelling requires both bounds; a min-only
-	// bound must use the postfix `TYPE >= LO` form (see parseBounded in ir.ts).
-	let src: string;
-	if (lower && upper) {
-		src = `${lower.value} ${lower.exclusive ? "<" : "<="} ${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
-	} else if (lower) {
-		src = `${keyword} ${lower.exclusive ? ">" : ">="} ${lower.value}`;
-	} else if (upper) {
-		src = `${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
-	} else {
-		src = keyword;
+	if (
+		lower &&
+		upper &&
+		(lower.value > upper.value || (lower.value === upper.value && (lower.exclusive || upper.exclusive)))
+	) {
+		throw new OmpTypeError("numeric range is unsatisfiable");
 	}
-	let schema = asRuntime<number>(type.raw(src));
+	// Fluent bounds write min/max straight into the IR, so decimal and
+	// exponent-form bounds share one path that renders the same structured
+	// errors; the DSL's decimal-only literals cannot spell the exponent form.
+	let schema = asRuntime<number>(type.raw(keyword));
+	if (lower) schema = lower.exclusive ? schema.moreThan(lower.value) : schema.atLeast(lower.value);
+	if (upper) schema = upper.exclusive ? schema.lessThan(upper.value) : schema.atMost(upper.value);
 	if (opts?.multipleOf !== undefined) {
 		const divisor = opts.multipleOf;
 		schema = schema.narrow((value, ctx) => {