experimental-a2 0.6.0 → 0.7.0

package/src/store-postgres.ts

@@ -1086,106 +1086,6 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
       },
     },
 
-    inspect: {
-      async listSessions(inspectionOptions) {
-        return wrap(async () => {
-          const c = await client()
-          const conditions = ['left(session_id, length($1)) = $1']
-          const params: unknown[] = [inspectionOptions.prefix]
-          if (inspectionOptions.cursor !== undefined) {
-            params.push(inspectionOptions.cursor)
-            conditions.push(`session_id > $${params.length}`)
-          }
-          params.push(inspectionOptions.limit + 1)
-          const { rows } = await c.query(
-            `select
-               session_id,
-               count(*) as event_count,
-               count(*) filter (where processed_at is null and failed_at is null) as pending_count,
-               count(*) filter (where failed_at is not null) as failed_count,
-               sum(attempt_count) as attempt_count,
-               sum(failure_count) as failure_count,
-               min(created_at) as first_event_at,
-               max(greatest(
-                 created_at,
-                 coalesce(first_claimed_at, 0),
-                 coalesce(last_claimed_at, 0),
-                 coalesce(last_failed_at, 0),
-                 coalesce(processed_at, 0),
-                 coalesce(failed_at, 0)
-               )) as updated_at
-             from a2_events
-             where ${conditions.join(' and ')}
-             group by session_id
-             order by session_id
-             limit $${params.length}`,
-            params,
-          )
-          const hasMore = rows.length > inspectionOptions.limit
-          const visible = rows.slice(0, inspectionOptions.limit)
-          return {
-            sessions: visible.map((row) => ({
-              sessionId: row['session_id'] as string,
-              eventCount: asNumber(row['event_count']),
-              pendingCount: asNumber(row['pending_count']),
-              failedCount: asNumber(row['failed_count']),
-              attemptCount: asNumber(row['attempt_count']),
-              failureCount: asNumber(row['failure_count']),
-              firstEventAt: new Date(asNumber(row['first_event_at'])),
-              updatedAt: new Date(asNumber(row['updated_at'])),
-            })),
-            cursor: hasMore
-              ? ((visible.at(-1)?.['session_id'] as string | undefined) ?? null)
-              : null,
-          }
-        })
-      },
-      async readEvents(sessionId, pageOptions) {
-        return wrap(async () => {
-          const c = await client()
-          const currentFrontier = asNumber(
-            (
-              await c.query(
-                'select coalesce(max(idx), 0) as frontier from a2_events where session_id = $1',
-                [sessionId],
-              )
-            ).rows[0]?.['frontier'] ?? 0,
-          )
-          const throughIndex = Math.min(
-            pageOptions.throughIndex ?? currentFrontier,
-            currentFrontier,
-          )
-          const { rows } = await c.query(
-            `select * from a2_events
-              where session_id = $1 and idx > $2 and idx <= $3
-              order by idx limit $4`,
-            [
-              sessionId,
-              pageOptions.afterIndex,
-              throughIndex,
-              pageOptions.limit,
-            ],
-          )
-          return { events: rows.map(toStored), throughIndex }
-        })
-      },
-      async listSnapshots(sessionId) {
-        return wrap(async () => {
-          const c = await client()
-          const { rows } = await c.query(
-            `select reducer_name, up_to_index, updated_at
-             from a2_snapshots where session_id = $1 order by reducer_name`,
-            [sessionId],
-          )
-          return rows.map((row) => ({
-            reducerName: row['reducer_name'] as string,
-            index: asNumber(row['up_to_index']),
-            updatedAt: new Date(asNumber(row['updated_at'])),
-          }))
-        })
-      },
-    },
-
     stream(sessionId, opts) {
       const readAfter = (afterIndex: number): Promise<StoredEvent[]> =>
         wrap(async () => {

package/src/store-redis-core.ts

@@ -23,7 +23,6 @@ import { nullProtoRecord } from './internal.ts'
 import { decodeReturnedEventIds } from './store-codec.ts'
 import type {
   A2Store,
-  A2StoreInspection,
   Clock,
   CompleteAttemptResult,
   Event,
@@ -56,11 +55,7 @@ export type RedisStoreCoreOptions = {
   notify?: (sessionId: string, count: number) => void
 }
 
-export type RedisStoreCore = Omit<
-  A2Store,
-  'stream' | 'inspect' | 'presence'
-> & {
-  inspect: A2StoreInspection
+export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /**
    * The storage half of the presence capability, shared by both
    * transports. `set` returns the applied patch — null when every
@@ -98,8 +93,8 @@ const READ_PAGE_SIZE = 256
 // ── Lua scripts (each runs atomically) ───────────────────────────────
 
 /**
- * KEYS: store stream, counter, global id hash, session index, metadata,
- * pending, ready, watched.
+ * KEYS: store stream, counter, global id hash, metadata, pending, ready,
+ * watched.
  * ARGV: sessionId, nowMs, n, then per event:
  * id, type, payloadJson, causeJson, lane, settled.
  * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending, watched] |
@@ -111,24 +106,24 @@ local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
 local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[6], idx, field)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local n = tonumber(ARGV[3])
 local base = tonumber(redis.call('GET', KEYS[2]) or '0')
-local has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+local has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 if n == 0 then return { 'empty', has_pending } end
 local dups = {}
 for i = 1, n do
@@ -155,9 +150,9 @@ for i = 1, n do
       return { 'no_parent', tostring(parsed.index) }
     end
     local field = tostring(pidx)
-    local dispatches = tonumber(redis.call('HGET', KEYS[5], field .. ':d') or '0')
+    local dispatches = tonumber(redis.call('HGET', KEYS[4], field .. ':d') or '0')
     if dispatches ~= tonumber(parsed.attempt) or
-       redis.call('HEXISTS', KEYS[5], field .. ':f') == 1 then
+       redis.call('HEXISTS', KEYS[4], field .. ':f') == 1 then
       return { 'superseded', field }
     end
   end
@@ -174,18 +169,17 @@ for i = 1, n do
     'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
     'cause', cause, 'lane', lane)
   redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[5], tostring(idx) .. ':l', lane)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(base + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
-has_pending = redis.call('ZCARD', KEYS[6]) > 0 and '1' or '0'
+has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
 return { 'ok', tostring(base + 1), has_pending,
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  tostring(redis.call('EXISTS', KEYS[7])) }
 `
 
 /** KEYS: counter, meta, pending, ready. ARGV: idx, attempt, error, maxFailures, nowMs. */
@@ -336,7 +330,7 @@ return result
 `
 
 /**
- * KEYS: store, counter, ids, session index, meta, pending, ready, watched.
+ * KEYS: store, counter, ids, meta, pending, ready, watched.
  * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
  * id, type, payloadJson, lane, settled.
  */
@@ -345,52 +339,52 @@ local function lane_field(lane, suffix)
   return '__lane:' .. tostring(string.len(lane)) .. ':' .. lane .. ':' .. suffix
 end
 local function settle(field)
+  redis.call('ZREM', KEYS[5], field)
   redis.call('ZREM', KEYS[6], field)
-  redis.call('ZREM', KEYS[7], field)
-  local lane = redis.call('HGET', KEYS[5], field .. ':l') or ''
+  local lane = redis.call('HGET', KEYS[4], field .. ':l') or ''
   if lane == '' then return end
   local head_key = lane_field(lane, 'head')
-  if redis.call('HGET', KEYS[5], head_key) ~= field then return end
-  local next_field = redis.call('HGET', KEYS[5], field .. ':next')
-  while next_field and redis.call('HEXISTS', KEYS[5], next_field .. ':p') == 1 do
-    next_field = redis.call('HGET', KEYS[5], next_field .. ':next')
+  if redis.call('HGET', KEYS[4], head_key) ~= field then return end
+  local next_field = redis.call('HGET', KEYS[4], field .. ':next')
+  while next_field and redis.call('HEXISTS', KEYS[4], next_field .. ':p') == 1 do
+    next_field = redis.call('HGET', KEYS[4], next_field .. ':next')
   end
   if next_field then
-    redis.call('HSET', KEYS[5], head_key, next_field)
-    if redis.call('HEXISTS', KEYS[5], next_field .. ':f') == 0 then
-      redis.call('ZADD', KEYS[7], tonumber(next_field), next_field)
+    redis.call('HSET', KEYS[4], head_key, next_field)
+    if redis.call('HEXISTS', KEYS[4], next_field .. ':f') == 0 then
+      redis.call('ZADD', KEYS[6], tonumber(next_field), next_field)
     end
   else
-    redis.call('HDEL', KEYS[5], head_key, lane_field(lane, 'tail'))
+    redis.call('HDEL', KEYS[4], head_key, lane_field(lane, 'tail'))
   end
 end
 local function enqueue(field, idx, lane)
-  redis.call('ZADD', KEYS[6], idx, field)
+  redis.call('ZADD', KEYS[5], idx, field)
   if lane == '' then
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('ZADD', KEYS[6], idx, field)
     return
   end
   local tail_key = lane_field(lane, 'tail')
-  local tail = redis.call('HGET', KEYS[5], tail_key)
+  local tail = redis.call('HGET', KEYS[4], tail_key)
   if tail then
-    redis.call('HSET', KEYS[5], tail .. ':next', field)
+    redis.call('HSET', KEYS[4], tail .. ':next', field)
   else
-    redis.call('HSET', KEYS[5], lane_field(lane, 'head'), field)
-    redis.call('ZADD', KEYS[7], idx, field)
+    redis.call('HSET', KEYS[4], lane_field(lane, 'head'), field)
+    redis.call('ZADD', KEYS[6], idx, field)
   end
-  redis.call('HSET', KEYS[5], tail_key, field)
+  redis.call('HSET', KEYS[4], tail_key, field)
 end
 local parent = ARGV[3]
 local attempt = tonumber(ARGV[4])
 local n = tonumber(ARGV[5])
 local total = tonumber(redis.call('GET', KEYS[2]) or '0')
 if tonumber(parent) < 1 or tonumber(parent) > total then return { 'missing' } end
-local dispatches = tonumber(redis.call('HGET', KEYS[5], parent .. ':d') or '0')
-local processed = redis.call('HGET', KEYS[5], parent .. ':p')
-local processed_attempt = tonumber(redis.call('HGET', KEYS[5], parent .. ':pa') or '0')
+local dispatches = tonumber(redis.call('HGET', KEYS[4], parent .. ':d') or '0')
+local processed = redis.call('HGET', KEYS[4], parent .. ':p')
+local processed_attempt = tonumber(redis.call('HGET', KEYS[4], parent .. ':pa') or '0')
 if processed then
   if processed_attempt ~= attempt then return { 'superseded' } end
-  local raw_recorded_ids = redis.call('HGET', KEYS[5], parent .. ':ri')
+  local raw_recorded_ids = redis.call('HGET', KEYS[4], parent .. ':ri')
   if not raw_recorded_ids then return { 'partial' } end
   local recorded_ids = cjson.decode(raw_recorded_ids)
   if #recorded_ids ~= n then return { 'partial' } end
@@ -420,9 +414,9 @@ if processed then
   return result
 end
 if dispatches ~= attempt then return { 'superseded' } end
-if redis.call('HEXISTS', KEYS[5], parent .. ':ch') == 0 or
-   redis.call('HEXISTS', KEYS[5], parent .. ':f') == 1 or
-   tonumber(redis.call('HGET', KEYS[5], parent .. ':lfa') or '0') == attempt then
+if redis.call('HEXISTS', KEYS[4], parent .. ':ch') == 0 or
+   redis.call('HEXISTS', KEYS[4], parent .. ':f') == 1 or
+   tonumber(redis.call('HGET', KEYS[4], parent .. ':lfa') or '0') == attempt then
   return { 'superseded' }
 end
 for i = 1, n do
@@ -433,11 +427,11 @@ local returned_ids = {}
 for i = 1, n do returned_ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
 local returned_json = '[]'
 if n > 0 then returned_json = cjson.encode(returned_ids) end
-redis.call('HSET', KEYS[5],
+redis.call('HSET', KEYS[4],
   parent .. ':p', ARGV[2],
   parent .. ':pa', ARGV[4],
   parent .. ':ri', returned_json)
-redis.call('HDEL', KEYS[5], parent .. ':ch', parent .. ':ce')
+redis.call('HDEL', KEYS[4], parent .. ':ch', parent .. ':ce')
 settle(parent)
 local cause = cjson.encode({ index = tonumber(parent), attempt = attempt })
 for i = 1, n do
@@ -451,17 +445,16 @@ for i = 1, n do
     'id', id, 'type', typ, 'payload', payload, 'created_at', ARGV[2],
     'cause', cause, 'lane', lane)
   redis.call('HSET', KEYS[3], id, cjson.encode({ ARGV[1], idx }))
-  redis.call('HSET', KEYS[5], tostring(idx) .. ':l', lane)
+  redis.call('HSET', KEYS[4], tostring(idx) .. ':l', lane)
   if settled == '1' then
-    redis.call('HSET', KEYS[5], tostring(idx) .. ':p', ARGV[2])
+    redis.call('HSET', KEYS[4], tostring(idx) .. ':p', ARGV[2])
   else
     enqueue(tostring(idx), idx, lane)
   end
 end
 redis.call('SET', KEYS[2], tostring(total + n))
-redis.call('ZADD', KEYS[4], 0, ARGV[1])
 return { 'ok', tostring(total + 1),
-  tostring(redis.call('EXISTS', KEYS[8])) }
+  tostring(redis.call('EXISTS', KEYS[7])) }
 `
 
 /** KEYS: snapshot. ARGV: upToIndex, json. Guarded: never move backward. */
@@ -579,14 +572,6 @@ const toEvent = (sessionId: string, entry: StreamEntry): Event => {
 
 const json = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
-const escapeGlob = (value: string): string =>
-  value
-    .replaceAll('\\', '\\\\')
-    .replaceAll('*', '\\*')
-    .replaceAll('?', '\\?')
-    .replaceAll('[', '\\[')
-    .replaceAll(']', '\\]')
-
 const toCause = (raw: string | undefined): EventCause | null => {
   if (raw === '' || raw === undefined) return null
   const value = JSON.parse(raw) as {
@@ -699,7 +684,6 @@ export function createRedisStoreCore(
   const watchedKey = (s: string): string => `${prefix}:${s}:watched`
   const presenceKey = (s: string): string => `${prefix}:${s}:presence`
   const idsKey = `${prefix}:ids`
-  const sessionsKey = `${prefix}:sessions`
 
   const evalScript = (
     script: string,
@@ -924,7 +908,6 @@ export function createRedisStoreCore(
             storeKey(sessionId),
             countKey(sessionId),
             idsKey,
-            sessionsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
@@ -1081,7 +1064,6 @@ export function createRedisStoreCore(
             storeKey(sessionId),
             countKey(sessionId),
             idsKey,
-            sessionsKey,
             metaKey(sessionId),
             pendingKey(sessionId),
             readyKey(sessionId),
@@ -1325,152 +1307,6 @@ export function createRedisStoreCore(
       },
     },
 
-    inspect: {
-      async listSessions(inspectionOptions) {
-        return wrap(async () => {
-          const minimum =
-            inspectionOptions.cursor === undefined
-              ? `[${inspectionOptions.prefix}`
-              : `(${inspectionOptions.cursor}`
-          const candidates = (await call(
-            'ZRANGEBYLEX',
-            sessionsKey,
-            minimum,
-            '+',
-            'LIMIT',
-            0,
-            inspectionOptions.limit + 1,
-          )) as string[]
-          const sessionIds = candidates
-            .filter((id) => id.startsWith(inspectionOptions.prefix))
-            .slice(0, inspectionOptions.limit)
-
-          const sessions = await Promise.all(
-            sessionIds.map(async (sessionId) => {
-              const rows = await readRange(sessionId, 0)
-              const first = rows[0]!
-              let updatedAt = first.createdAt
-              let pendingCount = 0
-              let failedCount = 0
-              let attemptCount = 0
-              let failureCount = 0
-              for (const row of rows) {
-                attemptCount += row.attemptCount
-                failureCount += row.failureCount
-                if (row.processedAt === null && row.failedAt === null) {
-                  pendingCount += 1
-                }
-                if (row.failedAt !== null) failedCount += 1
-                for (const timestamp of [
-                  row.createdAt,
-                  row.firstClaimedAt,
-                  row.lastClaimedAt,
-                  row.lastFailedAt,
-                  row.processedAt,
-                  row.failedAt,
-                ]) {
-                  if (timestamp && timestamp > updatedAt) updatedAt = timestamp
-                }
-              }
-              return {
-                sessionId,
-                eventCount: rows.length,
-                pendingCount,
-                failedCount,
-                attemptCount,
-                failureCount,
-                firstEventAt: first.createdAt,
-                updatedAt,
-              }
-            }),
-          )
-          return {
-            sessions: sessions.toSorted((a, b) =>
-              a.sessionId.localeCompare(b.sessionId),
-            ),
-            cursor:
-              candidates.length > inspectionOptions.limit &&
-              candidates[inspectionOptions.limit]?.startsWith(
-                inspectionOptions.prefix,
-              )
-                ? (sessionIds.at(-1) ?? null)
-                : null,
-          }
-        })
-      },
-      async readEvents(sessionId, pageOptions) {
-        return wrap(async () => {
-          const currentFrontier = await readFrontier(sessionId)
-          const throughIndex = Math.min(
-            pageOptions.throughIndex ?? currentFrontier,
-            currentFrontier,
-          )
-          const events = await readRangePage(
-            sessionId,
-            pageOptions.afterIndex,
-            throughIndex,
-            pageOptions.limit,
-          )
-          if (throughIndex > pageOptions.afterIndex && events.length === 0) {
-            throw new A2Error(
-              'STORE_UNAVAILABLE',
-              `redis event range for session '${sessionId}' ended before index ${throughIndex}`,
-            )
-          }
-          for (let position = 0; position < events.length; position += 1) {
-            if (
-              events[position]!.index !==
-              pageOptions.afterIndex + position + 1
-            ) {
-              throw new A2Error(
-                'STORE_UNAVAILABLE',
-                `redis event range for session '${sessionId}' is not contiguous`,
-              )
-            }
-          }
-          return { events, throughIndex }
-        })
-      },
-      async listSnapshots(sessionId) {
-        return wrap(async () => {
-          const start = `${prefix}:${sessionId}:snap:`
-          let cursor = '0'
-          const keys: string[] = []
-          do {
-            // oxlint-disable-next-line no-await-in-loop -- each SCAN cursor comes from the prior reply
-            const reply = (await call(
-              'SCAN',
-              cursor,
-              'MATCH',
-              `${escapeGlob(start)}*`,
-              'COUNT',
-              100,
-            )) as [string, string[]]
-            cursor = reply[0]
-            keys.push(...reply[1].filter((key) => key.startsWith(start)))
-          } while (cursor !== '0')
-          const snapshots = await Promise.all(
-            keys.map(async (key) => {
-              const raw = (await call('GET', key)) as string | null
-              if (raw === null) return null
-              const parsed = JSON.parse(raw) as {
-                index: number
-                updatedAt?: number
-              }
-              return {
-                reducerName: key.slice(start.length),
-                index: parsed.index,
-                updatedAt: new Date(parsed.updatedAt ?? 0),
-              }
-            }),
-          )
-          return snapshots
-            .filter((snapshot) => snapshot !== null)
-            .toSorted((a, b) => a.reducerName.localeCompare(b.reducerName))
-        })
-      },
-    },
-
     async readRange(sessionId, afterIndex, throughIndex) {
       return wrap(() => readRange(sessionId, afterIndex, throughIndex))
     },

package/src/store-redis-http.ts

@@ -102,7 +102,6 @@ export function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore {
       },
       read: core.presence.read,
     },
-    inspect: core.inspect,
 
     stream(sessionId, opts) {
       return pollingStream(

package/src/store-redis.ts

@@ -292,7 +292,6 @@ export function redis(options: RedisStoreOptions = {}): RedisStore {
     failAttempt: core.failAttempt,
     readState: core.readState,
     putSnapshot: core.putSnapshot,
-    inspect: core.inspect,
 
     presence: {
       async set(ns, participant, values, meta) {

package/src/store-sqlite.ts

@@ -231,23 +231,6 @@ type EventRow = {
   claim_expires_at: number | bigint | null
 }
 
-type SessionSummaryRow = {
-  session_id: string
-  event_count: number | bigint
-  pending_count: number | bigint
-  failed_count: number | bigint
-  attempt_count: number | bigint
-  failure_count: number | bigint
-  first_event_at: number | bigint
-  updated_at: number | bigint
-}
-
-type SnapshotRow = {
-  reducer_name: string
-  up_to_index: number | bigint
-  updated_at: number | bigint
-}
-
 type PresenceDbRow = {
   participant: string
   field: string
@@ -983,108 +966,6 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
       },
     },
 
-    inspect: {
-      async listSessions(inspectionOptions) {
-        return wrap(() => {
-          const conditions = ['substr(session_id, 1, ?) = ?']
-          const params: (string | number)[] = [
-            inspectionOptions.prefix.length,
-            inspectionOptions.prefix,
-          ]
-          if (inspectionOptions.cursor !== undefined) {
-            conditions.push('session_id > ?')
-            params.push(inspectionOptions.cursor)
-          }
-          params.push(inspectionOptions.limit + 1)
-          const rows = db
-            .prepare(
-              `select
-                 session_id,
-                 count(*) as event_count,
-                 sum(case when processed_at is null and failed_at is null then 1 else 0 end) as pending_count,
-                 sum(case when failed_at is not null then 1 else 0 end) as failed_count,
-                 sum(attempt_count) as attempt_count,
-                 sum(failure_count) as failure_count,
-                 min(created_at) as first_event_at,
-                 max(max(
-                   created_at,
-                   coalesce(first_claimed_at, 0),
-                   coalesce(last_claimed_at, 0),
-                   coalesce(last_failed_at, 0),
-                   coalesce(processed_at, 0),
-                   coalesce(failed_at, 0)
-                 )) as updated_at
-               from a2_events
-               where ${conditions.join(' and ')}
-               group by session_id
-               order by session_id
-               limit ?`,
-            )
-            .all(...params) as unknown as SessionSummaryRow[]
-          const hasMore = rows.length > inspectionOptions.limit
-          const visible = rows.slice(0, inspectionOptions.limit)
-          return {
-            sessions: visible.map((row) => ({
-              sessionId: row.session_id,
-              eventCount: Number(row.event_count),
-              pendingCount: Number(row.pending_count),
-              failedCount: Number(row.failed_count),
-              attemptCount: Number(row.attempt_count),
-              failureCount: Number(row.failure_count),
-              firstEventAt: new Date(Number(row.first_event_at)),
-              updatedAt: new Date(Number(row.updated_at)),
-            })),
-            cursor: hasMore ? (visible.at(-1)?.session_id ?? null) : null,
-          }
-        })
-      },
-      async readEvents(sessionId, pageOptions) {
-        return wrap(() => {
-          const currentFrontier = Number(
-            (
-              db
-                .prepare(
-                  'select coalesce(max(idx), 0) as frontier from a2_events where session_id = ?',
-                )
-                .get(sessionId) as { frontier: number }
-            ).frontier,
-          )
-          const throughIndex = Math.min(
-            pageOptions.throughIndex ?? currentFrontier,
-            currentFrontier,
-          )
-          const rows = db
-            .prepare(
-              `select * from a2_events
-                where session_id = ? and idx > ? and idx <= ?
-                order by idx limit ?`,
-            )
-            .all(
-              sessionId,
-              pageOptions.afterIndex,
-              throughIndex,
-              pageOptions.limit,
-            ) as unknown as EventRow[]
-          return { events: rows.map(toStored), throughIndex }
-        })
-      },
-      async listSnapshots(sessionId) {
-        return wrap(() => {
-          const rows = db
-            .prepare(
-              `select reducer_name, up_to_index, updated_at
-               from a2_snapshots where session_id = ? order by reducer_name`,
-            )
-            .all(sessionId) as unknown as SnapshotRow[]
-          return rows.map((row) => ({
-            reducerName: row.reducer_name,
-            index: Number(row.up_to_index),
-            updatedAt: new Date(Number(row.updated_at)),
-          }))
-        })
-      },
-    },
-
     stream(sessionId, opts) {
       const readAfter = (afterIndex: number): StoredEvent[] =>
         wrap(() => {