@depup/typebox 1.3.27-depup.0 → 1.3.34-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typebox
 
 | Field | Value |
 |-------|-------|
-| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.27 |
-| Processed | 2026-09-06 |
+| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.34 |
+| Processed | 2026-09-20 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/build/compile/code.mjs

@@ -16,9 +16,8 @@ function Separator() {
 function ImportSection(build) {
     const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
     const hashing = `import { Hashing } from "typebox/system"`;
-    const format = `import { Format } from "typebox/format"`;
     const guard = `import { Guard } from "typebox/guard"`;
-    return [...context, hashing, format, guard];
+    return [...context, hashing, guard];
 }
 // ------------------------------------------------------------------
 // ExternalSection

package/build/compile/validator.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Settings } from '../system/settings/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
@@ -51,7 +52,10 @@ export class Validator {
             return value;
         if (Settings.Get().correctiveParse)
             return Parser(this.Context(), this.Type(), value);
-        throw new ParseError(value, this.Errors(value));
+        EnableParseErrors();
+        const errors = this.Errors(value);
+        DisableParseErrors();
+        throw new ParseError(value, errors);
     }
     /** Returns an array of validation errors for the given value. */
     Errors(value) {

package/build/format/iri.mjs

@@ -1,9 +1,10 @@
 // deno-lint-ignore-file no-control-regex
-const IpvFutureMatchMaxLength = 2048;
-const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
-const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
+//
+// Removed by the following PR
+//
+// https://github.com/json-schema-org/JSON-Schema-Test-Suite/pull/1176
+//
 // NarrowIpvFuture
 //
 // Substitutes an IPvFuture address with a standard IPv6 loopback
@@ -13,12 +14,18 @@ const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // be expensive on large strings, this operation is strictly
 // limited to inputs under a defined length threshold.
 //
-// (review-optimization)
+// ------------------------------------------------------------------
+//
+// const IpvFutureMatchMaxLength = 2048
+// const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/ // Guarded By IpvFutureMatchMaxLength
+//
+// function NarrowIpvFuture(value: string): string {
+//   return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value
+// }
 //
 // ------------------------------------------------------------------
-function NarrowIpvFuture(value) {
-    return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value;
-}
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 /**
  * Returns true if the value is a valid Internationalized Resource Identifier.
  * @specification https://datatracker.ietf.org/doc/html/rfc3987
@@ -31,5 +38,5 @@ export function IsIri(value) {
     if (InvalidPercentEncoding.test(value))
         return false;
     // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
-    return URL.canParse(NarrowIpvFuture(value));
+    return URL.canParse(value);
 }

package/build/guard/emit.mjs

@@ -97,10 +97,10 @@ export function IsGreaterEqualThan(left, right) {
 // String
 // --------------------------------------------------------------------------
 export function IsMinLength(value, length) {
-    return `Guard.IsMinLength(${value}, ${length})`;
+    return `(${value}.length >= ${(+length) << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
 }
 export function IsMaxLength(value, length) {
-    return `Guard.IsMaxLength(${value}, ${length})`;
+    return `(${value}.length <= ${length} || (${value}.length <= ${(+length) << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
 }
 // --------------------------------------------------------------------------
 // Array

package/build/guard/guard.d.mts

@@ -33,12 +33,14 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export declare function GraphemeCount(value: string): number;
-/** Returns true if the string has at most the given number of graphemes */
-export declare function IsMaxLength(value: string, length: number): boolean;
-/** Returns true if the string has at least the given number of graphemes */
-export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns the total number of Unicode code points in the string. */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is at least minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */

package/build/guard/guard.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
-import * as String from './string.mjs';
+import * as UnicodeSegmentGuard from './unicode/unicode_segment.mjs';
+import * as UnicodeGuard from './unicode/unicode.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -123,17 +124,21 @@ export function IsValueLike(value) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export function GraphemeCount(value) {
-    return String.GraphemeCount(value);
+    return UnicodeSegmentGuard.GraphemeCount(value);
 }
-/** Returns true if the string has at most the given number of graphemes */
-export function IsMaxLength(value, length) {
-    return String.IsMaxLength(value, length);
+/** Returns the total number of Unicode code points in the string. */
+export function CodePointCount(value) {
+    return UnicodeGuard.CodePointCount(value);
 }
-/** Returns true if the string has at least the given number of graphemes */
-export function IsMinLength(value, length) {
-    return String.IsMinLength(value, length);
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export function IsMaxLength(value, maxLength) {
+    return UnicodeGuard.IsMaxLength(value, maxLength);
+}
+/** Returns true if the string length in Unicode code points is at least minLength */
+export function IsMinLength(value, minLength) {
+    return UnicodeGuard.IsMinLength(value, minLength);
 }
 // --------------------------------------------------------------------------
 // Array

package/build/guard/index.mjs

@@ -1,6 +1,12 @@
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
 export * as EmitGuard from './emit.mjs';
 export * as GlobalsGuard from './globals.mjs';
 export * as NativeGuard from './native.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 import * as Guard from './guard.mjs';
 export * as Guard from './guard.mjs';
 export default Guard;

package/build/guard/unicode/unicode.d.mts

@@ -0,0 +1,6 @@
+/** Returns the total number of Unicode code points in the string */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;

package/build/guard/unicode/unicode.mjs

@@ -0,0 +1,35 @@
+// ------------------------------------------------------------------
+// CodePointCount (10-bit Shift Branchless)
+//
+// Counts code points by enumerating UTF-16 sequences and incrementing
+// when not within a high/low pairing. Because surrogate blocks are
+// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
+// collapse each unit to a constant per block (high: 0x36, low: 0x37)
+// and shift again into a packed (0x3637) for comparison. Fetch calls
+// to charCodeAt(...) are kept to one call per iteration.
+//
+// ------------------------------------------------------------------
+/** Returns the total number of Unicode code points in the string */
+export function CodePointCount(value) {
+    let result = 0, index = 0, prev = 0;
+    while (index < value.length) {
+        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
+        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
+        prev = next;
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// IsMaxLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export function IsMaxLength(value, maxLength) {
+    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
+}
+// ------------------------------------------------------------------
+// IsMinLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export function IsMinLength(value, minLength) {
+    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
+}

package/build/guard/{string.mjs → unicode/unicode_segment.mjs}

@@ -91,26 +91,12 @@ function IsGraphemeCodePoint(value) {
         IsZeroWidthJoiner(value)));
 }
 // --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
 // IsMinLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
     // if (minLength === 0) return true // 0-length (unreachable)
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) >= minLength)
@@ -123,8 +109,7 @@ function IsMinLengthSegmented(value, minLength) {
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) > maxLength)
@@ -133,7 +118,19 @@ function IsMaxLengthSegmented(value, maxLength) {
     return true;
 }
 // --------------------------------------------------------------------------
-// IsMinLengthFast
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0, index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
 // --------------------------------------------------------------------------
 /** Fast check for minimum grapheme length, falls back to full check if needed */
 export function IsMinLength(value, minLength) {
@@ -151,7 +148,7 @@ export function IsMinLength(value, minLength) {
     }
 }
 // --------------------------------------------------------------------------
-// IsMaxLengthFast
+// IsMaxLength
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {

package/build/schema/build.mjs

@@ -4,7 +4,6 @@ import { Arguments } from '../system/arguments/index.mjs';
 import { Environment } from '../system/environment/index.mjs';
 import { Hashing } from '../system/hashing/index.mjs';
 import { Guard } from '../guard/index.mjs';
-import { Format } from '../format/index.mjs';
 import * as Engine from './engine/index.mjs';
 // ------------------------------------------------------------------
 // CreateCode
@@ -20,14 +19,14 @@ function CreateCode(build) {
 // CreateEvaluatedCheck
 // ------------------------------------------------------------------
 function CreateEvaluatedCheck(build, code) {
-    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
+    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Hashing', build.External().identifier, code);
+    return factory(Engine.CheckContext, Guard, Hashing, build.External().variables);
 }
 // ------------------------------------------------------------------
 // CreateDynamicCheck
 // ------------------------------------------------------------------
 function CreateDynamicCheck(build) {
-    const stack = new Engine.Stack(build.Context(), build.Schema());
+    const stack = Engine.Stack(build.Context(), build.Schema());
     const context = new Engine.CheckContext();
     return (value) => Engine.CheckSchema(stack, context, build.Schema(), value);
 }
@@ -109,7 +108,7 @@ export function Build(...args) {
     });
     Engine.ResetExternal();
     Engine.ResetFunctions();
-    const stack = new Engine.Stack(context, schema);
+    const stack = Engine.Stack(context, schema);
     const build = new Engine.BuildContext(Engine.HasUnevaluated(context, schema));
     const call = Engine.CreateFunction(stack, build, schema, 'value');
     const functions = Engine.GetFunctions();

package/build/schema/check.mjs

@@ -8,7 +8,7 @@ export function Check(...args) {
         3: (context, schema, value) => [context, schema, value],
         2: (schema, value) => [{}, schema, value]
     });
-    const stack = new Engine.Stack(context, schema);
+    const stack = Engine.Stack(context, schema);
     const checkContext = new Engine.CheckContext();
     return Engine.CheckSchema(stack, checkContext, schema, value);
 }

package/build/schema/engine/_context.d.mts

@@ -25,6 +25,10 @@ export declare class ErrorContext extends CheckContext {
     private readonly errors;
     constructor();
     AtCapacity(): boolean;
-    AddError(error: TValidationError): false;
+    AddError<Keyword extends TValidationError['keyword']>(keyword: Keyword, schemaPath: string, instancePath: string, params: Extract<TValidationError, {
+        keyword: Keyword;
+    }>['params']): false;
+    AddErrors(error: TValidationError[]): false;
     GetErrors(): TValidationError[];
+    private AddErrorObject;
 }

package/build/schema/engine/_context.mjs

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

package/build/schema/engine/_functions.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 } from './_context.mjs';
 export declare function ResetFunctions(): void;
 export declare function GetFunctions(): string[];
-export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CreateFunction(stack: Stack.XStack, context: BuildContext, schema: Schema.XSchema, value: string): string;

package/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.LexicalBaseURL());
+    const name = CreateName(schema, stack.lexicalBase);
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

package/build/schema/engine/_pathing.d.mts

@@ -0,0 +1 @@
+export declare function EncodeFragment(fragment: string): string;

package/build/schema/engine/_pathing.mjs

@@ -0,0 +1,11 @@
+// ------------------------------------------------------------------
+// EncodeFragment
+//
+// We use this function to encode instancePath and schemaPath path
+// fragments for errors. We need this encoding such that callers
+// can use Pointer to deref error targets. We should consider adding
+// this to the Pointer module as Pointer.Encode(...) (review)
+// ------------------------------------------------------------------
+export function EncodeFragment(fragment) {
+    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
+}

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

@@ -1,4 +1,4 @@
-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 } from './_context.mjs';
-export declare function Reducer(stack: Stack, context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;
+export declare function Reducer(stack: Stack.XStack, context: BuildContext, schemas: Schema.XSchema[], value: string, check: string): string;

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

@@ -1,6 +1,6 @@
-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 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;
+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;

package/build/schema/engine/_refine.mjs

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

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

@@ -1,22 +1,36 @@
 import * as Schema from '../types/index.mjs';
-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 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 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;