@openclaw/feishu 2026.9.3 → 2026.9.5

package/node_modules/@larksuiteoapi/node-sdk/types/index.d.ts

@@ -321647,6 +321647,14 @@ declare class WSClient {
     private reconnectInterval?;
     private reconnectGeneration;
     private isConnecting;
+    /**
+     * Set by {@link close}, cleared by {@link start}. Distinct from
+     * `reconnectGeneration`, which only invalidates *older* loops: a fresh
+     * `reConnect()` bumps the generation itself, so a closed client could
+     * resurrect its own retry loop. This flag says "this client is done"
+     * until someone starts it again.
+     */
+    private closed;
     private reconnectInfo;
     private agent?;
     /** User-supplied state-transition callbacks. All optional. */
@@ -321692,6 +321700,33 @@ declare class WSClient {
      */
     private armLiveness;
     private clearLiveness;
+    /**
+     * Detach a socket we are about to throw away: drop every listener, but
+     * leave one 'error' sink behind.
+     *
+     * `ws` reports the abort of a non-OPEN socket asynchronously — both
+     * `terminate()` and `close()` route through `abortHandshake()`, which
+     * emits 'error' on a later tick — and a non-force `close()` on an OPEN
+     * socket keeps the connection alive until the peer answers (up to `ws`'s
+     * 30s closeTimeout), during which a TCP reset still surfaces as 'error'.
+     * An EventEmitter with no 'error' listener throws instead of emitting, and
+     * that throw lands outside every try/catch, killing the host process.
+     * See https://github.com/larksuite/node-sdk/issues/197
+     *
+     * NOTE: not for the liveness watchdog — that one terminates *on purpose*
+     * and needs its listeners intact so 'close' drives the reconnect.
+     */
+    private detachSocket;
+    /**
+     * Throw away whatever the current attempt established — socket *and* the
+     * timers its 'open' handler armed. A handshake that completes after
+     * `close()` runs `pingLoop()`, and that timer is not unref'd: leaving it
+     * behind keeps the event loop alive forever on a client the caller closed.
+     *
+     * Only safe when {@link closed} is set: otherwise a newer session may
+     * already own `wsConfig`'s instance.
+     */
+    private discardConnection;
     /**
      * Invoke a user-supplied callback safely: no-op if undefined, swallow any
      * exception to avoid breaking the WS state machine.

package/node_modules/typebox/build/compile/validator.d.mts

@@ -18,7 +18,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Check(value: unknown): value is Encode;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Encode;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;

package/node_modules/typebox/build/compile/validator.mjs

@@ -53,7 +53,7 @@ export class Validator {
             return Parser(this.Context(), this.Type(), value);
         throw new ParseError(value, this.Errors(value));
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -14,14 +14,16 @@ function IsLabel(value) {
 // ------------------------------------------------------------------
 // NormalizeHostname
 //
-// Normalizes a hostname for label validation. Normalizes for NFC
-// such that equivalent codepoint sequences can be uniformly
-// compared. It also removes codepoints that IDNA mapping ignores,
-// and converts full stop variants to ASCII '.' so the hostname can
-// be split into labels.
+// Normalizes a hostname for label validation. Maps fullwidth
+// codepoints to their ASCII equivalent (e.g. 'ａ' U+FF41 maps to
+// 'a'), then normalizes for NFC such that equivalent codepoint
+// sequences can be uniformly compared. It also removes codepoints
+// that IDNA mapping ignores, and converts full stop variants to
+// ASCII '.' so the hostname can be split into labels.
 // ------------------------------------------------------------------
 function NormalizeHostname(value) {
     return value
+        .replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0)) // RE_FULLWIDTH_MAPPING
         .normalize('NFC')
         .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
         .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING

package/node_modules/typebox/build/format/iri.mjs

@@ -2,6 +2,7 @@
 const IpvFutureMatchMaxLength = 2048;
 const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
 // NarrowIpvFuture
 //
@@ -26,6 +27,9 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 2. Reject malformed percent-encoding triplets.
+    if (InvalidPercentEncoding.test(value))
+        return false;
+    // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
     return URL.canParse(NarrowIpvFuture(value));
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -106,15 +106,13 @@ export function IsMaxLength(value, length) {
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, params, expression) {
-    return G.IsEqual(offset, '0')
-        ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
-        : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
 }
 export function Some(value, params, expression) {
     return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function SomeAll(value, params, expression) {
-    return `((value, callback) => { let result = false; for(let index = 0; index < value.length; index++) if (callback(value[index], index)) result = true; return result })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
 }
 export function Counted(value, params, expression) {
     return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;

package/node_modules/typebox/build/guard/guard.mjs

@@ -140,36 +140,24 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            return false;
-    }
-    return true;
+    return value.every((item, index) => (index < offset) || callback(item, index));
 }
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            result = false;
-    }
+    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
+        result = false; });
     return result;
 }
 /** Returns true if some element satisfies the callback, short-circuiting on the first success */
 export function Some(value, callback) {
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            return true;
-    }
-    return false;
+    return value.some((value, index) => callback(value, index));
 }
 /** Returns true if some element satisfies the callback, using exhaustive enumeration */
 export function SomeAll(value, callback) {
     let result = false;
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            result = true;
-    }
+    value.forEach((item, index) => { if (callback(item, index))
+        result = true; });
     return result;
 }
 /** Returns the count of elements that satisfy the callback */

package/node_modules/typebox/build/guard/string.mjs

@@ -84,10 +84,11 @@ function NextGraphemeClusterIndex(value, clusterStart) {
 // IsGraphemeCodePoint
 // --------------------------------------------------------------------------
 function IsGraphemeCodePoint(value) {
-    return (IsHighSurrogate(value) ||
+    return ((value >= 0x0300) && ( // above special range
+    IsHighSurrogate(value) ||
         IsCombiningMark(value) ||
         IsVariationSelector(value) ||
-        IsZeroWidthJoiner(value));
+        IsZeroWidthJoiner(value)));
 }
 // --------------------------------------------------------------------------
 // GraphemeCount
@@ -103,30 +104,22 @@ export function GraphemeCount(value) {
     return count;
 }
 // --------------------------------------------------------------------------
-// IsMinLength
+// IsMinLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
-    // ----------------------------------------------------------------
-    // Inaccessible via public interface (review)
-    //
-    // deno-coverage-ignore-start
-    // ----------------------------------------------------------------
-    if (minLength === 0)
-        return true; // 0-length
-    // deno-coverage-ignore-stop
+    // if (minLength === 0) return true // 0-length (unreachable)
     let count = 0;
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count >= minLength)
+        if ((++count) >= minLength)
             return true;
     }
     return false;
 }
 // --------------------------------------------------------------------------
-// IsMaxLength
+// IsMaxLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
@@ -134,8 +127,7 @@ function IsMaxLengthSegmented(value, maxLength) {
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count > maxLength)
+        if ((++count) > maxLength)
             return false;
     }
     return true;
@@ -147,30 +139,30 @@ function IsMaxLengthSegmented(value, maxLength) {
 export function IsMinLength(value, minLength) {
     if (minLength === 0)
         return true; // 0-length
+    if (value.length < minLength)
+        return false; // length is upper bound on grapheme count
     let index = 0;
-    while (index < value.length) {
+    while (true) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMinLengthSegmented(value, minLength);
         }
-        index++;
-        if (index >= minLength)
+        if ((++index) >= minLength)
             return true;
     }
-    return false;
 }
 // --------------------------------------------------------------------------
 // IsMaxLengthFast
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {
+    if (value.length <= maxLength)
+        return true; // length is upper bound on grapheme count
     let index = 0;
-    while (index < value.length) {
+    while (true) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMaxLengthSegmented(value, maxLength);
         }
-        index++;
-        if (index > maxLength)
+        if ((++index) > maxLength)
             return false;
     }
-    return true;
 }

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

@@ -27,7 +27,7 @@ function CreateEvaluatedCheck(build, code) {
 // 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 +109,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/node_modules/typebox/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/node_modules/typebox/build/schema/compile.d.mts

@@ -2,8 +2,9 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly buildResult;
     private readonly evaluateResult;
+    private readonly context;
+    private readonly schema;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
@@ -13,7 +14,7 @@ export declare class Validator<const Schema extends Schema.XSchema = Schema.XSch
     Check(value: unknown): value is Value;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Value;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
 }
 /** Compiles this schema into a high performance Validator */

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

@@ -3,14 +3,15 @@
 import { Arguments } from '../system/arguments/index.mjs';
 import * as Build from './build.mjs';
 import { Errors } from './errors.mjs';
-import { ParseError } from './parse.mjs';
+import { ThrowParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 // Validator
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.buildResult = Build.Build(context, schema);
-        this.evaluateResult = this.buildResult.Evaluate();
+        this.evaluateResult = Build.Build(context, schema).Evaluate();
+        this.context = context;
+        this.schema = schema;
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
@@ -18,7 +19,7 @@ export class Validator {
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.buildResult.Schema();
+        return this.schema;
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
@@ -28,12 +29,11 @@ export class Validator {
     Parse(value) {
         if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
-        throw new ParseError(this.buildResult.Schema(), value, errors);
+        ThrowParseError(this.context, this.schema, value);
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
-        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        return Errors(this.context, this.schema, value);
     }
 }
 /** Compiles this schema into a high performance Validator */

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

@@ -21,15 +21,14 @@ export declare class CheckContext {
     GetKeys(): Set<string>;
     Merge(results: CheckContext[]): true;
 }
-export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
-    private readonly callback;
-    constructor(callback: ErrorContextCallback);
-    AddError(error: TValidationError): false;
-}
-export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
     constructor();
-    AddError(error: TValidationError): false;
+    AtCapacity(): boolean;
+    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/node_modules/typebox/build/schema/engine/_context.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../system/settings/index.mjs';
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -101,29 +102,36 @@ export class CheckContext {
         return true;
     }
 }
-export class ErrorContext extends CheckContext {
-    constructor(callback) {
-        super();
-        this.callback = callback;
-    }
-    AddError(error) {
-        this.callback(error);
-        return false;
-    }
-}
 // ------------------------------------------------------------------
-// AccumulatedErrorContext
+// ErrorContext
 // ------------------------------------------------------------------
-export class AccumulatedErrorContext extends ErrorContext {
+export class ErrorContext extends CheckContext {
     constructor() {
-        super(error => this.errors.push(error));
+        super();
         this.errors = [];
     }
-    AddError(error) {
-        this.errors.push(error);
+    // ----------------------------------------------------------------
+    // 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));
         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 { 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/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.BaseURL().href);
+    const name = CreateName(schema, stack.lexicalBase);
     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 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/node_modules/typebox/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/node_modules/typebox/build/schema/engine/_refine.mjs

@@ -1,11 +1,11 @@
 // 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
 // ------------------------------------------------------------------
 export function BuildRefine(_stack, _context, schema, value) {
-    const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
+    const refinements = Externals.CreateVariable(schema['~refine'].map((refinement) => refinement));
     return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
 }
 // ------------------------------------------------------------------
@@ -19,11 +19,8 @@ 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/node_modules/typebox/build/schema/engine/_stack.d.mts

@@ -1,18 +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 anchors;
-    private readonly recursiveAnchors;
-    private readonly dynamicAnchors;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    BaseURL(): URL;
-    Base(): Schema.XSchemaObject;
-    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;