@lunora/replica 1.0.0-alpha.8 → 1.0.0-alpha.80

package/dist/index.d.mts

@@ -1,9 +1,24 @@
-export { createBetterSqlite3Adapter } from "./adapters/better-sqlite3.mjs";
+export {
+/**
+ * \@lunora/replica — Event sourcing runtime + local SQLite mirror for Lunora
+ *
+ * ## Modules
+ *
+ * - **EventEmitter** — type-safe event emitter with typed + wildcard listeners.
+ * - **EventSource** — event-sourcing runtime that derives state from an
+ * append-only log via a reducer.
+ * - **SubscriptionManager** — manages state and event-type subscriptions.
+ * - **SnapshotStore** — interface + in-memory store for persisting
+ * event-sourced state snapshots.
+ * - **LocalMirror** — local SQLite mirror that applies typed table diffs.
+ * - **EventLog** — append-only log for events and catch-up replication.
+ */
+createBetterSqlite3Adapter } from "./adapters/better-sqlite3.mjs";
 export { createSqliteWasmAdapter } from "./adapters/sqlite-wasm.mjs";
 export { createSqlJsAdapter } from "./adapters/sqljs.mjs";
-import { S as SqliteAdapter } from "./packem_shared/types.d-CkMkSwLJ.mjs";
-import { T as TableDiff, I as InputEvent, S as Seq, E as EventLogEntry, a as EventLog, A as AppendOptions, L as LocalMirror } from "./packem_shared/local-mirror.d-DTavX_y0.mjs";
-export { type C as ClientSeq, type b as EventLogOptions, type c as EventLogSnapshot, type G as GlobalSeq, type d as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, e as classifyChanges, f as createTableDiff, g as diffSize, i as isClientSeq, h as isDiffEmpty, j as isGlobalSeq, k as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-DTavX_y0.mjs";
+import { S as SqliteAdapter } from "./packem_shared/types.d-BuLTPLaQ.mjs";
+import { T as TableDiff, I as InputEvent, S as Seq, E as EventLogEntry, a as EventLog, A as AppendOptions, L as LocalMirror } from "./packem_shared/local-mirror.d-CtQovAv_.mjs";
+export { type C as ClientSeq, type b as EventLogOptions, type c as EventLogSnapshot, type G as GlobalSeq, type d as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, e as classifyChanges, f as createTableDiff, g as diffSize, i as isClientSeq, h as isDiffEmpty, j as isGlobalSeq, k as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-CtQovAv_.mjs";
 /**
  * Apply a single {@link TableDiff} to an in-memory row map and return
  * the updated map.
@@ -30,15 +45,16 @@ declare const applyDiff: (current: ReadonlyMap<string, Record<string, unknown>>,
 /**
  * Apply an array of diffs **in order**, returning the final row map.
  *
- * This is equivalent to calling {@link applyDiff} repeatedly but avoids
- * intermediate map copies.
+ * This is equivalent to calling {@link applyDiff} repeatedly but copies the
+ * input map exactly once rather than once per diff — catch-up replay of an
+ * N-diff backlog is a single copy, not N+1.
  * @experimental
  */
 declare const applyDiffs: (current: ReadonlyMap<string, Record<string, unknown>>, diffs: ReadonlyArray<TableDiff>) => Map<string, Record<string, unknown>>;
 /**
  * Merge the row-level effect of a {@link TableDiff} into plain JSON
  * state keyed by table name, returning a new snapshot.
- * @param snapshot Current snapshot, e.g. `{ users: Map&lt;id, row>, posts: Map&lt;id, row> }`.
+ * @param snapshot Current snapshot, e.g. `{ users: Map<id, row>, posts: Map<id, row> }`.
  * @param diff Contains the target table name and the row-level changes to merge.
  * @returns A shallow copy of `snapshot` with `diff.table`'s map updated.
  * @experimental
@@ -105,7 +121,7 @@ interface DefineEventsOptions {
   /**
    * Optional version prefix for all event types.
    *
-   * When set, every qualified event type is prefixed with `"v&lt;N>."`, enabling
+   * When set, every qualified event type is prefixed with `"v<N>."`, enabling
    * versioned event naming like `"v1.chat.messageSent"` or `"v2.chat.messageSent"`.
    * This allows materializers to evolve their handling logic based on the event
    * version without breaking backward compatibility.
@@ -178,19 +194,28 @@ declare class EventLogDOClient {
     batchId?: string;
   }): Promise<EventLogEntry[]>;
   /**
-   * Fetch all entries with `seq >= sinceSeq`.
+   * Fetch ONE page of entries with `seq >= sinceSeq`.
    *
-   * Pass `sinceSeq = 0` to fetch the entire log.
-   */
-  getSince(sinceSeq: number): Promise<EventLogEntry[]>;
-  /**
-   * Fetch a paginated range of entries.
-   * @returns `{ entries, hasMore }` — `hasMore` is `true` when another
-   * page exists (i.e. the DO returned `limit + 1` rows).
+   * The DO bounds every page (500 entries unless `limit` says otherwise, 1000
+   * max), so `getSince(0)` is the START of the log, never all of it — a
+   * catch-up walks pages until `truncated` is `false`:
+   *
+   * ```ts
+   * let seq = 0;
+   * for (;;) {
+   *   const page = await client.getSince(seq);
+   *   apply(page.entries);
+   *   if (!page.truncated || page.cursor === undefined) break;
+   *   seq = page.cursor;
+   * }
+   * ```
+   * @returns `{ entries, truncated, cursor }` — `cursor` is the `sinceSeq`
+   * for the next page and is present exactly when `truncated` is `true`.
    */
-  getRange(fromSeq: number, limit?: number): Promise<{
+  getSince(sinceSeq: number, limit?: number): Promise<{
+    cursor?: number;
     entries: EventLogEntry[];
-    hasMore: boolean;
+    truncated: boolean;
   }>;
   /**
    * Return the total number of entries currently in the log.
@@ -271,8 +296,8 @@ type UnknownEventHandling = "warn" | "ignore" | "fail" | ((entry: EventLogEntry)
  * Events emitted by the {@link EventSource} runtime.
  *
  * A `type` (not `interface`) so it satisfies `EventEmitter`'s
- * `Record&lt;string, unknown>` constraint — interfaces have no implicit index
- * signature and aren't assignable to `Record&lt;string, unknown>`.
+ * `Record<string, unknown>` constraint — interfaces have no implicit index
+ * signature and aren't assignable to `Record<string, unknown>`.
  * @experimental
  */
 type EventSourceEvents = {
@@ -408,8 +433,10 @@ declare class EventSource<S extends Record<string, unknown> = Record<string, unk
    * starting from the events currently in the log and continuing with
    * every future `applyEvent` / `replayFromLog` call.
    *
-   * The generator runs indefinitely — it never returns. Callers should
-   * break out of the `for await` loop or use an `AbortSignal` to stop.
+   * The generator runs indefinitely unless given a `signal` — callers
+   * should break out of the `for await` loop or pass an `AbortSignal` to
+   * stop it (an abort settles the generator, `done: true`, on its next
+   * iteration step; it does not throw).
    * @example
    * ```ts
    * for await (const entry of source.events()) {
@@ -506,9 +533,9 @@ declare const defineMaterializer: <S>(definition: MaterializerDef<S>) => Materia
  * A materializer of any state shape. The {@link MaterializerRuntime} holds a
  * heterogeneous collection and only ever calls `apply(entry)` / `setState(...)`
  * (with cast values) / reads `def.name` — it never needs the concrete state
- * type. `Materializer&lt;unknown>` won't do: `setState(state: S)` makes
- * `Materializer&lt;S>` invariant in `S`, so `Materializer&lt;number>` isn't assignable
- * to `Materializer&lt;unknown>`. Erasing the type param is the idiomatic fix.
+ * type. `Materializer<unknown>` won't do: `setState(state: S)` makes
+ * `Materializer<S>` invariant in `S`, so `Materializer<number>` isn't assignable
+ * to `Materializer<unknown>`. Erasing the type param is the idiomatic fix.
  */
 type AnyMaterializer = Materializer<any>;
 /**
@@ -585,12 +612,24 @@ declare class MaterializerRuntime {
    *
    * 1. Recover materialized state from snapshots (if a snapshotStore is
    * configured).
-   * 2. Fetch all entries since the MINIMUM per-materializer watermark from
+   * 2. Fetch entries since the MINIMUM per-materializer watermark from
    * the DO — not the maximum — so a materializer with no snapshot (or a
    * lower one) still receives every event it hasn't seen (REPLICA-04).
    * 3. Apply them through the materializers; `applyEntries` skips each
    * entry for any materializer already past it, so nothing is double-applied.
    *
+   * The DO answers one BOUNDED page per request, so step 2/3 walk pages until
+   * the log is exhausted — applying each page as it arrives, rather than
+   * holding the whole backlog in memory. Taking only the first page (and
+   * dropping `truncated`) would silently leave every materializer short of
+   * the log's head whenever the backlog exceeds a page.
+   *
+   * The walk is bounded by {@link MAX_CATCHUP_PAGES}: against a log written
+   * faster than it is read, "until the log is exhausted" never arrives and
+   * startup would never finish. Hitting the budget returns what was applied
+   * with every materializer's watermark advanced, so a later `initialize()`
+   * (or the ordinary append path) picks up exactly where this left off.
+   *
    * Call this once on startup / after the DO binding is available.
    * @returns The number of entries applied during catch-up.
    */
@@ -602,7 +641,8 @@ declare class MaterializerRuntime {
    * This is a convenience over calling `doClient.append(...)` +
    * `runtime.applyEntries(...)` yourself — it persists the event
    * **then** applies the returned entry (with its assigned seq).
-   * @returns The persisted entry with its DO-assigned `seq`.
+   * @returns The persisted entry with its DO-assigned `seq` — always, whether
+   * or not the entry could be applied to the materializers (see below).
    */
   appendEvent(input: AppendEventInput): Promise<EventLogEntry>;
   /**
@@ -696,20 +736,15 @@ interface EventsFacade {
     type: string;
   }[]) => Promise<EventLogEntry[]>;
   /**
-   * Fetch a paginated range of entries.
-   * @returns `{ entries, hasMore }` — `hasMore` is `true` when another
-   * page exists.
+   * Fetch ONE bounded page of entries with `seq >= sinceSeq`.
+   * @returns `{ entries, truncated, cursor }` — pass `cursor` back as
+   * `sinceSeq` while `truncated` is `true` to walk the whole log.
    */
-  getRange: (fromSeq: number, limit?: number) => Promise<{
+  getSince: (sinceSeq: number, limit?: number) => Promise<{
+    cursor?: number;
     entries: EventLogEntry[];
-    hasMore: boolean;
+    truncated: boolean;
   }>;
-  /**
-   * Fetch all entries with `seq >= sinceSeq`.
-   *
-   * Pass `sinceSeq = 0` to fetch the entire log.
-   */
-  getSince: (sinceSeq: number) => Promise<EventLogEntry[]>;
   /** Return the total number of entries currently in the log. */
   getSize: () => Promise<number>;
   /** Return the full log state — all entries plus the next seq number. */
@@ -730,7 +765,7 @@ interface EventsContextOutput {
  * Create a middleware that attaches a typed `ctx.events` facade backed by
  * the given {@link EventLogDOClient}.
  *
- * The facade surfaces `append`, `getSince`, `getRange`, `getSize`, and
+ * The facade surfaces `append`, `getSince`, `getSize`, and
  * `getState` — every method the DO client exposes — so handlers can read
  * and write the event log without reaching for the DO stub directly.
  *
@@ -772,12 +807,16 @@ interface SubscriptionClient {
  * is applied to the local SQLite store.
  *
  * Each frame from a Lunora live query is the FULL current result set, so the
- * callback treats it as a snapshot: it upserts every row present and emits a
- * `delete` for any id that was mirrored on a previous frame but is absent now —
- * otherwise rows that drop out of the server result would linger stale in the
- * local mirror. Rows are keyed by their `id` field (the mirror's default primary
- * key); a row without an `id` can't be reconciled on removal, and — because the
- * mirror table's `id` column is `NOT NULL` — will fail the insert.
+ * callback diffs it against the previous frame: a row that is new or whose
+ * content changed is upserted, a row that dropped out is deleted, and an
+ * unchanged row produces nothing. A frame identical to the last one therefore
+ * applies no diff — no event-log entry, no `version` bump, no re-query for the
+ * hooks subscribed to the mirror.
+ *
+ * Rows are keyed by the table's primary key (`id` unless the table was
+ * registered with another `primaryKey`); a row without one can't be diffed or
+ * reconciled on removal, and — because the mirror's key column is `NOT NULL` —
+ * will fail the insert.
  *
  * The mirror table name is derived from the function ref alone (not `args`), so
  * do NOT mirror two subscriptions to the same function with different `args`
@@ -877,15 +916,28 @@ interface EventsSyncOptions {
    * consumer should feed these events into their state machine
    * (e.g. an {@link import("@lunora/replica").EventSource | EventSource})
    * so that the machine's state reflects the latest log position.
+   *
+   * **Must be atomic across the batch: apply every event, or none.** There is
+   * no rollback here and none is possible — the state machine is the
+   * consumer's. A call that mutates derived state and then throws partway is
+   * re-delivered WHOLE on the next poll (the watermark only advances past a
+   * batch that fully succeeded, and a replay that threw is not recorded), so a
+   * non-atomic implementation applies the events before the throw twice. A
+   * call that RETURNS is never re-delivered: {@link EventsSync} tracks the
+   * highest applied `seq` separately from the watermark, so a batch whose
+   * replay succeeded and whose mirror fan-out then failed is not replayed.
    */
   applyEvents: (events: ReadonlyArray<EventLogEntry>) => void;
   /**
-   * Fetch all events whose `seq >= sinceSeq`.
+   * Fetch the next batch of events whose `seq >= sinceSeq`.
    *
-   * In a server-side context, this typically wraps
-   * {@link import("@lunora/replica").EventLogDOClient.getSince |
-   * EventLogDOClient.getSince()}.
-   * In a client context it could call a Lunora action that proxies to the
+   * It does NOT have to return the whole backlog: a bounded batch is
+   * preferred and is what the DO-backed transport gives you
+   * ({@link import("@lunora/replica").EventLogDOClient.getSince |
+   * EventLogDOClient.getSince()} answers one page). {@link EventsSync} keeps
+   * calling with the advanced watermark until a call returns nothing, so the
+   * whole log is applied either way — one bounded atom at a time.
+   * In a client context this could call a Lunora action that proxies to the
    * event log, or read from an IndexedDB cache.
    *
    * Return an empty array when there are no new events.
@@ -895,8 +947,17 @@ interface EventsSyncOptions {
    * Produce {@link TableDiff | TableDiffs} from the current derived state.
    *
    * Called after every batch of events has been applied. The consumer
-   * compares the state _before_ and _after_ the batch and returns the
-   * diffs needed to bring the LocalMirror up to date.
+   * **recomputes a full diff from the current mirror-vs-source state** and
+   * returns the diffs needed to bring the LocalMirror up to date.
+   *
+   * **MUST be idempotent** — it must NOT advance a one-shot cursor as a side
+   * effect. A batch that fails partway (a `mirror.applyDiff` throws) is
+   * retried on the next poll from the same watermark; if this call consumed a
+   * cursor on the first attempt it would return `[]` on the retry and the
+   * un-mirrored diffs would be lost forever. Recompute-from-current-state has
+   * no such hazard: calling it again with no new events returns the same
+   * diffs, and calling it after a partial mirror write returns exactly the
+   * diffs still missing from the mirror.
    *
    * Return an empty array when there are no changes to push to the mirror.
    */

package/dist/index.d.ts

@@ -1,9 +1,24 @@
-export { createBetterSqlite3Adapter } from "./adapters/better-sqlite3.js";
+export {
+/**
+ * \@lunora/replica — Event sourcing runtime + local SQLite mirror for Lunora
+ *
+ * ## Modules
+ *
+ * - **EventEmitter** — type-safe event emitter with typed + wildcard listeners.
+ * - **EventSource** — event-sourcing runtime that derives state from an
+ * append-only log via a reducer.
+ * - **SubscriptionManager** — manages state and event-type subscriptions.
+ * - **SnapshotStore** — interface + in-memory store for persisting
+ * event-sourced state snapshots.
+ * - **LocalMirror** — local SQLite mirror that applies typed table diffs.
+ * - **EventLog** — append-only log for events and catch-up replication.
+ */
+createBetterSqlite3Adapter } from "./adapters/better-sqlite3.js";
 export { createSqliteWasmAdapter } from "./adapters/sqlite-wasm.js";
 export { createSqlJsAdapter } from "./adapters/sqljs.js";
-import { S as SqliteAdapter } from "./packem_shared/types.d-CkMkSwLJ.js";
-import { T as TableDiff, I as InputEvent, S as Seq, E as EventLogEntry, a as EventLog, A as AppendOptions, L as LocalMirror } from "./packem_shared/local-mirror.d-CyGOpUES.js";
-export { type C as ClientSeq, type b as EventLogOptions, type c as EventLogSnapshot, type G as GlobalSeq, type d as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, e as classifyChanges, f as createTableDiff, g as diffSize, i as isClientSeq, h as isDiffEmpty, j as isGlobalSeq, k as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-CyGOpUES.js";
+import { S as SqliteAdapter } from "./packem_shared/types.d-BuLTPLaQ.js";
+import { T as TableDiff, I as InputEvent, S as Seq, E as EventLogEntry, a as EventLog, A as AppendOptions, L as LocalMirror } from "./packem_shared/local-mirror.d-CErKffFW.js";
+export { type C as ClientSeq, type b as EventLogOptions, type c as EventLogSnapshot, type G as GlobalSeq, type d as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, e as classifyChanges, f as createTableDiff, g as diffSize, i as isClientSeq, h as isDiffEmpty, j as isGlobalSeq, k as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-CErKffFW.js";
 /**
  * Apply a single {@link TableDiff} to an in-memory row map and return
  * the updated map.
@@ -30,15 +45,16 @@ declare const applyDiff: (current: ReadonlyMap<string, Record<string, unknown>>,
 /**
  * Apply an array of diffs **in order**, returning the final row map.
  *
- * This is equivalent to calling {@link applyDiff} repeatedly but avoids
- * intermediate map copies.
+ * This is equivalent to calling {@link applyDiff} repeatedly but copies the
+ * input map exactly once rather than once per diff — catch-up replay of an
+ * N-diff backlog is a single copy, not N+1.
  * @experimental
  */
 declare const applyDiffs: (current: ReadonlyMap<string, Record<string, unknown>>, diffs: ReadonlyArray<TableDiff>) => Map<string, Record<string, unknown>>;
 /**
  * Merge the row-level effect of a {@link TableDiff} into plain JSON
  * state keyed by table name, returning a new snapshot.
- * @param snapshot Current snapshot, e.g. `{ users: Map&lt;id, row>, posts: Map&lt;id, row> }`.
+ * @param snapshot Current snapshot, e.g. `{ users: Map<id, row>, posts: Map<id, row> }`.
  * @param diff Contains the target table name and the row-level changes to merge.
  * @returns A shallow copy of `snapshot` with `diff.table`'s map updated.
  * @experimental
@@ -105,7 +121,7 @@ interface DefineEventsOptions {
   /**
    * Optional version prefix for all event types.
    *
-   * When set, every qualified event type is prefixed with `"v&lt;N>."`, enabling
+   * When set, every qualified event type is prefixed with `"v<N>."`, enabling
    * versioned event naming like `"v1.chat.messageSent"` or `"v2.chat.messageSent"`.
    * This allows materializers to evolve their handling logic based on the event
    * version without breaking backward compatibility.
@@ -178,19 +194,28 @@ declare class EventLogDOClient {
     batchId?: string;
   }): Promise<EventLogEntry[]>;
   /**
-   * Fetch all entries with `seq >= sinceSeq`.
+   * Fetch ONE page of entries with `seq >= sinceSeq`.
    *
-   * Pass `sinceSeq = 0` to fetch the entire log.
-   */
-  getSince(sinceSeq: number): Promise<EventLogEntry[]>;
-  /**
-   * Fetch a paginated range of entries.
-   * @returns `{ entries, hasMore }` — `hasMore` is `true` when another
-   * page exists (i.e. the DO returned `limit + 1` rows).
+   * The DO bounds every page (500 entries unless `limit` says otherwise, 1000
+   * max), so `getSince(0)` is the START of the log, never all of it — a
+   * catch-up walks pages until `truncated` is `false`:
+   *
+   * ```ts
+   * let seq = 0;
+   * for (;;) {
+   *   const page = await client.getSince(seq);
+   *   apply(page.entries);
+   *   if (!page.truncated || page.cursor === undefined) break;
+   *   seq = page.cursor;
+   * }
+   * ```
+   * @returns `{ entries, truncated, cursor }` — `cursor` is the `sinceSeq`
+   * for the next page and is present exactly when `truncated` is `true`.
    */
-  getRange(fromSeq: number, limit?: number): Promise<{
+  getSince(sinceSeq: number, limit?: number): Promise<{
+    cursor?: number;
     entries: EventLogEntry[];
-    hasMore: boolean;
+    truncated: boolean;
   }>;
   /**
    * Return the total number of entries currently in the log.
@@ -271,8 +296,8 @@ type UnknownEventHandling = "warn" | "ignore" | "fail" | ((entry: EventLogEntry)
  * Events emitted by the {@link EventSource} runtime.
  *
  * A `type` (not `interface`) so it satisfies `EventEmitter`'s
- * `Record&lt;string, unknown>` constraint — interfaces have no implicit index
- * signature and aren't assignable to `Record&lt;string, unknown>`.
+ * `Record<string, unknown>` constraint — interfaces have no implicit index
+ * signature and aren't assignable to `Record<string, unknown>`.
  * @experimental
  */
 type EventSourceEvents = {
@@ -408,8 +433,10 @@ declare class EventSource<S extends Record<string, unknown> = Record<string, unk
    * starting from the events currently in the log and continuing with
    * every future `applyEvent` / `replayFromLog` call.
    *
-   * The generator runs indefinitely — it never returns. Callers should
-   * break out of the `for await` loop or use an `AbortSignal` to stop.
+   * The generator runs indefinitely unless given a `signal` — callers
+   * should break out of the `for await` loop or pass an `AbortSignal` to
+   * stop it (an abort settles the generator, `done: true`, on its next
+   * iteration step; it does not throw).
    * @example
    * ```ts
    * for await (const entry of source.events()) {
@@ -506,9 +533,9 @@ declare const defineMaterializer: <S>(definition: MaterializerDef<S>) => Materia
  * A materializer of any state shape. The {@link MaterializerRuntime} holds a
  * heterogeneous collection and only ever calls `apply(entry)` / `setState(...)`
  * (with cast values) / reads `def.name` — it never needs the concrete state
- * type. `Materializer&lt;unknown>` won't do: `setState(state: S)` makes
- * `Materializer&lt;S>` invariant in `S`, so `Materializer&lt;number>` isn't assignable
- * to `Materializer&lt;unknown>`. Erasing the type param is the idiomatic fix.
+ * type. `Materializer<unknown>` won't do: `setState(state: S)` makes
+ * `Materializer<S>` invariant in `S`, so `Materializer<number>` isn't assignable
+ * to `Materializer<unknown>`. Erasing the type param is the idiomatic fix.
  */
 type AnyMaterializer = Materializer<any>;
 /**
@@ -585,12 +612,24 @@ declare class MaterializerRuntime {
    *
    * 1. Recover materialized state from snapshots (if a snapshotStore is
    * configured).
-   * 2. Fetch all entries since the MINIMUM per-materializer watermark from
+   * 2. Fetch entries since the MINIMUM per-materializer watermark from
    * the DO — not the maximum — so a materializer with no snapshot (or a
    * lower one) still receives every event it hasn't seen (REPLICA-04).
    * 3. Apply them through the materializers; `applyEntries` skips each
    * entry for any materializer already past it, so nothing is double-applied.
    *
+   * The DO answers one BOUNDED page per request, so step 2/3 walk pages until
+   * the log is exhausted — applying each page as it arrives, rather than
+   * holding the whole backlog in memory. Taking only the first page (and
+   * dropping `truncated`) would silently leave every materializer short of
+   * the log's head whenever the backlog exceeds a page.
+   *
+   * The walk is bounded by {@link MAX_CATCHUP_PAGES}: against a log written
+   * faster than it is read, "until the log is exhausted" never arrives and
+   * startup would never finish. Hitting the budget returns what was applied
+   * with every materializer's watermark advanced, so a later `initialize()`
+   * (or the ordinary append path) picks up exactly where this left off.
+   *
    * Call this once on startup / after the DO binding is available.
    * @returns The number of entries applied during catch-up.
    */
@@ -602,7 +641,8 @@ declare class MaterializerRuntime {
    * This is a convenience over calling `doClient.append(...)` +
    * `runtime.applyEntries(...)` yourself — it persists the event
    * **then** applies the returned entry (with its assigned seq).
-   * @returns The persisted entry with its DO-assigned `seq`.
+   * @returns The persisted entry with its DO-assigned `seq` — always, whether
+   * or not the entry could be applied to the materializers (see below).
    */
   appendEvent(input: AppendEventInput): Promise<EventLogEntry>;
   /**
@@ -696,20 +736,15 @@ interface EventsFacade {
     type: string;
   }[]) => Promise<EventLogEntry[]>;
   /**
-   * Fetch a paginated range of entries.
-   * @returns `{ entries, hasMore }` — `hasMore` is `true` when another
-   * page exists.
+   * Fetch ONE bounded page of entries with `seq >= sinceSeq`.
+   * @returns `{ entries, truncated, cursor }` — pass `cursor` back as
+   * `sinceSeq` while `truncated` is `true` to walk the whole log.
    */
-  getRange: (fromSeq: number, limit?: number) => Promise<{
+  getSince: (sinceSeq: number, limit?: number) => Promise<{
+    cursor?: number;
     entries: EventLogEntry[];
-    hasMore: boolean;
+    truncated: boolean;
   }>;
-  /**
-   * Fetch all entries with `seq >= sinceSeq`.
-   *
-   * Pass `sinceSeq = 0` to fetch the entire log.
-   */
-  getSince: (sinceSeq: number) => Promise<EventLogEntry[]>;
   /** Return the total number of entries currently in the log. */
   getSize: () => Promise<number>;
   /** Return the full log state — all entries plus the next seq number. */
@@ -730,7 +765,7 @@ interface EventsContextOutput {
  * Create a middleware that attaches a typed `ctx.events` facade backed by
  * the given {@link EventLogDOClient}.
  *
- * The facade surfaces `append`, `getSince`, `getRange`, `getSize`, and
+ * The facade surfaces `append`, `getSince`, `getSize`, and
  * `getState` — every method the DO client exposes — so handlers can read
  * and write the event log without reaching for the DO stub directly.
  *
@@ -772,12 +807,16 @@ interface SubscriptionClient {
  * is applied to the local SQLite store.
  *
  * Each frame from a Lunora live query is the FULL current result set, so the
- * callback treats it as a snapshot: it upserts every row present and emits a
- * `delete` for any id that was mirrored on a previous frame but is absent now —
- * otherwise rows that drop out of the server result would linger stale in the
- * local mirror. Rows are keyed by their `id` field (the mirror's default primary
- * key); a row without an `id` can't be reconciled on removal, and — because the
- * mirror table's `id` column is `NOT NULL` — will fail the insert.
+ * callback diffs it against the previous frame: a row that is new or whose
+ * content changed is upserted, a row that dropped out is deleted, and an
+ * unchanged row produces nothing. A frame identical to the last one therefore
+ * applies no diff — no event-log entry, no `version` bump, no re-query for the
+ * hooks subscribed to the mirror.
+ *
+ * Rows are keyed by the table's primary key (`id` unless the table was
+ * registered with another `primaryKey`); a row without one can't be diffed or
+ * reconciled on removal, and — because the mirror's key column is `NOT NULL` —
+ * will fail the insert.
  *
  * The mirror table name is derived from the function ref alone (not `args`), so
  * do NOT mirror two subscriptions to the same function with different `args`
@@ -877,15 +916,28 @@ interface EventsSyncOptions {
    * consumer should feed these events into their state machine
    * (e.g. an {@link import("@lunora/replica").EventSource | EventSource})
    * so that the machine's state reflects the latest log position.
+   *
+   * **Must be atomic across the batch: apply every event, or none.** There is
+   * no rollback here and none is possible — the state machine is the
+   * consumer's. A call that mutates derived state and then throws partway is
+   * re-delivered WHOLE on the next poll (the watermark only advances past a
+   * batch that fully succeeded, and a replay that threw is not recorded), so a
+   * non-atomic implementation applies the events before the throw twice. A
+   * call that RETURNS is never re-delivered: {@link EventsSync} tracks the
+   * highest applied `seq` separately from the watermark, so a batch whose
+   * replay succeeded and whose mirror fan-out then failed is not replayed.
    */
   applyEvents: (events: ReadonlyArray<EventLogEntry>) => void;
   /**
-   * Fetch all events whose `seq >= sinceSeq`.
+   * Fetch the next batch of events whose `seq >= sinceSeq`.
    *
-   * In a server-side context, this typically wraps
-   * {@link import("@lunora/replica").EventLogDOClient.getSince |
-   * EventLogDOClient.getSince()}.
-   * In a client context it could call a Lunora action that proxies to the
+   * It does NOT have to return the whole backlog: a bounded batch is
+   * preferred and is what the DO-backed transport gives you
+   * ({@link import("@lunora/replica").EventLogDOClient.getSince |
+   * EventLogDOClient.getSince()} answers one page). {@link EventsSync} keeps
+   * calling with the advanced watermark until a call returns nothing, so the
+   * whole log is applied either way — one bounded atom at a time.
+   * In a client context this could call a Lunora action that proxies to the
    * event log, or read from an IndexedDB cache.
    *
    * Return an empty array when there are no new events.
@@ -895,8 +947,17 @@ interface EventsSyncOptions {
    * Produce {@link TableDiff | TableDiffs} from the current derived state.
    *
    * Called after every batch of events has been applied. The consumer
-   * compares the state _before_ and _after_ the batch and returns the
-   * diffs needed to bring the LocalMirror up to date.
+   * **recomputes a full diff from the current mirror-vs-source state** and
+   * returns the diffs needed to bring the LocalMirror up to date.
+   *
+   * **MUST be idempotent** — it must NOT advance a one-shot cursor as a side
+   * effect. A batch that fails partway (a `mirror.applyDiff` throws) is
+   * retried on the next poll from the same watermark; if this call consumed a
+   * cursor on the first attempt it would return `[]` on the retry and the
+   * un-mirrored diffs would be lost forever. Recompute-from-current-state has
+   * no such hazard: calling it again with no new events returns the same
+   * diffs, and calling it after a partial mirror write returns exactly the
+   * diffs still missing from the mirror.
    *
    * Return an empty array when there are no changes to push to the mirror.
    */

package/dist/index.mjs

@@ -1,20 +1 @@
-export { createBetterSqlite3Adapter } from './adapters/better-sqlite3.mjs';
-export { createSqliteWasmAdapter } from './adapters/sqlite-wasm.mjs';
-export { createSqlJsAdapter } from './adapters/sqljs.mjs';
-export { applyDiff, applyDiffToSnapshot, applyDiffs } from './packem_shared/applyDiff-98tKzmiW.mjs';
-export { defineEvents } from './packem_shared/defineEvents-DiBkPTh_.mjs';
-export { MaterializerRuntime, defineMaterializer } from './packem_shared/MaterializerRuntime-BoIrsMYB.mjs';
-export { applyDiffToDb, applyDiffsToDb } from './packem_shared/applyDiffToDb-DQ1xZp5J.mjs';
-export { EventEmitter } from './packem_shared/EventEmitter-CMZfct03.mjs';
-export { EventLog } from './packem_shared/EventLog-CnK-3Wge.mjs';
-export { EventLogDO } from './packem_shared/EventLogDO-DqlsVx0H.mjs';
-export { EventLogDOClient } from './packem_shared/EventLogDOClient-F4FO8Si4.mjs';
-export { EventSource, UNHANDLED } from './packem_shared/EventSource-D5yO9_aI.mjs';
-export { eventsContext } from './packem_shared/eventsContext-Bk_p48hj.mjs';
-export { LocalMirror } from './packem_shared/LocalMirror-a-5jEqFN.mjs';
-export { isClientSeq, isGlobalSeq, isInputEvent } from './packem_shared/isClientSeq-C46BkzqJ.mjs';
-export { InMemorySnapshotStore } from './packem_shared/InMemorySnapshotStore-BHVAD-Bp.mjs';
-export { subscribeToMirror } from './packem_shared/subscribeToMirror-CiaM-nQ7.mjs';
-export { SubscriptionManager } from './packem_shared/SubscriptionManager-C5xbw0pg.mjs';
-export { EventsSync } from './packem_shared/EventsSync-BP36tC9O.mjs';
-export { classifyChanges, createTableDiff, diffSize, isDiffEmpty, mergeDiffs } from './packem_shared/classifyChanges-RcqLBpLs.mjs';
+import{createBetterSqlite3Adapter as o}from"./adapters/better-sqlite3.mjs";import{createSqliteWasmAdapter as f}from"./adapters/sqlite-wasm.mjs";import{createSqlJsAdapter as i}from"./adapters/sqljs.mjs";import{applyDiff as m,applyDiffToSnapshot as n,applyDiffs as x}from"./packem_shared/applyDiff-DRJ1gap3.mjs";import{defineEvents as l}from"./packem_shared/defineEvents-DHo-VK7G.mjs";import{MaterializerRuntime as S,defineMaterializer as E}from"./packem_shared/MaterializerRuntime-S-Knx6BM.mjs";import{applyDiffToDb as v,applyDiffsToDb as y}from"./packem_shared/applyDiffToDb-C6ek5Elp.mjs";import{EventEmitter as d}from"./packem_shared/EventEmitter-uo75adUL.mjs";import{EventLog as M}from"./packem_shared/EventLog-B1-yhArT.mjs";import{EventLogDO as u}from"./packem_shared/EventLogDO-BF9ZWc6C.mjs";import{EventLogDOClient as T}from"./packem_shared/EventLogDOClient-DWerZ3_n.mjs";import{EventSource as C,UNHANDLED as h}from"./packem_shared/EventSource-BC0hKJSA.mjs";import{eventsContext as I}from"./packem_shared/eventsContext-Dxow9Y7S.mjs";import{LocalMirror as O}from"./packem_shared/LocalMirror-ZmB8SJFe.mjs";import{isClientSeq as G,isGlobalSeq as H,isInputEvent as J}from"./packem_shared/isClientSeq-D2Xm0_lj.mjs";import{InMemorySnapshotStore as U}from"./packem_shared/InMemorySnapshotStore-C4taIG5K.mjs";import{subscribeToMirror as j}from"./packem_shared/subscribeToMirror-BT4oOBng.mjs";import{SubscriptionManager as w}from"./packem_shared/SubscriptionManager-AhPw3lFc.mjs";import{EventsSync as K}from"./packem_shared/EventsSync-B3wzXm-b.mjs";import{classifyChanges as Q,createTableDiff as V,diffSize as X,isDiffEmpty as Y,mergeDiffs as Z}from"./packem_shared/classifyChanges-BBc0-770.mjs";export{d as EventEmitter,M as EventLog,u as EventLogDO,T as EventLogDOClient,C as EventSource,K as EventsSync,U as InMemorySnapshotStore,O as LocalMirror,S as MaterializerRuntime,w as SubscriptionManager,h as UNHANDLED,m as applyDiff,v as applyDiffToDb,n as applyDiffToSnapshot,x as applyDiffs,y as applyDiffsToDb,Q as classifyChanges,o as createBetterSqlite3Adapter,i as createSqlJsAdapter,f as createSqliteWasmAdapter,V as createTableDiff,l as defineEvents,E as defineMaterializer,X as diffSize,I as eventsContext,G as isClientSeq,Y as isDiffEmpty,H as isGlobalSeq,J as isInputEvent,Z as mergeDiffs,j as subscribeToMirror};

package/dist/packem_shared/EventEmitter-uo75adUL.mjs

@@ -0,0 +1 @@
+class h{#t=new Map;#e=new Set;on(t,s){let e=this.#t.get(t);return e||(e=new Set,this.#t.set(t,e)),e.add(s),()=>{this.off(t,s)}}off(t,s){this.#t.get(t)?.delete(s)}onAny(t){return this.#e.add(t),()=>{this.#e.delete(t)}}offAny(t){this.#e.delete(t)}emit(t,s){let e=!1;const r=this.#t.get(t);if(r)for(const i of r)try{i(s),e=!0}catch{}for(const i of this.#e)try{i(t,s),e=!0}catch{}return e}hasListeners(t){return(this.#t.get(t)?.size??0)>0||this.#e.size>0}listenerCount(t){return this.#t.get(t)?.size??0}clear(){this.#t.clear(),this.#e.clear()}}export{h as EventEmitter};

package/dist/packem_shared/EventLog-B1-yhArT.mjs

@@ -0,0 +1 @@
+class l{#e=[];#t=0;#i=0;#s=null;#n;constructor(t){this.#n=l.#o(t?.maxEntries)}static#o(t){if(t!==void 0){if(!Number.isSafeInteger(t)||t<0)throw new RangeError("maxEntries must be a non-negative safe integer");return t}}#r(){return this.#e.slice(this.#t)}#h(){if(this.#n===void 0)return;const e=this.#e.length-this.#t-this.#n;e>0&&(this.#t+=e),this.#t>0&&this.#t>=this.#e.length-this.#t&&(this.#e=this.#e.slice(this.#t),this.#t=0)}append(t,e,s,n){const r=typeof t=="string"?t:t.type,o=typeof t=="string"?e:t.payload;let h,i;typeof t=="string"?(h=s,i=n):(h=void 0,i=e);const a=i?.parentSeqNum??this.#s??void 0,f=this.#i;this.#i+=1;const c={seq:f,type:r,payload:o,timestamp:i?.timestamp??Date.now(),tableDiffs:h,clientId:i?.clientId,sessionId:i?.sessionId,parentSeqNum:a};return this.#e.push(c),this.#s=c.seq,this.#h(),c}commitAll(t){if(t.length===0)return[];const e=[];for(const s of t){const{type:n}=s,r="payload"in s?s.payload:void 0,o="timestamp"in s?s.timestamp:Date.now(),h=e.at(-1)?.seq??this.#s??void 0,i=this.#i;this.#i+=1;const a={seq:i,type:n,payload:r,timestamp:o,parentSeqNum:h};this.#e.push(a),e.push(a)}return this.#s=e.at(-1)?.seq??this.#s,this.#h(),e}load(t){this.#e=[...t.entries],this.#t=0,this.#i=t.nextSeq,this.#s=t.headSeq,this.#h()}getSince(t){const e=this.#r();if(t<=0)return e;const s=e.findIndex(n=>n.seq>=t);return s===-1?[]:e.slice(s)}getFrom(t,e=50){const s=this.#e,n=this.#t,r=s.findIndex((h,i)=>i>=n&&h.seq>=t);if(r===-1)return{entries:[],hasMore:!1};const o=Math.min(r+e,s.length);return{entries:s.slice(r,o),hasMore:o<s.length}}snapshot(){return{entries:this.#r(),nextSeq:this.#i,headSeq:this.#s}}get size(){return this.#e.length-this.#t}get nextSeq(){return this.#i}get isEmpty(){return this.size===0}get headSeq(){return this.#s}clear(){this.#e=[],this.#t=0,this.#i=0,this.#s=null}truncateBelow(t){if(!Number.isSafeInteger(t)||t<0)throw new RangeError("floorSeq must be a non-negative safe integer");const e=this.#r(),s=e.findIndex(n=>n.seq>=t);this.#e=s===-1?[]:e.slice(s),this.#t=0}async*events(t=0){const e=this.getSince(t);for(const s of e)yield s}}export{l as EventLog};

package/dist/packem_shared/EventLogDO-BF9ZWc6C.mjs

@@ -0,0 +1 @@
+const y=Symbol("lunora.replica.event-log-do.idempotency-conflict"),q=n=>{const t=new Error(n);return Object.defineProperty(t,y,{value:!0}),t},N=n=>n instanceof Error&&y in n,T=n=>{if(Array.isArray(n))return n.map(t=>T(t));if(n!==null&&typeof n=="object"){const t=n,e=Object.keys(t);e.sort();const s={};for(const r of e)s[r]=T(t[r]);return s}return n},I=async n=>{const t=JSON.stringify(T(n)),e=new TextEncoder().encode(t),s=await crypto.subtle.digest("SHA-256",e);return[...new Uint8Array(s)].map(r=>r.toString(16).padStart(2,"0")).join("")},g=500,A=1e3,f=(n,t=200)=>Response.json(n,{status:t,headers:{"content-type":"application/json"}}),d=(n,t,e)=>f({error:{code:t,message:e}},n),m=n=>typeof n.toArray=="function"?n.toArray():typeof n[Symbol.iterator]=="function"?[...n]:[],E=n=>m(n).map(e=>({seq:e.seq,type:e.type,payload:JSON.parse(e.payload),timestamp:e.timestamp,clientId:e.client_id??void 0,sessionId:e.session_id??void 0,parentSeqNum:e.parent_seq??void 0}));class p{state;env;#t=!1;constructor(t,e){this.state=t,this.env=e}async fetch(t){this.#c();const e=new URL(t.url);try{if(t.method==="POST"&&e.pathname==="/append")return await this.#e(t);if(t.method==="GET"&&e.pathname==="/since")return this.#i(e);if(t.method==="GET"&&e.pathname==="/size")return this.#o();if(t.method==="GET"&&e.pathname==="/state")return this.#a()}catch(s){return console.error("[event-log-do] request failed:",s),d(500,"INTERNAL_ERROR","internal error")}return d(404,"NOT_FOUND","unknown route")}async#e(t){let e;try{e=await t.json()}catch{return d(400,"BAD_REQUEST","invalid JSON body")}const s=p.#n(e);if(s)return d(400,"BAD_REQUEST",s);const{sql:r}=this.state.storage,{batchId:o}=e,a=()=>p.#s(r,e,o),{transaction:i}=this.state.storage;let c;try{c=typeof i=="function"?await i(a):await a()}catch(u){if(N(u))return d(409,"CONFLICT",u.message);throw u}return f({entries:c})}static async#s(t,e,s){let r;if(typeof s=="string"){r=await I(e.events);const i=p.#p(t,s);if(i){if(i.fingerprint!==r)throw q(`batchId "${s}" was already used for a different event batch`);return i.entries}}const o=Date.now(),a=[];for(const i of e.events){const l={seq:p.#d(t),type:i.type,payload:i.payload,timestamp:i.timestamp??o,clientId:i.clientId,sessionId:i.sessionId,parentSeqNum:i.parentSeqNum};p.#l(t,l),a.push(l)}if(typeof s=="string"&&r!==void 0){const i=a[0]?.seq,c=a.at(-1)?.seq;i!==void 0&&c!==void 0&&p.#u(t,s,i,c,r)}return a}static#n(t){if(!Array.isArray(t.events)||t.events.length===0)return"events[] with a non-empty string `type` required";if(t.batchId!==void 0&&(typeof t.batchId!="string"||t.batchId.length===0))return"batchId must be a non-empty string";for(const e of t.events){const s=p.#r(e);if(s!==void 0)return s}}static#r(t){if(typeof t.type!="string"||t.type.length===0)return"events[] with a non-empty string `type` required";if(t.timestamp!==void 0&&!Number.isFinite(t.timestamp))return"events[].timestamp must be a finite number";if(t.clientId!==void 0&&typeof t.clientId!="string")return"events[].clientId must be a string";if(t.sessionId!==void 0&&typeof t.sessionId!="string")return"events[].sessionId must be a string";if(t.parentSeqNum!==void 0&&(typeof t.parentSeqNum!="number"||!Number.isInteger(t.parentSeqNum)||t.parentSeqNum<0))return"events[].parentSeqNum must be a non-negative integer"}#i(t){const e=t.searchParams.get("seq"),s=e===null?0:Number(e),r=t.searchParams.get("limit"),o=r===null?g:Number(r);if(!Number.isSafeInteger(s)||s<0)return d(400,"BAD_REQUEST","invalid seq");if(!Number.isSafeInteger(o)||o<1||o>A)return d(400,"BAD_REQUEST","invalid limit");const{sql:a}=this.state.storage,i=a.exec("SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events WHERE seq >= ? ORDER BY seq ASC LIMIT ?",s,o+1),c=E(i),l=c.length>o,u=l?c.slice(0,o):c,h=u.at(-1),S=l&&h!==void 0?{entries:u,truncated:!0,cursor:h.seq+1}:{entries:u,truncated:!1};return f(S)}#o(){const{sql:t}=this.state.storage,e=t.exec("SELECT COUNT(*) AS count FROM events"),r=m(e)[0]?.count??0;return f({count:r})}#a(){const{sql:t}=this.state.storage,e=t.exec("SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events ORDER BY seq ASC"),s=E(e),r=(s.at(-1)?.seq??-1)+1;return f({entries:s,nextSeq:r})}#c(){if(this.#t)return;const{sql:t}=this.state.storage;t.exec("CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, type TEXT NOT NULL, payload TEXT NOT NULL, timestamp INTEGER NOT NULL, client_id TEXT, session_id TEXT, parent_seq INTEGER)"),t.exec("CREATE TABLE IF NOT EXISTS event_batches (batch_id TEXT PRIMARY KEY, first_seq INTEGER NOT NULL, last_seq INTEGER NOT NULL, fingerprint TEXT NOT NULL)"),this.#t=!0}static#p(t,e){const s=t.exec("SELECT first_seq, last_seq, fingerprint FROM event_batches WHERE batch_id = ?",e),o=m(s)[0];if(!o)return;const a=t.exec("SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events WHERE seq >= ? AND seq <= ? ORDER BY seq ASC",o.first_seq,o.last_seq);return{entries:E(a),fingerprint:o.fingerprint}}static#u(t,e,s,r,o){t.exec("INSERT INTO event_batches (batch_id, first_seq, last_seq, fingerprint) VALUES (?, ?, ?, ?)",e,s,r,o)}static#d(t){const e=t.exec("SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM events");return m(e)[0]?.next_seq??0}static#l(t,e){const s=typeof e.parentSeqNum=="number"?e.parentSeqNum:null;t.exec("INSERT INTO events (seq, type, payload, timestamp, client_id, session_id, parent_seq) VALUES (?, ?, ?, ?, ?, ?, ?)",e.seq,e.type,JSON.stringify(e.payload),e.timestamp,e.clientId??null,e.sessionId??null,s)}}export{p as EventLogDO};

package/dist/packem_shared/EventLogDOClient-DWerZ3_n.mjs

@@ -0,0 +1 @@
+class n{#t;constructor(t){this.#t=t.fetch}async append(t,a){const e=JSON.stringify({events:t,batchId:a?.batchId}),s=await this.#t(new Request("https://do/append",{method:"POST",headers:{"content-type":"application/json"},body:e}));if(!s.ok)throw await n.#e(s,"append");return(await s.json()).entries}async getSince(t,a){const e=a===void 0?"":`&limit=${String(a)}`;return this.#a(`/since?seq=${String(t)}${e}`,"getSince")}async getSize(){return(await this.#a("/size","getSize")).count}async getState(){return this.#a("/state","getState")}async#a(t,a){const e=await this.#t(new Request(`https://do${t}`));if(!e.ok)throw await n.#e(e,a);return await e.json()}static async#e(t,a){try{const s=(await t.json()).error?.message??t.statusText;return new Error(`EventLogDO.${a} failed (${String(t.status)}): ${s}`)}catch{return new Error(`EventLogDO.${a} failed (${String(t.status)}): ${t.statusText}`)}}}export{n as EventLogDOClient};

package/dist/packem_shared/EventSource-BC0hKJSA.mjs

@@ -0,0 +1 @@
+import{EventEmitter as p}from"./EventEmitter-uo75adUL.mjs";import{EventLog as f}from"./EventLog-B1-yhArT.mjs";const d=Symbol("lunora.replica.event-source.unhandled");class w{emitter=new p;log;#e;#t;#n=!1;#i;#r=-1;constructor(e,t,n){this.#e={...e},this.#t=t,this.#i=n?.unknownEventHandling??"warn",this.log=new f({maxEntries:n?.maxLogEntries})}get state(){return this.#e}get replayed(){return this.#n}applyEvent(e,t,n){let r,o,i;typeof e=="string"?(r=e,o=t,i=n):(r=e.type,o=e.payload,i=t);const s={seq:this.log.nextSeq,type:r,payload:o,timestamp:Date.now(),clientId:i?.clientId,sessionId:i?.sessionId,parentSeqNum:i?.parentSeqNum??this.log.headSeq??void 0};let a;try{a=this.#t(this.#e,s)}catch(h){const u=h instanceof Error?h:new Error(String(h));throw this.emitter.emit("replay-error",{entry:s,error:u}),u}let c=!0;a===d&&(c=this.#s(s));const l=this.log.append(r,o,void 0,{...i,timestamp:s.timestamp});return a===d?(c&&this.emitter.emit("state-changed",{state:this.#e,entry:l}),l):(this.#e=a,this.emitter.emit("state-changed",{state:this.#e,entry:l}),l)}replayFromLog(e){const t=e.getSince(this.#r+1);for(const n of t)try{const r=this.#t(this.#e,n);r!==d&&(this.#e=r),this.log.append(n.type,n.payload,n.tableDiffs,{clientId:n.clientId,sessionId:n.sessionId,parentSeqNum:n.parentSeqNum})}catch(r){this.emitter.emit("replay-error",{entry:n,error:r instanceof Error?r:new Error(String(r))})}finally{this.#r=n.seq}this.#n=!0,this.emitter.emit("ready",{entryCount:this.log.size})}reset(e,t=-1){this.#e={...e},this.#r=t,this.#n=t>=0}async*events(e){const t=[];let n;const r=this.emitter.on("state-changed",({entry:i})=>{t.push(i),n?.()}),o=()=>{n?.()};e?.addEventListener("abort",o,{once:!0});try{let i=0;for(;i<this.log.size;){if(e?.aborted)return;for(const s of this.log.getSince(i))yield s;i=this.log.nextSeq}for(;!e?.aborted;){for(;t.length>0;){const s=t.shift();s&&(yield s)}t.length===0&&await new Promise(s=>{n=s})}}finally{r(),e?.removeEventListener("abort",o)}}#s(e){const t=this.#i;if(typeof t=="function")return t(e);switch(t){case"ignore":return!1;case"fail":throw new Error(`EventSource: unhandled event type "${e.type}" (seq ${String(e.seq)}). Configure \`unknownEventHandling\` to handle this event or change the strategy.`);default:return console.warn(`[EventSource] unhandled event type "${e.type}" (seq ${String(e.seq)}). The event was skipped. Configure \`unknownEventHandling\` if this is expected.`),!1}}}export{w as EventSource,d as UNHANDLED};