@lunora/replica 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/adapters/sqlite-wasm.d.mts

@@ -6,21 +6,31 @@ import { S as SqliteAdapter } from "../packem_shared/types.d-BuAWjEY5.mjs";
 * The adapter takes a structural projection of the OO API (`sqlite3.oo1.DB`) so
 * the package never imports from `@sqlite.org/sqlite-wasm` directly — consumers
 * install it themselves and pass in their database instance.
+*
+* IMPORTANT (REPLICA-01): the real `oo1.DB.exec()` does NOT return sql.js's
+* `{ columns, values }[]` result shape — with `rowMode: "object"` and
+* `returnValue: "resultRows"` it returns the rows directly, as
+* `Record<string, unknown>[]`. This adapter is written against that real
+* shape; `lastInsertRowId` uses the driver's `selectValue()` convenience
+* method (a single-scalar query helper) rather than parsing a result-row
+* array.
 * @param database An already-initialised `sqlite3.oo1.DB` instance.
 * @param database.close Tear down the database connection.
-* @param database.exec Execute SQL with optional bind params and return rows
-* as `{ columns, values }` result objects.
+* @param database.exec Execute SQL with optional bind params. With
+* `{ returnValue: "resultRows", rowMode: "object" }` it returns the matched
+* rows directly (`Record<string, unknown>[]`); otherwise (DDL/DML/BEGIN/
+* COMMIT/ROLLBACK) its return value is unused here.
+* @param database.selectValue Run a query and return the first column of the
+* first row as a single scalar — used for `SELECT last_insert_rowid()`.
 * @experimental
 */
 declare const createSqliteWasmAdapter: (database: {
   close: () => void;
   exec: (sql: string, options?: {
     bind?: unknown[];
-    returnValue?: "resultRows" | "simple";
-    rowMode?: "array" | "object";
-  }) => {
-    columns: string[];
-    values: unknown[][];
-  }[];
+    returnValue?: "resultRows";
+    rowMode?: "object";
+  }) => Record<string, unknown>[] | undefined;
+  selectValue: (sql: string, bind?: unknown[]) => unknown;
 }) => SqliteAdapter;
 export { createSqliteWasmAdapter };

package/dist/adapters/sqlite-wasm.d.ts

@@ -6,21 +6,31 @@ import { S as SqliteAdapter } from "../packem_shared/types.d-BuAWjEY5.js";
 * The adapter takes a structural projection of the OO API (`sqlite3.oo1.DB`) so
 * the package never imports from `@sqlite.org/sqlite-wasm` directly — consumers
 * install it themselves and pass in their database instance.
+*
+* IMPORTANT (REPLICA-01): the real `oo1.DB.exec()` does NOT return sql.js's
+* `{ columns, values }[]` result shape — with `rowMode: "object"` and
+* `returnValue: "resultRows"` it returns the rows directly, as
+* `Record<string, unknown>[]`. This adapter is written against that real
+* shape; `lastInsertRowId` uses the driver's `selectValue()` convenience
+* method (a single-scalar query helper) rather than parsing a result-row
+* array.
 * @param database An already-initialised `sqlite3.oo1.DB` instance.
 * @param database.close Tear down the database connection.
-* @param database.exec Execute SQL with optional bind params and return rows
-* as `{ columns, values }` result objects.
+* @param database.exec Execute SQL with optional bind params. With
+* `{ returnValue: "resultRows", rowMode: "object" }` it returns the matched
+* rows directly (`Record<string, unknown>[]`); otherwise (DDL/DML/BEGIN/
+* COMMIT/ROLLBACK) its return value is unused here.
+* @param database.selectValue Run a query and return the first column of the
+* first row as a single scalar — used for `SELECT last_insert_rowid()`.
 * @experimental
 */
 declare const createSqliteWasmAdapter: (database: {
   close: () => void;
   exec: (sql: string, options?: {
     bind?: unknown[];
-    returnValue?: "resultRows" | "simple";
-    rowMode?: "array" | "object";
-  }) => {
-    columns: string[];
-    values: unknown[][];
-  }[];
+    returnValue?: "resultRows";
+    rowMode?: "object";
+  }) => Record<string, unknown>[] | undefined;
+  selectValue: (sql: string, bind?: unknown[]) => unknown;
 }) => SqliteAdapter;
 export { createSqliteWasmAdapter };

package/dist/adapters/sqlite-wasm.mjs

@@ -8,22 +8,12 @@ const createSqliteWasmAdapter = (database) => {
       }
     },
     query(sql, params) {
-      const options = params && params.length > 0 ? { bind: [...params], returnValue: "resultRows" } : { returnValue: "resultRows" };
-      const result = database.exec(sql, options);
-      const first = result[0];
-      if (!first) {
-        return [];
-      }
-      const colNames = first.columns;
-      const rows = [];
-      for (const row of first.values) {
-        const object = {};
-        for (const [i, column] of colNames.entries()) {
-          object[column] = row[i];
-        }
-        rows.push(object);
-      }
-      return rows;
+      const rows = database.exec(sql, {
+        bind: params && params.length > 0 ? [...params] : void 0,
+        returnValue: "resultRows",
+        rowMode: "object"
+      });
+      return rows ?? [];
     },
     transaction(function_) {
       database.exec("BEGIN");
@@ -36,16 +26,14 @@ const createSqliteWasmAdapter = (database) => {
       }
     },
     lastInsertRowId() {
-      const result = database.exec("SELECT last_insert_rowid() AS id", { returnValue: "resultRows" });
-      const firstRow = result[0];
-      if (result.length === 0 || !firstRow || firstRow.values.length === 0) {
-        return -1;
+      const value = database.selectValue("SELECT last_insert_rowid()");
+      if (typeof value === "number") {
+        return value;
       }
-      const value = firstRow.values[0];
-      if (!value || value.length === 0) {
-        return -1;
+      if (typeof value === "bigint") {
+        return Number(value);
       }
-      return Number(value[0]);
+      return -1;
     },
     close() {
       database.close();

package/dist/index.d.mts

@@ -2,8 +2,8 @@ export { 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-BuAWjEY5.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-BUeOe5KC.mjs";
-export { type C as ClientSeq, type b as EventLogSnapshot, type G as GlobalSeq, type c as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, d as classifyChanges, e as createTableDiff, f as diffSize, i as isClientSeq, g as isDiffEmpty, h as isGlobalSeq, j as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-BUeOe5KC.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-DL1XJBB3.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-DL1XJBB3.mjs";
 /**
 * Apply a single {@link TableDiff} to an in-memory row map and return
 * the updated map.
@@ -166,9 +166,17 @@ declare class EventLogDOClient {
   constructor(options: EventLogDOClientOptions);
   /**
   * Append one or more events to the log.
+  * @param events The events to append.
+  * @param options Idempotency controls for the batch.
+  * @param options.batchId Optional idempotency key for the whole batch — a
+  * retried `append` call with the same `batchId` (e.g. after a network
+  * timeout that hid a successful response) returns the originally-persisted
+  * entries instead of inserting duplicates.
   * @returns The persisted entries with their assigned `seq` numbers.
   */
-  append(events: AppendEventInput[]): Promise<EventLogEntry[]>;
+  append(events: AppendEventInput[], options?: {
+    batchId?: string;
+  }): Promise<EventLogEntry[]>;
   /**
   * Fetch all entries with `seq >= sinceSeq`.
   *
@@ -284,18 +292,50 @@ type EventSourceEvents = {
   };
 };
 /**
+* Sentinel a reducer can return to EXPLICITLY signal it does not handle a
+* given event's `type` — as opposed to returning the current `state`
+* reference unchanged to represent a legitimate, idempotent no-op for a type
+* it DOES recognise.
+*
+* Reference equality alone can't tell these two cases apart (REPLICA-07): a
+* reducer that intentionally returns `state` for a type it fully understands
+* (e.g. "already applied this event, nothing to do") would otherwise be
+* misclassified as "unhandled" and trigger {@link UnknownEventHandling} — a
+* spurious warning, or worse, a thrown error under `"fail"`. Return `UNHANDLED`
+* only for a `type` your reducer truly does not recognise; every other return
+* (including a `state` returned by reference) is treated as handled.
+*
+* Reducers that always recognise every event they're given (a single
+* always-matching type, or a catch-all) can ignore this entirely.
+* @experimental
+*/
+declare const UNHANDLED: unique symbol;
+/**
 * A function that reduces an event into a state mutation.
 *
 * Pure functions are strongly encouraged: given the same event payload
-* and state, they must produce the same next state.
+* and state, they must produce the same next state. Return {@link UNHANDLED}
+* to explicitly mark an event `type` this reducer does not process — see
+* {@link UNHANDLED} for why reference equality against the input `state`
+* cannot be used for this instead.
 * @experimental
 */
-type EventReducer<S> = (state: S, entry: EventLogEntry) => S;
+type EventReducer<S> = (state: S, entry: EventLogEntry) => S | typeof UNHANDLED;
 /**
 * Options for constructing an {@link EventSource}.
 * @experimental
 */
 interface EventSourceOptions {
+  /**
+  * Cap this runtime's internal `log` to this many entries (REPLICA-06).
+  * `replayFromLog` copies every entry it replays from the source log into
+  * `this.log` too — a second, uncapped copy of the same history — so a
+  * long-lived `EventSource` fed by repeated replay accumulates entries in
+  * both places forever without a cap.
+  *
+  * `undefined` (the default) preserves unbounded retention.
+  */
+  maxLogEntries?: number;
   /**
   * How to handle events whose `type` is not recognised by the reducer.
   * @default "warn"
@@ -506,27 +546,38 @@ declare class MaterializerRuntime {
   #private;
   constructor(materializers: AnyMaterializer[], options?: MaterializerRuntimeOptions);
   /**
-  * The sequence number of the last event applied to all materializers.
+  * The lowest per-materializer watermark — the seq of the next event that
+  * at least one materializer has not yet applied. `0` when there are no
+  * materializers.
   */
   get appliedSeq(): number;
   /**
-  * Replay a batch of entries through all materializers.
-  *
-  * Entries with `seq < this.appliedSeq` are silently skipped (idempotent).
-  * @returns The number of entries actually applied.
+  * Replay a batch of entries, applying each entry only to the
+  * materializers whose own watermark is behind it — a materializer at or
+  * past an entry's seq (e.g. recovered from a snapshot, or already caught
+  * up) skips it, so no materializer ever double-applies an event.
+  * @returns The number of entries applied to at least one materializer.
   */
   applyEntries(entries: ReadonlyArray<EventLogEntry>): number;
   /**
   * Attempt to recover materialized state from a snapshot store.
   *
-  * When a snapshot is found for a materializer, its state is restored
-  * and the snapshot's watermark (`appliedSeq`) is returned so the caller
-  * can skip replaying entries up to that point.
-  * @returns The highest `appliedSeq` across all recovered snapshots, or `0`.
+  * When a snapshot is found for a materializer, its state AND its own
+  * watermark are restored from that snapshot. A materializer with no
+  * snapshot keeps its current watermark (`0` for a fresh runtime) — it
+  * does NOT inherit another materializer's watermark, so it still catches
+  * up from the very beginning (REPLICA-04: previously a shared watermark
+  * was bumped to the MAX across snapshots, permanently skipping events 0..N
+  * for any un-snapshotted or lagging materializer).
+  * @returns The highest snapshot `appliedSeq` across all materializers, or
+  * `0` — kept for backward compatibility; callers that need the fetch
+  * watermark for catch-up should use the per-materializer minimum instead
+  * (see `initialize`).
   */
   recoverFromSnapshots(): Promise<number>;
   /**
-  * Persist the current state of all materializers as snapshots.
+  * Persist the current state of all materializers as snapshots, each
+  * tagged with ITS OWN watermark (not a shared one).
   */
   persistSnapshots(): Promise<void>;
   /**
@@ -534,8 +585,11 @@ declare class MaterializerRuntime {
   *
   * 1. Recover materialized state from snapshots (if a snapshotStore is
   * configured).
-  * 2. Fetch all entries since the recovered watermark from the DO.
-  * 3. Apply them through the materializers.
+  * 2. Fetch all 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.
   *
   * Call this once on startup / after the DO binding is available.
   * @returns The number of entries applied during catch-up.
@@ -584,6 +638,13 @@ interface EventLogDOState {
     sql: {
       exec: (query: string, ...params: unknown[]) => unknown;
     };
+    /**
+    * The DO platform's native atomic-transaction primitive (async;
+    * commits on resolve, rolls back on throw/reject). Test doubles that
+    * omit it fall back to a bare (non-transactional) call — see
+    * `#handleAppend`.
+    */
+    transaction?: <T>(closure: () => Promise<T> | T) => Promise<T>;
   };
 }
 /**
@@ -907,4 +968,4 @@ declare class EventsSync {
   */
   sync(): Promise<number>;
 }
-export { type AppendEventInput, type AppendOptions, type EventCallback, EventEmitter, type EventFactory, EventLog, EventLogDO, EventLogDOClient, type EventLogDOClientOptions, type EventLogEntry, type EventNamespace, type EventReducer, EventSource, type EventSourceEvents, type EventSourceOptions, type EventsContextOutput, type EventsDefinition, type EventsFacade, EventsSync, type EventsSyncOptions, InMemorySnapshotStore, type InputEvent, LocalMirror, type Materializer, type MaterializerDef, type MaterializerReducer, MaterializerRuntime, type MaterializerRuntimeOptions, type Seq, type SnapshotStore, type SqliteAdapter, type StateChangeCallback, type SubscriptionClient, SubscriptionManager, type TableDiff, type UnknownEventHandling, applyDiff, applyDiffToDatabase as applyDiffToDb, applyDiffToSnapshot, applyDiffs, applyDiffsToDatabase as applyDiffsToDb, defineEvents, defineMaterializer, eventsContext, subscribeToMirror };
+export { type AppendEventInput, type AppendOptions, type EventCallback, EventEmitter, type EventFactory, EventLog, EventLogDO, EventLogDOClient, type EventLogDOClientOptions, type EventLogEntry, type EventNamespace, type EventReducer, EventSource, type EventSourceEvents, type EventSourceOptions, type EventsContextOutput, type EventsDefinition, type EventsFacade, EventsSync, type EventsSyncOptions, InMemorySnapshotStore, type InputEvent, LocalMirror, type Materializer, type MaterializerDef, type MaterializerReducer, MaterializerRuntime, type MaterializerRuntimeOptions, type Seq, type SnapshotStore, type SqliteAdapter, type StateChangeCallback, type SubscriptionClient, SubscriptionManager, type TableDiff, UNHANDLED, type UnknownEventHandling, applyDiff, applyDiffToDatabase as applyDiffToDb, applyDiffToSnapshot, applyDiffs, applyDiffsToDatabase as applyDiffsToDb, defineEvents, defineMaterializer, eventsContext, subscribeToMirror };

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { 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-BuAWjEY5.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-Cd8tAg-W.js";
-export { type C as ClientSeq, type b as EventLogSnapshot, type G as GlobalSeq, type c as LocalMirrorOptions, type M as MirrorTableDef, type R as RowChange, d as classifyChanges, e as createTableDiff, f as diffSize, i as isClientSeq, g as isDiffEmpty, h as isGlobalSeq, j as isInputEvent, m as mergeDiffs } from "./packem_shared/local-mirror.d-Cd8tAg-W.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-ByIjd7sW.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-ByIjd7sW.js";
 /**
 * Apply a single {@link TableDiff} to an in-memory row map and return
 * the updated map.
@@ -166,9 +166,17 @@ declare class EventLogDOClient {
   constructor(options: EventLogDOClientOptions);
   /**
   * Append one or more events to the log.
+  * @param events The events to append.
+  * @param options Idempotency controls for the batch.
+  * @param options.batchId Optional idempotency key for the whole batch — a
+  * retried `append` call with the same `batchId` (e.g. after a network
+  * timeout that hid a successful response) returns the originally-persisted
+  * entries instead of inserting duplicates.
   * @returns The persisted entries with their assigned `seq` numbers.
   */
-  append(events: AppendEventInput[]): Promise<EventLogEntry[]>;
+  append(events: AppendEventInput[], options?: {
+    batchId?: string;
+  }): Promise<EventLogEntry[]>;
   /**
   * Fetch all entries with `seq >= sinceSeq`.
   *
@@ -284,18 +292,50 @@ type EventSourceEvents = {
   };
 };
 /**
+* Sentinel a reducer can return to EXPLICITLY signal it does not handle a
+* given event's `type` — as opposed to returning the current `state`
+* reference unchanged to represent a legitimate, idempotent no-op for a type
+* it DOES recognise.
+*
+* Reference equality alone can't tell these two cases apart (REPLICA-07): a
+* reducer that intentionally returns `state` for a type it fully understands
+* (e.g. "already applied this event, nothing to do") would otherwise be
+* misclassified as "unhandled" and trigger {@link UnknownEventHandling} — a
+* spurious warning, or worse, a thrown error under `"fail"`. Return `UNHANDLED`
+* only for a `type` your reducer truly does not recognise; every other return
+* (including a `state` returned by reference) is treated as handled.
+*
+* Reducers that always recognise every event they're given (a single
+* always-matching type, or a catch-all) can ignore this entirely.
+* @experimental
+*/
+declare const UNHANDLED: unique symbol;
+/**
 * A function that reduces an event into a state mutation.
 *
 * Pure functions are strongly encouraged: given the same event payload
-* and state, they must produce the same next state.
+* and state, they must produce the same next state. Return {@link UNHANDLED}
+* to explicitly mark an event `type` this reducer does not process — see
+* {@link UNHANDLED} for why reference equality against the input `state`
+* cannot be used for this instead.
 * @experimental
 */
-type EventReducer<S> = (state: S, entry: EventLogEntry) => S;
+type EventReducer<S> = (state: S, entry: EventLogEntry) => S | typeof UNHANDLED;
 /**
 * Options for constructing an {@link EventSource}.
 * @experimental
 */
 interface EventSourceOptions {
+  /**
+  * Cap this runtime's internal `log` to this many entries (REPLICA-06).
+  * `replayFromLog` copies every entry it replays from the source log into
+  * `this.log` too — a second, uncapped copy of the same history — so a
+  * long-lived `EventSource` fed by repeated replay accumulates entries in
+  * both places forever without a cap.
+  *
+  * `undefined` (the default) preserves unbounded retention.
+  */
+  maxLogEntries?: number;
   /**
   * How to handle events whose `type` is not recognised by the reducer.
   * @default "warn"
@@ -506,27 +546,38 @@ declare class MaterializerRuntime {
   #private;
   constructor(materializers: AnyMaterializer[], options?: MaterializerRuntimeOptions);
   /**
-  * The sequence number of the last event applied to all materializers.
+  * The lowest per-materializer watermark — the seq of the next event that
+  * at least one materializer has not yet applied. `0` when there are no
+  * materializers.
   */
   get appliedSeq(): number;
   /**
-  * Replay a batch of entries through all materializers.
-  *
-  * Entries with `seq < this.appliedSeq` are silently skipped (idempotent).
-  * @returns The number of entries actually applied.
+  * Replay a batch of entries, applying each entry only to the
+  * materializers whose own watermark is behind it — a materializer at or
+  * past an entry's seq (e.g. recovered from a snapshot, or already caught
+  * up) skips it, so no materializer ever double-applies an event.
+  * @returns The number of entries applied to at least one materializer.
   */
   applyEntries(entries: ReadonlyArray<EventLogEntry>): number;
   /**
   * Attempt to recover materialized state from a snapshot store.
   *
-  * When a snapshot is found for a materializer, its state is restored
-  * and the snapshot's watermark (`appliedSeq`) is returned so the caller
-  * can skip replaying entries up to that point.
-  * @returns The highest `appliedSeq` across all recovered snapshots, or `0`.
+  * When a snapshot is found for a materializer, its state AND its own
+  * watermark are restored from that snapshot. A materializer with no
+  * snapshot keeps its current watermark (`0` for a fresh runtime) — it
+  * does NOT inherit another materializer's watermark, so it still catches
+  * up from the very beginning (REPLICA-04: previously a shared watermark
+  * was bumped to the MAX across snapshots, permanently skipping events 0..N
+  * for any un-snapshotted or lagging materializer).
+  * @returns The highest snapshot `appliedSeq` across all materializers, or
+  * `0` — kept for backward compatibility; callers that need the fetch
+  * watermark for catch-up should use the per-materializer minimum instead
+  * (see `initialize`).
   */
   recoverFromSnapshots(): Promise<number>;
   /**
-  * Persist the current state of all materializers as snapshots.
+  * Persist the current state of all materializers as snapshots, each
+  * tagged with ITS OWN watermark (not a shared one).
   */
   persistSnapshots(): Promise<void>;
   /**
@@ -534,8 +585,11 @@ declare class MaterializerRuntime {
   *
   * 1. Recover materialized state from snapshots (if a snapshotStore is
   * configured).
-  * 2. Fetch all entries since the recovered watermark from the DO.
-  * 3. Apply them through the materializers.
+  * 2. Fetch all 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.
   *
   * Call this once on startup / after the DO binding is available.
   * @returns The number of entries applied during catch-up.
@@ -584,6 +638,13 @@ interface EventLogDOState {
     sql: {
       exec: (query: string, ...params: unknown[]) => unknown;
     };
+    /**
+    * The DO platform's native atomic-transaction primitive (async;
+    * commits on resolve, rolls back on throw/reject). Test doubles that
+    * omit it fall back to a bare (non-transactional) call — see
+    * `#handleAppend`.
+    */
+    transaction?: <T>(closure: () => Promise<T> | T) => Promise<T>;
   };
 }
 /**
@@ -907,4 +968,4 @@ declare class EventsSync {
   */
   sync(): Promise<number>;
 }
-export { type AppendEventInput, type AppendOptions, type EventCallback, EventEmitter, type EventFactory, EventLog, EventLogDO, EventLogDOClient, type EventLogDOClientOptions, type EventLogEntry, type EventNamespace, type EventReducer, EventSource, type EventSourceEvents, type EventSourceOptions, type EventsContextOutput, type EventsDefinition, type EventsFacade, EventsSync, type EventsSyncOptions, InMemorySnapshotStore, type InputEvent, LocalMirror, type Materializer, type MaterializerDef, type MaterializerReducer, MaterializerRuntime, type MaterializerRuntimeOptions, type Seq, type SnapshotStore, type SqliteAdapter, type StateChangeCallback, type SubscriptionClient, SubscriptionManager, type TableDiff, type UnknownEventHandling, applyDiff, applyDiffToDatabase as applyDiffToDb, applyDiffToSnapshot, applyDiffs, applyDiffsToDatabase as applyDiffsToDb, defineEvents, defineMaterializer, eventsContext, subscribeToMirror };
+export { type AppendEventInput, type AppendOptions, type EventCallback, EventEmitter, type EventFactory, EventLog, EventLogDO, EventLogDOClient, type EventLogDOClientOptions, type EventLogEntry, type EventNamespace, type EventReducer, EventSource, type EventSourceEvents, type EventSourceOptions, type EventsContextOutput, type EventsDefinition, type EventsFacade, EventsSync, type EventsSyncOptions, InMemorySnapshotStore, type InputEvent, LocalMirror, type Materializer, type MaterializerDef, type MaterializerReducer, MaterializerRuntime, type MaterializerRuntimeOptions, type Seq, type SnapshotStore, type SqliteAdapter, type StateChangeCallback, type SubscriptionClient, SubscriptionManager, type TableDiff, UNHANDLED, type UnknownEventHandling, applyDiff, applyDiffToDatabase as applyDiffToDb, applyDiffToSnapshot, applyDiffs, applyDiffsToDatabase as applyDiffsToDb, defineEvents, defineMaterializer, eventsContext, subscribeToMirror };

package/dist/index.mjs

@@ -1,20 +1,20 @@
 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-BtbIl1D3.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-HqNXqJxp.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-zMy7AYP4.mjs';
-export { EventLogDO } from './packem_shared/EventLogDO-CZYUvvSr.mjs';
-export { EventLogDOClient } from './packem_shared/EventLogDOClient-DGiEdi96.mjs';
-export { EventSource } from './packem_shared/EventSource-DfV4VoRD.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-GeJ26eNe.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-DkVbU0WV.mjs';
-export { classifyChanges, createTableDiff, diffSize, isDiffEmpty, mergeDiffs } from './packem_shared/classifyChanges-aZmkxgVI.mjs';
+export { EventsSync } from './packem_shared/EventsSync-BP36tC9O.mjs';
+export { classifyChanges, createTableDiff, diffSize, isDiffEmpty, mergeDiffs } from './packem_shared/classifyChanges-RcqLBpLs.mjs';