@oh-my-pi/omptype 18.0.11 → 18.1.0

package/dist/js/compile.js

@@ -907,11 +907,12 @@ export function compile(ir) {
         // array), and each re-entry must reuse this build instead of starting a
         // fresh one forever. The wrapper resolves to the built validator by call
         // time; the interpreter is a safety net that never triggers post-build.
-        let built;
-        compiledCache.set(root, value => (built === undefined ? walk(root, value) : built(value)));
-        built = new Builder().build(root);
-        compiledCache.set(root, built);
-        return built;
+        const built = {};
+        compiledCache.set(root, value => (built.value === undefined ? walk(root, value) : built.value(value)));
+        const compiled = new Builder().build(root);
+        built.value = compiled;
+        compiledCache.set(root, compiled);
+        return compiled;
     }
     return validator;
 }
@@ -920,11 +921,12 @@ export function compileAllows(ir) {
     const root = resolvedRoot(ir);
     const validator = allowsCache.get(root);
     if (validator === undefined) {
-        let built;
-        allowsCache.set(root, ((value) => built === undefined ? !(walk(root, value) instanceof OmpErrors) : built(value)));
-        built = new Builder().buildAllows(root);
-        allowsCache.set(root, built);
-        return built;
+        const built = {};
+        allowsCache.set(root, ((value) => built.value === undefined ? !(walk(root, value) instanceof OmpErrors) : built.value(value)));
+        const compiled = new Builder().buildAllows(root);
+        built.value = compiled;
+        allowsCache.set(root, compiled);
+        return compiled;
     }
     return validator;
 }

package/dist/js/interp.js

@@ -328,6 +328,7 @@ function visitNode(ir, v, path) {
             if (ir.max !== undefined && v.length > ir.max)
                 return fail(path, `at most length ${ir.max}`, v.length);
             const morph = hasMorph(ir.el);
+            // oxlint-disable-next-line unicorn/no-new-array -- length preallocation
             const out = morph ? new Array(v.length) : v;
             let errors;
             for (let index = 0; index < v.length; index++) {

package/dist/js/keywords.js

@@ -98,8 +98,8 @@ function finiteNumber(expected = "a number") {
     };
 }
 function jsonObject() {
-    let value;
-    const resolveValue = () => value;
+    const value = {};
+    const resolveValue = () => value.current;
     const object = {
         k: "object",
         props: [],
@@ -111,7 +111,7 @@ function jsonObject() {
         el: { k: "alias", name: "$jsonValue", resolve: resolveValue },
         desc: "an object",
     };
-    value = {
+    value.current = {
         k: "union",
         members: [
             object,

package/dist/js/type.js

@@ -2071,14 +2071,14 @@ function parseGenericArgument(definition, outer) {
                 throw error;
         }
     }
-    let root;
+    const root = {};
     const self = {
         k: "alias",
         name: "this",
         resolve: () => {
-            if (root === undefined || root === self)
+            if (root.current === undefined || root.current === self)
                 throw new OmpTypeError('"this" cannot be used as a root definition');
-            return root;
+            return root.current;
         },
     };
     const resolve = ((name) => (name === "this" ? self : outer?.(name)));
@@ -2091,10 +2091,10 @@ function parseGenericArgument(definition, outer) {
         // strings inside the definition may still share the string cache.
         markThisOnlyResolver(resolve);
     }
-    root = parseDef(definition, resolve);
-    if (root === self)
+    root.current = parseDef(definition, resolve);
+    if (root.current === self)
         throw new OmpTypeError('"this" cannot be used as a root definition');
-    return root;
+    return root.current;
 }
 function genericBodyIR(parameters, definition, arguments_, outer) {
     const resolve = genericResolver(parameters, arguments_, outer);
@@ -2139,17 +2139,15 @@ function createRuntimeGeneric(parameters, definition, outer, validateBody = true
     return generic;
 }
 export function type(first) {
-    // biome-ignore lint/complexity/noArguments: Avoid allocating a rest array for the dominant single-definition call.
     const count = arguments.length;
     if (count === 2 && typeof first === "string" && first.trimStart().startsWith("<")) {
-        // biome-ignore lint/complexity/noArguments: The generic path reads its second positional argument without a rest array.
         return createRuntimeGeneric(parseGenericParameters(first), arguments[1]);
     }
     let definition = first;
     if (count !== 1) {
+        // oxlint-disable-next-line unicorn/no-new-array -- length preallocation
         const expression = new Array(count);
         for (let index = 0; index < count; index++) {
-            // biome-ignore lint/complexity/noArguments: Only multi-part expressions pay to materialize an argument array.
             expression[index] = arguments[index];
         }
         definition = expression;
@@ -2452,7 +2450,6 @@ function makeFn(resolve) {
     return Object.assign(parser, { raw: parser });
 }
 /** Fix a schema's externally declared static type without changing its runtime validation. */
-// biome-ignore lint/complexity/noBannedTypes: empty default options object
 export function declare() {
     return {
         type: definition => type(definition),
@@ -2710,7 +2707,6 @@ function naryStatics(resolve) {
         RegExp: keywordSchema("RegExp"),
         File: keywordSchema("File"),
         Error: keywordSchema("Error"),
-        // biome-ignore lint/complexity/noBannedTypes: built-in Function keyword
         Function: keywordSchema("Function"),
         Array: {
             liftFrom(definition) {
@@ -2761,7 +2757,6 @@ function naryStatics(resolve) {
         unknown: { any: keywordSchema("unknown.any") },
     };
     /** Date instance validator. */
-    // biome-ignore lint/suspicious/noShadowRestrictedNames: ArkType exposes this exact keyword.
     type.Date = makeType({ k: "instance", ctor: globalThis.Date, expected: "a Date" }, [], {});
     /** Validate instances of `ctor`. */
     function instanceOf(ctor) {
@@ -2795,7 +2790,6 @@ function naryStatics(resolve) {
     }
     type.enumeration = enumeration;
     /** Enumerate an enum-like object's forward values, excluding numeric reverse mappings. */
-    // biome-ignore lint/suspicious/noShadowRestrictedNames: Object.prototype.valueOf method name API
     function valueOf(values) {
         const members = [];
         for (const key in values) {
@@ -2817,7 +2811,6 @@ function naryStatics(resolve) {
     /** Build a function whose arguments and optional declared return are validated. */
     type.fn = makeFn();
     /** Fix an externally declared static type while retaining runtime validation. */
-    // biome-ignore lint/complexity/noBannedTypes: empty default options object
     type.declare = () => ({
         type: definition => type(definition),
     });
@@ -2932,7 +2925,7 @@ function buildScope(aliases, options) {
     }
     const references = new Map();
     const targets = new Map();
-    let scopeValue;
+    const scopeValue = {};
     const materialize = (entry) => {
         if (entry.materialized)
             return entry.definition;
@@ -3023,7 +3016,7 @@ function buildScope(aliases, options) {
         return target;
     };
     const bind = (schema) => {
-        Reflect.set(schema, "$", scopeValue);
+        Reflect.set(schema, "$", scopeValue.current);
         Reflect.set(schema, "resolver", resolve);
         return schema;
     };
@@ -3046,7 +3039,7 @@ function buildScope(aliases, options) {
     const schemaFor = (name) => bind(makeType(withScopeConfig(targetFor(name)), EMPTY_STEPS, scopeMeta));
     const bindModule = (names) => {
         const module = {};
-        Object.defineProperty(module, MODULE_SCOPE, { value: scopeValue });
+        Object.defineProperty(module, MODULE_SCOPE, { value: scopeValue.current });
         for (const name of names) {
             const entry = entries.get(name);
             if (entry === undefined)
@@ -3060,7 +3053,7 @@ function buildScope(aliases, options) {
         }
         return module;
     };
-    scopeValue = {
+    scopeValue.current = {
         type: scoped,
         match: scopedMatch,
         define(definition) {
@@ -3113,7 +3106,7 @@ function buildScope(aliases, options) {
             return json;
         },
     };
-    return scopeValue;
+    return scopeValue.current;
 }
 /** `hasMorph` re-export for diagnostics/tooling. */
 export { hasMorph };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omptype",
-	"version": "18.0.11",
+	"version": "18.1.0",
 	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -23,11 +23,11 @@
 	"main": "./dist/js/index.js",
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
-		"check": "biome check . && bun run check:types",
+		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
 		"check:types": "tsgo -p tsconfig.json --noEmit",
-		"lint": "biome lint .",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write .",
+		"lint": "oxlint .",
+		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
+		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'",
 		"test": "bun test --parallel",
 		"bench": "bun bench/bench.ts"
 	},

package/src/compile.ts

@@ -1108,11 +1108,12 @@ export function compile(ir: IR): (value: unknown) => unknown {
 		// array), and each re-entry must reuse this build instead of starting a
 		// fresh one forever. The wrapper resolves to the built validator by call
 		// time; the interpreter is a safety net that never triggers post-build.
-		let built: ((value: unknown) => unknown) | undefined;
-		compiledCache.set(root, value => (built === undefined ? walk(root, value) : built(value)));
-		built = new Builder().build(root);
-		compiledCache.set(root, built);
-		return built;
+		const built: { value?: (value: unknown) => unknown } = {};
+		compiledCache.set(root, value => (built.value === undefined ? walk(root, value) : built.value(value)));
+		const compiled = new Builder().build(root);
+		built.value = compiled;
+		compiledCache.set(root, compiled);
+		return compiled;
 	}
 	return validator;
 }
@@ -1122,14 +1123,15 @@ export function compileAllows(ir: IR): (value: unknown) => value is unknown {
 	const root = resolvedRoot(ir);
 	const validator = allowsCache.get(root);
 	if (validator === undefined) {
-		let built: ((value: unknown) => value is unknown) | undefined;
+		const built: { value?: (value: unknown) => value is unknown } = {};
 		allowsCache.set(root, ((value: unknown) =>
-			built === undefined ? !(walk(root, value) instanceof OmpErrors) : built(value)) as (
+			built.value === undefined ? !(walk(root, value) instanceof OmpErrors) : built.value(value)) as (
 			value: unknown,
 		) => value is unknown);
-		built = new Builder().buildAllows(root);
-		allowsCache.set(root, built);
-		return built;
+		const compiled = new Builder().buildAllows(root);
+		built.value = compiled;
+		allowsCache.set(root, compiled);
+		return compiled;
 	}
 	return validator;
 }

package/src/infer.ts

@@ -37,7 +37,6 @@ interface PrimitiveMap {
 	Key: PropertyKey;
 	Date: Date;
 	Array: unknown[];
-	// biome-ignore lint/complexity/noBannedTypes: built-in Function keyword
 	Function: Function;
 	RegExp: RegExp;
 	File: File;
@@ -214,35 +213,43 @@ type UnwrapProperty<def> = def extends readonly [infer value, "?" | "=", ...unkn
 type Simplify<t> = { [key in keyof t]: t[key] };
 
 type OutputRequired<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? HasDefault<def[key]> extends true
-			? PropName<key>
-			: never
-		: PropName<key>]-?: InferDef<UnwrapProperty<def[key]>>;
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
+			? HasDefault<def[key]> extends true
+				? PropName<key>
+				: never
+			: PropName<key>
+	]-?: InferDef<UnwrapProperty<def[key]>>;
 };
 
 type OutputOptional<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? HasDefault<def[key]> extends true
-			? never
-			: PropName<key>
-		: never]?: InferDef<UnwrapProperty<def[key]>>;
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
+			? HasDefault<def[key]> extends true
+				? never
+				: PropName<key>
+			: never
+	]?: InferDef<UnwrapProperty<def[key]>>;
 };
 
 type InputRequired<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? never
-		: HasDefault<def[key]> extends true
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
 			? never
-			: PropName<key>]-?: InferDefIn<UnwrapProperty<def[key]>>;
+			: HasDefault<def[key]> extends true
+				? never
+				: PropName<key>
+	]-?: InferDefIn<UnwrapProperty<def[key]>>;
 };
 
 type InputOptional<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? PropName<key>
-		: HasDefault<def[key]> extends true
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
 			? PropName<key>
-			: never]?: InferDefIn<UnwrapProperty<def[key]>>;
+			: HasDefault<def[key]> extends true
+				? PropName<key>
+				: never
+	]?: InferDefIn<UnwrapProperty<def[key]>>;
 };
 
 /**
@@ -302,35 +309,43 @@ type InferLiteralDefIn<def> = def extends { readonly inferIn: infer input }
 			: unknown;
 
 type LiteralRequired<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? HasDefault<def[key]> extends true
-			? PropName<key>
-			: never
-		: PropName<key>]-?: InferLiteralDef<UnwrapProperty<def[key]>>;
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
+			? HasDefault<def[key]> extends true
+				? PropName<key>
+				: never
+			: PropName<key>
+	]-?: InferLiteralDef<UnwrapProperty<def[key]>>;
 };
 
 type LiteralOptional<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? HasDefault<def[key]> extends true
-			? never
-			: PropName<key>
-		: never]?: InferLiteralDef<UnwrapProperty<def[key]>>;
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
+			? HasDefault<def[key]> extends true
+				? never
+				: PropName<key>
+			: never
+	]?: InferLiteralDef<UnwrapProperty<def[key]>>;
 };
 
 type LiteralRequiredIn<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? never
-		: HasDefault<def[key]> extends true
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
 			? never
-			: PropName<key>]-?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
+			: HasDefault<def[key]> extends true
+				? never
+				: PropName<key>
+	]-?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
 };
 
 type LiteralOptionalIn<def extends object> = {
-	-readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
-		? PropName<key>
-		: HasDefault<def[key]> extends true
+	-readonly [
+		key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
 			? PropName<key>
-			: never]?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
+			: HasDefault<def[key]> extends true
+				? PropName<key>
+				: never
+	]?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
 };
 
 /** Object-literal inference that unwraps embedded schema values one level deep. */

package/src/interp.ts

@@ -293,6 +293,7 @@ function visitNode(ir: IR, v: unknown, path: PropertyKey[]): unknown {
 			if (ir.min !== undefined && v.length < ir.min) return fail(path, `at least length ${ir.min}`, v.length);
 			if (ir.max !== undefined && v.length > ir.max) return fail(path, `at most length ${ir.max}`, v.length);
 			const morph = hasMorph(ir.el);
+			// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 			const out = morph ? new Array<unknown>(v.length) : v;
 			let errors: OmpErrors | undefined;
 			for (let index = 0; index < v.length; index++) {

package/src/keywords.ts

@@ -116,8 +116,8 @@ function finiteNumber(expected = "a number"): IR {
 }
 
 function jsonObject(): IR {
-	let value: IR;
-	const resolveValue = (): IR => value;
+	const value: { current?: IR } = {};
+	const resolveValue = (): IR => value.current as IR;
 	const object: IR = {
 		k: "object",
 		props: [],
@@ -129,7 +129,7 @@ function jsonObject(): IR {
 		el: { k: "alias", name: "$jsonValue", resolve: resolveValue },
 		desc: "an object",
 	};
-	value = {
+	value.current = {
 		k: "union",
 		members: [
 			object,

package/src/type.ts

@@ -199,7 +199,6 @@ type NaryAndOutput<definitions extends readonly unknown[]> = definitions extends
 type NaryAndInput<definitions extends readonly unknown[]> = definitions extends readonly []
 	? unknown
 	: SimplifyNary<UnionToIntersection<InferDefIn<definitions[number]>>>;
-// biome-ignore lint/complexity/noBannedTypes: generic accumulator default
 type ReduceNaryMergeOutput<definitions extends readonly unknown[], result = {}> = definitions extends readonly [
 	infer head,
 	...infer tail,
@@ -207,9 +206,7 @@ type ReduceNaryMergeOutput<definitions extends readonly unknown[], result = {}>
 	? ReduceNaryMergeOutput<tail, SimplifyNary<MergeTypes<result, InferDef<head>>>>
 	: definitions extends readonly []
 		? result
-		: // biome-ignore lint/complexity/noBannedTypes: empty object fallback
-			{};
-// biome-ignore lint/complexity/noBannedTypes: generic accumulator default
+		: {};
 type ReduceNaryMergeInput<definitions extends readonly unknown[], result = {}> = definitions extends readonly [
 	infer head,
 	...infer tail,
@@ -217,8 +214,7 @@ type ReduceNaryMergeInput<definitions extends readonly unknown[], result = {}> =
 	? ReduceNaryMergeInput<tail, SimplifyNary<MergeTypes<result, InferDefIn<head>>>>
 	: definitions extends readonly []
 		? result
-		: // biome-ignore lint/complexity/noBannedTypes: empty object fallback
-			{};
+		: {};
 type NaryMergeOutput<definitions extends readonly unknown[]> = definitions extends readonly []
 	? object
 	: ReduceNaryMergeOutput<definitions>;
@@ -560,7 +556,8 @@ const EMPTY_META: TypeMeta = {};
 const ARK_COMPAT_SCOPE = Object.freeze({ internal: Object.freeze({ name: "ark" as const }) });
 
 interface InternalType
-	extends Type<unknown, unknown>,
+	extends
+		Type<unknown, unknown>,
 		FluentMethods<unknown, unknown>,
 		ObjectMethods<Record<PropertyKey, unknown>, unknown> {
 	(data: unknown): unknown;
@@ -2575,13 +2572,14 @@ function parseGenericArgument(definition: unknown, outer?: AliasResolver): IR {
 			if (!(error instanceof OmpTypeError) || !error.message.includes('unknown keyword "this"')) throw error;
 		}
 	}
-	let root: IR | undefined;
+	const root: { current?: IR } = {};
 	const self: IR = {
 		k: "alias",
 		name: "this",
 		resolve: () => {
-			if (root === undefined || root === self) throw new OmpTypeError('"this" cannot be used as a root definition');
-			return root;
+			if (root.current === undefined || root.current === self)
+				throw new OmpTypeError('"this" cannot be used as a root definition');
+			return root.current;
 		},
 	};
 	const resolve = ((name: string) => (name === "this" ? self : outer?.(name))) as AliasResolver;
@@ -2593,9 +2591,9 @@ function parseGenericArgument(definition: unknown, outer?: AliasResolver): IR {
 		// strings inside the definition may still share the string cache.
 		markThisOnlyResolver(resolve);
 	}
-	root = parseDef(definition, resolve);
-	if (root === self) throw new OmpTypeError('"this" cannot be used as a root definition');
-	return root;
+	root.current = parseDef(definition, resolve);
+	if (root.current === self) throw new OmpTypeError('"this" cannot be used as a root definition');
+	return root.current;
 }
 
 function genericBodyIR(
@@ -2681,17 +2679,15 @@ export function type<const expression extends readonly unknown[]>(
 	...definition: expression
 ): FluentType<InferDef<expression>, InferDefIn<expression>>;
 export function type(first?: unknown): FluentType<unknown> | Generic {
-	// biome-ignore lint/complexity/noArguments: Avoid allocating a rest array for the dominant single-definition call.
 	const count = arguments.length;
 	if (count === 2 && typeof first === "string" && first.trimStart().startsWith("<")) {
-		// biome-ignore lint/complexity/noArguments: The generic path reads its second positional argument without a rest array.
 		return createRuntimeGeneric(parseGenericParameters(first), arguments[1]);
 	}
 	let definition: unknown = first;
 	if (count !== 1) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		const expression: unknown[] = new Array(count);
 		for (let index = 0; index < count; index++) {
-			// biome-ignore lint/complexity/noArguments: Only multi-part expressions pay to materialize an argument array.
 			expression[index] = arguments[index];
 		}
 		definition = expression;
@@ -3160,7 +3156,6 @@ export interface DeclaredParser<declared> {
 }
 
 /** Fix a schema's externally declared static type without changing its runtime validation. */
-// biome-ignore lint/complexity/noBannedTypes: empty default options object
 export function declare<declared, _options = {}>(): DeclaredParser<declared> {
 	return {
 		type: definition => type(definition) as unknown as FluentType<declared, InferDefIn<typeof definition>>,
@@ -3463,7 +3458,6 @@ export namespace type {
 		RegExp: keywordSchema<RegExp>("RegExp"),
 		File: keywordSchema<File>("File"),
 		Error: keywordSchema<Error>("Error"),
-		// biome-ignore lint/complexity/noBannedTypes: built-in Function keyword
 		Function: keywordSchema<Function>("Function"),
 		Array: {
 			liftFrom<const definition>(
@@ -3567,7 +3561,6 @@ export namespace type {
 		unknown: { any: keywordSchema<unknown>("unknown.any") },
 	};
 	/** Date instance validator. */
-	// biome-ignore lint/suspicious/noShadowRestrictedNames: ArkType exposes this exact keyword.
 	export const Date = makeType<globalThis.Date>({ k: "instance", ctor: globalThis.Date, expected: "a Date" }, [], {});
 
 	/** Validate instances of `ctor`. */
@@ -3604,7 +3597,6 @@ export namespace type {
 	}
 
 	/** Enumerate an enum-like object's forward values, excluding numeric reverse mappings. */
-	// biome-ignore lint/suspicious/noShadowRestrictedNames: Object.prototype.valueOf method name API
 	export function valueOf<const values extends Record<PropertyKey, unknown>>(
 		values: values,
 	): FluentType<values[keyof values]> {
@@ -3629,7 +3621,6 @@ export namespace type {
 	export const fn: FnParser = makeFn();
 
 	/** Fix an externally declared static type while retaining runtime validation. */
-	// biome-ignore lint/complexity/noBannedTypes: empty default options object
 	export const declare = <declared, _options = {}>(): DeclaredParser<declared> =>
 		({
 			type: definition => type(definition) as unknown as FluentType<declared, InferDefIn<typeof definition>>,
@@ -3802,7 +3793,7 @@ function buildScope(aliases: Record<string, unknown>, options?: ScopeOptions): T
 
 	const references = new Map<string, IR>();
 	const targets = new Map<string, IR>();
-	let scopeValue: TypeScope;
+	const scopeValue: { current?: TypeScope } = {};
 
 	const materialize = (entry: ScopeAlias): unknown => {
 		if (entry.materialized) return entry.definition;
@@ -3889,7 +3880,7 @@ function buildScope(aliases: Record<string, unknown>, options?: ScopeOptions): T
 	};
 
 	const bind = (schema: InternalType): InternalType => {
-		Reflect.set(schema, "$", scopeValue);
+		Reflect.set(schema, "$", scopeValue.current);
 		Reflect.set(schema, "resolver", resolve);
 		return schema;
 	};
@@ -3915,7 +3906,7 @@ function buildScope(aliases: Record<string, unknown>, options?: ScopeOptions): T
 
 	const bindModule = (names: readonly string[]): RuntimeModule => {
 		const module = {} as RuntimeModule;
-		Object.defineProperty(module, MODULE_SCOPE, { value: scopeValue });
+		Object.defineProperty(module, MODULE_SCOPE, { value: scopeValue.current });
 		for (const name of names) {
 			const entry = entries.get(name);
 			if (entry === undefined) continue;
@@ -3929,7 +3920,7 @@ function buildScope(aliases: Record<string, unknown>, options?: ScopeOptions): T
 		return module;
 	};
 
-	scopeValue = {
+	scopeValue.current = {
 		type: scoped,
 		match: scopedMatch,
 		define<const definition>(definition: definition): definition {
@@ -3979,7 +3970,7 @@ function buildScope(aliases: Record<string, unknown>, options?: ScopeOptions): T
 			return json;
 		},
 	};
-	return scopeValue;
+	return scopeValue.current;
 }
 
 /** A schema whose output type is not statically known (`type.raw` results). */