js-bao 0.12.0-alpha.6 → 0.12.0-alpha.7

package/dist/browser.cjs

@@ -2494,16 +2494,18 @@ function refusedWritesOf(entry) {
     seq: entry.seq
   }));
 }
-var RECORD_LOG_DEFAULT_EPOCH_ENTRIES, RECORD_LOG_ENTRY_MAX_BYTES, RECORD_LOG_FRAME_TARGET_BYTES, RECORD_LOG_SEND_WINDOW, RECORD_LOG_TICK_MS, RECORD_LOG_UP_BATCH_MAX, RECORD_LOG_FIRST_EPOCH, RecordLogStaleReceiptError, RecordLogStaleReplacementError, RecordLogWriteRefusedError;
+var RECORD_LOG_DEFAULT_EPOCH_ENTRIES, RECORD_LOG_ENTRY_MAX_BYTES, RECORD_LOG_FRAME_TARGET_BYTES, RECORD_LOG_FRAMES_IN_FLIGHT, RECORD_LOG_FRAME_WAIT_MS, RECORD_LOG_TICK_MS, RECORD_LOG_UP_BATCH_MAX, RECORD_LOG_FRAME_ENTRIES_MAX, RECORD_LOG_FIRST_EPOCH, RecordLogStaleReceiptError, RecordLogStaleReplacementError, RecordLogWriteRefusedError;
 var init_types = __esm({
   "src/record-log-client/types.ts"() {
     "use strict";
     RECORD_LOG_DEFAULT_EPOCH_ENTRIES = 1e4;
     RECORD_LOG_ENTRY_MAX_BYTES = 1024 * 1024;
     RECORD_LOG_FRAME_TARGET_BYTES = 64 * 1024;
-    RECORD_LOG_SEND_WINDOW = 8;
+    RECORD_LOG_FRAMES_IN_FLIGHT = 1;
+    RECORD_LOG_FRAME_WAIT_MS = 2e3;
     RECORD_LOG_TICK_MS = 5;
     RECORD_LOG_UP_BATCH_MAX = 200;
+    RECORD_LOG_FRAME_ENTRIES_MAX = 64;
     RECORD_LOG_FIRST_EPOCH = 1;
     RecordLogStaleReceiptError = class _RecordLogStaleReceiptError extends Error {
       /**
@@ -8737,9 +8739,11 @@ __export(browser_exports, {
   RECORD_LOG_DRAIN_WAIT_MS: () => RECORD_LOG_DRAIN_WAIT_MS,
   RECORD_LOG_ENTRY_MAX_BYTES: () => RECORD_LOG_ENTRY_MAX_BYTES,
   RECORD_LOG_FIRST_EPOCH: () => RECORD_LOG_FIRST_EPOCH,
+  RECORD_LOG_FRAMES_IN_FLIGHT: () => RECORD_LOG_FRAMES_IN_FLIGHT,
+  RECORD_LOG_FRAME_ENTRIES_MAX: () => RECORD_LOG_FRAME_ENTRIES_MAX,
   RECORD_LOG_FRAME_TARGET_BYTES: () => RECORD_LOG_FRAME_TARGET_BYTES,
+  RECORD_LOG_FRAME_WAIT_MS: () => RECORD_LOG_FRAME_WAIT_MS,
   RECORD_LOG_RESULT_GAP_MS: () => RECORD_LOG_RESULT_GAP_MS,
-  RECORD_LOG_SEND_WINDOW: () => RECORD_LOG_SEND_WINDOW,
   RECORD_LOG_STORE_CHANNEL: () => RECORD_LOG_STORE_CHANNEL,
   RECORD_LOG_TEARDOWN_DRAIN_BOUND_MS: () => RECORD_LOG_TEARDOWN_DRAIN_BOUND_MS,
   RECORD_LOG_TICK_MS: () => RECORD_LOG_TICK_MS,
@@ -10593,6 +10597,16 @@ var RecordLogClient = class {
   get pending() {
     return this.tables.pending(this.writer);
   }
+  /** One of a writer's unjudged entries, or `undefined`. */
+  entryOf(writer, seq) {
+    if (this.tables.pendingEntry) return this.tables.pendingEntry(writer, seq);
+    return this.tables.pending(writer).find((p) => p.seq === seq);
+  }
+  /** A writer's unjudged entries at or below `seq`, in `seq` order. */
+  entriesThrough(writer, seq) {
+    if (this.tables.pendingThrough) return this.tables.pendingThrough(writer, seq);
+    return this.tables.pending(writer).filter((p) => p.seq <= seq);
+  }
   /**
    * Write an entry: the next `seq`, the open epoch, the cursor. It joins the
    * pending log; the store applies it to the view as a guess.
@@ -10662,7 +10676,7 @@ var RecordLogClient = class {
   }
   /** The room has moved past a withdrawn entry's sequence number. */
   settled(seq) {
-    const entry = this.tables.pending(this.writer).find((p) => p.seq === seq);
+    const entry = this.entryOf(this.writer, seq);
     if (entry?.void) this.tables.deletePending(this.writer, seq);
     return { touched: [] };
   }
@@ -10677,7 +10691,7 @@ var RecordLogClient = class {
   receive(item) {
     const out = { touched: [], acknowledged: [], settled: [] };
     if ("void" in item) {
-      const entry = this.tables.pending(this.writer).find((p) => p.seq === item.seq);
+      const entry = this.entryOf(this.writer, item.seq);
       if (entry) {
         this.tables.deletePending(this.writer, item.seq);
         out.settled.push({ writer: this.writer, seq: item.seq });
@@ -10686,7 +10700,7 @@ var RecordLogClient = class {
       return out;
     }
     if ("duplicate" in item) {
-      const entry = this.tables.pending(this.writer).find((p) => p.seq === item.seq);
+      const entry = this.entryOf(this.writer, item.seq);
       out.acknowledged.push({ writer: this.writer, seq: item.seq });
       if (entry) {
         this.tables.deletePending(this.writer, item.seq);
@@ -10696,7 +10710,7 @@ var RecordLogClient = class {
       return out;
     }
     if (item.w !== void 0 && item.seq !== void 0 && this.tables.isWriter(item.w)) {
-      const entry = this.tables.pending(item.w).find((p) => p.seq === item.seq);
+      const entry = this.entryOf(item.w, item.seq);
       out.acknowledged.push({ writer: item.w, seq: item.seq });
       if (entry && !entry.void && entry.acked === void 0) {
         this.tables.putPending(item.w, { ...entry, acked: item.l, ...item.alias ? { alias: item.alias } : {} });
@@ -10729,7 +10743,7 @@ var RecordLogClient = class {
    */
   settleAcknowledged(out) {
     for (const { writer, seq } of this.tables.acknowledgedThrough(this.tables.cursor())) {
-      const entry = this.tables.pending(writer).find((p) => p.seq === seq);
+      const entry = this.entryOf(writer, seq);
       if (!entry) continue;
       this.tables.deletePending(writer, seq);
       out.settled.push({ writer, seq });
@@ -10744,8 +10758,7 @@ var RecordLogClient = class {
    * wrote since.
    */
   confirmEntry(writer, seq, alias, out) {
-    for (const p of this.tables.pending(writer)) {
-      if (p.seq > seq) continue;
+    for (const p of this.entriesThrough(writer, seq)) {
       this.tables.deletePending(writer, p.seq);
       out.settled.push({ writer, seq: p.seq });
       if (!p.void) out.touched.push(...keysOf(p));
@@ -11208,6 +11221,12 @@ var MemoryRecordLogTables = class {
   pending(writer) {
     return [...this.writers.get(writer)?.pending ?? []];
   }
+  pendingEntry(writer, seq) {
+    return this.writers.get(writer)?.pending.find((p) => p.seq === seq);
+  }
+  pendingThrough(writer, seq) {
+    return (this.writers.get(writer)?.pending ?? []).filter((p) => p.seq <= seq);
+  }
   putPending(writer, entry) {
     const w = this.writerOf(writer);
     const at = w.pending.findIndex((p) => p.seq === entry.seq);
@@ -11332,6 +11351,10 @@ function recordLogClientDDL() {
   PRIMARY KEY (doc_id, writer, seq)
 )`,
     `CREATE INDEX IF NOT EXISTS record_log_pending_acked ON record_log_pending(doc_id, acked) WHERE acked IS NOT NULL`,
+    // A write numbers its entry after the highest `ord` and counts its
+    // epoch's unwithdrawn entries; neither reads the entries.
+    `CREATE INDEX IF NOT EXISTS record_log_pending_by_ord ON record_log_pending(doc_id, ord)`,
+    `CREATE INDEX IF NOT EXISTS record_log_pending_by_epoch ON record_log_pending(doc_id, e) WHERE void = 0`,
     `CREATE TABLE IF NOT EXISTS record_log_pending_keys (
   doc_id TEXT NOT NULL,
   writer TEXT NOT NULL,
@@ -11341,7 +11364,10 @@ function recordLogClientDDL() {
   resolved INTEGER NOT NULL DEFAULT 0,
   PRIMARY KEY (doc_id, writer, seq, _type, _id)
 )`,
-    `CREATE INDEX IF NOT EXISTS record_log_pending_keys_by_record ON record_log_pending_keys(doc_id, _type, _id)`,
+    // The entries touching a record, answered from the index alone: without
+    // `writer, seq` in it SQLite reads the keys' primary key by document.
+    `DROP INDEX IF EXISTS record_log_pending_keys_by_record`,
+    `CREATE INDEX IF NOT EXISTS record_log_pending_keys_by_record_entry ON record_log_pending_keys(doc_id, _type, _id, writer, seq)`,
     `CREATE TABLE IF NOT EXISTS record_log_pending_values (
   doc_id TEXT NOT NULL,
   writer TEXT NOT NULL,
@@ -11445,6 +11471,11 @@ function queryRow(row, spec) {
 function rowsOf(sql, query, ...bindings) {
   return Array.from(sql.exec(query, ...bindings));
 }
+function pendingRow(row) {
+  const entry = JSON.parse(String(row.entry));
+  if (row.acked !== null && row.acked !== void 0) entry.acked = Number(row.acked);
+  return entry;
+}
 var SqlRecordLogTables = class {
   constructor(sql, docId) {
     this.sql = sql;
@@ -11456,6 +11487,11 @@ var SqlRecordLogTables = class {
   heldWarned = false;
   /** Records of entries changed or removed since the last {@link takeDirty}, resolutions included. */
   dirty = [];
+  /**
+   * Inside {@link countingEpochs}, each epoch's unwithdrawn pending entries
+   * once counted, kept as entries are added; `null` outside it.
+   */
+  epochPending = null;
   state() {
     return rowsOf(this.sql, `SELECT * FROM record_log_state WHERE doc_id = ?`, this.docId)[0] ?? null;
   }
@@ -11680,16 +11716,32 @@ var SqlRecordLogTables = class {
       `SELECT entry, acked FROM record_log_pending WHERE doc_id = ? AND writer = ? ORDER BY seq`,
       this.docId,
       writer
-    ).map((row) => {
-      const entry = JSON.parse(String(row.entry));
-      if (row.acked !== null && row.acked !== void 0) entry.acked = Number(row.acked);
-      return entry;
-    });
+    ).map(pendingRow);
+  }
+  pendingEntry(writer, seq) {
+    const [row] = rowsOf(
+      this.sql,
+      `SELECT entry, acked FROM record_log_pending WHERE doc_id = ? AND writer = ? AND seq = ?`,
+      this.docId,
+      writer,
+      seq
+    );
+    return row ? pendingRow(row) : void 0;
+  }
+  pendingThrough(writer, seq) {
+    return rowsOf(
+      this.sql,
+      `SELECT entry, acked FROM record_log_pending WHERE doc_id = ? AND writer = ? AND seq <= ? ORDER BY seq`,
+      this.docId,
+      writer,
+      seq
+    ).map(pendingRow);
   }
   putPending(writer, entry) {
     const { acked, ...stored } = entry;
     const exists = rowsOf(this.sql, `SELECT 1 FROM record_log_pending WHERE doc_id = ? AND writer = ? AND seq = ?`, this.docId, writer, entry.seq).length > 0;
     if (exists) {
+      this.epochPending?.clear();
       this.markDirty(writer, entry.seq);
       this.sql.exec(
         `UPDATE record_log_pending SET entry = ?, void = ?, acked = ?, e = ? WHERE doc_id = ? AND writer = ? AND seq = ?`,
@@ -11721,6 +11773,8 @@ var SqlRecordLogTables = class {
         entry.void ? 1 : 0,
         acked ?? null
       );
+      const counted = this.epochPending?.get(entry.e);
+      if (!entry.void && counted !== void 0) this.epochPending.set(entry.e, counted + 1);
     }
     this.putValues(writer, entry);
     for (const key of keysOf(entry)) {
@@ -11761,6 +11815,7 @@ var SqlRecordLogTables = class {
     }
   }
   deletePending(writer, seq) {
+    this.epochPending?.clear();
     this.markDirty(writer, seq);
     this.sql.exec(`DELETE FROM record_log_pending WHERE doc_id = ? AND writer = ? AND seq = ?`, this.docId, writer, seq);
     this.sql.exec(`DELETE FROM record_log_pending_keys WHERE doc_id = ? AND writer = ? AND seq = ?`, this.docId, writer, seq);
@@ -11810,13 +11865,30 @@ var SqlRecordLogTables = class {
     );
   }
   pendingInEpoch(e) {
+    const counted = this.epochPending?.get(e);
+    if (counted !== void 0) return counted;
     const [row] = rowsOf(
       this.sql,
       `SELECT COUNT(*) AS n FROM record_log_pending WHERE doc_id = ? AND void = 0 AND e = ?`,
       this.docId,
       e
     );
-    return Number(row?.n ?? 0);
+    const n = Number(row?.n ?? 0);
+    this.epochPending?.set(e, n);
+    return n;
+  }
+  /**
+   * Run `fn` counting each epoch's pending entries once: a commit's writes
+   * each check the budget, and inside one transaction only they change the
+   * count. Any other change to the pending log counts again.
+   */
+  countingEpochs(fn) {
+    this.epochPending = /* @__PURE__ */ new Map();
+    try {
+      return fn();
+    } finally {
+      this.epochPending = null;
+    }
   }
 };
 function modelsOf(keys) {
@@ -12441,31 +12513,33 @@ var RecordLogStore = class {
    *   epochs this client may write into are full; nothing of the command lands.
    */
   commitEntries(command) {
-    return this.sql.transaction(() => {
-      const client = this.client(command.writer);
-      const results = [];
-      const refreshed = [];
-      for (const write of command.writes) {
-        const stale = (write.expect ?? []).some(
-          ({ model, id, revision }) => recordLogRowRevision(this.read(model, id)) !== revision
-        );
-        if (stale) {
-          results.push({ stale: true });
-          continue;
-        }
-        client.budgetCheck(this.docId);
-        const [m, ...also] = write.mutations;
-        const entry = client.write(m, {
-          also,
-          ...write.upsertOn !== void 0 ? { upsertOn: write.upsertOn } : {},
-          ts: command.ts ?? Date.now()
-        });
-        refreshed.push(...this.refreshView([...keysOf(entry), ...this.tables.takeDirty()]));
-        results.push({ entry });
-      }
-      const changed = this.settleView([], command.project ?? [], refreshed);
-      return { results, changed, cursor: this.tables.cursor() };
-    });
+    return this.sql.transaction(
+      () => this.tables.countingEpochs(() => {
+        const client = this.client(command.writer);
+        const results = [];
+        const refreshed = [];
+        for (const write of command.writes) {
+          const stale = (write.expect ?? []).some(
+            ({ model, id, revision }) => recordLogRowRevision(this.read(model, id)) !== revision
+          );
+          if (stale) {
+            results.push({ stale: true });
+            continue;
+          }
+          client.budgetCheck(this.docId);
+          const [m, ...also] = write.mutations;
+          const entry = client.write(m, {
+            also,
+            ...write.upsertOn !== void 0 ? { upsertOn: write.upsertOn } : {},
+            ts: command.ts ?? Date.now()
+          });
+          refreshed.push(...this.refreshView([...keysOf(entry), ...this.tables.takeDirty()]));
+          results.push({ entry });
+        }
+        const changed = this.settleView([], command.project ?? [], refreshed);
+        return { results, changed, cursor: this.tables.cursor() };
+      })
+    );
   }
   /** Apply what the room relayed, item by item. */
   receive(command) {
@@ -16294,20 +16368,23 @@ var RecordLogSender = class {
   constructor(transport, options = {}) {
     this.transport = transport;
     this.tickMs = options.tickMs ?? RECORD_LOG_TICK_MS;
-    this.window = options.window ?? RECORD_LOG_SEND_WINDOW;
     this.frameTargetBytes = options.frameTargetBytes ?? RECORD_LOG_FRAME_TARGET_BYTES;
-    this.batchMax = options.batchMax ?? RECORD_LOG_UP_BATCH_MAX;
+    this.batchMax = options.batchMax ?? RECORD_LOG_FRAME_ENTRIES_MAX;
+    this.frameWaitMs = options.frameWaitMs ?? RECORD_LOG_FRAME_WAIT_MS;
     this.clock = options.clock ?? platformClock;
   }
   queue = [];
   inFlight = /* @__PURE__ */ new Set();
+  /** The frames sent and not yet answered in full, oldest first: the numbers each still owes. */
+  frames = [];
   timer = null;
+  /** Runs out when the oldest frame has waited {@link frameWaitMs}. */
+  frameTimer = null;
   tickMs;
   frameTargetBytes;
   batchMax;
+  frameWaitMs;
   clock;
-  /** How many unacknowledged entries may be in flight; a bulk-saving app may widen it. */
-  window;
   /** Entries queued and not yet sent. */
   queued() {
     return this.queue.filter((q) => q.kind === "entry").length;
@@ -16316,6 +16393,10 @@ var RecordLogSender = class {
   inFlightCount() {
     return this.inFlight.size;
   }
+  /** `record.entries` frames that hold the next back: sent, not answered in full, and within their wait. */
+  framesInFlight() {
+    return this.frames.length;
+  }
   /** Queue an entry to send; one already queued or in flight is not queued twice. */
   enqueue(entry) {
     if (this.inFlight.has(entry.seq)) return;
@@ -16336,10 +16417,12 @@ var RecordLogSender = class {
   }
   /**
    * The room is missing entries from `expected` on: every entry in flight
-   * from there is sent again, in `seq` order, ahead of what is queued.
+   * from there is sent again, in `seq` order, ahead of what is queued. A
+   * frame no longer owes them; one that owed nothing else is done.
    */
   resendFrom(expected, entries) {
     for (const seq of [...this.inFlight]) if (seq >= expected) this.inFlight.delete(seq);
+    this.forget((seq) => seq >= expected);
     const again = entries.filter((entry) => entry.seq >= expected).filter((entry) => !this.queue.some((q) => q.kind === "entry" && q.entry.seq === entry.seq)).sort((a, b) => a.seq - b.seq).map((entry) => ({ kind: "entry", entry, bytes: recordLogJsonBytes(entry) }));
     this.queue.unshift(...again);
     if (this.queue.length) this.schedule();
@@ -16349,7 +16432,7 @@ var RecordLogSender = class {
    * entry it already judged only when it arrives again. Every entry in
    * flight goes back to the head of the queue in `seq` order, ahead of what
    * was queued after it, in its form among `unjudged`; one no longer there
-   * is dropped.
+   * is dropped. No frame is in flight any more.
    */
   requeueInFlight(unjudged) {
     const bySeq = new Map(unjudged.map((entry) => [entry.seq, entry]));
@@ -16360,6 +16443,7 @@ var RecordLogSender = class {
       again.push({ kind: "entry", entry, bytes: recordLogJsonBytes(entry) });
     }
     this.inFlight.clear();
+    this.clearFrames();
     this.queue.unshift(...again);
     if (this.queue.length) this.schedule();
   }
@@ -16368,14 +16452,21 @@ var RecordLogSender = class {
     this.queue.push({ kind: "control", frame });
     this.schedule();
   }
-  /** The room has judged `seq`: its slot in the window is free. */
+  /**
+   * The room has judged `seq` (a result, `void`, `duplicate` or a refusal):
+   * its frame no longer owes it, and a frame answered in full lets the next
+   * leave at the next tick.
+   */
   acknowledged(seq) {
-    if (this.inFlight.delete(seq) && this.queue.length) this.schedule();
+    const answered = this.inFlight.delete(seq);
+    this.forget((owed) => owed === seq);
+    if (answered && this.queue.length) this.schedule();
   }
   /** Forget everything queued and in flight: the connection that would carry it is gone. */
   reset() {
     this.queue.length = 0;
     this.inFlight.clear();
+    this.clearFrames();
     if (this.timer !== null) this.clock.clearTimeout(this.timer);
     this.timer = null;
   }
@@ -16390,7 +16481,39 @@ var RecordLogSender = class {
       this.flush();
     }, this.tickMs);
   }
-  /** Send what the window and the transport allow now. */
+  /** The frames no longer owe the numbers `owed` picks; one that owes nothing is done. */
+  forget(owed) {
+    const oldest = this.frames[0];
+    for (const frame of this.frames) for (const seq of [...frame]) if (owed(seq)) frame.delete(seq);
+    this.frames = this.frames.filter((frame) => frame.size > 0);
+    if (this.frames[0] !== oldest) {
+      this.clearFrameTimer();
+      this.armFrameTimer();
+    }
+  }
+  clearFrames() {
+    this.frames = [];
+    this.clearFrameTimer();
+  }
+  clearFrameTimer() {
+    if (this.frameTimer !== null) this.clock.clearTimeout(this.frameTimer);
+    this.frameTimer = null;
+  }
+  /**
+   * Time the oldest frame. Unanswered at the end of its wait, it stops
+   * holding the next back; its numbers stay in flight, so a `record.gap`
+   * still sends them again and their answers are still taken.
+   */
+  armFrameTimer() {
+    if (this.frameTimer !== null || !this.frames.length) return;
+    this.frameTimer = this.clock.setTimeout(() => {
+      this.frameTimer = null;
+      this.frames.shift();
+      this.armFrameTimer();
+      if (this.queue.length) this.schedule();
+    }, this.frameWaitMs);
+  }
+  /** Send what the frame in flight and the transport allow now. */
   flush() {
     if (!this.transport.connected()) return;
     let batch = [];
@@ -16398,6 +16521,8 @@ var RecordLogSender = class {
     const send = () => {
       if (!batch.length) return;
       this.transport.send({ type: "record.entries", entries: batch });
+      this.frames.push(new Set(batch.map((entry) => entry.seq)));
+      this.armFrameTimer();
       batch = [];
       bytes = 0;
     };
@@ -16409,7 +16534,7 @@ var RecordLogSender = class {
         this.transport.send(head.frame);
         continue;
       }
-      if (this.inFlight.size >= this.window) break;
+      if (!batch.length && this.frames.length >= RECORD_LOG_FRAMES_IN_FLIGHT) break;
       const fits = batch.length < this.batchMax && (batch.length === 0 || bytes + head.bytes <= this.frameTargetBytes);
       if (!fits) {
         send();
@@ -16777,6 +16902,7 @@ var RecordLogDocumentSession = class {
       await this.store.refreshMarks();
       if (generation !== this.generation) return;
       this.current = { writer, orphan: false };
+      this.sender.reset();
       await this.sendOpen();
       return;
     }
@@ -17394,11 +17520,13 @@ var RecordLogDocumentSession = class {
       return;
     }
     const writer = this.current.writer;
-    const before = await this.store.pendingOf(writer);
-    const named = before.find((p) => p.seq === refusal.seq);
     const reply = await this.store.refused(refusal, this.host.projectionSpecs(), writer);
     const sender = this.senderOf(writer);
     const after = new Map((await this.store.pendingOf(writer)).map((p) => [p.seq, p]));
+    if (after.get(refusal.seq)?.void) {
+      await this.store.dispatch({ kind: "settled", writer, seq: refusal.seq });
+      after.delete(refusal.seq);
+    }
     for (const frame of reply.frames) sender?.enqueueControl(frame);
     const handed = reply.handedBack.filter((p) => !p.void);
     for (const p of reply.handedBack) {
@@ -17407,7 +17535,6 @@ var RecordLogDocumentSession = class {
     }
     sender?.acknowledged(refusal.seq);
     this.answered([refusal.seq, ...reply.handedBack.map((p) => p.seq)]);
-    if (named?.void) await this.store.dispatch({ kind: "settled", writer, seq: refusal.seq });
     if (!handed.length) {
       Logger.debug(`[record-log] ${this.docId}: refusal of ${refusal.seq} (${refusal.code}) withdrew nothing new`);
       return;
@@ -17513,6 +17640,7 @@ var RecordLogDocumentSession = class {
         if (!current.orphan) {
           this.store.renumbered(renumbered);
           await this.store.refreshMarks();
+          this.sender.reset();
         }
         this.current = { writer, orphan: current.orphan };
         await this.sendOpen();