experimental-a2 0.20.0 → 0.22.0

package/src/store-sqlite.ts

@@ -18,16 +18,26 @@ import { DatabaseSync } from 'node:sqlite'
 import { A2Error, supersededAttemptError } from './errors.ts'
 import { CLEAR_EVENT_TYPE, sessionClearedError } from './session-clear.ts'
 import { idempotentReplay } from './idempotent-replay.ts'
-import { decodeReturnedEventIds } from './store-codec.ts'
+import {
+  cursorKeyOf,
+  decodeCause,
+  decodeReturnedEventIds,
+  idleLogCursor,
+} from './store-codec.ts'
 import { pollingStream } from './store-polling.ts'
 import {
   RANDOM_IDS,
   SYSTEM_CLOCK,
   type A2Store,
+  type AppendEvent,
   type Clock,
   type Event,
   type EventCause,
+  type HeadEvent,
+  type HeadRef,
   type IdSource,
+  type StoreConsumer,
+  type StoredCursor,
   type StoredEvent,
 } from './store.ts'
 
@@ -45,7 +55,15 @@ export type SqliteStore = A2Store & {
   close(): void
 }
 
+/** The cursor layout; databases from before it are rejected, not migrated. */
+const LAYOUT = 'cursors-1'
+
 const SCHEMA = `
+create table if not exists a2_meta (
+  key   text not null primary key,
+  value text not null
+) strict;
+
 create table if not exists a2_events (
   session_id   text    not null,
   idx          integer not null,
@@ -54,35 +72,52 @@ create table if not exists a2_events (
   event_id     text    not null,
   created_at   integer not null,
   cause        text,
+  primary key (session_id, idx)
+) strict;
+
+create unique index if not exists a2_events_session_event_id
+  on a2_events (session_id, event_id);
+drop index if exists a2_events_event_id;
+create index if not exists a2_events_types on a2_events (session_id, event_type, idx);
+
+create table if not exists a2_cursors (
+  session_id   text    not null,
+  consumer     text    not null,
+  cursor_key   text    not null,
   lane         text,
-  lane_ready   integer not null default 0,
-  processed_at integer,
-  processed_by_attempt integer,
-  returned_event_ids text,
+  kind         text    not null,
+  position     integer not null,
+  head         integer,
+  types        text,
+  attempt_count integer not null default 0,
   first_claimed_at integer,
   last_claimed_at integer,
-  attempt_count integer not null default 0,
+  claim_holder text,
+  claim_expires_at integer,
   failure_count integer not null default 0,
   last_failed_at integer,
   last_failed_attempt integer,
   last_error   text,
   failed_at    integer,
-  claim_holder text,
-  claim_expires_at integer,
-  primary key (session_id, idx)
+  completed_idx integer,
+  completed_attempt integer,
+  returned_event_ids text,
+  primary key (session_id, consumer, cursor_key)
 ) strict;
 
-create unique index if not exists a2_events_event_id on a2_events (event_id);
-create index if not exists a2_events_unprocessed
-  on a2_events (session_id, idx) where processed_at is null;
-create index if not exists a2_events_lane_pending
-  on a2_events (session_id, lane, idx) where processed_at is null;
-create index if not exists a2_events_dispatch_ready
-  on a2_events (session_id, idx)
-  where lane_ready = 1 and processed_at is null and failed_at is null;
-create index if not exists a2_events_claim_expiry
-  on a2_events (session_id, claim_expires_at)
-  where lane_ready = 1 and processed_at is null and failed_at is null;
+create index if not exists a2_cursors_heads
+  on a2_cursors (session_id, head) where head is not null;
+
+create table if not exists a2_lane_events (
+  session_id   text    not null,
+  consumer     text    not null,
+  lane         text    not null,
+  idx          integer not null,
+  done         integer not null default 0,
+  completed_attempt integer,
+  returned_event_ids text,
+  primary key (session_id, consumer, lane, idx)
+) strict;
 
 create table if not exists a2_snapshots (
   session_id   text    not null,
@@ -104,10 +139,12 @@ create table if not exists a2_snapshot_history (
 
 create table if not exists a2_snapshot_pins (
   session_id   text    not null,
+  consumer     text    not null,
+  cursor_key   text    not null,
   event_index  integer not null,
   reducer_name text    not null,
   up_to_index  integer not null,
-  primary key (session_id, event_index, reducer_name, up_to_index)
+  primary key (session_id, consumer, cursor_key, event_index, reducer_name, up_to_index)
 ) strict;
 
 create index if not exists a2_snapshot_pins_checkpoint
@@ -165,34 +202,51 @@ const wrap = <T>(fn: () => T): T => {
 const toDate = (ms: number | bigint | null): Date | null =>
   ms === null ? null : new Date(Number(ms))
 
-const toCause = (json: string | null): EventCause | null => {
-  if (json === null) return null
-  const value = JSON.parse(json) as {
-    index?: unknown
-    attempt?: unknown
-    batchSize?: unknown
-  }
-  if (
-    !Number.isInteger(value.index) ||
-    Number(value.index) < 1 ||
-    !Number.isInteger(value.attempt) ||
-    Number(value.attempt) < 1
-  ) {
-    throw new TypeError('stored event has an invalid cause')
-  }
-  if (
-    value.batchSize !== undefined &&
-    (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)
-  ) {
-    throw new TypeError('stored event has an invalid cause')
-  }
-  return {
-    index: Number(value.index),
-    attempt: Number(value.attempt),
-    ...(value.batchSize === undefined
-      ? {}
-      : { batchSize: Number(value.batchSize) }),
-  }
+const toNumber = (value: number | bigint | null): number | null =>
+  value === null ? null : Number(value)
+
+type EventRow = {
+  session_id: string
+  idx: number | bigint
+  event_type: string
+  payload: string
+  event_id: string
+  created_at: number | bigint
+  cause: string | null
+}
+
+type CursorRow = {
+  session_id: string
+  consumer: string
+  cursor_key: string
+  lane: string | null
+  kind: 'log' | 'lane' | 'event'
+  position: number | bigint
+  head: number | bigint | null
+  types: string | null
+  attempt_count: number | bigint
+  first_claimed_at: number | bigint | null
+  last_claimed_at: number | bigint | null
+  claim_holder: string | null
+  claim_expires_at: number | bigint | null
+  failure_count: number | bigint
+  last_failed_at: number | bigint | null
+  last_failed_attempt: number | bigint | null
+  last_error: string | null
+  failed_at: number | bigint | null
+  completed_idx: number | bigint | null
+  completed_attempt: number | bigint | null
+  returned_event_ids: string | null
+}
+
+/** A cursor joined with its head event's columns, prefixed `e_`. */
+type HeadRow = CursorRow & {
+  e_idx: number | bigint
+  e_event_type: string
+  e_payload: string
+  e_event_id: string
+  e_created_at: number | bigint
+  e_cause: string | null
 }
 
 const toStored = (row: EventRow): StoredEvent => ({
@@ -202,26 +256,7 @@ const toStored = (row: EventRow): StoredEvent => ({
   index: Number(row.idx),
   sessionId: row.session_id,
   createdAt: new Date(Number(row.created_at)),
-  cause: toCause(row.cause),
-  lane: row.lane,
-  processedAt: toDate(row.processed_at),
-  processedByAttempt:
-    row.processed_by_attempt === null ? null : Number(row.processed_by_attempt),
-  returnedEventIds:
-    row.returned_event_ids === null
-      ? null
-      : decodeReturnedEventIds(row.returned_event_ids),
-  firstClaimedAt: toDate(row.first_claimed_at),
-  lastClaimedAt: toDate(row.last_claimed_at),
-  attemptCount: Number(row.attempt_count),
-  failureCount: Number(row.failure_count),
-  lastFailedAt: toDate(row.last_failed_at),
-  lastFailedAttempt:
-    row.last_failed_attempt === null ? null : Number(row.last_failed_attempt),
-  lastError: row.last_error,
-  failedAt: toDate(row.failed_at),
-  claimHolder: row.claim_holder,
-  claimExpiresAt: toDate(row.claim_expires_at),
+  cause: decodeCause(row.cause),
 })
 
 const toEvent = (row: EventRow): Event => ({
@@ -233,28 +268,37 @@ const toEvent = (row: EventRow): Event => ({
   createdAt: new Date(Number(row.created_at)),
 })
 
-type EventRow = {
-  session_id: string
-  idx: number | bigint
-  event_type: string
-  payload: string
-  event_id: string
-  created_at: number | bigint
-  cause: string | null
-  lane: string | null
-  processed_at: number | bigint | null
-  processed_by_attempt: number | bigint | null
-  returned_event_ids: string | null
-  first_claimed_at: number | bigint | null
-  last_claimed_at: number | bigint | null
-  attempt_count: number | bigint
-  failure_count: number | bigint
-  last_failed_at: number | bigint | null
-  last_failed_attempt: number | bigint | null
-  last_error: string | null
-  failed_at: number | bigint | null
-  claim_holder: string | null
-  claim_expires_at: number | bigint | null
+const toCursor = (row: CursorRow): StoredCursor => ({
+  consumer: row.consumer,
+  lane: row.lane,
+  position: Number(row.position),
+  head: toNumber(row.head),
+  firstClaimedAt: toDate(row.first_claimed_at),
+  lastClaimedAt: toDate(row.last_claimed_at),
+  attemptCount: Number(row.attempt_count),
+  claimHolder: row.claim_holder,
+  claimExpiresAt: toDate(row.claim_expires_at),
+  failureCount: Number(row.failure_count),
+  lastFailedAt: toDate(row.last_failed_at),
+  lastFailedAttempt: toNumber(row.last_failed_attempt),
+  lastError: row.last_error,
+  failedAt: toDate(row.failed_at),
+})
+
+const toHead = (row: HeadRow): HeadEvent => {
+  const { position: _position, head: _head, ...dispatch } = toCursor(row)
+  return {
+    ...toStored({
+      session_id: row.session_id,
+      idx: row.e_idx,
+      event_type: row.e_event_type,
+      payload: row.e_payload,
+      event_id: row.e_event_id,
+      created_at: row.e_created_at,
+      cause: row.e_cause,
+    }),
+    ...dispatch,
+  }
 }
 
 type PresenceDbRow = {
@@ -280,16 +324,30 @@ type SnapshotHeadRow = {
   updated_at: number | bigint
 }
 
-type AppendStatusRow = {
-  max: number | bigint
-  has_pending: number | bigint
-}
+const RECLAIM_BATCH = 256
 
-type ExistingEventRow = EventRow & {
-  session_has_pending: number | bigint
-}
+/** The head columns every claim, dead letter, and listing joins in. */
+const HEAD_SELECT = `
+  select cursor.*,
+         event.idx as e_idx, event.event_type as e_event_type,
+         event.payload as e_payload, event.event_id as e_event_id,
+         event.created_at as e_created_at, event.cause as e_cause
+    from a2_cursors cursor
+    join a2_events event
+      on event.session_id = cursor.session_id and event.idx = cursor.head`
 
-const RECLAIM_BATCH = 256
+/** A fresh head's dispatch columns, for `set` clauses. */
+const FRESH_DISPATCH = `
+  attempt_count = 0, first_claimed_at = null, last_claimed_at = null,
+  claim_holder = null, claim_expires_at = null, failure_count = 0,
+  last_failed_at = null, last_failed_attempt = null, last_error = null,
+  failed_at = null`
+
+const placeholders = (count: number): string =>
+  Array.from({ length: count }, () => '?').join(', ')
+
+const compareText = (a: string, b: string): number =>
+  a < b ? -1 : a > b ? 1 : 0
 
 export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   const path = options.path ?? '.a2/dev.db'
@@ -311,44 +369,126 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   db.exec('pragma busy_timeout = 5000')
   setWalJournalMode(db)
   db.exec('pragma synchronous = normal')
+  const legacy = db
+    .prepare("select 1 from pragma_table_info('a2_events') where name = ?")
+    .get('processed_at')
+  if (legacy) {
+    db.close()
+    throw new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `the sqlite database at '${path}' has the A2 layout from before consumers; delete it, or point the store at a fresh database file`,
+    )
+  }
   db.exec(SCHEMA)
+  db.prepare(
+    "insert into a2_meta (key, value) values ('layout', ?) on conflict (key) do nothing",
+  ).run(LAYOUT)
 
   const insertEvent = db.prepare(
     `insert into a2_events
-       (session_id, idx, event_type, payload, event_id, created_at,
-        cause, lane, lane_ready, processed_at)
-     select ?, ?, ?, ?, ?, ?, ?, ?,
-            case
-              when ? is null then 1
-              when not exists (
-                select 1 from a2_events
-                 where session_id = ? and lane = ? and processed_at is null
-                   and idx > ?
-              ) then 1
-              else 0
-            end,
-            ?`,
+       (session_id, idx, event_type, payload, event_id, created_at, cause)
+     values (?, ?, ?, ?, ?, ?, ?)`,
+  )
+  const selectHead = db.prepare(
+    'select coalesce(max(idx), 0) as max from a2_events where session_id = ?',
+  )
+  const headOf = (sessionId: string): number =>
+    Number((selectHead.get(sessionId) as { max: number | bigint }).max)
+  const selectEvent = db.prepare(
+    'select 1 from a2_events where session_id = ? and idx = ?',
+  )
+  const selectCursor = db.prepare(
+    'select * from a2_cursors where session_id = ? and consumer = ? and cursor_key = ?',
   )
-  const promoteLaneHead = db.prepare(
-    `update a2_events set lane_ready = 1
-      where session_id = ?
-        and idx = (
-          select idx from a2_events
-           where session_id = ? and lane = ? and processed_at is null
-             and idx > ?
-           order by idx limit 1
-        )`,
+  const cursorOf = (sessionId: string, ref: HeadRef): CursorRow | undefined =>
+    selectCursor.get(
+      sessionId,
+      ref.consumer,
+      cursorKeyOf(ref.lane, ref.index),
+    ) as CursorRow | undefined
+  const insertEventCursor = db.prepare(
+    `insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head)
+     values (?, ?, ?, null, 'event', ?, ?)`,
+  )
+  const insertLaneEvent = db.prepare(
+    `insert into a2_lane_events (session_id, consumer, lane, idx)
+     values (?, ?, ?, ?)`,
+  )
+  // A lane cursor whose head lies at or below the clear marker is idle: the
+  // marker superseded everything it had queued.
+  const queueLaneHead = db.prepare(
+    `insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head)
+     values (?, ?, ?, ?, 'lane', ?, ?)
+     on conflict (session_id, consumer, cursor_key) do update set
+       head = excluded.head,
+       position = max(a2_cursors.position, excluded.position),
+       ${FRESH_DISPATCH}
+     where a2_cursors.head is null or a2_cursors.head <= excluded.position`,
+  )
+  const openLogCursor = db.prepare(
+    `insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head, types)
+     values (?, ?, ?, ?, 'log', ?, ?, ?)`,
+  )
+  const wakeLogCursor = db.prepare(
+    `update a2_cursors set types = ?, head = ?
+      where session_id = ? and consumer = ? and cursor_key = ?`,
+  )
+  const refreshTypes = db.prepare(
+    `update a2_cursors set types = ?
+      where session_id = ? and consumer = ? and kind = 'log'
+        and types is not ?`,
+  )
+  const nextLogHeadAll = db.prepare(
+    `select min(idx) as next from a2_events
+      where session_id = ? and idx > ? and event_type != ?`,
+  )
+  const nextLogHeadOf = db.prepare(
+    `select min(idx) as next from a2_events
+      where session_id = ? and idx > ? and event_type != ?
+        and event_type in (select value from json_each(?))`,
+  )
+  const nextLogHead = (
+    sessionId: string,
+    after: number,
+    types: string | null,
+  ): number | null =>
+    toNumber(
+      (
+        (types === null
+          ? nextLogHeadAll.get(sessionId, after, CLEAR_EVENT_TYPE)
+          : nextLogHeadOf.get(sessionId, after, CLEAR_EVENT_TYPE, types)) as {
+          next: number | bigint | null
+        }
+      ).next,
+    )
+  const nextLaneHead = db.prepare(
+    `select min(idx) as next from a2_lane_events
+      where session_id = ? and consumer = ? and lane = ? and done = 0
+        and idx > ?`,
+  )
+  const selectLaneEvent = db.prepare(
+    `select completed_attempt, returned_event_ids from a2_lane_events
+      where session_id = ? and consumer = ? and lane = ? and idx = ?`,
   )
-  const appendStatus = db.prepare(
-    `select coalesce(
-              (select max(idx) from a2_events where session_id = ?),
-              0
-            ) as max,
-            exists(
-              select 1 from a2_events
-              where session_id = ? and processed_at is null and idx > ?
-            ) as has_pending`,
+  const finishLaneEvent = db.prepare(
+    `update a2_lane_events
+        set done = 1, completed_attempt = ?, returned_event_ids = ?
+      where session_id = ? and consumer = ? and lane = ? and idx = ?`,
   )
+  const moveCursor = db.prepare(
+    `update a2_cursors set position = ?, head = ?, ${FRESH_DISPATCH}
+      where session_id = ? and consumer = ? and cursor_key = ?`,
+  )
+  const recordCompletion = db.prepare(
+    `update a2_cursors
+        set completed_idx = ?, completed_attempt = ?, returned_event_ids = ?
+      where session_id = ? and consumer = ? and cursor_key = ?`,
+  )
+  // A JSON null value is a tombstone: a delete's `at`, kept until it
+  // expires so an older set arriving after it still loses.
   const upsertPresence = db.prepare(
     `insert into a2_presence (ns, participant, field, value, seen, at, expires_at)
      values (?, ?, ?, ?, ?, ?, ?)
@@ -357,11 +497,7 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
        seen = excluded.seen,
        at = excluded.at,
        expires_at = excluded.expires_at
-     where a2_presence.at <= excluded.at`,
-  )
-  const deletePresence = db.prepare(
-    `delete from a2_presence
-      where ns = ? and participant = ? and field = ? and at <= ?`,
+     where a2_presence.at <= excluded.at or a2_presence.expires_at <= ?`,
   )
   const sweepPresence = db.prepare(
     'delete from a2_presence where ns = ? and expires_at <= ?',
@@ -369,21 +505,14 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   const selectPresence = db.prepare(
     `select participant, field, value, seen, at, expires_at
        from a2_presence
-      where ns = ? and expires_at > ?
+      where ns = ? and expires_at > ? and value != 'null'
       order by participant, field`,
   )
   const selectByIds = (count: number) =>
     db.prepare(
-      `select stored.*,
-              exists(
-                select 1 from a2_events pending
-                where pending.session_id = ?
-                  and pending.processed_at is null
-                  and pending.idx > ?
-              ) as session_has_pending
-         from a2_events stored
-        where stored.event_id in (${Array.from({ length: count }, () => '?').join(', ')})
-        order by stored.idx`,
+      `select * from a2_events
+        where session_id = ? and event_id in (${placeholders(count)})
+        order by idx`,
     )
 
   const selectClearIndex = db.prepare(
@@ -400,33 +529,59 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
     'delete from a2_events where session_id = ? and event_id = ?',
   )
 
+  /** Served consumers as a SQL condition on `cursor.consumer`. */
+  const servedClause = (
+    consumers: readonly StoreConsumer[] | undefined,
+  ): { sql: string; params: string[] } =>
+    consumers === undefined
+      ? { sql: '', params: [] }
+      : consumers.length === 0
+        ? { sql: 'and 0', params: [] }
+        : {
+            sql: `and cursor.consumer in (${placeholders(consumers.length)})`,
+            params: consumers.map((consumer) => consumer.name),
+          }
+
+  const hasPending = (
+    sessionId: string,
+    clearIndex: number,
+    consumers: readonly StoreConsumer[] | undefined,
+  ): boolean => {
+    const served = servedClause(consumers)
+    return (
+      db
+        .prepare(
+          `select 1 from a2_cursors cursor
+            where cursor.session_id = ? and cursor.head > ?
+              and cursor.failed_at is null ${served.sql}
+            limit 1`,
+        )
+        .get(sessionId, clearIndex, ...served.params) !== undefined
+    )
+  }
+
   /**
-   * The rows owning `ids`. This session's rows below its clear marker do
-   * not own their ids: they are deleted here so the ids can be reused.
+   * The session's rows owning `ids`. Rows below its clear marker do not
+   * own their ids: they are deleted here so the ids can be reused.
    */
   const liveOwnersOf = (
     sessionId: string,
     clearIndex: number,
     ids: readonly string[],
-  ): ExistingEventRow[] => {
+  ): EventRow[] => {
     if (ids.length === 0) return []
     const rows = selectByIds(ids.length).all(
       sessionId,
-      clearIndex,
       ...ids,
-    ) as unknown as ExistingEventRow[]
+    ) as unknown as EventRow[]
     return rows.filter((row) => {
-      if (row.session_id !== sessionId || Number(row.idx) >= clearIndex)
-        return true
+      if (Number(row.idx) >= clearIndex) return true
       deleteEventById.run(sessionId, row.event_id)
       return false
     })
   }
 
-  const selectCauseParent = db.prepare(
-    'select attempt_count, failed_at from a2_events where session_id = ? and idx = ?',
-  )
-  /** The attempt-currency fence shared by handler appends and clears. */
+  /** The attempt-currency fence shared by consumer appends and clears. */
   const assertCurrentCause = ({
     sessionId,
     cause,
@@ -438,16 +593,12 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
   }): void => {
     if (cause.index <= clearIndex)
       throw supersededAttemptError(sessionId, cause)
-    const parent = selectCauseParent.get(sessionId, cause.index) as
-      { attempt_count: number | bigint; failed_at: unknown } | undefined
-    if (!parent) {
-      throw new TypeError(
-        `no event at index ${cause.index} in session '${sessionId}'`,
-      )
-    }
+    const cursor = cursorOf(sessionId, cause)
     if (
-      Number(parent.attempt_count) !== cause.attempt ||
-      parent.failed_at !== null
+      !cursor ||
+      toNumber(cursor.head) !== cause.index ||
+      Number(cursor.attempt_count) !== cause.attempt ||
+      cursor.failed_at !== null
     ) {
       throw supersededAttemptError(sessionId, cause)
     }
@@ -470,11 +621,17 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
     }
   }
 
-  /** A dead-lettered event's snapshot pins, and history no pin keeps. */
-  const releasePins = (sessionId: string, index: number): void => {
+  /** A finished or dead head's snapshot pins, and history no pin keeps. */
+  const releasePins = (
+    sessionId: string,
+    consumer: string,
+    cursorKey: string,
+    index: number,
+  ): void => {
     db.prepare(
-      'delete from a2_snapshot_pins where session_id = ? and event_index = ?',
-    ).run(sessionId, index)
+      `delete from a2_snapshot_pins
+        where session_id = ? and consumer = ? and cursor_key = ? and event_index = ?`,
+    ).run(sessionId, consumer, cursorKey, index)
     db.prepare(
       `delete from a2_snapshot_history
         where session_id = ?
@@ -486,20 +643,201 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           )`,
     ).run(sessionId)
   }
+
+  /** Moves a cursor past its head; the next head starts fresh. */
+  const advance = (sessionId: string, cursor: CursorRow): void => {
+    const done = Number(cursor.head)
+    releasePins(sessionId, cursor.consumer, cursor.cursor_key, done)
+    let next: number | null
+    if (cursor.kind === 'event') {
+      next = null
+    } else if (cursor.kind === 'lane') {
+      next = toNumber(
+        (
+          nextLaneHead.get(
+            sessionId,
+            cursor.consumer,
+            cursor.lane,
+            Math.max(done, clearIndexOf(sessionId)),
+          ) as { next: number | bigint | null }
+        ).next,
+      )
+    } else {
+      const { types } = selectCursor.get(
+        sessionId,
+        cursor.consumer,
+        cursor.cursor_key,
+      ) as CursorRow
+      next = nextLogHead(sessionId, done, types)
+    }
+    moveCursor.run(done, next, sessionId, cursor.consumer, cursor.cursor_key)
+  }
+
+  /**
+   * Brings a log consumer's cursor up to date and records its types. A
+   * missing cursor opens at the clear marker with `backfill`, otherwise at
+   * `base`; an idle one takes the next event of its types after its
+   * position; one with a head keeps it, claim and all. Returns its key.
+   */
+  const wakeLogAt = ({
+    sessionId,
+    consumer,
+    log,
+    base,
+    clearIndex,
+  }: {
+    sessionId: string
+    consumer: string
+    log: NonNullable<StoreConsumer['log']>
+    base: number
+    clearIndex: number
+  }): string => {
+    const types = log.types === null ? null : JSON.stringify(log.types)
+    const key = cursorKeyOf(log.lane, 0)
+    const existing = selectCursor.get(sessionId, consumer, key) as
+      CursorRow | undefined
+    if (existing) {
+      wakeLogCursor.run(
+        types,
+        existing.head === null
+          ? // A deployment that doesn't serve this consumer may have
+            // appended events it takes since it went idle.
+            nextLogHead(sessionId, Number(existing.position), types)
+          : Number(existing.head),
+        sessionId,
+        consumer,
+        key,
+      )
+      return key
+    }
+    const position = log.backfill ? clearIndex : base
+    openLogCursor.run(
+      sessionId,
+      consumer,
+      key,
+      log.lane,
+      position,
+      nextLogHead(sessionId, position, types),
+      types,
+    )
+    return key
+  }
+
+  /** Starts the cursor work an inserted batch carries. */
+  const enqueue = ({
+    sessionId,
+    events,
+    base,
+    clearIndex,
+    consumers,
+  }: {
+    sessionId: string
+    events: readonly AppendEvent[]
+    base: number
+    clearIndex: number
+    consumers: readonly StoreConsumer[] | undefined
+  }): void => {
+    events.forEach((event, offset) => {
+      const index = base + 1 + offset
+      for (const target of event.targets ?? []) {
+        if (target.lane === null) {
+          insertEventCursor.run(
+            sessionId,
+            target.consumer,
+            cursorKeyOf(null, index),
+            index - 1,
+            index,
+          )
+          continue
+        }
+        insertLaneEvent.run(sessionId, target.consumer, target.lane, index)
+        queueLaneHead.run(
+          sessionId,
+          target.consumer,
+          cursorKeyOf(target.lane, index),
+          target.lane,
+          clearIndex,
+          index,
+        )
+      }
+    })
+    // The batch is inserted already, so a cursor it wakes finds the batch's
+    // first event of its types, or an earlier one.
+    for (const consumer of consumers ?? []) {
+      const log = consumer.log
+      if (!log) continue
+      const carries = events.some(
+        (event) =>
+          event.type !== CLEAR_EVENT_TYPE &&
+          (log.types === null || log.types.includes(event.type)),
+      )
+      if (!carries) continue
+      wakeLogAt({ sessionId, consumer: consumer.name, log, base, clearIndex })
+    }
+  }
+
+  const refreshLogTypes = (
+    sessionId: string,
+    consumers: readonly StoreConsumer[] | undefined,
+  ): void => {
+    for (const consumer of consumers ?? []) {
+      if (!consumer.log) continue
+      const types =
+        consumer.log.types === null ? null : JSON.stringify(consumer.log.types)
+      refreshTypes.run(types, sessionId, consumer.name, types)
+    }
+  }
+
+  const insertBatch = ({
+    sessionId,
+    events,
+    clearIndex,
+    consumers,
+    cause,
+  }: {
+    sessionId: string
+    events: readonly AppendEvent[]
+    clearIndex: number
+    consumers: readonly StoreConsumer[] | undefined
+    cause?: EventCause
+  }): StoredEvent[] => {
+    const base = headOf(sessionId)
+    const now = clock.now().getTime()
+    const inserted = events.map((event, offset): StoredEvent => {
+      const id = event.id ?? generateId()
+      const index = base + 1 + offset
+      const eventCause = cause ?? event.cause ?? null
+      insertEvent.run(
+        sessionId,
+        index,
+        event.type,
+        JSON.stringify(event.payload) ?? 'null',
+        id,
+        now,
+        eventCause ? JSON.stringify(eventCause) : null,
+      )
+      return {
+        id,
+        type: event.type,
+        payload: structuredClone(event.payload),
+        index,
+        sessionId,
+        createdAt: new Date(now),
+        cause: eventCause ? { ...eventCause } : null,
+      }
+    })
+    enqueue({ sessionId, events, base, clearIndex, consumers })
+    return inserted
+  }
+
   return {
     async append(sessionId, events, appendOptions) {
+      const consumers = appendOptions?.consumers
       if (events.length === 0) {
-        return wrap(() => {
-          const status = appendStatus.get(
-            sessionId,
-            sessionId,
-            clearIndexOf(sessionId),
-          ) as AppendStatusRow
-          return {
-            events: [],
-            hasPending: Number(status.has_pending) === 1,
-          }
-        })
+        return wrap(() => ({
+          events: [],
+          hasPending: hasPending(sessionId, clearIndexOf(sessionId), consumers),
+        }))
       }
       return wrap(() =>
         tx(() => {
@@ -515,19 +853,10 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           if (suppliedIds.length > 0) {
             const existing = liveOwnersOf(sessionId, clearIndex, suppliedIds)
             if (existing.length > 0) {
-              const foreign = existing.find(
-                (row) => row.session_id !== sessionId,
-              )
-              if (foreign) {
-                throw new A2Error(
-                  'PARTIAL_DUPLICATE_BATCH',
-                  `event id '${foreign.event_id}' already exists in another session`,
-                )
-              }
               if (existing.length === events.length) {
                 return {
                   events: idempotentReplay(events, existing.map(toStored)),
-                  hasPending: Number(existing[0]!.session_has_pending) === 1,
+                  hasPending: hasPending(sessionId, clearIndex, consumers),
                 }
               }
               throw new A2Error(
@@ -543,8 +872,8 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
               `scheduled work from event ${originIndex} was cleared in session '${sessionId}'`,
             )
           }
-          // Attempt-currency fence: a fresh handler append commits only
-          // while its causal attempt is still the parent's latest
+          // Attempt-currency fence: a fresh consumer append commits only
+          // while its causal attempt still owns the cursor's head
           // (store.ts `append`). `begin immediate` serializes this read
           // against a concurrent claim.
           for (const e of events) {
@@ -552,65 +881,69 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
               assertCurrentCause({ sessionId, cause: e.cause, clearIndex })
           }
 
-          const status = appendStatus.get(
-            sessionId,
+          const inserted = insertBatch({
             sessionId,
+            events,
             clearIndex,
-          ) as AppendStatusRow
-          const base = Number(status.max)
-          const now = clock.now().getTime()
-          const inserted: StoredEvent[] = events.map((e, i) => {
-            const id = e.id ?? generateId()
-            const index = base + 1 + i
-            insertEvent.run(
-              sessionId,
-              index,
-              e.type,
-              JSON.stringify(e.payload) ?? 'null',
-              id,
-              now,
-              e.cause ? JSON.stringify(e.cause) : null,
-              e.lane ?? null,
-              e.lane ?? null,
-              sessionId,
-              e.lane ?? null,
-              clearIndex,
-              e.settled ? now : null,
-            )
-            return {
-              id,
-              type: e.type,
-              payload: structuredClone(e.payload),
-              index,
-              sessionId,
-              createdAt: new Date(now),
-              cause: e.cause ? { ...e.cause } : null,
-              lane: e.lane ?? null,
-              processedAt: e.settled ? new Date(now) : null,
-              processedByAttempt: null,
-              returnedEventIds: null,
-              firstClaimedAt: null,
-              lastClaimedAt: null,
-              attemptCount: 0,
-              failureCount: 0,
-              lastFailedAt: null,
-              lastFailedAttempt: null,
-              lastError: null,
-              failedAt: null,
-              claimHolder: null,
-              claimExpiresAt: null,
-            }
+            consumers,
           })
           return {
             events: inserted,
-            hasPending:
-              Number(status.has_pending) === 1 ||
-              events.some((event) => event.settled !== true),
+            hasPending: hasPending(sessionId, clearIndex, consumers),
           }
         }),
       )
     },
 
+    async wakeLog({ sessionId, consumer }) {
+      return wrap(() => {
+        // Nothing after the latest clear: a missing cursor stays missing,
+        // and nothing takes the write lock.
+        const { lane } = consumer.log
+        const marker = clearIndexOf(sessionId)
+        if (
+          headOf(sessionId) === marker &&
+          !selectCursor.get(sessionId, consumer.name, cursorKeyOf(lane, 0))
+        ) {
+          return {
+            cursor: idleLogCursor(consumer.name, lane, marker),
+            head: marker,
+          }
+        }
+        return tx(() => {
+          const head = headOf(sessionId)
+          const key = wakeLogAt({
+            sessionId,
+            consumer: consumer.name,
+            log: consumer.log,
+            base: head,
+            clearIndex: clearIndexOf(sessionId),
+          })
+          const cursor = selectCursor.get(sessionId, consumer.name, key)
+          return { cursor: toCursor(cursor as CursorRow), head }
+        })
+      })
+    },
+
+    async cursors(sessionId) {
+      return wrap(() => {
+        const clearIndex = clearIndexOf(sessionId)
+        const rows = db
+          .prepare(
+            `select * from a2_cursors
+              where session_id = ?
+                and (
+                  kind = 'log'
+                  or head > ?
+                  or (kind = 'lane' and head is null and position > ?)
+                )
+              order by consumer, lane is null, lane, head`,
+          )
+          .all(sessionId, clearIndex, clearIndex) as unknown as CursorRow[]
+        return rows.map(toCursor)
+      })
+    },
+
     async read(sessionId, opts) {
       return wrap(() => {
         // Reads start at the latest clear marker.
@@ -641,44 +974,61 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
       holder,
       ttlMs,
       expiresAtMs,
-      excludeIndexes = [],
+      exclude = [],
+      consumers,
       maxFailures,
+      through,
     }) {
       return wrap(() =>
         tx(() => {
+          refreshLogTypes(sessionId, consumers)
           const now = clock.now().getTime()
           const expiresAt = expiresAtMs ?? now + ttlMs
           const clearIndex = clearIndexOf(sessionId)
+          const served = servedClause(consumers)
+          const excludedKeys = exclude.map(
+            (ref) => `${ref.consumer}\u0000${cursorKeyOf(ref.lane, ref.index)}`,
+          )
           const exclusion =
-            excludeIndexes.length === 0
+            excludedKeys.length === 0
               ? ''
-              : `and event.idx not in (${excludeIndexes.map(() => '?').join(', ')})`
+              : `and cursor.consumer || char(0) || cursor.cursor_key
+                     not in (${placeholders(excludedKeys.length)})`
+          const bounded = through === undefined ? '' : 'and cursor.head <= ?'
+          const filter = `
+            where cursor.session_id = ?
+              and cursor.head > ?
+              and cursor.failed_at is null
+              ${bounded}
+              ${served.sql}
+              ${exclusion}`
+          const params = [
+            sessionId,
+            clearIndex,
+            ...(through === undefined ? [] : [through]),
+            ...served.params,
+            ...excludedKeys,
+            now,
+          ]
           const eligible = db
             .prepare(
-              `select event.idx, event.claim_holder, event.failure_count
-                 from a2_events event
-                where event.session_id = ?
-                  and event.processed_at is null
-                  and event.failed_at is null
-                  and event.lane_ready = 1
-                  and event.idx > ?
-                  and (event.claim_expires_at is null or event.claim_expires_at <= ?)
-                  ${exclusion}
-                order by event.idx`,
+              `select cursor.consumer, cursor.cursor_key,
+                      cursor.claim_holder, cursor.failure_count
+                 from a2_cursors cursor
+                ${filter}
+                  and (cursor.claim_expires_at is null
+                       or cursor.claim_expires_at <= ?)
+                order by cursor.head, cursor.consumer`,
             )
-            .all(
-              sessionId,
-              clearIndex,
-              now,
-              ...excludeIndexes,
-            ) as unknown as Array<{
-            idx: number | bigint
-            claim_holder: string | null
-            failure_count: number | bigint
-          }>
+            .all(...params) as unknown as Array<
+            Pick<
+              CursorRow,
+              'consumer' | 'cursor_key' | 'claim_holder' | 'failure_count'
+            >
+          >
           if (eligible.length > 0) {
-            const update = db.prepare(
-              `update a2_events set
+            const claimHead = db.prepare(
+              `update a2_cursors set
                  attempt_count = attempt_count + 1,
                  failure_count = failure_count
                    + case when claim_holder is null then 0 else 1 end,
@@ -686,55 +1036,71 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                  last_claimed_at = ?,
                  claim_holder = ?,
                  claim_expires_at = ?
-               where session_id = ? and idx = ?
-               returning *`,
+               where session_id = ? and consumer = ? and cursor_key = ?`,
             )
             // Advancing the attempt fences the lapsed one; nothing runs.
-            const deadLetter = () =>
-              db.prepare(
-                `update a2_events set
-                   attempt_count = attempt_count + 1,
-                   failure_count = failure_count + 1,
-                   failed_at = ?,
-                   claim_holder = null,
-                   claim_expires_at = null
-                 where session_id = ? and idx = ?
-                 returning *`,
-              )
+            const deadLetterHead = db.prepare(
+              `update a2_cursors set
+                 attempt_count = attempt_count + 1,
+                 failure_count = failure_count + 1,
+                 failed_at = ?,
+                 claim_holder = null,
+                 claim_expires_at = null
+               where session_id = ? and consumer = ? and cursor_key = ?`,
+            )
+            const selectHeadRow = db.prepare(
+              `${HEAD_SELECT}
+                where cursor.session_id = ? and cursor.consumer = ?
+                  and cursor.cursor_key = ?`,
+            )
             const events = eligible.map((row) => {
               // A lapsed claim's takeover that spends the last failed attempt.
               const exhausted =
                 row.claim_holder !== null &&
                 maxFailures !== undefined &&
                 Number(row.failure_count) + 1 >= maxFailures
-              const claimed = (
-                exhausted
-                  ? deadLetter().get(now, sessionId, row.idx)
-                  : update.get(now, now, holder, expiresAt, sessionId, row.idx)
-              ) as EventRow
-              if (exhausted) releasePins(sessionId, Number(row.idx))
-              const stored = toStored(claimed)
-              if (clearIndex > 0) stored.clearIndex = clearIndex
-              return stored
+              if (exhausted) {
+                deadLetterHead.run(now, sessionId, row.consumer, row.cursor_key)
+              } else {
+                claimHead.run(
+                  now,
+                  now,
+                  holder,
+                  expiresAt,
+                  sessionId,
+                  row.consumer,
+                  row.cursor_key,
+                )
+              }
+              const claimed = toHead(
+                selectHeadRow.get(
+                  sessionId,
+                  row.consumer,
+                  row.cursor_key,
+                ) as HeadRow,
+              )
+              if (exhausted) {
+                releasePins(
+                  sessionId,
+                  row.consumer,
+                  row.cursor_key,
+                  claimed.index,
+                )
+              }
+              if (clearIndex > 0) claimed.clearIndex = clearIndex
+              return claimed
             })
-            return { outcome: 'claimed', events }
+            return { outcome: 'claimed', events, head: headOf(sessionId) }
           }
 
           const active = db
             .prepare(
-              `select min(claim_expires_at) as retry_at
-                 from a2_events event
-                where session_id = ?
-                  and processed_at is null
-                  and failed_at is null
-                  and lane_ready = 1
-                  and idx > ?
-                  and claim_expires_at > ?
-                  ${exclusion}`,
+              `select min(cursor.claim_expires_at) as retry_at
+                 from a2_cursors cursor
+                ${filter}
+                  and cursor.claim_expires_at > ?`,
             )
-            .get(sessionId, clearIndex, now, ...excludeIndexes) as {
-            retry_at: number | bigint | null
-          }
+            .get(...params) as { retry_at: number | bigint | null }
           return active.retry_at === null
             ? { outcome: 'settled' }
             : { outcome: 'busy', retryAt: new Date(Number(active.retry_at)) }
@@ -748,65 +1114,76 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
         tx(() => {
           const now = clock.now().getTime()
           const expiresAt = expiresAtMs ?? now + ttlMs
-          const renewed: number[] = []
-          const superseded: number[] = []
-          const currentAttempt = db.prepare(
-            'select attempt_count from a2_events where session_id = ? and idx = ?',
-          )
+          const renewed: HeadRef[] = []
+          const superseded: HeadRef[] = []
           const extend = db.prepare(
-            `update a2_events set claim_expires_at = ?
-              where session_id = ?
-                and idx = ?
+            `update a2_cursors set claim_expires_at = ?
+              where session_id = ? and consumer = ? and cursor_key = ?
+                and head = ?
                 and attempt_count = ?
-                and processed_at is null
                 and failed_at is null
                 and claim_holder = ?
                 and claim_expires_at > ?`,
           )
           const clearIndex = clearIndexOf(sessionId)
-          for (const claim of claims) {
-            if (claim.index <= clearIndex) {
-              superseded.push(claim.index)
+          const ordered = claims.toSorted(
+            (a, b) => a.index - b.index || compareText(a.consumer, b.consumer),
+          )
+          for (const { attempt, ...ref } of ordered) {
+            if (ref.index <= clearIndex) {
+              superseded.push(ref)
               continue
             }
-            const row = currentAttempt.get(sessionId, claim.index) as
-              { attempt_count: number | bigint } | undefined
-            if (!row) continue
-            if (Number(row.attempt_count) > claim.attempt) {
-              superseded.push(claim.index)
+            const cursor = cursorOf(sessionId, ref)
+            if (!cursor) continue
+            const head = toNumber(cursor.head)
+            // An event the cursor has not reached yet holds no claim to renew.
+            if (head !== ref.index && Number(cursor.position) < ref.index)
+              continue
+            if (head !== ref.index || Number(cursor.attempt_count) > attempt) {
+              superseded.push(ref)
               continue
             }
             const updated = extend.run(
               expiresAt,
               sessionId,
-              claim.index,
-              claim.attempt,
+              ref.consumer,
+              cursor.cursor_key,
+              ref.index,
+              attempt,
               holder,
               now,
             )
-            if (Number(updated.changes) === 1) renewed.push(claim.index)
-          }
-          return {
-            renewed: renewed.toSorted((a, b) => a - b),
-            superseded: superseded.toSorted((a, b) => a - b),
+            if (Number(updated.changes) === 1) renewed.push(ref)
           }
+          return { renewed, superseded }
         }),
       )
     },
 
-    async completeAttempt({ sessionId, index, attempt, events }) {
+    async completeAttempt({
+      sessionId,
+      consumer,
+      lane,
+      index,
+      attempt,
+      events,
+      consumers,
+    }) {
       return wrap(() =>
         tx(() => {
           const clearIndex = clearIndexOf(sessionId)
           if (index <= clearIndex) return { outcome: 'superseded' }
-          const parent = db
-            .prepare('select * from a2_events where session_id = ? and idx = ?')
-            .get(sessionId, index) as EventRow | undefined
-          if (!parent) {
-            throw new TypeError(
-              `no event at index ${index} in session '${sessionId}'`,
-            )
+          const cursor = cursorOf(sessionId, { consumer, lane, index })
+          if (!cursor) {
+            if (!selectEvent.get(sessionId, index)) {
+              throw new TypeError(
+                `no event at index ${index} in session '${sessionId}'`,
+              )
+            }
+            return { outcome: 'superseded' }
           }
+          refreshLogTypes(sessionId, consumers)
           const ids = events.map((event) => event.id)
           if (new Set(ids).size !== ids.length) {
             throw new A2Error(
@@ -815,14 +1192,38 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             )
           }
 
-          if (parent.processed_at !== null) {
-            if (Number(parent.processed_by_attempt) !== attempt) {
+          if (toNumber(cursor.head) !== index) {
+            let completion:
+              { attempt: number | null; ids: string | null } | undefined
+            if (cursor.kind === 'lane') {
+              const row = selectLaneEvent.get(
+                sessionId,
+                consumer,
+                lane,
+                index,
+              ) as
+                | {
+                    completed_attempt: number | bigint | null
+                    returned_event_ids: string | null
+                  }
+                | undefined
+              completion = row && {
+                attempt: toNumber(row.completed_attempt),
+                ids: row.returned_event_ids,
+              }
+            } else if (toNumber(cursor.completed_idx) === index) {
+              completion = {
+                attempt: toNumber(cursor.completed_attempt),
+                ids: cursor.returned_event_ids,
+              }
+            }
+            if (!completion || completion.attempt !== attempt) {
               return { outcome: 'superseded' }
             }
             const returnedIds =
-              parent.returned_event_ids === null
+              completion.ids === null
                 ? null
-                : decodeReturnedEventIds(parent.returned_event_ids)
+                : decodeReturnedEventIds(completion.ids)
             if (
               returnedIds === null ||
               returnedIds.length !== ids.length ||
@@ -838,20 +1239,21 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                 ? []
                 : (selectByIds(ids.length).all(
                     sessionId,
-                    clearIndex,
                     ...ids,
-                  ) as unknown as ExistingEventRow[])
+                  ) as unknown as EventRow[])
             const byId = new Map(existing.map((row) => [row.event_id, row]))
             const ordered = ids.map((id) => byId.get(id))
             if (
-              ordered.some(
-                (row) =>
+              ordered.some((row) => {
+                const cause = row ? decodeCause(row.cause) : null
+                return (
                   !row ||
-                  row.session_id !== sessionId ||
-                  row.cause === null ||
-                  toCause(row.cause)?.index !== index ||
-                  toCause(row.cause)?.attempt !== attempt,
-              )
+                  cause?.consumer !== consumer ||
+                  cause.lane !== lane ||
+                  cause.index !== index ||
+                  cause.attempt !== attempt
+                )
+              })
             ) {
               throw new A2Error(
                 'PARTIAL_DUPLICATE_BATCH',
@@ -860,16 +1262,19 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             }
             return {
               outcome: 'completed',
-              events: idempotentReplay(
-                events,
-                (ordered as ExistingEventRow[]).map(toStored),
-              ),
+              events:
+                events.length === 0
+                  ? []
+                  : idempotentReplay(
+                      events,
+                      (ordered as EventRow[]).map(toStored),
+                    ),
             }
           }
           if (
-            Number(parent.attempt_count) !== attempt ||
-            parent.claim_holder === null ||
-            parent.failed_at !== null
+            Number(cursor.attempt_count) !== attempt ||
+            cursor.claim_holder === null ||
+            cursor.failed_at !== null
           ) {
             return { outcome: 'superseded' }
           }
@@ -881,65 +1286,34 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             )
           }
 
-          const status = appendStatus.get(
-            sessionId,
+          const inserted = insertBatch({
             sessionId,
+            events,
             clearIndex,
-          ) as AppendStatusRow
-          const now = clock.now().getTime()
-          db.prepare(
-            `update a2_events set
-               processed_at = ?,
-               processed_by_attempt = ?,
-               returned_event_ids = ?,
-               lane_ready = 0,
-               claim_holder = null,
-               claim_expires_at = null
-             where session_id = ? and idx = ?`,
-          ).run(now, attempt, JSON.stringify(ids), sessionId, index)
-          db.prepare(
-            'delete from a2_snapshot_pins where session_id = ? and event_index = ?',
-          ).run(sessionId, index)
-          db.prepare(
-            `delete from a2_snapshot_history
-              where session_id = ?
-                and not exists (
-                  select 1 from a2_snapshot_pins pin
-                   where pin.session_id = a2_snapshot_history.session_id
-                     and pin.reducer_name = a2_snapshot_history.reducer_name
-                     and pin.up_to_index = a2_snapshot_history.up_to_index
-                )`,
-          ).run(sessionId)
-          if (parent.lane !== null) {
-            promoteLaneHead.run(sessionId, sessionId, parent.lane, clearIndex)
-          }
-          const inserted = events.map((event, offset) => {
-            const id = event.id
-            const childIndex = Number(status.max) + offset + 1
-            const cause = { index, attempt }
-            insertEvent.run(
-              sessionId,
-              childIndex,
-              event.type,
-              JSON.stringify(event.payload) ?? 'null',
-              id,
-              now,
-              JSON.stringify(cause),
-              event.lane ?? null,
-              event.lane ?? null,
+            consumers,
+            cause: { consumer, lane, index, attempt },
+          })
+          const returned = JSON.stringify(ids)
+          if (cursor.kind === 'lane') {
+            finishLaneEvent.run(
+              attempt,
+              returned,
               sessionId,
-              event.lane ?? null,
-              clearIndex,
-              event.settled ? now : null,
+              consumer,
+              lane,
+              index,
             )
-            return toStored(
-              db
-                .prepare(
-                  'select * from a2_events where session_id = ? and idx = ?',
-                )
-                .get(sessionId, childIndex) as EventRow,
+          } else {
+            recordCompletion.run(
+              index,
+              attempt,
+              returned,
+              sessionId,
+              consumer,
+              cursor.cursor_key,
             )
-          })
+          }
+          advance(sessionId, cursor)
           return { outcome: 'completed', events: inserted }
         }),
       )
@@ -947,6 +1321,8 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
 
     async failAttempt({
       sessionId,
+      consumer,
+      lane,
       index,
       attempt,
       error,
@@ -958,30 +1334,34 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           if (index <= clearIndexOf(sessionId)) {
             return { outcome: 'superseded', failureCount: 0 }
           }
-          const current = db
-            .prepare('select * from a2_events where session_id = ? and idx = ?')
-            .get(sessionId, index) as EventRow | undefined
+          const current = cursorOf(sessionId, { consumer, lane, index })
           if (!current) {
-            throw new TypeError(
-              `no event at index ${index} in session '${sessionId}'`,
-            )
+            if (!selectEvent.get(sessionId, index)) {
+              throw new TypeError(
+                `no event at index ${index} in session '${sessionId}'`,
+              )
+            }
+            return { outcome: 'superseded', failureCount: 0 }
+          }
+          if (toNumber(current.head) !== index) {
+            return { outcome: 'superseded', failureCount: 0 }
           }
           const failureCount = Number(current.failure_count)
-          if (
-            current.processed_at !== null ||
-            Number(current.attempt_count) !== attempt
-          ) {
+          if (Number(current.attempt_count) !== attempt) {
             return { outcome: 'superseded', failureCount }
           }
-          if (current.failed_at !== null) {
-            return { outcome: 'dead_lettered', failureCount }
-          }
           if (
             current.claim_holder === null &&
             current.last_failed_attempt !== null &&
             Number(current.last_failed_attempt) === attempt
           ) {
-            return { outcome: 'failed', failureCount }
+            return {
+              outcome: current.failed_at === null ? 'failed' : 'dead_lettered',
+              failureCount,
+            }
+          }
+          if (current.failed_at !== null) {
+            return { outcome: 'dead_lettered', failureCount }
           }
           if (current.claim_holder === null) {
             return { outcome: 'superseded', failureCount }
@@ -991,7 +1371,7 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           const nextFailureCount = failureCount + 1
           const deadLettered = nextFailureCount >= maxFailures
           db.prepare(
-            `update a2_events set
+            `update a2_cursors set
                failure_count = ?,
                last_error = ?,
                last_failed_at = ?,
@@ -999,7 +1379,7 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                failed_at = ?,
                claim_holder = null,
                claim_expires_at = ?
-             where session_id = ? and idx = ?`,
+             where session_id = ? and consumer = ? and cursor_key = ?`,
           ).run(
             nextFailureCount,
             error,
@@ -1010,9 +1390,12 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
               ? null
               : now + retryAfterMs,
             sessionId,
-            index,
+            consumer,
+            current.cursor_key,
           )
-          if (deadLettered) releasePins(sessionId, index)
+          if (deadLettered) {
+            releasePins(sessionId, consumer, current.cursor_key, index)
+          }
           return {
             outcome: deadLettered ? 'dead_lettered' : 'failed',
             failureCount: nextFailureCount,
@@ -1025,58 +1408,58 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
       return wrap(() => {
         const rows = db
           .prepare(
-            `select * from a2_events
-              where session_id = ?
-                and processed_at is null
-                and failed_at is not null
-                and idx > coalesce(
+            `${HEAD_SELECT}
+              where cursor.session_id = ?
+                and cursor.failed_at is not null
+                and cursor.head > coalesce(
                   (select clear_index from a2_clears where session_id = ?), 0
                 )
-              order by idx`,
+              order by cursor.head, cursor.consumer`,
           )
-          .all(sessionId, sessionId) as unknown as EventRow[]
-        return rows.map(toStored)
+          .all(sessionId, sessionId) as unknown as HeadRow[]
+        return rows.map(toHead)
       })
     },
 
-    async redrive({ sessionId, index, action }) {
+    async redrive({ sessionId, consumer, index, action, consumers }) {
       return wrap(() =>
         tx(() => {
           const clearIndex = clearIndexOf(sessionId)
-          const row =
+          const cursor =
             index > clearIndex
               ? (db
                   .prepare(
-                    'select lane, processed_at, failed_at from a2_events where session_id = ? and idx = ?',
+                    `select * from a2_cursors
+                      where session_id = ? and consumer = ? and head = ?
+                        and failed_at is not null`,
                   )
-                  .get(sessionId, index) as
-                  | Pick<EventRow, 'lane' | 'processed_at' | 'failed_at'>
-                  | undefined)
+                  .get(sessionId, consumer, index) as CursorRow | undefined)
               : undefined
-          const redriven =
-            row !== undefined &&
-            row.processed_at === null &&
-            row.failed_at !== null
-          if (redriven && action === 'skip') {
-            db.prepare(
-              `update a2_events set processed_at = ?, lane_ready = 0
-                where session_id = ? and idx = ?`,
-            ).run(clock.now().getTime(), sessionId, index)
-            if (row.lane !== null) {
-              promoteLaneHead.run(sessionId, sessionId, row.lane, clearIndex)
+          if (cursor) {
+            refreshLogTypes(sessionId, consumers)
+            if (action === 'skip') {
+              if (cursor.kind === 'lane') {
+                finishLaneEvent.run(
+                  null,
+                  null,
+                  sessionId,
+                  consumer,
+                  cursor.lane,
+                  index,
+                )
+              }
+              advance(sessionId, cursor)
+            } else {
+              db.prepare(
+                `update a2_cursors set failed_at = null, failure_count = 0
+                  where session_id = ? and consumer = ? and cursor_key = ?`,
+              ).run(sessionId, consumer, cursor.cursor_key)
             }
-          } else if (redriven) {
-            db.prepare(
-              `update a2_events set failed_at = null, failure_count = 0
-                where session_id = ? and idx = ?`,
-            ).run(sessionId, index)
           }
-          const status = appendStatus.get(
-            sessionId,
-            sessionId,
-            clearIndex,
-          ) as AppendStatusRow
-          return { redriven, hasPending: Number(status.has_pending) === 1 }
+          return {
+            redriven: cursor !== undefined,
+            hasPending: hasPending(sessionId, clearIndex, consumers),
+          }
         }),
       )
     },
@@ -1116,21 +1499,15 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                     (select state from snapshot) as snapshot_state,
                     null as session_id, null as idx, null as event_type,
                     null as payload, null as event_id, null as created_at,
-                    null as cause, null as lane, null as lane_ready,
-                    null as processed_at,
-                    null as processed_by_attempt, null as returned_event_ids,
-                    null as first_claimed_at,
-                    null as last_claimed_at, null as attempt_count,
-                    null as failure_count, null as last_failed_at,
-                    null as last_failed_attempt, null as last_error,
-                    null as failed_at, null as claim_holder,
-                    null as claim_expires_at
+                    null as cause
              union all
              select 1 as row_order, 'event' as row_kind,
                     null as clear_index,
                     (select up_to_index from head) as head_index,
                     null as snapshot_index, null as snapshot_state,
-                    event.*
+                    event.session_id, event.idx, event.event_type,
+                    event.payload, event.event_id, event.created_at,
+                    event.cause
              from a2_events as event
              where event.session_id = ?
                and event.idx > max(
@@ -1182,19 +1559,19 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
     async putSnapshots(sessionId, reducerName, writes) {
       await wrap(() =>
         tx(() => {
-          const selectHead = db.prepare(
+          const selectSnapshotHead = db.prepare(
             `select up_to_index, state, updated_at from a2_snapshots
               where session_id = ? and reducer_name = ?`,
           )
           const unfinished = db.prepare(
-            `select 1 from a2_events
-              where session_id = ? and idx = ? and idx > ?
-                and processed_at is null and failed_at is null`,
+            `select 1 from a2_cursors
+              where session_id = ? and consumer = ? and cursor_key = ?
+                and head = ? and head > ? and failed_at is null`,
           )
           const insertPin = db.prepare(
             `insert or ignore into a2_snapshot_pins
-               (session_id, event_index, reducer_name, up_to_index)
-             values (?, ?, ?, ?)`,
+               (session_id, consumer, cursor_key, event_index, reducer_name, up_to_index)
+             values (?, ?, ?, ?, ?, ?)`,
           )
           const hasPin = db.prepare(
             `select 1 from a2_snapshot_pins
@@ -1226,12 +1603,28 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
           for (const write of writes.toSorted((a, b) => a.index - b.index)) {
             // A fold from before the latest clear describes a lifetime that is gone.
             if (write.index < clearIndex) continue
-            for (const eventIndex of write.pinEventIndexes ?? []) {
-              if (unfinished.get(sessionId, eventIndex, clearIndex)) {
-                insertPin.run(sessionId, eventIndex, reducerName, write.index)
+            for (const pin of write.pins ?? []) {
+              const cursorKey = cursorKeyOf(pin.lane, pin.index)
+              if (
+                unfinished.get(
+                  sessionId,
+                  pin.consumer,
+                  cursorKey,
+                  pin.index,
+                  clearIndex,
+                )
+              ) {
+                insertPin.run(
+                  sessionId,
+                  pin.consumer,
+                  cursorKey,
+                  pin.index,
+                  reducerName,
+                  write.index,
+                )
               }
             }
-            const head = selectHead.get(sessionId, reducerName) as
+            const head = selectSnapshotHead.get(sessionId, reducerName) as
               SnapshotHeadRow | undefined
             const now = clock.now().getTime()
             if (!head || write.index >= Number(head.up_to_index)) {
@@ -1283,23 +1676,22 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             const atMs = meta.at.getTime()
             // Expiry anchors on the storage clock — the sender's `at`
             // orders writes but never anchors their lifetime.
-            const expiresAtMs = clock.now().getTime() + meta.ttlMs
+            const nowMs = clock.now().getTime()
+            const expiresAtMs = nowMs + meta.ttlMs
             for (const [field, value] of entries) {
-              // Field-wise LWW: a stored row with a strictly newer `at`
-              // survives; ties go to the incoming write (memory parity).
-              if (value === null) {
-                deletePresence.run(ns, participant, field, atMs)
-              } else {
-                upsertPresence.run(
-                  ns,
-                  participant,
-                  field,
-                  JSON.stringify(value) ?? 'null',
-                  meta.seen,
-                  atMs,
-                  expiresAtMs,
-                )
-              }
+              // Field-wise LWW against values and tombstones alike: an
+              // unexpired stored row with a strictly newer `at` survives;
+              // ties go to the incoming write (memory parity).
+              upsertPresence.run(
+                ns,
+                participant,
+                field,
+                JSON.stringify(value) ?? 'null',
+                meta.seen,
+                atMs,
+                expiresAtMs,
+                nowMs,
+              )
             }
           }),
         )
@@ -1349,15 +1741,7 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
         tx(() => {
           const clearIndex = clearIndexOf(sessionId)
           if (cause) assertCurrentCause({ sessionId, cause, clearIndex })
-          const head = Number(
-            (
-              appendStatus.get(
-                sessionId,
-                sessionId,
-                clearIndex,
-              ) as AppendStatusRow
-            ).max,
-          )
+          const head = headOf(sessionId)
           if (ifLastIndex !== undefined && clearIndex === ifLastIndex + 1) {
             return { cleared: true, index: head, clearIndex }
           }
@@ -1368,26 +1752,32 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             return { cleared: true, index: head, clearIndex }
           }
           const marker = head + 1
-          const now = clock.now().getTime()
           insertEvent.run(
             sessionId,
             marker,
             CLEAR_EVENT_TYPE,
             'null',
             generateId(),
-            now,
-            null,
-            null,
+            clock.now().getTime(),
             null,
-            sessionId,
-            null,
-            clearIndex,
-            now,
           )
           db.prepare(
             `insert into a2_clears (session_id, clear_index) values (?, ?)
              on conflict (session_id) do update set clear_index = excluded.clear_index`,
           ).run(sessionId, marker)
+          // One row per log consumer: they count from the marker. Lane and
+          // concurrent cursors at or below it are superseded by the marker
+          // alone, and reclaim deletes them.
+          db.prepare(
+            `update a2_cursors
+                set position = ?, head = null, ${FRESH_DISPATCH},
+                    completed_idx = null, completed_attempt = null,
+                    returned_event_ids = null
+              where session_id = ? and kind = 'log'`,
+          ).run(marker, sessionId)
+          db.prepare(
+            'delete from a2_snapshot_pins where session_id = ? and event_index < ?',
+          ).run(sessionId, marker)
           return { cleared: true, index: marker, clearIndex: marker }
         }),
       )
@@ -1420,7 +1810,11 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
                 .run(sessionId, through).changes,
             )
             db.prepare(
-              'delete from a2_snapshot_pins where session_id = ? and event_index <= ?',
+              'delete from a2_lane_events where session_id = ? and idx <= ?',
+            ).run(sessionId, through)
+            db.prepare(
+              `delete from a2_cursors
+                where session_id = ? and kind = 'event' and position < ?`,
             ).run(sessionId, through)
           }
           const done =
@@ -1431,6 +1825,11 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
               .get(sessionId, clearIndex) === undefined
           // Writes serialize with the clear, so none lands below the marker later.
           if (done) {
+            db.prepare(
+              `delete from a2_cursors
+                where session_id = ? and kind != 'log'
+                  and (head is null or head <= ?) and position <= ?`,
+            ).run(sessionId, clearIndex, clearIndex)
             for (const table of [
               'a2_snapshot_pins',
               'a2_snapshot_history',