@reticlehq/browser 2.10.0 → 2.12.0

package/dist/dom/refs.js

@@ -19,6 +19,8 @@ import { TRANSPORT_LIMITS, asRef } from '@reticlehq/core';
 export const MAX_TRACKED_REFS = 10000;
 /** Marks a ref that was too long to echo in full. */
 const REF_ELISION = '…';
+/** Every ref Reticle mints is this letter followed by its sequence number. */
+const REF_PREFIX = 'e';
 /**
  * A ref, made safe to interpolate into an error message.
  *
@@ -105,6 +107,15 @@ export class RefRegistry {
     /** The end of the block currently reserved. Minting past it claims the next one. */
     #reserved = 0;
     #mintsSinceSweep = 0;
+    /**
+     * The highest number handed out before the last hot update was applied, or 0 while none has been.
+     *
+     * A watermark rather than a per-ref stamp: the sequence never restarts within a document, so one
+     * number separates "minted before the code changed" from "minted after it" for every ref at once.
+     * The alternative — an epoch on every map entry — is bookkeeping paid on every mint for an answer
+     * needed only on the rare refusal.
+     */
+    #editedAtSeq = 0;
     /**
      * Storage is injected rather than read from the global for the same reason the clock is: it is an
      * ambient dependency that decides behaviour, and the cross-document property is untestable if the
@@ -156,6 +167,24 @@ export class RefRegistry {
         while (this.#fromRef.size > MAX_TRACKED_REFS)
             this.#evictOldest();
     }
+    /**
+     * A hot update just replaced modules in this document: every ref handed out so far was minted
+     * against the DOM the previous version of that code produced.
+     *
+     * Only the boundary is recorded. Nothing is evicted — a hot update is not a navigation, and most
+     * of the page survives one, so refs minted before it very often still resolve. This exists so the
+     * ones that DON'T can say why.
+     */
+    markEdited() {
+        this.#editedAtSeq = this.#seq;
+    }
+    /** Was this ref handed out before the last hot update? False while no update has been observed. */
+    mintedBeforeLastEdit(ref) {
+        if (0 === this.#editedAtSeq || !ref.startsWith(REF_PREFIX))
+            return false;
+        const n = Number(ref.slice(REF_PREFIX.length));
+        return Number.isSafeInteger(n) && n > 0 && n <= this.#editedAtSeq;
+    }
     /** Get the existing ref for an element, or mint a new one. */
     refFor(el) {
         const existing = this.#toRef.get(el);
@@ -173,7 +202,7 @@ export class RefRegistry {
         if (this.#seq >= this.#reserved)
             this.#reserve();
         this.#seq += 1;
-        const ref = asRef(`e${String(this.#seq)}`);
+        const ref = asRef(`${REF_PREFIX}${String(this.#seq)}`);
         this.#toRef.set(el, ref);
         this.#fromRef.set(ref, new WeakRef(el));
         // Keep bounded cheaply on every mint; run the full dead-entry sweep only periodically.

package/dist/dom/snapshot.d.ts

@@ -21,13 +21,42 @@ export interface SnapshotResult {
      * must not receive the entire page as if it were the modal.
      */
     scopeMissing?: boolean;
+    /**
+     * Refs of the subtree roots the walk never entered, present ONLY when `truncated`. This is the
+     * cut's own frontier: re-snapshot each with `{ scope: ref, includeRoot: true }` and the union is
+     * the whole tree. Without it `truncated` says only THAT the read stopped, never WHERE, so nobody
+     * could finish it — and a reader who does not finish it must not conclude anything is ABSENT.
+     */
+    unread?: string[];
+    /**
+     * True when the frontier itself did not fit in `MAX_UNREAD_BRANCHES`, so `unread` is a prefix of
+     * the branches that were cut. Completion is then impossible from this read, and the difference
+     * between "impossible" and "not attempted" is the whole point of saying so.
+     */
+    unreadOverflow?: true;
 }
 interface SnapshotOptions {
     scope?: string | undefined;
     mode?: SnapshotMode | undefined;
     maxNodes?: number | undefined;
     maxDepth?: number | undefined;
+    /**
+     * Emit the scope element's OWN line before its descendants. Off by default (a scoped snapshot has
+     * always been the subtree UNDER the scope); the completion re-read needs it, because the branch it
+     * is re-reading is exactly the node the truncated walk stopped before emitting.
+     */
+    includeRoot?: boolean | undefined;
 }
+/**
+ * Cap on how many cut branches one snapshot names.
+ *
+ * A hostile or merely huge DOM can cut thousands of siblings at once (a non-virtualized grid does it
+ * routinely), and a frontier that large is neither affordable to send nor useful to re-read one at a
+ * time. Fifty is well above what a real page's cut produces — the frontier is the branches at the
+ * node cap, not the nodes themselves — and small enough that the list stays a hint rather than a
+ * second snapshot. Past it the read declares `unreadOverflow` instead of quietly sending fewer.
+ */
+export declare const MAX_UNREAD_BRANCHES = 50;
 /** Build the semantic accessibility snapshot of the page or a subtree. */
 export declare function buildSnapshot(options?: SnapshotOptions): SnapshotResult;
 export {};

package/dist/dom/snapshot.js

@@ -55,6 +55,16 @@ function directText(el) {
     const collapsed = out.replace(/\s+/g, ' ').trim();
     return collapsed.length > TEXT_MAX ? `${collapsed.slice(0, TEXT_MAX)}…` : collapsed;
 }
+/**
+ * Cap on how many cut branches one snapshot names.
+ *
+ * A hostile or merely huge DOM can cut thousands of siblings at once (a non-virtualized grid does it
+ * routinely), and a frontier that large is neither affordable to send nor useful to re-read one at a
+ * time. Fifty is well above what a real page's cut produces — the frontier is the branches at the
+ * node cap, not the nodes themselves — and small enough that the list stays a hint rather than a
+ * second snapshot. Past it the read declares `unreadOverflow` instead of quietly sending fewer.
+ */
+export const MAX_UNREAD_BRANCHES = 50;
 /** Cheap skips that need no computed style (tags, overlays, aria-hidden, [hidden]). */
 function skipEarly(el) {
     if (SKIP_TAGS.has(el.tagName.toLowerCase()))
@@ -105,6 +115,16 @@ function layoutSignature(style) {
     }
     return '';
 }
+/** Record a cut branch on the frontier, declaring an overflow rather than shortening it silently. */
+function recordUnread(branches, ctx) {
+    for (const branch of branches) {
+        if (ctx.unread.length >= MAX_UNREAD_BRANCHES) {
+            ctx.unreadOverflow = true;
+            return;
+        }
+        ctx.unread.push(refs.refFor(branch));
+    }
+}
 /**
  * The children to walk under `parent`, piercing boundaries a plain `.children` misses: an OPEN shadow
  * root renders as part of the element (web components / design systems), and a SAME-ORIGIN iframe's
@@ -134,46 +154,57 @@ function pierceChildren(parent) {
     }
     return out;
 }
+/** Emit one element (if it earns a line) and descend into it. Split out of `walk` so the completion
+ * re-read can start AT a branch root — the node the truncated walk stopped just before emitting. */
+function visit(child, depth, ctx, inLive) {
+    if (skipEarly(child))
+        return;
+    // Resolve computed style ONCE per node (the dominant snapshot cost) and thread it into both the
+    // display-none skip and the layout signature — was two forced style resolutions per node.
+    const view = child.ownerDocument.defaultView;
+    const style = view !== null ? view.getComputedStyle(child) : null;
+    if (style !== null && 'none' === style.display)
+        return;
+    const role = getRole(child);
+    const name = getAccessibleName(child);
+    const interactive = INTERACTIVE.has(role);
+    // Announcements are exempt from leanness, and so is everything inside one: a live region whose
+    // message sits in a child element would otherwise be included as a contentless `- generic`.
+    const announce = inLive || announces(child, role);
+    const lean = ctx.mode === SnapshotMode.INTERACTIVE && !announce;
+    // A generic, unnamed container's own text content — only consulted outside INTERACTIVE mode,
+    // so the actionable-only view stays lean while FULL/meaningful views see content regressions.
+    const text = !lean && 'generic' === role && 0 === name.length ? directText(child) : '';
+    // Layout signature for grid/flex containers — makes CLS/layout regressions visible.
+    const layout = lean ? '' : layoutSignature(style);
+    const meaningful = interactive || role !== 'generic' || name.length > 0 || text.length > 0 || layout.length > 0;
+    const include = lean ? interactive : meaningful;
+    if (include) {
+        ctx.nodes += 1;
+        ctx.lines.push(text.length > 0 && 0 === name.length && 0 === layout.length
+            ? formatTextLine(depth, text)
+            : formatLine(child, depth, role, name, layout));
+        walk(child, depth + 1, ctx, announce);
+    }
+    else {
+        walk(child, depth, ctx, announce);
+    }
+}
 function walk(parent, depth, ctx, inLive = false) {
     if (depth > ctx.maxDepth)
         return;
-    for (const child of pierceChildren(parent)) {
+    const children = pierceChildren(parent);
+    for (let index = 0; index < children.length; index += 1) {
         if (ctx.nodes >= ctx.maxNodes) {
             ctx.truncated = true;
+            // Everything from here on is unread, not absent. Naming the frontier is what makes the cut
+            // recoverable — see `unread` on SnapshotResult.
+            recordUnread(children.slice(index), ctx);
             return;
         }
-        if (skipEarly(child))
-            continue;
-        // Resolve computed style ONCE per node (the dominant snapshot cost) and thread it into both the
-        // display-none skip and the layout signature — was two forced style resolutions per node.
-        const view = child.ownerDocument.defaultView;
-        const style = view !== null ? view.getComputedStyle(child) : null;
-        if (style !== null && 'none' === style.display)
-            continue;
-        const role = getRole(child);
-        const name = getAccessibleName(child);
-        const interactive = INTERACTIVE.has(role);
-        // Announcements are exempt from leanness, and so is everything inside one: a live region whose
-        // message sits in a child element would otherwise be included as a contentless `- generic`.
-        const announce = inLive || announces(child, role);
-        const lean = ctx.mode === SnapshotMode.INTERACTIVE && !announce;
-        // A generic, unnamed container's own text content — only consulted outside INTERACTIVE mode,
-        // so the actionable-only view stays lean while FULL/meaningful views see content regressions.
-        const text = !lean && 'generic' === role && 0 === name.length ? directText(child) : '';
-        // Layout signature for grid/flex containers — makes CLS/layout regressions visible.
-        const layout = lean ? '' : layoutSignature(style);
-        const meaningful = interactive || role !== 'generic' || name.length > 0 || text.length > 0 || layout.length > 0;
-        const include = lean ? interactive : meaningful;
-        if (include) {
-            ctx.nodes += 1;
-            ctx.lines.push(text.length > 0 && 0 === name.length && 0 === layout.length
-                ? formatTextLine(depth, text)
-                : formatLine(child, depth, role, name, layout));
-            walk(child, depth + 1, ctx, announce);
-        }
-        else {
-            walk(child, depth, ctx, announce);
-        }
+        const child = children[index];
+        if (child !== undefined)
+            visit(child, depth, ctx, inLive);
     }
 }
 function collectDialogs(root) {
@@ -259,12 +290,19 @@ export function buildSnapshot(options = {}) {
         mode,
         maxNodes: options.maxNodes ?? 400,
         maxDepth: options.maxDepth ?? 20,
+        unread: [],
+        unreadOverflow: false,
     };
-    walk(root, 0, ctx);
+    if (true === options.includeRoot)
+        visit(root, 0, ctx, false);
+    else
+        walk(root, 0, ctx);
     return {
         tree: ctx.lines.join('\n'),
         status,
         nodes: ctx.nodes,
         truncated: ctx.truncated,
+        ...(ctx.unread.length > 0 ? { unread: ctx.unread } : {}),
+        ...(ctx.unreadOverflow ? { unreadOverflow: true } : {}),
     };
 }

package/dist/edit-epoch.d.ts

@@ -0,0 +1,32 @@
+import { type RefRegistry } from './dom/refs.js';
+export declare class EditEpoch {
+    #private;
+    /** The registry is injected for the same reason the clock is: the interesting property is the
+     *  RELATION between when a ref was minted and when an edit landed, and a global has no seam. */
+    constructor(registry: RefRegistry);
+    /**
+     * How many hot updates this document has applied.
+     *
+     * `NO_EDITS_OBSERVED` means exactly that and never "none happened": most pages Reticle instruments
+     * have no channel that could report one, so absence here is UNKNOWN.
+     */
+    get current(): number;
+    /** Subscribe to a hot-update channel if one was handed in. Anything else is silently ignored —
+     *  no channel is the normal case, not an error. */
+    observe(hot: unknown): void;
+    /** Record that an update was applied, naming the files it changed (which may be none). */
+    applied(files: readonly string[]): void;
+    /**
+     * The refusal for a ref that no longer resolves — saying WHY when the page can tell us.
+     *
+     * The generic wording is untouched and stays at the front: it is already tuned, and the server's
+     * recovery table matches on it. When the ref predates the last hot update the diagnosis is
+     * appended, because "you edited TripCard.tsx and it re-rendered" is a next step and "that ref is
+     * stale" is a dead end. A ref minted AFTER the last update gets the generic message unchanged —
+     * blaming an edit for an ordinary post-click stale ref would be a confident wrong answer, which is
+     * worse than the vague right one.
+     */
+    staleRefMessage(ref: string): string;
+}
+/** The epoch of the page, paired with the process-wide ref registry it has to reason against. */
+export declare const editEpoch: EditEpoch;

package/dist/edit-epoch.js

@@ -0,0 +1,108 @@
+import { NO_EDITS_OBSERVED } from '@reticlehq/core';
+import { echoRef, refs } from './dom/refs.js';
+/**
+ * What the page can tell us about its own source being edited underneath it.
+ *
+ * The agent driving Reticle edits source and re-verifies in a loop. When an edit lands, the dev
+ * server hot-updates the module and the framework re-renders: DOM nodes are REPLACED, every ref the
+ * agent holds points at a detached node — and there was no navigation, so the document is the same
+ * one and `documentId` never moves. The agent got a generic "that ref is stale" and could not tell
+ * its own edit landing from a bug in the app it was verifying.
+ *
+ * DELIBERATELY NOT A BUILD INTEGRATION. Nothing here watches files, reads the user's repo or knows
+ * what a module graph is. The page is told by its own dev server that it hot-updated; this records
+ * that it happened and what it named, and that is the whole feature.
+ */
+/**
+ * Vite's "the update has been applied" event, on a hot context.
+ *
+ * `vite:afterUpdate` rather than `vite:beforeUpdate`: the point of the epoch is that the DOM has
+ * been replaced, and before the update it has not been yet.
+ *
+ * The SDK does NOT depend on Vite — it ships to Next, Electron, Tauri and plain pages, and it cannot
+ * read `import.meta.hot` of its own module in any of them (a dependency is pre-bundled by Vite's
+ * optimizer and gets no hot context at all). The channel is handed IN by whoever has one, and this
+ * name is the only Vite-shaped thing in the SDK.
+ */
+const HOT_UPDATE_APPLIED = 'vite:afterUpdate';
+/** How many changed files a refusal names before it stops being a diagnosis and starts being a list. */
+const MAX_NAMED_FILES = 3;
+/** The exact substring the server's recovery table keys off. Changing it silently unclassifies. */
+const STALE_REF_REFUSAL = 'no longer resolves to an element';
+/** The clause that turns a dead end into a diagnosis, and the one the server's table matches on. */
+const CODE_CHANGED = 'the code changed underneath it';
+/** Anything object-shaped, as a bag of unknowns. The payload comes from the page, so nothing about
+ *  its shape is guaranteed and every field has to be checked before it is read. */
+function fields(value) {
+    return null !== value && 'object' === typeof value
+        ? value
+        : undefined;
+}
+function isHotLike(value) {
+    return 'function' === typeof fields(value)?.['on'];
+}
+/** The file paths a hot-update payload named, narrowed from `unknown`. */
+function updatedPaths(payload) {
+    const updates = fields(payload)?.['updates'];
+    if (!Array.isArray(updates))
+        return [];
+    const paths = [];
+    for (const update of updates) {
+        const path = fields(update)?.['path'];
+        if ('string' === typeof path && path.length > 0 && !paths.includes(path))
+            paths.push(path);
+    }
+    return paths;
+}
+export class EditEpoch {
+    #epoch = NO_EDITS_OBSERVED;
+    #files = [];
+    #refs;
+    /** The registry is injected for the same reason the clock is: the interesting property is the
+     *  RELATION between when a ref was minted and when an edit landed, and a global has no seam. */
+    constructor(registry) {
+        this.#refs = registry;
+    }
+    /**
+     * How many hot updates this document has applied.
+     *
+     * `NO_EDITS_OBSERVED` means exactly that and never "none happened": most pages Reticle instruments
+     * have no channel that could report one, so absence here is UNKNOWN.
+     */
+    get current() {
+        return this.#epoch;
+    }
+    /** Subscribe to a hot-update channel if one was handed in. Anything else is silently ignored —
+     *  no channel is the normal case, not an error. */
+    observe(hot) {
+        if (!isHotLike(hot))
+            return;
+        hot.on(HOT_UPDATE_APPLIED, (payload) => this.applied(updatedPaths(payload)));
+    }
+    /** Record that an update was applied, naming the files it changed (which may be none). */
+    applied(files) {
+        this.#epoch += 1;
+        this.#files = files.slice(0, MAX_NAMED_FILES);
+        this.#refs.markEdited();
+    }
+    /**
+     * The refusal for a ref that no longer resolves — saying WHY when the page can tell us.
+     *
+     * The generic wording is untouched and stays at the front: it is already tuned, and the server's
+     * recovery table matches on it. When the ref predates the last hot update the diagnosis is
+     * appended, because "you edited TripCard.tsx and it re-rendered" is a next step and "that ref is
+     * stale" is a dead end. A ref minted AFTER the last update gets the generic message unchanged —
+     * blaming an edit for an ordinary post-click stale ref would be a confident wrong answer, which is
+     * worse than the vague right one.
+     */
+    staleRefMessage(ref) {
+        const generic = `ref '${echoRef(ref)}' ${STALE_REF_REFUSAL}`;
+        if (!this.#refs.mintedBeforeLastEdit(ref))
+            return generic;
+        const named = 0 === this.#files.length ? 'the page hot-updated' : `${this.#files.join(', ')} hot-updated`;
+        return (`${generic} — ${named} after this ref was taken, so ${CODE_CHANGED} and the framework ` +
+            'replaced the node. Query again for a fresh ref: this is your own edit landing, not the app failing.');
+    }
+}
+/** The epoch of the page, paired with the process-wide ref registry it has to reason against. */
+export const editEpoch = new EditEpoch(refs);

package/dist/observers/context-open.d.ts

@@ -0,0 +1,12 @@
+import type { Emit, Teardown } from './types.js';
+/**
+ * The page asked for ANOTHER browsing context — `window.open` — so the consequence of whatever was
+ * just clicked may live where this document's SDK cannot follow. An OAuth sign-in is the archetype:
+ * the POST succeeds, the popup carries the whole flow, and the original tab legitimately never
+ * changes (#508). Without this event the contradiction layer reads that shape as response-ignored,
+ * accusing the client of ignoring a response it handed to a window nobody can see.
+ *
+ * The wrap preserves the call exactly: same arguments, same return value, and a null/undefined
+ * first argument (the "open a blank tab" form) still emits, since a blank tab can navigate anywhere.
+ */
+export declare function installContextOpen(emit: Emit): Teardown;

package/dist/observers/context-open.js

@@ -0,0 +1,25 @@
+import { EventType } from '@reticlehq/core';
+import { captureMethod } from '../patching/capture-method.js';
+/**
+ * The page asked for ANOTHER browsing context — `window.open` — so the consequence of whatever was
+ * just clicked may live where this document's SDK cannot follow. An OAuth sign-in is the archetype:
+ * the POST succeeds, the popup carries the whole flow, and the original tab legitimately never
+ * changes (#508). Without this event the contradiction layer reads that shape as response-ignored,
+ * accusing the client of ignoring a response it handed to a window nobody can see.
+ *
+ * The wrap preserves the call exactly: same arguments, same return value, and a null/undefined
+ * first argument (the "open a blank tab" form) still emits, since a blank tab can navigate anywhere.
+ */
+export function installContextOpen(emit) {
+    const originalOpen = captureMethod(window, 'open');
+    if (originalOpen === undefined)
+        return () => { };
+    const openPatch = function (href, target, features) {
+        emit(EventType.CONTEXT_OPENED, { ...(href === undefined ? {} : { href }) });
+        return originalOpen.call(this, href, target, features);
+    };
+    window.open = openPatch;
+    return () => {
+        window.open = originalOpen;
+    };
+}

package/dist/observers/install-all.js

@@ -17,6 +17,7 @@ import { installStoreState } from './state.js';
 import { installFocus } from './focus.js';
 import { installBlindSpots } from './blind-spots.js';
 import { installDownload } from './download.js';
+import { installContextOpen } from './context-open.js';
 import { installNetwork } from './network.js';
 import { installIpc, ipcNetOverrides, isReticleOwnIpc } from './ipc.js';
 import { installPerf } from './perf.js';
@@ -62,5 +63,6 @@ export function installAllObservers(emit, options) {
         guard(emit, SdkSite.NETWORK_OBSERVER, () => installDownload(emit, { capturePreview: options.captureBodies })),
         guard(emit, SdkSite.DOM_OBSERVER, () => installBlindSpots(emit)), // cross-origin iframes the SDK can't see → BLIND_SPOT (coverage: partial)
         guard(emit, SdkSite.HEALTH_OBSERVER, () => installHealth(emit)), // page visibility/focus health + heartbeat
+        guard(emit, SdkSite.DOM_OBSERVER, () => installContextOpen(emit)), // window.open → CONTEXT_OPENED (the consequence may live in another context)
     ];
 }

package/dist/observers/network.js

@@ -256,6 +256,7 @@ export function installNetwork(emit, opts = {}) {
             const contentType = res.headers.get('content-type');
             // The request is done; the BODY may not be. Watch it so settle cannot pass mid-stream.
             watchStreamedBody(emit, res, id, url, contentType, res.headers.get('content-length'));
+            reportedNetUrls.add(rawUrl);
             const emitRequest = (responseBodyFields) => {
                 emit(EventType.NET_REQUEST, {
                     id,
@@ -385,6 +386,7 @@ export function installNetwork(emit, opts = {}) {
                     const cur = meta.get(this);
                     if (cur === undefined)
                         return;
+                    reportedNetUrls.add(cur.rawUrl);
                     const xhrContentType = this.getResponseHeader('content-type');
                     let responseBodyFields = {};
                     // responseText throws unless responseType is '' or 'text' — guard before reading.
@@ -523,7 +525,64 @@ export function installNetwork(emit, opts = {}) {
         };
         navProto.sendBeacon = patchedBeacon;
     }
+    // Document-initiated subresources (link/css/img/script/manifest): fetch and XHR patches never see
+    // these, so a `{net}` predicate over a favicon or manifest used to read `assertion_failed` — "your
+    // change is broken" — when the truthful answer is "not observable". A PerformanceObserver over
+    // `resource` entries reports them with no CDP. Status is the known gap: entries carry one only on
+    // newer Chromium, so the field is emitted ONLY when readable and the evaluation seam downgrades
+    // status assertions it cannot verify instead of guessing.
+    //
+    // Dedup: any URL the patched transports already reported (or later report) is skipped — resource
+    // timing also records fetch/XHR loads. The seen-set is filled eagerly here AND at every
+    // NET_REQUEST emit below, so both orders of arrival stay single-reported.
+    const reportedNetUrls = new Set();
+    let subresourceEvents = 0;
+    const SUBRESOURCE_CAP = 200;
+    let subresourceObserver;
+    if (typeof PerformanceObserver !== 'undefined') {
+        try {
+            const observer = new PerformanceObserver((list) => {
+                for (const raw of list.getEntries()) {
+                    const entry = raw;
+                    if (subresourceEvents >= SUBRESOURCE_CAP)
+                        return;
+                    const type = entry.initiatorType || 'other';
+                    // Patched transports own their records; only document-initiated types are new here.
+                    if ('fetch' === type || 'xmlhttprequest' === type)
+                        continue;
+                    const rawUrl = entry.name;
+                    if (reportedNetUrls.has(rawUrl))
+                        continue;
+                    reportedNetUrls.add(rawUrl);
+                    subresourceEvents += 1;
+                    emit(EventType.NET_REQUEST, {
+                        id: nextId(),
+                        method: 'GET',
+                        url: redactUrl(rawUrl),
+                        durationMs: Math.round(entry.duration),
+                        initiator: type,
+                        ...(entry.transferSize > 0 ? { transferSize: entry.transferSize } : {}),
+                        // responseStatus is Chromium-only; omitted entirely when unreadable so the wire never
+                        // carries a guessed status. Its absence is what the server-side seam reads as unknown.
+                        ...((entry.responseStatus ?? 0) > 0
+                            ? {
+                                status: entry.responseStatus,
+                                ok: (entry.responseStatus ?? 0) >= 200 && (entry.responseStatus ?? 0) < 400,
+                            }
+                            : {}),
+                    });
+                }
+            });
+            subresourceObserver = observer;
+            observer.observe({ type: 'resource', buffered: true });
+            // Disconnected in the disposer below.
+        }
+        catch {
+            // No observer support: document-initiated loads stay unobserved, stated rather than guessed.
+        }
+    }
     return () => {
+        subresourceObserver?.disconnect();
         // Restore each slot ONLY if it still holds OUR wrapper. Between connect() and disconnect() the app
         // (or Sentry/analytics/a router) may have wrapped fetch/XHR/EventSource/WebSocket/sendBeacon ON TOP
         // of ours; blindly writing the original back would silently uninstall their instrumentation — the

package/dist/observers/storage.js

@@ -65,7 +65,7 @@ export function readStorage(area) {
         return readArea(safeArea(() => window.localStorage));
     if (area === StorageArea.SESSION)
         return readArea(safeArea(() => window.sessionStorage));
-    if ('cookies' === area)
+    if (StorageArea.COOKIE === area)
         return readCookies();
     return {
         local: readArea(safeArea(() => window.localStorage)),

package/dist/presenter/presenter-brand.d.ts

@@ -9,28 +9,14 @@
  */
 /**
  * Brand marks, inlined. The SDK is bundled into someone else's page: it cannot read
- * `assets/logo/*.svg` from disk at runtime and must never fetch from our own domain, so the two
- * artwork files live here as strings (same precedent as SEND_ICON in presenter-controls.ts).
- * Both are minified - editor metadata, clip paths, masks and sub-0.01 precision stripped - and paint
+ * `assets/logo/*.svg` from disk at runtime and must never fetch from our own domain, so the mark
+ * lives here as a string (same precedent as SEND_ICON in presenter-controls.ts).
+ * Minified - editor metadata, clip paths, masks and sub-0.01 precision stripped - and painted
  * with `currentColor` so the mark tracks --reticle-fg instead of hardcoding the export's #FAFAFA.
  */
-/** Accessible name of the HUD - the wordmark is artwork, this is what a screen reader reads. */
+/** Accessible name of the HUD. */
 export declare const BRAND_NAME = "Reticle";
 /** Mark alone (shown in the FAB and compact toolbar). */
 export declare const MARK_SVG: string;
-/** FAB-sized mark for the collapsed circular control. */
-export declare const FAB_MARK_SVG: string;
-/** Mark + "reticle" lettering (legacy wordmark artwork). */
-export declare const WORDMARK_SVG: string;
-/** Compact text label beside the mark in the expanded toolbar. */
-export declare const BRAND_MINI_CLASS = "reticle-brand-mini";
-/** Toolbar brand: mark + Reticle word (always shown together when expanded). */
-export declare const TOOLBAR_BRAND_HTML: string;
-/**
- * Header brand block. Both marks are always in the DOM and CSS picks one off the collapsed
- * attribute, so there is no JS state to keep in sync. The artwork is decorative (aria-hidden);
- * the visually-hidden name is what keeps the HUD identifiable to a screen reader in BOTH states.
- */
-export declare const BRAND_HTML: string;
 /** Collapsed FAB control - Reticle mark only. */
 export declare const FAB_TOGGLE_HTML: string;

package/dist/presenter/presenter-brand.js

@@ -9,30 +9,18 @@
  */
 /**
  * Brand marks, inlined. The SDK is bundled into someone else's page: it cannot read
- * `assets/logo/*.svg` from disk at runtime and must never fetch from our own domain, so the two
- * artwork files live here as strings (same precedent as SEND_ICON in presenter-controls.ts).
- * Both are minified - editor metadata, clip paths, masks and sub-0.01 precision stripped - and paint
+ * `assets/logo/*.svg` from disk at runtime and must never fetch from our own domain, so the mark
+ * lives here as a string (same precedent as SEND_ICON in presenter-controls.ts).
+ * Minified - editor metadata, clip paths, masks and sub-0.01 precision stripped - and painted
  * with `currentColor` so the mark tracks --reticle-fg instead of hardcoding the export's #FAFAFA.
  */
-/** Accessible name of the HUD - the wordmark is artwork, this is what a screen reader reads. */
+/** Accessible name of the HUD. */
 export const BRAND_NAME = 'Reticle';
-/** The two glyph paths of the mark, shared by both marks - the wordmark just offsets them by (1,1). */
+/** The two glyph paths of the mark. */
 const MARK_PATHS = `<path d="M92.82 92.16C93.07 93.4 91.77 94.4 90.63 93.83C89.62 93.33 88.62 92.82 87.63 92.3C71.14 83.78 54.79 72.27 39.61 57.96C39.09 57.49 38.57 56.98 38.06 56.49C22.45 41.52 9.78 25.14 .33 8.52C0.29 8.45 .25 8.38 .2 8.31C-0.44 7.2 .51 5.84 1.79 6.05L24.07 9.71C43.06 12.83 60.63 11.75 75.55 6.53L93.95 .09C95.15-0.33 96.31 .78 95.93 1.98L90.1 20.49C85.37 35.48 84.9 52.97 88.69 71.73L92.83 92.16H92.82Z"/><path d="M58.72 89.23L6.15 92.8C5.24 92.86 4.48 92.13 4.51 91.22L6.56 30.39C6.61 28.91 8.51 28.36 9.35 29.57C16.23 39.43 24.98 52.35 33.01 61.26C41.05 70.17 50.6 78.72 59.62 86.56C60.65 87.45 60.08 89.13 58.72 89.23Z"/>`;
 /** Mark alone (shown in the FAB and compact toolbar). */
 export const MARK_SVG = `<svg class="reticle-mark" viewBox="0 0 96 94" fill="currentColor" aria-hidden="true">${MARK_PATHS}</svg>`;
 /** FAB-sized mark for the collapsed circular control. */
-export const FAB_MARK_SVG = `<svg class="reticle-fab-mark" viewBox="0 0 96 94" fill="currentColor" aria-hidden="true">${MARK_PATHS}</svg>`;
-/** Mark + "reticle" lettering (legacy wordmark artwork). */
-export const WORDMARK_SVG = `<svg class="reticle-wordmark" viewBox="0 0 347 96" fill="currentColor" aria-hidden="true"><g transform="translate(1 1)">${MARK_PATHS}</g><path d="M116.43 78V27.09H136.51C140.35 27.09 143.64 27.78 146.35 29.15C149.09 30.51 151.17 32.44 152.59 34.95C154.04 37.43 154.76 40.36 154.76 43.72C154.76 47.1 154.03 50.01 152.57 52.45C151.11 54.87 149 56.72 146.23 58.01C143.48 59.31 140.15 59.95 136.24 59.95H122.79V51.3H134.5C136.55 51.3 138.26 51.02 139.62 50.46C140.98 49.89 141.99 49.05 142.65 47.92C143.33 46.8 143.67 45.39 143.67 43.72C143.67 42.03 143.33 40.61 142.65 39.45C141.99 38.29 140.97 37.41 139.59 36.81C138.23 36.2 136.52 35.89 134.45 35.89H127.19V78H116.43ZM143.92 54.83L156.57 78H144.69L132.31 54.83H143.92ZM178.95 78.75C175.02 78.75 171.64 77.95 168.81 76.36C165.99 74.75 163.82 72.48 162.29 69.55C160.77 66.6 160.01 63.11 160.01 59.08C160.01 55.16 160.77 51.71 162.29 48.74C163.82 45.78 165.97 43.46 168.73 41.81C171.52 40.15 174.78 39.32 178.53 39.32C181.05 39.32 183.39 39.73 185.56 40.54C187.75 41.33 189.65 42.54 191.28 44.14C192.92 45.75 194.2 47.77 195.11 50.21C196.02 52.63 196.47 55.46 196.47 58.71V61.62H164.23V55.06H186.51C186.51 53.53 186.17 52.18 185.51 51C184.85 49.83 183.93 48.91 182.75 48.25C181.59 47.57 180.24 47.23 178.7 47.23C177.09 47.23 175.67 47.6 174.43 48.34C173.2 49.07 172.24 50.06 171.54 51.3C170.85 52.53 170.49 53.9 170.47 55.4V61.64C170.47 63.53 170.82 65.17 171.52 66.54C172.23 67.92 173.23 68.98 174.52 69.72C175.82 70.47 177.35 70.84 179.12 70.84C180.3 70.84 181.38 70.68 182.35 70.34C183.33 70.01 184.17 69.52 184.87 68.85C185.56 68.19 186.09 67.38 186.46 66.42L196.25 67.06C195.75 69.42 194.73 71.47 193.19 73.23C191.67 74.97 189.7 76.33 187.28 77.3C184.87 78.27 182.1 78.75 178.95 78.75ZM223.69 39.82V47.77H200.7V39.82H223.69ZM205.92 30.67H216.51V66.27C216.51 67.24 216.66 68.01 216.96 68.55C217.26 69.08 217.67 69.46 218.2 69.67C218.75 69.89 219.38 70 220.09 70C220.59 70 221.08 69.95 221.58 69.87C222.08 69.77 222.46 69.7 222.72 69.65L224.39 77.53C223.86 77.69 223.11 77.88 222.15 78.1C221.19 78.33 220.02 78.47 218.65 78.52C216.1 78.62 213.86 78.28 211.94 77.5C210.03 76.72 208.55 75.51 207.49 73.87C206.43 72.23 205.9 70.16 205.92 67.66V30.67ZM230.59 78V39.82H241.18V78H230.59ZM235.91 34.9C234.34 34.9 232.99 34.37 231.86 33.33C230.75 32.27 230.19 31 230.19 29.53C230.19 28.07 230.75 26.82 231.86 25.77C232.99 24.71 234.34 24.18 235.91 24.18C237.49 24.18 238.83 24.71 239.94 25.77C241.07 26.82 241.63 28.07 241.63 29.53C241.63 31 241.07 32.27 239.94 33.33C238.83 34.37 237.49 34.9 235.91 34.9ZM266.92 78.75C263 78.75 259.64 77.92 256.82 76.26C254.02 74.59 251.87 72.27 250.36 69.3C248.87 66.33 248.12 62.92 248.12 59.06C248.12 55.15 248.88 51.72 250.38 48.77C251.91 45.8 254.07 43.49 256.87 41.83C259.67 40.16 263 39.32 266.87 39.32C270.2 39.32 273.11 39.93 275.62 41.14C278.12 42.35 280.1 44.04 281.56 46.23C283.01 48.42 283.82 50.99 283.97 53.94H273.97C273.69 52.03 272.95 50.5 271.74 49.34C270.54 48.16 268.98 47.57 267.04 47.57C265.4 47.57 263.96 48.02 262.74 48.92C261.53 49.79 260.58 51.08 259.9 52.77C259.23 54.46 258.89 56.51 258.89 58.91C258.89 61.35 259.22 63.42 259.88 65.12C260.56 66.83 261.51 68.13 262.74 69.03C263.96 69.92 265.4 70.37 267.04 70.37C268.25 70.37 269.33 70.12 270.3 69.62C271.27 69.13 272.08 68.4 272.71 67.46C273.35 66.5 273.78 65.35 273.97 64.01H283.97C283.8 66.92 283.01 69.49 281.58 71.71C280.17 73.92 278.23 75.64 275.74 76.88C273.25 78.12 270.31 78.75 266.92 78.75ZM301.34 27.09V78H290.75V27.09H301.34ZM327.22 78.75C323.29 78.75 319.91 77.95 317.08 76.36C314.26 74.75 312.09 72.48 310.57 69.55C309.04 66.6 308.28 63.11 308.28 59.08C308.28 55.16 309.04 51.71 310.57 48.74C312.09 45.78 314.24 43.46 317 41.81C319.79 40.15 323.05 39.32 326.8 39.32C329.32 39.32 331.66 39.73 333.83 40.54C336.02 41.33 337.93 42.54 339.55 44.14C341.19 45.75 342.47 47.77 343.38 50.21C344.29 52.63 344.75 55.46 344.75 58.71V61.62H312.5V55.06H334.78C334.78 53.53 334.45 52.18 333.78 51C333.12 49.83 332.2 48.91 331.02 48.25C329.86 47.57 328.51 47.23 326.97 47.23C325.36 47.23 323.94 47.6 322.7 48.34C321.47 49.07 320.51 50.06 319.81 51.3C319.12 52.53 318.76 53.9 318.74 55.4V61.64C318.74 63.53 319.09 65.17 319.79 66.54C320.5 67.92 321.5 68.98 322.8 69.72C324.09 70.47 325.62 70.84 327.39 70.84C328.57 70.84 329.65 70.68 330.63 70.34C331.6 70.01 332.44 69.52 333.14 68.85C333.83 68.19 334.36 67.38 334.73 66.42L344.52 67.06C344.02 69.42 343.01 71.47 341.46 73.23C339.94 74.97 337.97 76.33 335.55 77.3C333.15 78.27 330.37 78.75 327.22 78.75Z"/></svg>`;
-/** Compact text label beside the mark in the expanded toolbar. */
-export const BRAND_MINI_CLASS = 'reticle-brand-mini';
-/** Toolbar brand: mark + Reticle word (always shown together when expanded). */
-export const TOOLBAR_BRAND_HTML = `<span class="reticle-brand reticle-brand--toolbar">${MARK_SVG}<span class="${BRAND_MINI_CLASS}">${BRAND_NAME}</span><span class="reticle-brand-sr">${BRAND_NAME}</span></span>`;
-/**
- * Header brand block. Both marks are always in the DOM and CSS picks one off the collapsed
- * attribute, so there is no JS state to keep in sync. The artwork is decorative (aria-hidden);
- * the visually-hidden name is what keeps the HUD identifiable to a screen reader in BOTH states.
- */
-export const BRAND_HTML = `<span class="reticle-brand">${MARK_SVG}${WORDMARK_SVG}<span class="${BRAND_MINI_CLASS}">${BRAND_NAME}</span><span class="reticle-brand-sr">${BRAND_NAME}</span></span>`;
+const FAB_MARK_SVG = `<svg class="reticle-fab-mark" viewBox="0 0 96 94" fill="currentColor" aria-hidden="true">${MARK_PATHS}</svg>`;
 /** Collapsed FAB control - Reticle mark only. */
 export const FAB_TOGGLE_HTML = `<button type="button" class="reticle-fab" data-reticle-fab aria-label="Start ${BRAND_NAME}" aria-expanded="false">${FAB_MARK_SVG}<span class="reticle-fab-pulse" aria-hidden="true"></span><span data-reticle-mark-count class="reticle-fab-badge" hidden>0</span></button>`;

package/dist/presenter/presenter-config.d.ts

@@ -126,10 +126,6 @@ export declare const Placement: {
     readonly ABOVE: "above";
     readonly BELOW: "below";
 };
-export declare const DockAlign: {
-    readonly START: "start";
-    readonly END: "end";
-};
 /** Show/hide annotation markers. */
 export declare const MARKERS_BTN_ATTR = "data-reticle-markers-btn";
 /** Clear every annotation on the page. */
@@ -177,8 +173,6 @@ export declare const LOG_TIMESTAMPS_ATTR = "data-reticle-log-ts";
 /** When 1, the chat panel uses a narrower width. */
 /** When 1, HUD motion is reduced for accessibility. */
 export declare const REDUCE_MOTION_ATTR = "data-reticle-reduce-motion";
-/** Presenter settings card version label (browser package). */
-export declare const PRESENTER_UI_VERSION = "2.7.0";
 /** Docs opened from the settings footer. */
 export declare const MCP_DOCS_URL = "https://github.com/reticlehq/reticle/blob/main/docs/getting-started.md";
 /** HUD has been dragged off the default dock - positioned with explicit left/top. */