@lunora/replica 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/EventLogDO-CZYUvvSr.mjs

@@ -1,235 +0,0 @@
-const toArray = (cursor) => {
-  if (typeof cursor.toArray === "function") {
-    return cursor.toArray();
-  }
-  if (typeof cursor[Symbol.iterator] === "function") {
-    return [...cursor];
-  }
-  return [];
-};
-const rowsToEntries = (cursor) => {
-  const rows = toArray(cursor);
-  return rows.map((row) => {
-    return {
-      seq: row.seq,
-      type: row.type,
-      payload: JSON.parse(row.payload),
-      timestamp: row.timestamp,
-      clientId: row.client_id ?? void 0,
-      sessionId: row.session_id ?? void 0,
-      parentSeqNum: row.parent_seq ?? void 0
-    };
-  });
-};
-class EventLogDO {
-  state;
-  env;
-  /** Whether the `events` table has been created. */
-  #initialized = false;
-  constructor(state, env) {
-    this.state = state;
-    this.env = env;
-  }
-  // ── Fetch (RPC dispatch) ──────────────────────────────────────────
-  async fetch(request) {
-    this.#ensureTable();
-    const url = new URL(request.url);
-    try {
-      if (request.method === "POST" && url.pathname === "/append") {
-        return await this.#handleAppend(request);
-      }
-      if (request.method === "GET" && url.pathname === "/since") {
-        return this.#handleSince(url);
-      }
-      if (request.method === "GET" && url.pathname === "/range") {
-        return this.#handleRange(url);
-      }
-      if (request.method === "GET" && url.pathname === "/size") {
-        return this.#handleSize();
-      }
-      if (request.method === "GET" && url.pathname === "/state") {
-        return this.#handleState();
-      }
-    } catch (error) {
-      console.error("[event-log-do] request failed:", error);
-      return Response.json(
-        {
-          error: {
-            code: "INTERNAL_ERROR",
-            message: "internal error"
-          }
-        },
-        { status: 500, headers: { "content-type": "application/json" } }
-      );
-    }
-    return Response.json(
-      { error: { code: "NOT_FOUND", message: "unknown route" } },
-      {
-        status: 404,
-        headers: { "content-type": "application/json" }
-      }
-    );
-  }
-  // ── Handlers ──────────────────────────────────────────────────────
-  /** POST /append — insert events, return entries with assigned seqs. */
-  async #handleAppend(request) {
-    let body;
-    try {
-      body = await request.json();
-    } catch {
-      return Response.json(
-        { error: { code: "BAD_REQUEST", message: "invalid JSON body" } },
-        {
-          status: 400,
-          headers: { "content-type": "application/json" }
-        }
-      );
-    }
-    if (!Array.isArray(body.events) || body.events.length === 0 || body.events.some((eventRecord) => typeof eventRecord.type !== "string" || eventRecord.type.length === 0)) {
-      return Response.json(
-        { error: { code: "BAD_REQUEST", message: "events[] with a non-empty string `type` required" } },
-        {
-          status: 400,
-          headers: { "content-type": "application/json" }
-        }
-      );
-    }
-    const entries = [];
-    const { sql } = this.state.storage;
-    const now = Date.now();
-    for (const eventRecord of body.events) {
-      const seq = EventLogDO.#nextSeq(sql);
-      const entry = {
-        seq,
-        type: eventRecord.type,
-        payload: eventRecord.payload,
-        timestamp: eventRecord.timestamp ?? now
-      };
-      EventLogDO.#insertEvent(sql, entry);
-      entries.push(entry);
-    }
-    const response = { entries };
-    return Response.json(response, {
-      status: 200,
-      headers: { "content-type": "application/json" }
-    });
-  }
-  /** GET /since?seq=N — return entries with seq >= N. */
-  #handleSince(url) {
-    const seqParameter = url.searchParams.get("seq");
-    const sinceSeq = seqParameter === null ? 0 : Number(seqParameter);
-    if (!Number.isFinite(sinceSeq) || sinceSeq < 0) {
-      return Response.json(
-        { error: { code: "BAD_REQUEST", message: "invalid seq" } },
-        {
-          status: 400,
-          headers: { "content-type": "application/json" }
-        }
-      );
-    }
-    const { sql } = this.state.storage;
-    const cursor = sql.exec(
-      "SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events WHERE seq >= ? ORDER BY seq ASC",
-      sinceSeq
-    );
-    const entries = rowsToEntries(cursor);
-    return Response.json(
-      { entries },
-      {
-        status: 200,
-        headers: { "content-type": "application/json" }
-      }
-    );
-  }
-  /** GET /range?from=N&amp;limit=M — paginated read (default limit 50). */
-  #handleRange(url) {
-    const fromParameter = url.searchParams.get("from");
-    const fromSeq = fromParameter === null ? 0 : Number(fromParameter);
-    const limitParameter = url.searchParams.get("limit");
-    const limit = limitParameter === null ? 50 : Number(limitParameter);
-    if (!Number.isFinite(fromSeq) || fromSeq < 0 || !Number.isFinite(limit) || limit < 1 || limit > 1e3) {
-      return Response.json(
-        { error: { code: "BAD_REQUEST", message: "invalid from/limit" } },
-        {
-          status: 400,
-          headers: { "content-type": "application/json" }
-        }
-      );
-    }
-    const { sql } = this.state.storage;
-    const cursor = sql.exec(
-      "SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events WHERE seq >= ? ORDER BY seq ASC LIMIT ?",
-      fromSeq,
-      limit + 1
-      // Fetch one extra to detect hasMore
-    );
-    const allRows = rowsToEntries(cursor);
-    const hasMore = allRows.length > limit;
-    const entries = hasMore ? allRows.slice(0, limit) : allRows;
-    const response = { entries, hasMore };
-    return Response.json(response, {
-      status: 200,
-      headers: { "content-type": "application/json" }
-    });
-  }
-  /** GET /size — return the number of stored events. */
-  #handleSize() {
-    const { sql } = this.state.storage;
-    const cursor = sql.exec("SELECT COUNT(*) AS count FROM events");
-    const rows = toArray(cursor);
-    const count = rows[0]?.count ?? 0;
-    return Response.json(
-      { count },
-      {
-        status: 200,
-        headers: { "content-type": "application/json" }
-      }
-    );
-  }
-  /** GET /state — return the full event log state. */
-  #handleState() {
-    const { sql } = this.state.storage;
-    const cursor = sql.exec("SELECT seq, type, payload, timestamp, client_id, session_id, parent_seq FROM events ORDER BY seq ASC");
-    const entries = rowsToEntries(cursor);
-    const nextSeq = (entries.at(-1)?.seq ?? -1) + 1;
-    return Response.json({ entries, nextSeq }, { status: 200, headers: { "content-type": "application/json" } });
-  }
-  // ── Internal ──────────────────────────────────────────────────────
-  #ensureTable() {
-    if (this.#initialized) {
-      return;
-    }
-    const { sql } = this.state.storage;
-    sql.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)"
-    );
-    this.#initialized = true;
-  }
-  /** Get the next available sequence number. */
-  static #nextSeq(sql) {
-    const cursor = sql.exec("SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM events");
-    const rows = toArray(cursor);
-    return rows[0]?.next_seq ?? 0;
-  }
-  /** Insert a single event entry. */
-  /* eslint-disable unicorn/no-null -- SQLite bindings use `null` for missing optional columns */
-  static #insertEvent(sql, entry) {
-    let parentSeq = null;
-    if (typeof entry.parentSeqNum === "number") {
-      parentSeq = entry.parentSeqNum;
-    }
-    sql.exec(
-      "INSERT INTO events (seq, type, payload, timestamp, client_id, session_id, parent_seq) VALUES (?, ?, ?, ?, ?, ?, ?)",
-      entry.seq,
-      entry.type,
-      JSON.stringify(entry.payload),
-      entry.timestamp,
-      entry.clientId ?? null,
-      entry.sessionId ?? null,
-      parentSeq
-    );
-  }
-  /* eslint-enable unicorn/no-null */
-}
-
-export { EventLogDO };

package/dist/packem_shared/EventLogDOClient-DGiEdi96.mjs

@@ -1,86 +0,0 @@
-class EventLogDOClient {
-  #fetch;
-  constructor(options) {
-    this.#fetch = options.fetch;
-  }
-  // ── Append ─────────────────────────────────────────────────────────
-  /**
-   * Append one or more events to the log.
-   * @returns The persisted entries with their assigned `seq` numbers.
-   */
-  async append(events) {
-    const body = JSON.stringify({ events });
-    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-DfV4VoRD.mjs

@@ -1,195 +0,0 @@
-import { EventEmitter } from './EventEmitter-CMZfct03.mjs';
-import { EventLog } from './EventLog-zMy7AYP4.mjs';
-
-class EventSource {
-  // eslint-disable-next-line unicorn/prefer-event-target -- EventEmitter is the library's typed public API
-  emitter = new EventEmitter();
-  log = new EventLog();
-  #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";
-  }
-  // ── 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 entry = this.log.append(type, pl, void 0, resolvedOptions);
-    this.#applyEntry(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 {
-        this.#state = this.#reducer(this.#state, entry);
-        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 ──────────────────────────────────────────────────────
-  #applyEntry(entry) {
-    const stateBefore = this.#state;
-    try {
-      this.#state = this.#reducer(this.#state, entry);
-    } catch (error) {
-      this.emitter.emit("replay-error", {
-        entry,
-        error: error instanceof Error ? error : new Error(String(error))
-      });
-      return;
-    }
-    if (this.#state === stateBefore && !this.#handleUnknown(entry)) {
-      return;
-    }
-    this.emitter.emit("state-changed", { state: this.#state, entry });
-  }
-  #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 };

package/dist/packem_shared/EventsSync-DkVbU0WV.mjs

@@ -1,91 +0,0 @@
-class EventsSync {
-  #options;
-  /** The highest `seq + 1` that has been applied. Starts at `0`. */
-  #watermark = 0;
-  #timer;
-  /** Guards against overlapping poll cycles (e.g. slow fetch). */
-  #running = false;
-  // ── 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 ────────────────────────────────────────────────────────
-  /**
-   * One poll cycle: fetch → apply → diff → mirror.
-   */
-  async #poll() {
-    if (this.#running) {
-      return 0;
-    }
-    this.#running = true;
-    try {
-      const events = await this.#options.fetchEventsSince(this.#watermark);
-      if (events.length === 0) {
-        return 0;
-      }
-      this.#options.applyEvents(events);
-      const lastEvent = events[events.length - 1];
-      if (lastEvent) {
-        this.#watermark = lastEvent.seq + 1;
-      }
-      const diffs = this.#options.getTableDiffs();
-      for (const diff of diffs) {
-        this.#options.mirror.applyDiff(diff);
-      }
-      return events.length;
-    } catch (error) {
-      const onError = this.#options.onError ?? console.error;
-      onError(error);
-      return 0;
-    } finally {
-      this.#running = false;
-    }
-  }
-}
-
-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 };