multiple fixes

Author: icecrasher321

apps/sim/app/api/files/serve/[...path]/route.ts

@@ -153,6 +153,24 @@ function getWorkspaceIdForCompile(key: string): string | undefined {
   return parseWorkspaceFileKey(key) ?? undefined
 }
 
+const IMMUTABLE_CACHE_CONTROL = 'private, max-age=31536000, immutable'
+const WORKSPACE_REVALIDATE_CACHE_CONTROL = 'private, no-cache, must-revalidate'
+
+/**
+ * Cache-Control for a served file. A versioned request (`?v=<updatedAt>`) addresses
+ * content-immutable bytes — generated docs are content-addressed and the version
+ * bumps on every edit — so the browser may cache it indefinitely; re-opens and
+ * focus refetches then resolve from cache with no round trip. Unversioned workspace
+ * reads stay revalidated because the same storage key is edited in place.
+ */
+function resolveServeCacheControl(
+  versioned: boolean,
+  context: string | undefined
+): string | undefined {
+  if (versioned) return IMMUTABLE_CACHE_CONTROL
+  return context === 'workspace' ? WORKSPACE_REVALIDATE_CACHE_CONTROL : undefined
+}
+
 export const GET = withRouteHandler(
   async (request: NextRequest, { params }: { params: Promise<{ path: string[] }> }) => {
     try {
@@ -190,8 +208,10 @@ export const GET = withRouteHandler(
 
       const query = fileServeQuerySchema.parse({
         raw: request.nextUrl.searchParams.get('raw'),
+        v: request.nextUrl.searchParams.get('v'),
       })
       const raw = query.raw === '1'
+      const versioned = query.v != null
 
       const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
 
@@ -206,10 +226,10 @@ export const GET = withRouteHandler(
       const userId = authResult.userId
 
       if (isUsingCloudStorage()) {
-        return await handleCloudProxy(cloudKey, userId, raw, request.signal)
+        return await handleCloudProxy(cloudKey, userId, raw, versioned, request.signal)
       }
 
-      return await handleLocalFile(cloudKey, userId, raw, request.signal)
+      return await handleLocalFile(cloudKey, userId, raw, versioned, request.signal)
     } catch (error) {
       // An in-progress/incomplete doc source fails to compile — this is expected
       // mid-generation, not a server fault. Return 409 (not 500) so it isn't an
@@ -237,6 +257,7 @@ async function handleLocalFile(
   filename: string,
   userId: string,
   raw: boolean,
+  versioned: boolean,
   signal: AbortSignal | undefined
 ): Promise<NextResponse> {
   const ownerKey = `user:${userId}`
@@ -283,7 +304,7 @@ async function handleLocalFile(
       buffer: fileBuffer,
       contentType,
       filename: displayName,
-      cacheControl: contextParam === 'workspace' ? 'private, no-cache, must-revalidate' : undefined,
+      cacheControl: resolveServeCacheControl(versioned, contextParam),
     })
   } catch (error) {
     logger.error('Error reading local file:', error)
@@ -295,6 +316,7 @@ async function handleCloudProxy(
   cloudKey: string,
   userId: string,
   raw = false,
+  versioned = false,
   signal: AbortSignal | undefined = undefined
 ): Promise<NextResponse> {
   const ownerKey = `user:${userId}`
@@ -349,7 +371,7 @@ async function handleCloudProxy(
       buffer: fileBuffer,
       contentType,
       filename: displayName,
-      cacheControl: context === 'workspace' ? 'private, no-cache, must-revalidate' : undefined,
+      cacheControl: resolveServeCacheControl(versioned, context),
     })
   } catch (error) {
     logger.error('Error downloading from cloud storage:', error)

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/use-doc-preview-binary.test.ts

@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { resolveDocPreviewBinary } from './use-doc-preview-binary'
+import { resolveDocPreviewBinary, stepDocPreviewBinary } from './use-doc-preview-binary'
 
 function buffer(byte: number): ArrayBuffer {
   return new Uint8Array([byte]).buffer
@@ -94,3 +94,91 @@ describe('resolveDocPreviewBinary', () => {
     expect(result.error).toBe(err)
   })
 })
+
+describe('stepDocPreviewBinary', () => {
+  it('shows loading for a committed file whose first fetch has not resolved', () => {
+    const step = stepDocPreviewBinary({
+      fileChanged: false,
+      data: undefined,
+      isPlaceholderData: false,
+      error: null,
+      hasCommittedContent: true,
+      prevHasResolvedForFile: false,
+      prevLastGood: null,
+    })
+
+    expect(step.resolved.state).toBe('loading')
+    expect(step.hasResolvedForFile).toBe(false)
+    expect(step.lastGood).toBeNull()
+  })
+
+  it('advances the head and records resolution on a fresh success', () => {
+    const fresh = buffer(1)
+    const step = stepDocPreviewBinary({
+      fileChanged: false,
+      data: fresh,
+      isPlaceholderData: false,
+      error: null,
+      hasCommittedContent: true,
+      prevHasResolvedForFile: false,
+      prevLastGood: null,
+    })
+
+    expect(step.resolved.state).toBe('ready')
+    expect(step.resolved.data).toBe(fresh)
+    expect(step.hasResolvedForFile).toBe(true)
+    expect(step.lastGood).toBe(fresh)
+  })
+
+  it('ignores the prior-file placeholder on a file change (no cross-file bleed)', () => {
+    const priorFileBytes = buffer(1)
+    const step = stepDocPreviewBinary({
+      fileChanged: true,
+      data: priorFileBytes,
+      isPlaceholderData: true,
+      error: null,
+      hasCommittedContent: true,
+      prevHasResolvedForFile: true,
+      prevLastGood: priorFileBytes,
+    })
+
+    expect(step.resolved.state).toBe('loading')
+    expect(step.resolved.data).toBeNull()
+    expect(step.hasResolvedForFile).toBe(false)
+    expect(step.lastGood).toBeNull()
+  })
+
+  it('holds the previous version as stale during a same-file recompile', () => {
+    const v1 = buffer(1)
+    const step = stepDocPreviewBinary({
+      fileChanged: false,
+      data: v1,
+      isPlaceholderData: true,
+      error: null,
+      hasCommittedContent: true,
+      prevHasResolvedForFile: true,
+      prevLastGood: v1,
+    })
+
+    expect(step.resolved.state).toBe('stale')
+    expect(step.resolved.data).toBe(v1)
+    expect(step.hasResolvedForFile).toBe(true)
+  })
+
+  it('keeps the last good binary and suppresses the error after a failed refetch', () => {
+    const v1 = buffer(1)
+    const step = stepDocPreviewBinary({
+      fileChanged: false,
+      data: undefined,
+      isPlaceholderData: false,
+      error: new Error('boom'),
+      hasCommittedContent: true,
+      prevHasResolvedForFile: true,
+      prevLastGood: v1,
+    })
+
+    expect(step.resolved.state).toBe('stale')
+    expect(step.resolved.data).toBe(v1)
+    expect(step.resolved.error).toBeNull()
+  })
+})

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/use-doc-preview-binary.ts

@@ -67,6 +67,52 @@ export function resolveDocPreviewBinary({
   }
 }
 
+interface DocPreviewStepArgs {
+  fileChanged: boolean
+  data: ArrayBuffer | undefined
+  isPlaceholderData: boolean
+  error: Error | null
+  hasCommittedContent: boolean
+  prevHasResolvedForFile: boolean
+  prevLastGood: ArrayBuffer | null
+}
+
+interface DocPreviewStep {
+  resolved: ResolvedDocPreview
+  hasResolvedForFile: boolean
+  lastGood: ArrayBuffer | null
+}
+
+/**
+ * Pure per-render step for {@link useDocPreviewBinary}: folds the prior last-good
+ * binary and the "has a fresh binary resolved for this file yet" flag with the
+ * current query result. On a file change the prior file's last-good and resolved
+ * flag are dropped, and the keep-previous placeholder (which still holds the prior
+ * file's bytes) is ignored until a fresh binary resolves for the new file.
+ */
+export function stepDocPreviewBinary({
+  fileChanged,
+  data,
+  isPlaceholderData,
+  error,
+  hasCommittedContent,
+  prevHasResolvedForFile,
+  prevLastGood,
+}: DocPreviewStepArgs): DocPreviewStep {
+  const lastGood = fileChanged ? null : prevLastGood
+  const hasResolvedForFile =
+    (fileChanged ? false : prevHasResolvedForFile) || (Boolean(data) && !isPlaceholderData)
+  const placeholderFromPriorFile = isPlaceholderData && !hasResolvedForFile
+  const resolved = resolveDocPreviewBinary({
+    data: placeholderFromPriorFile ? undefined : data,
+    isPlaceholderData,
+    error,
+    lastGood,
+    hasCommittedContent,
+  })
+  return { resolved, hasResolvedForFile, lastGood: resolved.lastGood }
+}
+
 /**
  * Resolves the compiled binary to render for a generated or uploaded document and
  * retains the last successfully fetched binary as a fallback.
@@ -89,30 +135,27 @@ export function useDocPreviewBinary(workspaceId: string, file: DocPreviewFile):
   const lastGoodRef = useRef<ArrayBuffer | null>(null)
   const fileIdRef = useRef(file.id)
   const hasResolvedForFileRef = useRef(false)
-  if (fileIdRef.current !== file.id) {
+  const fileChanged = fileIdRef.current !== file.id
+  if (fileChanged) {
     fileIdRef.current = file.id
-    lastGoodRef.current = null
-    hasResolvedForFileRef.current = false
-  }
-  if (query.data && !query.isPlaceholderData) {
-    hasResolvedForFileRef.current = true
   }
 
-  const placeholderFromPriorFile = query.isPlaceholderData && !hasResolvedForFileRef.current
-
-  const resolved = resolveDocPreviewBinary({
-    data: placeholderFromPriorFile ? undefined : query.data,
+  const step = stepDocPreviewBinary({
+    fileChanged,
+    data: query.data,
     isPlaceholderData: query.isPlaceholderData,
     error: (query.error as Error | null) ?? null,
-    lastGood: lastGoodRef.current,
     hasCommittedContent: (file.size ?? 0) > 0,
+    prevHasResolvedForFile: hasResolvedForFileRef.current,
+    prevLastGood: lastGoodRef.current,
   })
-  lastGoodRef.current = resolved.lastGood
+  hasResolvedForFileRef.current = step.hasResolvedForFile
+  lastGoodRef.current = step.lastGood
 
   return {
-    data: resolved.data,
-    state: resolved.state,
-    error: resolved.error,
+    data: step.resolved.data,
+    state: step.resolved.state,
+    error: step.resolved.error,
     dataUpdatedAt: query.dataUpdatedAt,
   }
 }