fix(files): publish a stable file-doc flush and trace its outcome

The published flush was bound to the provider's identity, so every socket churn
republished it — and a churn ending on null left the file-detail header with
nothing to call, silently degrading a retype back to a stale read. It now
publishes once and resolves the provider at call time.

Adds a log on both sides of the flush. Its outcome decides whether the caller may
treat the durable bytes as current, and unchanged/skipped are both silent
no-writes, so a stale read after a retype is otherwise indistinguishable from a
rendering bug.

Author: mzxchandra

apps/realtime/src/handlers/file-doc.ts

@@ -1304,6 +1304,12 @@ export function setupWorkspaceFileDocHandlers(
       room.persistDeadline = null
 
       const outcome = await flushPersist(name, room, 'requested')
+      // The caller's next step depends on this outcome, and `unchanged`/`skipped` are both silent
+      // no-writes — worth a line so a stale read after a retype can be traced without a repro.
+      logger.info(`Requested flush for file ${fileId}: ${outcome.status}`, {
+        edited: room.edited,
+        hasWorkspace: Boolean(room.workspaceId),
+      })
       ack(outcome.status, outcome.status === 'persisted' ? outcome.version : undefined)
     } catch (error) {
       logger.error('Error flushing file-doc room:', error)

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/collaboration/use-file-doc-collaboration.ts

@@ -1,6 +1,6 @@
 'use client'
 
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { FILE_DOC_EVENTS, type FileDocPresence } from '@sim/realtime-protocol/file-doc'
 import { Awareness } from 'y-protocols/awareness'
 import * as Y from 'yjs'
@@ -110,10 +110,25 @@ export function useFileDocCollaboration({
     }
   }, [enabled, socket, fileId])
 
-  // Publish this document's flush so the file-detail header can force durability before it reads the
-  // file's stored bytes back (changing the file's type unmounts this editor and swaps in one that
-  // reads them). Cleared with the provider, so it can never outlive the socket it wraps.
-  useReportFileDocFlush(useMemo(() => (provider ? () => provider.flush() : null), [provider]))
+  /**
+   * Publish this document's flush so the file-detail header can force durability before it reads the
+   * file's stored bytes back (changing the file's type unmounts this editor and swaps in one that
+   * reads them).
+   *
+   * The published function is STABLE and resolves the provider at call time through a ref. Binding it
+   * to the provider's identity instead looked equivalent and was not: the provider is torn down and
+   * rebuilt on every socket change, so each churn republished — and any churn ending on `null` left
+   * the header with nothing to call, silently degrading the retype back to a stale read. A stable
+   * identity publishes once and always sees the live provider.
+   */
+  const providerRef = useRef<FileDocProvider | null>(null)
+  providerRef.current = provider
+  useReportFileDocFlush(
+    useCallback(
+      () => providerRef.current?.flush() ?? Promise.resolve({ fileId, status: 'skipped' as const }),
+      [fileId]
+    )
+  )
 
   const reportOthers = useReportFileDocOthers()
   const reportOthersRef = useRef(reportOthers)

apps/sim/app/workspace/[workspaceId]/files/files.tsx

@@ -1238,7 +1238,15 @@ export function Files() {
       if (type.mimeType === file.type && nextName === file.name) return
 
       if (isDirtyRef.current) await saveRef.current?.()
-      await flushFileDocRef(fileDocFlushRef)
+      const flushed = await flushFileDocRef(fileDocFlushRef)
+      if (flushed.status !== 'persisted') {
+        // Not an error — `unchanged` means there was nothing to write, and `skipped` means the write
+        // did not land in time. The retype proceeds either way; this is the breadcrumb for a stale
+        // first paint, which is otherwise indistinguishable from a rendering bug.
+        logger.info('Changing file type without a confirmed durable flush', {
+          status: flushed.status,
+        })
+      }
 
       const siblingNames = new Set(
         filesRef.current