stitchkit 0.99.0 → 0.100.0

package/dist/entrypoints/files.js

@@ -1,6 +1,7 @@
 import {
   attemptExclusiveLock
-} from "../index-8p52kd5p.js";
+} from "../index-js7gqrb1.js";
+import"../index-zjjyynm3.js";
 import {
   ManagedFileError,
   createManagedFileBoundary

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

@@ -44,6 +44,9 @@ import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES
 } from "../index-wqgjfstn.js";
+import {
+  createMutationQueue
+} from "../index-q3pyb9n0.js";
 import {
   LiveStateControllerStatusSchema,
   LiveStatePhaseSchema,
@@ -393,6 +396,172 @@ function createRetainedTopics() {
     }
   };
 }
+// src/browser/session.ts
+class SessionExpiredError extends Error {
+  constructor() {
+    super("The originating session is no longer active");
+    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) {
+            assertCurrent();
+            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");
+  }
+  let state;
+  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 config.storage.write(operation.context, 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 config.storage.clear();
+      });
+    },
+    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);
+        await write(operation, next);
+        read(operation);
+        state = { operation, credentials: next };
+        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 +893,8 @@ export {
   createUrlBuilder,
   createTraceContext,
   createSocketIOClient,
+  createSessionScope,
+  createSessionCredentials,
   createScopedUrlBuilders,
   createScopedClients,
   createRetainedTopics,
@@ -742,6 +913,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,9 +299,19 @@ function createWatchClient(contract, config) {
   }
   function handleFor(action, args) {
     const mine = new Set;
-    const entry = entryFor({ service, action, digest: argumentsDigest(args) }, args);
+    let entry = entryFor({
+      service,
+      action,
+      digest: argumentsDigest(args),
+      ...config.session && { instance: config.session.id }
+    }, args);
     return {
       subscribe(listeners) {
+        config.session?.assertCurrent();
+        if (entry.released)
+          entry = entryFor(entry.key, args);
+        if (entry.listeners.size >= maxListeners)
+          throw new Error("Watch listener capacity exceeded");
         const registered = listeners;
         mine.add(registered);
         entry.listeners.add(registered);
@@ -267,14 +322,14 @@ function createWatchClient(contract, config) {
         return () => {
           mine.delete(registered);
           entry.listeners.delete(registered);
-          releaseEntry(entry);
+          releaseWatchClientEntry(entry);
         };
       },
       close() {
         for (const listener of mine)
           entry.listeners.delete(listener);
         mine.clear();
-        releaseEntry(entry);
+        releaseWatchClientEntry(entry);
       }
     };
   }

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/{index-wsm5w4ee.js → index-0b1cnze2.js}

@@ -19,7 +19,7 @@ import {
   canonicalAgentJson,
   decodeAgentConversationArchive,
   encodeAgentConversationArchive
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema,
@@ -427,6 +427,37 @@ async function importConversation(driver, bytes) {
   });
 }
 
+// src/agent-runtime/store-event-once.ts
+import { createHash } from "node:crypto";
+function appendEventOnce(driver, input, key) {
+  const parsed = AppendAgentStoreEventSchema.parse(input);
+  if (!key)
+    throw new TypeError("Event admission key must not be empty");
+  const eventId = createHash("sha256").update(JSON.stringify([parsed.conversationId, parsed.kind, key])).digest("hex");
+  return driver.transaction(async (transaction) => {
+    if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+      throw new AgentConversationPurgedError;
+    }
+    let fromSeq;
+    do {
+      const page = await driver.events.list(transaction, {
+        conversationId: parsed.conversationId,
+        fromSeq,
+        limit: 1e4
+      });
+      const previous = page.items.find((event2) => event2.eventId === eventId);
+      if (previous)
+        return { outcome: "duplicate", event: previous };
+      fromSeq = page.nextSeq;
+    } while (fromSeq !== undefined);
+    const event = await driver.events.append(transaction, {
+      ...agentStoreEventDraft(parsed),
+      eventId
+    });
+    return { outcome: "applied", event };
+  });
+}
+
 // src/agent-runtime/store-mutate.ts
 import { z as z4 } from "zod";
 
@@ -453,7 +484,7 @@ function applied(current, input, effects) {
 }
 
 // src/agent-runtime/store-reducer.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // src/agent-runtime/store-reduce-history.ts
 function reduceAccept(current, input) {
@@ -737,7 +768,7 @@ function transitionRecord(operation) {
       assistant: {
         id: assistant.id,
         status: assistant.status,
-        sha256: createHash("sha256").update(body).digest("hex"),
+        sha256: createHash2("sha256").update(body).digest("hex"),
         parts: assistant.parts.length,
         bytes: Buffer.byteLength(body)
       }
@@ -979,6 +1010,7 @@ function createAgentRuntimeStore(driver) {
     loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
     loadRun: (input) => loadRun(driver, input),
     listActiveRuns: (conversationId) => listActiveRuns(driver, conversationId),
+    appendEventOnce: (input, key) => appendEventOnce(driver, input, key),
     appendEvent: (input) => appendEvent(driver, input),
     readEvents: (input) => readEvents(driver, input),
     exportConversation: (conversationId) => exportConversation(driver, conversationId),

package/dist/{index-gxrt5h6v.js → index-cyktc4bp.js}

@@ -17,6 +17,9 @@ import { z } from "zod";
 var AgentStoreEventKindSchema = z.enum([
   "runtime/baseline",
   "runtime/transition",
+  "invocation/started",
+  "invocation/finished",
+  "provider/payload",
   "provider/request",
   "provider/response",
   "provider/message",