stitchkit 0.99.0 → 0.100.1

package/dist/entrypoints/files.js

@@ -1,6 +1,7 @@
 import {
   attemptExclusiveLock
-} from "../index-8p52kd5p.js";
+} from "../index-c6bxbsnc.js";
+import"../index-zjjyynm3.js";
 import {
   ManagedFileError,
   createManagedFileBoundary
@@ -46,6 +47,12 @@ function describeHolder(holder) {
   const machine = holder.machine === undefined ? "" : `, machine ${holder.machine}`;
   return `pid ${holder.pid} on ${holder.host}${machine} since ${holder.acquiredAt}`;
 }
+function describeEvidence(diagnosis) {
+  if (!diagnosis)
+    return "";
+  const identity = diagnosis.identity === undefined ? "" : `, identity ${diagnosis.identity}`;
+  return ` (${diagnosis.attribution}, liveness ${diagnosis.liveness}${identity})`;
+}
 function pause(ms, signal) {
   return new Promise((resolve) => {
     const done = () => {
@@ -93,7 +100,7 @@ async function withExclusiveLock(path, run, options = {}) {
     const remaining = deadline - performance.now();
     if (remaining <= 0) {
       const holder = attempt.diagnosis?.owner ?? null;
-      throw new ExclusiveLockError("LOCK_TIMEOUT", label, holder, `[stitchkit] the lock on "${label}" is held by ${describeHolder(holder)}; gave up after ${timeoutMs} ms`, { cause: attempt.error });
+      throw new ExclusiveLockError("LOCK_TIMEOUT", label, holder, `[stitchkit] the lock on "${label}" is held by ${describeHolder(holder)}${describeEvidence(attempt.diagnosis)}; gave up after ${timeoutMs} ms`, { cause: attempt.error });
     }
     await pause(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal);
     delay = Math.min(delay * 2, MAX_RETRY_MS);

package/dist/entrypoints/index.d.ts

@@ -5,6 +5,8 @@ export type { BindRealtimeClientOptions, BoundRealtimeClient, RealtimeClientTran
 export { bindRealtimeClient } from '../browser/realtime-client.js';
 export { type ResumableAttempt, type ResumableIteratorConfig, resumableIterator, } from '../browser/resumable.js';
 export { createRetainedTopics, type RetainedTopics } from '../browser/retained.js';
+export { createSessionScope, SessionExpiredError, type SessionOperation, type SessionScope, } from '../browser/session.js';
+export { createSessionCredentials, type SessionCredentials, type SessionCredentialsConfig, } from '../browser/session-credentials.js';
 export type { RealtimeClient, RealtimeClientOptions, SocketEventMap, SocketIOClient, SocketIOClientConfig, SocketIOClientPeerLoaders, } from '../browser/socket-io.js';
 export { createRealtimeClient, createSocketIOClient } from '../browser/socket-io.js';
 export { type ParseNDJSONOptions, type ParseSSEOptions, parseNDJSON, parseSSE, } from '../browser/stream.js';

package/dist/entrypoints/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entrypoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAChF,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,WAAW,EACX,QAAQ,GACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGzF,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entrypoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,WAAW,EACX,QAAQ,GACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGzF,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/entrypoints/index.js

@@ -32,6 +32,9 @@ import {
   RealtimeRequestRejectedError,
   RealtimeRequestTimeoutError
 } from "../index-dce5wxcq.js";
+import {
+  withDeadline
+} from "../index-b9aefrqd.js";
 import"../index-48ffdxgk.js";
 import {
   createContractFactory,
@@ -44,6 +47,9 @@ import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES
 } from "../index-wqgjfstn.js";
+import {
+  createMutationQueue
+} from "../index-q3pyb9n0.js";
 import {
   LiveStateControllerStatusSchema,
   LiveStatePhaseSchema,
@@ -393,6 +399,196 @@ function createRetainedTopics() {
     }
   };
 }
+// src/browser/session.ts
+class SessionExpiredError extends Error {
+  constructor(options) {
+    super("The originating session is no longer active", options);
+    this.name = "SessionExpiredError";
+  }
+}
+function createSessionScope() {
+  let generation = 0;
+  let stopped = false;
+  let active;
+  let abort;
+  const invalidate = () => {
+    const previous = abort;
+    generation += 1;
+    active = undefined;
+    abort = undefined;
+    previous?.abort(new SessionExpiredError);
+  };
+  return {
+    get generation() {
+      return generation;
+    },
+    replace(context) {
+      if (stopped)
+        throw new SessionExpiredError;
+      const previous = abort;
+      generation += 1;
+      const controller = new AbortController;
+      abort = controller;
+      const id = generation;
+      const current = () => !stopped && generation === id && !controller.signal.aborted;
+      const assertCurrent = () => {
+        if (!current())
+          throw new SessionExpiredError;
+      };
+      const operation = {
+        context,
+        id: crypto.randomUUID(),
+        generation: id,
+        signal: controller.signal,
+        current,
+        assertCurrent,
+        async run(work) {
+          assertCurrent();
+          try {
+            const result = await work();
+            assertCurrent();
+            return result;
+          } catch (error) {
+            if (!current())
+              throw new SessionExpiredError({ cause: error });
+            throw error;
+          }
+        },
+        deliver(delivery) {
+          if (!current())
+            return false;
+          delivery();
+          return true;
+        },
+        bindFetch(fetch, headers) {
+          return async (input, init) => {
+            assertCurrent();
+            const request = new Request(input, init);
+            const extra = headers?.();
+            assertCurrent();
+            if (extra)
+              new Headers(extra).forEach((value, key) => {
+                request.headers.set(key, value);
+              });
+            const signal = AbortSignal.any([controller.signal, request.signal]);
+            return operation.run(() => fetch(new Request(request, { signal })));
+          };
+        }
+      };
+      active = Object.freeze(operation);
+      previous?.abort(new SessionExpiredError);
+      return operation;
+    },
+    clear: invalidate,
+    stop() {
+      stopped = true;
+      invalidate();
+    },
+    capture() {
+      if (!active)
+        throw new SessionExpiredError;
+      return active;
+    },
+    owns(operation) {
+      return active === operation && operation.current();
+    }
+  };
+}
+// src/browser/session-credentials.ts
+function createSessionCredentials(config) {
+  const capacity = config.maxPendingWrites ?? 128;
+  if (!Number.isSafeInteger(capacity) || capacity < 1 || capacity > 65536)
+    throw new RangeError("maxPendingWrites must be between 1 and 65536");
+  const serialize = createMutationQueue(capacity);
+  const timeout = config.refreshTimeoutMs ?? 30000;
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 3600000) {
+    throw new RangeError("refreshTimeoutMs must be between 1 and 3600000");
+  }
+  const storageTimeout = config.storageTimeoutMs ?? 30000;
+  if (!Number.isInteger(storageTimeout) || storageTimeout < 1 || storageTimeout > 3600000) {
+    throw new RangeError("storageTimeoutMs must be between 1 and 3600000");
+  }
+  let state;
+  const bounded = async (work, wrote) => {
+    const outcome = await withDeadline(work, storageTimeout);
+    if (outcome.settled)
+      return;
+    work.then(() => {
+      if (state?.credentials !== wrote)
+        return restore();
+    }).catch(() => {
+      return;
+    });
+    throw new Error("Session storage did not answer within storageTimeoutMs");
+  };
+  const restore = () => serialize(async () => {
+    const current = state;
+    if (current)
+      await bounded(config.storage.write(current.operation.context, current.credentials), current.credentials);
+    else
+      await bounded(config.storage.clear(), undefined);
+  });
+  let flight;
+  const read = (operation) => {
+    if (!config.scope.owns(operation) || state?.operation !== operation)
+      throw new SessionExpiredError;
+    return state.credentials;
+  };
+  const write = (operation, credentials) => serialize(async () => {
+    read(operation);
+    await bounded(config.storage.write(operation.context, credentials), credentials);
+    operation.assertCurrent();
+  });
+  return {
+    async login(session, credentials) {
+      const operation = config.scope.replace(session);
+      operation.assertCurrent();
+      state = { operation, credentials };
+      await write(operation, credentials);
+      return operation;
+    },
+    logout() {
+      config.scope.clear();
+      state = undefined;
+      const generation = config.scope.generation;
+      return serialize(async () => {
+        if (config.scope.generation === generation)
+          await bounded(config.storage.clear(), undefined);
+      });
+    },
+    read,
+    refresh(operation) {
+      const credentials = read(operation);
+      if (flight?.operation === operation)
+        return flight.result;
+      const controller = new AbortController;
+      const signal = AbortSignal.any([operation.signal, controller.signal]);
+      const timer = setTimeout(() => controller.abort(new DOMException("Refresh timed out", "TimeoutError")), timeout);
+      let onAbort = () => {
+        return;
+      };
+      const abortPromise = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      const result = operation.run(async () => {
+        const next = await Promise.race([config.refresh(credentials, signal), abortPromise]);
+        read(operation);
+        state = { operation, credentials: next };
+        await write(operation, next);
+        read(operation);
+        return next;
+      }).finally(() => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        if (flight?.result === result)
+          flight = undefined;
+      });
+      flight = { operation, result };
+      return result;
+    }
+  };
+}
 // src/browser/socket-io-connection.ts
 function toIoAuth(auth) {
   if (typeof auth !== "function")
@@ -724,6 +920,8 @@ export {
   createUrlBuilder,
   createTraceContext,
   createSocketIOClient,
+  createSessionScope,
+  createSessionCredentials,
   createScopedUrlBuilders,
   createScopedClients,
   createRetainedTopics,
@@ -742,6 +940,7 @@ export {
   asRealtimeRejection,
   appError,
   TOOL_TRANSPORTS,
+  SessionExpiredError,
   STITCH_ERROR_STATUS,
   RealtimeRequestTimeoutError,
   RealtimeRequestRejectedError,

package/dist/entrypoints/live.js

@@ -14,7 +14,7 @@ import {
   diff,
   watchContract,
   watchKeyString
-} from "../index-wt743f7f.js";
+} from "../index-k6gpggb9.js";
 import"../index-1j8pm5t0.js";
 import"../index-d9pk3td4.js";
 import {
@@ -73,23 +73,23 @@ function toRealtimeContract(declaration) {
   }
   return { serverToClient, clientToServer: {} };
 }
-// src/live/watch-client.ts
-function watchTransport(client) {
-  return client;
-}
+// src/live/watch-client-state.ts
 function publishState(entry, state) {
   entry.state = state;
   for (const listener of [...entry.listeners])
     listener.state?.(state);
 }
 async function openWatch(config, openTimeoutMs, entry) {
-  if (entry.opened)
+  if (entry.opened || entry.released || config.session && !config.session.current())
     return;
+  const epoch = ++entry.epoch;
   entry.opened = true;
   entry.answered = false;
   try {
     const have = entry.hasValue && entry.fingerprint !== undefined ? { revision: entry.revision, fingerprint: entry.fingerprint } : undefined;
     const acknowledgement = await config.transport.request(WATCH_OPEN, { key: entry.key, args: entry.args, ...have !== undefined && { have } }, { timeoutMs: openTimeoutMs });
+    if (epoch !== entry.epoch || entry.released || config.session && !config.session.current())
+      return;
     if (!acknowledgement.accepted) {
       const reason = acknowledgement.reason ?? "the server refused this watch";
       config.onRefused?.(entry.key, reason);
@@ -101,6 +101,8 @@ async function openWatch(config, openTimeoutMs, entry) {
       });
     }
   } catch (error) {
+    if (epoch !== entry.epoch || entry.released || config.session && !config.session.current())
+      return;
     entry.opened = false;
     const code = typeof error === "object" && error !== null && "code" in error ? String(Reflect.get(error, "code")) : undefined;
     publishState(entry, {
@@ -160,8 +162,19 @@ function applyWatchFrame(entry, frame) {
   entry.answered = true;
   return { kind: "value", value };
 }
+
+// src/live/watch-client.ts
+function watchTransport(client) {
+  return client;
+}
 function createWatchClient(contract, config) {
   const entries = new Map;
+  const valid = () => !config.session || config.session.current();
+  const maxKeys = config.maxKeys ?? 1024;
+  const maxListeners = config.maxListenersPerKey ?? 128;
+  for (const bound of [maxKeys, maxListeners])
+    if (!Number.isInteger(bound) || bound < 1)
+      throw new RangeError("Watch capacity must be positive");
   const holdMs = config.holdMs ?? 0;
   const openTimeoutMs = config.openTimeoutMs ?? 1e4;
   const service = contract.meta.prefix;
@@ -175,7 +188,9 @@ function createWatchClient(contract, config) {
     config.transport.emit(WATCH_CLOSE, { key: entry.key });
     openWatch(config, openTimeoutMs, entry);
   }
-  config.transport.on(WATCH_VALUE, (frame) => {
+  const offValue = config.transport.on(WATCH_VALUE, (frame) => {
+    if (!valid())
+      return;
     const entry = entries.get(watchKeyString(frame.key));
     if (!entry)
       return;
@@ -189,16 +204,21 @@ function createWatchClient(contract, config) {
     for (const listener of [...entry.listeners])
       listener.value(outcome.value);
   });
-  config.transport.on(WATCH_STATE, (frame) => {
+  const offState = config.transport.on(WATCH_STATE, (frame) => {
+    if (!valid())
+      return;
     const entry = entries.get(watchKeyString(frame.key));
     if (!entry)
       return;
     publishState(entry, frame);
   });
-  config.transport.onConnectionChange((connected, reason) => {
+  const offConnection = config.transport.onConnectionChange((connected, reason) => {
+    if (!valid())
+      return;
     if (!connected) {
       for (const entry of entries.values()) {
         entry.opened = false;
+        entry.epoch += 1;
         publishState(entry, {
           key: entry.key,
           phase: "unavailable",
@@ -215,6 +235,25 @@ function createWatchClient(contract, config) {
       openWatch(config, openTimeoutMs, entry);
     }
   });
+  const shutdown = () => {
+    offValue();
+    offState();
+    offConnection();
+    for (const entry of entries.values()) {
+      entry.released = true;
+      entry.epoch++;
+      clearTimeout(entry.release);
+      entry.listeners.clear();
+      entry.value = undefined;
+      entry.hasValue = false;
+      config.transport.emit(WATCH_CLOSE, { key: entry.key });
+    }
+    entries.clear();
+  };
+  if (config.session?.signal.aborted)
+    shutdown();
+  else
+    config.session?.signal.addEventListener("abort", shutdown, { once: true });
   function entryFor(key, args) {
     const id = watchKeyString(key);
     const existing = entries.get(id);
@@ -223,7 +262,11 @@ function createWatchClient(contract, config) {
       existing.release = undefined;
       return existing;
     }
+    if (entries.size >= maxKeys)
+      throw new Error("Watch key capacity exceeded");
     const entry = {
+      epoch: 0,
+      released: false,
       key,
       args,
       listeners: new Set,
@@ -236,12 +279,14 @@ function createWatchClient(contract, config) {
     entries.set(id, entry);
     return entry;
   }
-  function releaseEntry(entry) {
+  function releaseWatchClientEntry(entry) {
     if (entry.listeners.size > 0)
       return;
     const drop = () => {
       if (entry.listeners.size > 0)
         return;
+      entry.released = true;
+      entry.epoch++;
       entries.delete(watchKeyString(entry.key));
       config.transport.emit(WATCH_CLOSE, { key: entry.key });
     };
@@ -254,27 +299,41 @@ function createWatchClient(contract, config) {
   }
   function handleFor(action, args) {
     const mine = new Set;
-    const entry = entryFor({ service, action, digest: argumentsDigest(args) }, args);
+    const key = {
+      service,
+      action,
+      digest: argumentsDigest(args),
+      ...config.session && { instance: config.session.id }
+    };
+    let entry;
     return {
       subscribe(listeners) {
+        config.session?.assertCurrent();
+        if (!entry || entry.released)
+          entry = entryFor(key, args);
+        const current = entry;
+        if (current.listeners.size >= maxListeners)
+          throw new Error("Watch listener capacity exceeded");
         const registered = listeners;
         mine.add(registered);
-        entry.listeners.add(registered);
-        if (entry.hasValue)
-          registered.value(entry.value);
-        registered.state?.(entry.state);
-        openWatch(config, openTimeoutMs, entry);
+        current.listeners.add(registered);
+        if (current.hasValue)
+          registered.value(current.value);
+        registered.state?.(current.state);
+        openWatch(config, openTimeoutMs, current);
         return () => {
           mine.delete(registered);
-          entry.listeners.delete(registered);
-          releaseEntry(entry);
+          current.listeners.delete(registered);
+          releaseWatchClientEntry(current);
         };
       },
       close() {
+        if (!entry)
+          return;
         for (const listener of mine)
           entry.listeners.delete(listener);
         mine.clear();
-        releaseEntry(entry);
+        releaseWatchClientEntry(entry);
       }
     };
   }

package/dist/entrypoints/node.js

@@ -8,7 +8,7 @@ import {
   createSocketIOServer,
   createUnixClientTransport,
   implementRegistry
-} from "../index-p3vsv1fb.js";
+} from "../index-hadmp193.js";
 import"../index-y91ry9h2.js";
 import {
   ShutdownOptionsSchema,

package/dist/entrypoints/react.d.ts

@@ -1,4 +1,4 @@
-export { type CacheBridge, type CacheBridgeConfig, type CacheBridgeContext, type CacheBridgeHandler, type CacheBridgeHandlers, type CacheBridgeSocket, createCacheBridge, createRealtimeCacheBridge, type RealtimeCacheBridgeConfig, } from '../react/cache-bridge.js';
+export { type CacheBridge, type CacheBridgeConfig, type CacheBridgeContext, type CacheBridgeHandler, type CacheBridgeHandlers, type CacheBridgeSocket, createCacheBridge, createRealtimeCacheBridge, type RealtimeCacheBridgeConfig, type WatchCacheBinding, } from '../react/cache-bridge.js';
 export { type CursorQueryConfig, createCursorQuery } from '../react/cursor-query.js';
 export { createEntityCacheHandlers, type DeletedPayload, type EntityCacheConfig, type EntityCacheEvent, type EntityCacheHandlers, type EntityCacheKey, type EntityCacheListConfig, type EntityCacheListShape, type EntityCacheMembership, type EntityCacheMembershipPolicy, type EntityCacheTotalDeltaInput, type EntityCacheTotalPolicy, } from '../react/entity-cache.js';
 export { type ApiErrorRetryConfig, apiErrorRetry, createQueryClientFactory, type QueryClientFactoryConfig, type QueryClientServerCache, type QueryRetryValue, } from '../react/query-client.js';

package/dist/entrypoints/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/entrypoints/react.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,KAAK,yBAAyB,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EACL,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,mBAAmB,EACxB,aAAa,EACb,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,eAAe,GACrB,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/entrypoints/react.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EACL,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,mBAAmB,EACxB,aAAa,EACb,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,eAAe,GACrB,MAAM,uBAAuB,CAAC"}

package/dist/entrypoints/react.js

@@ -36,28 +36,71 @@ function createCacheBridge(config) {
     expiryTimers.clear();
     freshAt.clear();
   };
+  let connected = false;
+  let clearWatched;
+  const disconnect = () => {
+    for (const off of unsubscribers)
+      off();
+    unsubscribers = [];
+    connected = false;
+    clearFresh();
+    config.session?.signal.removeEventListener("abort", invalidateSession);
+  };
+  const invalidateSession = () => {
+    disconnect();
+    clearWatched?.();
+  };
   return {
     connect() {
-      if (unsubscribers.length > 0)
+      config.session?.assertCurrent();
+      if (connected)
         return;
       const queryClient = typeof config.queryClient === "function" ? config.queryClient() : config.queryClient;
-      const ctx = { queryClient, isFresh };
-      const handlers = config.handlers;
-      const socket = config.socket;
-      for (const event of Object.keys(handlers)) {
-        const handler = handlers[event];
-        if (!handler)
-          continue;
-        const off = socket.on(event, (data) => handler(data, ctx));
-        unsubscribers.push(off);
+      connected = true;
+      try {
+        clearWatched = () => {
+          for (const binding of config.watched ?? [])
+            queryClient.removeQueries({ queryKey: binding.queryKey, exact: true });
+        };
+        config.session?.signal.addEventListener("abort", invalidateSession, { once: true });
+        for (const binding of config.watched ?? []) {
+          unsubscribers.push(binding.handle.subscribe({
+            value(value) {
+              if (!config.session || config.session.current())
+                queryClient.setQueryData(binding.queryKey, value);
+            },
+            state(state) {
+              if (config.session && !config.session.current())
+                return;
+              if (state.phase !== "live")
+                queryClient.invalidateQueries({
+                  queryKey: binding.queryKey,
+                  exact: true,
+                  refetchType: "none"
+                });
+              binding.state?.(state);
+            }
+          }));
+        }
+        const ctx = { queryClient, isFresh };
+        const handlers = config.handlers;
+        const socket = config.socket;
+        for (const event of Object.keys(handlers)) {
+          const handler = handlers[event];
+          if (!handler)
+            continue;
+          const off = socket.on(event, (data) => {
+            if (!config.session || config.session.current())
+              handler(data, ctx);
+          });
+          unsubscribers.push(off);
+        }
+      } catch (error) {
+        disconnect();
+        throw error;
       }
     },
-    disconnect() {
-      for (const off of unsubscribers)
-        off();
-      unsubscribers = [];
-      clearFresh();
-    },
+    disconnect,
     markFresh(key) {
       const serialised = JSON.stringify(key);
       const existingTimer = expiryTimers.get(serialised);

package/dist/entrypoints/server.js

@@ -19,14 +19,11 @@ import {
   sseRoute,
   streamingRoute,
   webSocketLane
-} from "../index-p3vsv1fb.js";
+} from "../index-hadmp193.js";
 import"../index-y91ry9h2.js";
 import {
   createFileStateStore
 } from "../index-tm88avnj.js";
-import {
-  withDeadline
-} from "../index-b9aefrqd.js";
 import {
   ShutdownOptionsSchema,
   ShutdownResultSchema,
@@ -36,6 +33,9 @@ import {
 } from "../index-3z73fh2c.js";
 import"../index-ndddxtyx.js";
 import"../index-dce5wxcq.js";
+import {
+  withDeadline
+} from "../index-b9aefrqd.js";
 import {
   inputIsQuery
 } from "../index-48ffdxgk.js";

package/dist/{index-sp1tzwnb.js → index-10x2hbx0.js}

@@ -7,12 +7,12 @@ import {
   createAgentRuntimeStore,
   isActiveRunState,
   replaceMessage
-} from "./index-wsm5w4ee.js";
+} from "./index-vqr7f7v8.js";
 import {
   AgentRecoverablePageSchema,
   AgentStoreEventEnvelopeSchema,
   AgentStoreEventPageSchema
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema
@@ -202,6 +202,9 @@ var memoryEvents = {
       items,
       ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
     });
+  },
+  async find(transaction, input) {
+    return (transaction.events.get(input.conversationId) ?? []).find((event) => event.eventId === input.eventId);
   }
 };
 function scanMemoryRecoverable(runs, input) {