pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

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

@@ -110,28 +110,15 @@ export class ErrorContext extends CheckContext {
         super();
         this.errors = [];
     }
-    // ----------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------
     AtCapacity() {
         return this.errors.length >= Settings.Get().maxErrors;
     }
-    AddError(keyword, schemaPath, instancePath, params) {
-        return this.AddErrorObject({ keyword, schemaPath, instancePath, params });
-    }
-    AddErrors(error) {
-        error.forEach(error => this.AddErrorObject(error));
+    AddError(error) {
+        if (!this.AtCapacity())
+            this.errors.push(error);
         return false;
     }
     GetErrors() {
         return this.errors;
     }
-    // ----------------------------------------------------------------
-    // Private
-    // ----------------------------------------------------------------
-    AddErrorObject(error) {
-        if (!this.AtCapacity())
-            this.errors.push(error);
-        return false;
-    }
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext } from './_context.mjs';
 export declare function ResetFunctions(): void;
 export declare function GetFunctions(): string[];
-export declare function CreateFunction(stack: Stack.XStack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;

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

@@ -55,7 +55,7 @@ export function GetFunctions() {
 // CreateFunction
 // ------------------------------------------------------------------
 export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.lexicalBase);
+    const name = CreateName(schema, stack.LexicalBaseURL());
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

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

@@ -1,4 +1,4 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import * as S from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext } from './_context.mjs';
-export declare function Reducer(stack: Stack.XStack, context: BuildContext, schemas: Schema.XSchema[], value: string, check: string): string;
+export declare function Reducer(stack: Stack, context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;

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

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

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

@@ -1,21 +1,12 @@
 // deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
+import * as V from './_externals.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildRefineMultiple(_stack, _context, schema, value) {
-    const external = Externals.CreateVariable(schema['~refine']);
-    return E.Every(external, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
-}
-function BuildRefineSingle(_stack, _context, schema, value) {
-    const external = Externals.CreateVariable(schema['~refine'][0]);
-    return E.Call(E.Member(external, 'check'), [value]);
-}
 export function BuildRefine(_stack, _context, schema, value) {
-    return G.IsEqual(schema['~refine'].length, 1)
-        ? BuildRefineSingle(_stack, _context, schema, value)
-        : BuildRefineMultiple(_stack, _context, schema, value);
+    const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
@@ -28,7 +19,11 @@ export function CheckRefine(_stack, _context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) ||
-            context.AddError('~refine', schemaPath, instancePath, { index, message: refinement.error(value) });
+        return refinement.check(value) || context.AddError({
+            keyword: '~refine',
+            schemaPath,
+            instancePath,
+            params: { index, message: refinement.error(value) },
+        });
     });
 }

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

@@ -1,36 +1,22 @@
 import * as Schema from '../types/index.mjs';
-export declare const DefaultUri = "urn:typebox:root";
-export interface XStack {
-    /** The schema context. */
-    readonly context: Record<string, Schema.XSchema>;
-    /** The entry schema. */
-    readonly schema: Schema.XSchema;
-    /** Visited $id schemas, kept only to detect resource re-entry (see resolve.ts FindResolvedResource). */
-    readonly ids: Schema.XId[];
-    /** Nearest enclosing $id schema, used as the root for local pointer resolution. */
-    readonly lexicalSchema: Schema.XSchema;
-    /** First $recursiveAnchor: true schema seen on the path. */
-    readonly recursiveAnchor: Schema.XRecursiveAnchor | undefined;
-    /** Dynamic anchors visible at this point in the traversal. */
-    readonly dynamicAnchors: Schema.XDynamicAnchor[];
-    /** Lexical base URL, used to resolve relative $id and $ref values within the current schema. */
-    readonly lexicalBase: string;
-    /** Base URL of the current resource, reset each time a new resource $id is entered. */
-    readonly resourceBase: string;
-    /** Base URL that $ref values resolve against. */
-    readonly referenceBase: string;
-    /** Resource entry point bookkeeping: schema -> the base/root to apply when that schema is next pushed. */
-    readonly resourceEntries: Map<Schema.XSchemaObject, {
-        base: string;
-        root: Schema.XSchemaObject;
-    }>;
-    /** True while referenceBase should track resourceBase rather than lexicalBase. */
-    readonly useResourceBaseForReference: boolean;
-    /** True until the next $id schema is entered, marking it as a fresh resource root. */
-    readonly pendingResource: boolean;
-    /** True once traversal has entered a retrieved or legacy resource. */
-    readonly enteredResource: boolean;
+export declare class Stack {
+    #private;
+    private readonly context;
+    private readonly schema;
+    private readonly ids;
+    private readonly resourceIds;
+    private readonly anchors;
+    private readonly recursiveAnchors;
+    private readonly dynamicAnchors;
+    private readonly retrievedResources;
+    private readonly retrievedFrames;
+    private readonly resolvedResources;
+    private pendingResource;
+    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
+    LexicalBaseURL(): string;
+    Push(schema: Schema.XSchema): void;
+    Pop(schema: Schema.XSchema): void;
+    Ref(ref: Schema.XRef): Schema.XSchema | undefined;
+    RecursiveRef(recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
+    DynamicRef(dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
 }
-export declare function NextUri(ref: string, base: string): URL;
-export declare function Stack(context: Record<string, Schema.XSchema>, schema: Schema.XSchema): XStack;
-export declare function NextStack(stack: XStack, schema: Schema.XSchema): XStack;

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

@@ -1,150 +1,209 @@
-import { Guard } from '../../guard/index.mjs';
+// 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_StackFrame, _Stack_ApplyRefResult, _Stack_BuildBase, _Stack_ResourceBaseURL, _Stack_ReferenceBaseURL, _Stack_LexicalSchema, _Stack_RegisterResourceAnchorArray, _Stack_UnregisterResourceAnchorArray, _Stack_RegisterResourceAnchors, _Stack_UnregisterResourceAnchors, _Stack_RegisterResource, _Stack_UnregisterResource, _Stack_EnterResolvedResource, _Stack_ExitResolvedResource;
 import * as Schema from '../types/index.mjs';
-// ------------------------------------------------------------------
-// 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}`);
-}
-// ------------------------------------------------------------------
+import { Guard } from '../../guard/index.mjs';
+import { Resolve } from '../resolve/index.mjs';
+// --------------------------------------------------------------------------
 // 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;
+// Tracks traversal state ($ids, $anchors, stack frames) and applies scope
+// updates. Reference resolution rules ($ref, $dynamicRef) are delegated to
+// the Resolve functions using state snapshots (Resolve.Scope).
+// --------------------------------------------------------------------------
+export class Stack {
+    constructor(context, schema) {
+        _Stack_instances.add(this);
+        this.context = context;
+        this.schema = schema;
+        this.ids = [];
+        this.resourceIds = [];
+        this.anchors = [];
+        this.recursiveAnchors = [];
+        this.dynamicAnchors = [];
+        this.retrievedResources = new Map();
+        this.retrievedFrames = [];
+        this.resolvedResources = new Map();
+        this.pendingResource = true;
+    }
+    // ----------------------------------------------------------------
+    // LexicalBaseURL
+    // ----------------------------------------------------------------
+    LexicalBaseURL() {
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.ids);
+    }
+    // ----------------------------------------------------------------
+    // Push
+    // ----------------------------------------------------------------
+    Push(schema) {
+        if (!Schema.IsSchemaObject(schema))
+            return;
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).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);
+        const retrievedResource = this.retrievedResources.get(schema);
+        if (retrievedResource) {
+            this.retrievedFrames.push({
+                schema: retrievedResource.root,
+                base: retrievedResource.base,
+                idDepth: this.ids.length,
+                resourceDepth: this.resourceIds.length
+            });
+        }
+    }
+    // ----------------------------------------------------------------
+    // Pop
+    // ----------------------------------------------------------------
+    Pop(schema) {
+        if (!Schema.IsSchemaObject(schema))
+            return;
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, schema);
+        if (Schema.IsAnchor(schema))
+            this.anchors.pop();
+        if (Schema.IsRecursiveAnchorTrue(schema))
+            this.recursiveAnchors.pop();
+        if (Schema.IsDynamicAnchor(schema))
+            this.dynamicAnchors.pop();
+        if (this.retrievedResources.has(schema))
+            this.retrievedFrames.pop();
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ExitResolvedResource).call(this, schema);
+    }
+    // ----------------------------------------------------------------
+    // Ref
+    // ----------------------------------------------------------------
+    Ref(ref) {
+        const result = Resolve.ResolveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), ref);
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ApplyRefResult).call(this, result);
+        return result.schema;
+    }
+    // ----------------------------------------------------------------
+    // RecursiveRef
+    // ----------------------------------------------------------------
+    RecursiveRef(recursiveRef) {
+        const result = Resolve.ResolveRecursiveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), recursiveRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
+    }
+    // ----------------------------------------------------------------
+    // DynamicRef
+    // ----------------------------------------------------------------
+    DynamicRef(dynamicRef) {
+        const result = Resolve.ResolveDynamicRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), dynamicRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
+    }
+}
+_Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame() {
     return {
-        context,
-        schema,
-        lexicalSchema: schema,
-        lexicalBase: base,
-        resourceBase: base,
-        referenceBase: base,
-        ids: [],
-        useResourceBaseForReference: true,
-        recursiveAnchor: undefined,
-        dynamicAnchors: [],
-        resourceEntries: new Map(),
-        pendingResource: true,
-        enteredResource: false
+        context: this.context,
+        root: this.schema,
+        ids: this.ids,
+        lexicalSchema: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_LexicalSchema).call(this),
+        lexicalBase: this.LexicalBaseURL(),
+        referenceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ReferenceBaseURL).call(this),
+        resourceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this),
+        recursiveAnchors: this.recursiveAnchors,
+        dynamicAnchors: this.dynamicAnchors,
+        inRetrievedFrame: this.retrievedFrames.length > 0
     };
-}
-// ------------------------------------------------------------------
-// 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) {
+}, _Stack_ApplyRefResult = function _Stack_ApplyRefResult(result) {
+    if (!Guard.IsUndefined(result.schema))
+        this.pendingResource = true;
+    if (!Guard.IsUndefined(result.resolvedResource)) {
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_EnterResolvedResource).call(this, result.resolvedResource.target, result.resolvedResource.resource);
+    }
+    if (!Guard.IsUndefined(result.retrievedResource)) {
+        this.retrievedResources.set(result.retrievedResource.target, {
+            base: result.retrievedResource.base,
+            root: result.retrievedResource.root
+        });
+    }
+}, _Stack_BuildBase = function _Stack_BuildBase(stack) {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    const base = frame ? new URL(frame.base) : new URL(Resolve.DefaultBase);
+    const scoped = frame ? stack.slice(frame.idDepth) : stack;
+    return scoped.reduce((result, schema) => new URL(schema.$id, result), base).href;
+}, _Stack_ResourceBaseURL = function _Stack_ResourceBaseURL() {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    if (!frame)
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.resourceIds);
+    return this.resourceIds.slice(frame.resourceDepth).reduce((result, schema) => new URL(schema.$id, result), new URL(frame.base)).href;
+}, _Stack_ReferenceBaseURL = function _Stack_ReferenceBaseURL() {
+    if (this.retrievedFrames.length > 0)
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
+    const lexical = this.ids[this.ids.length - 1];
+    if (lexical && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(lexical.$id))
+        return this.LexicalBaseURL();
+    return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
+}, _Stack_LexicalSchema = function _Stack_LexicalSchema() {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    if (frame)
+        return this.ids.length > frame.idDepth ? this.ids[this.ids.length - 1] : frame.schema;
+    return this.ids.length > 0 ? this.ids[this.ids.length - 1] : this.schema;
+}, _Stack_RegisterResourceAnchorArray = function _Stack_RegisterResourceAnchorArray(schema) {
+    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, false));
+}, _Stack_UnregisterResourceAnchorArray = function _Stack_UnregisterResourceAnchorArray(schema) {
+    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, false));
+}, _Stack_RegisterResourceAnchors = function _Stack_RegisterResourceAnchors(schema, isRoot = true) {
     if (Schema.IsSchemaBoolean(schema))
-        return anchors;
-    if (Array.isArray(schema))
-        return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
+        return;
+    if (Guard.IsArray(schema))
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchorArray).call(this, schema);
     if (!Schema.IsSchemaObject(schema))
-        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;
-}
+        return;
+    const current = schema;
+    if (!isRoot && Schema.IsId(current))
+        return;
+    if (!isRoot && Schema.IsDynamicAnchor(current))
+        this.dynamicAnchors.push(current);
+    for (const key of Guard.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, current[key], false);
+}, _Stack_UnregisterResourceAnchors = function _Stack_UnregisterResourceAnchors(schema, isRoot = true) {
+    if (Schema.IsSchemaBoolean(schema))
+        return;
+    if (Guard.IsArray(schema))
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchorArray).call(this, schema);
+    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 Guard.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, current[key], false);
+}, _Stack_RegisterResource = function _Stack_RegisterResource(schema) {
+    this.ids.push(schema);
+    const isResource = this.pendingResource;
+    this.pendingResource = false;
+    if (isResource)
+        this.resourceIds.push(schema);
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, true);
+}, _Stack_UnregisterResource = function _Stack_UnregisterResource(schema) {
+    this.ids.pop();
+    const isResource = this.resourceIds.length > 0 && Guard.IsEqual(this.resourceIds[this.resourceIds.length - 1], schema);
+    if (isResource)
+        this.resourceIds.pop();
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, true);
+}, _Stack_EnterResolvedResource = function _Stack_EnterResolvedResource(target, resource) {
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, resource);
+    this.resolvedResources.set(target, resource);
+}, _Stack_ExitResolvedResource = function _Stack_ExitResolvedResource(target) {
+    if (!this.resolvedResources.has(target))
+        return;
+    const resource = this.resolvedResources.get(target);
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, resource);
+    this.resolvedResources.delete(target);
+};

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

@@ -1,4 +1,2 @@
-/** Creates a unique variable name */
-export declare function CreateUnique(): string;
-/** Resets the unique variable name counter */
-export declare function ResetUnique(): void;
+/** Returns a Unique Variable Name */
+export declare function Unique(): string;

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

@@ -1,9 +1,5 @@
 let index = 0;
-/** Creates a unique variable name */
-export function CreateUnique() {
-    return `unique_${index++}`;
-}
-/** Resets the unique variable name counter */
-export function ResetUnique() {
-    index = 0;
+/** Returns a Unique Variable Name */
+export function Unique() {
+    return `var_${index++}`;
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
+import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,14 +13,14 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildAdditionalItemsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
+    const [item, index] = [Unique(), Unique()];
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     const addIndex = context.AddIndex(index);
     return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, E.And(isSchema, addIndex)));
 }
 function BuildAdditionalItemsFast(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
+    const [item, index] = [Unique(), Unique()];
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, isSchema));

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

@@ -1,6 +1,9 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import * as S from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;