fix(files, chat): contain the media work's blast radius

Each of these is a side-effect of a deliberate change reaching further than the
change needed. The features stay; what they touched by accident is put back.

- Config files download again. Resolving unknown extensions through the
  canonical MIME table is what makes byte-range serving work, but it also
  promoted .env/.log/.conf/.ini/.cfg from "unknown bytes" to text/plain, which
  is on the inline allowlist — a shared .env started rendering in the tab
  instead of downloading. Those five join FORCE_ATTACHMENT_EXTENSIONS, so the
  MIME resolution stays honest and the disposition stays what it was. Verified
  these are the only five of the 47 newly-typed extensions that flipped.

- The aggregate per-share ceiling is charged once per read, not once per seek.
  It is shared by every visitor to a link, so counting each range request let
  one person scrubbing a shared video 429 everyone else. The audit row beside it
  already deduped seeks; both now use one `isReadStart` predicate rather than
  two copies of the same string test that can drift apart.

- MediaPreview clears a decode failure when the bytes change. It is keyed on
  `file.id`, which is stable across content edits, so one transient error wedged
  the player until the viewer opened a different file. Adjusted during render,
  the same pattern the markdown image node view uses.

- The chat-trigger attachment guard accepts `dataUrl`, the preferred inline
  field, not just the legacy `data`. `processChatFiles` reads `dataUrl || data`,
  so testing only `data` skipped the upload for every current client and dropped
  its attachments silently — the exact failure the guard was added to prevent.

- The navbar sticks below the macOS traffic-light lane instead of the viewport.
  Every shell mounting it wears `.desktop-title-bar-page`, which reserves the
  lane with padding, but sticky positions against the scroll port — so the bar
  slid under the traffic lights on scroll. The variable is 0px off-desktop.

- The wordmark opens in a new tab on the deployed chat and the public file page.
  Reusing the landing navbar turned those two from `sim.ai` in a new tab into
  same-origin `/` in the same tab, so clicking the logo mid-conversation
  navigated away and destroyed it. `/` is the better href — self-hosters get
  their own landing — so only the target moves back, behind one `brandInNewTab`
  prop for surfaces hosting something the viewer would lose.

Author: waleedlatif1

apps/sim/app/(interfaces)/chat/components/header/header.tsx

@@ -35,6 +35,7 @@ export function ChatHeader({ chatConfig }: ChatHeaderProps) {
   return (
     <Navbar
       logoOnly
+      brandInNewTab
       name={title}
       meta={buildSharedByLabel(chatConfig?.sharedByName ?? null)}
       hideBrand={Boolean(brand.logoUrl)}

apps/sim/app/(landing)/components/navbar/components/navbar-shell/navbar-shell.tsx

@@ -94,7 +94,15 @@ export function NavbarShell({ children }: NavbarShellProps) {
   return (
     <NavbarFrostContext value={frost}>
       <div ref={sentinelRef} aria-hidden='true' className='-mb-px h-px' />
-      <header className='sticky top-0 z-50'>
+      {/*
+        Sticks below the macOS traffic-light lane, not to the viewport. Every shell
+        that mounts this navbar wears `.desktop-title-bar-page`, which reserves the
+        lane with `padding-top` — but sticky positions against the scroll port, so a
+        plain `top-0` slides the bar under the traffic lights the moment the page
+        scrolls. The variable is `0px` everywhere except the desktop app, so this is
+        `top: 0` on the web.
+      */}
+      <header className='sticky top-[var(--desktop-title-bar-height)] z-50'>
         <div
           aria-hidden='true'
           className={cn(

apps/sim/app/(landing)/components/navbar/navbar.tsx

@@ -92,6 +92,16 @@ interface NavbarProps {
    * Download chip) — the minimal surfaces' equivalent of the marketing CTAs.
    */
   actions?: ReactNode
+  /**
+   * Open the wordmark's home link in a new tab.
+   *
+   * For surfaces that host something the viewer would lose by navigating away —
+   * a deployed chat's in-progress conversation, a shared file's scroll position
+   * and unsaved viewer state. On those the wordmark is a credit, not navigation,
+   * so it must not take the tab with it. Everywhere else it is ordinary
+   * same-tab navigation.
+   */
+  brandInNewTab?: boolean
 }
 
 export function Navbar({
@@ -102,6 +112,7 @@ export function Navbar({
   meta,
   hideBrand = false,
   actions,
+  brandInNewTab = false,
 }: NavbarProps) {
   /**
    * A named resource navbar (shared file / interface / chat) drops the centered
@@ -130,6 +141,7 @@ export function Navbar({
             aria-label='Sim home'
             itemProp='url'
             prefetch={false}
+            {...(brandInNewTab ? { target: '_blank', rel: 'noopener noreferrer' } : {})}
             className='flex h-[30px] items-center'
           >
             <span itemProp='name' className='sr-only'>

apps/sim/app/api/files/public/[token]/content/route.ts

@@ -12,7 +12,7 @@ import { enforcePerIpRateLimit, enforcePerShareRateLimit } from '@/lib/public-sh
 import { resolveActiveShareByToken } from '@/lib/public-shares/share-manager'
 import { downloadFile, downloadFileStream, headObject } from '@/lib/uploads/core/storage-service'
 import { resolveServableImageBytes } from '@/lib/uploads/server/image-derivative'
-import { isMediaContentType } from '@/lib/uploads/utils/byte-range'
+import { isMediaContentType, isReadStart } from '@/lib/uploads/utils/byte-range'
 import {
   createByteRangeResponse,
   createErrorResponse,
@@ -74,9 +74,16 @@ export const GET = withRouteHandler(
        * bucket above, and after the auth gate so a caller holding the token but
        * failing the gate cannot drain the ceiling for everyone else. Both apply,
        * and this runs before any S3 egress is spent.
+       *
+       * A seek within an in-progress playback is charged nothing: the ceiling is
+       * shared by every visitor to the link, so counting each of a player's range
+       * requests would let one person scrubbing a video 429 everyone else. Same
+       * rule as the audit row below, from the same predicate.
        */
-      const shareLimited = await enforcePerShareRateLimit('content', resolved.share.id)
-      if (shareLimited) return shareLimited
+      if (isReadStart(request.headers.get('range'))) {
+        const shareLimited = await enforcePerShareRateLimit('content', resolved.share.id)
+        if (shareLimited) return shareLimited
+      }
 
       const { file } = resolved
 
@@ -104,7 +111,7 @@ export const GET = withRouteHandler(
          * starting at byte 0) is recorded, so the trail still shows every access
          * without a row for each scrub.
          */
-        if (!rangeHeader || rangeHeader.startsWith('bytes=0-')) {
+        if (isReadStart(rangeHeader)) {
           recordAudit({
             workspaceId: file.workspaceId ?? null,
             actorId: null,

apps/sim/app/api/files/utils.test.ts

@@ -490,6 +490,28 @@ describe('media disposition', () => {
     })
     expect(response.headers.get('Content-Disposition')).toContain('attachment')
   })
+
+  /**
+   * Resolving unknown extensions through the canonical MIME table — which is what
+   * makes byte-range serving work — promoted these from "unknown bytes" to
+   * `text/plain`, which is on the inline allowlist. They downloaded before the
+   * media work and must keep downloading after it.
+   */
+  it.each(['app.env', 'server.log', 'nginx.conf', 'settings.ini', 'tool.cfg'])(
+    'keeps %s downloading rather than rendering it in the tab',
+    (filename) => {
+      const response = createFileResponse({
+        buffer: Buffer.from('SECRET=1'),
+        contentType: getContentType(filename),
+        filename,
+      })
+      expect(response.headers.get('Content-Disposition')).toContain('attachment')
+    }
+  )
+
+  it('still resolves those extensions to a real MIME type', () => {
+    expect(getContentType('server.log')).toBe('text/plain')
+  })
 })
 
 describe('createByteRangeResponse', () => {

apps/sim/app/api/files/utils.ts

@@ -202,7 +202,30 @@ const SAFE_INLINE_TYPES = new Set([
   'application/json',
 ])
 
-const FORCE_ATTACHMENT_EXTENSIONS = new Set(['html', 'htm', 'js', 'css', 'xml'])
+/**
+ * Served as an opaque download regardless of what their bytes look like.
+ *
+ * `html`/`htm`/`js`/`css`/`xml` because rendering them inline is an execution
+ * vector. The config-file group is here for a different reason: resolving an
+ * extension through the canonical MIME table (rather than defaulting everything
+ * unknown to `application/octet-stream`) is what makes byte-range serving work,
+ * but it also promoted these five from "unknown bytes" to `text/plain`, which is
+ * on the inline allowlist. A shared `.env` that used to download would otherwise
+ * start rendering in the tab. Nothing about the media work needs that, so the
+ * previous behaviour is kept explicitly.
+ */
+const FORCE_ATTACHMENT_EXTENSIONS = new Set([
+  'html',
+  'htm',
+  'js',
+  'css',
+  'xml',
+  'cfg',
+  'conf',
+  'env',
+  'ini',
+  'log',
+])
 
 function getSecureFileHeaders(filename: string, originalContentType: string) {
   const extension = filename.split('.').pop()?.toLowerCase() || ''

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -1450,14 +1450,21 @@ async function handleExecutePost(
        * same way the deployed chat route does, so the start block receives the
        * `UserFile[]` it normalizes; anything else it silently drops.
        *
-       * Already-uploaded files carry a storage `key` and no `data`, so a
+       * Already-uploaded files carry a storage `key` and no inline payload, so a
        * re-submitted payload passes through untouched.
+       *
+       * `dataUrl` is the preferred inline field and `data` the legacy one — the
+       * same precedence `processChatFiles` itself applies. Testing only `data`
+       * would skip the upload for every current client and drop its attachments
+       * silently, which is the failure this pass exists to prevent.
        */
       if (triggerType === 'chat') {
         const chatFiles = (processedInput as { files?: unknown } | null | undefined)?.files
         const pending =
           Array.isArray(chatFiles) &&
-          chatFiles.some((file) => file && typeof file === 'object' && 'data' in file)
+          chatFiles.some(
+            (file) => file && typeof file === 'object' && ('dataUrl' in file || 'data' in file)
+          )
         if (pending) {
           const uploaded = await ChatFiles.processChatFiles(
             chatFiles as Parameters<typeof ChatFiles.processChatFiles>[0],

apps/sim/app/f/[token]/public-file-view.tsx

@@ -64,6 +64,7 @@ export function PublicFileView({
       <DesktopTitleBarLane />
       <Navbar
         logoOnly
+        brandInNewTab
         name={name}
         meta={buildSharedByLabel(ownerName)}
         hideBrand={Boolean(brand.logoUrl)}

apps/sim/components/resources/file-view/file-view.tsx

@@ -475,6 +475,19 @@ const MediaPreview = memo(function MediaPreview({
     ? fileContentUrl(source, file.key, { version: file.updatedAt.getTime() })
     : null
 
+  /**
+   * Clear a previous failure when the bytes change. Adjusted during render rather
+   * than in an effect so the error state never paints for a frame over content
+   * that has already been replaced. The parent keys this on `file.id`, which is
+   * stable across content edits, so without this a single transient decode error
+   * would wedge the player until the viewer opened a different file.
+   */
+  const [prevSrc, setPrevSrc] = useState(src)
+  if (prevSrc !== src) {
+    setPrevSrc(src)
+    setFailed(false)
+  }
+
   if (!src || failed) {
     return <PreviewError label={kind} error={`This ${kind} could not be played.`} />
   }

apps/sim/lib/uploads/utils/byte-range.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest'
 import {
   byteRangeLength,
   contentRangeHeader,
+  isReadStart,
   parseByteRange,
   unsatisfiableContentRangeHeader,
 } from '@/lib/uploads/utils/byte-range'
@@ -106,3 +107,30 @@ describe('header builders', () => {
     expect(byteRangeLength({ start: 0, end: 499 })).toBe(500)
   })
 })
+
+describe('isReadStart', () => {
+  it('treats an unranged request as opening a read', () => {
+    expect(isReadStart(null)).toBe(true)
+    expect(isReadStart(undefined)).toBe(true)
+    expect(isReadStart('')).toBe(true)
+  })
+
+  it('treats a range anchored at byte 0 as opening a read', () => {
+    expect(isReadStart('bytes=0-')).toBe(true)
+    expect(isReadStart('bytes=0-1023')).toBe(true)
+    expect(isReadStart('  bytes=0-  ')).toBe(true)
+  })
+
+  /**
+   * The audit trail records one row per playback and the aggregate per-share
+   * ceiling charges one token per playback, both off this predicate. A seek is a
+   * continuation of a read already accounted for — counting it would write a row
+   * per drag, and let one viewer scrubbing a shared video spend the whole link's
+   * minute budget on everyone else's behalf.
+   */
+  it('treats a seek into the object as a continuation', () => {
+    expect(isReadStart('bytes=1024-')).toBe(false)
+    expect(isReadStart('bytes=500-999')).toBe(false)
+    expect(isReadStart('bytes=-512')).toBe(false)
+  })
+})