effect 4.0.4 → 4.0.6

package/dist/eventlog/EventJournal.js

@@ -13,17 +13,20 @@
  * @since 4.0.0
  */
 import * as Arr from "../Array.js";
+import * as Clock from "../Clock.js";
 import * as Context from "../Context.js";
 import * as Data from "../Data.js";
 import * as DateTime from "../DateTime.js";
 import * as Effect from "../Effect.js";
 import * as SchemaBinary from "../encoding/SchemaBinary.js";
+import { constVoid } from "../Function.js";
 import * as Uuid from "../internal/uuid.js";
 import * as Layer from "../Layer.js";
 import * as Order from "../Order.js";
 import * as PubSub from "../PubSub.js";
 import * as Schema from "../Schema.js";
 import * as Semaphore from "../Semaphore.js";
+import { ConflictIndex, entryIdOrder } from "./internal/conflicts.js";
 /**
  * Context service for storing and replaying event journal entries.
  *
@@ -32,6 +35,9 @@ import * as Semaphore from "../Semaphore.js";
  * The service writes local entries, imports entries from remote journals, exposes
  * a stream of local changes, and provides per-store locking.
  *
+ * Entries written by `EventLog` carry payloads encoded with their event's
+ * `payloadSchemaBinary`; see {@link Entry} for how to decode them.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -115,14 +121,50 @@ export const EntryId = /*#__PURE__*/Schema.Uint8Array.pipe(/*#__PURE__*/Schema.b
  * @category ordering
  * @since 4.0.0
  */
-export const EntryIdOrder = /*#__PURE__*/Order.make((a, b) => {
-  for (let i = 0; i < 16; i++) {
-    if (a[i] !== b[i]) {
-      return a[i] - b[i] < 0 ? -1 : 1;
-    }
+export const EntryIdOrder = entryIdOrder;
+const maxEntryIdMillis = 2 ** 48 - 1;
+const processEntryIds = {
+  millis: 0,
+  counter: 0
+};
+const nextEntryId = (sequence, now) => {
+  if (now > sequence.millis) {
+    sequence.millis = now;
+    sequence.counter = 0;
+  } else if (++sequence.counter > 0xfff) {
+    sequence.millis++;
+    sequence.counter = 0;
   }
-  return 0;
-});
+  // The sequence only moves forward, so once exhausted it stays exhausted.
+  if (sequence.millis > maxEntryIdMillis) {
+    throw new RangeError("The entry id sequence has passed the last UUID v7 millisecond");
+  }
+  const bytes = Uuid.v7Bytes(sequence.millis);
+  // The counter replaces the 12 random `rand_a` bits after the version.
+  bytes[6] = 0x70 | sequence.counter >> 8;
+  bytes[7] = sequence.counter & 0xff;
+  return bytes;
+};
+// The process sequence, or a copy advanced to `floor` when that is later. The
+// copy is never written back, so a floor read from uncommitted rows leaves the
+// process sequence alone.
+const sequenceAfter = floor => {
+  if (floor === undefined) return processEntryIds;
+  const millis = entryIdMillis(floor);
+  // Continuing from the floor's `rand_a` sorts the next id after it.
+  const counter = (floor[6] & 0x0f) << 8 | floor[7];
+  return millis > processEntryIds.millis || millis === processEntryIds.millis && counter > processEntryIds.counter ? {
+    millis,
+    counter
+  } : processEntryIds;
+};
+const maxEntryId = ids => {
+  let latest;
+  for (const id of ids) {
+    if (latest === undefined || EntryIdOrder(id, latest) === 1) latest = id;
+  }
+  return latest;
+};
 /**
  * Generates a UUID v7 `EntryId`, optionally using the supplied millisecond
  * timestamp.
@@ -132,16 +174,54 @@ export const EntryIdOrder = /*#__PURE__*/Order.make((a, b) => {
  * Use when generating an event-log entry id internally and the UUID v7 bytes
  * are trusted to satisfy the brand.
  *
+ * **Details**
+ *
+ * Ids taken from the clock are strictly ascending within the current process.
+ * Ids created in the same millisecond carry an incrementing 12-bit counter. If
+ * the clock stalls or moves backwards, ids keep the last millisecond, and
+ * after 4096 ids in one millisecond they move to the next one.
+ *
+ * The journals generate local ids from this sequence, or from a copy of it
+ * advanced past the latest id in their store, so a local id sorts after every
+ * entry committed to that store, even when the local clock is behind.
+ *
  * **Gotchas**
  *
  * This is unsafe because the generated UUID bytes are cast to the brand without
  * schema validation.
  *
+ * Throws a `RangeError` once the sequence passes the last UUID v7 millisecond.
+ * Every later call throws too, because any id it could return would sort before
+ * one already generated.
+ *
+ * Ids created with an explicit `msecs` are not part of the sequence, and clamp
+ * to the UUID v7 range.
+ *
  * @stability unstable
  * @category unsafe
  * @since 4.0.0
  */
-export const makeEntryIdUnsafe = (options = {}) => Uuid.v7Bytes(options.msecs ?? DateTime.nowUnsafe().epochMilliseconds);
+export const makeEntryIdUnsafe = (options = {}) => options.msecs !== undefined ? Uuid.v7Bytes(options.msecs) : nextEntryId(processEntryIds, Date.now());
+// Imported ids further ahead of the local clock than this are logged.
+const maxClockSkewMillis = 24 * 60 * 60 * 1000;
+/**
+ * Logs a warning when the latest of the imported `ids` is more than 24 hours
+ * ahead of the supplied `clock`. Memory and IndexedDB journals call this after
+ * commit; SQL calls it at the end of its transaction body, so a later rollback
+ * (including an enclosing transaction rollback) can still leave a warning.
+ *
+ * @internal
+ */
+export const warnIfAhead = (clock, ids) => {
+  const latest = maxEntryId(ids);
+  if (latest === undefined) return Effect.void;
+  const ahead = entryIdMillis(latest) - clock.currentTimeMillisUnsafe();
+  if (ahead <= maxClockSkewMillis) return Effect.void;
+  return Effect.logWarning(`Imported an entry id ${Math.round(ahead / 3_600_000)} hours ahead of the local clock`).pipe(Effect.annotateLogs({
+    service: "EventJournal",
+    entryId: Uuid.stringify(latest)
+  }));
+};
 /**
  * Extracts the millisecond timestamp encoded in a UUID v7 `EntryId`.
  *
@@ -149,11 +229,9 @@ export const makeEntryIdUnsafe = (options = {}) => Uuid.v7Bytes(options.msecs ??
  * @category getters
  * @since 4.0.0
  */
-export const entryIdMillis = entryId => {
-  const bytes = new Uint8Array(8);
-  bytes.set(entryId.subarray(0, 6), 2);
-  return Number(new DataView(bytes.buffer).getBigUint64(0));
-};
+export const entryIdMillis = entryId =>
+// Multiply instead of shifting: bitwise operators are signed 32-bit.
+((((entryId[0] * 256 + entryId[1]) * 256 + entryId[2]) * 256 + entryId[3]) * 256 + entryId[4]) * 256 + entryId[5];
 /**
  * Schema for a committed event journal entry.
  *
@@ -162,6 +240,14 @@ export const entryIdMillis = entryId => {
  * An entry records its ID, event tag, primary key, and SchemaBinary-encoded
  * payload, with helpers for array SchemaBinary encoding and creation timestamps.
  *
+ * **Gotchas**
+ *
+ * `EventLog` encodes `payload` with the `payloadSchemaBinary` of the event whose
+ * tag is `entry.event`, so decode it with that event's codec. A codec with an
+ * incompatible wire layout, such as a union of a group's tagged payload schemas,
+ * cannot read it. Entries from remote journals can carry tags the local schema
+ * does not define.
+ *
  * @stability unstable
  * @category schemas
  * @since 4.0.0
@@ -192,7 +278,7 @@ export class Entry extends /*#__PURE__*/Schema.Class("effect/eventlog/EventJourn
    * @stability unstable
    * @since 4.0.0
    */
-  static decodeArray = /*#__PURE__*/Schema.decodeUnknownEffect(Entry.arraySchemaBinary);
+  static decodeArray = (input, options) => Effect.map(decodeEntryFieldsArray(input, options), Arr.map(entryFromFields));
   /**
    * Ordering for committed entries by their event journal entry id.
    *
@@ -200,6 +286,7 @@ export class Entry extends /*#__PURE__*/Schema.Class("effect/eventlog/EventJourn
    * @since 4.0.0
    */
   static Order = /*#__PURE__*/Order.make((a, b) => EntryIdOrder(a.id, b.id));
+  #idString;
   /**
    * String representation of the entry id.
    *
@@ -207,7 +294,7 @@ export class Entry extends /*#__PURE__*/Schema.Class("effect/eventlog/EventJourn
    * @since 4.0.0
    */
   get idString() {
-    return Uuid.stringify(this.id);
+    return this.#idString ??= Uuid.stringify(this.id);
   }
   /**
    * Creation timestamp encoded in the UUID v7 entry id, in epoch milliseconds.
@@ -243,6 +330,41 @@ export class RemoteEntry extends /*#__PURE__*/Schema.Class("effect/eventlog/Even
   remoteSequence: Schema.Natural,
   entry: Entry
 }) {}
+// Decoding frames into the plain field structs and then constructing the
+// classes from the already validated fields skips the per-instance class
+// decode, which costs more than reading the frame. The wire format is the same.
+/** @internal */
+export const EntryFields = /*#__PURE__*/Schema.Struct(Entry.fields);
+/** @internal */
+export const entryFromFields = fields => Schema.makeClassTrusted(Entry, fields);
+const decodeEntryFieldsArray = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(/*#__PURE__*/SchemaBinary.toCodec(EntryFields)));
+/**
+ * Creates local entries with ids after every id in `after`, normally the
+ * latest id in the journal's store.
+ *
+ * @internal
+ */
+export const makeEntries = (entries, after) => Effect.try({
+  try: () => {
+    const sequence = sequenceAfter(maxEntryId(after));
+    return Arr.map(entries, ({
+      event,
+      payload,
+      primaryKey
+    }) => new Entry({
+      id: nextEntryId(sequence, Date.now()),
+      event,
+      primaryKey,
+      payload
+    }, {
+      disableChecks: true
+    }));
+  },
+  catch: cause => new EventJournalError({
+    method: "writeMany",
+    cause
+  })
+});
 /**
  * Creates an in-memory `EventJournal` service.
  *
@@ -257,6 +379,17 @@ export class RemoteEntry extends /*#__PURE__*/Schema.Class("effect/eventlog/Even
  */
 export const makeMemory = /*#__PURE__*/Effect.gen(function* () {
   const journal = [];
+  // Local writes append in commit order, which unserialized direct callers can
+  // make differ from id order, leaving the journal unordered until the next
+  // import re-sorts it. Remote backlogs are subsequences of the journal, so one
+  // flag covers them too.
+  let journalSorted = true;
+  // The latest committed id, the floor for local ids.
+  let latestId;
+  const commitLatest = ids => {
+    latestId = maxEntryId(latestId === undefined ? ids : [latestId, ...ids]);
+  };
+  const clock = yield* Clock.Clock;
   const byId = new Map();
   const remotes = new Map();
   const pubsub = yield* PubSub.unbounded();
@@ -280,85 +413,80 @@ export const makeMemory = /*#__PURE__*/Effect.gen(function* () {
     remotes.set(remoteIdString, created);
     return created;
   };
+  const writeMany = ({
+    effect,
+    entries
+  }) => Effect.acquireUseRelease(Effect.suspend(() => makeEntries(entries, latestId === undefined ? [] : [latestId])), effect, (entries, exit) => Effect.suspend(() => {
+    if (exit._tag === "Failure") return Effect.void;
+    for (const entry of entries) {
+      const last = journal[journal.length - 1];
+      if (last !== undefined && Entry.Order(last, entry) > 0) {
+        journalSorted = false;
+      }
+      journal.push(entry);
+      byId.set(entry.idString, entry);
+      remotes.forEach(remote => {
+        remote.missing.push(entry);
+      });
+    }
+    commitLatest(entries.map(entry => entry.id));
+    return PubSub.publishAll(pubsub, entries);
+  }));
   return EventJournal.of({
     entries: Effect.sync(() => journal.slice()),
-    write({
+    write: ({
       effect,
-      event,
-      payload,
-      primaryKey
-    }) {
-      return Effect.acquireUseRelease(Effect.sync(() => new Entry({
-        id: makeEntryIdUnsafe(),
-        event,
-        primaryKey,
-        payload
-      }, {
-        disableChecks: true
-      })), effect, (entry, exit) => Effect.suspend(() => {
-        if (exit._tag === "Failure" || byId.has(entry.idString)) return Effect.void;
-        journal.push(entry);
-        byId.set(entry.idString, entry);
-        remotes.forEach(remote => {
-          remote.missing.push(entry);
-        });
-        return PubSub.publish(pubsub, entry);
-      }));
-    },
+      ...entry
+    }) => writeMany({
+      entries: [entry],
+      effect: entries => effect(entries[0])
+    }),
+    writeMany,
     writeFromRemote: Effect.fnUntraced(function* (options) {
       const remote = ensureRemote(options.remoteId);
       const uncommittedRemotes = [];
-      const uncommitted = [];
       const duplicateEntries = [];
+      // Overlapping batches can repeat an entry; the first copy wins.
+      const incomingIds = new Set();
       for (const remoteEntry of options.entries) {
-        if (byId.has(remoteEntry.entry.idString)) {
+        const idString = remoteEntry.entry.idString;
+        if (byId.has(idString)) {
           duplicateEntries.push(remoteEntry.entry);
-          if (remoteEntry.remoteSequence >= remote.sequence) {
-            remote.sequence = remoteEntry.remoteSequence + 1;
-          }
-          continue;
+        } else if (!incomingIds.has(idString)) {
+          incomingIds.add(idString);
+          uncommittedRemotes.push(remoteEntry);
         }
-        uncommittedRemotes.push(remoteEntry);
-        uncommitted.push(remoteEntry.entry);
       }
-      const compacted = options.compact ? yield* options.compact(uncommittedRemotes) : uncommitted;
-      for (const originEntry of compacted) {
-        const entryMillis = entryIdMillis(originEntry.id);
-        const conflicts = [];
-        for (let i = journal.length - 1; i >= -1; i--) {
-          const entry = journal[i];
-          if (entry !== undefined && entry.createdAtMillis > entryMillis) {
-            continue;
-          }
-          for (let j = i + 1; j < journal.length; j++) {
-            const scannedEntry = journal[j];
-            if (scannedEntry.event === originEntry.event && scannedEntry.primaryKey === originEntry.primaryKey) {
-              conflicts.push(scannedEntry);
-            }
-          }
-          yield* options.effect({
-            entry: originEntry,
-            conflicts
-          });
-          break;
+      const compacted = options.compact ? yield* options.compact(uncommittedRemotes) : uncommittedRemotes.map(remoteEntry => remoteEntry.entry);
+      if (Arr.isReadonlyArrayNonEmpty(compacted)) {
+        const index = new ConflictIndex(compacted);
+        const oldest = index.oldest;
+        // Only the suffix with greater ids can conflict, unless local writes
+        // left the journal unordered.
+        let i = journalSorted ? journal.length : 0;
+        while (i > 0 && Entry.Order(journal[i - 1], oldest) > 0) i--;
+        for (; i < journal.length; i++) {
+          index.add(journal[i]);
         }
+        yield* options.effect(index.toBatch());
       }
       for (const remoteEntry of uncommittedRemotes) {
-        journal.push(remoteEntry.entry);
         byId.set(remoteEntry.entry.idString, remoteEntry.entry);
-        remotes.forEach(target => {
-          if (target !== remote) {
-            target.missing.push(remoteEntry.entry);
-          }
-        });
-        if (remoteEntry.remoteSequence >= remote.sequence) {
-          remote.sequence = remoteEntry.remoteSequence + 1;
-        }
       }
-      journal.sort((a, b) => a.createdAtMillis - b.createdAtMillis);
-      remotes.forEach(remote => {
-        remote.missing.sort((a, b) => a.createdAtMillis - b.createdAtMillis);
+      // Sequences advance with the commit, so a failed batch is redelivered.
+      remote.sequence = nextSequenceAfter(options.entries, remote.sequence);
+      const imported = uncommittedRemotes.map(remoteEntry => remoteEntry.entry).sort(Entry.Order);
+      insertOrdered(journal, journalSorted, imported);
+      remotes.forEach(target => {
+        if (target !== remote) {
+          insertOrdered(target.missing, journalSorted, imported);
+        } else if (!journalSorted) {
+          target.missing.sort(Entry.Order);
+        }
       });
+      journalSorted = true;
+      commitLatest(imported.map(entry => entry.id));
+      yield* warnIfAhead(clock, imported.map(entry => entry.id));
       return {
         duplicateEntries
       };
@@ -375,16 +503,48 @@ export const makeMemory = /*#__PURE__*/Effect.gen(function* () {
         }
       }
     })),
+    writeRemoteAcks: ({
+      acks,
+      firstSequence,
+      remoteId
+    }) => Effect.sync(() => {
+      const remote = ensureRemote(remoteId);
+      remote.sequence = advanceSequence(remote.sequence, acks, firstSequence);
+    }),
     nextRemoteSequence: remoteId => Effect.sync(() => ensureRemote(remoteId).sequence),
+    entriesById: ids => Effect.sync(() => ids.map(id => byId.get(Uuid.stringify(id)))),
     changes: PubSub.subscribe(pubsub),
     destroy: Effect.sync(() => {
       journal.length = 0;
+      journalSorted = true;
+      latestId = undefined;
       byId.clear();
       remotes.clear();
     }),
     withLock
   });
 });
+// Same result as appending `additions` and sorting by id.
+const insertOrdered = (entries, sorted, additions) => {
+  let i = entries.length - 1;
+  for (let n = 0; n < additions.length; n++) {
+    entries.push(additions[n]);
+  }
+  if (!sorted) {
+    entries.sort(Entry.Order);
+    return;
+  }
+  // Merge from the back, so additions sorting after the whole array cost O(additions).
+  let j = additions.length - 1;
+  let k = entries.length - 1;
+  while (j >= 0) {
+    if (i >= 0 && Entry.Order(entries[i], additions[j]) > 0) {
+      entries[k--] = entries[i--];
+    } else {
+      entries[k--] = additions[j--];
+    }
+  }
+};
 /**
  * Layer that provides an in-memory `EventJournal`.
  *
@@ -413,194 +573,239 @@ export const layerMemory = /*#__PURE__*/Layer.effect(EventJournal, makeMemory);
  */
 export const makeIndexedDb = options => Effect.gen(function* () {
   const database = options?.database ?? "effect_event_journal";
-  const openRequest = indexedDB.open(database, 1);
-  openRequest.onupgradeneeded = () => {
+  const openRequest = indexedDB.open(database, 2);
+  openRequest.onupgradeneeded = event => {
     const db = openRequest.result;
-    const entries = db.createObjectStore("entries", {
-      keyPath: "id"
-    });
-    entries.createIndex("id", "id", {
-      unique: true
-    });
-    entries.createIndex("event", "event");
-    const remotes = db.createObjectStore("remotes", {
-      keyPath: ["remoteId", "entryId"]
-    });
-    remotes.createIndex("id", ["remoteId", "entryId"], {
-      unique: true
-    });
-    remotes.createIndex("sequence", ["remoteId", "sequence"], {
-      unique: true
-    });
-    const remoteEntryId = db.createObjectStore("remoteEntryId", {
-      keyPath: ["remoteId"]
-    });
-    remoteEntryId.createIndex("id", "remoteId", {
-      unique: true
+    const tx = openRequest.transaction;
+    if (event.oldVersion < 1) {
+      const entries = db.createObjectStore("entries", {
+        keyPath: "id"
+      });
+      entries.createIndex("id", "id", {
+        unique: true
+      });
+      entries.createIndex("event", "event");
+      db.createObjectStore("remoteEntryId", {
+        keyPath: ["remoteId"]
+      }).createIndex("id", "remoteId", {
+        unique: true
+      });
+    }
+    const entries = tx.objectStore("entries");
+    // Bounds conflict reads to one event and primary key.
+    entries.createIndex("conflict", ["event", "primaryKey", "id"]);
+    // Entry ids order creation, not insertion, so uploads checkpoint an
+    // insertion sequence instead.
+    const sequence = db.createObjectStore("entrySequence", {
+      autoIncrement: true
     });
+    // The remote each imported entry came from, so uploads skip it.
+    const sources = db.createObjectStore("entrySource");
+    if (event.oldVersion < 1) return;
+    // Number the existing entries in creation order.
+    const entryIds = entries.openKeyCursor();
+    entryIds.onsuccess = () => {
+      const cursor = entryIds.result;
+      if (!cursor) return;
+      sequence.add(cursor.primaryKey);
+      cursor.continue();
+    };
+    // Version 1 kept a `remotes` row per entry per remote and recorded upload
+    // progress as an entry id, which cannot become a checkpoint. Keep one
+    // source per entry and, walking each remote's rows in sequence order, its
+    // download cursor; then drop the store.
+    const progress = tx.objectStore("remoteEntryId");
+    progress.clear();
+    const remotes = tx.objectStore("remotes").index("sequence").openCursor();
+    remotes.onsuccess = () => {
+      const cursor = remotes.result;
+      if (!cursor) {
+        db.deleteObjectStore("remotes");
+        return;
+      }
+      const row = cursor.value;
+      sources.put(row.remoteId, row.entryId);
+      progress.put({
+        remoteId: row.remoteId,
+        nextSequence: row.sequence + 1
+      });
+      cursor.continue();
+    };
   };
   const db = yield* Effect.acquireRelease(idbReq("open", () => openRequest), db => Effect.sync(() => db.close()));
   const pubsub = yield* PubSub.unbounded();
+  const clock = yield* Clock.Clock;
+  // Other tabs share the database but not the entry id sequence.
+  const latestEntryId = Effect.callback(resume => {
+    const tx = db.transaction("entries", "readonly");
+    const request = tx.objectStore("entries").openKeyCursor(null, "prev");
+    onTransactionDone(tx, "writeMany", resume, () => {
+      const key = request.result?.primaryKey;
+      if (key === undefined) return [];
+      return [ArrayBuffer.isView(key) ? new Uint8Array(key.buffer, key.byteOffset, key.byteLength) : new Uint8Array(key)];
+    });
+    return Effect.sync(() => tx.abort());
+  });
+  const writeMany = ({
+    effect,
+    entries
+  }) => Effect.uninterruptibleMask(restore => latestEntryId.pipe(Effect.flatMap(latest => makeEntries(entries, latest)), Effect.flatMap(committed => restore(effect(committed)).pipe(Effect.tap(Effect.callback(resume => {
+    const tx = db.transaction(["entries", "entrySequence"], "readwrite");
+    const store = tx.objectStore("entries");
+    const sequence = tx.objectStore("entrySequence");
+    for (const entry of committed) {
+      store.put(encodeEntryIdb(entry));
+      sequence.add(entry.id);
+    }
+    onTransactionDone(tx, "writeMany", resume, constVoid);
+  })), Effect.tap(PubSub.publishAll(pubsub, committed))))));
   return EventJournal.of({
-    entries: idbReq("entries", () => db.transaction("entries", "readonly").objectStore("entries").index("id").getAll()).pipe(Effect.flatMap(_ => decodeEntryIdbArray(_).pipe(Effect.mapError(cause => new EventJournalError({
-      method: "entries",
-      cause
-    }))))),
+    entries: idbReq("entries", () => db.transaction("entries", "readonly").objectStore("entries").index("id").getAll()).pipe(Effect.map(rows => rows.map(entryFromIdb))),
+    entriesById: ids => Effect.callback(resume => {
+      const entries = ids.map(() => undefined);
+      const tx = db.transaction("entries", "readonly");
+      const store = tx.objectStore("entries");
+      for (let i = 0; i < ids.length; i++) {
+        const request = store.get(ids[i]);
+        request.onsuccess = () => {
+          if (request.result !== undefined) entries[i] = entryFromIdb(request.result);
+        };
+      }
+      onTransactionDone(tx, "entriesById", resume, () => entries);
+      return Effect.sync(() => tx.abort());
+    }),
     write: ({
       effect,
-      event,
-      payload,
-      primaryKey
-    }) => Effect.uninterruptibleMask(restore => {
-      const entry = new Entry({
-        id: makeEntryIdUnsafe(),
-        event,
-        primaryKey,
-        payload
-      }, {
-        disableChecks: true
-      });
-      return restore(effect(entry)).pipe(Effect.tap(idbReq("write", () => db.transaction("entries", "readwrite").objectStore("entries").put(encodeEntryIdb(entry)))), Effect.tap(PubSub.publish(pubsub, entry)));
+      ...entry
+    }) => writeMany({
+      entries: [entry],
+      effect: entries => effect(entries[0])
     }),
+    writeMany,
     writeFromRemote: Effect.fnUntraced(function* (options) {
-      const uncommitted = [];
       const uncommittedRemotes = [];
       const duplicateEntries = [];
+      // Overlapping batches can repeat an entry; the first copy wins.
+      const incomingIds = new Set();
       yield* Effect.callback(resume => {
-        const tx = db.transaction(["entries", "remotes"], "readwrite");
+        const tx = db.transaction("entries", "readonly");
         const entries = tx.objectStore("entries");
-        const remotes = tx.objectStore("remotes");
-        const iterator = options.entries[Symbol.iterator]();
-        const handleNext = state => {
-          if (state.done) return;
-          const remoteEntry = state.value;
-          const entry = remoteEntry.entry;
-          const entryIdKey = entry.id;
-          entries.get(entryIdKey).onsuccess = event => {
-            if (event.target && "result" in event.target && event.target.result) {
-              duplicateEntries.push(entry);
-              remotes.put({
-                remoteId: options.remoteId,
-                entryId: entry.id,
-                sequence: remoteEntry.remoteSequence
-              });
-              handleNext(iterator.next());
-              return;
+        // Requests in a transaction complete in the order they were issued.
+        for (const remoteEntry of options.entries) {
+          const request = entries.getKey(remoteEntry.entry.id);
+          request.onsuccess = () => {
+            const idString = remoteEntry.entry.idString;
+            if (request.result !== undefined) {
+              duplicateEntries.push(remoteEntry.entry);
+            } else if (!incomingIds.has(idString)) {
+              incomingIds.add(idString);
+              uncommittedRemotes.push(remoteEntry);
             }
-            uncommitted.push(entry);
-            uncommittedRemotes.push(remoteEntry);
-            handleNext(iterator.next());
           };
-        };
-        handleNext(iterator.next());
-        tx.oncomplete = () => resume(Effect.void);
-        tx.onerror = () => resume(Effect.fail(new EventJournalError({
-          method: "writeFromRemote",
-          cause: tx.error
-        })));
+        }
+        onTransactionDone(tx, "writeFromRemote", resume, constVoid);
         return Effect.sync(() => tx.abort());
       });
-      const compacted = options.compact ? yield* options.compact(uncommittedRemotes) : uncommitted;
-      for (const originEntry of compacted) {
-        const conflicts = [];
+      const compacted = options.compact ? yield* options.compact(uncommittedRemotes) : uncommittedRemotes.map(remoteEntry => remoteEntry.entry);
+      if (Arr.isReadonlyArrayNonEmpty(compacted)) {
+        const index = new ConflictIndex(compacted);
         yield* Effect.callback(resume => {
           const tx = db.transaction("entries", "readonly");
-          const entries = tx.objectStore("entries");
-          const cursorRequest = entries.index("id").openCursor(IDBKeyRange.lowerBound(originEntry.id, true), "next");
-          cursorRequest.onsuccess = () => {
-            const cursor = cursorRequest.result;
-            if (!cursor) return;
-            const decodedEntry = decodeEntryIdb(cursor.value);
-            if (decodedEntry.event === originEntry.event && decodedEntry.primaryKey === originEntry.primaryKey) {
-              conflicts.push(decodedEntry);
-            }
-            cursor.continue();
-          };
-          tx.oncomplete = () => resume(Effect.void);
-          tx.onerror = () => resume(Effect.fail(new EventJournalError({
-            method: "writeFromRemote",
-            cause: tx.error
-          })));
+          const conflicts = tx.objectStore("entries").index("conflict");
+          // One read per group of the entries with a greater id than its
+          // oldest, in id order.
+          for (const group of index.groups()) {
+            const request = conflicts.getAll(IDBKeyRange.bound([group.event, group.primaryKey, group.oldest.id], [group.event, group.primaryKey, entryIdUpperBound], true));
+            request.onsuccess = () => {
+              for (const row of request.result) index.add(entryFromIdb(row));
+            };
+          }
+          onTransactionDone(tx, "writeFromRemote", resume, constVoid);
           return Effect.sync(() => tx.abort());
         });
-        yield* options.effect({
-          entry: originEntry,
-          conflicts
-        });
+        yield* options.effect(index.toBatch());
       }
       yield* Effect.callback(resume => {
-        const tx = db.transaction(["entries", "remotes"], "readwrite");
+        const tx = db.transaction(["entries", "entrySource", "entrySequence", "remoteEntryId"], "readwrite");
         const entries = tx.objectStore("entries");
-        const remotes = tx.objectStore("remotes");
+        const sources = tx.objectStore("entrySource");
+        const sequence = tx.objectStore("entrySequence");
         for (const remoteEntry of uncommittedRemotes) {
           entries.add(encodeEntryIdb(remoteEntry.entry));
-          remotes.put({
-            remoteId: options.remoteId,
-            entryId: remoteEntry.entry.id,
-            sequence: remoteEntry.remoteSequence
-          });
+          sequence.add(remoteEntry.entry.id);
+          sources.put(options.remoteId, remoteEntry.entry.id);
         }
-        tx.oncomplete = () => resume(Effect.void);
-        tx.onerror = () => resume(Effect.fail(new EventJournalError({
-          method: "writeFromRemote",
-          cause: tx.error
-        })));
+        // Sequences advance with the commit, so a failed batch is redelivered.
+        advanceProgress(tx.objectStore("remoteEntryId"), options.remoteId, "nextSequence", () => nextSequenceAfter(options.entries));
+        onTransactionDone(tx, "writeFromRemote", resume, constVoid);
         return Effect.sync(() => tx.abort());
       });
+      yield* warnIfAhead(clock, uncommittedRemotes.map(remoteEntry => remoteEntry.entry.id));
       return {
         duplicateEntries
       };
     }),
-    withRemoteUncommited: (remoteId, f) => Effect.callback(resume => {
-      const entries = [];
-      const tx = db.transaction(["entries", "remotes", "remoteEntryId"], "readwrite");
-      const entriesStore = tx.objectStore("entries");
-      const remotesStore = tx.objectStore("remotes");
-      const remoteEntryIdStore = tx.objectStore("remoteEntryId");
+    withRemoteUncommited: (remoteId, f) => {
       const remoteIdKey = remoteId;
-      const request = remoteEntryIdStore.get(remoteIdKey);
-      request.onsuccess = () => {
-        const startEntryId = request.result?.entryId;
-        const entryCursor = entriesStore.index("id").openCursor(startEntryId ? IDBKeyRange.lowerBound(startEntryId, true) : null, "next");
-        entryCursor.onsuccess = () => {
-          const cursor = entryCursor.result;
-          if (!cursor) return;
-          const entry = decodeEntryIdb(cursor.value);
-          remotesStore.get([remoteIdKey, entry.id]).onsuccess = event => {
-            if (!(event.target && "result" in event.target && event.target.result)) entries.push(entry);
+      return Effect.callback(resume => {
+        const entries = [];
+        // The last insertion sequence visited, or 0 when nothing follows the checkpoint.
+        let sequence = 0;
+        const tx = db.transaction(["entries", "entrySource", "remoteEntryId", "entrySequence"], "readonly");
+        const entriesStore = tx.objectStore("entries");
+        const sourcesStore = tx.objectStore("entrySource");
+        const checkpoint = tx.objectStore("remoteEntryId").get([remoteIdKey]);
+        checkpoint.onsuccess = () => {
+          const cursorRequest = tx.objectStore("entrySequence").openCursor(IDBKeyRange.lowerBound(checkpoint.result?.sequence ?? 0, true));
+          cursorRequest.onsuccess = () => {
+            const cursor = cursorRequest.result;
+            if (!cursor) return;
+            sequence = cursor.key;
+            const entryId = cursor.value;
+            const source = sourcesStore.get(entryId);
+            source.onsuccess = () => {
+              if (source.result !== undefined && indexedDB.cmp(source.result, remoteIdKey) === 0) return;
+              const entry = entriesStore.get(entryId);
+              entry.onsuccess = () => {
+                entries.push(entryFromIdb(entry.result));
+              };
+            };
             cursor.continue();
           };
         };
-      };
-      tx.oncomplete = () => resume(Effect.succeed(entries));
-      tx.onerror = () => resume(Effect.fail(new EventJournalError({
-        method: "withRemoteUncommited",
-        cause: tx.error
-      })));
+        onTransactionDone(tx, "withRemoteUncommited", resume, () => ({
+          entries,
+          sequence
+        }));
+        return Effect.sync(() => tx.abort());
+      }).pipe(Effect.flatMap(({
+        entries,
+        sequence
+      }) => {
+        if (sequence === 0) return Effect.succeedNone;
+        entries.sort(byEntryId);
+        return Effect.uninterruptibleMask(restore => restore(Arr.isReadonlyArrayNonEmpty(entries) ? Effect.asSome(f(entries)) : Effect.succeedNone).pipe(Effect.tap(Effect.callback(resume => {
+          // Uploads can complete out of order; the checkpoint only moves forward.
+          const tx = db.transaction("remoteEntryId", "readwrite");
+          advanceProgress(tx.objectStore("remoteEntryId"), remoteId, "sequence", () => sequence);
+          onTransactionDone(tx, "withRemoteUncommited", resume, constVoid);
+        }))));
+      }));
+    },
+    writeRemoteAcks: ({
+      acks,
+      firstSequence,
+      remoteId
+    }) => Effect.callback(resume => {
+      const tx = db.transaction("remoteEntryId", "readwrite");
+      advanceProgress(tx.objectStore("remoteEntryId"), remoteId, "nextSequence", next => advanceSequence(next, acks, firstSequence));
+      onTransactionDone(tx, "writeRemoteAcks", resume, constVoid);
       return Effect.sync(() => tx.abort());
-    }).pipe(Effect.flatMap(entries => {
-      if (!Arr.isReadonlyArrayNonEmpty(entries)) return Effect.succeedNone;
-      const entryId = entries[entries.length - 1].id;
-      return Effect.uninterruptibleMask(restore => restore(f(entries)).pipe(Effect.tap(idbReq("withRemoteUncommited", () => db.transaction("remoteEntryId", "readwrite").objectStore("remoteEntryId").put({
-        remoteId,
-        entryId
-      }))), Effect.asSome));
-    })),
+    }),
     nextRemoteSequence: remoteId => Effect.callback(resume => {
-      const tx = db.transaction("remotes", "readonly");
-      let sequence = 0;
-      const remoteIdKey = remoteId;
-      const cursorRequest = tx.objectStore("remotes").index("sequence").openCursor(IDBKeyRange.bound([remoteIdKey, 0], [remoteIdKey, Infinity]), "prev");
-      cursorRequest.onsuccess = () => {
-        const cursor = cursorRequest.result;
-        if (!cursor) return;
-        sequence = cursor.value.sequence + 1;
-      };
-      tx.oncomplete = () => resume(Effect.succeed(sequence));
-      tx.onerror = () => resume(Effect.fail(new EventJournalError({
-        method: "nextRemoteSequence",
-        cause: tx.error
-      })));
+      const tx = db.transaction("remoteEntryId", "readonly");
+      const progress = tx.objectStore("remoteEntryId").get([remoteId]);
+      onTransactionDone(tx, "nextRemoteSequence", resume, () => progress.result?.nextSequence ?? 0);
       return Effect.sync(() => tx.abort());
     }),
     changes: PubSub.subscribe(pubsub),
@@ -610,6 +815,30 @@ export const makeIndexedDb = options => Effect.gen(function* () {
     withLock: yield* makeBrowserWithLock(database)
   });
 });
+/**
+ * The sequence following every entry in a delivered batch.
+ *
+ * @internal
+ */
+export const nextSequenceAfter = (entries, next = 0) => {
+  for (const remoteEntry of entries) {
+    if (remoteEntry.remoteSequence >= next) next = remoteEntry.remoteSequence + 1;
+  }
+  return next;
+};
+/**
+ * Advances across contiguous acknowledgements without skipping unseen entries.
+ *
+ * @internal
+ */
+export const advanceSequence = (next, acks, firstSequence = 0) => {
+  next = Math.max(next, firstSequence);
+  const sequences = acks.map(ack => ack.sequence).sort((a, b) => a - b);
+  for (const sequence of sequences) {
+    if (sequence === next) next++;else if (sequence > next) break;
+  }
+  return next;
+};
 const makeBrowserWithLock = /*#__PURE__*/Effect.fnUntraced(function* (key) {
   if (typeof navigator !== "undefined" && "locks" in navigator) {
     return storeId => self => Effect.callback((resume, signal) => {
@@ -633,10 +862,32 @@ const makeBrowserWithLock = /*#__PURE__*/Effect.fnUntraced(function* (key) {
     return semaphore.withPermit;
   };
 });
-const decodeEntryIdb = /*#__PURE__*/Schema.decodeSync(Entry);
+// Raises one progress field within the store's transaction; progress only moves forward.
+const advanceProgress = (store, remoteId, field, next) => {
+  const request = store.get([remoteId]);
+  request.onsuccess = () => {
+    const current = request.result?.[field] ?? 0;
+    const value = next(current);
+    if (value > current) store.put({
+      ...request.result,
+      remoteId,
+      [field]: value
+    });
+  };
+};
+const byEntryId = (a, b) => indexedDB.cmp(a.id, b.id);
+// Greater than or equal to every entry id.
+const entryIdUpperBound = /*#__PURE__*/new Uint8Array(16).fill(0xff);
+// Rows are written by `encodeEntryIdb`, so they are not validated again.
+const entryFromIdb = row => new Entry({
+  id: row.id,
+  event: row.event,
+  primaryKey: row.primaryKey,
+  payload: row.payload
+}, {
+  disableChecks: true
+});
 const encodeEntryIdb = /*#__PURE__*/Schema.encodeSync(Entry);
-const EntryIdbArray = /*#__PURE__*/Schema.Array(Entry);
-const decodeEntryIdbArray = /*#__PURE__*/Schema.decodeUnknownEffect(EntryIdbArray);
 /**
  * Provides `EventJournal` using the IndexedDB-backed implementation created by
  * `makeIndexedDb`.
@@ -646,6 +897,15 @@ const decodeEntryIdbArray = /*#__PURE__*/Schema.decodeUnknownEffect(EntryIdbArra
  * @since 4.0.0
  */
 export const layerIndexedDb = options => Layer.effect(EventJournal, makeIndexedDb(options));
+// Resumes when the transaction commits, and fails if it errors or aborts. An
+// abort, such as a failed commit, does not always dispatch an error first.
+const onTransactionDone = (tx, method, resume, onComplete) => {
+  tx.oncomplete = () => resume(Effect.succeed(onComplete()));
+  tx.onerror = tx.onabort = () => resume(Effect.fail(new EventJournalError({
+    method,
+    cause: tx.error
+  })));
+};
 const idbReq = (method, evaluate) => Effect.callback(resume => {
   const request = evaluate();
   if (request.readyState === "done") {