experimental-a2 0.6.0 → 0.7.0

package/src/devtools.ts

@@ -1,716 +0,0 @@
-/**
- * Shared wire protocol for A2's read-only devtools surfaces.
- *
- * The HTTP dashboard and non-interactive consumers use the same response
- * shapes. Captures are newline-delimited JSON so they can be streamed,
- * inspected with ordinary command-line tools, and verified without access to
- * an A2 server.
- */
-
-export const DEVTOOLS_PROTOCOL_VERSION = 1 as const
-export const DEVTOOLS_CAPTURE_VERSION = 1 as const
-export const DEVTOOLS_CAPTURE_MEDIA_TYPE = 'application/x-ndjson' as const
-export const DEVTOOLS_SESSION_PAGE_LIMIT = 250 as const
-export const DEVTOOLS_SESSION_PAGE_MAX_LIMIT = 1_000 as const
-
-export type DevtoolsWireSessionSummary = {
-  sessionId: string
-  eventCount: number
-  pendingCount: number
-  failedCount: number
-  attemptCount: number
-  failureCount: number
-  firstEventAt: string
-  updatedAt: string
-}
-
-export type DevtoolsWireEvent = {
-  id: string
-  type: string
-  payload: unknown
-  index: number
-  sessionId: string
-  createdAt: string
-  cause: { index: number; attempt: number; batchSize?: number } | null
-  lane: string | null
-  processedAt: string | null
-  processedByAttempt: number | null
-  returnedEventIds: string[] | null
-  firstClaimedAt: string | null
-  lastClaimedAt: string | null
-  attemptCount: number
-  claimHolder: string | null
-  claimExpiresAt: string | null
-  failureCount: number
-  lastFailedAt: string | null
-  lastFailedAttempt: number | null
-  lastError: string | null
-  failedAt: string | null
-}
-
-export type DevtoolsWireSnapshot = {
-  reducerName: string
-  index: number
-  updatedAt: string | null
-}
-
-export type DevtoolsContractsResponse = {
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  contracts: Array<{ name: string }>
-}
-
-export type DevtoolsSessionsResponse = {
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  cursor: string | null
-  sessions: DevtoolsWireSessionSummary[]
-}
-
-export type DevtoolsSessionDetail = {
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  contract: string
-  sessionId: string
-  /** An invalidation token, not a content-integrity digest. */
-  revision: string
-  events: DevtoolsWireEvent[]
-  snapshots: DevtoolsWireSnapshot[]
-}
-
-export type DevtoolsSessionPage = {
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  contract: string
-  sessionId: string
-  /** Inclusive log frontier frozen by the first page. */
-  throughIndex: number
-  /** Opaque continuation token; null means this frozen read is complete. */
-  cursor: string | null
-  events: DevtoolsWireEvent[]
-  /** Snapshot metadata is present only on the first page. */
-  snapshots: DevtoolsWireSnapshot[]
-}
-
-export type DevtoolsCapabilities = {
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  resources: Array<'contracts' | 'sessions' | 'session' | 'watch' | 'export'>
-  sessionPagination: {
-    defaultLimit: typeof DEVTOOLS_SESSION_PAGE_LIMIT
-    maxLimit: typeof DEVTOOLS_SESSION_PAGE_MAX_LIMIT
-  }
-  capture: {
-    version: typeof DEVTOOLS_CAPTURE_VERSION
-    mediaType: typeof DEVTOOLS_CAPTURE_MEDIA_TYPE
-  }
-}
-
-export const DEVTOOLS_CAPABILITIES: DevtoolsCapabilities = {
-  protocolVersion: DEVTOOLS_PROTOCOL_VERSION,
-  resources: ['contracts', 'sessions', 'session', 'watch', 'export'],
-  sessionPagination: {
-    defaultLimit: DEVTOOLS_SESSION_PAGE_LIMIT,
-    maxLimit: DEVTOOLS_SESSION_PAGE_MAX_LIMIT,
-  },
-  capture: {
-    version: DEVTOOLS_CAPTURE_VERSION,
-    mediaType: DEVTOOLS_CAPTURE_MEDIA_TYPE,
-  },
-}
-
-export type DevtoolsCaptureManifest = {
-  kind: 'a2.capture'
-  captureVersion: typeof DEVTOOLS_CAPTURE_VERSION
-  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION
-  contract: string
-  sessionId: string
-  revision: string
-  capturedAt: string
-  fidelity: 'exact'
-}
-
-/** One exact durable event, with the record discriminator added. */
-export type DevtoolsCaptureEvent = DevtoolsWireEvent & { kind: 'event' }
-
-/** Snapshot metadata only. Cached reducer state is never exported. */
-export type DevtoolsCaptureSnapshot = DevtoolsWireSnapshot & {
-  kind: 'snapshot'
-}
-
-export type DevtoolsCaptureFooter = {
-  kind: 'end'
-  captureVersion: typeof DEVTOOLS_CAPTURE_VERSION
-  eventCount: number
-  snapshotCount: number
-  maxIndex: number | null
-  sha256: string
-}
-
-export type DevtoolsCaptureRecord =
-  | DevtoolsCaptureManifest
-  | DevtoolsCaptureEvent
-  | DevtoolsCaptureSnapshot
-  | DevtoolsCaptureFooter
-
-export type DevtoolsCapture = {
-  contract: string
-  sessionId: string
-  revision: string
-  capturedAt: string
-  manifest: DevtoolsCaptureManifest
-  events: DevtoolsCaptureEvent[]
-  snapshots: DevtoolsCaptureSnapshot[]
-  footer: DevtoolsCaptureFooter
-  records: DevtoolsCaptureRecord[]
-}
-
-const encoder = new TextEncoder()
-const decoder = new TextDecoder('utf-8', { fatal: true })
-
-const objectValue = (value: unknown): Record<string, unknown> | null =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null
-
-class DevtoolsCaptureError extends TypeError {}
-
-const captureError = (message: string): DevtoolsCaptureError =>
-  new DevtoolsCaptureError(`invalid A2 devtools capture: ${message}`)
-
-const sha256 = async (value: string): Promise<string> => {
-  const digest = await crypto.subtle.digest('SHA-256', encoder.encode(value))
-  return [...new Uint8Array(digest)]
-    .map((byte) => byte.toString(16).padStart(2, '0'))
-    .join('')
-}
-
-const timestampMs = (value: string | null): number | null =>
-  value === null ? null : new Date(value).getTime()
-
-/** Compute the server-compatible lifecycle invalidation token. */
-export const devtoolsSessionRevision = (detail: {
-  events: readonly DevtoolsWireEvent[]
-  snapshots: readonly DevtoolsWireSnapshot[]
-}): Promise<string> =>
-  sha256(
-    JSON.stringify({
-      events: detail.events.map((event) => [
-        event.id,
-        event.index,
-        event.cause?.index ?? null,
-        event.cause?.attempt ?? null,
-        timestampMs(event.processedAt),
-        event.processedByAttempt,
-        timestampMs(event.firstClaimedAt),
-        timestampMs(event.lastClaimedAt),
-        event.attemptCount,
-        event.failureCount,
-        timestampMs(event.lastFailedAt),
-        event.lastFailedAttempt,
-        event.lastError,
-        timestampMs(event.failedAt),
-      ]),
-      snapshots: detail.snapshots.map((snapshot) => [
-        snapshot.reducerName,
-        snapshot.index,
-        snapshot.updatedAt === null
-          ? 0
-          : new Date(snapshot.updatedAt).getTime(),
-      ]),
-    }),
-  )
-
-const encodeRecords = (records: readonly unknown[]): string =>
-  records.map((record) => JSON.stringify(record)).join('\n') + '\n'
-
-const asCapturedAt = (value: string | Date | undefined): string => {
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) {
-      throw new TypeError('capturedAt must be a canonical ISO date')
-    }
-    return value.toISOString()
-  }
-  if (value === undefined) return new Date().toISOString()
-  const parsed = new Date(value)
-  if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) {
-    throw new TypeError(
-      'capturedAt must be a canonical ISO date string or Date',
-    )
-  }
-  return value
-}
-
-export async function encodeDevtoolsCapture(
-  detail: DevtoolsSessionDetail,
-  options: { capturedAt?: string | Date } = {},
-): Promise<string> {
-  const manifest: DevtoolsCaptureManifest = {
-    kind: 'a2.capture',
-    captureVersion: DEVTOOLS_CAPTURE_VERSION,
-    protocolVersion: DEVTOOLS_PROTOCOL_VERSION,
-    contract: detail.contract,
-    sessionId: detail.sessionId,
-    revision: detail.revision,
-    capturedAt: asCapturedAt(options.capturedAt),
-    fidelity: 'exact',
-  }
-  const events = detail.events.map((event): DevtoolsCaptureEvent => ({
-    ...event,
-    kind: 'event',
-  }))
-  const snapshots = detail.snapshots.map(
-    (snapshot): DevtoolsCaptureSnapshot => ({
-      ...snapshot,
-      kind: 'snapshot',
-    }),
-  )
-  const signedRecords = [manifest, ...events, ...snapshots]
-  validateCanonicalJsonValue(signedRecords, 'capture')
-  const signed = encodeRecords(signedRecords)
-  const footer: DevtoolsCaptureFooter = {
-    kind: 'end',
-    captureVersion: DEVTOOLS_CAPTURE_VERSION,
-    eventCount: events.length,
-    snapshotCount: snapshots.length,
-    maxIndex: events.at(-1)?.index ?? null,
-    sha256: `sha256:${await sha256(signed)}`,
-  }
-  return `${signed}${JSON.stringify(footer)}\n`
-}
-
-const recordsFromText = (text: string): unknown[] => {
-  if (text.length === 0) throw captureError('capture is empty')
-  const lines = text.split('\n')
-  if (lines.pop() !== '') {
-    throw captureError('capture must end with a newline')
-  }
-  const records = lines.map((line, index) => {
-    if (line.length === 0) {
-      throw captureError(`record ${index + 1} is empty`)
-    }
-    try {
-      return JSON.parse(line) as unknown
-    } catch {
-      throw captureError(`record ${index + 1} is not valid JSON`)
-    }
-  })
-  if (encodeRecords(records) !== text) {
-    throw captureError('capture must use canonical UTF-8 NDJSON encoding')
-  }
-  return records
-}
-
-const recordsFromValues = (records: readonly unknown[]): unknown[] => {
-  try {
-    validateCanonicalJsonValue(records, 'capture.records')
-    return recordsFromText(encodeRecords(records))
-  } catch (error) {
-    if (error instanceof DevtoolsCaptureError) throw error
-    throw captureError('capture records are not JSON-serializable')
-  }
-}
-
-const captureRecordsFrom = (value: unknown): unknown[] => {
-  if (typeof value === 'string') return recordsFromText(value)
-  if (value instanceof Uint8Array) {
-    try {
-      return recordsFromText(decoder.decode(value))
-    } catch (error) {
-      if (error instanceof DevtoolsCaptureError) throw error
-      throw captureError('capture is not valid UTF-8')
-    }
-  }
-  if (Array.isArray(value)) return recordsFromValues(value)
-  const capture = objectValue(value)
-  if (capture) {
-    if (Array.isArray(capture['records'])) {
-      return recordsFromValues(capture['records'])
-    }
-    const manifest = capture['manifest']
-    const events = capture['events']
-    const snapshots = capture['snapshots']
-    const footer = capture['footer']
-    if (Array.isArray(events) && Array.isArray(snapshots)) {
-      return recordsFromValues([manifest, ...events, ...snapshots, footer])
-    }
-  }
-  throw captureError('expected NDJSON text, bytes, records, or a capture')
-}
-
-const stringField = (
-  value: Record<string, unknown>,
-  field: string,
-  record: string,
-): string => {
-  const candidate = value[field]
-  if (typeof candidate !== 'string' || candidate.length === 0) {
-    throw captureError(`${record}.${field} must be a non-empty string`)
-  }
-  return candidate
-}
-
-const integerField = (
-  value: Record<string, unknown>,
-  field: string,
-  record: string,
-): number => {
-  const candidate = value[field]
-  if (!Number.isSafeInteger(candidate) || (candidate as number) < 0) {
-    throw captureError(`${record}.${field} must be a non-negative integer`)
-  }
-  return candidate as number
-}
-
-const positiveInteger = (value: unknown): value is number =>
-  Number.isSafeInteger(value) && (value as number) > 0
-
-const nonNegativeInteger = (value: unknown): value is number =>
-  Number.isSafeInteger(value) && (value as number) >= 0
-
-const canonicalDate = (value: unknown): value is string => {
-  if (typeof value !== 'string') return false
-  const parsed = new Date(value)
-  return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value
-}
-
-const optionalDate = (value: unknown): value is string | null =>
-  value === null || canonicalDate(value)
-
-const nullableString = (value: unknown): value is string | null =>
-  value === null || typeof value === 'string'
-
-const nullablePositiveInteger = (value: unknown): value is number | null =>
-  value === null || positiveInteger(value)
-
-const validateDate = (
-  value: unknown,
-  field: string,
-  record: string,
-  nullable: boolean,
-): void => {
-  if (nullable ? optionalDate(value) : canonicalDate(value)) return
-  throw captureError(
-    `${record}.${field} has an invalid timestamp; expected a canonical ISO date${nullable ? ' or null' : ''}`,
-  )
-}
-
-const validateCause = (value: unknown, record: string): void => {
-  if (value === null) return
-  const cause = objectValue(value)
-  if (
-    cause === null ||
-    !positiveInteger(cause['index']) ||
-    !positiveInteger(cause['attempt']) ||
-    (cause['batchSize'] !== undefined && !positiveInteger(cause['batchSize']))
-  ) {
-    throw captureError(`${record}.cause is invalid`)
-  }
-}
-
-const validateEventRecord = (
-  record: Record<string, unknown>,
-  label: string,
-): void => {
-  stringField(record, 'id', label)
-  stringField(record, 'type', label)
-  stringField(record, 'sessionId', label)
-  if (!Object.hasOwn(record, 'payload')) {
-    throw captureError(`${label}.payload is required`)
-  }
-  if (!positiveInteger(record['index'])) {
-    throw captureError(`${label}.index must be a positive integer`)
-  }
-  validateDate(record['createdAt'], 'createdAt', label, false)
-  validateCause(record['cause'], label)
-  if (!nullableString(record['lane'])) {
-    throw captureError(`${label}.lane must be a string or null`)
-  }
-  validateDate(record['processedAt'], 'processedAt', label, true)
-  if (!nullablePositiveInteger(record['processedByAttempt'])) {
-    throw captureError(
-      `${label}.processedByAttempt must be a positive integer or null`,
-    )
-  }
-  validateDate(record['firstClaimedAt'], 'firstClaimedAt', label, true)
-  validateDate(record['lastClaimedAt'], 'lastClaimedAt', label, true)
-  if (!nonNegativeInteger(record['attemptCount'])) {
-    throw captureError(`${label}.attemptCount must be a non-negative integer`)
-  }
-  if (!nullableString(record['claimHolder'])) {
-    throw captureError(`${label}.claimHolder must be a string or null`)
-  }
-  validateDate(record['claimExpiresAt'], 'claimExpiresAt', label, true)
-  if (!nonNegativeInteger(record['failureCount'])) {
-    throw captureError(`${label}.failureCount must be a non-negative integer`)
-  }
-  validateDate(record['lastFailedAt'], 'lastFailedAt', label, true)
-  if (!nullablePositiveInteger(record['lastFailedAttempt'])) {
-    throw captureError(
-      `${label}.lastFailedAttempt must be a positive integer or null`,
-    )
-  }
-  if (!nullableString(record['lastError'])) {
-    throw captureError(`${label}.lastError must be a string or null`)
-  }
-  validateDate(record['failedAt'], 'failedAt', label, true)
-  const returned = record['returnedEventIds']
-  if (
-    returned !== null &&
-    (!Array.isArray(returned) ||
-      returned.some((id) => typeof id !== 'string' || id.length === 0))
-  ) {
-    throw captureError(`${label}.returnedEventIds is invalid`)
-  }
-}
-
-const validateSnapshotRecord = (
-  record: Record<string, unknown>,
-  label: string,
-): void => {
-  stringField(record, 'reducerName', label)
-  if (!nonNegativeInteger(record['index'])) {
-    throw captureError(`${label}.index must be a non-negative integer`)
-  }
-  validateDate(record['updatedAt'], 'updatedAt', label, true)
-}
-
-function validateCanonicalJsonValue(
-  value: unknown,
-  path: string,
-  ancestors = new WeakSet<object>(),
-): void {
-  if (
-    value === null ||
-    typeof value === 'string' ||
-    typeof value === 'boolean'
-  ) {
-    return
-  }
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value) || Object.is(value, -0)) {
-      throw captureError(`${path} is not a canonical JSON number`)
-    }
-    return
-  }
-  if (Array.isArray(value)) {
-    if (ancestors.has(value)) {
-      throw captureError(`${path} is not a canonical JSON tree`)
-    }
-    ancestors.add(value)
-    try {
-      const keys = Object.keys(value)
-      const ownKeys = Reflect.ownKeys(value)
-      if (
-        keys.length !== value.length ||
-        ownKeys.length !== keys.length + 1 ||
-        !ownKeys.includes('length') ||
-        keys.some((key, index) => key !== String(index))
-      ) {
-        throw captureError(`${path} is not a canonical JSON array`)
-      }
-      value.forEach((entry, index) =>
-        validateCanonicalJsonValue(entry, `${path}[${index}]`, ancestors),
-      )
-    } finally {
-      ancestors.delete(value)
-    }
-    return
-  }
-  const object = objectValue(value)
-  if (
-    object === null ||
-    (Object.getPrototypeOf(object) !== Object.prototype &&
-      Object.getPrototypeOf(object) !== null)
-  ) {
-    throw captureError(`${path} is not a canonical JSON value`)
-  }
-  if (ancestors.has(object)) {
-    throw captureError(`${path} is not a canonical JSON tree`)
-  }
-  ancestors.add(object)
-  try {
-    const keys = Object.keys(object)
-    if (
-      Reflect.ownKeys(object).length !== keys.length ||
-      keys.some(
-        (key) => !Object.prototype.propertyIsEnumerable.call(object, key),
-      )
-    ) {
-      throw captureError(`${path} is not a canonical JSON object`)
-    }
-    for (const key of keys) {
-      validateCanonicalJsonValue(object[key], `${path}.${key}`, ancestors)
-    }
-  } finally {
-    ancestors.delete(object)
-  }
-}
-
-export function parseDevtoolsCapture(value: unknown): DevtoolsCapture {
-  const records = captureRecordsFrom(value)
-  if (records.length < 2) {
-    throw captureError('capture needs a manifest and footer')
-  }
-  const manifestValue = objectValue(records[0])
-  if (manifestValue?.['kind'] !== 'a2.capture') {
-    throw captureError("first record must have kind 'a2.capture'")
-  }
-  if (manifestValue['captureVersion'] !== DEVTOOLS_CAPTURE_VERSION) {
-    throw captureError(
-      `unsupported capture version '${String(manifestValue['captureVersion'])}'`,
-    )
-  }
-  if (manifestValue['protocolVersion'] !== DEVTOOLS_PROTOCOL_VERSION) {
-    throw captureError(
-      `unsupported protocol version '${String(manifestValue['protocolVersion'])}'`,
-    )
-  }
-  if (manifestValue['fidelity'] !== 'exact') {
-    throw captureError("manifest.fidelity must be 'exact'")
-  }
-  const manifest = manifestValue as DevtoolsCaptureManifest
-  const contract = stringField(manifestValue, 'contract', 'manifest')
-  const sessionId = stringField(manifestValue, 'sessionId', 'manifest')
-  const revision = stringField(manifestValue, 'revision', 'manifest')
-  const capturedAt = stringField(manifestValue, 'capturedAt', 'manifest')
-  if (!canonicalDate(capturedAt)) {
-    throw captureError('manifest.capturedAt must be a canonical ISO date')
-  }
-
-  const footerValue = objectValue(records.at(-1))
-  if (footerValue?.['kind'] !== 'end') {
-    throw captureError("last record must have kind 'end'")
-  }
-  if (footerValue['captureVersion'] !== DEVTOOLS_CAPTURE_VERSION) {
-    throw captureError('footer capture version does not match')
-  }
-  const footer = footerValue as DevtoolsCaptureFooter
-  integerField(footerValue, 'eventCount', 'footer')
-  integerField(footerValue, 'snapshotCount', 'footer')
-  stringField(footerValue, 'sha256', 'footer')
-  if (
-    footerValue['maxIndex'] !== null &&
-    (!Number.isSafeInteger(footerValue['maxIndex']) ||
-      (footerValue['maxIndex'] as number) < 1)
-  ) {
-    throw captureError('footer.maxIndex must be null or a positive integer')
-  }
-
-  const events: DevtoolsCaptureEvent[] = []
-  const snapshots: DevtoolsCaptureSnapshot[] = []
-  let sawSnapshot = false
-  for (let index = 1; index < records.length - 1; index += 1) {
-    const record = objectValue(records[index])
-    if (record?.['kind'] === 'event') {
-      if (sawSnapshot) {
-        throw captureError('event records must precede snapshot records')
-      }
-      validateEventRecord(record, `record ${index + 1}`)
-      events.push(record as DevtoolsCaptureEvent)
-    } else if (record?.['kind'] === 'snapshot') {
-      sawSnapshot = true
-      validateSnapshotRecord(record, `record ${index + 1}`)
-      snapshots.push(record as DevtoolsCaptureSnapshot)
-    } else {
-      throw captureError(`record ${index + 1} has an unknown kind`)
-    }
-  }
-
-  return {
-    contract,
-    sessionId,
-    revision,
-    capturedAt,
-    manifest,
-    events,
-    snapshots,
-    footer,
-    records: records as DevtoolsCaptureRecord[],
-  }
-}
-
-export async function verifyDevtoolsCapture(
-  capture: DevtoolsCapture,
-): Promise<void> {
-  validateCanonicalJsonValue(capture.records, 'capture.records')
-  parseDevtoolsCapture(capture.records)
-  const expectedRecords: DevtoolsCaptureRecord[] = [
-    capture.manifest,
-    ...capture.events,
-    ...capture.snapshots,
-    capture.footer,
-  ]
-  if (
-    capture.records.length !== expectedRecords.length ||
-    capture.records.some((record, index) => record !== expectedRecords[index])
-  ) {
-    throw captureError('record sequence does not match the capture')
-  }
-  if (
-    capture.contract !== capture.manifest.contract ||
-    capture.sessionId !== capture.manifest.sessionId ||
-    capture.revision !== capture.manifest.revision ||
-    capture.capturedAt !== capture.manifest.capturedAt
-  ) {
-    throw captureError('capture identity does not match its manifest')
-  }
-  if (!canonicalDate(capture.capturedAt)) {
-    throw captureError('manifest.capturedAt must be a canonical ISO date')
-  }
-  if (capture.footer.eventCount !== capture.events.length) {
-    throw captureError('footer event count does not match')
-  }
-  if (capture.footer.snapshotCount !== capture.snapshots.length) {
-    throw captureError('footer snapshot count does not match')
-  }
-
-  let previousIndex = 0
-  const ids = new Set<string>()
-  for (const event of capture.events) {
-    if (event.kind !== 'event') throw captureError('invalid event record kind')
-    validateEventRecord(
-      event as unknown as Record<string, unknown>,
-      `event #${event.index}`,
-    )
-    if (
-      !Number.isSafeInteger(event.index) ||
-      event.index !== previousIndex + 1
-    ) {
-      throw captureError('event indexes must be contiguous from 1')
-    }
-    previousIndex = event.index
-    if (event.sessionId !== capture.sessionId) {
-      throw captureError(`event #${event.index} belongs to another session`)
-    }
-    if (ids.has(event.id)) {
-      throw captureError(`event #${event.index} repeats id '${event.id}'`)
-    }
-    ids.add(event.id)
-  }
-
-  for (const snapshot of capture.snapshots) {
-    if (snapshot.kind !== 'snapshot') {
-      throw captureError('invalid snapshot record kind')
-    }
-    validateSnapshotRecord(
-      snapshot as unknown as Record<string, unknown>,
-      `snapshot '${snapshot.reducerName}'`,
-    )
-    if (
-      !Number.isSafeInteger(snapshot.index) ||
-      snapshot.index > previousIndex
-    ) {
-      throw captureError(`snapshot '${snapshot.reducerName}' is invalid`)
-    }
-  }
-
-  const maxIndex = capture.events.at(-1)?.index ?? null
-  if (capture.footer.maxIndex !== maxIndex) {
-    throw captureError('footer max index does not match')
-  }
-  if (!/^sha256:[\da-f]{64}$/.test(capture.footer.sha256)) {
-    throw captureError('footer.sha256 is malformed')
-  }
-  const expected = `sha256:${await sha256(
-    encodeRecords(capture.records.slice(0, -1)),
-  )}`
-  if (capture.footer.sha256 !== expected) {
-    throw captureError('capture digest does not match')
-  }
-}