@lunora/replica 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/packem_shared/MaterializerRuntime-BoIrsMYB.mjs

@@ -1,224 +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;
-  /**
-   * Per-materializer watermark: the seq of the next event each materializer
-   * (by index, parallel to `#materializers`) has NOT yet applied. Starts at
-   * `0` for every materializer and advances independently — a materializer
-   * with no snapshot stays at `0` even when a sibling has recovered to a
-   * much higher watermark, so catch-up never skips events for it (REPLICA-04).
-   */
-  #watermarks;
-  constructor(materializers, options = {}) {
-    this.#materializers = [...materializers];
-    this.#watermarks = this.#materializers.map(() => 0);
-    this.#snapshotStore = options.snapshotStore;
-    this.#doClient = options.doClient;
-    this.#unknownEventHandling = options.unknownEventHandling ?? "warn";
-  }
-  // ── Public API ──────────────────────────────────────────────────────
-  /**
-   * 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() {
-    return this.#watermarks.length > 0 ? Math.min(...this.#watermarks) : 0;
-  }
-  /**
-   * 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) {
-    let count = 0;
-    for (const entry of entries) {
-      let appliedToAny = false;
-      let anyChanged = false;
-      for (const [i, materializer] of this.#materializers.entries()) {
-        const watermark = this.#watermarks[i] ?? 0;
-        if (entry.seq < watermark) {
-          continue;
-        }
-        const stateBefore = materializer.state;
-        materializer.apply(entry);
-        appliedToAny = true;
-        if (materializer.state !== stateBefore) {
-          anyChanged = true;
-        }
-        this.#watermarks[i] = entry.seq + 1;
-      }
-      if (!appliedToAny) {
-        continue;
-      }
-      if (!anyChanged) {
-        this.#handleUnknownEvent(entry);
-      }
-      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 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`).
-   */
-  async recoverFromSnapshots() {
-    if (!this.#snapshotStore) {
-      return 0;
-    }
-    let maxSeq = 0;
-    for (const [i, materializer] of this.#materializers.entries()) {
-      const raw = await this.#snapshotStore.load(materializer.def.name);
-      if (raw !== null && typeof raw === "object") {
-        const snapshot = raw;
-        if (snapshot.state !== void 0) {
-          materializer.setState(snapshot.state);
-        }
-        this.#watermarks[i] = snapshot.appliedSeq;
-        if (snapshot.appliedSeq > maxSeq) {
-          maxSeq = snapshot.appliedSeq;
-        }
-      }
-    }
-    return maxSeq;
-  }
-  /**
-   * Persist the current state of all materializers as snapshots, each
-   * tagged with ITS OWN watermark (not a shared one).
-   */
-  async persistSnapshots() {
-    if (!this.#snapshotStore) {
-      return;
-    }
-    for (const [i, materializer] of this.#materializers.entries()) {
-      await this.#snapshotStore.save(materializer.def.name, {
-        appliedSeq: this.#watermarks[i] ?? 0,
-        state: materializer.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 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.
-   */
-  async initialize() {
-    if (!this.#doClient) {
-      return 0;
-    }
-    await this.recoverFromSnapshots();
-    const minWatermark = this.#watermarks.length > 0 ? Math.min(...this.#watermarks) : 0;
-    const entries = await this.#doClient.getSince(minWatermark);
-    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() {
-    for (const [i, materializer] of this.#materializers.entries()) {
-      this.#watermarks[i] = 0;
-      materializer.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-98tKzmiW.mjs

@@ -1,67 +0,0 @@
-const canonicalizeForHash = (value) => {
-  if (Array.isArray(value)) {
-    return value.map((item) => canonicalizeForHash(item));
-  }
-  if (value !== null && typeof value === "object") {
-    const record = value;
-    const sortedKeys = Object.keys(record).toSorted((a, b) => a.localeCompare(b));
-    const result = {};
-    for (const key of sortedKeys) {
-      result[key] = canonicalizeForHash(record[key]);
-    }
-    return result;
-  }
-  return value;
-};
-const deriveInsertId = (diff, changeIndex, data) => {
-  const diffIdentity = diff.id ?? String(diff.timestamp);
-  const input = `${diff.table}::${diffIdentity}::${String(changeIndex)}::${JSON.stringify(canonicalizeForHash(data))}`;
-  let hash = 0xcbf29ce484222325n;
-  const prime = 0x00000100000001b3n;
-  const mask64 = 0xffffffffffffffffn;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= BigInt(input.codePointAt(index) ?? 0);
-    hash = hash * prime & mask64;
-  }
-  return `row-${hash.toString(16).padStart(16, "0")}`;
-};
-const applyDiff = (current, diff) => {
-  const next = new Map(current);
-  for (const [changeIndex, change] of diff.changes.entries()) {
-    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) : deriveInsertId(diff, changeIndex, change.data);
-        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-RcqLBpLs.mjs

@@ -1,41 +0,0 @@
-const createTableDiff = (table, changes, timestamp, id) => {
-  return {
-    table,
-    changes,
-    timestamp: timestamp ?? Date.now(),
-    id: id ?? crypto.randomUUID()
-  };
-};
-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];
-  const mergedId = `merge:${diffs.map((d) => d.id ?? String(d.timestamp)).join("|")}`;
-  return createTableDiff(
-    first.table,
-    diffs.flatMap((d) => d.changes),
-    last.timestamp,
-    mergedId
-  );
-};
-
-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 };

package/dist/packem_shared/subscribeToMirror-CiaM-nQ7.mjs

@@ -1,45 +0,0 @@
-const deriveTableName = (functionRef) => `fn_${functionRef.replaceAll(/[/:.]/g, "_")}`;
-const asRowArray = (data) => {
-  if (Array.isArray(data)) {
-    return data;
-  }
-  if (data !== null && typeof data === "object") {
-    return [data];
-  }
-  return [];
-};
-const subscribeToMirror = (client, mirror, functionRef, args, shardKey) => {
-  const tableName = deriveTableName(functionRef.__lunoraRef);
-  mirror.registerTable(tableName, {});
-  let knownIds = /* @__PURE__ */ new Set();
-  return client.subscribe(
-    functionRef,
-    args,
-    (data) => {
-      const rows = asRowArray(data);
-      const nextIds = /* @__PURE__ */ new Set();
-      const changes = [];
-      for (const row of rows) {
-        const record = row;
-        const rawId = record.id;
-        if (typeof rawId === "string" || typeof rawId === "number") {
-          nextIds.add(String(rawId));
-        }
-        changes.push({ type: "insert", data: record });
-      }
-      for (const id of knownIds) {
-        if (!nextIds.has(id)) {
-          changes.push({ type: "delete", id });
-        }
-      }
-      knownIds = nextIds;
-      if (changes.length === 0) {
-        return;
-      }
-      mirror.applyDiff({ table: tableName, changes, timestamp: Date.now() });
-    },
-    { shardKey }
-  );
-};
-
-export { subscribeToMirror };