@gotcos/glasses-server 6.99.16 → 6.99.25

package/server/lib/prep-store.ts

@@ -0,0 +1,226 @@
+/**
+ * Prep v1.1 (6.99.19): the durable Prep store at dataPath('prep').
+ *
+ *   drafts/<draftId>.json            one PrepDraft, written whole (fsync + rename, mode 0600)
+ *   files/<draftId>/<fileId>.bin     the original bytes, copied out of /api/media at add time (the media stage expires in 4 h)
+ *   files/<draftId>/<fileId>.txt     the extracted text a run and a bind read (ready files only)
+ *   runs/<draftId>/<clientRequestId>.txt   a run's exact prompt, saved before the job is submitted
+ *   binds/<draftId>/<sessionId>/<revision>.json   the exact Meeting Ask rows a bind attaches, saved before its intent
+ *
+ * Drafts are read back from disk on first use, so a restarted server (a fresh instance) serves the same drafts. Writes
+ * are synchronous inside one server process; prep-runtime.ts serializes each draft's read-modify-write. Nothing is
+ * auto-deleted in v1. A draft file that cannot be read is skipped and logged, never deleted.
+ */
+import { createHash } from 'node:crypto'
+import { lstatSync, mkdirSync, readFileSync, readdirSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { dataPath } from './data-dir.js'
+import { ASK_SESSION } from './ask-session-id.js'
+import { PREP_DRAFT_ID, PREP_FILE_ID, PREP_PROVIDERS, PREP_UUID_V4, type PrepDraft, type PrepOccurrence } from '../../shared/prep.js'
+
+export class PrepError extends Error {
+  constructor(readonly code: string, readonly status = 400, readonly draft?: PrepDraft, readonly extra: Record<string, unknown> = {}) {
+    super(code)
+    this.name = 'PrepError'
+  }
+}
+
+/**
+ * v1.1 #16: "occ:v2:" + sha256("occ:v2:" + provider|account|calendarId|eventId or ""|externalId or ""|startsAt exact
+ * UTC ISO). Every part, no quantization, so distinct occurrences never coalesce. Finds a draft; never binds one.
+ */
+export function prepOccurrenceKey(o: Pick<PrepOccurrence, 'provider' | 'account' | 'calendarId' | 'eventId' | 'externalId' | 'startsAt'>): string {
+  const text = 'occ:v2:' + [o.provider, o.account ?? '', o.calendarId, o.eventId ?? '', o.externalId ?? '', new Date(Date.parse(o.startsAt)).toISOString()].join('|')
+  return 'occ:v2:' + createHash('sha256').update(text).digest('hex')
+}
+
+/**
+ * The provider identity, or null. All of provider, calendarId, eventId or externalId, and startsAt must be present
+ * (account is optional and part of the key); anything less is no identity at all, never a guess from title or time.
+ * A client-sent `key` is ignored and recomputed. A non-object is a 400.
+ */
+export function parsePrepOccurrence(raw: unknown): PrepOccurrence | null {
+  if (raw === null) return null
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new PrepError('invalid_occurrence')
+  const o = raw as Record<string, unknown>
+  const id = (v: unknown) => typeof v === 'string' && v.trim() && v.length <= 512 ? v : null
+  const iso = (v: unknown) => typeof v === 'string' && v.length <= 64 && Number.isFinite(Date.parse(v)) ? new Date(Date.parse(v)).toISOString() : null
+  const provider = PREP_PROVIDERS.includes(o.provider as never) ? o.provider as PrepOccurrence['provider'] : null
+  const account = id(o.account), calendarId = id(o.calendarId), eventId = id(o.eventId), externalId = id(o.externalId)
+  const startsAt = iso(o.startsAt)
+  if (!provider || !calendarId || (!eventId && !externalId) || !startsAt) return null
+  const base = { provider, account, calendarId, eventId, externalId, startsAt }
+  return { key: prepOccurrenceKey(base), ...base, endsAt: iso(o.endsAt) }
+}
+
+/** The loader skips a draft file larger than this; writes stop well short of it. */
+export const DRAFT_LOAD_BYTES = 5_000_000
+export const DRAFT_WRITE_BYTES = 4_000_000
+
+export class PrepStore {
+  readonly root: string
+  private cache: Map<string, PrepDraft> | null = null
+
+  constructor(root = dataPath('prep')) { this.root = resolve(root) }
+
+  private dir(...parts: string[]): string {
+    mkdirSync(this.root, { recursive: true, mode: 0o700 })
+    if (lstatSync(this.root).isSymbolicLink()) throw new PrepError('prep_store_unsafe', 503)
+    let p = this.root
+    for (const part of parts) {
+      p = join(p, part)
+      mkdirSync(p, { recursive: true, mode: 0o700 })
+      if (lstatSync(p).isSymbolicLink()) throw new PrepError('prep_store_unsafe', 503)
+    }
+    return p
+  }
+
+  private load(): Map<string, PrepDraft> {
+    if (this.cache) return this.cache
+    const drafts = new Map<string, PrepDraft>()
+    const dir = this.dir('drafts')
+    for (const name of readdirSync(dir)) {
+      if (!name.endsWith('.json')) continue
+      const id = name.slice(0, -5)
+      try {
+        const path = join(dir, name), st = lstatSync(path)
+        if (!PREP_DRAFT_ID.test(id) || !st.isFile() || st.size > DRAFT_LOAD_BYTES) throw new Error('unsafe')
+        const draft = JSON.parse(readFileSync(path, 'utf8')) as PrepDraft
+        if (draft?.id !== id || !Number.isSafeInteger(draft.revision) || !Array.isArray(draft.files)) throw new Error('shape')
+        draft.snapshots ??= []
+        draft.fileOperations ??= []
+        drafts.set(id, draft)
+      } catch {
+        // Kept on disk for a person to look at; it simply is not served.
+        console.warn(`[prep] skipped an unreadable draft file (${id.slice(0, 12)})`)
+      }
+    }
+    this.cache = drafts
+    return drafts
+  }
+
+  get(id: string): PrepDraft | undefined {
+    if (!PREP_DRAFT_ID.test(id)) return undefined
+    const d = this.load().get(id)
+    return d ? structuredClone(d) : undefined
+  }
+
+  list(): PrepDraft[] { return [...this.load().values()].map(d => structuredClone(d)) }
+
+  byClientDraftId(clientDraftId: string): PrepDraft | undefined {
+    for (const d of this.load().values()) if (d.clientDraftId === clientDraftId) return structuredClone(d)
+    return undefined
+  }
+
+  write(draft: PrepDraft): PrepDraft {
+    if (!PREP_DRAFT_ID.test(draft.id)) throw new PrepError('invalid_draft_id')
+    const encoded = JSON.stringify(draft)
+    // Never write a draft the loader would refuse: it would vanish on the next restart.
+    if (Buffer.byteLength(encoded, 'utf8') > DRAFT_WRITE_BYTES) throw new PrepError('prep_draft_too_large', 507)
+    try {
+      durableAtomicWriteFileSync(join(this.dir('drafts'), draft.id + '.json'), encoded, { mode: 0o600 })
+    } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+    this.load().set(draft.id, structuredClone(draft))
+    return structuredClone(draft)
+  }
+
+  private blobPath(draftId: string, fileId: string, ext: 'bin' | 'txt'): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !PREP_FILE_ID.test(fileId)) throw new PrepError('invalid_file_id')
+    return join(this.dir('files', draftId), `${fileId}.${ext}`)
+  }
+
+  putOriginal(draftId: string, fileId: string, bytes: Buffer): void {
+    try { durableAtomicWriteFileSync(this.blobPath(draftId, fileId, 'bin'), bytes, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  putText(draftId: string, fileId: string, text: string): void {
+    try { durableAtomicWriteFileSync(this.blobPath(draftId, fileId, 'txt'), text, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readOriginal(draftId: string, fileId: string): Buffer {
+    try { return readFileSync(this.blobPath(draftId, fileId, 'bin')) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('file_not_found', 404)
+    }
+  }
+
+  /** The stored text, or '' when the file has none (not ready, or never extracted). */
+  readText(draftId: string, fileId: string): string {
+    try { return readFileSync(this.blobPath(draftId, fileId, 'txt'), 'utf8') } catch (e) {
+      if (e instanceof PrepError) throw e
+      return ''
+    }
+  }
+
+  /** The exact prompt of a run, saved before its job is submitted so a retry after a crash resubmits the same bytes. */
+  putPrompt(draftId: string, clientRequestId: string, prompt: string): void {
+    try { durableAtomicWriteFileSync(this.promptPath(draftId, clientRequestId), prompt, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readPrompt(draftId: string, clientRequestId: string): string | null {
+    try { return readFileSync(this.promptPath(draftId, clientRequestId), 'utf8') } catch (e) {
+      if (e instanceof PrepError) throw e
+      return null
+    }
+  }
+
+  private promptPath(draftId: string, clientRequestId: string): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !PREP_UUID_V4.test(clientRequestId)) throw new PrepError('invalid_client_request_id')
+    return join(this.dir('runs', draftId), `${clientRequestId}.txt`)
+  }
+
+  /**
+   * The exact Meeting Ask rows one bind attaches, saved before the binding intent, so a retry after a crash re-applies
+   * the frozen revision rather than whatever the draft holds by then.
+   */
+  putBindPayload(draftId: string, sessionId: string, revision: number, rows: unknown[]): void {
+    try { durableAtomicWriteFileSync(this.bindPath(draftId, sessionId, revision), JSON.stringify(rows), { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readBindPayload(draftId: string, sessionId: string, revision: number): unknown[] | null {
+    try {
+      const rows = JSON.parse(readFileSync(this.bindPath(draftId, sessionId, revision), 'utf8'))
+      return Array.isArray(rows) ? rows : null
+    } catch (e) {
+      if (e instanceof PrepError) throw e
+      return null
+    }
+  }
+
+  /** Keyed by (draft, meeting, revision): a replay of one bind can never read another bind's rows. */
+  private bindPath(draftId: string, sessionId: string, revision: number): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !ASK_SESSION.test(sessionId) || !Number.isSafeInteger(revision) || revision < 0) throw new PrepError('invalid_session_id')
+    return join(this.dir('binds', draftId, sessionId), `${revision}.json`)
+  }
+
+  /** Bytes on disk under the store root (drafts, originals, text). Walked on each add: at most 300 drafts x 10 files. */
+  usageBytes(): number {
+    let total = 0
+    const walk = (p: string) => {
+      for (const name of readdirSync(p)) {
+        const child = join(p, name), st = lstatSync(child)
+        if (st.isSymbolicLink()) continue
+        if (st.isDirectory()) walk(child)
+        else if (st.isFile()) total += st.size
+      }
+    }
+    walk(this.dir())
+    return total
+  }
+}

package/server/lib/stt-resolver.ts

@@ -17,6 +17,13 @@
 //      holds a profile vocabulary term the primary's side does not, the second
 //      opinion's words are taken.
 //
+// A third caller (6.99.18) is the saved iPhone transcript, where the second
+// side is the live Whisper words the phone already heard with the vocabulary
+// prompt. Those words have approximate clocks and a prompted Whisper can echo a
+// vocabulary term into a pause, so that caller sets anchoredVocabularyOnly: a
+// term is taken only where the primary heard other words in the same place,
+// and the taken words are clocked across the primary words they replace.
+//
 // Everything else stays as the primary heard it. No region whose two sides
 // differ in a negation, a number or a unit is ever changed, whatever its length
 // (the 2026-10-13 diagnostic saw "born lacking" become "born having" and
@@ -37,7 +44,7 @@ export interface Hypothesis {
 }
 
 export type DisagreementKind = 'substitution' | 'primary_only' | 'second_only'
-export type ResolutionReason = 'gap_fill' | 'vocabulary' | 'protected' | 'not_speech' | 'low_confidence' | 'too_wide' | null
+export type ResolutionReason = 'gap_fill' | 'vocabulary' | 'protected' | 'not_speech' | 'low_confidence' | 'too_wide' | 'unanchored' | null
 
 export interface Disagreement {
   kind: DisagreementKind
@@ -66,6 +73,10 @@ export interface ResolveOptions {
    *  10 s) made the resolver worse than plain text alignment, because Large-v3's
    *  remapped token clocks have a heavy tail (median skew 0.23 s, p90 1.0 s). */
   maxSkewSec?: number | null
+  /** The second side's clocks are approximate (live words). A vocabulary term is
+   *  taken only from a substitution, never an insertion the primary has nothing
+   *  for, and the taken words are clocked across the primary words they replace. */
+  anchoredVocabularyOnly?: boolean
 }
 
 export interface ResolveResult {
@@ -241,6 +252,15 @@ function gapVerdict(q: Token[], options: ResolveOptions): ResolutionReason {
   return 'gap_fill'
 }
 
+/** The second side's words spread evenly over the time the replaced primary words took. */
+function reclock(q: Token[], p: Token[]): Token[] {
+  const { start, end } = span(p)
+  if (start === null) return q.map(t => ({ ...t, start: null, end: null }))
+  const stop = Math.max(start, end ?? start)
+  const step = (stop - start) / q.length
+  return q.map((t, i) => ({ ...t, start: start + i * step, end: start + (i + 1) * step }))
+}
+
 export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, options: ResolveOptions): ResolveResult {
   const P = tokens(primary), Q = tokens(second)
   const toWords = (ts: Token[]): HypWord[] => ts.map(t => ({
@@ -290,6 +310,7 @@ export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, optio
       const wantVocab = newTerms.length > 0
       if (wantGap || wantVocab) {
         if (!sameProtected(p, q)) reason = 'protected'
+        else if (wantVocab && options.anchoredVocabularyOnly && !p.length) reason = 'unanchored'
         else if (wantVocab && (q.length > MAX_VOCAB_REGION_WORDS || p.length > q.length + MAX_VOCAB_REGION_SLACK)) {
           // A term inside a long disagreement is not a reason to swap the whole region.
           reason = wantGap ? gapVerdict(q, options) : 'too_wide'
@@ -308,7 +329,10 @@ export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, optio
       taken: options.apply ? take : 'primary',
       reason,
     })
-    if (options.apply && take === 'second') { out.push(...q); wordsFromSecond += q.length }
+    if (options.apply && take === 'second') {
+      out.push(...(options.anchoredVocabularyOnly ? reclock(q, p) : q))
+      wordsFromSecond += q.length
+    }
     else out.push(...p)
   }
   return {

package/server/lib/transcript-cleanup.ts

@@ -28,6 +28,7 @@
 
 import { existsSync, mkdirSync, appendFileSync, readFileSync, renameSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
+import { isPrepCopyId } from '../../shared/prep.js'
 import { LensGistLimitError, runLensGistEngine } from './lens-gist-engines.js'
 import { resolveProviderBinary } from './provider-binary.js'
 import { getVocabulary, getWhisperCorrections } from './profile.js'
@@ -167,11 +168,19 @@ const notesSearchDefault: CleanupDeps['searchNotes'] = async (queries, sessionId
   })(queries, sessionId, signal)
 }
 
+/**
+ * The meeting files whose words may steer saved-transcript cleanup. Pasted text and read pages (paste_, web_) are
+ * article words, not the room's vocabulary, and so are Prep copies (prep_prep_..., 6.99.19): notes and documents
+ * written before the call. None of them may rewrite the saved transcript.
+ */
+export function cleanupVocabularyFiles(files: ReadonlyArray<{ id: string; name: string; status: string; text: string }>, isPastedFileId: (id: string) => boolean): CleanupFile[] {
+  return files.filter(f => !isPastedFileId(f.id) && !isPrepCopyId(f.id) && f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
+}
+
 const filesDefault: CleanupDeps['files'] = async sessionId => {
   try {
     const { MeetingAskStore, isPastedFileId } = await import('./meeting-ask-store.js')
-    // Pasted text and read pages (paste_, web_) are article words, not the room's vocabulary: they must not rewrite the saved transcript.
-    return new MeetingAskStore().files(sessionId).filter(f => !isPastedFileId(f.id) && f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
+    return cleanupVocabularyFiles(new MeetingAskStore().files(sessionId), isPastedFileId)
   } catch { return [] }
 }
 

package/server/lib/web-control-static.ts

@@ -0,0 +1,226 @@
+/**
+ * Fast static serving for COS Control Web (`/control/*`).
+ *
+ * Before this, `/control` went straight to `express.static`: no compression and
+ * `Cache-Control: public, max-age=0`, so every open on the phone re-asked the Mac about
+ * all 22 boot files over Tailscale and downloaded about 1.2 MB of uncompressed JS and CSS
+ * plus 770 KB of fonts whenever anything changed.
+ *
+ * What this does:
+ * - Every asset gets a content hash. `index.html` and the CSS files have their
+ *   `/control/...` references rewritten to `/control/...?v=<hash>`.
+ * - A request whose `?v=` matches the current hash is cached for a year as `immutable`.
+ *   Anything else (index.html, a stale or missing `?v=`) is `no-cache`, so it revalidates
+ *   with its ETag and a new release is picked up on the next open.
+ * - Text assets are served brotli or gzip compressed when the browser accepts it. The
+ *   compressed bytes are built on first request and kept in memory.
+ * - Files on disk are re-checked at most once per `recheckMs`, so a test copy served from
+ *   a worktree picks up edits without a restart.
+ *
+ * Anything not in the table (a path this walker skips) falls through to `next()`, and the
+ * caller keeps `express.static` behind it, so no URL that worked before stops working.
+ */
+import crypto from 'crypto'
+import fs from 'fs'
+import path from 'path'
+import zlib from 'zlib'
+import type { NextFunction, Request, RequestHandler, Response } from 'express'
+
+/** A versioned URL's lifetime. Safe because the hash changes whenever the bytes do. */
+export const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable'
+/** Unversioned and HTML responses: always revalidate, so a new release shows on the next open. */
+export const REVALIDATE_CACHE = 'no-cache'
+
+const TYPES: Record<string, string> = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.json': 'application/json; charset=utf-8',
+  '.ttf': 'font/ttf',
+  '.woff2': 'font/woff2',
+  '.png': 'image/png',
+  '.webp': 'image/webp',
+  '.jpg': 'image/jpeg',
+}
+/** Worth compressing. WOFF2 and images are already compressed. */
+const COMPRESSIBLE = new Set(['.html', '.js', '.css', '.svg', '.json', '.ttf'])
+/** Files whose `/control/...` references are rewritten to versioned URLs. */
+const REWRITTEN = new Set(['.html', '.css'])
+/** Only assets of these types get a versioned URL; HTML pages are always revalidated. */
+const VERSIONABLE = new Set(['.js', '.css', '.svg', '.json', '.ttf', '.woff2', '.png', '.webp', '.jpg'])
+
+export interface WebAsset {
+  /** Path under the mount, with a leading slash: `/panes/work.js`. */
+  urlPath: string
+  ext: string
+  type: string
+  body: Buffer
+  /** First 16 hex characters of the SHA-256 of `body` (after any rewrite). */
+  hash: string
+  gzip?: Promise<Buffer>
+  br?: Promise<Buffer>
+}
+
+export type WebAssetTable = Map<string, WebAsset>
+
+/** Dotfiles are never served. Sources (`.ts`) and maps stay out because TYPES does not list them. */
+function skip(name: string): boolean {
+  return name.startsWith('.')
+}
+
+function walk(dir: string, base = ''): Array<{ urlPath: string; file: string; stat: fs.Stats }> {
+  const out: Array<{ urlPath: string; file: string; stat: fs.Stats }> = []
+  let names: string[]
+  try { names = fs.readdirSync(dir) } catch { return out }
+  for (const name of names.sort()) {
+    if (skip(name)) continue
+    const file = path.join(dir, name)
+    let stat: fs.Stats
+    try { stat = fs.statSync(file) } catch { continue }
+    const urlPath = `${base}/${name}`
+    if (stat.isDirectory()) out.push(...walk(file, urlPath))
+    else if (stat.isFile() && TYPES[path.extname(name).toLowerCase()]) out.push({ urlPath, file, stat })
+  }
+  return out
+}
+
+/** A cheap fingerprint of the tree: every path, size and mtime. */
+export function treeSignature(dir: string): string {
+  return walk(dir).map((f) => `${f.urlPath}:${f.stat.size}:${f.stat.mtimeMs}`).join('|')
+}
+
+function sha(body: Buffer): string {
+  return crypto.createHash('sha256').update(body).digest('hex').slice(0, 16)
+}
+
+/**
+ * Rewrite `/control/<path>` references (quoted, or inside `url(...)`) to carry `?v=<hash>`.
+ * Only references to a known, versionable asset are touched; a reference that already has a
+ * query string, or names a file that does not exist, is left exactly as written.
+ */
+export function rewriteReferences(text: string, mount: string, hashes: Map<string, string>): string {
+  const prefix = mount.replace(/\/$/, '')
+  const re = new RegExp(`(["'(])${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(/[A-Za-z0-9_./-]+)(["')])`, 'g')
+  return text.replace(re, (whole, open: string, rel: string, close: string) => {
+    const hash = hashes.get(rel)
+    if (!hash || !VERSIONABLE.has(path.extname(rel).toLowerCase())) return whole
+    return `${open}${prefix}${rel}?v=${hash}${close}`
+  })
+}
+
+/**
+ * Build the table. Leaves (JS, fonts, images) are hashed first, then CSS is rewritten against
+ * them and hashed, then HTML is rewritten against everything. So a font change gives its CSS a
+ * new hash, and that gives index.html new references.
+ */
+export function buildWebAssetTable(dir: string, mount = '/control'): WebAssetTable {
+  const files = walk(dir)
+  const hashes = new Map<string, string>()
+  const table: WebAssetTable = new Map()
+  const read = (file: string): Buffer | null => { try { return fs.readFileSync(file) } catch { return null } }
+  const add = (urlPath: string, ext: string, body: Buffer): void => {
+    const hash = sha(body)
+    hashes.set(urlPath, hash)
+    table.set(urlPath, { urlPath, ext, type: TYPES[ext], body, hash })
+  }
+  const pass = (pick: (ext: string) => boolean): void => {
+    for (const f of files) {
+      const ext = path.extname(f.urlPath).toLowerCase()
+      if (!pick(ext)) continue
+      const raw = read(f.file)
+      if (!raw) continue
+      const body = REWRITTEN.has(ext) ? Buffer.from(rewriteReferences(raw.toString('utf8'), mount, hashes), 'utf8') : raw
+      add(f.urlPath, ext, body)
+    }
+  }
+  pass((ext) => !REWRITTEN.has(ext))
+  pass((ext) => ext === '.css')
+  pass((ext) => ext === '.html')
+  return table
+}
+
+/** Which encoding to send: brotli, then gzip, then none. `q=0` refuses an encoding. */
+export function pickEncoding(acceptEncoding: string | undefined): 'br' | 'gzip' | null {
+  const accepted = new Map<string, number>()
+  for (const part of String(acceptEncoding || '').toLowerCase().split(',')) {
+    const [name, ...params] = part.trim().split(';')
+    if (!name) continue
+    const q = params.map((p) => p.trim()).find((p) => p.startsWith('q='))
+    accepted.set(name.trim(), q ? Number(q.slice(2)) || 0 : 1)
+  }
+  const ok = (name: string): boolean => (accepted.get(name) ?? accepted.get('*') ?? 0) > 0
+  if (ok('br')) return 'br'
+  if (ok('gzip')) return 'gzip'
+  return null
+}
+
+function compressed(asset: WebAsset, encoding: 'br' | 'gzip'): Promise<Buffer> {
+  if (encoding === 'br') {
+    asset.br ??= new Promise((resolve, reject) => zlib.brotliCompress(asset.body, {
+      params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 9, [zlib.constants.BROTLI_PARAM_SIZE_HINT]: asset.body.length },
+    }, (err, out) => (err ? reject(err) : resolve(out))))
+    return asset.br
+  }
+  asset.gzip ??= new Promise((resolve, reject) => zlib.gzip(asset.body, { level: 9 }, (err, out) => (err ? reject(err) : resolve(out))))
+  return asset.gzip
+}
+
+export interface WebControlStaticOptions {
+  mount?: string
+  /** How often the tree is re-checked for edits. 0 checks on every request. */
+  recheckMs?: number
+  now?: () => number
+}
+
+export function createWebControlStatic(dir: string, opts: WebControlStaticOptions = {}): RequestHandler & { table: () => WebAssetTable } {
+  const mount = opts.mount ?? '/control'
+  const recheckMs = opts.recheckMs ?? 1000
+  const now = opts.now ?? Date.now
+  let signature = treeSignature(dir)
+  let table = buildWebAssetTable(dir, mount)
+  let checkedAt = now()
+
+  const current = (): WebAssetTable => {
+    if (now() - checkedAt >= recheckMs) {
+      checkedAt = now()
+      const next = treeSignature(dir)
+      if (next !== signature) { signature = next; table = buildWebAssetTable(dir, mount) }
+    }
+    return table
+  }
+
+  const handler = (req: Request, res: Response, next: NextFunction): void => {
+    if (req.method !== 'GET' && req.method !== 'HEAD') { next(); return }
+    let urlPath = req.path || '/'
+    if (urlPath.endsWith('/')) urlPath += 'index.html'
+    const asset = current().get(urlPath)
+    if (!asset) { next(); return }
+
+    const versioned = VERSIONABLE.has(asset.ext) && req.query.v === asset.hash
+    const encoding = COMPRESSIBLE.has(asset.ext) ? pickEncoding(req.headers['accept-encoding'] as string | undefined) : null
+    const etag = `"${asset.hash}${encoding ? `-${encoding}` : ''}"`
+    res.setHeader('Content-Type', asset.type)
+    res.setHeader('Cache-Control', versioned ? IMMUTABLE_CACHE : REVALIDATE_CACHE)
+    res.setHeader('ETag', etag)
+    if (COMPRESSIBLE.has(asset.ext)) res.setHeader('Vary', 'Accept-Encoding')
+
+    const inm = String(req.headers['if-none-match'] || '')
+    if (inm && inm.split(',').map((t) => t.trim().replace(/^W\//, '')).includes(etag)) { res.status(304).end(); return }
+
+    const send = (body: Buffer): void => {
+      if (encoding) res.setHeader('Content-Encoding', encoding)
+      res.setHeader('Content-Length', String(body.length))
+      if (req.method === 'HEAD') res.end(); else res.end(body)
+    }
+    if (!encoding) { send(asset.body); return }
+    compressed(asset, encoding).then(send, () => {
+      // Compression failed: send the plain bytes rather than nothing.
+      res.removeHeader('Content-Encoding')
+      res.setHeader('ETag', `"${asset.hash}"`)
+      res.setHeader('Content-Length', String(asset.body.length))
+      if (req.method === 'HEAD') res.end(); else res.end(asset.body)
+    })
+  }
+  return Object.assign(handler, { table: current })
+}

package/server/lib/web-memories-bridge.ts

@@ -306,14 +306,15 @@ export async function dispatchMemoriesWebOp(
       return r.status === 200 ? reply(true, 'Duplicates ready', r.body) : reply(false, r.body.message || r.body.error || 'Failed')
     }
     case 'cues.summary': {
-      // Rating cues opens Control's native cue pane, which the browser does not have, so the
-      // page is told cues are unavailable and hides "Cues to rate" rather than show a button
-      // that does nothing. The counts use Control's keys for when a web cue pane exists.
-      const r = await loopbackFetch('/api/live-cues/history?days=7&limit=200', { timeoutMs: 10_000 })
-      const counts = (r.status === 200 ? r.body.counts ?? {} : {}) as Record<string, any>
-      const unrated = typeof counts.unrated === 'number' ? counts.unrated : 0
-      const rated = typeof counts.rated === 'number' ? counts.rated : 0
-      return reply(true, 'Cues', { available: false, unrated, rated, total: unrated + rated })
+      // Control's CueVerdicts.summary: the cue history read is the capability check. A 200 in the v1 contract means the
+      // server keeps the cue log and verdicts, and COS Control Web rates them in Memories (Cues to rate, Rated cues), so
+      // the answer is available with the week's counts; anything else is unavailable and the entries hide.
+      const r = await loopbackFetch('/api/live-cues/history?days=7&unrated=1&limit=1', { timeoutMs: 10_000 })
+      const counts = (r.status === 200 && r.body.v === 1 ? r.body.counts ?? null : null) as Record<string, any> | null
+      if (!counts || typeof counts.unrated !== 'number' || typeof counts.rated !== 'number' || typeof counts.total !== 'number') {
+        return reply(true, 'Cues', { available: false })
+      }
+      return reply(true, 'Cues', { available: true, unrated: counts.unrated, rated: counts.rated, total: counts.total })
     }
     case 'copy':
       return reply(true, 'Copied', {})