effect 4.0.5 → 4.0.7

package/src/eventlog/EventJournal.ts

@@ -14,20 +14,24 @@
  */
 import * as Arr from "../Array.ts"
 import type { Brand } from "../Brand.ts"
+import * as Clock from "../Clock.ts"
 import * as Context from "../Context.ts"
 import * as Data from "../Data.ts"
 import * as DateTime from "../DateTime.ts"
 import * as Effect from "../Effect.ts"
 import * as SchemaBinary from "../encoding/SchemaBinary.ts"
+import { constVoid } from "../Function.ts"
 import * as Uuid from "../internal/uuid.ts"
 import * as Layer from "../Layer.ts"
 import type { Option } from "../Option.ts"
 import * as Order from "../Order.ts"
 import * as PubSub from "../PubSub.ts"
 import * as Schema from "../Schema.ts"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Scope } from "../Scope.ts"
 import * as Semaphore from "../Semaphore.ts"
 import type { StoreId } from "./EventLogMessage.ts"
+import { ConflictIndex, entryIdOrder } from "./internal/conflicts.ts"
 
 /**
  * Context service for storing and replaying event journal entries.
@@ -37,6 +41,9 @@ import type { StoreId } from "./EventLogMessage.ts"
  * 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
@@ -47,6 +54,14 @@ export class EventJournal extends Context.Service<EventJournal, {
    */
   readonly entries: Effect.Effect<ReadonlyArray<Entry>, EventJournalError>
 
+  /**
+   * Read the stored entries with the given ids. The result is aligned with
+   * `ids`, with `undefined` for ids that are not in the journal.
+   */
+  readonly entriesById: (
+    ids: ReadonlyArray<EntryId>
+  ) => Effect.Effect<ReadonlyArray<Entry | undefined>, EventJournalError>
+
   /**
    * Write an event to the journal, performing an effect before committing the
    * event.
@@ -58,12 +73,42 @@ export class EventJournal extends Context.Service<EventJournal, {
     readonly effect: (entry: Entry) => Effect.Effect<A, E, R>
   }) => Effect.Effect<A, EventJournalError | E, R>
 
+  /**
+   * Write several events to the journal, performing an effect before
+   * committing them.
+   *
+   * **Details**
+   *
+   * `effect` runs once with every entry, in input order and with ascending
+   * ids. The entries are committed together and then published to `changes`
+   * only after it succeeds. If it fails, nothing is committed or published.
+   */
+  readonly writeMany: <A, E, R>(options: {
+    readonly entries: Arr.NonEmptyReadonlyArray<{
+      readonly event: string
+      readonly primaryKey: string
+      readonly payload: Uint8Array
+    }>
+    readonly effect: (entries: Arr.NonEmptyReadonlyArray<Entry>) => Effect.Effect<A, E, R>
+  }) => Effect.Effect<A, EventJournalError | E, R>
+
   /**
    * Write events from a remote source to the journal.
    *
    * **Details**
    *
-   * Effects run sequentially in compaction bracket order.
+   * `effect` runs once with every new entry after compaction, sorted by
+   * `Entry.Order`. Each entry is paired with the stored entries for the same
+   * event and primary key whose id is strictly greater, in id order. Entries
+   * in the batch never conflict with each other: applying them in id order
+   * gives the same result as delivering them one at a time. A compaction
+   * replacement written by `EventLog` takes the place and conflicts of the
+   * source entry it is anchored to, not of its own id.
+   *
+   * All conflicts are read before `effect` runs and the batch is committed
+   * after it succeeds, with no journal I/O while it runs. It is not called
+   * when the batch has no new entries. If `effect` fails, no entry from the
+   * batch is committed.
    */
   readonly writeFromRemote: (
     options: {
@@ -72,10 +117,12 @@ export class EventJournal extends Context.Service<EventJournal, {
       readonly compact?:
         | ((uncommitted: ReadonlyArray<RemoteEntry>) => Effect.Effect<ReadonlyArray<Entry>, EventJournalError>)
         | undefined
-      readonly effect: (options: {
-        readonly entry: Entry
-        readonly conflicts: ReadonlyArray<Entry>
-      }) => Effect.Effect<void, EventJournalError>
+      readonly effect: (
+        entries: ReadonlyArray<{
+          readonly entry: Entry
+          readonly conflicts: ReadonlyArray<Entry>
+        }>
+      ) => Effect.Effect<void, EventJournalError>
     }
   ) => Effect.Effect<{
     readonly duplicateEntries: ReadonlyArray<Entry>
@@ -93,6 +140,16 @@ export class EventJournal extends Context.Service<EventJournal, {
     f: (entries: Arr.NonEmptyReadonlyArray<Entry>) => Effect.Effect<A, E, R>
   ) => Effect.Effect<Option<A>, EventJournalError | E, R>
 
+  /**
+   * Records upload acknowledgements, advancing `nextRemoteSequence` only across
+   * contiguous sequences from the current cursor or `firstSequence`.
+   */
+  readonly writeRemoteAcks: (options: {
+    readonly remoteId: RemoteId
+    readonly acks: ReadonlyArray<RemoteAck>
+    readonly firstSequence?: number | undefined
+  }) => Effect.Effect<void, EventJournalError>
+
   /**
    * Retrieve the first unused sequence number for a remote source.
    */
@@ -240,14 +297,57 @@ export const EntryId = (Schema.Uint8Array as Schema.instanceOf<Uint8Array<ArrayB
  * @category ordering
  * @since 4.0.0
  */
-export const EntryIdOrder = Order.make<EntryId>((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: Order.Order<EntryId> = entryIdOrder
+
+const maxEntryIdMillis = 2 ** 48 - 1
+
+// The millisecond and 12-bit counter of the last id in a sequence of local ids.
+interface EntryIdSequence {
+  millis: number
+  counter: number
+}
+
+const processEntryIds: EntryIdSequence = { millis: 0, counter: 0 }
+
+const nextEntryId = (sequence: EntryIdSequence, now: number): EntryId => {
+  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 as EntryId
+}
+
+// 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: EntryId | undefined): EntryIdSequence => {
+  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: Iterable<EntryId>): EntryId | undefined => {
+  let latest: EntryId | undefined
+  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
@@ -258,17 +358,58 @@ export const EntryIdOrder = Order.make<EntryId>((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: { msecs?: number } = {}): EntryId =>
-  Uuid.v7Bytes(options.msecs ?? DateTime.nowUnsafe().epochMilliseconds) as EntryId
+  options.msecs !== undefined
+    ? Uuid.v7Bytes(options.msecs) as EntryId
+    : 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: Clock.Clock, ids: Iterable<EntryId>): Effect.Effect<void> => {
+  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`.
@@ -277,11 +418,10 @@ export const makeEntryIdUnsafe = (options: { msecs?: number } = {}): EntryId =>
  * @category getters
  * @since 4.0.0
  */
-export const entryIdMillis = (entryId: EntryId): number => {
-  const bytes = new Uint8Array(8)
-  bytes.set(entryId.subarray(0, 6), 2)
-  return Number(new DataView(bytes.buffer).getBigUint64(0))
-}
+export const entryIdMillis = (entryId: EntryId): number =>
+  // 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.
@@ -291,6 +431,14 @@ export const entryIdMillis = (entryId: EntryId): number => {
  * 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
@@ -323,7 +471,11 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
    * @stability unstable
    * @since 4.0.0
    */
-  static decodeArray = Schema.decodeUnknownEffect(Entry.arraySchemaBinary)
+  static decodeArray = (
+    input: unknown,
+    options?: SchemaAST.ParseOptions
+  ): Effect.Effect<Array<Entry>, Schema.SchemaError> =>
+    Effect.map(decodeEntryFieldsArray(input, options), Arr.map(entryFromFields))
 
   /**
    * Ordering for committed entries by their event journal entry id.
@@ -333,6 +485,8 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
    */
   static Order = Order.make<Entry>((a, b) => EntryIdOrder(a.id, b.id))
 
+  #idString: string | undefined
+
   /**
    * String representation of the entry id.
    *
@@ -340,7 +494,7 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
    * @since 4.0.0
    */
   get idString(): string {
-    return Uuid.stringify(this.id)
+    return this.#idString ??= Uuid.stringify(this.id)
   }
 
   /**
@@ -364,6 +518,18 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
   }
 }
 
+/**
+ * A local entry's remote-assigned sequence.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.6
+ */
+export interface RemoteAck {
+  readonly entryId: EntryId
+  readonly sequence: number
+}
+
 /**
  * Schema for an event journal entry received from a remote source.
  *
@@ -380,6 +546,44 @@ export class RemoteEntry extends Schema.Class<RemoteEntry>("effect/eventlog/Even
   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 = Schema.Struct(Entry.fields)
+
+/** @internal */
+export const entryFromFields = (fields: typeof EntryFields.Type): Entry => Schema.makeClassTrusted(Entry, fields)
+
+const decodeEntryFieldsArray = Schema.decodeUnknownEffect(Schema.Array(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: Arr.NonEmptyReadonlyArray<
+    { readonly event: string; readonly primaryKey: string; readonly payload: Uint8Array }
+  >,
+  after: Iterable<EntryId>
+): Effect.Effect<Arr.NonEmptyArray<Entry>, EventJournalError> =>
+  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.
  *
@@ -394,6 +598,17 @@ export class RemoteEntry extends Schema.Class<RemoteEntry>("effect/eventlog/Even
  */
 export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(function*() {
   const journal: Array<Entry> = []
+  // 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: EntryId | undefined
+  const commitLatest = (ids: Iterable<EntryId>) => {
+    latestId = maxEntryId(latestId === undefined ? ids : [latestId, ...ids])
+  }
+  const clock = yield* Clock.Clock
   const byId = new Map<string, Entry>()
   const remotes = new Map<string, { sequence: number; missing: Array<Entry> }>()
   const pubsub = yield* PubSub.unbounded<Entry>()
@@ -416,86 +631,82 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
     return created
   }
 
-  return EventJournal.of({
-    entries: Effect.sync(() => journal.slice()),
-    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
+  const writeMany: EventJournal["Service"]["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)
             })
-            return PubSub.publish(pubsub, entry)
-          })
-      )
-    },
+          }
+          commitLatest(entries.map((entry) => entry.id))
+          return PubSub.publishAll(pubsub, entries)
+        })
+    )
+
+  return EventJournal.of({
+    entries: Effect.sync(() => journal.slice()),
+    write: ({ effect, ...entry }) => writeMany({ entries: [entry], effect: (entries) => effect(entries[0]) }),
+    writeMany,
     writeFromRemote: Effect.fnUntraced(function*(options) {
       const remote = ensureRemote(options.remoteId)
       const uncommittedRemotes: Array<RemoteEntry> = []
-      const uncommitted: Array<Entry> = []
       const duplicateEntries: Array<Entry> = []
+      // Overlapping batches can repeat an entry; the first copy wins.
+      const incomingIds = new Set<string>()
       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: Array<Entry> = []
-        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
+        : 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
       }
@@ -518,10 +729,18 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
             }
           })
       ),
+    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()
     }),
@@ -529,6 +748,28 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
   })
 })
 
+// Same result as appending `additions` and sorting by id.
+const insertOrdered = (entries: Array<Entry>, sorted: boolean, additions: ReadonlyArray<Entry>): void => {
+  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`.
  *
@@ -561,20 +802,55 @@ export const makeIndexedDb = (options?: {
 }): Effect.Effect<EventJournal["Service"], EventJournalError, Scope> =>
   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 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 = db.createObjectStore("entries", { keyPath: "id" })
-      entries.createIndex("id", "id", { unique: true })
-      entries.createIndex("event", "event")
+      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
 
-      const remotes = db.createObjectStore("remotes", { keyPath: ["remoteId", "entryId"] })
-      remotes.createIndex("id", ["remoteId", "entryId"], { unique: true })
-      remotes.createIndex("sequence", ["remoteId", "sequence"], { unique: true })
+      // 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()
+      }
 
-      const remoteEntryId = db.createObjectStore("remoteEntryId", { keyPath: ["remoteId"] })
-      remoteEntryId.createIndex("id", "remoteId", { unique: true })
+      // 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 as { remoteId: IDBValidKey; entryId: IDBValidKey; sequence: number }
+        sources.put(row.remoteId, row.entryId)
+        progress.put({ remoteId: row.remoteId, nextSequence: row.sequence + 1 })
+        cursor.continue()
+      }
     }
 
     const db = yield* Effect.acquireRelease(
@@ -583,6 +859,45 @@ export const makeIndexedDb = (options?: {
     )
 
     const pubsub = yield* PubSub.unbounded<Entry>()
+    const clock = yield* Clock.Clock
+
+    // Other tabs share the database but not the entry id sequence.
+    const latestEntryId = Effect.callback<ReadonlyArray<EntryId>, EventJournalError>((resume) => {
+      const tx = db.transaction("entries", "readonly")
+      const request = tx.objectStore("entries").openKeyCursor(null, "prev")
+      onTransactionDone(tx, "writeMany", resume, () => {
+        const key = request.result?.primaryKey as ArrayBuffer | ArrayBufferView | undefined
+        if (key === undefined) return []
+        return [
+          (ArrayBuffer.isView(key)
+            ? new Uint8Array(key.buffer, key.byteOffset, key.byteLength)
+            : new Uint8Array(key)) as EntryId
+        ]
+      })
+      return Effect.sync(() => tx.abort())
+    })
+
+    const writeMany: EventJournal["Service"]["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<void, EventJournalError>((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 as IDBValidKey)
+                }
+                onTransactionDone(tx, "writeMany", resume, constVoid)
+              })),
+              Effect.tap(PubSub.publishAll(pubsub, committed))
+            )
+          )
+        )
+      )
 
     return EventJournal.of({
       entries: idbReq("entries", () =>
@@ -590,188 +905,174 @@ export const makeIndexedDb = (options?: {
           .objectStore("entries")
           .index("id")
           .getAll()).pipe(
-          Effect.flatMap((_) =>
-            decodeEntryIdbArray(_).pipe(
-              Effect.mapError((cause) => new EventJournalError({ method: "entries", cause }))
-            )
-          )
+          Effect.map((rows) => rows.map(entryFromIdb))
         ),
-      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))
-          )
+      entriesById: (ids) =>
+        Effect.callback<Array<Entry | undefined>, EventJournalError>((resume) => {
+          const entries: Array<Entry | undefined> = 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] as IDBValidKey)
+            request.onsuccess = () => {
+              if (request.result !== undefined) entries[i] = entryFromIdb(request.result)
+            }
+          }
+          onTransactionDone(tx, "entriesById", resume, () => entries)
+          return Effect.sync(() => tx.abort())
         }),
+      write: ({ effect, ...entry }) => writeMany({ entries: [entry], effect: (entries) => effect(entries[0]) }),
+      writeMany,
       writeFromRemote: Effect.fnUntraced(function*(options) {
-        const uncommitted: Array<Entry> = []
         const uncommittedRemotes: Array<RemoteEntry> = []
         const duplicateEntries: Array<Entry> = []
+        // Overlapping batches can repeat an entry; the first copy wins.
+        const incomingIds = new Set<string>()
 
         yield* Effect.callback<void, EventJournalError>((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: IteratorResult<RemoteEntry, void>) => {
-            if (state.done) return
-            const remoteEntry = state.value
-            const entry = remoteEntry.entry
-            const entryIdKey = entry.id as IDBValidKey
-            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 as IDBValidKey)
+            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
+          : uncommittedRemotes.map((remoteEntry) => remoteEntry.entry)
 
-        for (const originEntry of compacted) {
-          const conflicts: Array<Entry> = []
+        if (Arr.isReadonlyArrayNonEmpty(compacted)) {
+          const index = new ConflictIndex(compacted)
           yield* Effect.callback<void, EventJournalError>((resume) => {
             const tx = db.transaction("entries", "readonly")
-            const entries = tx.objectStore("entries")
-            const cursorRequest = entries.index("id").openCursor(
-              IDBKeyRange.lowerBound(originEntry.id as IDBValidKey, 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)
+            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 as IDBValidKey],
+                [group.event, group.primaryKey, entryIdUpperBound],
+                true
+              ))
+              request.onsuccess = () => {
+                for (const row of request.result) index.add(entryFromIdb(row))
               }
-              cursor.continue()
             }
-            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())
           })
-
-          yield* options.effect({ entry: originEntry, conflicts })
+          yield* options.effect(index.toBatch())
         }
 
         yield* Effect.callback<void, EventJournalError>((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 as IDBValidKey)
+            sources.put(options.remoteId, remoteEntry.entry.id as IDBValidKey)
           }
-          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<ReadonlyArray<Entry>, EventJournalError>((resume) => {
-          const entries: Array<Entry> = []
-          const tx = db.transaction(["entries", "remotes", "remoteEntryId"], "readwrite")
-
-          const entriesStore = tx.objectStore("entries")
-          const remotesStore = tx.objectStore("remotes")
-          const remoteEntryIdStore = tx.objectStore("remoteEntryId")
-
-          const remoteIdKey = remoteId as IDBValidKey
-          const request = remoteEntryIdStore.get(remoteIdKey) as IDBRequest<{ entryId: IDBValidKey } | undefined>
-          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 as IDBValidKey]).onsuccess = (event) => {
-                if (!(event.target && "result" in event.target && event.target.result)) entries.push(entry)
+      withRemoteUncommited: (remoteId, f) => {
+        const remoteIdKey = remoteId as IDBValidKey
+        return Effect.callback<{ readonly entries: Array<Entry>; readonly sequence: number }, EventJournalError>(
+          (resume) => {
+            const entries: Array<Entry> = []
+            // 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]) as IDBRequest<
+              RemoteProgress | undefined
+            >
+            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 as number
+                const entryId = cursor.value as IDBValidKey
+                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()
               }
             }
+            onTransactionDone(tx, "withRemoteUncommited", resume, () => ({ entries, sequence }))
+            return Effect.sync(() => tx.abort())
           }
-
-          tx.oncomplete = () => resume(Effect.succeed(entries))
-          tx.onerror = () =>
-            resume(Effect.fail(new EventJournalError({ method: "withRemoteUncommited", cause: tx.error })))
-          return Effect.sync(() => tx.abort())
-        }).pipe(
-          Effect.flatMap((entries) => {
-            if (!Arr.isReadonlyArrayNonEmpty(entries)) return Effect.succeedNone
-            const entryId = entries[entries.length - 1].id
+        ).pipe(
+          Effect.flatMap(({ entries, sequence }) => {
+            if (sequence === 0) return Effect.succeedNone
+            entries.sort(byEntryId)
             return Effect.uninterruptibleMask((restore) =>
-              restore(f(entries)).pipe(
-                Effect.tap(
-                  idbReq("withRemoteUncommited", () =>
-                    db.transaction("remoteEntryId", "readwrite").objectStore("remoteEntryId").put({
-                      remoteId,
-                      entryId
-                    }))
-                ),
-                Effect.asSome
+              restore(Arr.isReadonlyArrayNonEmpty(entries) ? Effect.asSome(f(entries)) : Effect.succeedNone).pipe(
+                Effect.tap(Effect.callback<void, EventJournalError>((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<void, EventJournalError>((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())
+        }),
       nextRemoteSequence: (remoteId) =>
         Effect.callback<number, EventJournalError>((resume) => {
-          const tx = db.transaction("remotes", "readonly")
-          let sequence = 0
-          const remoteIdKey = remoteId as IDBValidKey
-          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 as IDBValidKey]) as IDBRequest<
+            RemoteProgress | undefined
+          >
+          onTransactionDone(tx, "nextRemoteSequence", resume, () => progress.result?.nextSequence ?? 0)
           return Effect.sync(() => tx.abort())
         }),
       changes: PubSub.subscribe(pubsub),
@@ -782,6 +1083,37 @@ export const makeIndexedDb = (options?: {
     })
   })
 
+/**
+ * The sequence following every entry in a delivered batch.
+ *
+ * @internal
+ */
+export const nextSequenceAfter = (entries: ReadonlyArray<RemoteEntry>, next = 0): number => {
+  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: number,
+  acks: ReadonlyArray<RemoteAck>,
+  firstSequence = 0
+): number => {
+  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 = Effect.fnUntraced(function*(key: string) {
   if (typeof navigator !== "undefined" && "locks" in navigator) {
     return (storeId: StoreId) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
@@ -806,10 +1138,50 @@ const makeBrowserWithLock = Effect.fnUntraced(function*(key: string) {
   }
 })
 
-const decodeEntryIdb = Schema.decodeSync(Entry)
+// Progress for a remote: `sequence` is the upload checkpoint and `nextSequence`
+// the download cursor.
+interface RemoteProgress {
+  readonly sequence?: number
+  readonly nextSequence?: number
+}
+
+// Raises one progress field within the store's transaction; progress only moves forward.
+const advanceProgress = (
+  store: IDBObjectStore,
+  remoteId: RemoteId,
+  field: keyof RemoteProgress,
+  next: (current: number) => number
+): void => {
+  const request = store.get([remoteId as IDBValidKey]) as IDBRequest<RemoteProgress | undefined>
+  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: Entry, b: Entry) => indexedDB.cmp(a.id as IDBValidKey, b.id as IDBValidKey)
+
+// Greater than or equal to every entry id.
+const entryIdUpperBound = new Uint8Array(16).fill(0xff)
+
+interface EntryIdb {
+  readonly id: EntryId
+  readonly event: string
+  readonly primaryKey: string
+  readonly payload: Uint8Array
+}
+
+// Rows are written by `encodeEntryIdb`, so they are not validated again.
+const entryFromIdb = (row: EntryIdb): Entry =>
+  new Entry({
+    id: row.id,
+    event: row.event,
+    primaryKey: row.primaryKey,
+    payload: row.payload
+  }, { disableChecks: true })
+
 const encodeEntryIdb = Schema.encodeSync(Entry)
-const EntryIdbArray = Schema.Array(Entry)
-const decodeEntryIdbArray = Schema.decodeUnknownEffect(EntryIdbArray)
 
 /**
  * Provides `EventJournal` using the IndexedDB-backed implementation created by
@@ -827,6 +1199,18 @@ export const layerIndexedDb = (options?: {
     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 = <A>(
+  tx: IDBTransaction,
+  method: string,
+  resume: (effect: Effect.Effect<A, EventJournalError>) => void,
+  onComplete: () => A
+): void => {
+  tx.oncomplete = () => resume(Effect.succeed(onComplete()))
+  tx.onerror = tx.onabort = () => resume(Effect.fail(new EventJournalError({ method, cause: tx.error })))
+}
+
 const idbReq = <T>(method: string, evaluate: () => IDBRequest<T>) =>
   Effect.callback<T, EventJournalError>((resume) => {
     const request = evaluate()