fix(files): stop promising immutable caching for documents compiled against other files - #8129
Conversation
…gainst other files A versioned serve URL (`?v=<updatedAt>`) was always answered with a one-year `immutable` Cache-Control. That holds for a stored source — a content write rotates the storage key, so a given key's bytes never change — but not for a response the route resolves against OTHER files: a document compiled against the files it references, or a sim page inlining its images, recompiles on every request. Those bytes change when a referenced file changes, while this file's key and `updatedAt` stay put, so the whole URL is unchanged and the browser served a stale render from cache until the document itself was edited. The resolver now reports when it read referenced content, and the route withholds the immutable lifetime for exactly those responses, keeping it for stored sources and self-contained artifacts. Also corrects three comments that claimed generated docs are edited in place under the same storage key. That stopped being true in #5545 (2026-07-13), which made every content write allocate a new key; the caching rule above was reasoned from the stale claim.
|
The latest updates on your projects. Learn more about Vercel for GitHub. |
|
…erty An optional boolean let a branch added to the resolver inherit the cacheable default by saying nothing — the exact failure this change exists to prevent. Cacheability is now a required field every branch must declare, so forgetting it fails the build rather than silently promising a year of immutability.
…e whole body A response the browser is told to revalidate carried no validator, so every check re-sent the entire file. That is the cost a document compiled against other files now pays on each window focus: it cannot be given a cache lifetime, because its bytes really may have changed, so the only way to make the check cheap is to let the client prove what it already holds. Authorized serves now carry an ETag — the digest of the bytes about to be sent, which is exact by construction however those bytes were produced — and answer 304 to a matching If-None-Match. Matching is weak, per RFC 9110, so a cache that stored a weak validator still revalidates. Kept out of createFileResponse deliberately: digesting costs a pass over the buffer, up to the 100MB transfer ceiling, and a response served as immutable is never revalidated, so it would pay that pass and never collect. Public assets and the assistant-image path are unchanged.
…e path The isolated-VM fallback returns before the static reference scan, so a document it compiled never reported one — yet that path reads workspace files live through its broker, which is what `onWorkspaceFileAccess` records. A versioned request for such a document therefore still took a one-year immutable lifetime, and changing a referenced file left the browser serving a stale render. Fixed at the root rather than in that one branch: the flag is now required on CompiledDocResult, so every compile path must declare it and a new one cannot inherit a cacheable-forever answer by staying silent. Each site reports the union of what the source references statically and what the compile actually touched — neither alone is sufficient, since a failed read records no access and the broker reaches files the static scan cannot see. Making it required immediately surfaced a second case: the process-local compile cache is shared with compiles that carried a workspace, so a cached entry can hold contributor identities even when the reading call passes none. That branch now reads the cached identities instead of assuming independence.
|
@cubic-dev-ai review this PR |
@waleedlatif1 I have started the AI code review. It will take a few minutes to complete. |
There was a problem hiding this comment.
All reported issues were addressed across 8 files
Reply with feedback, questions, or to request a fix.
Fix all with cubic | Re-trigger cubic
…revalidated Both reviewers caught the same contradiction: the digest was documented as worth paying only where a 304 can be collected, then applied to every authorized serve including immutable ones, which are never revalidated. One place now decides, so an immutable response takes the plain path and spends no pass over its buffer. Also drops a redundant translation. The resolver was converting the compiler's boolean into a string union and the cache rule was converting it straight back; the producer's own required boolean now travels end to end, which is one fact in one shape and keeps the same build-time guarantee that a new branch must declare it.
|
@cubic-dev-ai review this PR |
@waleedlatif1 I have started the AI code review. It will take a few minutes to complete. |
Summary
?v=<updatedAt>) was always answered with a one-yearimmutableCache-Control. That is right for a stored source — a content write rotates the storage key, so a given key's bytes never change — but wrong for a response resolved against OTHER files: a document compiled against the files it references, or a sim page inlining its images, is re-resolved on every requestupdatedAtstay put — so the URL is unchanged and the browser keeps serving a stale render until the document itself is editedIf-None-Match— the focus refetch costs a conditional request instead of the whole file. Matching is weak, per RFC 9110Notes
createFileResponse: it costs a pass over the buffer (up to the 100MB transfer ceiling) and an immutable response is never revalidated, so it would pay that pass and never collect. Public assets and the assistant-image path are unchangedType of Change
Testing
Route tests cover both cache lifetimes; unit tests cover the validator, the 304, weak matching, list and wildcard matching, and validator uniqueness. Each new test was verified to fail against the previous behavior, and the required-cacheability gate was verified to fail the build when a branch omits it.
apps/simtype-check, lint, 47 audits, docs-manifest check, and 340 tests across the files, workspace-files hook, and copilot doc suites pass.Checklist