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

package/dist/packem_shared/LocalMirror-GeJ26eNe.mjs

@@ -1,188 +0,0 @@
-import { createSqlJsAdapter } from '../adapters/sqljs.mjs';
-import { applyDiffToDb as applyDiffToDatabase, escapeIdentifier } from './applyDiffToDb-DQ1xZp5J.mjs';
-import { EventLog } from './EventLog-zMy7AYP4.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 = new EventLog();
-  #changeListeners = /* @__PURE__ */ new Set();
-  /**
-   * 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 };
-    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;
-  }
-  /**
-   * 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]);
-    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.
-   */
-  clearData() {
-    const tables = this.#db.query(
-      `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '__lunora_%' AND name NOT LIKE 'sqlite_%'`
-    );
-    this.#db.transaction(() => {
-      for (const { name } of tables) {
-        this.#db.exec(`DELETE FROM ${escapeIdentifier(name)}`);
-      }
-    });
-  }
-  /**
-   * 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 };

package/dist/packem_shared/MaterializerRuntime-HqNXqJxp.mjs

@@ -1,204 +0,0 @@
-const defineMaterializer = (definition) => {
-  let state = definition.initial();
-  return {
-    def: definition,
-    get state() {
-      return Object.freeze(state);
-    },
-    setState(newState) {
-      state = newState;
-    },
-    apply(entry) {
-      state = definition.handle(state, entry);
-    },
-    reset() {
-      state = definition.initial();
-    }
-  };
-};
-class MaterializerRuntime {
-  #materializers;
-  #snapshotStore;
-  #doClient;
-  #unknownEventHandling;
-  /**
-   * The highest event seq that has been applied to all materializers.
-   * Starts at `0` and advances monotonically.
-   */
-  #appliedSeq = 0;
-  constructor(materializers, options = {}) {
-    this.#materializers = [...materializers];
-    this.#snapshotStore = options.snapshotStore;
-    this.#doClient = options.doClient;
-    this.#unknownEventHandling = options.unknownEventHandling ?? "warn";
-  }
-  // ── Public API ──────────────────────────────────────────────────────
-  /**
-   * The sequence number of the last event applied to all materializers.
-   */
-  get appliedSeq() {
-    return this.#appliedSeq;
-  }
-  /**
-   * Replay a batch of entries through all materializers.
-   *
-   * Entries with `seq < this.appliedSeq` are silently skipped (idempotent).
-   * @returns The number of entries actually applied.
-   */
-  applyEntries(entries) {
-    let count = 0;
-    for (const entry of entries) {
-      if (entry.seq < this.#appliedSeq) {
-        continue;
-      }
-      const statesBefore = this.#materializers.map((m) => m.state);
-      let stateChanged = false;
-      for (const m of this.#materializers) {
-        m.apply(entry);
-      }
-      for (let i = 0; i < this.#materializers.length; i += 1) {
-        if (this.#materializers[i]?.state !== statesBefore[i]) {
-          stateChanged = true;
-          break;
-        }
-      }
-      if (!stateChanged) {
-        this.#handleUnknownEvent(entry);
-      }
-      this.#appliedSeq = entry.seq + 1;
-      count += 1;
-    }
-    return count;
-  }
-  /**
-   * Apply the configured {@link UnknownEventHandling} strategy for an event
-   * that no materializer handled.
-   */
-  #handleUnknownEvent(entry) {
-    const strategy = this.#unknownEventHandling;
-    if (typeof strategy === "function") {
-      strategy(entry);
-      return;
-    }
-    switch (strategy) {
-      case "ignore": {
-        return;
-      }
-      case "fail": {
-        throw new Error(
-          `MaterializerRuntime: unhandled event type "${entry.type}" (seq ${String(entry.seq)}). Configure \`unknownEventHandling\` to handle this event or change the strategy.`
-        );
-      }
-      default: {
-        console.warn(
-          `[MaterializerRuntime] unhandled event type "${entry.type}" (seq ${String(entry.seq)}). The event was skipped. Configure \`unknownEventHandling\` if this is expected.`
-        );
-      }
-    }
-  }
-  /**
-   * 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`.
-   */
-  async recoverFromSnapshots() {
-    if (!this.#snapshotStore) {
-      return 0;
-    }
-    let maxSeq = 0;
-    for (const m of this.#materializers) {
-      const raw = await this.#snapshotStore.load(m.def.name);
-      if (raw !== null && typeof raw === "object") {
-        const snapshot = raw;
-        if (snapshot.state !== void 0) {
-          m.setState(snapshot.state);
-        }
-        if (snapshot.appliedSeq > maxSeq) {
-          maxSeq = snapshot.appliedSeq;
-        }
-      }
-    }
-    if (maxSeq > this.#appliedSeq) {
-      this.#appliedSeq = maxSeq;
-    }
-    return maxSeq;
-  }
-  /**
-   * Persist the current state of all materializers as snapshots.
-   */
-  async persistSnapshots() {
-    if (!this.#snapshotStore) {
-      return;
-    }
-    for (const m of this.#materializers) {
-      await this.#snapshotStore.save(m.def.name, {
-        appliedSeq: this.#appliedSeq,
-        state: m.state
-      });
-    }
-  }
-  // ── DO-backed lifecycle (when a doClient is provided) ──────────────
-  /**
-   * Bootstrap the runtime from the EventLogDO.
-   *
-   * 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.
-   *
-   * Call this once on startup / after the DO binding is available.
-   * @returns The number of entries applied during catch-up.
-   */
-  async initialize() {
-    if (!this.#doClient) {
-      return 0;
-    }
-    const snapshotSeq = await this.recoverFromSnapshots();
-    const entries = await this.#doClient.getSince(snapshotSeq);
-    if (entries.length === 0) {
-      return 0;
-    }
-    return this.applyEntries(entries);
-  }
-  /**
-   * Append an event to the EventLogDO and apply it through all
-   * materializers.
-   *
-   * 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`.
-   */
-  async appendEvent(input) {
-    if (!this.#doClient) {
-      throw new Error("MaterializerRuntime.appendEvent requires a doClient — pass one in the constructor options.");
-    }
-    const persisted = await this.#doClient.append([input]);
-    const entry = persisted[0];
-    if (!entry) {
-      throw new Error("MaterializerRuntime.appendEvent: DO returned empty result");
-    }
-    this.applyEntries([entry]);
-    return entry;
-  }
-  /**
-   * Reset all materializers to their initial state and clear snapshots.
-   */
-  reset() {
-    this.#appliedSeq = 0;
-    for (const m of this.#materializers) {
-      m.reset();
-    }
-  }
-  /**
-   * The list of registered materializers.
-   */
-  get materializers() {
-    return this.#materializers;
-  }
-}
-
-export { MaterializerRuntime, defineMaterializer };

package/dist/packem_shared/SubscriptionManager-C5xbw0pg.mjs

@@ -1,75 +0,0 @@
-class SubscriptionManager {
-  #subscriptions = /* @__PURE__ */ new Map();
-  #nextId = 0;
-  // ── Registration ──────────────────────────────────────────────────
-  /**
-   * Subscribe to every state change emitted by the event source.
-   * @returns Unsubscribe function.
-   */
-  onStateChange(callback) {
-    const id = String(this.#nextId);
-    this.#nextId += 1;
-    const sub = { kind: "state", id, callback };
-    this.#subscriptions.set(id, sub);
-    return () => {
-      this.#subscriptions.delete(id);
-    };
-  }
-  /**
-   * Subscribe to a specific event type.
-   * @param eventType The event type to listen for (matches `entry.type`).
-   * @param callback Invoked with each matching entry.
-   * @returns Unsubscribe function.
-   */
-  onEvent(eventType, callback) {
-    const id = String(this.#nextId);
-    this.#nextId += 1;
-    const sub = { kind: "event", id, eventType, callback };
-    this.#subscriptions.set(id, sub);
-    return () => {
-      this.#subscriptions.delete(id);
-    };
-  }
-  // ── Notification ──────────────────────────────────────────────────
-  /**
-   * Notify all state-change subscribers with the current state.
-   */
-  notifyState(state) {
-    for (const sub of this.#subscriptions.values()) {
-      if (sub.kind === "state") {
-        try {
-          sub.callback(state);
-        } catch {
-        }
-      }
-    }
-  }
-  /**
-   * Notify event-type subscribers whose `eventType` matches.
-   */
-  notifyEvent(entry) {
-    for (const sub of this.#subscriptions.values()) {
-      if (sub.kind === "event" && sub.eventType === entry.type) {
-        try {
-          sub.callback(entry);
-        } catch {
-        }
-      }
-    }
-  }
-  // ── Introspection ─────────────────────────────────────────────────
-  /**
-   * Return the total number of active subscriptions.
-   */
-  get size() {
-    return this.#subscriptions.size;
-  }
-  /**
-   * Remove all subscriptions.
-   */
-  clear() {
-    this.#subscriptions.clear();
-  }
-}
-
-export { SubscriptionManager };

package/dist/packem_shared/applyDiff-BtbIl1D3.mjs

@@ -1,40 +0,0 @@
-const applyDiff = (current, diff) => {
-  const next = new Map(current);
-  for (const change of diff.changes) {
-    switch (change.type) {
-      case "delete": {
-        next.delete(change.id);
-        break;
-      }
-      case "insert": {
-        const rawId = change.data.id;
-        const id = typeof rawId === "string" || typeof rawId === "number" ? String(rawId) : crypto.randomUUID();
-        next.set(id, { ...change.data, id });
-        break;
-      }
-      case "update": {
-        const existing = next.get(change.id);
-        if (existing) {
-          next.set(change.id, { ...existing, ...change.data });
-        }
-        break;
-      }
-    }
-  }
-  return next;
-};
-const applyDiffs = (current, diffs) => {
-  let result = new Map(current);
-  for (const diff of diffs) {
-    result = applyDiff(result, diff);
-  }
-  return result;
-};
-const applyDiffToSnapshot = (snapshot, diff) => {
-  const next = new Map(snapshot);
-  const tableMap = next.get(diff.table) ?? /* @__PURE__ */ new Map();
-  next.set(diff.table, applyDiff(tableMap, diff));
-  return next;
-};
-
-export { applyDiff, applyDiffToSnapshot, applyDiffs };

package/dist/packem_shared/applyDiffToDb-DQ1xZp5J.mjs

@@ -1,58 +0,0 @@
-const escapeIdentifier = (id) => `\`${id.replaceAll("`", "``")}\``;
-const setClause = (keys) => keys.map((key) => `${escapeIdentifier(key)} = ?`).join(", ");
-const colList = (keys) => `(${keys.map((key) => escapeIdentifier(key)).join(", ")})`;
-const valueList = (count) => `(${Array.from({ length: count }).fill("?").join(", ")})`;
-const applySingleDiff = (database, diff, pkColumn) => {
-  if (diff.changes.length === 0) {
-    return;
-  }
-  const table = escapeIdentifier(diff.table);
-  const pk = escapeIdentifier(pkColumn);
-  for (const change of diff.changes) {
-    switch (change.type) {
-      case "delete": {
-        database.exec(`DELETE FROM ${table} WHERE ${pk} = ?`, [change.id]);
-        break;
-      }
-      case "insert": {
-        const { data } = change;
-        const keys = Object.keys(data);
-        if (keys.length === 0) {
-          continue;
-        }
-        const sql = `INSERT OR REPLACE INTO ${table} ${colList(keys)} VALUES ${valueList(keys.length)}`;
-        const values = keys.map((k) => data[k]);
-        database.exec(sql, values);
-        break;
-      }
-      case "update": {
-        const { data } = change;
-        const keys = Object.keys(data);
-        if (keys.length === 0) {
-          continue;
-        }
-        const sql = `UPDATE ${table} SET ${setClause(keys)} WHERE ${pk} = ?`;
-        const values = [...keys.map((k) => data[k]), change.id];
-        database.exec(sql, values);
-        break;
-      }
-    }
-  }
-};
-const applyDiffToDatabase = (database, diff, pkColumn) => {
-  database.transaction(() => {
-    applySingleDiff(database, diff, pkColumn ?? "id");
-  });
-};
-const applyDiffsToDatabase = (database, diffs) => {
-  if (diffs.length === 0) {
-    return;
-  }
-  database.transaction(() => {
-    for (const diff of diffs) {
-      applySingleDiff(database, diff, "id");
-    }
-  });
-};
-
-export { applyDiffToDatabase as applyDiffToDb, applyDiffsToDatabase as applyDiffsToDb, escapeIdentifier };

package/dist/packem_shared/classifyChanges-aZmkxgVI.mjs

@@ -1,38 +0,0 @@
-const createTableDiff = (table, changes, timestamp) => {
-  return {
-    table,
-    changes,
-    timestamp: timestamp ?? Date.now()
-  };
-};
-const isDiffEmpty = (diff) => diff.changes.length === 0;
-const diffSize = (diff) => diff.changes.length;
-const classifyChanges = (diff) => {
-  const inserts = [];
-  const updates = [];
-  const deletes = [];
-  for (const change of diff.changes) {
-    if (change.type === "insert") {
-      inserts.push(change);
-    } else if (change.type === "update") {
-      updates.push(change);
-    } else {
-      deletes.push(change);
-    }
-  }
-  return { inserts, updates, deletes };
-};
-const mergeDiffs = (diffs) => {
-  if (diffs.length === 0) {
-    return null;
-  }
-  const first = diffs[0];
-  const last = diffs[diffs.length - 1];
-  return createTableDiff(
-    first.table,
-    diffs.flatMap((d) => d.changes),
-    last.timestamp
-  );
-};
-
-export { classifyChanges, createTableDiff, diffSize, isDiffEmpty, mergeDiffs };

package/dist/packem_shared/defineEvents-DiBkPTh_.mjs

@@ -1,28 +0,0 @@
-const defineEvents = (definition, options) => {
-  const result = {};
-  const typeMap = {};
-  const prefix = options?.version ? `${options.version}.` : "";
-  for (const [namespace, events] of Object.entries(definition)) {
-    const nsObject = {};
-    for (const [name] of Object.entries(events)) {
-      const qualifiedType = `${prefix}${namespace}.${name}`;
-      typeMap[qualifiedType] = void 0;
-      const factory = Object.assign(
-        (payload) => {
-          return {
-            type: qualifiedType,
-            payload,
-            timestamp: Date.now()
-          };
-        },
-        { type: qualifiedType }
-      );
-      nsObject[name] = factory;
-    }
-    result[namespace] = nsObject;
-  }
-  result._types = typeMap;
-  return result;
-};
-
-export { defineEvents };

package/dist/packem_shared/eventsContext-Bk_p48hj.mjs

@@ -1,6 +0,0 @@
-const eventsContext = (client) => {
-  const facade = client;
-  return async ({ ctx: _context, next }) => next({ ctx: { events: facade } });
-};
-
-export { eventsContext };

package/dist/packem_shared/isClientSeq-C46BkzqJ.mjs

@@ -1,5 +0,0 @@
-const isGlobalSeq = (seq) => typeof seq === "number";
-const isClientSeq = (seq) => typeof seq !== "number" && "rebaseGeneration" in seq;
-const isInputEvent = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "payload" in value && "timestamp" in value;
-
-export { isClientSeq, isGlobalSeq, isInputEvent };