@code-yeongyu/senpi 2026.9.11 → 2026.9.12-3

package/node_modules/typebox/build/schema/engine/additionalProperties.mjs

@@ -2,12 +2,23 @@
 import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
-// Common: GetPropertiesPattern
+// Optimization: IsAdditionalPropertiesIgnored
+//
+// We can ignore additionalProperties if the schema is true-like and
+// we are not in an unevaluated context, noting that additional
+// properties are considered tracked, evaluated keys.
+// ------------------------------------------------------------------
+function IsAdditionalPropertiesIgnored(context, additionalProperties) {
+    return !context.UseUnevaluated() &&
+        (G.IsEqual(additionalProperties, true) ||
+            (G.IsObject(additionalProperties) && G.IsEqual(G.Keys(additionalProperties).length, 0)));
+}
+// ------------------------------------------------------------------
+// Optimization: GetPropertiesPattern
 //
 // Constructs a regular expression that matches all property keys
 // and pattern properties defined in a schema. This approach unifies
@@ -71,6 +82,8 @@ export function BuildAdditionalPropertiesStandard(stack, context, schema, value)
 // Build
 // ------------------------------------------------------------------
 export function BuildAdditionalProperties(stack, context, schema, value) {
+    if (IsAdditionalPropertiesIgnored(context, schema.additionalProperties))
+        return E.Constant(true);
     return CanAdditionalPropertiesFast(context, schema, value)
         ? BuildAdditionalPropertiesFast(context, schema, value)
         : BuildAdditionalPropertiesStandard(stack, context, schema, value);
@@ -95,9 +108,8 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
         const nextInstancePath = `${instancePath}/${key}`;
-        const nextContext = new AccumulatedErrorContext();
         const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchemaPushStack(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)
             additionalProperties.push(key);
         return isAdditionalProperty;

package/node_modules/typebox/build/schema/engine/allOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -34,7 +34,7 @@ export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, val
     const failedContexts = [];
     const results = schema.allOf.reduce((result, schema, index) => {
         const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)
             failedContexts.push(nextContext);

package/node_modules/typebox/build/schema/engine/anyOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -33,7 +33,7 @@ export function CheckAnyOf(stack, context, schema, value) {
 export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
     const failedContexts = [];
     const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const nextSchemaPath = `${schemaPath}/anyOf/${index}`;
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)

package/node_modules/typebox/build/schema/engine/if.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -27,7 +27,7 @@ export function CheckIf(stack, context, schema, value) {
 export function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
     const thenSchema = Schema.IsThen(schema) ? schema.then : true;
     const elseSchema = Schema.IsElse(schema) ? schema.else : true;
-    const trueContext = new AccumulatedErrorContext();
+    const trueContext = new ErrorContext();
     const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
         ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
             keyword: 'if',

package/node_modules/typebox/build/schema/engine/oneOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -38,7 +38,7 @@ export function ErrorOneOf(stack, context, schemaPath, instancePath, schema, val
     const failedContexts = [];
     const passingSchemas = [];
     const passedContexts = schema.oneOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const nextSchemaPath = `${schemaPath}/oneOf/${index}`;
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (isSchema)

package/node_modules/typebox/build/schema/engine/propertyNames.mjs

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -24,8 +23,7 @@ export function ErrorPropertyNames(stack, context, schemaPath, instancePath, sch
     const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextInstancePath = `${instancePath}/${key}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
-        const nextContext = new AccumulatedErrorContext();
-        const isPropertyName = ErrorSchema(stack, nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
+        const isPropertyName = ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
         if (!isPropertyName)
             propertyNames.push(key);
         return isPropertyName;

package/node_modules/typebox/build/schema/engine/ref.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -42,7 +42,7 @@ export function CheckRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
     const target = stack.Ref(schema) ?? false;
-    const nextContext = new AccumulatedErrorContext();
+    const nextContext = new ErrorContext();
     const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
     if (result)
         context.Merge([nextContext]);

package/node_modules/typebox/build/schema/engine/schema.mjs

@@ -308,6 +308,12 @@ export function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, s
     return (context.Push() && ErrorSchema(stack, context, schemaPath, instancePath, schema, value)) && context.Pop();
 }
 export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
+    // Optimization: We can safely terminate here when the context is at capacity because we are unable to
+    // append additional errors. It is worth being mindful that logical keywords such as allOf, anyOf,
+    // oneOf pass a new context per operand, so the capacity check applies per context, not across the
+    // full set of errors accumulated by the schema as a whole. (review)
+    if (context.AtCapacity())
+        return false;
     stack.Push(schema);
     const result = (Schema.IsSchemaBoolean(schema)) ? ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
         +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!Schema.IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) &

package/node_modules/typebox/build/schema/engine/unevaluatedItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -35,7 +35,7 @@ export function ErrorUnevaluatedItems(stack, context, schemaPath, instancePath,
     const indices = context.GetIndices();
     const unevaluatedItems = [];
     const isUnevaluatedItems = G.EveryAll(value, 0, (item, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isEvaluatedItem = (indices.has(index) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedItems, item))
             && context.AddIndex(index);
         if (!isEvaluatedItem)

package/node_modules/typebox/build/schema/engine/unevaluatedProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -35,7 +35,7 @@ export function ErrorUnevaluatedProperties(stack, context, schemaPath, instanceP
     const keys = context.GetKeys();
     const unevaluatedProperties = [];
     const isUnevaluatedProperties = G.EveryAll(G.Entries(value), 0, ([key, prop]) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isEvaluatedProperty = keys.has(key)
             || (ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedProperties, prop) && context.AddKey(key));
         if (!isEvaluatedProperty)

package/node_modules/typebox/build/schema/errors.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import * as Schema from './types/index.mjs';
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors(schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];

package/node_modules/typebox/build/schema/errors.mjs

@@ -1,24 +1,18 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../system/arguments/index.mjs';
-import { Settings } from '../system/settings/index.mjs';
-import { Get as LocaleGet } from '../system/locale/_config.mjs';
-import { Guard } from '../guard/index.mjs';
+import { Get as GetLocalizationFunction } from '../system/locale/_config.mjs';
 import * as Engine from './engine/index.mjs';
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export function Errors(...args) {
     const [context, schema, value] = Arguments.Match(args, {
         3: (context, schema, value) => [context, schema, value],
         2: (schema, value) => [{}, schema, value]
     });
-    const settings = Settings.Get();
-    const locale = LocaleGet();
-    const errors = [];
     const stack = new Engine.Stack(context, schema);
-    const errorContext = new Engine.ErrorContext(error => {
-        if (Guard.IsGreaterEqualThan(errors.length, settings.maxErrors))
-            return;
-        return errors.push({ ...error, message: locale(error) });
-    });
+    const errorContext = new Engine.ErrorContext();
     const result = Engine.ErrorSchema(stack, errorContext, '#', '', schema, value);
-    return [result, errors];
+    const errors = errorContext.GetErrors();
+    const locale = GetLocalizationFunction();
+    const localized = errors.map(error => ({ ...error, message: locale(error) }));
+    return [result, localized];
 }

package/node_modules/typebox/build/schema/intern/index.d.mts

@@ -0,0 +1 @@
+export * from './intern.mjs';

package/node_modules/typebox/build/schema/intern/index.mjs

@@ -0,0 +1 @@
+export * from './intern.mjs';

package/node_modules/typebox/build/schema/intern/intern.d.mts

@@ -0,0 +1,14 @@
+import { type XStatic } from '../static/index.mjs';
+import * as S from '../types/index.mjs';
+export interface XIntern<Type extends unknown = unknown> {
+    '~unsafe': Type;
+    $ref: string;
+    $defs: Record<string, S.XSchemaObject>;
+}
+/**
+ * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
+ * schema. This function restructures the schema such that each distinct sub-schema is stored
+ * exactly once in a $defs object and keyed by content hash. This function can be used to
+ * both compress and optimize schemas prior to compilation.
+ */
+export declare function Intern<const Schema extends S.XSchema>(schema: Schema): XIntern<XStatic<Schema>>;

package/node_modules/typebox/build/schema/intern/intern.mjs

@@ -0,0 +1,259 @@
+import { Hashing, Memory } from '../../system/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Resolve } from '../resolve/index.mjs';
+import * as S from '../types/index.mjs';
+// ----------------------------------------------------------------
+// UnsupportedKeyword
+// ----------------------------------------------------------------
+function UnsupportedKeyword(keyword) {
+    throw Error(`UnsupportedKeyword '${keyword}'`);
+}
+// ----------------------------------------------------------------
+// UnresolvableRef
+// ----------------------------------------------------------------
+function UnresolvableRef(ref) {
+    throw Error(`UnresolvableRef '${ref}'`);
+}
+// ----------------------------------------------------------------
+// HashKey
+// ----------------------------------------------------------------
+function HashKey(schema) {
+    return `x-${Hashing.Hash(schema)}`;
+}
+// ----------------------------------------------------------------
+// AdditionalItems
+// ----------------------------------------------------------------
+function FromAdditionalItems(context, schema) {
+    return FromSchema(context, schema.additionalItems);
+}
+// ----------------------------------------------------------------
+// AdditionalProperties
+// ----------------------------------------------------------------
+function FromAdditionalProperties(context, schema) {
+    return FromSchema(context, schema.additionalProperties);
+}
+// ----------------------------------------------------------------
+// AllOf
+// ----------------------------------------------------------------
+function FromAllOf(context, schema) {
+    return schema.allOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// AnyOf
+// ----------------------------------------------------------------
+function FromAnyOf(context, schema) {
+    return schema.anyOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// Contains
+// ----------------------------------------------------------------
+function FromContains(context, schema) {
+    return FromSchema(context, schema.contains);
+}
+// ----------------------------------------------------------------
+// DependentSchemas
+// ----------------------------------------------------------------
+function FromDependentSchemas(context, schema) {
+    return Guard.Keys(schema.dependentSchemas).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.dependentSchemas[key]) }), {});
+}
+// ----------------------------------------------------------------
+// Else
+// ----------------------------------------------------------------
+function FromElse(context, schema) {
+    return FromSchema(context, schema.else);
+}
+// ----------------------------------------------------------------
+// If
+// ----------------------------------------------------------------
+function FromIf(context, schema) {
+    return FromSchema(context, schema.if);
+}
+// ----------------------------------------------------------------
+// Items
+// ----------------------------------------------------------------
+function FromItems(context, schema) {
+    return S.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
+}
+// ----------------------------------------------------------------
+// ItemsSized
+// ----------------------------------------------------------------
+function FromItemsSized(context, schema) {
+    return schema.items.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// ItemsUnsized
+// ----------------------------------------------------------------
+function FromItemsUnsized(context, schema) {
+    return FromSchema(context, schema.items);
+}
+// ----------------------------------------------------------------
+// Not
+// ----------------------------------------------------------------
+function FromNot(context, schema) {
+    return FromSchema(context, schema.not);
+}
+// ----------------------------------------------------------------
+// OneOf
+// ----------------------------------------------------------------
+function FromOneOf(context, schema) {
+    return schema.oneOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// PatternProperties
+// ----------------------------------------------------------------
+function FromPatternProperties(context, schema) {
+    return Guard.Keys(schema.patternProperties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.patternProperties[key]) }), {});
+}
+// ----------------------------------------------------------------
+// PrefixItems
+// ----------------------------------------------------------------
+function FromPrefixItems(context, schema) {
+    return schema.prefixItems.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// Properties
+// ----------------------------------------------------------------
+function FromProperties(context, schema) {
+    return Guard.Keys(schema.properties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.properties[key]) }), {});
+}
+// ----------------------------------------------------------------
+// PropertyNames
+// ----------------------------------------------------------------
+function FromPropertyNames(context, schema) {
+    return FromSchema(context, schema.propertyNames);
+}
+// ----------------------------------------------------------------
+// Ref
+// ----------------------------------------------------------------
+function ResolveRef(context, schema, ref) {
+    return Resolve.Ref(context, schema, Resolve.DefaultBase, ref) ?? UnresolvableRef(ref);
+}
+function FromRef(context, schema) {
+    // Resolve target
+    const target = ResolveRef(context.context, context.schema, schema.$ref);
+    // Check if target is resolving, if not, resolve
+    const resolving = context.resolving.get(target);
+    if (Guard.IsUndefined(resolving))
+        return FromSchema(context, target);
+    // Target is mid-intern, so this is a cycle (point at its reserved placeholder)
+    resolving.used = true;
+    return { $ref: `#/$defs/${resolving.key}` };
+}
+// ----------------------------------------------------------------
+// Then
+// ----------------------------------------------------------------
+function FromThen(context, schema) {
+    return FromSchema(context, schema.then);
+}
+// ----------------------------------------------------------------
+// UnevaluatedItems
+// ----------------------------------------------------------------
+function FromUnevaluatedItems(context, schema) {
+    return FromSchema(context, schema.unevaluatedItems);
+}
+// ----------------------------------------------------------------
+// UnevaluatedProperties
+// ----------------------------------------------------------------
+function FromUnevaluatedProperties(context, schema) {
+    return FromSchema(context, schema.unevaluatedProperties);
+}
+// ----------------------------------------------------------------
+// SchemaObject
+// ----------------------------------------------------------------
+function FromSchemaObject(context, schema) {
+    // Reference schemas cannot contain other keywords
+    if (S.IsRef(schema))
+        return FromRef(context, schema);
+    // Check if the schema has already been resolved
+    const existing = resolved.get(schema);
+    if (!Guard.IsUndefined(existing))
+        return existing;
+    // These keywords are unsupported
+    if (S.IsDynamicRef(schema))
+        UnsupportedKeyword('$dynamicRef');
+    if (S.IsRecursiveRef(schema))
+        UnsupportedKeyword('$recursiveRef');
+    // Reserve a placeholder key in case a nested ref cycles back to this schema
+    const reservation = { key: `x-ref-${context.resolving.size}`, used: false };
+    context.resolving.set(schema, reservation);
+    // Intern each subschema
+    const remapped = {
+        ...(S.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
+        ...(S.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
+        ...(S.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
+        ...(S.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
+        ...(S.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
+        ...(S.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
+        ...(S.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
+        ...(S.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
+        ...(S.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
+        ...(S.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
+        ...(S.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
+        ...(S.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
+        ...(S.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
+        ...(S.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
+        ...(S.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
+        ...(S.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
+        ...(S.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
+        ...(S.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
+        ...(S.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
+    };
+    context.resolving.delete(schema);
+    // Finalize and register the result
+    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id']);
+    const key = reservation.used ? reservation.key : HashKey(interned);
+    registry.set(key, interned);
+    // Result
+    const result = { $ref: `#/$defs/${key}` };
+    resolved.set(schema, result);
+    return result;
+}
+// ----------------------------------------------------------------
+// SchemaBoolean
+// ----------------------------------------------------------------
+function FromSchemaBoolean(_context, schema) {
+    // Finalize and register the result
+    const key = HashKey(schema);
+    registry.set(key, schema);
+    // Result
+    const result = { $ref: `#/$defs/${key}` };
+    resolved.set(schema, result);
+    return result;
+}
+// ----------------------------------------------------------------
+// Schema
+// ----------------------------------------------------------------
+function FromSchema(context, schema) {
+    return S.IsSchemaBoolean(schema) ? FromSchemaBoolean(context, schema) : FromSchemaObject(context, schema);
+}
+// ----------------------------------------------------------------
+// BooleanEntry
+// ----------------------------------------------------------------
+function BooleanEntry(schema) {
+    const key = HashKey(schema);
+    return { $ref: `#/$defs/${key}`, $defs: { [key]: schema } };
+}
+// ----------------------------------------------------------------
+// Module-level accumulator state
+// ----------------------------------------------------------------
+const registry = new Map();
+const resolved = new Map();
+/**
+ * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
+ * schema. This function restructures the schema such that each distinct sub-schema is stored
+ * exactly once in a $defs object and keyed by content hash. This function can be used to
+ * both compress and optimize schemas prior to compilation.
+ */
+export function Intern(schema) {
+    registry.clear();
+    resolved.clear();
+    if (S.IsSchemaBoolean(schema))
+        return BooleanEntry(schema);
+    const context = S.IsDefs(schema) ? schema.$defs : {};
+    const entry = S.IsRef(schema) ? ResolveRef(context, schema, schema.$ref) : schema;
+    if (S.IsSchemaBoolean(entry))
+        return BooleanEntry(entry);
+    const ref_context = { schema, context, resolving: new Map() };
+    const result = FromSchema(ref_context, entry);
+    return { $ref: result.$ref, $defs: Object.fromEntries(registry) };
+}

package/node_modules/typebox/build/schema/parse.d.mts

@@ -7,6 +7,7 @@ export declare class ParseError {
     errors: TLocalizedValidationError[];
     constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
 }
+export declare function ThrowParseError(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): never;
 /** Parses a value against the provided schema */
 export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static<Schema>;
 /** Parses a value against the provided schema */

package/node_modules/typebox/build/schema/parse.mjs

@@ -13,15 +13,20 @@ export class ParseError {
         this.errors = errors;
     }
 }
+// ------------------------------------------------------------------
+// ThrowParseError
+// ------------------------------------------------------------------
+export function ThrowParseError(context, schema, value) {
+    const result = Errors(context, schema, value);
+    throw new ParseError(schema, value, result[1]);
+}
 /** Parses a value against the provided schema */
 export function Parse(...args) {
     const [context, schema, value] = Arguments.Match(args, {
         3: (context, schema, value) => [context, schema, value],
         2: (schema, value) => [{}, schema, value]
     });
-    if (!Check(context, schema, value)) {
-        const [_result, errors] = Errors(context, schema, value);
-        throw new ParseError(schema, value, errors);
-    }
-    return value;
+    if (Check(context, schema, value))
+        return value;
+    ThrowParseError(context, schema, value);
 }

package/node_modules/typebox/build/schema/resolve/resolve.d.mts

@@ -1,4 +1,35 @@
 import * as Schema from '../types/index.mjs';
-export declare const DefaultBase: URL;
-export declare function Ref(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
-export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;
+export declare const DefaultBase = "https://json-schema.org";
+export interface StackFrame {
+    context: Record<string, Schema.XSchema>;
+    root: Schema.XSchemaObject;
+    lexicalSchema: Schema.XSchemaObject;
+    lexicalBase: string;
+    referenceBase: string;
+    resourceBase: string;
+    ids: Schema.XId[];
+    recursiveAnchors: Schema.XRecursiveAnchor[];
+    dynamicAnchors: Schema.XDynamicAnchor[];
+    inRetrievedFrame: boolean;
+}
+export interface RetrievedResource {
+    target: Schema.XSchemaObject;
+    base: string;
+    root: Schema.XSchemaObject;
+}
+export interface ResolvedResource {
+    target: Schema.XSchemaObject;
+    resource: Schema.XId;
+}
+export interface RefResult {
+    schema: Schema.XSchema | undefined;
+    retrievedResource?: RetrievedResource;
+    resolvedResource?: ResolvedResource;
+}
+export declare function Base(schema: Schema.XSchemaObject, base: string, target: Schema.XSchema): string | undefined;
+export declare function Resource(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string): Schema.XId | undefined;
+export declare function Ref(remotes: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string, applySchemaId?: boolean): Schema.XSchema | undefined;
+export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: string, schema: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;
+export declare function ResolveRef(stackframe: StackFrame, ref: Schema.XRef): RefResult;
+export declare function ResolveRecursiveRef(stackframe: StackFrame, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
+export declare function ResolveDynamicRef(stackframe: StackFrame, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;