@openclaw/diffs 2026.9.4 → 2026.9.6

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

@@ -1,106 +1,150 @@
-// deno-fmt-ignore-file
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors;
+import { Guard } from '../../guard/index.mjs';
 import * as Schema from '../types/index.mjs';
-import { Guard as G } from '../../guard/index.mjs';
-import { Resolve } from '../resolve/index.mjs';
-export class Stack {
-    constructor(context, schema) {
-        _Stack_instances.add(this);
-        this.context = context;
-        this.schema = schema;
-        this.ids = [];
-        this.anchors = [];
-        this.recursiveAnchors = [];
-        this.dynamicAnchors = [];
-    }
-    // ----------------------------------------------------------------
-    // Base
-    // ----------------------------------------------------------------
-    BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
-    }
-    Base() {
-        return this.ids[this.ids.length - 1] ?? this.schema;
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema)) {
-            this.ids.push(schema);
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
-        }
-        if (Schema.IsAnchor(schema))
-            this.anchors.push(schema);
-        if (Schema.IsRecursiveAnchorTrue(schema))
-            this.recursiveAnchors.push(schema);
-        if (Schema.IsDynamicAnchor(schema))
-            this.dynamicAnchors.push(schema);
-    }
-    Pop(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema)) {
-            this.ids.pop();
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
-        }
-        if (Schema.IsAnchor(schema))
-            this.anchors.pop();
-        if (Schema.IsRecursiveAnchorTrue(schema))
-            this.recursiveAnchors.pop();
-        if (Schema.IsDynamicAnchor(schema))
-            this.dynamicAnchors.pop();
-    }
-    // ----------------------------------------------------------------
-    // Ref
-    // ----------------------------------------------------------------
-    Ref(ref) {
-        const root = this.schema;
-        return !ref.$ref.startsWith('#')
-            ? Resolve.Ref(this.context, root, ref.$ref)
-            : Resolve.Ref(this.context, this.Base(), ref.$ref);
-    }
-    // ----------------------------------------------------------------
-    // RecursiveRef
-    // ----------------------------------------------------------------
-    RecursiveRef(recursiveRef) {
-        return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
-    }
-    // ----------------------------------------------------------------
-    // DynamicRef
-    // ----------------------------------------------------------------
-    DynamicRef(dynamicRef) {
-        const root = this.schema;
-        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
-    }
-}
-_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
-    if (!Schema.IsSchemaObject(schema))
-        return;
-    const current = schema;
-    if (!isRoot && Schema.IsId(current))
-        return;
-    if (!isRoot && Schema.IsDynamicAnchor(current))
-        this.dynamicAnchors.push(current);
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
-}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
+// ------------------------------------------------------------------
+// DefaultUri
+// ------------------------------------------------------------------
+export const DefaultUri = 'urn:typebox:root';
+// ------------------------------------------------------------------
+// NextUri
+//
+// Resolves a relative or absolute ref against a base URI or URN.
+// Hierarchical bases (http, https, etc.) resolve using the normal
+// URL rules. URN bases have no path to resolve against, so the ref
+// is appended after the base's last ':' segment instead.
+// ------------------------------------------------------------------
+export function NextUri(ref, base) {
+    return (URL.canParse(ref, base)) ? new URL(ref, base) : Guard.IsEqual(base, DefaultUri) ? new URL(`${base}:${ref}`) : new URL(`${base.slice(0, base.lastIndexOf(':'))}:${ref}`);
+}
+// ------------------------------------------------------------------
+// Stack
+//
+// Creates the root frame a schema traversal starts from.
+// ------------------------------------------------------------------
+export function Stack(context, schema) {
+    const base = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? NextUri(schema.$id, DefaultUri).href : DefaultUri;
+    return {
+        context,
+        schema,
+        lexicalSchema: schema,
+        lexicalBase: base,
+        resourceBase: base,
+        referenceBase: base,
+        ids: [],
+        useResourceBaseForReference: true,
+        recursiveAnchor: undefined,
+        dynamicAnchors: [],
+        resourceEntries: new Map(),
+        pendingResource: true,
+        enteredResource: false
+    };
+}
+// ------------------------------------------------------------------
+// RegisterResourceAnchors
+//
+// Collects $dynamicAnchor schemas reachable from a resource root,
+// stopping at nested $id boundaries which own their own anchors.
+// ------------------------------------------------------------------
+function RegisterResourceAnchors(anchors, schema, isRoot = true) {
+    if (Schema.IsSchemaBoolean(schema))
+        return anchors;
+    if (Array.isArray(schema))
+        return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
     if (!Schema.IsSchemaObject(schema))
-        return;
-    const current = schema;
-    if (!isRoot && Schema.IsId(current))
-        return;
-    if (!isRoot && Schema.IsDynamicAnchor(current))
-        this.dynamicAnchors.pop();
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-};
+        return anchors;
+    if (!isRoot && Schema.IsId(schema))
+        return anchors;
+    const next = !isRoot && Schema.IsDynamicAnchor(schema) ? [...anchors, schema] : anchors;
+    return Object.keys(schema).reduce((result, key) => RegisterResourceAnchors(result, schema[key], false), next);
+}
+// ------------------------------------------------------------------
+// ResourceEntry
+//
+// A ref crossing (Resolve.Ref) may have marked `schema` as the entry
+// point of a retrieved/legacy resource. If so the frame resets to
+// that resource's base/root instead of chaining onto the parent.
+// ------------------------------------------------------------------
+function ResourceEntry(stack, schema) {
+    return stack.resourceEntries.get(schema);
+}
+function NextEnteredResource(stack, schema) {
+    return stack.enteredResource || ResourceEntry(stack, schema) !== undefined;
+}
+// ------------------------------------------------------------------
+// NextStack
+//
+// Each Next* helper below computes one XStack field in isolation from
+// the previous frame and the schema being pushed.
+// ------------------------------------------------------------------
+function IsRelativeId(schema) {
+    return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(schema.$id);
+}
+function NextIds(stack, schema) {
+    return Schema.IsId(schema) ? [...stack.ids, schema] : stack.ids;
+}
+function NextRecursiveAnchor(stack, schema) {
+    return stack.recursiveAnchor ?? (Schema.IsRecursiveAnchorTrue(schema) ? schema : undefined);
+}
+function NextDynamicAnchors(stack, schema) {
+    const registered = Schema.IsId(schema) ? RegisterResourceAnchors(stack.dynamicAnchors, schema) : stack.dynamicAnchors;
+    return Schema.IsDynamicAnchor(schema) ? [...registered, schema] : registered;
+}
+function NextPendingResource(stack, schema) {
+    return Schema.IsId(schema) ? false : stack.pendingResource;
+}
+function NextLexicalBase(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.base;
+    return Schema.IsId(schema) ? NextUri(schema.$id, stack.lexicalBase).href : stack.lexicalBase;
+}
+function NextResourceBase(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.base;
+    return (Schema.IsId(schema) && stack.pendingResource) ? NextUri(schema.$id, stack.resourceBase).href : stack.resourceBase;
+}
+function NextUseResourceBaseForReference(stack, schema) {
+    return Schema.IsId(schema) ? !IsRelativeId(schema) : stack.useResourceBaseForReference;
+}
+function NextReferenceBase(stack, schema) {
+    const isRetrieved = NextEnteredResource(stack, schema);
+    const useResourceBaseForReference = NextUseResourceBaseForReference(stack, schema);
+    return (isRetrieved || useResourceBaseForReference) ? NextResourceBase(stack, schema) : NextLexicalBase(stack, schema);
+}
+function NextLexicalSchema(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.root;
+    return Schema.IsId(schema) ? schema : stack.lexicalSchema;
+}
+// ------------------------------------------------------------------
+// NextStack | HasStackKeywords (Optimization)
+//
+// HasStackKeywords narrows schema to an object and checks whether it
+// carries $id, $dynamicAnchor, a first-seen $recursiveAnchor, or a
+// resource-entry point. When none apply, NextStack skips the frame
+// rebuild and returns the parent stack as-is.
+// ------------------------------------------------------------------
+function HasStackKeywords(stack, schema) {
+    return Schema.IsSchemaObject(schema) && (Schema.IsId(schema) ||
+        Schema.IsDynamicAnchor(schema) ||
+        (Guard.IsUndefined(stack.recursiveAnchor) && Schema.IsRecursiveAnchorTrue(schema)) ||
+        !Guard.IsUndefined(ResourceEntry(stack, schema)));
+}
+export function NextStack(stack, schema) {
+    return HasStackKeywords(stack, schema)
+        ? {
+            ...stack,
+            ids: NextIds(stack, schema),
+            dynamicAnchors: NextDynamicAnchors(stack, schema),
+            recursiveAnchor: NextRecursiveAnchor(stack, schema),
+            pendingResource: NextPendingResource(stack, schema),
+            lexicalBase: NextLexicalBase(stack, schema),
+            resourceBase: NextResourceBase(stack, schema),
+            useResourceBaseForReference: NextUseResourceBaseForReference(stack, schema),
+            referenceBase: NextReferenceBase(stack, schema),
+            lexicalSchema: NextLexicalSchema(stack, schema),
+            enteredResource: NextEnteredResource(stack, schema)
+        }
+        : stack;
+}

package/node_modules/typebox/build/schema/engine/additionalItems.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAdditionalItems(stack: Stack, context: BuildContext, schema: Schema.XAdditionalItems, value: string): string;
-export declare function CheckAdditionalItems(stack: Stack, context: CheckContext, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
-export declare function ErrorAdditionalItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
+export declare function BuildAdditionalItems(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalItems, value: string): string;
+export declare function CheckAdditionalItems(stack: Stack.XStack, context: CheckContext, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
+export declare function ErrorAdditionalItems(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalItems, value: unknown[]): boolean;

package/node_modules/typebox/build/schema/engine/additionalProperties.d.mts

@@ -1,9 +1,9 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Schema from '../types/index.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function CanAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties, _value: string): schema is S.XAdditionalProperties & S.XRequired;
-export declare function BuildAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
-export declare function BuildAdditionalPropertiesStandard(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
-export declare function BuildAdditionalProperties(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
-export declare function CheckAdditionalProperties(stack: Stack, context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorAdditionalProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function CanAdditionalPropertiesFast(_context: BuildContext, schema: Schema.XAdditionalProperties, _value: string): schema is Schema.XAdditionalProperties & Schema.XRequired;
+export declare function BuildAdditionalPropertiesFast(_context: BuildContext, schema: Schema.XAdditionalProperties & Schema.XRequired, value: string): string;
+export declare function BuildAdditionalPropertiesStandard(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalProperties, value: string): string;
+export declare function BuildAdditionalProperties(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalProperties, value: string): string;
+export declare function CheckAdditionalProperties(stack: Stack.XStack, context: CheckContext, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorAdditionalProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,13 +1,24 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
-import * as V from './_externals.mjs';
+import * as Schema from '../types/index.mjs';
+import * as Externals 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
@@ -23,9 +34,9 @@ function GetPropertyKeyAsPattern(key) {
 }
 function GetPropertiesPattern(schema) {
     const patterns = [];
-    if (S.IsPatternProperties(schema))
+    if (Schema.IsPatternProperties(schema))
         patterns.push(...G.Keys(schema.patternProperties));
-    if (S.IsProperties(schema))
+    if (Schema.IsProperties(schema))
         patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
     return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
 }
@@ -45,9 +56,9 @@ function GetPropertiesPattern(schema) {
 //
 // ------------------------------------------------------------------
 export function CanAdditionalPropertiesFast(_context, schema, _value) {
-    return S.IsRequired(schema)
-        && S.IsProperties(schema)
-        && !S.IsPatternProperties(schema)
+    return Schema.IsRequired(schema)
+        && Schema.IsProperties(schema)
+        && !Schema.IsPatternProperties(schema)
         && G.IsEqual(schema.additionalProperties, false)
         && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
 }
@@ -59,7 +70,7 @@ export function BuildAdditionalPropertiesFast(_context, schema, value) {
 // ------------------------------------------------------------------
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
+    const regexp = Externals.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
@@ -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,17 +108,12 @@ 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;
     });
-    return isAdditionalProperties || context.AddError({
-        keyword: 'additionalProperties',
-        schemaPath,
-        instancePath,
-        params: { additionalProperties },
-    });
+    return isAdditionalProperties ||
+        context.AddError('additionalProperties', schemaPath, instancePath, { additionalProperties });
 }

package/node_modules/typebox/build/schema/engine/allOf.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAllOf(stack: Stack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
-export declare function CheckAllOf(stack: Stack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
-export declare function ErrorAllOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;
+export declare function BuildAllOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
+export declare function CheckAllOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
+export declare function ErrorAllOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;

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);
@@ -42,6 +42,6 @@ export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isAllOf = G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
     if (!isAllOf)
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
+        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
     return isAllOf;
 }

package/node_modules/typebox/build/schema/engine/anyOf.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAnyOf(stack: Stack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
-export declare function CheckAnyOf(stack: Stack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
-export declare function ErrorAnyOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function BuildAnyOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
+export declare function CheckAnyOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function ErrorAnyOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

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

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -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)
@@ -42,11 +42,6 @@ export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isAnyOf = G.IsGreaterThan(results.length, 0) && context.Merge(results);
     if (!isAnyOf)
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isAnyOf || context.AddError({
-        keyword: 'anyOf',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
+        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
+    return isAnyOf || context.AddError('anyOf', schemaPath, instancePath, {});
 }

package/node_modules/typebox/build/schema/engine/boolean.d.mts

@@ -1,5 +1,5 @@
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorSchemaBoolean(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;
+export declare function BuildSchemaBoolean(_stack: Stack.XStack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckSchemaBoolean(_stack: Stack.XStack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
+export declare function ErrorSchemaBoolean(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

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

@@ -16,10 +16,6 @@ export function CheckSchemaBoolean(_stack, _context, schema, _value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckSchemaBoolean(stack, context, schema, value) || context.AddError({
-        keyword: 'boolean',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
+    return CheckSchemaBoolean(stack, context, schema, value) ||
+        context.AddError('boolean', schemaPath, instancePath, {});
 }

package/node_modules/typebox/build/schema/engine/const.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildConst(_stack: Stack, _context: BuildContext, schema: Schema.XConst, value: string): string;
-export declare function CheckConst(_stack: Stack, _context: CheckContext, schema: Schema.XConst, value: unknown): boolean;
-export declare function ErrorConst(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XConst, value: unknown): boolean;
+export declare function BuildConst(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XConst, value: string): string;
+export declare function CheckConst(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XConst, value: unknown): boolean;
+export declare function ErrorConst(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XConst, value: unknown): boolean;

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

@@ -21,10 +21,6 @@ export function CheckConst(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckConst(stack, context, schema, value) || context.AddError({
-        keyword: 'const',
-        schemaPath,
-        instancePath,
-        params: { allowedValue: schema.const },
-    });
+    return CheckConst(stack, context, schema, value) ||
+        context.AddError('const', schemaPath, instancePath, { allowedValue: schema.const });
 }

package/node_modules/typebox/build/schema/engine/contains.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildContains(stack: Stack, context: BuildContext, schema: Schema.XContains, value: string): string;
-export declare function CheckContains(stack: Stack, context: CheckContext, schema: Schema.XContains, value: unknown[]): boolean;
-export declare function ErrorContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XContains, value: unknown[]): boolean;
+export declare function BuildContains(stack: Stack.XStack, context: BuildContext, schema: Schema.XContains, value: string): string;
+export declare function CheckContains(stack: Stack.XStack, context: CheckContext, schema: Schema.XContains, value: unknown[]): boolean;
+export declare function ErrorContains(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XContains, value: unknown[]): boolean;

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

@@ -45,10 +45,6 @@ export function CheckContains(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains: 1 },
-    });
+    return CheckContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains: 1 });
 }

package/node_modules/typebox/build/schema/engine/dependencies.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependencies(stack: Stack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
-export declare function CheckDependencies(stack: Stack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependencies(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependencies(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
+export declare function CheckDependencies(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependencies(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;

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

@@ -34,12 +34,9 @@ export function ErrorDependencies(stack, context, schemaPath, instancePath, sche
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-                keyword: 'dependencies',
-                schemaPath,
-                instancePath,
-                params: { property: key, dependencies: schema },
-            })) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
+            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
+                context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))
+            : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
     });
     return isLength || isEvery;
 }

package/node_modules/typebox/build/schema/engine/dependentRequired.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentRequired(_stack: Stack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
-export declare function CheckDependentRequired(_stack: Stack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependentRequired(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
+export declare function CheckDependentRequired(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentRequired(_stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;

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

@@ -29,12 +29,8 @@ export function CheckDependentRequired(_stack, _context, schema, value) {
 export function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-            keyword: 'dependentRequired',
-            schemaPath,
-            instancePath,
-            params: { property: key, dependencies: keys },
-        }));
+        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) ||
+            context.AddError('dependentRequired', schemaPath, instancePath, { property: key, dependencies: keys }));
     });
     return isLength || isEveryEntry;
 }

package/node_modules/typebox/build/schema/engine/dependentSchemas.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentSchemas(stack: Stack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
-export declare function CheckDependentSchemas(stack: Stack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentSchemas(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependentSchemas(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
+export declare function CheckDependentSchemas(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentSchemas(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;