Use nanosecond mtime for workspace file ETag

The `/fs/` validator was size + millisecond mtime (`Math.trunc`). This
route serves agent-regenerated files at stable paths, so a same-length
rewrite landing inside one millisecond tick kept an identical validator
and the new `no-cache` 304 path would pin stale media in the browser.

Switch to size + nanosecond mtime via `statSync(path, { bigint: true })`,
which closes the realistic rapid-rewrite window without hashing the
(possibly huge) file on every request. A tool that deliberately preserves
mtime with same-size/different bytes could still collide — only a content
hash defeats that, and re-reading a video per request isn't worth it when
agents rewrite files normally.

Addresses PR review feedback.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FpGBXW5iHAsc8K2543Z7BU

Author: claude

server/applets.ts

@@ -12,7 +12,7 @@
 // `%%MOI_APPLET_API_BASE%%` sentinel (for RPC + `fileUrl`), swapped to the real
 // `/api/workspaces/<id>` base when served — so the on-disk bundle is
 // workspace-agnostic.
-import { realpathSync } from 'node:fs'
+import { realpathSync, statSync } from 'node:fs'
 import { mkdir, readdir, rm } from 'node:fs/promises'
 import { dirname, join, resolve, sep } from 'path'
 
@@ -303,8 +303,8 @@ export function resolveWorkspaceMediaFile(workspaceRoot: string, tail: string):
 // stored by a shared/edge cache sitting in front of moi, or one user's video
 // could be served to the next, and an edited file could be served stale from a
 // stable url (the applet-bundle incident, but with private bytes). `private`
-// keeps them off the edge; an ETag (size+mtime) + `no-cache` lets the browser
-// revalidate cheaply (304) while guaranteeing a re-fetch when the file changes.
+// keeps them off the edge; a strong ETag (size + nanosecond mtime) + `no-cache`
+// lets the browser revalidate cheaply (304) while re-fetching when it changes.
 export async function serveWorkspaceFile(
   workspaceRoot: string,
   tail: string,
@@ -315,10 +315,24 @@ export async function serveWorkspaceFile(
   if (realTarget instanceof Response) return realTarget
   const file = Bun.file(realTarget)
 
-  const size = file.size
+  let stat: ReturnType<typeof statSync>
+  try {
+    stat = statSync(realTarget, { bigint: true })
+  } catch {
+    return new Response('Not found', { status: 404 })
+  }
+  const size = Number(stat.size)
   const type = file.type || 'application/octet-stream'
 
-  const etag = `"${size}-${Math.trunc(file.lastModified)}"`
+  // Validator = size + NANOSECOND mtime. This route serves agent-regenerated
+  // files at stable paths, so a weak validator that returns a false 304 pins
+  // stale media in the browser. Truncating mtime to whole milliseconds (or
+  // seconds) can collide when a same-length rewrite lands inside one tick; ns
+  // resolution closes that window without hashing the (possibly huge) file on
+  // every request. A tool that deliberately preserves mtime with same-size but
+  // different bytes could still collide — only a content hash defeats that, and
+  // it's not worth re-reading a video per request when agents rewrite normally.
+  const etag = `"${size}-${stat.mtimeNs}"`
   const cache = { ETag: etag, 'Cache-Control': 'private, no-cache' }
   if (ifNoneMatch === etag) return new Response(null, { status: 304, headers: cache })
 

server/test/applets.test.ts

@@ -237,6 +237,28 @@ describe('serveWorkspaceFile (fileUrl streaming)', () => {
     expect(await revalidated.text()).toBe('')
   })
 
+  test('workspace ETag uses nanosecond mtime — survives sub-millisecond rewrites', async () => {
+    // The file is agent-regenerated at a stable path, so a coarse validator can
+    // return a false 304 and pin stale media. Guard the resolution: a nanosecond
+    // epoch timestamp is ~19 digits, a millisecond one ~13, so a revert to
+    // `Math.trunc(mtimeMs)` (which could collide on a same-length rewrite inside
+    // one tick) is caught here.
+    seedFile('clips/a.mp4', new Uint8Array([1, 2, 3, 4]))
+    const res = await serveWorkspaceFile(WS, 'clips/a.mp4')
+    const mtimePart = res.headers.get('etag')!.replace(/"/g, '').split('-')[1]
+    expect(mtimePart.length).toBeGreaterThanOrEqual(16)
+  })
+
+  test('a same-length rewrite changes the ETag (no false 304)', async () => {
+    seedFile('clips/a.mp4', new Uint8Array([1, 2, 3, 4]))
+    const etag1 = (await serveWorkspaceFile(WS, 'clips/a.mp4')).headers.get('etag')!
+    // Overwrite with DIFFERENT bytes of the SAME length — the reviewer's case.
+    seedFile('clips/a.mp4', new Uint8Array([9, 8, 7, 6]))
+    const res = await serveWorkspaceFile(WS, 'clips/a.mp4', undefined, etag1)
+    expect(res.status).toBe(200) // the stale validator must not win a 304
+    expect(res.headers.get('etag')).not.toBe(etag1)
+  })
+
   test('a range request still carries the private cache headers', async () => {
     seedFile('clips/a.mp4', new Uint8Array([10, 11, 12, 13, 14, 15]))
     const res = await serveWorkspaceFile(WS, 'clips/a.mp4', 'bytes=1-3')