experimental-a2 0.14.1 → 0.16.0

package/dist/client-CzyacQpJ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-CzyacQpJ.d.ts","names":[],"sources":["../src/client-errors.ts","../src/client.ts"],"mappings":";;;KAEY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;cAGW,sBAAsB;WACxB;WACA;WACA;WACA;WACA;EAET,YACE,MAAM,aACN,iBACA,UAAU;;;;KCkCF,mBAAmB;EAC7B;EACA,OAAO;EACP;;KAGU;;;;;;;KASA;EACN;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;EAAkB;EAAoB,OAAO;;EAC7C;EAAgB;;EAChB;;;;;;;;;;KAUM,WAAW,UAAU,aAAa,QAAQ,cAAc;WACzD,WAAW,QAAQ,cAAc;;KAGhC;;;;;;EAMV;;EAEA;;;KAIU;;EAEV;;EAEA;;EAEA;;;KAIU,gBACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aACF;;EAGE,UAAU,YAAY;;;EAIxB,OAAO;;;;;EAKP,QAAQ,cAAc;;;EAGtB;;EAEA,SAAS;EACT,YAAY;;;;;;;KAQF,sBAAsB,UAAU;;;;;;;;;;EAU1C,YAAY,QAAQ,cAAc;;KAGxB,cACV,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI,KACF,aAAa,GAAG,sBAAsB;WAC/B;EACT,UAAU;EACV,eAAe,gBAAgB,GAAG,GAAG;;;;;;;;;;EAUrC,QAAQ,QAAQ,YAAY,OAAO,WAAW;;;;;;;;;;;EAW9C,YAAY,UAAU,qBAAqB,QAAQ,cAAc;;;;;;;;;;EAUjE;;;EAGA;;;;;;EAMA;;KAGU,eAAe,UAAU,WAAW;EAC9C,eAAe;EACf;;EAEA,gBAAgB,cAAc;;;EAG9B;;KAGU,SACV,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI;EAEJ,QACE,mBACA,UAAU,eAAe,GAAG,KAC3B,cAAc,GAAG,GAAG,GAAG;;;;;;;;;KAUhB,wBAAwB;KAExB,YACR;EACE;EAAc,MAAM;EAAY,QAAQ;;EAExC;EAAY,KAAK;EAAY;;EAE7B;EAAY;EAAa;;;;;;;KAOnB;WACD;EACT,KAAK;EACL,MAAM,eAAe;EACrB,iBAAiB,cAAc;EAC/B,iBACE,iBACA,WAAW;IAAS;;EAEtB,iBACE,eACA,WAAW;IAAS;IAAc;;EAEpC,iBAAiB,eAAe;;KAGtB,kCAAkC,gBAAgB;KAElD,oBACV,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI;EAEJ,SAAS,QAAQ,GAAG,GAAG,GAAG;;EAE1B,KAAK;;EAEL,YAAY;;EAEZ,eAAe,WAAW;;;EAG1B,YAAY;;;EAGZ;;;;;;;;EAQA;;iBAm9Bc,aACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI,GACJ,SAAS,oBAAoB,GAAG,GAAG,GAAG,KAAK,SAAS,GAAG,GAAG,GAAG"}

package/dist/client.d.ts

@@ -1,2 +1,2 @@
-import { _ as createClient, a as Connection, c as HistoryState, d as ReconnectPolicy, f as SessionClient, g as SessionUrl, h as SessionSnapshot, i as ClientWebSocketConstructor, l as LoadHistoryOptions, m as SessionOptions, n as ClientApi, o as ConnectionStatus, p as SessionClientPresence, r as ClientWebSocket, s as CreateClientOptions, t as A2Client, u as PushResult, v as A2ClientError, y as A2ClientErrorOptions } from "./client-BAEABRZB.js";
+import { _ as createClient, a as Connection, c as HistoryState, d as ReconnectPolicy, f as SessionClient, g as SessionUrl, h as SessionSnapshot, i as ClientWebSocketConstructor, l as LoadHistoryOptions, m as SessionOptions, n as ClientApi, o as ConnectionStatus, p as SessionClientPresence, r as ClientWebSocket, s as CreateClientOptions, t as A2Client, u as PushResult, v as A2ClientError, y as A2ClientErrorOptions } from "./client-CzyacQpJ.js";
 export { A2Client, A2ClientError, type A2ClientErrorOptions, ClientApi, ClientWebSocket, ClientWebSocketConstructor, Connection, ConnectionStatus, CreateClientOptions, HistoryState, LoadHistoryOptions, PushResult, ReconnectPolicy, SessionClient, SessionClientPresence, SessionOptions, SessionSnapshot, SessionUrl, createClient };

package/dist/idempotent-id-BRJVeylj.js

@@ -0,0 +1,13 @@
+//#region src/idempotent-id.ts
+async function idempotentId(...parts) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(parts)));
+	const bytes = new Uint8Array(digest).slice(0, 16);
+	bytes[6] = bytes[6] & 15 | 128;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+//#endregion
+export { idempotentId as t };
+
+//# sourceMappingURL=idempotent-id-BRJVeylj.js.map

package/dist/idempotent-id-BRJVeylj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotent-id-BRJVeylj.js","names":[],"sources":["../src/idempotent-id.ts"],"sourcesContent":["export async function idempotentId(...parts: string[]): Promise<string> {\n  const digest = await crypto.subtle.digest(\n    'SHA-256',\n    new TextEncoder().encode(JSON.stringify(parts)),\n  )\n  const bytes = new Uint8Array(digest).slice(0, 16)\n  bytes[6] = (bytes[6]! & 0x0f) | 0x80\n  bytes[8] = (bytes[8]! & 0x3f) | 0x80\n  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('')\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`\n}\n"],"mappings":";AAAA,eAAsB,aAAa,GAAG,OAAkC;CACtE,MAAM,SAAS,MAAM,OAAO,OAAO,OACjC,WACA,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,UAAU,KAAK,CAAC,CAChD;CACA,MAAM,QAAQ,IAAI,WAAW,MAAM,CAAC,CAAC,MAAM,GAAG,EAAE;CAChD,MAAM,KAAM,MAAM,KAAM,KAAQ;CAChC,MAAM,KAAM,MAAM,KAAM,KAAQ;CAChC,MAAM,MAAM,MAAM,KAAK,QAAQ,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;CAC7E,OAAO,GAAG,IAAI,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI,MAAM,GAAG,EAAE,EAAE,GAAG,IAAI,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,IAAI,EAAE,EAAE,GAAG,IAAI,MAAM,IAAI,EAAE;AAC7G"}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-import { a as ContractEvent, c as PresenceDefs, d as PresenceSnapshot, f as ReducerOptions, h as StandardSchemaV1, i as Contract, l as PresenceMap, m as contract, n as ReducerBuilder, o as EventBatchFactory, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-BcS9VDKC.js";
-import { i as Event } from "./store-D_yhNdPz.js";
+import { a as ContractEvent, c as PresenceDefs, d as PresenceSnapshot, f as ReducerOptions, h as StandardSchemaV1, i as Contract, l as PresenceMap, m as contract, n as ReducerBuilder, o as EventBatchFactory, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-otzHjuJj.js";
+import { i as Event } from "./store-DyZM6fS5.js";
 import { i as NonRetriableError, n as A2ErrorCode, r as A2ServerErrorCode, t as A2Error } from "./errors-DvhSXnxk.js";
-import { i as A2Telemetry, n as A2SpanHandle, r as A2SpanName, t as A2AttributeValue } from "./telemetry-CpeclqB2.js";
-export { type A2AttributeValue, A2Error, type A2ErrorCode, type A2ServerErrorCode, type A2SpanHandle, type A2SpanName, type A2Telemetry, type AppendInput, type Contract, type ContractEvent, type Event, type EventBatchFactory, type EventDefs, NonRetriableError, type PresenceDefs, type PresenceMap, type PresencePatch, type PresenceSnapshot, type Reducer, type ReducerBuilder, type ReducerOptions, type StandardSchemaV1, contract };
+import { i as A2Telemetry, n as A2SpanHandle, r as A2SpanName, t as A2AttributeValue } from "./telemetry-B5jzpy6y.js";
+//#region src/idempotent-id.d.ts
+declare function idempotentId(...parts: string[]): Promise<string>;
+//#endregion
+export { type A2AttributeValue, A2Error, type A2ErrorCode, type A2ServerErrorCode, type A2SpanHandle, type A2SpanName, type A2Telemetry, type AppendInput, type Contract, type ContractEvent, type Event, type EventBatchFactory, type EventDefs, NonRetriableError, type PresenceDefs, type PresenceMap, type PresencePatch, type PresenceSnapshot, type Reducer, type ReducerBuilder, type ReducerOptions, type StandardSchemaV1, contract, idempotentId };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/idempotent-id.ts"],"mappings":";;;;;iBAAsB,gBAAgB,kBAAkB"}

package/dist/index.js

@@ -1,3 +1,4 @@
 import { t as contract } from "./contract-CKRg_E4q.js";
+import { t as idempotentId } from "./idempotent-id-BRJVeylj.js";
 import { n as NonRetriableError, t as A2Error } from "./errors-DCk6ch5n.js";
-export { A2Error, NonRetriableError, contract };
+export { A2Error, NonRetriableError, contract, idempotentId };

package/dist/otel.d.ts

@@ -1,4 +1,4 @@
-import { i as A2Telemetry } from "./telemetry-CpeclqB2.js";
+import { i as A2Telemetry } from "./telemetry-B5jzpy6y.js";
 import { Tracer } from "@opentelemetry/api";
 //#region src/otel.d.ts
 type OtelOptions = {

package/dist/react.d.ts

@@ -1,5 +1,5 @@
-import { a as ContractEvent, c as PresenceDefs, l as PresenceMap, p as WithPresence, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-BcS9VDKC.js";
-import { a as Connection, c as HistoryState, l as LoadHistoryOptions, t as A2Client, u as PushResult } from "./client-BAEABRZB.js";
+import { a as ContractEvent, c as PresenceDefs, l as PresenceMap, p as WithPresence, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-otzHjuJj.js";
+import { a as Connection, c as HistoryState, l as LoadHistoryOptions, t as A2Client, u as PushResult } from "./client-CzyacQpJ.js";
 import { ReactElement, ReactNode } from "react";
 //#region src/react.d.ts
 type UseSessionOptions<S> = {
@@ -92,20 +92,20 @@ type UseSessionResult<D extends EventDefs, S, P extends PresenceDefs = Record<ne
   /** Backscroll progress: `complete` means the feed reaches index 1. */
   history: HistoryState;
 };
-type A2React<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>> = {
+type A2React<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>, V = S> = {
   SessionProvider: (props: SessionProviderProps<D, S>) => ReactElement;
-  useSession: () => UseSessionResult<D, S, P>;
+  useSession: () => UseSessionResult<D, V, P>;
 };
-type BoundA2React<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>> = {
+type BoundA2React<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>, V = S> = {
   SessionProvider: (props: BoundSessionProviderProps<D, S>) => ReactElement;
-  useSession: () => UseSessionResult<D, S, P>;
+  useSession: () => UseSessionResult<D, V, P>;
 };
-declare function createReact<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>>(options: {
-  client: A2Client<D, S, P>;
-}): BoundA2React<D, S, P>;
-declare function createReact<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>>(options: {
-  reducer: Reducer<D, S, P>;
-}): A2React<D, S, P>;
+declare function createReact<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>, V = S>(options: {
+  client: A2Client<D, S, P, V>;
+}): BoundA2React<D, S, P, V>;
+declare function createReact<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>, V = S>(options: {
+  reducer: Reducer<D, S, P, V>;
+}): A2React<D, S, P, V>;
 /**
  * The standalone, provider-less hook — for apps whose components reach
  * sessions ad hoc (a sidebar of channel sessions, a user session read
@@ -116,7 +116,7 @@ declare function createReact<D extends EventDefs, S, P extends PresenceDefs = Re
  * stream is held, and your data layer's loading state is the pending
  * state.
  */
-declare function useSession<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>>(client: A2Client<D, S, P>, sessionId: string, options?: UseSessionOptions<S>): UseSessionResult<D, S, P>;
+declare function useSession<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>, V = S>(client: A2Client<D, S, P, V>, sessionId: string, options?: UseSessionOptions<S>): UseSessionResult<D, V, P>;
 //#endregion
 export { A2React, BoundA2React, BoundSessionProviderProps, SessionProviderProps, UseSessionOptions, UseSessionPresence, UseSessionResult, createReact, useSession };
 //# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","names":[],"sources":["../src/react.ts"],"mappings":";;;;KAoDY,kBAAkB;;;;EAI5B;;;;;;;;;;;;;;;;;EAiBA;IAAY,OAAO;IAAG;;;KAGZ,qBAAqB,UAAU,WAAW;;EAEpD;;EAEA;;EAEA,cAAc;;EAEd;;EAEA,gBAAgB,cAAc;;;EAG9B;EACA,WAAW;;KAGD,0BAA0B,UAAU,WAAW,KAAK,KAC9D,qBAAqB,GAAG;;;;;;KASd,mBAAmB,UAAU;;EAEvC,UAAU,YAAY;;;;;;;;EAQtB,cAAc,QAAQ,cAAc;;KAG1B,iBACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aAAa,GAAG,mBAAmB;;EAErC,OAAO;;EAEP,QAAQ,cAAc;;EAEtB;;;;;;EAMA,YAAY;;;;;;EAMZ,UAAU,QAAQ,YAAY,SAAS,WAAW;;EAElD;;;;;;EAMA,cAAc,UAAU,uBAAuB,QAAQ,cAAc;;EAErE,SAAS;;KAGC,QACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,kBAAkB,OAAO,qBAAqB,GAAG,OAAO;EACxD,kBAAkB,iBAAiB,GAAG,GAAG;;KAG/B,aACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,kBAAkB,OAAO,0BAA0B,GAAG,OAAO;EAC7D,kBAAkB,iBAAiB,GAAG,GAAG;;iBAG3B,YACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB;EAAW,QAAQ,SAAS,GAAG,GAAG;IAAO,aAAa,GAAG,GAAG;iBAC9C,YACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB;EAAW,SAAS,QAAQ,GAAG,GAAG;IAAO,QAAQ,GAAG,GAAG;;;;;;;;;;;iBAgKzC,WACd,UAAU,WACV,GACA,UAAU,eAAe,sBAEzB,QAAQ,SAAS,GAAG,GAAG,IACvB,mBACA,UAAU,kBAAkB,KAC3B,iBAAiB,GAAG,GAAG"}
+{"version":3,"file":"react.d.ts","names":[],"sources":["../src/react.ts"],"mappings":";;;;KAoDY,kBAAkB;;;;EAI5B;;;;;;;;;;;;;;;;;EAiBA;IAAY,OAAO;IAAG;;;KAGZ,qBAAqB,UAAU,WAAW;;EAEpD;;EAEA;;EAEA,cAAc;;EAEd;;EAEA,gBAAgB,cAAc;;;EAG9B;EACA,WAAW;;KAGD,0BAA0B,UAAU,WAAW,KAAK,KAC9D,qBAAqB,GAAG;;;;;;KASd,mBAAmB,UAAU;;EAEvC,UAAU,YAAY;;;;;;;;EAQtB,cAAc,QAAQ,cAAc;;KAG1B,iBACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aAAa,GAAG,mBAAmB;;EAErC,OAAO;;EAEP,QAAQ,cAAc;;EAEtB;;;;;;EAMA,YAAY;;;;;;EAMZ,UAAU,QAAQ,YAAY,SAAS,WAAW;;EAElD;;;;;;EAMA,cAAc,UAAU,uBAAuB,QAAQ,cAAc;;EAErE,SAAS;;KAGC,QACV,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI;EAEJ,kBAAkB,OAAO,qBAAqB,GAAG,OAAO;EACxD,kBAAkB,iBAAiB,GAAG,GAAG;;KAG/B,aACV,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI;EAEJ,kBAAkB,OAAO,0BAA0B,GAAG,OAAO;EAC7D,kBAAkB,iBAAiB,GAAG,GAAG;;iBAG3B,YACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI,GACJ;EAAW,QAAQ,SAAS,GAAG,GAAG,GAAG;IAAO,aAAa,GAAG,GAAG,GAAG;iBACpD,YACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI,GACJ;EAAW,SAAS,QAAQ,GAAG,GAAG,GAAG;IAAO,QAAQ,GAAG,GAAG,GAAG;;;;;;;;;;;iBAiK/C,WACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,IAAI,GAEJ,QAAQ,SAAS,GAAG,GAAG,GAAG,IAC1B,mBACA,UAAU,kBAAkB,KAC3B,iBAAiB,GAAG,GAAG"}

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","names":[],"sources":["../src/react.ts"],"sourcesContent":["'use client'\n/**\n * experimental-a2/react — React bindings over experimental-a2/client.\n *\n * `createReact({ client })` is a factory (like createContext): call it\n * once in a `'use client'` module with a shared A2 client and export the\n * bound pair. Server components import `SessionProvider` from that module\n * as a client reference; client components import `useSession` from the\n * same file. The shared client also makes imperative pushes and provider\n * renders resolve the same live session. Everything is typed by the\n * reducer value — no type arguments, and nothing here ever touches the\n * machine module.\n *\n * The standalone `useSession(client, sessionId, options?)` is the\n * provider-less primitive for client-first apps: identity-mapped\n * handles, one leased stream per session, and an app-owned hydration\n * input — the hook holds the stream until the app hands it a\n * `{ state, index }` fold.\n */\n\nimport {\n  createContext,\n  createElement,\n  useContext,\n  useEffect,\n  useMemo,\n  useSyncExternalStore,\n  type ReactElement,\n  type ReactNode,\n} from 'react'\nimport {\n  createClient,\n  type A2Client,\n  type Connection,\n  type HistoryState,\n  type LoadHistoryOptions,\n  type PushResult,\n  type SessionClient,\n  type SessionClientPresence,\n  type SessionSnapshot,\n} from './client.ts'\nimport type {\n  AppendInput,\n  ContractEvent,\n  EventDefs,\n  PresenceDefs,\n  PresenceMap,\n  PresencePatch,\n  WithPresence,\n} from './contract.ts'\nimport type { Reducer } from './reducer.ts'\n\nexport type UseSessionOptions<S> = {\n  /** Overrides the client's `participant` for this session — for apps\n   * whose identity is only known at mount time. Bound once per\n   * session handle. */\n  participant?: string\n  /**\n   * The server fold this session mounts from: the `{ state, index }`\n   * pair `session.state(reducer)` returns, fetched by the app through\n   * its own route. Atomic on purpose — the fold and its frontier\n   * travel together or not at all. While `undefined` (the app's fetch\n   * has not landed), the hook holds the stream; when the value\n   * arrives, the session hydrates through the ordinary re-hydration\n   * seam and the stream connects at that frontier. To fold from the log's start\n   * deliberately, hand the fold's true starting point:\n   * `{ state: reducer.initialState, index: 0 }` — state at index 0 is\n   * the reducer's seed by definition, so the explicit replay needs no\n   * special vocabulary. There is no pending/ready echo on the result:\n   * whether the fold has been handed over is this option — the\n   * caller's own input — so the data layer's loading state IS the\n   * pending state.\n   */\n  hydrate?: { state: S; index: number } | undefined\n}\n\nexport type SessionProviderProps<D extends EventDefs, S> = {\n  /** Which session to subscribe to. */\n  sessionId: string\n  /** Base path of the route exposing GET (stream) and POST (push). */\n  api: string\n  /** The server-rendered fold — the first paint, no client JS needed. */\n  initialState: S\n  /** The fold's frontier — the stream resumes exactly there. */\n  initialIndex: number\n  /** Server-rendered event history through `initialIndex`. */\n  initialEvents?: ContractEvent<D>[]\n  /** Overrides the client's `participant` for this session — for apps\n   * whose identity is only known at mount time. */\n  participant?: string\n  children?: ReactNode\n}\n\nexport type BoundSessionProviderProps<D extends EventDefs, S> = Omit<\n  SessionProviderProps<D, S>,\n  'api'\n>\n\n/**\n * The presence members of the hook result — intersected in via\n * `WithPresence`, so they exist exactly when the contract declares\n * presence fields (the reducer is the client's typed handle on it).\n */\nexport type UseSessionPresence<P extends PresenceDefs> = {\n  /** The replicated presence map, this client included (local echo). */\n  presence: PresenceMap<P>\n  /**\n   * Fire-and-forget: validated locally, echoed into the map\n   * immediately, coalesced on the wire to a fixed cadence (a leading\n   * send immediately, then at most one merged send per interval;\n   * later values win per field), stamped with the frontier at send\n   * time as `seen`. Requires the provider's `participant`.\n   */\n  setPresence: (values: PresencePatch<P>['values']) => void\n}\n\nexport type UseSessionResult<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = WithPresence<P, UseSessionPresence<P>> & {\n  /** The live view, folded through the shared reducer. */\n  state: S\n  /** The raw event feed — observed, seeded, or backscrolled. */\n  events: ContractEvent<D>[]\n  /** The stream frontier — `lastSeenIndex` for cancellation. */\n  index: number\n  /**\n   * The connection, as a discriminated union — `error` exists only\n   * while disconnected; \"reconnecting…\" is\n   * `status === 'connecting' && reconnects > 0`.\n   */\n  connection: Connection\n  /**\n   * Typed optimistic append. Awaiting it gives the server ack;\n   * `.confirmed` resolves when the live stream has delivered the batch\n   * back. Rejects with the server's A2Error codes.\n   */\n  push: (...events: AppendInput<D>[]) => PushResult<D>\n  /** Restart the live subscription without resetting its state or cursor. */\n  reconnect: () => void\n  /**\n   * Backscroll: fetch a bounded slice of older events into `events`.\n   * Defaults page backward 50 at a time from the oldest loaded event.\n   * Display data only — `state` and the optimistic overlay never move.\n   */\n  loadHistory: (options?: LoadHistoryOptions) => Promise<ContractEvent<D>[]>\n  /** Backscroll progress: `complete` means the feed reaches index 1. */\n  history: HistoryState\n}\n\nexport type A2React<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = {\n  SessionProvider: (props: SessionProviderProps<D, S>) => ReactElement\n  useSession: () => UseSessionResult<D, S, P>\n}\n\nexport type BoundA2React<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = {\n  SessionProvider: (props: BoundSessionProviderProps<D, S>) => ReactElement\n  useSession: () => UseSessionResult<D, S, P>\n}\n\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n>(options: { client: A2Client<D, S, P> }): BoundA2React<D, S, P>\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n>(options: { reducer: Reducer<D, S, P> }): A2React<D, S, P>\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n>(\n  options: { client: A2Client<D, S, P> } | { reducer: Reducer<D, S, P> },\n): BoundA2React<D, S, P> | A2React<D, S, P> {\n  const Context = createContext<SessionClient<D, S, P> | null>(null)\n  const resolveSession: (\n    sessionId: string,\n    api: string | undefined,\n    initialState: S,\n    initialIndex: number,\n    initialEvents: ContractEvent<D>[] | undefined,\n    participant: string | undefined,\n  ) => SessionClient<D, S, P> =\n    'client' in options\n      ? (\n          sessionId,\n          _api,\n          initialState,\n          initialIndex,\n          initialEvents,\n          participant,\n        ) =>\n          options.client.session(sessionId, {\n            initialState,\n            initialIndex,\n            ...(initialEvents === undefined ? {} : { initialEvents }),\n            ...(participant === undefined ? {} : { participant }),\n          })\n      : (() => {\n          const clients = new Map<string, A2Client<D, S, P>>()\n          return (\n            sessionId: string,\n            api: string | undefined,\n            initialState: S,\n            initialIndex: number,\n            initialEvents: ContractEvent<D>[] | undefined,\n            participant: string | undefined,\n          ) => {\n            if (api === undefined) {\n              throw new TypeError(\n                'SessionProvider requires api when createReact binds a reducer',\n              )\n            }\n            let client = clients.get(api)\n            if (!client) {\n              client = createClient({ reducer: options.reducer, api })\n              clients.set(api, client)\n            }\n            return client.session(sessionId, {\n              initialState,\n              initialIndex,\n              ...(initialEvents === undefined ? {} : { initialEvents }),\n              ...(participant === undefined ? {} : { participant }),\n            })\n          }\n        })()\n\n  function SessionProvider(\n    props: SessionProviderProps<D, S> | BoundSessionProviderProps<D, S>,\n  ): ReactElement {\n    const {\n      sessionId,\n      initialState,\n      initialIndex,\n      initialEvents,\n      participant,\n    } = props\n    const api = 'api' in props ? props.api : undefined\n    const client = useMemo(\n      () =>\n        resolveSession(\n          sessionId,\n          api,\n          initialState,\n          initialIndex,\n          initialEvents,\n          participant,\n        ),\n      [sessionId, api, initialState, initialIndex, initialEvents, participant],\n    )\n    useSessionLifecycle(client, true)\n    return createElement(Context.Provider, { value: client }, props.children)\n  }\n\n  function useBoundSession(): UseSessionResult<D, S, P> {\n    const client = useContext(Context)\n    if (!client) {\n      throw new Error(\n        'useSession must be rendered inside its matching SessionProvider',\n      )\n    }\n    return useSessionResult(client)\n  }\n\n  return { SessionProvider, useSession: useBoundSession }\n}\n\n// ── the shared session lifecycle ───────────────────────────────\n\n/**\n * Hold a stream lease while mounted and `live` — the client refcounts\n * leases per handle, so however many providers and hooks mount one\n * session, the first connects and the last release closes\n * (StrictMode-safe: the lease is retaken on remount). A standalone\n * hook without a `hydrate` value passes `live: false` and holds the\n * stream — connecting an unhydrated session would replay the whole\n * log, and the library never picks the expensive path silently.\n */\nfunction useSessionLifecycle<D extends EventDefs, S, P extends PresenceDefs>(\n  session: SessionClient<D, S, P>,\n  live: boolean,\n): void {\n  useEffect(() => {\n    if (!live) return\n    return session.connect()\n  }, [session, live])\n}\n\nfunction useSessionResult<D extends EventDefs, S, P extends PresenceDefs>(\n  session: SessionClient<D, S, P>,\n): UseSessionResult<D, S, P> {\n  const snapshot: SessionSnapshot<D, S, P> = useSyncExternalStore(\n    session.subscribe,\n    session.getSnapshot,\n    session.getSnapshot,\n  )\n  return useMemo(() => {\n    // Runtime mirror of the WithPresence surface: the client attaches\n    // setPresence (and the snapshot carries presence) exactly when the\n    // reducer declares presence fields — no runtime-inert members.\n    const { setPresence } = session as Partial<SessionClientPresence<P>>\n    const { presence } = snapshot as Partial<{ presence: PresenceMap<P> }>\n    return {\n      state: snapshot.state,\n      events: snapshot.events,\n      index: snapshot.index,\n      connection: snapshot.connection,\n      push: session.push,\n      reconnect: session.reconnect,\n      loadHistory: session.loadHistory,\n      history: snapshot.history,\n      ...(setPresence && presence ? { presence, setPresence } : {}),\n    } as UseSessionResult<D, S, P>\n  }, [snapshot, session])\n}\n\n/**\n * The standalone, provider-less hook — for apps whose components reach\n * sessions ad hoc (a sidebar of channel sessions, a user session read\n * from a menu). Takes the shared client and a session id; the handle\n * is identity-mapped, so every hook and provider mounting the same\n * session shares one runtime and one leased stream. Hydration is\n * app-owned: pass `hydrate` when your fetch lands; until then the\n * stream is held, and your data layer's loading state is the pending\n * state.\n */\nexport function useSession<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n>(\n  client: A2Client<D, S, P>,\n  sessionId: string,\n  options?: UseSessionOptions<S>,\n): UseSessionResult<D, S, P> {\n  const { participant, hydrate } = options ?? {}\n  const session = useMemo(\n    () =>\n      client.session(sessionId, {\n        ...(hydrate === undefined\n          ? {}\n          : { initialState: hydrate.state, initialIndex: hydrate.index }),\n        ...(participant === undefined ? {} : { participant }),\n      }),\n    [client, sessionId, hydrate, participant],\n  )\n  useSessionLifecycle(session, hydrate !== undefined)\n  return useSessionResult(session)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmLA,SAAgB,YAKd,SAC0C;CAC1C,MAAM,UAAU,cAA6C,IAAI;CACjE,MAAM,iBAQJ,YAAY,WAEN,WACA,MACA,cACA,cACA,eACA,gBAEA,QAAQ,OAAO,QAAQ,WAAW;EAChC;EACA;EACA,GAAI,kBAAkB,KAAA,IAAY,CAAC,IAAI,EAAE,cAAc;EACvD,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;CACrD,CAAC,WACI;EACL,MAAM,0BAAU,IAAI,IAA+B;EACnD,QACE,WACA,KACA,cACA,cACA,eACA,gBACG;GACH,IAAI,QAAQ,KAAA,GACV,MAAM,IAAI,UACR,+DACF;GAEF,IAAI,SAAS,QAAQ,IAAI,GAAG;GAC5B,IAAI,CAAC,QAAQ;IACX,SAAS,aAAa;KAAE,SAAS,QAAQ;KAAS;IAAI,CAAC;IACvD,QAAQ,IAAI,KAAK,MAAM;GACzB;GACA,OAAO,OAAO,QAAQ,WAAW;IAC/B;IACA;IACA,GAAI,kBAAkB,KAAA,IAAY,CAAC,IAAI,EAAE,cAAc;IACvD,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;GACrD,CAAC;EACH;CACF,EAAA,CAAG;CAET,SAAS,gBACP,OACc;EACd,MAAM,EACJ,WACA,cACA,cACA,eACA,gBACE;EACJ,MAAM,MAAM,SAAS,QAAQ,MAAM,MAAM,KAAA;EACzC,MAAM,SAAS,cAEX,eACE,WACA,KACA,cACA,cACA,eACA,WACF,GACF;GAAC;GAAW;GAAK;GAAc;GAAc;GAAe;EAAW,CACzE;EACA,oBAAoB,QAAQ,IAAI;EAChC,OAAO,cAAc,QAAQ,UAAU,EAAE,OAAO,OAAO,GAAG,MAAM,QAAQ;CAC1E;CAEA,SAAS,kBAA6C;EACpD,MAAM,SAAS,WAAW,OAAO;EACjC,IAAI,CAAC,QACH,MAAM,IAAI,MACR,iEACF;EAEF,OAAO,iBAAiB,MAAM;CAChC;CAEA,OAAO;EAAE;EAAiB,YAAY;CAAgB;AACxD;;;;;;;;;;AAaA,SAAS,oBACP,SACA,MACM;CACN,gBAAgB;EACd,IAAI,CAAC,MAAM;EACX,OAAO,QAAQ,QAAQ;CACzB,GAAG,CAAC,SAAS,IAAI,CAAC;AACpB;AAEA,SAAS,iBACP,SAC2B;CAC3B,MAAM,WAAqC,qBACzC,QAAQ,WACR,QAAQ,aACR,QAAQ,WACV;CACA,OAAO,cAAc;EAInB,MAAM,EAAE,gBAAgB;EACxB,MAAM,EAAE,aAAa;EACrB,OAAO;GACL,OAAO,SAAS;GAChB,QAAQ,SAAS;GACjB,OAAO,SAAS;GAChB,YAAY,SAAS;GACrB,MAAM,QAAQ;GACd,WAAW,QAAQ;GACnB,aAAa,QAAQ;GACrB,SAAS,SAAS;GAClB,GAAI,eAAe,WAAW;IAAE;IAAU;GAAY,IAAI,CAAC;EAC7D;CACF,GAAG,CAAC,UAAU,OAAO,CAAC;AACxB;;;;;;;;;;;AAYA,SAAgB,WAKd,QACA,WACA,SAC2B;CAC3B,MAAM,EAAE,aAAa,YAAY,WAAW,CAAC;CAC7C,MAAM,UAAU,cAEZ,OAAO,QAAQ,WAAW;EACxB,GAAI,YAAY,KAAA,IACZ,CAAC,IACD;GAAE,cAAc,QAAQ;GAAO,cAAc,QAAQ;EAAM;EAC/D,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;CACrD,CAAC,GACH;EAAC;EAAQ;EAAW;EAAS;CAAW,CAC1C;CACA,oBAAoB,SAAS,YAAY,KAAA,CAAS;CAClD,OAAO,iBAAiB,OAAO;AACjC"}
+{"version":3,"file":"react.js","names":[],"sources":["../src/react.ts"],"sourcesContent":["'use client'\n/**\n * experimental-a2/react — React bindings over experimental-a2/client.\n *\n * `createReact({ client })` is a factory (like createContext): call it\n * once in a `'use client'` module with a shared A2 client and export the\n * bound pair. Server components import `SessionProvider` from that module\n * as a client reference; client components import `useSession` from the\n * same file. The shared client also makes imperative pushes and provider\n * renders resolve the same live session. Everything is typed by the\n * reducer value — no type arguments, and nothing here ever touches the\n * machine module.\n *\n * The standalone `useSession(client, sessionId, options?)` is the\n * provider-less primitive for client-first apps: identity-mapped\n * handles, one leased stream per session, and an app-owned hydration\n * input — the hook holds the stream until the app hands it a\n * `{ state, index }` fold.\n */\n\nimport {\n  createContext,\n  createElement,\n  useContext,\n  useEffect,\n  useMemo,\n  useSyncExternalStore,\n  type ReactElement,\n  type ReactNode,\n} from 'react'\nimport {\n  createClient,\n  type A2Client,\n  type Connection,\n  type HistoryState,\n  type LoadHistoryOptions,\n  type PushResult,\n  type SessionClient,\n  type SessionClientPresence,\n  type SessionSnapshot,\n} from './client.ts'\nimport type {\n  AppendInput,\n  ContractEvent,\n  EventDefs,\n  PresenceDefs,\n  PresenceMap,\n  PresencePatch,\n  WithPresence,\n} from './contract.ts'\nimport type { Reducer } from './reducer.ts'\n\nexport type UseSessionOptions<S> = {\n  /** Overrides the client's `participant` for this session — for apps\n   * whose identity is only known at mount time. Bound once per\n   * session handle. */\n  participant?: string\n  /**\n   * The server fold this session mounts from: the `{ state, index }`\n   * pair `session.state(reducer)` returns, fetched by the app through\n   * its own route. Atomic on purpose — the fold and its frontier\n   * travel together or not at all. While `undefined` (the app's fetch\n   * has not landed), the hook holds the stream; when the value\n   * arrives, the session hydrates through the ordinary re-hydration\n   * seam and the stream connects at that frontier. To fold from the log's start\n   * deliberately, hand the fold's true starting point:\n   * `{ state: reducer.initialState, index: 0 }` — state at index 0 is\n   * the reducer's seed by definition, so the explicit replay needs no\n   * special vocabulary. There is no pending/ready echo on the result:\n   * whether the fold has been handed over is this option — the\n   * caller's own input — so the data layer's loading state IS the\n   * pending state.\n   */\n  hydrate?: { state: S; index: number } | undefined\n}\n\nexport type SessionProviderProps<D extends EventDefs, S> = {\n  /** Which session to subscribe to. */\n  sessionId: string\n  /** Base path of the route exposing GET (stream) and POST (push). */\n  api: string\n  /** The server-rendered fold — the first paint, no client JS needed. */\n  initialState: S\n  /** The fold's frontier — the stream resumes exactly there. */\n  initialIndex: number\n  /** Server-rendered event history through `initialIndex`. */\n  initialEvents?: ContractEvent<D>[]\n  /** Overrides the client's `participant` for this session — for apps\n   * whose identity is only known at mount time. */\n  participant?: string\n  children?: ReactNode\n}\n\nexport type BoundSessionProviderProps<D extends EventDefs, S> = Omit<\n  SessionProviderProps<D, S>,\n  'api'\n>\n\n/**\n * The presence members of the hook result — intersected in via\n * `WithPresence`, so they exist exactly when the contract declares\n * presence fields (the reducer is the client's typed handle on it).\n */\nexport type UseSessionPresence<P extends PresenceDefs> = {\n  /** The replicated presence map, this client included (local echo). */\n  presence: PresenceMap<P>\n  /**\n   * Fire-and-forget: validated locally, echoed into the map\n   * immediately, coalesced on the wire to a fixed cadence (a leading\n   * send immediately, then at most one merged send per interval;\n   * later values win per field), stamped with the frontier at send\n   * time as `seen`. Requires the provider's `participant`.\n   */\n  setPresence: (values: PresencePatch<P>['values']) => void\n}\n\nexport type UseSessionResult<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = WithPresence<P, UseSessionPresence<P>> & {\n  /** The live view, folded through the shared reducer. */\n  state: S\n  /** The raw event feed — observed, seeded, or backscrolled. */\n  events: ContractEvent<D>[]\n  /** The stream frontier — `lastSeenIndex` for cancellation. */\n  index: number\n  /**\n   * The connection, as a discriminated union — `error` exists only\n   * while disconnected; \"reconnecting…\" is\n   * `status === 'connecting' && reconnects > 0`.\n   */\n  connection: Connection\n  /**\n   * Typed optimistic append. Awaiting it gives the server ack;\n   * `.confirmed` resolves when the live stream has delivered the batch\n   * back. Rejects with the server's A2Error codes.\n   */\n  push: (...events: AppendInput<D>[]) => PushResult<D>\n  /** Restart the live subscription without resetting its state or cursor. */\n  reconnect: () => void\n  /**\n   * Backscroll: fetch a bounded slice of older events into `events`.\n   * Defaults page backward 50 at a time from the oldest loaded event.\n   * Display data only — `state` and the optimistic overlay never move.\n   */\n  loadHistory: (options?: LoadHistoryOptions) => Promise<ContractEvent<D>[]>\n  /** Backscroll progress: `complete` means the feed reaches index 1. */\n  history: HistoryState\n}\n\nexport type A2React<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n> = {\n  SessionProvider: (props: SessionProviderProps<D, S>) => ReactElement\n  useSession: () => UseSessionResult<D, V, P>\n}\n\nexport type BoundA2React<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n> = {\n  SessionProvider: (props: BoundSessionProviderProps<D, S>) => ReactElement\n  useSession: () => UseSessionResult<D, V, P>\n}\n\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n>(options: { client: A2Client<D, S, P, V> }): BoundA2React<D, S, P, V>\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n>(options: { reducer: Reducer<D, S, P, V> }): A2React<D, S, P, V>\nexport function createReact<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n>(\n  options: { client: A2Client<D, S, P, V> } | { reducer: Reducer<D, S, P, V> },\n): BoundA2React<D, S, P, V> | A2React<D, S, P, V> {\n  const Context = createContext<SessionClient<D, S, P, V> | null>(null)\n  const resolveSession: (\n    sessionId: string,\n    api: string | undefined,\n    initialState: S,\n    initialIndex: number,\n    initialEvents: ContractEvent<D>[] | undefined,\n    participant: string | undefined,\n  ) => SessionClient<D, S, P, V> =\n    'client' in options\n      ? (\n          sessionId,\n          _api,\n          initialState,\n          initialIndex,\n          initialEvents,\n          participant,\n        ) =>\n          options.client.session(sessionId, {\n            initialState,\n            initialIndex,\n            ...(initialEvents === undefined ? {} : { initialEvents }),\n            ...(participant === undefined ? {} : { participant }),\n          })\n      : (() => {\n          const clients = new Map<string, A2Client<D, S, P, V>>()\n          return (\n            sessionId: string,\n            api: string | undefined,\n            initialState: S,\n            initialIndex: number,\n            initialEvents: ContractEvent<D>[] | undefined,\n            participant: string | undefined,\n          ) => {\n            if (api === undefined) {\n              throw new TypeError(\n                'SessionProvider requires api when createReact binds a reducer',\n              )\n            }\n            let client = clients.get(api)\n            if (!client) {\n              client = createClient({ reducer: options.reducer, api })\n              clients.set(api, client)\n            }\n            return client.session(sessionId, {\n              initialState,\n              initialIndex,\n              ...(initialEvents === undefined ? {} : { initialEvents }),\n              ...(participant === undefined ? {} : { participant }),\n            })\n          }\n        })()\n\n  function SessionProvider(\n    props: SessionProviderProps<D, S> | BoundSessionProviderProps<D, S>,\n  ): ReactElement {\n    const {\n      sessionId,\n      initialState,\n      initialIndex,\n      initialEvents,\n      participant,\n    } = props\n    const api = 'api' in props ? props.api : undefined\n    const client = useMemo(\n      () =>\n        resolveSession(\n          sessionId,\n          api,\n          initialState,\n          initialIndex,\n          initialEvents,\n          participant,\n        ),\n      [sessionId, api, initialState, initialIndex, initialEvents, participant],\n    )\n    useSessionLifecycle(client, true)\n    return createElement(Context.Provider, { value: client }, props.children)\n  }\n\n  function useBoundSession(): UseSessionResult<D, V, P> {\n    const client = useContext(Context)\n    if (!client) {\n      throw new Error(\n        'useSession must be rendered inside its matching SessionProvider',\n      )\n    }\n    return useSessionResult(client)\n  }\n\n  return { SessionProvider, useSession: useBoundSession }\n}\n\n// ── the shared session lifecycle ───────────────────────────────\n\n/**\n * Hold a stream lease while mounted and `live` — the client refcounts\n * leases per handle, so however many providers and hooks mount one\n * session, the first connects and the last release closes\n * (StrictMode-safe: the lease is retaken on remount). A standalone\n * hook without a `hydrate` value passes `live: false` and holds the\n * stream — connecting an unhydrated session would replay the whole\n * log, and the library never picks the expensive path silently.\n */\nfunction useSessionLifecycle<D extends EventDefs, S, P extends PresenceDefs, V>(\n  session: SessionClient<D, S, P, V>,\n  live: boolean,\n): void {\n  useEffect(() => {\n    if (!live) return\n    return session.connect()\n  }, [session, live])\n}\n\nfunction useSessionResult<D extends EventDefs, S, P extends PresenceDefs, V>(\n  session: SessionClient<D, S, P, V>,\n): UseSessionResult<D, V, P> {\n  const snapshot: SessionSnapshot<D, V, P> = useSyncExternalStore(\n    session.subscribe,\n    session.getSnapshot,\n    session.getSnapshot,\n  )\n  return useMemo(() => {\n    // Runtime mirror of the WithPresence surface: the client attaches\n    // setPresence (and the snapshot carries presence) exactly when the\n    // reducer declares presence fields — no runtime-inert members.\n    const { setPresence } = session as Partial<SessionClientPresence<P>>\n    const { presence } = snapshot as Partial<{ presence: PresenceMap<P> }>\n    return {\n      state: snapshot.state,\n      events: snapshot.events,\n      index: snapshot.index,\n      connection: snapshot.connection,\n      push: session.push,\n      reconnect: session.reconnect,\n      loadHistory: session.loadHistory,\n      history: snapshot.history,\n      ...(setPresence && presence ? { presence, setPresence } : {}),\n    } as UseSessionResult<D, V, P>\n  }, [snapshot, session])\n}\n\n/**\n * The standalone, provider-less hook — for apps whose components reach\n * sessions ad hoc (a sidebar of channel sessions, a user session read\n * from a menu). Takes the shared client and a session id; the handle\n * is identity-mapped, so every hook and provider mounting the same\n * session shares one runtime and one leased stream. Hydration is\n * app-owned: pass `hydrate` when your fetch lands; until then the\n * stream is held, and your data layer's loading state is the pending\n * state.\n */\nexport function useSession<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n>(\n  client: A2Client<D, S, P, V>,\n  sessionId: string,\n  options?: UseSessionOptions<S>,\n): UseSessionResult<D, V, P> {\n  const { participant, hydrate } = options ?? {}\n  const session = useMemo(\n    () =>\n      client.session(sessionId, {\n        ...(hydrate === undefined\n          ? {}\n          : { initialState: hydrate.state, initialIndex: hydrate.index }),\n        ...(participant === undefined ? {} : { participant }),\n      }),\n    [client, sessionId, hydrate, participant],\n  )\n  useSessionLifecycle(session, hydrate !== undefined)\n  return useSessionResult(session)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuLA,SAAgB,YAMd,SACgD;CAChD,MAAM,UAAU,cAAgD,IAAI;CACpE,MAAM,iBAQJ,YAAY,WAEN,WACA,MACA,cACA,cACA,eACA,gBAEA,QAAQ,OAAO,QAAQ,WAAW;EAChC;EACA;EACA,GAAI,kBAAkB,KAAA,IAAY,CAAC,IAAI,EAAE,cAAc;EACvD,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;CACrD,CAAC,WACI;EACL,MAAM,0BAAU,IAAI,IAAkC;EACtD,QACE,WACA,KACA,cACA,cACA,eACA,gBACG;GACH,IAAI,QAAQ,KAAA,GACV,MAAM,IAAI,UACR,+DACF;GAEF,IAAI,SAAS,QAAQ,IAAI,GAAG;GAC5B,IAAI,CAAC,QAAQ;IACX,SAAS,aAAa;KAAE,SAAS,QAAQ;KAAS;IAAI,CAAC;IACvD,QAAQ,IAAI,KAAK,MAAM;GACzB;GACA,OAAO,OAAO,QAAQ,WAAW;IAC/B;IACA;IACA,GAAI,kBAAkB,KAAA,IAAY,CAAC,IAAI,EAAE,cAAc;IACvD,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;GACrD,CAAC;EACH;CACF,EAAA,CAAG;CAET,SAAS,gBACP,OACc;EACd,MAAM,EACJ,WACA,cACA,cACA,eACA,gBACE;EACJ,MAAM,MAAM,SAAS,QAAQ,MAAM,MAAM,KAAA;EACzC,MAAM,SAAS,cAEX,eACE,WACA,KACA,cACA,cACA,eACA,WACF,GACF;GAAC;GAAW;GAAK;GAAc;GAAc;GAAe;EAAW,CACzE;EACA,oBAAoB,QAAQ,IAAI;EAChC,OAAO,cAAc,QAAQ,UAAU,EAAE,OAAO,OAAO,GAAG,MAAM,QAAQ;CAC1E;CAEA,SAAS,kBAA6C;EACpD,MAAM,SAAS,WAAW,OAAO;EACjC,IAAI,CAAC,QACH,MAAM,IAAI,MACR,iEACF;EAEF,OAAO,iBAAiB,MAAM;CAChC;CAEA,OAAO;EAAE;EAAiB,YAAY;CAAgB;AACxD;;;;;;;;;;AAaA,SAAS,oBACP,SACA,MACM;CACN,gBAAgB;EACd,IAAI,CAAC,MAAM;EACX,OAAO,QAAQ,QAAQ;CACzB,GAAG,CAAC,SAAS,IAAI,CAAC;AACpB;AAEA,SAAS,iBACP,SAC2B;CAC3B,MAAM,WAAqC,qBACzC,QAAQ,WACR,QAAQ,aACR,QAAQ,WACV;CACA,OAAO,cAAc;EAInB,MAAM,EAAE,gBAAgB;EACxB,MAAM,EAAE,aAAa;EACrB,OAAO;GACL,OAAO,SAAS;GAChB,QAAQ,SAAS;GACjB,OAAO,SAAS;GAChB,YAAY,SAAS;GACrB,MAAM,QAAQ;GACd,WAAW,QAAQ;GACnB,aAAa,QAAQ;GACrB,SAAS,SAAS;GAClB,GAAI,eAAe,WAAW;IAAE;IAAU;GAAY,IAAI,CAAC;EAC7D;CACF,GAAG,CAAC,UAAU,OAAO,CAAC;AACxB;;;;;;;;;;;AAYA,SAAgB,WAMd,QACA,WACA,SAC2B;CAC3B,MAAM,EAAE,aAAa,YAAY,WAAW,CAAC;CAC7C,MAAM,UAAU,cAEZ,OAAO,QAAQ,WAAW;EACxB,GAAI,YAAY,KAAA,IACZ,CAAC,IACD;GAAE,cAAc,QAAQ;GAAO,cAAc,QAAQ;EAAM;EAC/D,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;CACrD,CAAC,GACH;EAAC;EAAQ;EAAW;EAAS;CAAW,CAC1C;CACA,oBAAoB,SAAS,YAAY,KAAA,CAAS;CAClD,OAAO,iBAAiB,OAAO;AACjC"}

package/dist/reducer-DEMjEY_O.js.map

@@ -1 +1 @@
-{"version":3,"file":"reducer-DEMjEY_O.js","names":[],"sources":["../src/reducer.ts"],"sourcesContent":["import type { ContractEvent, EventDefs, PresenceDefs } from './contract.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\nimport { validateSync } from './validate.ts'\n\nexport const clientStateProjection: unique symbol = Symbol(\n  'a2.clientStateProjection',\n)\n\n/**\n * A pure fold over a session's events — `(state, event) => state` —\n * derived from a contract via `contract.reducer(options).fold(fn)`.\n *\n * The name is the reducer's identity. Cached folds (server snapshots,\n * the browser cache) are keyed by it, which makes it the invalidation\n * knob too: changed the fold's logic? Change the name. Snapshots under\n * the old name are ignored and the next read refolds from raw events.\n * See docs/concepts/04-state.mdx.\n */\nexport type Reducer<\n  D extends EventDefs = EventDefs,\n  S = unknown,\n  P extends PresenceDefs = Record<never, never>,\n> = {\n  /** Identity and cache key. Rename when the fold's logic changes. */\n  readonly name: string\n  /** The contract's vocabulary — types every event in the fold. */\n  readonly events: Readonly<D>\n  /**\n   * The contract's presence vocabulary — carried because the reducer\n   * is the client's typed handle on the contract. The fold never sees\n   * presence.\n   */\n  readonly presence: Readonly<P>\n  readonly fold: (state: S, event: ContractEvent<D>) => S\n  readonly initialState: S\n  /** Internal read-side projection. Never used as a fold input or persisted. */\n  readonly [clientStateProjection]?: (state: S) => S\n  /**\n   * When present: `initialState` was validated against it at\n   * definition, and any cached fold a2 rehydrates (server snapshots,\n   * the browser cache) is checked against it — failing snapshots are\n   * discarded and refolded, catching shape drift a stale name can't.\n   */\n  readonly stateSchema: StandardSchemaV1<unknown, S> | undefined\n}\n\n/** The second step of `contract.reducer` — see the method's doc. */\nexport type ReducerBuilder<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = {\n  fold(fold: (state: S, event: ContractEvent<D>) => S): Reducer<D, S, P>\n}\n\n/** Internal — reducers are created through `contract.reducer(...).fold(...)`. */\nexport function makeReducerBuilder<\n  D extends EventDefs,\n  P extends PresenceDefs,\n  Seed,\n  S,\n>(\n  events: Readonly<D>,\n  presence: Readonly<P>,\n  options: {\n    name: string\n    initialState: Seed\n    stateSchema?: StandardSchemaV1<Seed, S>\n  },\n): ReducerBuilder<D, S, P> {\n  const { name } = options\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new TypeError(\n      'reducer name must be a non-empty string — it identifies the reducer and keys cached snapshots',\n    )\n  }\n\n  // Without a schema, S = Seed (the type parameter default), so the\n  // seed is the state. With one, the seed is the schema's input and the\n  // validated output (defaults applied) becomes the fold's actual seed.\n  let initialState = options.initialState as unknown as S\n  if (options.stateSchema) {\n    const result = validateSync(\n      options.stateSchema,\n      options.initialState,\n      'the stateSchema',\n    )\n    if (result.issues) {\n      throw new TypeError(\n        `reducer initialState does not match its stateSchema: ${result.issues\n          .map((issue) => issue.message)\n          .join('; ')}`,\n      )\n    }\n    initialState = result.value as S\n  }\n\n  return {\n    fold(fold) {\n      if (typeof fold !== 'function') {\n        throw new TypeError('reducer fold must be a function')\n      }\n      return {\n        name,\n        events,\n        presence,\n        fold,\n        initialState,\n        stateSchema: options.stateSchema as\n          StandardSchemaV1<unknown, S> | undefined,\n      }\n    },\n  }\n}\n"],"mappings":";;AAIA,MAAa,wBAAuC,OAClD,0BACF;;AAkDA,SAAgB,mBAMd,QACA,UACA,SAKyB;CACzB,MAAM,EAAE,SAAS;CACjB,IAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAC9C,MAAM,IAAI,UACR,+FACF;CAMF,IAAI,eAAe,QAAQ;CAC3B,IAAI,QAAQ,aAAa;EACvB,MAAM,SAAS,aACb,QAAQ,aACR,QAAQ,cACR,iBACF;EACA,IAAI,OAAO,QACT,MAAM,IAAI,UACR,wDAAwD,OAAO,OAC5D,KAAK,UAAU,MAAM,OAAO,CAAC,CAC7B,KAAK,IAAI,GACd;EAEF,eAAe,OAAO;CACxB;CAEA,OAAO,EACL,KAAK,MAAM;EACT,IAAI,OAAO,SAAS,YAClB,MAAM,IAAI,UAAU,iCAAiC;EAEvD,OAAO;GACL;GACA;GACA;GACA;GACA;GACA,aAAa,QAAQ;EAEvB;CACF,EACF;AACF"}
+{"version":3,"file":"reducer-DEMjEY_O.js","names":[],"sources":["../src/reducer.ts"],"sourcesContent":["import type { ContractEvent, EventDefs, PresenceDefs } from './contract.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\nimport { validateSync } from './validate.ts'\n\nexport const clientStateProjection: unique symbol = Symbol(\n  'a2.clientStateProjection',\n)\n\n/**\n * A pure fold over a session's events — `(state, event) => state` —\n * derived from a contract via `contract.reducer(options).fold(fn)`.\n *\n * The name is the reducer's identity. Cached folds (server snapshots,\n * the browser cache) are keyed by it, which makes it the invalidation\n * knob too: changed the fold's logic? Change the name. Snapshots under\n * the old name are ignored and the next read refolds from raw events.\n * See docs/concepts/04-state.mdx.\n */\nexport type Reducer<\n  D extends EventDefs = EventDefs,\n  S = unknown,\n  P extends PresenceDefs = Record<never, never>,\n  V = S,\n> = {\n  /** Identity and cache key. Rename when the fold's logic changes. */\n  readonly name: string\n  /** The contract's vocabulary — types every event in the fold. */\n  readonly events: Readonly<D>\n  /**\n   * The contract's presence vocabulary — carried because the reducer\n   * is the client's typed handle on the contract. The fold never sees\n   * presence.\n   */\n  readonly presence: Readonly<P>\n  readonly fold: (state: S, event: ContractEvent<D>) => S\n  readonly initialState: S\n  /** Internal read-side projection. Never used as a fold input or persisted. */\n  readonly [clientStateProjection]?: (state: S) => V\n  /**\n   * When present: `initialState` was validated against it at\n   * definition, and any cached fold a2 rehydrates (server snapshots,\n   * the browser cache) is checked against it — failing snapshots are\n   * discarded and refolded, catching shape drift a stale name can't.\n   */\n  readonly stateSchema: StandardSchemaV1<unknown, S> | undefined\n}\n\n/** The second step of `contract.reducer` — see the method's doc. */\nexport type ReducerBuilder<\n  D extends EventDefs,\n  S,\n  P extends PresenceDefs = Record<never, never>,\n> = {\n  fold(fold: (state: S, event: ContractEvent<D>) => S): Reducer<D, S, P>\n}\n\n/** Internal — reducers are created through `contract.reducer(...).fold(...)`. */\nexport function makeReducerBuilder<\n  D extends EventDefs,\n  P extends PresenceDefs,\n  Seed,\n  S,\n>(\n  events: Readonly<D>,\n  presence: Readonly<P>,\n  options: {\n    name: string\n    initialState: Seed\n    stateSchema?: StandardSchemaV1<Seed, S>\n  },\n): ReducerBuilder<D, S, P> {\n  const { name } = options\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new TypeError(\n      'reducer name must be a non-empty string — it identifies the reducer and keys cached snapshots',\n    )\n  }\n\n  // Without a schema, S = Seed (the type parameter default), so the\n  // seed is the state. With one, the seed is the schema's input and the\n  // validated output (defaults applied) becomes the fold's actual seed.\n  let initialState = options.initialState as unknown as S\n  if (options.stateSchema) {\n    const result = validateSync(\n      options.stateSchema,\n      options.initialState,\n      'the stateSchema',\n    )\n    if (result.issues) {\n      throw new TypeError(\n        `reducer initialState does not match its stateSchema: ${result.issues\n          .map((issue) => issue.message)\n          .join('; ')}`,\n      )\n    }\n    initialState = result.value as S\n  }\n\n  return {\n    fold(fold) {\n      if (typeof fold !== 'function') {\n        throw new TypeError('reducer fold must be a function')\n      }\n      return {\n        name,\n        events,\n        presence,\n        fold,\n        initialState,\n        stateSchema: options.stateSchema as\n          StandardSchemaV1<unknown, S> | undefined,\n      }\n    },\n  }\n}\n"],"mappings":";;AAIA,MAAa,wBAAuC,OAClD,0BACF;;AAmDA,SAAgB,mBAMd,QACA,UACA,SAKyB;CACzB,MAAM,EAAE,SAAS;CACjB,IAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAC9C,MAAM,IAAI,UACR,+FACF;CAMF,IAAI,eAAe,QAAQ;CAC3B,IAAI,QAAQ,aAAa;EACvB,MAAM,SAAS,aACb,QAAQ,aACR,QAAQ,cACR,iBACF;EACA,IAAI,OAAO,QACT,MAAM,IAAI,UACR,wDAAwD,OAAO,OAC5D,KAAK,UAAU,MAAM,OAAO,CAAC,CAC7B,KAAK,IAAI,GACd;EAEF,eAAe,OAAO;CACxB;CAEA,OAAO,EACL,KAAK,MAAM;EACT,IAAI,OAAO,SAAS,YAClB,MAAM,IAAI,UAAU,iCAAiC;EAEvD,OAAO;GACL;GACA;GACA;GACA;GACA;GACA,aAAa,QAAQ;EAEvB;CACF,EACF;AACF"}

package/dist/{reducer-BcS9VDKC.d.ts → reducer-otzHjuJj.d.ts}

@@ -190,7 +190,7 @@ declare const clientStateProjection: unique symbol;
  * the old name are ignored and the next read refolds from raw events.
  * See docs/concepts/04-state.mdx.
  */
-type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDefs = Record<never, never>> = {
+type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDefs = Record<never, never>, V = S> = {
   /** Identity and cache key. Rename when the fold's logic changes. */
   readonly name: string;
   /** The contract's vocabulary — types every event in the fold. */
@@ -204,7 +204,7 @@ type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDef
   readonly fold: (state: S, event: ContractEvent<D>) => S;
   readonly initialState: S;
   /** Internal read-side projection. Never used as a fold input or persisted. */
-  readonly [clientStateProjection]?: (state: S) => S;
+  readonly [clientStateProjection]?: (state: S) => V;
   /**
    * When present: `initialState` was validated against it at
    * definition, and any cached fold a2 rehydrates (server snapshots,
@@ -219,4 +219,4 @@ type ReducerBuilder<D extends EventDefs, S, P extends PresenceDefs = Record<neve
 };
 //#endregion
 export { ContractEvent as a, PresenceDefs as c, PresenceSnapshot as d, ReducerOptions as f, StandardSchemaV1 as h, Contract as i, PresenceMap as l, contract as m, ReducerBuilder as n, EventBatchFactory as o, WithPresence as p, AppendInput as r, EventDefs as s, Reducer as t, PresencePatch as u };
-//# sourceMappingURL=reducer-BcS9VDKC.d.ts.map
+//# sourceMappingURL=reducer-otzHjuJj.d.ts.map

package/dist/{reducer-BcS9VDKC.d.ts.map → reducer-otzHjuJj.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"reducer-BcS9VDKC.d.ts","names":[],"sources":["../src/standard-schema.ts","../src/contract.ts","../src/reducer.ts"],"mappings":";;;;;;;;UAQiB,iBAAiB,iBAAiB,SAAS;;WAEjD,aAAa,iBAAiB,MAAM,OAAO;;kBAG7B;;mBAEN,MAAM,iBAAiB,SAAS;;aAEtC;;aAEA;;aAEA,WACP,mBACG,OAAO,UAAU,QAAQ,OAAO;;aAE5B,QAAQ,MAAM,OAAO;;;cAIpB,OAAO,UAAU,cAAc,UAAU;;mBAGpC,cAAc;;aAEpB,OAAO;;aAEP;;;mBAIM;;aAEN,QAAQ,cAAc;;;mBAIhB;;aAEN;;aAEA,OAAO,cAAc,cAAc;;;mBAI7B;;aAEN,KAAK;;;mBAIC,MAAM,iBAAiB,SAAS;;aAEtC,OAAO;;aAEP,QAAQ;;;cAIP,WAAW,eAAe,oBAAoB,YACxD;;cAIU,YAAY,eAAe,oBAAoB,YACzD;;;;;KC1DQ,YAAY,eAAe;;KAG3B,eAAe,eAAe;;KAG9B,cACV,UAAU,WACV,gBAAgB,mBAAmB,iBAElC,WAAW;EACV;EACA,MAAM;EACN,SAAS,iBAAiB,YAAY,EAAE;EACxC;EACA;EACA,WAAW;KAEb;;KAGU,YAAY,UAAU,gBAC/B,WAAW;EACV,MAAM;EACN,SAAS,iBAAiB,WAAW,EAAE;EACvC;WAEI;KAEI,kBAAkB,UAAU,oBAChC,mBAAmB,YAAY,SAElC,QAAQ,MACR;;;;;;KAOO,cAAc,UAAU,eAAe;EACjD;EACA,WACG,WAAW,cAAc,iBAAiB,YAAY,EAAE;EAE3D;EACA,IAAI;;;;;;;;KASM,YAAY,UAAU,eAAe;GAE5C,yBAAA,WAAW;IACV,OAAO,iBAAiB,YAAY,EAAE;IACtC;IACA,IAAI;;;;;;;;KAUE,iBAAiB,UAAU,eAAe;EACpD,UAAU,YAAY;;;;;;;KAQZ,aACV,UAAU,cACV,iBACQ,4BAA4B;KAE1B,eAAe,MAAM;;;;;EAK/B;;;;;;EAMA,cAAc;;;;;;EAMd,cAAc,iBAAiB,MAAM;;KAG3B,SACV,UAAU,YAAY,WACtB,UAAU,eAAe;;WAGhB;;WAEA,QAAQ,SAAS;;WAEjB,UAAU,SAAS;;WAEnB,OAAO,kBAAkB;;;;;;;;;;;EAWlC,QAAQ,MAAM,IAAI,MAChB,SAAS,eAAe,MAAM,KAC7B,eAAe,GAAG,GAAG;;;;;;;iBAQV,SACd,UAAU,WACV,UAAU,eAAe,sBACzB;;EAEA;;EAEA,QAAQ;;;;;;EAMR,WAAW;IACT,SAAS,GAAG;;;cClKH;;;;;;;;;;;KAcD,QACV,UAAU,YAAY,WACtB,aACA,UAAU,eAAe;;WAGhB;;WAEA,QAAQ,SAAS;;;;;;WAMjB,UAAU,SAAS;WACnB,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO;WAC7C,cAAc;;YAEb,0BAA0B,OAAO,MAAM;;;;;;;WAOxC,aAAa,0BAA0B;;;KAItC,eACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,KAAK,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO,IAAI,QAAQ,GAAG,GAAG"}
+{"version":3,"file":"reducer-otzHjuJj.d.ts","names":[],"sources":["../src/standard-schema.ts","../src/contract.ts","../src/reducer.ts"],"mappings":";;;;;;;;UAQiB,iBAAiB,iBAAiB,SAAS;;WAEjD,aAAa,iBAAiB,MAAM,OAAO;;kBAG7B;;mBAEN,MAAM,iBAAiB,SAAS;;aAEtC;;aAEA;;aAEA,WACP,mBACG,OAAO,UAAU,QAAQ,OAAO;;aAE5B,QAAQ,MAAM,OAAO;;;cAIpB,OAAO,UAAU,cAAc,UAAU;;mBAGpC,cAAc;;aAEpB,OAAO;;aAEP;;;mBAIM;;aAEN,QAAQ,cAAc;;;mBAIhB;;aAEN;;aAEA,OAAO,cAAc,cAAc;;;mBAI7B;;aAEN,KAAK;;;mBAIC,MAAM,iBAAiB,SAAS;;aAEtC,OAAO;;aAEP,QAAQ;;;cAIP,WAAW,eAAe,oBAAoB,YACxD;;cAIU,YAAY,eAAe,oBAAoB,YACzD;;;;;KC1DQ,YAAY,eAAe;;KAG3B,eAAe,eAAe;;KAG9B,cACV,UAAU,WACV,gBAAgB,mBAAmB,iBAElC,WAAW;EACV;EACA,MAAM;EACN,SAAS,iBAAiB,YAAY,EAAE;EACxC;EACA;EACA,WAAW;KAEb;;KAGU,YAAY,UAAU,gBAC/B,WAAW;EACV,MAAM;EACN,SAAS,iBAAiB,WAAW,EAAE;EACvC;WAEI;KAEI,kBAAkB,UAAU,oBAChC,mBAAmB,YAAY,SAElC,QAAQ,MACR;;;;;;KAOO,cAAc,UAAU,eAAe;EACjD;EACA,WACG,WAAW,cAAc,iBAAiB,YAAY,EAAE;EAE3D;EACA,IAAI;;;;;;;;KASM,YAAY,UAAU,eAAe;GAE5C,yBAAA,WAAW;IACV,OAAO,iBAAiB,YAAY,EAAE;IACtC;IACA,IAAI;;;;;;;;KAUE,iBAAiB,UAAU,eAAe;EACpD,UAAU,YAAY;;;;;;;KAQZ,aACV,UAAU,cACV,iBACQ,4BAA4B;KAE1B,eAAe,MAAM;;;;;EAK/B;;;;;;EAMA,cAAc;;;;;;EAMd,cAAc,iBAAiB,MAAM;;KAG3B,SACV,UAAU,YAAY,WACtB,UAAU,eAAe;;WAGhB;;WAEA,QAAQ,SAAS;;WAEjB,UAAU,SAAS;;WAEnB,OAAO,kBAAkB;;;;;;;;;;;EAWlC,QAAQ,MAAM,IAAI,MAChB,SAAS,eAAe,MAAM,KAC7B,eAAe,GAAG,GAAG;;;;;;;iBAQV,SACd,UAAU,WACV,UAAU,eAAe,sBACzB;;EAEA;;EAEA,QAAQ;;;;;;EAMR,WAAW;IACT,SAAS,GAAG;;;cClKH;;;;;;;;;;;KAcD,QACV,UAAU,YAAY,WACtB,aACA,UAAU,eAAe,sBACzB,IAAI;;WAGK;;WAEA,QAAQ,SAAS;;;;;;WAMjB,UAAU,SAAS;WACnB,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO;WAC7C,cAAc;;YAEb,0BAA0B,OAAO,MAAM;;;;;;;WAOxC,aAAa,0BAA0B;;;KAItC,eACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,KAAK,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO,IAAI,QAAQ,GAAG,GAAG"}

package/dist/scheduler-qstash.d.ts

@@ -1,5 +1,5 @@
-import { r as Clock } from "./store-D_yhNdPz.js";
-import { E as SchedulerTask, t as A2Scheduler } from "./server-Bp5Nd1pF.js";
+import { r as Clock } from "./store-DyZM6fS5.js";
+import { E as SchedulerTask, t as A2Scheduler } from "./server-DbD7IJVK.js";
 //#region src/scheduler-qstash.d.ts
 type QStashStoreOutage = {
   version: 1;

package/dist/scheduler-qstash.js

@@ -1,7 +1,7 @@
 import { t as A2Error } from "./errors-DCk6ch5n.js";
 import { d as classifySchedulerSendFailure, g as serverInternals, t as DRAIN_TIMINGS, u as assertSchedulerTargets } from "./internal-Dq2qYxou.js";
 import { n as platformVercelOidcToken } from "./platform-B4TnJtWu.js";
-import { n as deliverSchedulerAppend } from "./server-CjJSGcF7.js";
+import { n as deliverSchedulerAppend } from "./server-BD5ckxZb.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./store-N8PXxDAS.js";
 import { t as normalizeSchedulerTask } from "./scheduler-task-BpzhPnRS.js";

package/dist/scheduler-vercel.d.ts

@@ -1,5 +1,5 @@
-import { r as Clock } from "./store-D_yhNdPz.js";
-import { E as SchedulerTask, t as A2Scheduler } from "./server-Bp5Nd1pF.js";
+import { r as Clock } from "./store-DyZM6fS5.js";
+import { E as SchedulerTask, t as A2Scheduler } from "./server-DbD7IJVK.js";
 //#region src/scheduler-vercel.d.ts
 /**
  * The "not settled yet" signal for a stalled handler — an expected state,

package/dist/scheduler-vercel.js

@@ -1,5 +1,5 @@
 import { d as classifySchedulerSendFailure, g as serverInternals, t as DRAIN_TIMINGS, u as assertSchedulerTargets } from "./internal-Dq2qYxou.js";
-import { n as deliverSchedulerAppend } from "./server-CjJSGcF7.js";
+import { n as deliverSchedulerAppend } from "./server-BD5ckxZb.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./store-N8PXxDAS.js";
 import { t as normalizeSchedulerTask } from "./scheduler-task-BpzhPnRS.js";

package/dist/{server-CjJSGcF7.js → server-BD5ckxZb.js}

@@ -1174,22 +1174,14 @@ function createServer(options) {
 			throw asStoreUnavailable(err);
 		}
 	};
-	const readCachedState = async (store, sessionId, reducerName, throughIndex, snapshotThroughIndex) => {
+	const readStoreState = async (store, sessionId, reducerName, throughIndex, snapshotThroughIndex) => {
 		try {
 			return await store.readState(nsId(sessionId), reducerName, throughIndex === void 0 && snapshotThroughIndex === void 0 ? void 0 : {
 				...throughIndex === void 0 ? {} : { throughIndex },
 				...snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex }
 			});
-		} catch {
-			try {
-				return {
-					headIndex: null,
-					snapshot: null,
-					events: await store.read(nsId(sessionId), throughIndex === void 0 ? void 0 : { throughIndex })
-				};
-			} catch (err) {
-				throw asStoreUnavailable(err);
-			}
+		} catch (err) {
+			throw asStoreUnavailable(err);
 		}
 	};
 	const planStateReads = (batch) => {
@@ -1289,7 +1281,29 @@ function createServer(options) {
 				if (write.pinEventIndexes.size > 0) snapshot.pinEventIndexes = [...write.pinEventIndexes];
 				snapshots.push(snapshot);
 			}
-			const persistence = Promise.resolve().then(() => store.putSnapshots(nsId(plan.sessionId), reducer.name, snapshots)).catch(() => {});
+			const persistence = Promise.resolve().then(() => telemetry.span("a2.snapshot", {
+				"a2.contract": name,
+				"a2.session_id": plan.sessionId,
+				"a2.snapshot.reducer": reducer.name,
+				"a2.snapshot.index": snapshots.at(-1).index,
+				"a2.snapshot.count": snapshots.length
+			}, async (span) => {
+				try {
+					await store.putSnapshots(nsId(plan.sessionId), reducer.name, snapshots);
+				} catch (error) {
+					try {
+						span.recordError(error);
+					} catch (telemetryError) {
+						throw new AggregateError([error, telemetryError], "Snapshot write and error reporting failed", { cause: telemetryError });
+					}
+				}
+			})).catch((error) => {
+				console.error("[a2] error in a2.snapshot telemetry", {
+					sessionId: plan.sessionId,
+					reducer: reducer.name,
+					index: snapshots.at(-1).index
+				}, error);
+			});
 			track(persistence);
 			platformWaitUntil(persistence);
 		}
@@ -1303,21 +1317,20 @@ function createServer(options) {
 				sessionId: nsId(plan.sessionId),
 				...plan.throughIndex === void 0 ? {} : { throughIndex: plan.throughIndex },
 				...plan.snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex: plan.snapshotThroughIndex }
-			})), reducer.name) : await Promise.all(plans.map((plan) => readCachedState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex)));
-		} catch {
-			reads = null;
-		}
-		if (!reads || reads.length !== plans.length) try {
-			reads = await Promise.all(plans.map((plan) => readCachedState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex)));
-		} catch (err) {
-			for (const entry of batch) entry.reject(err);
+			})), reducer.name) : plans.map((plan) => readStoreState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex));
+			if (reads.length !== plans.length) throw new TypeError("store.readStates must return one result per request");
+		} catch (error) {
+			const failure = asStoreUnavailable(error);
+			for (const entry of batch) entry.reject(failure);
 			return;
 		}
-		for (const [position, plan] of plans.entries()) try {
-			await foldStatePlan(store, reducer, plan, reads[position]);
-		} catch (err) {
-			for (const entry of plan.entries) entry.reject(err);
-		}
+		await Promise.all(plans.map(async (plan, position) => {
+			try {
+				await foldStatePlan(store, reducer, plan, await reads[position]);
+			} catch (error) {
+				for (const entry of plan.entries) entry.reject(error);
+			}
+		}));
 	};
 	const enqueueStateRead = (store, sessionId, reducer, throughIndex, pinEventIndex, span) => new Promise((resolve, reject) => {
 		const reducerName = reducer.name;
@@ -2325,4 +2338,4 @@ function cloneInitial(initial) {
 //#endregion
 export { sseResponse as a, setServerFetchHooks as i, deliverSchedulerAppend as n, parsePresenceSibling as o, handler as r, createServer as t };
 
-//# sourceMappingURL=server-CjJSGcF7.js.map
+//# sourceMappingURL=server-BD5ckxZb.js.map