@reticlehq/browser 2.4.0 → 2.5.0

package/dist/session-continuity.js

@@ -0,0 +1,42 @@
+/**
+ * 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 = () => {
+        try {
+            const value = store?.getItem(STORAGE_KEY);
+            return value !== null && value !== undefined && value.length > 0 ? value : undefined;
+        }
+        catch {
+            return undefined; // a sandboxed iframe throws on access; a session must still start
+        }
+    };
+    const write = (value) => {
+        try {
+            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);
+    return chosen;
+}

package/dist/timers/clock.js

@@ -12,7 +12,7 @@ export function isClockFrozen() {
     return installed;
 }
 export function freezeClock() {
-    if (installed || typeof window === 'undefined')
+    if (installed || 'undefined' === typeof window)
         return;
     installed = true;
     virtualNow = 0;
@@ -81,7 +81,7 @@ export function advanceClock(ms) {
  * in still has ~3s to go), and the ids the app is holding keep working — see the translation note.
  */
 export function resetClock() {
-    if (!installed || originals === null)
+    if (!installed || null === originals)
         return;
     const natives = originals;
     const pending = tasks;
@@ -95,7 +95,7 @@ export function resetClock() {
     tasks = [];
     installed = false;
     virtualNow = 0;
-    if (pending.length === 0)
+    if (0 === pending.length)
         return;
     // Re-arm the app's pending work onto REAL timers, translating ids as we go.
     //
@@ -112,7 +112,7 @@ export function resetClock() {
     const reArmed = new Map();
     const done = (virtualId) => {
         reArmed.delete(virtualId);
-        if (reArmed.size === 0)
+        if (0 === reArmed.size)
             restoreRawClears(natives);
     };
     for (const task of pending) {

package/dist/timers/native-console.js

@@ -3,7 +3,7 @@
 // MUST use this instead of bare `console.warn` — otherwise they emit spurious CONSOLE_WARN
 // events to the agent, polluting the observation stream with SDK internals.
 const g = globalThis;
-const realWarn = typeof g.console?.warn === 'function' ? g.console.warn.bind(g.console) : null;
+const realWarn = 'function' === typeof g.console?.warn ? g.console.warn.bind(g.console) : null;
 export const nativeWarn = (...args) => {
     realWarn?.(...args);
 };

package/dist/timers/native-timers.js

@@ -5,10 +5,10 @@
 // Important: we bind the reference now. Resolving `setTimeout` at call time would pick up the
 // patched (frozen) timer once reticle_clock freezes the clock — which would hang the SDK.
 const g = globalThis;
-const realSetTimeout = typeof g.setTimeout === 'function' ? g.setTimeout.bind(g) : null;
-const realClearTimeout = typeof g.clearTimeout === 'function' ? g.clearTimeout.bind(g) : null;
-const realRaf = typeof g.requestAnimationFrame === 'function' ? g.requestAnimationFrame.bind(g) : null;
-const realPerfNow = typeof g.performance?.now === 'function' ? g.performance.now.bind(g.performance) : null;
+const realSetTimeout = 'function' === typeof g.setTimeout ? g.setTimeout.bind(g) : null;
+const realClearTimeout = 'function' === typeof g.clearTimeout ? g.clearTimeout.bind(g) : null;
+const realRaf = 'function' === typeof g.requestAnimationFrame ? g.requestAnimationFrame.bind(g) : null;
+const realPerfNow = 'function' === typeof g.performance?.now ? g.performance.now.bind(g.performance) : null;
 /**
  * Monotonic "now" bound at load. clock.ts deliberately does NOT patch performance.now, so this
  * stays live even when the app clock (reticle_clock) is frozen — the presenter state machine relies

package/dist/transport/transport.js

@@ -4,10 +4,10 @@ import { nativeWarn } from '../timers/native-console.js';
 import { safeStringify } from '../security/serialization.js';
 /** Default visibility source: fire `handler` whenever the document returns to the foreground. */
 function subscribeDocumentVisible(handler) {
-    if (typeof document === 'undefined')
+    if ('undefined' === typeof document)
         return () => undefined;
     const listener = () => {
-        if (document.visibilityState === 'visible')
+        if ('visible' === document.visibilityState)
             handler();
     };
     document.addEventListener('visibilitychange', listener);
@@ -60,7 +60,7 @@ export class Transport {
         this.#now = deps.now ?? nativeNow;
     }
     connect() {
-        if (typeof WebSocket === 'undefined')
+        if ('undefined' === typeof WebSocket)
             return;
         this.#closed = false;
         this.#unsubscribeVisible ??= (this.#deps.onVisible ?? subscribeDocumentVisible)(() => this.#onVisible());
@@ -114,7 +114,7 @@ export class Transport {
         };
         ws.onmessage = (event) => {
             const data = event.data;
-            void this.#onMessage(typeof data === 'string' ? data : String(data));
+            void this.#onMessage('string' === typeof data ? data : String(data));
         };
         ws.onclose = (event) => {
             this.#ws = undefined;
@@ -189,7 +189,7 @@ export class Transport {
             // failure mode where the cause is knowable and was being thrown away. Reply if we can recover
             // an id; a message without one is not a command we can answer at all.
             const id = parsed?.id;
-            if (typeof id === 'string' && id.length > 0) {
+            if ('string' === typeof id && id.length > 0) {
                 this.#sendRaw(safeStringify({
                     kind: MessageKind.COMMAND_RESULT,
                     id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/browser",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Reticle browser SDK — installs observers, builds semantic snapshots, executes actions, talks to the bridge.",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,11 +9,12 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "dependencies": {
     "@testing-library/dom": "^10.4.1",
-    "@reticlehq/core": "2.4.0"
+    "@reticlehq/core": "2.5.0"
   },
   "devDependencies": {
     "@tanstack/query-core": "^5.101.4",
@@ -61,6 +62,7 @@
     "build": "tsc -b",
     "typecheck": "tsc -b",
     "lint": "eslint src",
-    "test:unit": "vitest run src --passWithNoTests"
+    "test:unit": "vitest run src --passWithNoTests",
+    "test:coverage": "vitest run src --passWithNoTests --coverage.enabled --coverage.provider=v8 --coverage.reporter=text-summary --coverage.include='src/**/*.ts' --coverage.exclude='src/**/*.test.ts'"
   }
 }