@reticlehq/browser 2.13.1 → 3.1.0

package/dist/review/annotator-styles.js

@@ -1,17 +1,10 @@
-import { Z_OVERLAY } from '../presenter/presenter-styles.js';
-/** Markup + CSS for the in-page annotation HUD (markers, hover box, composer). */
+import { Z_OVERLAY } from '../presenter/chrome/layers.js';
 const MARK_ATTR = 'data-reticle-mark';
 const sel = (role) => `[${MARK_ATTR}="${role}"]`;
 export const MARK_PLACEHOLDER = 'What should change?';
 export const MARK_SUBMIT = 'Add';
 export const MARK_CANCEL = 'Cancel';
 export const MARK_PENDING_GLYPH = '+';
-/**
- * ABOVE the presenter overlay, because the overlay contains the page blocker annotate mode raises.
- * One below it, the shield painted over the composer: every click on Cancel or Add landed on the
- * blocker instead of the button, so the note could be neither saved nor dismissed. The root here is
- * pointer-events:none, so only the marks and the composer sit above the HUD - not a new shield.
- */
 const Z_MARK = Z_OVERLAY + 1;
 export const ANNOTATOR_CSS = `
 ${sel('root')}{position:fixed;inset:0;pointer-events:none;z-index:${String(Z_MARK)};}

package/dist/review/annotator.d.ts

@@ -1,19 +1,9 @@
 import { EventType } from '@reticlehq/core';
-/**
- * What the HUD is told about a mark the moment it is placed.
- *
- * The row used to get the note and the anchor's label - "generic: my feedback" - which names
- * neither the element nor which of several marks it is. The pin on the page is numbered, so the
- * row carries the same number, plus the source the anchor already resolved.
- */
-export interface MarkReport {
+interface MarkReport {
     note: string;
-    /** The anchor the agent will look the element up by, e.g. `[data-testid="deploy-submit"]`. */
     anchor: string;
     label: string;
-    /** 1-based, matching the number drawn in the pin. */
     index: number;
-    /** file:line, when the app is source-stamped. */
     source?: string;
 }
 export interface AnnotatorDeps {
@@ -34,9 +24,7 @@ export declare class Annotator {
     get active(): boolean;
     get markCount(): number;
     mount(): void;
-    /** Drive marker/highlight chrome from the HUD accent swatch. */
     setAccent(hex: string): void;
-    /** @deprecated HUD expand/collapse owns annotate mode; chrome buttons are hide/clear. */
     attachFlagButton(btn: HTMLElement): void;
     attachChrome(chrome: AnnotatorChrome): void;
     destroy(): void;
@@ -45,3 +33,4 @@ export declare class Annotator {
     syncAnchors(): void;
 }
 export declare function installAnnotator(deps: AnnotatorDeps): Annotator;
+export {};

package/dist/review/annotator.js

@@ -1,10 +1,9 @@
-import { isSyntheticInput } from '../actions/synthetic-input.js';
+import { isSyntheticInput } from '../actions/synthetic/synthetic-input.js';
 import { EventType } from '@reticlehq/core';
 import { isReticleUi, isReticleOverlay } from '../dom/dom-ignore.js';
 import { resolveMarkAnchor } from './mark-anchor.js';
-import { nativeSetTimeout, nativeClearTimeout } from '../timers/native-timers.js';
+import { nativeSetTimeout, nativeClearTimeout } from '../timers/native/native-timers.js';
 import { ANNOTATOR_CSS, ANNOTATOR_ROOT_HTML, MARK_CANCEL, MARK_PENDING_GLYPH, MARK_PLACEHOLDER, MARK_SUBMIT, } from './annotator-styles.js';
-/** The cursor must rest this long before the outline boxes the element under it - calm, not jumpy. */
 const HIGHLIGHT_REST_MS = 130;
 const SHAKE_MS = 250;
 const POP_W = 280;
@@ -85,12 +84,10 @@ export class Annotator {
         if (undefined !== this.#accent)
             this.setAccent(this.#accent);
     }
-    /** Drive marker/highlight chrome from the HUD accent swatch. */
     setAccent(hex) {
         this.#accent = hex;
         this.#root?.style.setProperty('--reticle-mark-accent', hex);
     }
-    /** @deprecated HUD expand/collapse owns annotate mode; chrome buttons are hide/clear. */
     attachFlagButton(btn) {
         this.attachChrome({ markersBtn: btn });
     }
@@ -211,18 +208,11 @@ export class Annotator {
     #handleClick(ev) {
         if (!this.#active)
             return;
-        // A click Reticle dispatched is the agent driving the app, not a person placing a mark. Without
-        // this, expanding the HUD silently disabled every `reticle_act` click while the action still
-        // reported success — a false green in our own UI. See synthetic-input.ts.
         if (isSyntheticInput())
             return;
         const raw = ev.target;
         if (!(raw instanceof Element))
             return;
-        // The page blocker is a full-viewport shield Reticle puts up WHILE annotating, so with it on
-        // every click lands on Reticle's own UI and was discarded as such — annotate mode looked
-        // completely dead, because the one thing standing between the user and the page is the thing
-        // annotate mode turns on. Resolve what is underneath instead of giving up on the click.
         const target = raw.hasAttribute(BLOCKER_ATTR_NAME)
             ? pageElementAt(ev.clientX, ev.clientY)
             : raw;
@@ -274,9 +264,6 @@ export class Annotator {
         if (this.#hi === undefined)
             return;
         const raw = ev.target;
-        // Same shield as in #handleClick: while annotating, a full-viewport blocker sits over the page,
-        // so EVERY mousemove reports it as the target. Resolving only there left the outline suppressed
-        // on every element - a crosshair with no indication of what it was on. See #handleClick.
         const target = raw instanceof Element && raw.hasAttribute(BLOCKER_ATTR_NAME)
             ? pageElementAt(ev.clientX, ev.clientY)
             : raw;
@@ -315,22 +302,11 @@ export class Annotator {
         this.#pendingKey = mark.anchor;
         this.#pendingTarget = mark.target;
         this.#hideHighlight();
-        // Where the element is NOW, not where it was when the mark was made. The popover is
-        // position:fixed, so it is placed in viewport coordinates, and the stored clientX/clientY are
-        // viewport coordinates from an earlier scroll position. Reopening a mark after scrolling put the
-        // note somewhere unrelated to the thing it annotates — further away the further you had scrolled.
         const at = this.#currentPoint(mark);
         this.#mountPopover(mark.label, at.x, at.y, mark.note);
         this.#dropPending(at.x, at.y);
         this.#paintSelection();
     }
-    /**
-     * The viewport point a mark's popover should open at.
-     *
-     * Prefers the element's live box, because that is what the note is ABOUT. Falls back to the stored
-     * coordinates only when the element is gone, where there is nothing better and the mark is already
-     * shown as stale.
-     */
     #currentPoint(mark) {
         const el = mark.target;
         if (el !== undefined && el.isConnected) {
@@ -471,7 +447,6 @@ export class Annotator {
         this.#dropPin(resolved, note, x, y);
         this.#report(note, resolved.anchor, resolved.label, this.#marks.length, sourceLabel(resolved));
     }
-    /** Hand the HUD everything it needs to name this mark in one row. */
     #report(note, anchor, label, index, source) {
         const mark = { note, anchor, label, index };
         if (source !== undefined)
@@ -560,12 +535,6 @@ export class Annotator {
         this.#repositionPopover();
         this.#paintSelection();
     }
-    /**
-     * Keep an OPEN popover attached to its element while the page scrolls.
-     *
-     * The pins were repositioned here and the popover was not, so scrolling with a note open slid the
-     * note off its target and left it floating over unrelated content.
-     */
     #repositionPopover() {
         const pop = this.#pop;
         const mark = this.#editing;
@@ -589,7 +558,6 @@ export class Annotator {
             this.#selBox.hidden = true;
     }
 }
-/** "file:line" for a resolved anchor, when the app carries source stamps. */
 function sourceLabel(resolved) {
     return resolved.source === undefined
         ? undefined
@@ -607,15 +575,7 @@ function isElementFixed(el) {
     const pos = getComputedStyle(el).position;
     return 'fixed' === pos || 'sticky' === pos;
 }
-/** The blocker Reticle raises over the page while annotating; see the click handler. */
 const BLOCKER_ATTR_NAME = 'data-reticle-blocker';
-/**
- * The topmost element of the HOST PAGE at a point, seeing past Reticle's own overlays.
- *
- * `elementsFromPoint` returns the whole stack topmost-first, so the page element is simply the first
- * entry that is not ours. Returns undefined where the API is unavailable (jsdom) or nothing but
- * Reticle UI is there, and the caller drops the click rather than guessing at a target.
- */
 function pageElementAt(x, y) {
     const from = document.elementsFromPoint.bind(document);
     if (from === undefined)

package/dist/review/mark-anchor.d.ts

@@ -1,10 +1,4 @@
 import { MarkAnchorStrategy } from '@reticlehq/core';
-/**
- * The element address carried by a human review mark: a re-resolvable anchor (auto-anchor's most
- * durable tier for this element), its durability strategy, a human-legible label, and — crucially —
- * the source file:line the agent should open. Source is reported INDEPENDENTLY of the anchor tier:
- * a role-anchored element still carries its babel-stamped source so the agent can jump to the code.
- */
 export interface MarkAnchor {
     anchor: string;
     strategy: MarkAnchorStrategy;
@@ -14,9 +8,4 @@ export interface MarkAnchor {
         line: number;
     };
 }
-/**
- * Resolve a clicked element into the address a human review mark carries. Reuses the same
- * auto-anchor machinery a recorded flow uses, so a mark pins to the element the way Reticle addresses
- * it everywhere else — and always reports the source file:line when one is available.
- */
 export declare function resolveMarkAnchor(el: Element): MarkAnchor;

package/dist/review/mark-anchor.js

@@ -1,28 +1,20 @@
 import { MarkAnchorStrategy } from '@reticlehq/core';
-import { AnchorStrategy, synthesizeAnchor } from '../dom/auto-anchor.js';
+import { AnchorStrategy, synthesizeAnchor, } from '../dom/addressing/auto-anchor.js';
 import { getAccessibleName, getRole } from '../dom/a11y.js';
-import { identifyComponent } from '../registry/adapters.js';
-import { sourceFor } from '../dom/source.js';
-/** Attribute names — defined locally per the recorder/query convention (no shared free string). */
+import { identifyComponent } from '../registry/stores/adapters.js';
+import { sourceFor } from '../dom/addressing/source.js';
 const TESTID_ATTR = 'data-testid';
-/** AnchorStrategy and MarkAnchorStrategy share string values; map explicitly (no cross-cast). */
 const STRATEGY = {
     [AnchorStrategy.TESTID]: MarkAnchorStrategy.TESTID,
     [AnchorStrategy.COMPONENT]: MarkAnchorStrategy.COMPONENT,
     [AnchorStrategy.ROLE]: MarkAnchorStrategy.ROLE,
     [AnchorStrategy.POSITION]: MarkAnchorStrategy.POSITION,
 };
-/** A short, human-legible label for the element: `role "name"`, falling back to role / tag name. */
 function labelFor(el, role, name) {
     if (name.length > 0)
         return role.length > 0 ? `${role} "${name}"` : `"${name}"`;
     return role.length > 0 ? role : el.tagName.toLowerCase();
 }
-/**
- * Resolve a clicked element into the address a human review mark carries. Reuses the same
- * auto-anchor machinery a recorded flow uses, so a mark pins to the element the way Reticle addresses
- * it everywhere else — and always reports the source file:line when one is available.
- */
 export function resolveMarkAnchor(el) {
     const testid = el.getAttribute(TESTID_ATTR) ?? undefined;
     const info = identifyComponent(el);

package/dist/security/serialization.d.ts

@@ -1,33 +1,13 @@
 import { isSensitiveKey, scrubKnownSecrets } from '@reticlehq/core';
-/**
- * What the transport caps removed from a value, if anything.
- *
- * Truncation used to be entirely silent: a 1,000-entity store came back as ~142 entities with no
- * marker and no count, and a caller comparing it against expected data would conclude the app had
- * lost the rest. A partial answer that cannot be distinguished from a complete one is the precise
- * shape of a false green — the failure this project exists to prevent — so the caps now report.
- */
 export interface TruncationReport {
-    /** Whole collection items not included, either past the item cap or past the node budget. */
     droppedItems: number;
-    /** Values replaced by the `[TRUNCATED]` placeholder because a cap was hit inside them. */
     truncatedValues: number;
-    /** Human-and-agent readable summary. Present so a consumer never has to compose one. */
     note: string;
 }
-/** Convert arbitrary app state into a bounded, redacted JSON-compatible value. */
 export declare function sanitizeForTransport(value: unknown): unknown;
-/**
- * As `sanitizeForTransport`, but also reports what the caps removed.
- *
- * Returned as a separate field rather than embedded in the value: the value has to keep the exact
- * shape the consumer's schema declares, so a marker spliced inside it would break validation on the
- * very payloads that are already under pressure.
- */
 export declare function sanitizeWithReport(value: unknown): {
     value: unknown;
     truncation?: TruncationReport;
 };
-/** Serialize without allowing cycles, BigInt, getters, or secrets to break the transport. */
 export declare function safeStringify(value: unknown): string;
 export { isSensitiveKey, scrubKnownSecrets };

package/dist/security/serialization.js

@@ -3,8 +3,6 @@ const TRUNCATED_VALUE = '[TRUNCATED]';
 const UNSERIALIZABLE_VALUE = '[UNSERIALIZABLE]';
 const OMIT_VALUE = Symbol('omit');
 const MAX_KEY_LENGTH = 256;
-// UTF-8 encodes at most ~3 bytes per JS (UTF-16) code unit, so /4 is a provably-safe bound that never
-// exceeds the byte budget — /8 was ~1/8 of the real 1MiB wire budget and truncated legitimate state.
 const MAX_TOTAL_CHARACTERS = Math.floor(TRANSPORT_LIMITS.MAX_MESSAGE_BYTES / 4);
 const MAX_TOTAL_NODES = TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS * 5;
 function boundedString(value, state, max) {
@@ -13,9 +11,6 @@ function boundedString(value, state, max) {
         state.remainingCharacters -= value.length;
         return value;
     }
-    // Count the cut. A silently shortened string is the same false green the collection caps were made
-    // to report: a caller comparing a 500k-char value against expected data sees 65k and concludes the
-    // app dropped the rest, with no marker saying WE did. The report interface exists for exactly this.
     state.truncatedValues += 1;
     const truncated = allowed <= TRUNCATED_VALUE.length
         ? TRUNCATED_VALUE.slice(0, allowed)
@@ -45,23 +40,13 @@ function sanitize(value, state, depth, key) {
     if ('undefined' === typeof value || 'function' === typeof value || 'symbol' === typeof value) {
         return OMIT_VALUE;
     }
-    // An invalid Date (`new Date(NaN)` / `new Date(undefined)`, easy to land in app state) throws
-    // RangeError on toISOString — and only safeStringify catches it, so a direct sanitize caller
-    // (readStoresWithTruncation, the state observer) crashed the WHOLE state read over one bad Date.
-    // Degrade to null, the same way a non-finite number does two branches up.
     if (value instanceof Date)
         return Number.isNaN(value.getTime()) ? null : value.toISOString();
-    // Map and Set are common enough in app state (a normalized store keyed by id, a set of selected
-    // ids) that serializing them to `{}` — which is what the plain-object branch below does, since they
-    // have no enumerable own keys — is a false green: an agent reads empty and concludes the state is
-    // empty, when really it was unrepresentable. Convert to a readable shape, bounded by the same caps.
     if (value instanceof Map) {
         const out = Object.create(null);
         let n = 0;
         for (const [k, v] of value) {
             if (state.nodes >= MAX_TOTAL_NODES || n >= TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS) {
-                // Budget spent — STOP. `continue` iterated a million-entry Map to the end just to count drops
-                // one at a time; size-n records the remainder in one shot (like the typed-array branch).
                 state.droppedItems += value.size - n;
                 break;
             }
@@ -78,7 +63,7 @@ function sanitize(value, state, depth, key) {
         let n = 0;
         for (const item of value) {
             if (state.nodes >= MAX_TOTAL_NODES || n >= TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS) {
-                state.droppedItems += value.size - n; // stop; record the remainder at once, don't walk the rest
+                state.droppedItems += value.size - n;
                 break;
             }
             const sv = sanitize(item, state, depth + 1);
@@ -87,10 +72,6 @@ function sanitize(value, state, depth, key) {
         }
         return out;
     }
-    // A typed array (Uint8Array, Float32Array, …) is array-like DATA, not a plain object. The
-    // plain-object branch below turned it into index-keyed keys ({"0":1,"1":2,…}) — a shape lie: an
-    // agent reading a tensor/binary field saw an object where an array lives, and a big one blew the key
-    // cap silently. Emit its numbers as a bounded array like a Set. DataView is opaque bytes — leave it.
     if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
         const len = value.length;
         const out = [];
@@ -117,35 +98,15 @@ function sanitize(value, state, depth, key) {
     state.seen.add(value);
     try {
         if (Array.isArray(value)) {
-            // Truncate by dropping whole ITEMS, never by corrupting them.
-            //
-            // The node budget used to run out mid-collection, so later items kept their shape while
-            // individual fields became the string "[TRUNCATED]" — an array field turned into a string, a
-            // boolean into a string. Consumers declare output schemas over these payloads, so that was not
-            // a degraded answer: validation rejected the whole message and the caller received NOTHING. On
-            // a page with thousands of matches that is a total loss of the query tool, in exactly the
-            // conditions where it matters most.
-            //
-            // Stopping BEFORE an item that will not fit keeps every survivor whole and type-correct. The
-            // collection's true size travels separately as a scalar (serialized first), so "how many" stays
-            // exact while the sample shrinks.
             const out = [];
             const considered = value.slice(0, TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS);
-            // Items beyond the collection cap are dropped before the loop even sees them; count them here
-            // so the report covers BOTH reasons a caller is holding a short list.
             state.droppedItems += Math.max(0, value.length - considered.length);
             for (const item of considered) {
                 if (state.nodes >= MAX_TOTAL_NODES) {
                     state.droppedItems += 1;
                     continue;
                 }
-                // Checking only BEFORE the item is not enough: one that starts under the budget can cross it
-                // partway through and come back with its tail replaced by placeholders. Serialize, then keep
-                // it only if it fitted — otherwise discard it and stop, so what ships is always whole.
                 const sanitized = sanitize(item, state, depth + 1);
-                // `>=`, not `>`: sanitize stops AT the ceiling rather than passing it, so the budget never
-                // reads as exceeded. Reaching it during this item means some field inside was replaced by a
-                // placeholder, which makes the item schema-invalid — drop it and stop.
                 if (state.nodes >= MAX_TOTAL_NODES) {
                     state.droppedItems += 1;
                     continue;
@@ -155,24 +116,9 @@ function sanitize(value, state, depth, key) {
             return out;
         }
         const out = Object.create(null);
-        // Scalars first, collections second. The node budget is spent in iteration order, so a large
-        // array sitting earlier in the object would consume the whole budget and turn the scalars after
-        // it into "[TRUNCATED]". Those scalars are the summary fields — a match `count`, a `total`, a
-        // status — and a summary that degrades to a placeholder while its own sample survives is the
-        // worst trade available: the caller keeps a partial list and loses the number that says the list
-        // is partial. Ordering by cost makes that impossible regardless of how a producer writes its
-        // object literal, so no caller has to know this rule to stay correct.
         const allKeys = Object.keys(value);
         const keys = allKeys.slice(0, TRANSPORT_LIMITS.MAX_OBJECT_KEYS);
-        // Keys past the cap are dropped — count them, like the array/Map/Set paths do, so a 5,000-key
-        // store reported as 200 keys carries a droppedItems marker instead of reading as complete.
         state.droppedItems += Math.max(0, allKeys.length - keys.length);
-        // Read each key's value ONCE, inside the guard. A property getter can throw — MobX strict mode,
-        // a Vue reactive trap read outside a reactive context, any hostile Proxy — and that throw must
-        // cost only its own key, not the whole object read. The earlier code dereferenced the getter in
-        // an unguarded `isScalar` (and again in the sanitize call: two invocations, doubling side
-        // effects), so one bad property lost the entire STATE_READ — the exact silent-loss shape the Date
-        // guard above was written to prevent. Snapshot first, then partition scalars-before-collections.
         const read = keys.map((key) => {
             try {
                 const v = value[key];
@@ -203,17 +149,9 @@ function sanitize(value, state, depth, key) {
         state.seen.delete(value);
     }
 }
-/** Convert arbitrary app state into a bounded, redacted JSON-compatible value. */
 export function sanitizeForTransport(value) {
     return sanitizeWithReport(value).value;
 }
-/**
- * As `sanitizeForTransport`, but also reports what the caps removed.
- *
- * Returned as a separate field rather than embedded in the value: the value has to keep the exact
- * shape the consumer's schema declares, so a marker spliced inside it would break validation on the
- * very payloads that are already under pressure.
- */
 export function sanitizeWithReport(value) {
     const state = {
         seen: new WeakSet(),
@@ -240,7 +178,6 @@ export function sanitizeWithReport(value) {
         },
     };
 }
-/** Serialize without allowing cycles, BigInt, getters, or secrets to break the transport. */
 export function safeStringify(value) {
     try {
         return JSON.stringify(sanitizeForTransport(value));
@@ -249,6 +186,4 @@ export function safeStringify(value) {
         return JSON.stringify(UNSERIALIZABLE_VALUE);
     }
 }
-// Re-exported: these moved to @reticlehq/core (they are wire rules, not DOM rules).
-// Kept on this module's surface so every existing importer inside the SDK is unaffected.
 export { isSensitiveKey, scrubKnownSecrets };

package/dist/session-continuity.d.ts

@@ -1,17 +1 @@
-/**
- * Keep a tab's session id across a reload.
- *
- * The id was minted fresh on every `connect()`. A reload is a new document, so the page came back as
- * a NEW session while the agent still held the old id — and every call after
- * `reticle_navigate { reload: true }` was refused with "no browser session connected". Reported on 6
- * of 6 apps; a reload is the most ordinary thing an agent does.
- *
- * `sessionStorage` is exactly the right scope: it survives reloads and same-tab navigations, and is
- * NOT shared with another tab of the same app — so two tabs stay two sessions, which is what the
- * multi-session tooling assumes.
- *
- * An explicit id still wins. `connect({ session })` and the `__reticle_session` URL param a lease
- * stamps are callers ASSERTING an identity, not asking for one; they are also remembered, so a
- * leased tab that reloads rejoins its own lease.
- */
 export declare function rememberSessionLabel(explicit: string | undefined, store: Storage | undefined, generate: () => string): string;

package/dist/session-continuity.js

@@ -1,20 +1,3 @@
-/**
- * Keep a tab's session id across a reload.
- *
- * The id was minted fresh on every `connect()`. A reload is a new document, so the page came back as
- * a NEW session while the agent still held the old id — and every call after
- * `reticle_navigate { reload: true }` was refused with "no browser session connected". Reported on 6
- * of 6 apps; a reload is the most ordinary thing an agent does.
- *
- * `sessionStorage` is exactly the right scope: it survives reloads and same-tab navigations, and is
- * NOT shared with another tab of the same app — so two tabs stay two sessions, which is what the
- * multi-session tooling assumes.
- *
- * An explicit id still wins. `connect({ session })` and the `__reticle_session` URL param a lease
- * stamps are callers ASSERTING an identity, not asking for one; they are also remembered, so a
- * leased tab that reloads rejoins its own lease.
- */
-/** Where the id lives. Namespaced like the URL param it mirrors. */
 const STORAGE_KEY = '__reticle_session';
 export function rememberSessionLabel(explicit, store, generate) {
     const read = () => {
@@ -23,7 +6,7 @@ export function rememberSessionLabel(explicit, store, generate) {
             return value !== null && value !== undefined && value.length > 0 ? value : undefined;
         }
         catch {
-            return undefined; // a sandboxed iframe throws on access; a session must still start
+            return undefined;
         }
     };
     const write = (value) => {
@@ -31,10 +14,8 @@ export function rememberSessionLabel(explicit, store, generate) {
             store?.setItem(STORAGE_KEY, value);
         }
         catch {
-            /* same: never block connect on storage */
         }
     };
-    // `explicit` may be '' — resolveSessionLabel yields that for "none given" — and `??` would take it.
     const asked = explicit !== undefined && explicit.length > 0 ? explicit : undefined;
     const chosen = asked ?? read() ?? generate();
     write(chosen);

package/dist/timers/clock.d.ts

@@ -1,18 +1,5 @@
+export declare const FREEZE_WATCHDOG_MS = 120000;
 export declare function isClockFrozen(): boolean;
 export declare function freezeClock(): void;
-/** Run all timers due within the next `ms` of virtual time, in order. */
 export declare function advanceClock(ms: number): void;
-/**
- * Restore the real timers AND hand back everything the app queued while frozen.
- *
- * The queue used to be discarded (`tasks = []`). Restoring the native functions is only half the job:
- * the callbacks the app scheduled during the freeze live in the virtual queue, and dropping them leaves
- * the app quietly broken in a new way — a toast that never dismisses, a retry that never fires, a
- * session-expiry check that never runs. `Date.now()` and future timers look healthy, so nothing points
- * at the cause. That matters most on the path this is called from: an agent freezes the clock, the
- * bridge dies, and the developer is left with an app that was never un-frozen deliberately.
- *
- * Pending work is re-scheduled onto REAL timers with its remaining virtual delay (a 5s toast frozen 2s
- * in still has ~3s to go), and the ids the app is holding keep working — see the translation note.
- */
 export declare function resetClock(): void;