@oh-my-pi/omptype 17.2.15 → 17.3.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [17.3.0] - 2026-08-13
+
+### Added
+
+- Added `type.withJsonSchema(schema, json)` to wrap a validation-only schema, ensuring JSON Schema emission yields the provided `json` verbatim even when nested inside objects, arrays, or unions. Schemas with defaults or output-changing morphs are rejected to prevent transformed outputs from being discarded.
+
 ## [17.2.10] - 2026-08-06
 
 ### Changed

package/dist/js/type.js

@@ -2852,6 +2852,38 @@ function naryStatics(resolve) {
         return makeType(parseDef(def), [], {});
     }
     type.raw = raw;
+    /**
+     * Return a validation-only schema that emits `json` verbatim — even when
+     * embedded in an object, array, or union.
+     *
+     * A `.toJsonSchema()` method override cannot survive nesting: a parent schema
+     * emits each child's IR directly and never calls the child's method, so the
+     * override silently disappears from the wire schema. This stores the override
+     * on the IR instead.
+     *
+     * # Errors
+     *
+     * Throws when `schema` has a default or output-changing morph/pipe. A refine
+     * can preserve validation and the input value, but silently discarding a
+     * transformed output would violate the returned {@link Type}.
+     */
+    function withJsonSchema(schema, json) {
+        const internal = schema;
+        if (internal.hasDefault || hasMorph(internal.ir) || internal[kSteps].some(step => step.kind === "pipe")) {
+            throw new OmpTypeError("type.withJsonSchema cannot wrap schemas with defaults or output-changing morphs");
+        }
+        return makeType({
+            k: "refine",
+            base: { k: "unknown" },
+            pred: value => {
+                const result = schema(value);
+                return result instanceof OmpErrors ? result : true;
+            },
+            expected: schema.expression,
+            json: { ...json },
+        }, [], {});
+    }
+    type.withJsonSchema = withJsonSchema;
 })(type || (type = {}));
 // Reserved words cannot be declared as namespace bindings, but ArkType exposes
 // them as runtime keyword properties.

package/dist/types/type.d.ts

@@ -496,6 +496,22 @@ export declare namespace type {
     export function generic(...parameters: readonly GenericParameterSpec[]): GenericBuilder;
     /** Untyped builder for runtime-assembled definitions. */
     export function raw(def: unknown): BaseType;
+    /**
+     * Return a validation-only schema that emits `json` verbatim — even when
+     * embedded in an object, array, or union.
+     *
+     * A `.toJsonSchema()` method override cannot survive nesting: a parent schema
+     * emits each child's IR directly and never calls the child's method, so the
+     * override silently disappears from the wire schema. This stores the override
+     * on the IR instead.
+     *
+     * # Errors
+     *
+     * Throws when `schema` has a default or output-changing morph/pipe. A refine
+     * can preserve validation and the input value, but silently discarding a
+     * transformed output would violate the returned {@link Type}.
+     */
+    export function withJsonSchema<t, i = t>(schema: Type<t, i>, json: Record<string, unknown>): Type<t, i>;
     export {};
 }
 export interface ScopeOptions {

package/package.json

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

package/src/type.ts

@@ -3675,6 +3675,42 @@ export namespace type {
 	export function raw(def: unknown): BaseType {
 		return makeType(parseDef(def), [], {}) as unknown as BaseType;
 	}
+
+	/**
+	 * Return a validation-only schema that emits `json` verbatim — even when
+	 * embedded in an object, array, or union.
+	 *
+	 * A `.toJsonSchema()` method override cannot survive nesting: a parent schema
+	 * emits each child's IR directly and never calls the child's method, so the
+	 * override silently disappears from the wire schema. This stores the override
+	 * on the IR instead.
+	 *
+	 * # Errors
+	 *
+	 * Throws when `schema` has a default or output-changing morph/pipe. A refine
+	 * can preserve validation and the input value, but silently discarding a
+	 * transformed output would violate the returned {@link Type}.
+	 */
+	export function withJsonSchema<t, i = t>(schema: Type<t, i>, json: Record<string, unknown>): Type<t, i> {
+		const internal = schema as unknown as InternalType;
+		if (internal.hasDefault || hasMorph(internal.ir) || internal[kSteps].some(step => step.kind === "pipe")) {
+			throw new OmpTypeError("type.withJsonSchema cannot wrap schemas with defaults or output-changing morphs");
+		}
+		return makeType<t, i>(
+			{
+				k: "refine",
+				base: { k: "unknown" },
+				pred: value => {
+					const result = schema(value);
+					return result instanceof OmpErrors ? result : true;
+				},
+				expected: schema.expression,
+				json: { ...json },
+			},
+			[],
+			{},
+		);
+	}
 }
 
 // Reserved words cannot be declared as namespace bindings, but ArkType exposes