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

package/dist/packem_shared/EventLogDOClient-F4FO8Si4.mjs

@@ -1,92 +0,0 @@
-class EventLogDOClient {
-  #fetch;
-  constructor(options) {
-    this.#fetch = options.fetch;
-  }
-  // ── Append ─────────────────────────────────────────────────────────
-  /**
-   * 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.
-   */
-  async append(events, options) {
-    const body = JSON.stringify({ events, batchId: options?.batchId });
-    const response = await this.#fetch(
-      new Request("https://do/append", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body
-      })
-    );
-    if (!response.ok) {
-      throw await EventLogDOClient.#toError(response, "append");
-    }
-    const data = await response.json();
-    return data.entries;
-  }
-  // ── Read / replay ───────────────────────────────────────────────────
-  /**
-   * Fetch all entries with `seq >= sinceSeq`.
-   *
-   * Pass `sinceSeq = 0` to fetch the entire log.
-   */
-  async getSince(sinceSeq) {
-    const response = await this.#fetch(new Request(`https://do/since?seq=${String(sinceSeq)}`));
-    if (!response.ok) {
-      throw await EventLogDOClient.#toError(response, "getSince");
-    }
-    const data = await response.json();
-    return data.entries;
-  }
-  /**
-   * Fetch a paginated range of entries.
-   * @returns `{ entries, hasMore }` — `hasMore` is `true` when another
-   * page exists (i.e. the DO returned `limit + 1` rows).
-   */
-  async getRange(fromSeq, limit = 50) {
-    const response = await this.#fetch(new Request(`https://do/range?from=${String(fromSeq)}&limit=${String(limit)}`));
-    if (!response.ok) {
-      throw await EventLogDOClient.#toError(response, "getRange");
-    }
-    return await response.json();
-  }
-  /**
-   * Return the total number of entries currently in the log.
-   */
-  async getSize() {
-    const response = await this.#fetch(new Request("https://do/size"));
-    if (!response.ok) {
-      throw await EventLogDOClient.#toError(response, "getSize");
-    }
-    const data = await response.json();
-    return data.count;
-  }
-  /**
-   * Return the full log state — all entries plus the next seq number.
-   */
-  async getState() {
-    const response = await this.#fetch(new Request("https://do/state"));
-    if (!response.ok) {
-      throw await EventLogDOClient.#toError(response, "getState");
-    }
-    return await response.json();
-  }
-  // ── Internal ────────────────────────────────────────────────────────
-  /** Parse an error response body and return a descriptive `Error`. */
-  static async #toError(response, method) {
-    try {
-      const body = await response.json();
-      const message = body.error?.message ?? response.statusText;
-      return new Error(`EventLogDO.${method} failed (${String(response.status)}): ${message}`);
-    } catch {
-      return new Error(`EventLogDO.${method} failed (${String(response.status)}): ${response.statusText}`);
-    }
-  }
-}
-
-export { EventLogDOClient };

package/dist/packem_shared/EventSource-D5yO9_aI.mjs

@@ -1,221 +0,0 @@
-import { EventEmitter } from './EventEmitter-CMZfct03.mjs';
-import { EventLog } from './EventLog-CnK-3Wge.mjs';
-
-const UNHANDLED = /* @__PURE__ */ Symbol("lunora.replica.event-source.unhandled");
-class EventSource {
-  // eslint-disable-next-line unicorn/prefer-event-target -- EventEmitter is the library's typed public API
-  emitter = new EventEmitter();
-  log;
-  #state;
-  #reducer;
-  #replayed = false;
-  #unknownEventHandling;
-  /**
-   * Watermark over the EXTERNAL source log: the highest source `seq` already
-   * applied by {@link EventSource.replayFromLog}, or `-1` when nothing has been applied.
-   * Tracked separately from `this.log.nextSeq` (the destination log, which
-   * `applyEvent` and each replay append advance independently) so a repeated
-   * `replayFromLog` neither skips unseen source entries nor reprocesses
-   * already-applied ones.
-   */
-  #lastAppliedSeq = -1;
-  constructor(initialState, reducer, options) {
-    this.#state = { ...initialState };
-    this.#reducer = reducer;
-    this.#unknownEventHandling = options?.unknownEventHandling ?? "warn";
-    this.log = new EventLog({ maxEntries: options?.maxLogEntries });
-  }
-  // ── Public API ────────────────────────────────────────────────────
-  /**
-   * The current derived state. Read-only snapshot; mutate through events.
-   */
-  get state() {
-    return this.#state;
-  }
-  /**
-   * Whether the initial replay from an existing log has completed.
-   */
-  get replayed() {
-    return this.#replayed;
-  }
-  applyEvent(typeOrEvent, payload, options) {
-    let type;
-    let pl;
-    let resolvedOptions;
-    if (typeof typeOrEvent === "string") {
-      type = typeOrEvent;
-      pl = payload;
-      resolvedOptions = options;
-    } else {
-      type = typeOrEvent.type;
-      pl = typeOrEvent.payload;
-      resolvedOptions = payload;
-    }
-    const candidate = {
-      seq: this.log.nextSeq,
-      type,
-      payload: pl,
-      timestamp: Date.now(),
-      clientId: resolvedOptions?.clientId,
-      sessionId: resolvedOptions?.sessionId,
-      parentSeqNum: resolvedOptions?.parentSeqNum ?? this.log.headSeq ?? void 0
-    };
-    let reduced;
-    try {
-      reduced = this.#reducer(this.#state, candidate);
-    } catch (error) {
-      const normalizedError = error instanceof Error ? error : new Error(String(error));
-      this.emitter.emit("replay-error", {
-        entry: candidate,
-        error: normalizedError
-      });
-      throw normalizedError;
-    }
-    let handledByCallback = true;
-    if (reduced === UNHANDLED) {
-      handledByCallback = this.#handleUnknown(candidate);
-    }
-    const entry = this.log.append(type, pl, void 0, { ...resolvedOptions, timestamp: candidate.timestamp });
-    if (reduced === UNHANDLED) {
-      if (handledByCallback) {
-        this.emitter.emit("state-changed", { state: this.#state, entry });
-      }
-      return entry;
-    }
-    this.#state = reduced;
-    this.emitter.emit("state-changed", { state: this.#state, entry });
-    return entry;
-  }
-  /**
-   * Replay all entries from an existing {@link EventLog} to bootstrap
-   * the current state.
-   *
-   * Idempotent across calls: only source entries past the `#lastAppliedSeq`
-   * watermark are applied, so re-invoking picks up just the new entries.
-   * @param log The external log to replay from.
-   */
-  replayFromLog(log) {
-    const entries = log.getSince(this.#lastAppliedSeq + 1);
-    for (const entry of entries) {
-      try {
-        const reduced = this.#reducer(this.#state, entry);
-        if (reduced !== UNHANDLED) {
-          this.#state = reduced;
-        }
-        this.log.append(entry.type, entry.payload, entry.tableDiffs, {
-          clientId: entry.clientId,
-          sessionId: entry.sessionId,
-          parentSeqNum: entry.parentSeqNum
-        });
-      } catch (error) {
-        this.emitter.emit("replay-error", {
-          entry,
-          error: error instanceof Error ? error : new Error(String(error))
-        });
-      } finally {
-        this.#lastAppliedSeq = entry.seq;
-      }
-    }
-    this.#replayed = true;
-    this.emitter.emit("ready", { entryCount: this.log.size });
-  }
-  /**
-   * Reset the runtime to a base state, optionally resuming from a watermark.
-   *
-   * Useful after loading a snapshot from the DO: pass the snapshot's state as
-   * `initialState` and its highest applied source `seq` as `resumeFromSeq`, so
-   * the next {@link replayFromLog} applies ONLY the events after the snapshot
-   * (`getSince(resumeFromSeq + 1)`) rather than replaying the whole log on top
-   * of the snapshot — which would double-apply non-idempotent reducers.
-   *
-   * Omit `resumeFromSeq` (default `-1`) for a full reset that replays from the
-   * beginning.
-   * @param initialState The base state to reset to (e.g. a loaded snapshot).
-   * @param resumeFromSeq Highest source `seq` already baked into `initialState`, or `-1` to replay all.
-   */
-  reset(initialState, resumeFromSeq = -1) {
-    this.#state = { ...initialState };
-    this.#lastAppliedSeq = resumeFromSeq;
-    this.#replayed = resumeFromSeq >= 0;
-  }
-  /**
-   * Return an async generator that yields every event as it is applied,
-   * 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.
-   * @example
-   * ```ts
-   * for await (const entry of source.events()) {
-   *   console.log("event applied:", entry);
-   * }
-   * ```
-   */
-  async *events(signal) {
-    const buffer = [];
-    let wake;
-    const unsub = this.emitter.on("state-changed", ({ entry }) => {
-      buffer.push(entry);
-      wake?.();
-    });
-    try {
-      let watermark = 0;
-      while (watermark < this.log.size) {
-        if (signal?.aborted) {
-          return;
-        }
-        for (const entry of this.log.getSince(watermark)) {
-          yield entry;
-        }
-        watermark = this.log.nextSeq;
-      }
-      while (!signal?.aborted) {
-        while (buffer.length > 0) {
-          const nextEntry = buffer.shift();
-          if (nextEntry) {
-            yield nextEntry;
-          }
-        }
-        if (buffer.length === 0) {
-          await new Promise((resolve) => {
-            wake = resolve;
-          });
-        }
-      }
-    } finally {
-      unsub();
-    }
-  }
-  // ── Internal ──────────────────────────────────────────────────────
-  /**
-   * Explicit-sentinel detection (not `state === stateBefore` reference
-   * equality) is what lets a reducer legitimately return `state` unchanged
-   * for a type it DOES recognise without being misclassified as unhandled
-   * (REPLICA-07).
-   */
-  #handleUnknown(entry) {
-    const strategy = this.#unknownEventHandling;
-    if (typeof strategy === "function") {
-      return strategy(entry);
-    }
-    switch (strategy) {
-      case "ignore": {
-        return false;
-      }
-      case "fail": {
-        throw new Error(
-          `EventSource: unhandled event type "${entry.type}" (seq ${String(entry.seq)}). Configure \`unknownEventHandling\` to handle this event or change the strategy.`
-        );
-      }
-      default: {
-        console.warn(
-          `[EventSource] unhandled event type "${entry.type}" (seq ${String(entry.seq)}). The event was skipped. Configure \`unknownEventHandling\` if this is expected.`
-        );
-        return false;
-      }
-    }
-  }
-}
-
-export { EventSource, UNHANDLED };

package/dist/packem_shared/EventsSync-BP36tC9O.mjs

@@ -1,123 +0,0 @@
-class EventsSync {
-  #options;
-  /** The highest `seq + 1` that has been applied. Starts at `0`. */
-  #watermark = 0;
-  #timer;
-  /**
-   * The in-flight poll cycle, or `undefined` when idle. A concurrent
-   * `sync()`/timer tick AWAITS this instead of no-op'ing (REPLICA-08) —
-   * previously a concurrent call returned `0` immediately without waiting
-   * for the in-progress cycle to actually finish.
-   */
-  #inFlight;
-  // ── Constructor ─────────────────────────────────────────────────────
-  constructor(options) {
-    this.#options = options;
-  }
-  // ── Public API ──────────────────────────────────────────────────────
-  /**
-   * The current watermark — the next `seq` the sync will fetch from.
-   *
-   * Starts at `0` (fetch everything). Advances to `max(seq) + 1` after
-   * each successful poll cycle.
-   */
-  get watermark() {
-    return this.#watermark;
-  }
-  /**
-   * Start polling for new events on the configured interval.
-   *
-   * Does nothing if polling is already active.
-   * Does **not** perform an initial sync — call {@link sync} once if you
-   * need to catch up immediately.
-   */
-  start() {
-    if (this.#timer !== void 0) {
-      return;
-    }
-    const ms = this.#options.pollInterval ?? 5e3;
-    this.#timer = setInterval(() => {
-      this.#poll().catch(() => void 0);
-    }, ms);
-  }
-  /**
-   * Stop polling for new events.
-   *
-   * Safe to call when not started.
-   */
-  stop() {
-    if (this.#timer !== void 0) {
-      clearInterval(this.#timer);
-      this.#timer = void 0;
-    }
-  }
-  /**
-   * Perform a one-shot sync: fetch events since the current watermark,
-   * apply them through the state machine, and push diffs to the mirror.
-   * @returns The number of events that were fetched and applied.
-   */
-  async sync() {
-    return this.#poll();
-  }
-  // ── Internal ────────────────────────────────────────────────────────
-  /**
-   * Entry point for a poll cycle. A cycle already in flight is AWAITED
-   * (not restarted, not no-op'd) so a `sync()` racing a timer tick — or two
-   * concurrent `sync()` calls — observes the real outcome of the one cycle
-   * that actually runs (REPLICA-08).
-   */
-  async #poll() {
-    if (this.#inFlight) {
-      return this.#inFlight;
-    }
-    const promise = this.#pollOnce().finally(() => {
-      this.#inFlight = void 0;
-    });
-    this.#inFlight = promise;
-    return promise;
-  }
-  /**
-   * One poll cycle: fetch → (apply → diff → mirror) per event.
-   *
-   * Each event is driven through the FULL pipeline — `applyEvents`,
-   * `getTableDiffs`, and `mirror.applyDiff` — atomically before the
-   * watermark advances past it (REPLICA-08). Advancing the watermark any
-   * earlier (e.g. right after `applyEvents`) would let a later throw from
-   * `getTableDiffs`/`mirror.applyDiff` skip mirror delivery for that event
-   * PERMANENTLY, since the next poll would never re-fetch it. Keeping the
-   * watermark pinned to the last event whose entire pipeline succeeded
-   * means the next poll re-fetches exactly the unapplied remainder — never
-   * re-applying a fully-succeeded event, never silently dropping one that
-   * partially failed.
-   */
-  async #pollOnce() {
-    try {
-      const events = await this.#options.fetchEventsSince(this.#watermark);
-      if (events.length === 0) {
-        return 0;
-      }
-      let appliedCount = 0;
-      try {
-        for (const event of events) {
-          this.#options.applyEvents([event]);
-          const diffs = this.#options.getTableDiffs();
-          for (const diff of diffs) {
-            this.#options.mirror.applyDiff(diff);
-          }
-          this.#watermark = event.seq + 1;
-          appliedCount += 1;
-        }
-      } catch (error) {
-        const onError = this.#options.onError ?? console.error;
-        onError(error);
-      }
-      return appliedCount;
-    } catch (error) {
-      const onError = this.#options.onError ?? console.error;
-      onError(error);
-      return 0;
-    }
-  }
-}
-
-export { EventsSync };

package/dist/packem_shared/InMemorySnapshotStore-BHVAD-Bp.mjs

@@ -1,24 +0,0 @@
-class InMemorySnapshotStore {
-  #store = /* @__PURE__ */ new Map();
-  save(key, snapshot) {
-    this.#store.set(key, structuredClone(snapshot));
-    return Promise.resolve();
-  }
-  load(key) {
-    const value = this.#store.get(key);
-    return Promise.resolve(value === void 0 ? null : structuredClone(value));
-  }
-  list() {
-    return Promise.resolve([...this.#store.keys()]);
-  }
-  delete(key) {
-    this.#store.delete(key);
-    return Promise.resolve();
-  }
-  clear() {
-    this.#store.clear();
-    return Promise.resolve();
-  }
-}
-
-export { InMemorySnapshotStore };

package/dist/packem_shared/LocalMirror-a-5jEqFN.mjs

@@ -1,219 +0,0 @@
-import { createSqlJsAdapter } from '../adapters/sqljs.mjs';
-import { applyDiffToDb as applyDiffToDatabase, escapeIdentifier } from './applyDiffToDb-DQ1xZp5J.mjs';
-import { EventLog } from './EventLog-CnK-3Wge.mjs';
-
-const MIRROR_META_TABLE = "__lunora_mirror_meta";
-const ensureMetaTable = (database) => {
-  database.exec(
-    `CREATE TABLE IF NOT EXISTS ${MIRROR_META_TABLE} (
-            key   TEXT PRIMARY KEY NOT NULL,
-            value TEXT NOT NULL
-        )`
-  );
-};
-class LocalMirror {
-  #db;
-  #tables;
-  #eventLog;
-  #changeListeners = /* @__PURE__ */ new Set();
-  /**
-   * Monotonically increasing counter bumped on every state-changing
-   * operation (`applyDiff`, `clearData`) — independent of `eventLog.size`.
-   * `clearData` doesn't grow the log (REPLICA-09), so a consumer that used
-   * `eventLog.size` as its `useSyncExternalStore` snapshot would never
-   * re-render after a clear; `version` changes on both operations.
-   */
-  #version = 0;
-  /**
-   * Convenience factory that creates a {@link LocalMirror} backed by a
-   * {@link createSqlJsAdapter sql.js adapter} without needing to import
-   * and wire sql.js manually.
-   *
-   * The caller provides an initialised sql.js database — this method wraps
-   * it in an adapter and constructs the mirror.
-   * @example
-   * ```ts
-   * import initSqlJs from "sql.js";
-   *
-   * const SQL = await initSqlJs();
-   * const mirror = LocalMirror.create(new SQL.Database(), {
-   *   tables: { todos: { primaryKey: "id" } },
-   * });
-   * ```
-   */
-  static create(sqlJsDatabase, options) {
-    const adapter = createSqlJsAdapter(sqlJsDatabase);
-    return new LocalMirror({ db: adapter, tables: options?.tables });
-  }
-  constructor(options) {
-    this.#db = options.db;
-    this.#tables = { ...options.tables };
-    this.#eventLog = new EventLog({ maxEntries: options.maxEventLogEntries });
-    ensureMetaTable(this.#db);
-  }
-  /**
-   * Subscribe to data-change notifications. Fires after every {@link applyDiff}.
-   * Returns an unsubscribe function.
-   */
-  onChange(callback) {
-    this.#changeListeners.add(callback);
-    return () => {
-      this.#changeListeners.delete(callback);
-    };
-  }
-  // ── Public API ─────────────────────────────────────────────────────
-  /**
-   * The in-memory event log tracking every diff applied to this mirror.
-   * Use {@link EventLog.getSince} for catch-up replication across tabs
-   * or service-worker instances.
-   */
-  get eventLog() {
-    return this.#eventLog;
-  }
-  /**
-   * The raw SQLite adapter. Advanced consumers (e.g. the React hook)
-   * can use it for ad-hoc queries or bulk operations.
-   */
-  get db() {
-    return this.#db;
-  }
-  /**
-   * Monotonically increasing version counter, bumped on every operation
-   * that changes mirrored data (`applyDiff`, `clearData`). Use this — not
-   * `eventLog.size` — as a `useSyncExternalStore` snapshot so operations
-   * that don't append to the log still trigger a re-render.
-   */
-  get version() {
-    return this.#version;
-  }
-  /**
-   * Apply a server-side diff to the local SQLite mirror.
-   *
-   * The diff is applied in a transaction and recorded in the event log
-   * so other tabs or the SW can catch up.
-   */
-  applyDiff(diff) {
-    if (diff.changes.length === 0) {
-      return;
-    }
-    const pkColumn = this.#tables[diff.table]?.primaryKey ?? "id";
-    this.#ensureTableSchema(diff);
-    applyDiffToDatabase(this.#db, diff, pkColumn);
-    this.#eventLog.append("table-diff", diff, [diff]);
-    this.#version += 1;
-    for (const listener of this.#changeListeners) {
-      try {
-        listener();
-      } catch {
-      }
-    }
-  }
-  /**
-   * Run an arbitrary SQL query against the local mirror and return
-   * typed results.
-   * @example
-   * ```ts
-   * const users = mirror.query<{ id: string; name: string }>(
-   *   "SELECT id, name FROM users WHERE active = ?",
-   *   [true],
-   * );
-   * ```
-   */
-  query(sql, params) {
-    return this.#db.query(sql, params);
-  }
-  /**
-   * Delete every row from all known tables (preserves the event log
-   * and schema). Useful when re-syncing from scratch.
-   *
-   * Notifies `onChange` subscribers and bumps {@link LocalMirror.version}
-   * (REPLICA-09) even though nothing is appended to the event log — a
-   * consumer keyed only on `eventLog.size` would otherwise never learn the
-   * mirror was cleared and keep rendering deleted rows.
-   */
-  clearData() {
-    const tables = this.#db.query(
-      String.raw`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '\_\_lunora\_%' ESCAPE '\' AND name NOT LIKE 'sqlite\_%' ESCAPE '\'`
-    );
-    this.#db.transaction(() => {
-      for (const { name } of tables) {
-        this.#db.exec(`DELETE FROM ${escapeIdentifier(name)}`);
-      }
-    });
-    this.#version += 1;
-    for (const listener of this.#changeListeners) {
-      try {
-        listener();
-      } catch {
-      }
-    }
-  }
-  /**
-   * Dispose the mirror and close the database connection.
-   */
-  close() {
-    this.#db.close();
-    this.#eventLog.clear();
-  }
-  // ── Schema helpers ─────────────────────────────────────────────────
-  /**
-   * Register a table schema so the mirror can create the table on
-   * first use.
-   */
-  registerTable(name, definition) {
-    this.#tables[name] = definition;
-  }
-  /**
-   * Return the list of mirrored table names.
-   */
-  get mirroredTables() {
-    return Object.keys(this.#tables);
-  }
-  // ── Internal ───────────────────────────────────────────────────────
-  /**
-   * Derive the UNION of non-PK column names across every non-delete change.
-   * @param diff The table diff whose changes are scanned.
-   * @param pk The primary-key column to exclude from the result.
-   */
-  static #collectDiffColumns(diff, pk) {
-    const requiredColumns = /* @__PURE__ */ new Set();
-    for (const change of diff.changes) {
-      if (change.type === "delete") {
-        continue;
-      }
-      for (const key of Object.keys(change.data)) {
-        if (key !== pk) {
-          requiredColumns.add(key);
-        }
-      }
-    }
-    return requiredColumns;
-  }
-  /**
-   * Ensure the target table exists with all columns needed by the diff.
-   *
-   * - If the table doesn't exist yet, CREATE it with columns derived from the diff data (PK + every non-delete column).
-   * - If the table already exists, ALTER TABLE ADD COLUMN for any keys in the diff that don't have a corresponding column yet (schema evolution).
-   */
-  #ensureTableSchema(diff) {
-    const pk = this.#tables[diff.table]?.primaryKey ?? "id";
-    const requiredColumns = LocalMirror.#collectDiffColumns(diff, pk);
-    const existing = this.#db.query(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [diff.table]);
-    if (existing.length === 0) {
-      let columnDefs = `${escapeIdentifier(pk)} TEXT PRIMARY KEY NOT NULL`;
-      for (const key of requiredColumns) {
-        columnDefs += `, ${escapeIdentifier(key)} TEXT`;
-      }
-      this.#db.exec(`CREATE TABLE IF NOT EXISTS ${escapeIdentifier(diff.table)} (${columnDefs})`);
-    } else if (requiredColumns.size > 0) {
-      const existingColumns = new Set(this.#db.query(`PRAGMA table_info(${escapeIdentifier(diff.table)})`).map((row) => row.name));
-      for (const key of requiredColumns) {
-        if (!existingColumns.has(key)) {
-          this.#db.exec(`ALTER TABLE ${escapeIdentifier(diff.table)} ADD COLUMN ${escapeIdentifier(key)} TEXT`);
-        }
-      }
-    }
-  }
-}
-
-export { LocalMirror };