@preventive/triage 1.0.0-alpha.26 → 1.0.0-alpha.28

package/server-managed/storage-maintenance.ts

@@ -0,0 +1,197 @@
+import { type StorageKey, decryptStorageStream, encryptStorageStream } from '../server-common/storage-crypto.ts'
+import { ENCRYPTED_CACHE_PREFIX, type RawObjectStorage, deleteObjects, isBlobId, openObjectVersion } from './object-storage.ts'
+import { type StorageDb, type StorageEncryptionState, type StorageMigrationRow, unwrapDataKey } from './storage-db.ts'
+import { STORAGE_UPLOAD_TTL_MS } from './storage-encryption.ts'
+import { StoragePayloadError, inspectStorageObject, storageOwner, storageRowPath, verifyStoragePayload } from './storage-payload.ts'
+
+async function migrateRow(raw: RawObjectStorage, db: StorageDb, key: StorageKey, item: StorageMigrationRow, signal: AbortSignal): Promise<string | void> {
+  if (item.type === 'user') { await db.migrateStorageUserTokens(item.id); return }
+  const row = await db.ensureStorageDataKey(item.type, item.id)
+  if (!row || row.encrypted) return
+  const dataKey = unwrapDataKey(key, item.type, row), identity = storageRowPath(item.type, row)
+  try {
+    const source = await raw.open(identity, signal)
+    if (!source) {
+      if (!await db.getStorageRow(item.type, item.id)) return
+      throw new StoragePayloadError('Migration payload unavailable')
+    }
+    let inspected = await inspectStorageObject(source)
+    if (inspected.encrypted) {
+      // A previous PUT may have completed before a timeout or lost SQL ack.
+      try {
+        const decoded = await decryptStorageStream(inspected.stream, dataKey, identity)
+        await verifyStoragePayload(item.type, row, decoded.stream, signal)
+      } catch {
+        signal.throwIfAborted()
+        // Legacy arbitrary bytes can share the magic prefix. A matching
+        // original upload hash is required before encrypting them as plaintext.
+        const legacy = await openObjectVersion(raw, identity, source.version, signal)
+        if (!legacy) return 'Payload disappeared or changed version before plaintext verification'
+        inspected = { ...legacy, encrypted: false }
+      }
+    }
+    if (!inspected.encrypted) {
+      await verifyStoragePayload(item.type, row, inspected.stream, signal)
+      signal.throwIfAborted()
+      const current = await openObjectVersion(raw, identity, source.version, signal)
+      if (!current) return 'Payload disappeared or changed version before encryption'
+      const encrypted = encryptStorageStream(current.stream, dataKey, identity, current.size)
+      let replaced: boolean
+      try { replaced = await raw.put(identity, encrypted, signal, source.version, current.size ?? undefined) }
+      finally { encrypted.destroy(); current.stream.destroy() }
+      if (!replaced) return 'Conditional replacement rejected (object version precondition failed)'
+      // Do not mark the row encrypted until the stored bytes authenticate and
+      // match the original upload (including decompression for sourcemaps).
+      const replacement = await raw.open(identity, signal)
+      if (!replacement) {
+        if (!await db.getStorageRow(item.type, item.id)) return
+        throw new StoragePayloadError('Migrated payload unavailable')
+      }
+      const decoded = await decryptStorageStream(replacement.stream, dataKey, identity)
+      await verifyStoragePayload(item.type, row, decoded.stream, signal)
+    }
+    signal.throwIfAborted()
+    // Another process may have renamed ciphertext but stopped before syncing
+    // the directory. Persist the observed rename even on the resume path.
+    await raw.sync?.(identity, signal)
+    await db.markStorageEncrypted(item.type, item.id, row.dataKey!)
+  } finally { dataKey.fill(0) }
+}
+
+const CLEANUP_PREFIXES = ['cache/', 'reports/', 'bundles/', ENCRYPTED_CACHE_PREFIX]
+function cleanupPosition(state: StorageEncryptionState): { prefix: number; cursor: string | null } {
+  const value = state.cleanupCursor === null ? { prefix: 0, cursor: null } : JSON.parse(state.cleanupCursor)
+  if (!Number.isInteger(value.prefix) || value.prefix < 0 || value.prefix >= CLEANUP_PREFIXES.length
+    || (value.cursor !== null && typeof value.cursor !== 'string')) throw new Error('Invalid legacy cleanup cursor')
+  return value
+}
+
+// The database directory may be shared. Recognize managed paths, including
+// disk atomic-write temps, before treating any listed file as ours to remove.
+function cleanupTarget(identity: string) {
+  const temp = /^(.+)\.([^.]+)\.tmp$/u.exec(identity)
+  const temporary = !!temp && isBlobId(temp[2]!)
+  const path = temporary ? temp![1]! : identity
+  const encryptedCache = path.startsWith(ENCRYPTED_CACHE_PREFIX)
+  if (encryptedCache && !temporary) return null
+  const owner = storageOwner(encryptedCache ? `cache/${path.slice(ENCRYPTED_CACHE_PREFIX.length)}` : path)
+  return owner ? { owner, temporary } : null
+}
+
+// Referenced-data migration never depends on Blob listings. A separate bounded
+// inventory removes legacy caches and unreferenced plaintext; ciphertext
+// orphans do not hold a recoverable data key and need no manifest-based GC.
+async function cleanupLegacy(raw: RawObjectStorage, db: StorageDb, state: StorageEncryptionState, limit: number, signal: AbortSignal) {
+  const position = cleanupPosition(state), prefix = CLEANUP_PREFIXES[position.prefix]!
+  const page = await raw.list(prefix, position.cursor, Math.min(limit, 16), signal)
+  let found = 0, retryAt: number | null = null
+  for (const object of page.objects) {
+    signal.throwIfAborted()
+    const target = cleanupTarget(object.key)
+    if (!target) continue
+    const { owner, temporary } = target
+    if (!temporary && !owner.cache) {
+      const row = await db.getStorageRow(owner.type, owner.id)
+      if (row && storageRowPath(owner.type, row) === object.key) continue
+    }
+    const stored = await raw.head(object.key, signal)
+    if (!stored) continue
+    // A killed disk writer can leave plaintext or ciphertext in its temp file.
+    // Recheck its current age and give live writes a full staging grace window.
+    if (temporary && stored.modifiedAt > Date.now() - STORAGE_UPLOAD_TTL_MS) {
+      found++
+      retryAt = Math.min(retryAt ?? Infinity, stored.modifiedAt + STORAGE_UPLOAD_TTL_MS)
+      continue
+    }
+    // Old pre-activation orphans are legacy even when their arbitrary bytes
+    // share the magic prefix. Keep a full staging grace window around enable:
+    // Blob Last-Modified has only second precision, and a new encrypted upload
+    // may still be waiting for its SQL insert.
+    let legacy = temporary || owner.cache || stored.modifiedAt < state.enabledAt - STORAGE_UPLOAD_TTL_MS
+    if (!legacy) {
+      const source = await raw.open(object.key, signal)
+      if (!source) continue
+      try {
+        if (source.version !== stored.version) throw new Error('Legacy object changed during cleanup')
+        const inspected = await inspectStorageObject(source)
+        legacy = !inspected.encrypted
+        inspected.stream.destroy()
+      } finally { source.stream.destroy() }
+    }
+    if (legacy) {
+      found++
+      if (!await raw.delete(object.key, stored.version, signal)) throw new Error('Legacy object changed during cleanup')
+    }
+  }
+  const next = page.cursor === null ? position.prefix + 1 < CLEANUP_PREFIXES.length ? { prefix: position.prefix + 1, cursor: null } : null
+    : { ...position, cursor: page.cursor }
+  // A full pass without removals closes offset-pagination gaps left by deletes.
+  await db.advanceStorageCleanup(state.cleanupCursor, next === null ? null : JSON.stringify(next), found)
+  return { processed: page.objects.length || 1, retryAt }
+}
+
+interface StorageMigrationResult extends StorageEncryptionState {
+  retryAt: number | null
+  failures: { type: StorageMigrationRow['type']; id: string; message: string }[]
+}
+interface MigrationOptions { maxObjects?: number; maxMs?: number | undefined; signal?: AbortSignal | undefined }
+export async function migrateStorage(raw: RawObjectStorage, db: StorageDb, key: StorageKey,
+  { maxObjects = 64, maxMs = 150_000, signal: stopping }: MigrationOptions = {}): Promise<StorageMigrationResult> {
+  if (!Number.isSafeInteger(maxObjects) || maxObjects < 1 || !Number.isSafeInteger(maxMs) || maxMs < 1) throw new Error('Invalid migration budget')
+  const deadline = Date.now() + maxMs, timeout = AbortSignal.timeout(maxMs)
+  const signal = stopping ? AbortSignal.any([stopping, timeout]) : timeout
+  const errors: unknown[] = []
+  const failures: StorageMigrationResult['failures'] = []
+  let processed = 0, retryAt: number | null = null, state = await db.getStorageEncryption()
+  if (!state) throw new Error('Storage encryption is not enabled; configure MANAGED_STORAGE_ENCRYPTION_KEY')
+  // At most one SQL pass per invocation. Checkpoint each row, including a
+  // failure: other rows progress, and the failed row is retried next pass.
+  while (!state.complete && processed < maxObjects && Date.now() < deadline && !signal.aborted) {
+    const rows = await db.listStorageMigrationRows(state.cursor, Math.min(16, maxObjects - processed))
+    if (stopping?.aborted) break
+    if (rows.length === 0) { await db.advanceStorageMigration(state.cursor, null); break }
+    for (const row of rows) {
+      if (Date.now() >= deadline || signal.aborted) break
+      try {
+        const pending = await migrateRow(raw, db, key, row, signal)
+        if (pending) failures.push({ type: row.type, id: row.id, message: pending })
+      }
+      catch (err) {
+        // A row started late gets a full budget next time. Skip an oversized
+        // first row until the next pass so later rows and tokens can advance.
+        if (stopping?.aborted || (signal.aborted && processed > 0)) break
+        const failure = signal.aborted
+          ? `Could not migrate ${row.type} ${row.id} within MANAGED_STORAGE_ENCRYPTION_MIGRATE_MAX_MS=${maxMs}; increase the budget`
+          : err instanceof StoragePayloadError ? err.message : null
+        if (failure === null) errors.push(new Error(`Could not migrate ${row.type} ${row.id}`, { cause: err }))
+        else failures.push({ type: row.type, id: row.id, message: failure })
+      }
+      if (stopping?.aborted) break
+      await db.advanceStorageMigration(state.cursor, row.position)
+      processed++
+      state = (await db.getStorageEncryption())!
+    }
+  }
+  state = (await db.getStorageEncryption())!
+  while (!state.cleanupComplete && processed < maxObjects && Date.now() < deadline && !signal.aborted) {
+    try {
+      const cleanup = await cleanupLegacy(raw, db, state, maxObjects - processed, signal)
+      processed += cleanup.processed
+      retryAt = cleanup.retryAt
+    }
+    catch (err) { if (!signal.aborted) errors.push(err); break }
+    state = (await db.getStorageEncryption())!
+    if (retryAt !== null) break // Wait for staging grace rather than spinning over live temp files.
+  }
+  if (errors.length > 0) throw new AggregateError(errors, 'Storage migration has pending failures', { cause: errors[0] })
+  return { ...state, retryAt, failures }
+}
+
+export async function reapStorageUploads(raw: RawObjectStorage, db: StorageDb, now = Date.now(), stopping?: AbortSignal): Promise<number> {
+  if (stopping?.aborted) return 0
+  const timeout = AbortSignal.timeout(150_000)
+  const signal = stopping ? AbortSignal.any([stopping, timeout]) : timeout
+  await db.getStorageEncryption()
+  try { return await deleteObjects(raw, 'uploads/', signal, now - STORAGE_UPLOAD_TTL_MS) }
+  catch (err) { if (stopping?.aborted) return 0; throw err }
+}

package/server-managed/storage-payload.ts

@@ -0,0 +1,72 @@
+import { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+import { Readable, Writable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { createBrotliDecompress } from 'node:zlib'
+import { STORAGE_MAGIC } from '../server-common/storage-crypto.ts'
+import { type RawObject, isBlobId } from './object-storage.ts'
+import type { StorageRow, StorageRowKind } from './storage-db.ts'
+
+// A damaged/missing payload needs repair; retrying the whole cleanup job does
+// not fix it. Keep this distinct from database, storage and cancellation errors.
+export class StoragePayloadError extends Error {}
+
+export function storageRowPath(type: StorageRowKind, row: Pick<StorageRow, 'id' | 'kind'>): string {
+  return `${type === 'report' ? 'reports' : 'bundles'}/${row.id}${type === 'bundle' && row.kind === 'sourcemap' ? '.map.br' : ''}`
+}
+export function storageOwner(identity: string): { type: StorageRowKind; id: string; cache: boolean } | null {
+  const match = /^(reports|bundles)\/([^/]+)$/u.exec(identity)
+  if (match) {
+    const id = match[1] === 'bundles' ? match[2]!.replace(/\.map\.br$/u, '') : match[2]!
+    if (isBlobId(id)) return { type: match[1] === 'reports' ? 'report' : 'bundle', id, cache: false }
+  }
+  const cache = /^cache\/(?:bundles|report-sources)\/([a-f\d-]{36})\//u.exec(identity)
+  return cache && isBlobId(cache[1]!) ? { type: 'bundle', id: cache[1]!, cache: true } : null
+}
+
+// Peek without buffering the object or consuming bytes from its next reader.
+export async function inspectStorageObject(stored: RawObject): Promise<RawObject & { encrypted: boolean }> {
+  const original = stored.stream
+  const iterator = original[Symbol.asyncIterator]()
+  const first: Buffer[] = [], prefix = Buffer.alloc(STORAGE_MAGIC.length)
+  let length = 0
+  try {
+    while (length < prefix.length) {
+      const next = await iterator.next()
+      if (next.done) break
+      const bytes = Buffer.from(next.value)
+      first.push(bytes)
+      length += bytes.copy(prefix, length, 0, prefix.length - length)
+    }
+  } catch (err) { original.destroy(); throw err }
+  async function* joined() {
+    try {
+      yield* first
+      for (;;) { const next = await iterator.next(); if (next.done) return; yield next.value }
+    } finally { await iterator.return?.(); original.destroy() }
+  }
+  const stream = Readable.from(joined(), { objectMode: false })
+  stream.once('close', () => original.destroy())
+  return { ...stored, stream, encrypted: length === prefix.length && prefix.equals(STORAGE_MAGIC) }
+}
+
+// Sourcemap integrity describes the original upload, before Brotli storage.
+// Hash incrementally, including decompression, so migration stays streaming.
+export async function verifyStoragePayload(type: StorageRowKind, row: StorageRow, source: Readable, signal?: AbortSignal): Promise<void> {
+  const hash = createHash(type === 'report' ? 'sha256' : 'sha512')
+  const sink = new Writable({ write(chunk, _encoding, next) { hash.update(chunk); next() } })
+  const options = signal ? { signal } : {}
+  try {
+    if (type === 'bundle' && row.kind === 'sourcemap') {
+      await pipeline(source, createBrotliDecompress(), sink, options)
+    } else await pipeline(source, sink, options)
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code ?? ''
+    if (['Z_DATA_ERROR', 'Z_BUF_ERROR'].includes(code) || code.startsWith('ERR__ERROR_FORMAT_')) {
+      throw new StoragePayloadError('Stored sourcemap cannot be decompressed', { cause: err })
+    }
+    throw err
+  }
+  const actual = type === 'report' ? hash.digest('base64url') : `sha512-${hash.digest('base64')}`
+  if (actual !== row.hash) throw new StoragePayloadError('Stored payload does not match its upload hash')
+}

package/server-managed/storage-stores.ts

@@ -0,0 +1,81 @@
+// Logical stores share one encryption boundary. Compression, identifiers and
+// public response bytes stay the same with either physical backend.
+import { Buffer } from 'node:buffer'
+import type { AvatarStore } from './avatar-store.ts'
+import type { BlobStore } from './blob-store.ts'
+import type { BundleCacheStorage } from './bundle-cache.ts'
+import { createBundleStore } from './bundle-store.ts'
+import { CacheMissError, type CacheStorage, validateCacheKey } from './cache-storage.ts'
+import { type ObjectStorage, isBlobId } from './object-storage.ts'
+
+function id(value: string): string {
+  if (!isBlobId(value)) throw new Error('Invalid managed blob id')
+  return value
+}
+
+function blobStore(objects: ObjectStorage, name: string, suffix = ''): BlobStore {
+  const path = (value: string) => `${name}/${id(value)}${suffix}`
+  return {
+    put: (value, bytes) => objects.put(path(value), bytes),
+    get: value => objects.get(path(value)),
+    open: value => objects.open(path(value)),
+    delete: value => objects.delete(path(value)),
+  }
+}
+
+function cacheStore(objects: ObjectStorage, name: string): CacheStorage {
+  const path = (key: string) => `cache/${name}/${validateCacheKey(key)}`
+  return {
+    exists: key => objects.exists(path(key)),
+    put: async (key, bytes) => { await objects.put(path(key), bytes) },
+    async open(key) {
+      const value = await objects.open(path(key))
+      if (!value) throw new CacheMissError()
+      return value
+    },
+    delete: prefix => objects.deletePrefix(`${path(prefix)}/`),
+  }
+}
+
+function avatarStore(objects: ObjectStorage, sidecar: boolean): AvatarStore {
+  return {
+    async put(value, contentType, bytes) {
+      const path = `avatars/${id(value)}`, type = contentType.split(';', 1)[0]!.trim()
+      if (!/^image\/[a-z0-9.+-]+$/iu.test(type)) throw new Error('Invalid avatar type')
+      if (sidecar) {
+        await objects.put(path, bytes)
+        await objects.put(`${path}.type`, Buffer.from(type))
+      } else await objects.put(path, Buffer.concat([Buffer.from(`${type}\n`), bytes]))
+    },
+    async get(value) {
+      const path = `avatars/${id(value)}`
+      const bytes = await objects.get(path)
+      if (!bytes) return null
+      if (sidecar) {
+        const type = await objects.get(`${path}.type`)
+        return type ? { bytes, contentType: type.toString().trim() || 'application/octet-stream' } : null
+      }
+      const split = bytes.indexOf(10)
+      if (split < 0 || split > 100) throw new Error('Invalid cached avatar')
+      return { contentType: bytes.subarray(0, split).toString(), bytes: bytes.subarray(split + 1) }
+    },
+  }
+}
+
+export function createManagedStores(objects: ObjectStorage, avatarSidecar: boolean) {
+  const bundles = cacheStore(objects, 'bundles')
+  const cacheStorage: BundleCacheStorage = {
+    exists: (value, file) => bundles.exists(`${id(value)}/${file}`),
+    put: (value, file, bytes) => bundles.put(`${id(value)}/${file}`, bytes),
+    open: (value, file) => bundles.open(`${id(value)}/${file}`),
+    delete: value => bundles.delete(id(value)),
+  }
+  return {
+    reportStore: blobStore(objects, 'reports'),
+    bundleStore: createBundleStore(blobStore(objects, 'bundles'), blobStore(objects, 'bundles', '.map.br')),
+    uploadStore: blobStore(objects, 'uploads'),
+    avatarStore: avatarStore(objects, avatarSidecar),
+    cacheStorage,
+    reportSourcesStorage: cacheStore(objects, 'report-sources'),
+  }
+}

package/server-managed/storage.ts

@@ -1,34 +1,58 @@
 // Backend selection is shared by standalone, combined and function entrypoints.
-import { dirname, join } from 'node:path'
-import { createDiskAvatarStore } from './avatar-store.ts'
-import { createDiskBlobStore } from './blob-store.ts'
-import { createDiskBundleStore } from './bundle-store.ts'
-import { createBundleCache, createDiskBundleCache } from './bundle-cache.ts'
-import { createDiskCacheStorage } from './cache-storage.ts'
+import { dirname } from 'node:path'
+import { parseStorageKey } from '../server-common/storage-crypto.ts'
+import { createBundleCache } from './bundle-cache.ts'
 import { createReportSourcesCache } from './report-sources.ts'
-import { openManagedVercelStorage } from './blob-vercel.ts'
 import { openNeonManagedDb } from './db-neon.ts'
 import type { ManagedConfig } from './config.ts'
+import { createEncryptedObjectStorage } from './storage-encryption.ts'
+import { createManagedStores } from './storage-stores.ts'
+import { createDiskObjectStorage } from './object-storage-disk.ts'
+import { openVercelObjectStorage } from './object-storage-vercel.ts'
+import { migrateStorage, reapStorageUploads } from './storage-maintenance.ts'
+
+// Database-only callers (notably status) must not activate byte encryption.
+export async function openManagedStorageDb(config: ManagedConfig) {
+  const options = { triageHistoryLimit: config.triageHistoryLimit, storageEncryptionKey: parseStorageKey(config.storageEncryptionKey) }
+  return config.neonUrl ? openNeonManagedDb(config.neonUrl, options)
+    : (await import('./db.ts')).openSqliteManagedDb(config.dbPath, options)
+}
 
 export async function openManagedStorage(config: ManagedConfig) {
-  const options = { triageHistoryLimit: config.triageHistoryLimit }
-  if (config.neonUrl) {
-    if (!config.blobToken) throw new Error('Managed Neon mode requires BLOB_READ_WRITE_TOKEN')
-    const storage = await openManagedVercelStorage(config.blobToken)
-    const db = await openNeonManagedDb(config.neonUrl, options)
-    return { ...storage, db, bundleCache: createBundleCache(storage.cacheStorage, db, storage.bundleStore),
+  const key = parseStorageKey(config.storageEncryptionKey)
+  if (config.storageEncryptionMigrate && !key) throw new Error('MANAGED_STORAGE_ENCRYPTION_MIGRATE requires MANAGED_STORAGE_ENCRYPTION_KEY')
+  if (config.neonUrl && !config.blobToken) throw new Error('Managed Neon mode requires BLOB_READ_WRITE_TOKEN')
+  if (config.serverless && !config.neonUrl) throw new Error('Serverless managed storage requires Neon')
+  const db = await openManagedStorageDb(config)
+  try {
+    const raw = config.neonUrl ? await openVercelObjectStorage(config.blobToken!) : createDiskObjectStorage(dirname(config.dbPath))
+    // Enable before exposing stores or token writers. Concurrent first starts
+    // serialize activation in the database and validate the winning key.
+    if (key && !await db.getStorageEncryption()) {
+      if (config.vercelPreview) throw new Error('Storage encryption must be enabled outside a Vercel preview deployment')
+      await db.enableStorageEncryption()
+    }
+    const objects = await createEncryptedObjectStorage(raw, db, key)
+    const storage = createManagedStores(objects, !config.neonUrl)
+    return { ...storage, db, uploadStore: config.neonUrl ? storage.uploadStore : undefined,
+      bundleCache: createBundleCache(storage.cacheStorage, db, storage.bundleStore),
       reportSourcesCache: createReportSourcesCache(storage.reportSourcesStorage, db, storage.reportStore, storage.bundleStore),
+      async reapStorage(signal?: AbortSignal) {
+        if (!config.storageEncryptionMigrate || signal?.aborted) return
+        const state = await db.getStorageEncryption()
+        if (state?.complete && state.cleanupComplete) return
+        const result = await migrateStorage(raw, db, key!, { maxMs: config.storageEncryptionMigrateMaxMs, signal })
+        for (const failure of result.failures) console.warn('managed-storage-migration-row:', JSON.stringify(failure))
+        console.info('managed-storage-migration:', JSON.stringify({
+          complete: result.complete === 1, cleanupComplete: result.cleanupComplete === 1,
+          migrated: result.migrated, cursor: result.cursor, retryAt: result.retryAt,
+          failed: result.failures.length, cancelled: signal?.aborted === true,
+        }))
+      },
+      ...(config.neonUrl ? { reapUploads: (signal?: AbortSignal) => reapStorageUploads(raw, db, Date.now(), signal) } : {}),
     }
-  }
-  if (config.serverless) throw new Error('Serverless managed storage requires Neon')
-  const { openSqliteManagedDb } = await import('./db.ts')
-  const db = openSqliteManagedDb(config.dbPath, options)
-  const dir = dirname(config.dbPath)
-  const reportStore = createDiskBlobStore(join(dir, 'reports'))
-  const bundleStore = createDiskBundleStore(join(dir, 'bundles'))
-  return { db, reportStore, bundleStore,
-    reportSourcesCache: createReportSourcesCache(createDiskCacheStorage(join(dir, 'cache', 'report-sources')), db, reportStore, bundleStore),
-    avatarStore: createDiskAvatarStore(join(dir, 'avatars')),
-    bundleCache: createDiskBundleCache(join(dir, 'cache', 'bundles'), db, bundleStore),
+  } catch (err) {
+    await db.close()
+    throw err
   }
 }

package/server-managed/team-feed.ts

@@ -3,6 +3,7 @@ import { setTimeout as delay } from 'node:timers/promises'
 import type { ManagedHttpDeps } from './http.ts'
 import type { StoredUser, TeamReportAccessSnapshot } from './db.ts'
 import { TeamReportsError, teamSnapshotKey, teamWorkspaceFindingIds } from './team-reports.ts'
+import type { WorkspaceShareFeedState } from './workspace-shares.ts'
 
 // Short database reads work across instances without pinning a Neon connection.
 // All polling belongs to the awaited request; nothing runs after it completes.
@@ -15,14 +16,30 @@ type Publish = (event: 'teams' | 'triage', revision: string | undefined) => bool
 
 // Public capabilities remain scoped to their single shared workspace.
 export async function serveTeamFeed(res: ServerResponse, deps: ManagedHttpDeps,
-  snapshot: TeamReportAccessSnapshot, recheck: () => Promise<void>, options: FeedOptions = {}): Promise<void> {
+  snapshot: TeamReportAccessSnapshot, recheck: () => Promise<void>,
+  options: FeedOptions & { readState?: () => Promise<WorkspaceShareFeedState | null> } = {}): Promise<void> {
   let ids: string[] | undefined
+  let previous: WorkspaceShareFeedState | undefined
+  const sameAccess = (a: WorkspaceShareFeedState, b?: WorkspaceShareFeedState) => a.grant === b?.grant && a.catalog === b.catalog
+  const readState = async () => {
+    const state = await options.readState!()
+    if (!state) throw new TeamReportsError(404, 'workspace-changed')
+    return state
+  }
   await serveFeed(res, deps, async publish => {
-    await recheck()
+    const state = options.readState ? await readState() : undefined
+    // The first poll still compares the full snapshot loaded before the stream.
+    // Unchanged polls validate the live grant without reading report catalogs.
+    if (state && sameAccess(state, previous)) {
+      if (state.annotations === previous!.annotations) return
+    } else await recheck()
     ids ??= [...await teamWorkspaceFindingIds(deps.db, deps.reportStore, snapshot)]
     const triage = await deps.db.getAnnotationRevision(ids)
-    await recheck()
+    const after = options.readState ? await readState() : undefined
+    if (!after || !sameAccess(after, state)) await recheck()
     publish('triage', triage)
+    // A write during the read must remain pending for the following poll.
+    if (after?.annotations === state?.annotations) previous = after
   }, options)
 }
 
@@ -32,6 +49,8 @@ export async function serveTeamFeed(res: ServerResponse, deps: ManagedHttpDeps,
 export async function serveUserTeamFeed(res: ServerResponse, deps: ManagedHttpDeps,
   sessionId: string, user: StoredUser, teamId: string | null, options: FeedOptions = {}): Promise<void> {
   let ids: string[] = [], visibilityKey: string | undefined
+  let focusedKey: string | undefined
+  let previousState: { catalog: number; annotations: number } | undefined
   const checkUser = (current: { user: Pick<StoredUser, 'id' | 'role'> } | null) => {
     if (!current) throw new TeamReportsError(401, 'unauthenticated')
     if (current.user.id !== user.id || current.user.role !== user.role || current.user.role === 'none') {
@@ -39,12 +58,33 @@ export async function serveUserTeamFeed(res: ServerResponse, deps: ManagedHttpDe
     }
   }
   await serveFeed(res, deps, async publish => {
+    const state = await deps.db.getFeedState(sessionId, Date.now())
+    checkUser(state)
+    if (state!.catalog === previousState?.catalog && (!teamId || state!.annotations === previousState?.annotations)) return
+    if (teamId && focusedKey !== undefined && state!.catalog === previousState?.catalog) {
+      // Annotation changes cannot change visibility. Read only this workspace's
+      // IDs, then fence against concurrent access/content changes before sending.
+      const triage = JSON.stringify([focusedKey, await deps.db.getAnnotationRevision(ids)])
+      const after = await deps.db.getFeedState(sessionId, Date.now())
+      checkUser(after)
+      if (after!.catalog !== state!.catalog) return
+      publish('triage', triage)
+      if (after!.annotations === state!.annotations) previousState = state!
+      return
+    }
     const catalog = await deps.db.getUserTeamFeedSnapshot(sessionId, Date.now())
     checkUser(catalog)
     checkUser(await deps.db.getReportAccessSnapshot(sessionId, Date.now(), []))
     // Publish catalog state before loading any report blobs. A slow or broken
     // focused report must not hide membership/content changes from the client.
-    if (!publish('teams', catalog!.revision) || !teamId) return
+    if (!publish('teams', catalog!.revision)) return
+    if (!teamId) {
+      // A mutation during the snapshot must cause a fresh read next poll.
+      const current = await deps.db.getFeedState(sessionId, Date.now())
+      checkUser(current)
+      if (current!.catalog === state!.catalog) previousState = state!
+      return
+    }
     let triage: string | undefined
     const snapshot = await deps.db.getTeamReportAccessSnapshot(sessionId, Date.now(), teamId)
     if (!snapshot) throw new TeamReportsError(401, 'unauthenticated')
@@ -67,6 +107,10 @@ export async function serveUserTeamFeed(res: ServerResponse, deps: ManagedHttpDe
     checkUser(current)
     if (!current || teamSnapshotKey(current) !== key) return
     publish('triage', triage)
+    focusedKey = snapshot.teamId ? key : undefined
+    const after = await deps.db.getFeedState(sessionId, Date.now())
+    checkUser(after)
+    if (after!.catalog === state!.catalog && after!.annotations === state!.annotations) previousState = state!
   }, options)
 }
 
@@ -106,7 +150,8 @@ async function serveFeed(res: ServerResponse, deps: ManagedHttpDeps, read: (publ
       return true
     }
     while (!stopped()) {
-      await read(publish)
+      if (deps.db.withRequest) await deps.db.withRequest(() => read(publish))
+      else await read(publish)
       if (stopped()) break
       if (Date.now() - heartbeat >= HEARTBEAT_MS) {
         if (!write(': keepalive\n\n')) break