@bycrux/editor 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bycrux/editor",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "private": false,
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "lint": "eslint src"
   },
   "dependencies": {
-    "@bycrux/timeline-core": "^0.2.1",
+    "@bycrux/timeline-core": "^0.2.2",
     "class-variance-authority": "^0.7",
     "clsx": "^2",
     "lucide-react": "^0.400",

package/src/index.ts

@@ -37,6 +37,7 @@ export type {
   RenderPhase,
   CaptionEvent,
   GenerateCaptionsOptions,
+  CaptionProfileDefaults,
   MediaScope,
   MediaItem,
   GlobalOverlay,

package/src/types.ts

@@ -186,6 +186,50 @@ export interface GenerateCaptionsOptions {
   style?: string
 }
 
+/**
+ * The caption look a host has on file for one of its named profiles —
+ * everything this package can seed a freshly transcribed track with.
+ *
+ * This package owns NO notion of what a profile is beyond `Project.profile`'s
+ * bare name: whether profiles are files on disk, rows in the host's database,
+ * or nothing at all is the host's business, and asking the host through
+ * `getCaptionProfileDefaults` is how the editor stays ignorant of it. Every
+ * field is optional and the whole thing is nullable, so "this host has no
+ * profiles", "this profile has no styling" and "this profile sets only a
+ * color" are all expressible without the editor knowing which it got.
+ *
+ * Field names are the *editor's* vocabulary, not any host's — each one is
+ * named after the field it seeds, so the mapping from a host's own schema
+ * happens once, in that host's adapter, rather than leaking a host's column
+ * names into this package.
+ */
+export interface CaptionProfileDefaults {
+  /**
+   * Seeds `GenerateCaptionsOptions.style` on the regeneration request — the
+   * style the new track is transcribed INTO. Deliberately `string` rather
+   * than `Captions['style']`, matching the field it feeds: the host is what
+   * validates a style name, and a host storing one in a free-text column
+   * should not have to narrow before it can answer.
+   *
+   * Never written onto the returned track: the host reports the style it
+   * actually used, and that report wins (see `mergeCaptionProfileDefaults`).
+   */
+  style?: string
+  /** Seeds `Captions.fontFamily` — a CSS font-family stack. */
+  fontFamily?: string
+  /**
+   * Seeds `Captions.googleFonts` alongside `fontFamily`, and only alongside
+   * it. The two travel together (see `Captions.fontFamily`'s own note): a
+   * family whose font file is not also fetched renders as the fallback face,
+   * in the editor preview and the export alike. A host that seeds a Google
+   * family without its spec here gets a silent half-application — the right
+   * stack, the wrong glyphs.
+   */
+  googleFonts?: string[]
+  /** Seeds `Captions.color` — the base caption text color. */
+  color?: string
+}
+
 // ── Overlay library types ─────────────────────────────────────────────────────
 // Copied verbatim from Montaj's `ui/src/lib/api.ts` so the package owns the
 // shape the editor consumes. A host's overlay-listing endpoints return these;
@@ -794,6 +838,30 @@ export interface EditorAdapter<P extends Project = Project> {
    */
   generateCaptions?(id: string, opts?: GenerateCaptionsOptions): AsyncIterable<CaptionEvent>
 
+  /**
+   * Optional: resolve the caption look the host has on file for `profile` —
+   * the value of `Project.profile`, which this package treats as an opaque
+   * name and nothing more. Used to seed a freshly transcribed caption track
+   * with the style, font and color the profile already implies, instead of
+   * leaving the user to re-pick all three every regeneration.
+   *
+   * THE PROFILE CONCEPT ITSELF STAYS ON THE HOST SIDE, which is the whole
+   * reason this is a seam rather than a lookup. `Project.profile` is a bare
+   * string here; what it resolves to is the host's — a local file for the
+   * OSS `serve` UI, an account-scoped database row for a hosted app, nothing
+   * at all for a host with no profile concept. A host that cannot answer
+   * omits this method; the editor feature-detects its absence and generates
+   * captions exactly as it did before this existed, with no second argument
+   * on `generateCaptions` and no merge on the result.
+   *
+   * Best-effort on the editor's side: a rejection is swallowed and treated as
+   * `null`. Caption regeneration is the user's actual request and must never
+   * fail because a styling convenience could not be looked up.
+   *
+   * Returns `null` when the host has no defaults for that name.
+   */
+  getCaptionProfileDefaults?(profile: string): Promise<CaptionProfileDefaults | null>
+
   /**
    * Optional: report the editor's live playhead and selection to the host.
    *

package/src/video/CaptionRegenModal.tsx

@@ -1,21 +1,35 @@
 import { useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
-import type { EditorAdapter, Project } from '../types'
+import type { CaptionProfileDefaults, EditorAdapter, Project } from '../types'
 import type { Captions } from '../schema'
+import { resolveCaptionProfileDefaults } from './captionProfileDefaults'
 
 interface CaptionRegenModalProps<P extends Project = Project> {
   projectId: string
   /** Adapter driving the caption-regeneration stream. Must implement
    *  `generateCaptions` — callers gate rendering on its presence. */
   adapter: EditorAdapter<P>
+  /** The project's attached profile name (`Project.profile`), if it has one.
+   *  Passed to `adapter.getCaptionProfileDefaults` to seed the new track's
+   *  style/font/color. Absent — or a host with no such seam — and the run is
+   *  byte-identical to what it was before profile seeding existed. */
+  profile?: string
   /** Caption rows the project has right now (`maxCaptionLane(segments) + 1`,
    *  so 1 for a lane-less or empty track). Regeneration replaces the whole
    *  track with a single fresh row, so this is the count the warning banner
    *  below reports as about to be discarded. */
   existingRowCount: number
-  /** Fired on terminal success with the freshly transcribed caption track. The
-   *  caller patches `project.captions` from this; the modal then closes. */
-  onDone: (captions: Captions) => void
+  /** Fired on terminal success with the freshly transcribed caption track,
+   *  plus whatever the host answered for `profile` (null when it answered
+   *  nothing). The caller patches `project.captions` from the first and folds
+   *  the second onto it — see `mergeCaptionProfileDefaults`. The modal then
+   *  closes.
+   *
+   *  The defaults are handed OVER rather than re-fetched by the caller so the
+   *  profile is resolved exactly once per run: the modal already had to ask
+   *  before the stream started (it needs the style for the request), and a
+   *  second lookup at apply time could answer differently. */
+  onDone: (captions: Captions, profileDefaults: CaptionProfileDefaults | null) => void
   /** Fired when the modal closes (cancel, error dismiss, or post-done). */
   onClose: () => void
   /** Editor theme mode — light/dark. The panel and log box follow
@@ -38,7 +52,7 @@ function LogLine({ text, mode = 'dark' }: { text: string; mode?: 'light' | 'dark
   )
 }
 
-export default function CaptionRegenModal<P extends Project = Project>({ projectId, adapter, existingRowCount, onDone, onClose, mode = 'dark' }: CaptionRegenModalProps<P>) {
+export default function CaptionRegenModal<P extends Project = Project>({ projectId, adapter, profile, existingRowCount, onDone, onClose, mode = 'dark' }: CaptionRegenModalProps<P>) {
   const [logs, setLogs]     = useState<string[]>([])
   const [status, setStatus] = useState<'running' | 'done' | 'error'>('running')
   const [errorMsg, setError] = useState<string | null>(null)
@@ -66,13 +80,25 @@ export default function CaptionRegenModal<P extends Project = Project>({ project
 
     void (async () => {
       try {
-        for await (const ev of adapter.generateCaptions!(projectId)) {
+        // Seeding, before anything is spawned: the style has to be on the
+        // request, so this one await sits in front of the stream. It cannot
+        // reject (see `resolveCaptionProfileDefaults`) and it cannot stop the
+        // run — a host with no profile seam, or a lookup that failed, simply
+        // produces `null` and everything below behaves exactly as it did
+        // before this existed, down to the arity of the call.
+        const profileDefaults = await resolveCaptionProfileDefaults(adapter, profile)
+        if (unmountedRef.current || cancelledRef.current) return
+        const stream = profileDefaults?.style
+          ? adapter.generateCaptions!(projectId, { style: profileDefaults.style })
+          : adapter.generateCaptions!(projectId)
+
+        for await (const ev of stream) {
           if (unmountedRef.current || cancelledRef.current) break
           if (ev.type === 'log') {
             setLogs(l => [...l, ev.message])
           } else if (ev.type === 'done') {
             setStatus('done')
-            onDone(ev.captions)
+            onDone(ev.captions, profileDefaults)
           } else {
             setError(ev.message)
             setStatus('error')
@@ -94,7 +120,7 @@ export default function CaptionRegenModal<P extends Project = Project>({ project
         unmountedRef.current = true
       }, 0)
     }
-  }, [projectId, adapter, onDone])
+  }, [projectId, adapter, profile, onDone])
 
   // Auto-scroll logs
   useEffect(() => {

package/src/video/VideoEditor.tsx

@@ -14,6 +14,7 @@ import { collapseGaps, rippleDelete, splitAtTime } from './cuts'
 import { addMarker } from './timeline/markers'
 import { repairCaptionWords } from './captionRepair'
 import { maxCaptionLane, normalizeCaptionLanes } from './captionLanes'
+import { mergeCaptionProfileDefaults } from './captionProfileDefaults'
 import Timeline, { type TimelineActions, type TimelineMode } from './timeline/Timeline'
 import { visualDuration } from '@bycrux/timeline-core'
 import { audioEnd, computeAutoCrossfade, computeDerivedTiming, computeVisualCrossfade, enabledTrackItems, mapTrackItems, normalizeAudioTracks, trackItems, withEnabledItemTracks } from './timeline/timeline-model'
@@ -2954,10 +2955,19 @@ function ReviewSurface<P extends Project>({
         <CaptionRegenModal
           adapter={adapter}
           projectId={project.id}
+          profile={project.profile}
           existingRowCount={maxCaptionLane(project.captions?.segments ?? []) + 1}
           onClose={() => setRegenCaptionsOpen(false)}
-          onDone={(captions) => {
-            sync.applyExternal({ ...syncProjectRef.current, captions } as P)
+          onDone={(captions, profileDefaults) => {
+            // The modal resolved the profile once, before the stream; we fold
+            // its font/color onto the fresh track here rather than there
+            // because this is the seam that decides what lands on the project
+            // — and the merge only ever fills fields the host left unset, so
+            // a host that starts returning them keeps authoring them.
+            // `mergeCaptionProfileDefaults` returns `captions` itself when
+            // there is nothing to seed, which is every host without the seam.
+            const seeded = mergeCaptionProfileDefaults(captions, profileDefaults)
+            sync.applyExternal({ ...syncProjectRef.current, captions: seeded } as P)
             setRegenCaptionsOpen(false)
           }}
           mode={timelineMode}

package/src/video/__tests__/CaptionRegenModal.test.tsx

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, afterEach } from 'vitest'
 import { render, screen, waitFor, cleanup } from '@testing-library/react'
-import type { CaptionEvent, EditorAdapter, ImageElement, Project } from '../../types'
+import type { CaptionEvent, CaptionProfileDefaults, EditorAdapter, ImageElement, Project } from '../../types'
 import type { Captions } from '../../schema'
 import CaptionRegenModal from '../CaptionRegenModal'
 
@@ -45,7 +45,9 @@ describe('CaptionRegenModal', () => {
     )
 
     await waitFor(() => expect(screen.getByText(/transcribing audio/i)).toBeTruthy())
-    await waitFor(() => expect(onDone).toHaveBeenCalledWith(doneCaptions))
+    // Second argument is the profile defaults the host resolved — `null` on
+    // this adapter, which implements no `getCaptionProfileDefaults`.
+    await waitFor(() => expect(onDone).toHaveBeenCalledWith(doneCaptions, null))
   })
 
   it('shows an error message verbatim on error', async () => {
@@ -92,3 +94,160 @@ describe('CaptionRegenModal', () => {
     expect(screen.queryByText(/caption rows/i)).toBeNull()
   })
 })
+
+// ── Profile-seeded caption defaults ──────────────────────────────────────────
+//
+// `adapter.getCaptionProfileDefaults` is an OPTIONAL host seam: this package
+// owns no notion of what a profile is beyond `Project.profile`'s bare name, so
+// a host that can resolve one answers, and a host that cannot omits the method
+// entirely. Every assertion below therefore comes in a pair — the seam present
+// and the seam absent — because the absent case is the one every existing host
+// (Hub, Los Parceros, the OSS `serve` UI) is in today, and it must keep
+// producing the byte-identical call it produced before this seam existed.
+
+/** Adapter whose `generateCaptions` is a spy, so the opts argument is readable. */
+function makeSpyAdapter() {
+  const adapter = makeAdapter()
+  const generateCaptions = vi.fn(async function* (): AsyncIterable<CaptionEvent> {
+    yield { type: 'done', captions: doneCaptions }
+  })
+  adapter.generateCaptions = generateCaptions
+  return { adapter, generateCaptions }
+}
+
+const PROFILE_DEFAULTS: CaptionProfileDefaults = {
+  style: 'karaoke',
+  fontFamily: '"Inter", system-ui, sans-serif',
+  color: '#112233',
+}
+
+describe('CaptionRegenModal — profile-seeded caption defaults', () => {
+  it('seeds the generation style from the defaults the host resolves for the project profile', async () => {
+    const { adapter, generateCaptions } = makeSpyAdapter()
+    const getCaptionProfileDefaults = vi.fn(async () => PROFILE_DEFAULTS)
+    adapter.getCaptionProfileDefaults = getCaptionProfileDefaults
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        profile="sam"
+        existingRowCount={1}
+        onDone={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(generateCaptions).toHaveBeenCalledWith('vid-1', { style: 'karaoke' }))
+    expect(getCaptionProfileDefaults).toHaveBeenCalledWith('sam')
+  })
+
+  it('hands the resolved defaults to onDone alongside the fresh captions', async () => {
+    // The host merges font/color onto the track at its own apply seam; the
+    // modal resolves the profile ONCE and passes what it got, so the host
+    // never repeats the round trip (and can never race a second answer).
+    const { adapter } = makeSpyAdapter()
+    adapter.getCaptionProfileDefaults = vi.fn(async () => PROFILE_DEFAULTS)
+    const onDone = vi.fn()
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        profile="sam"
+        existingRowCount={1}
+        onDone={onDone}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(onDone).toHaveBeenCalledWith(doneCaptions, PROFILE_DEFAULTS))
+  })
+
+  it('passes no opts at all when the host implements no caption-defaults seam', async () => {
+    // Today's behaviour for every existing host, pinned: a bare one-argument
+    // call, not `(id, undefined)` and not `(id, {})`.
+    const { adapter, generateCaptions } = makeSpyAdapter()
+    const onDone = vi.fn()
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        profile="sam"
+        existingRowCount={1}
+        onDone={onDone}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(onDone).toHaveBeenCalled())
+    expect(generateCaptions).toHaveBeenCalledWith('vid-1')
+    expect(onDone).toHaveBeenCalledWith(doneCaptions, null)
+  })
+
+  it('never asks for defaults when the project has no profile', async () => {
+    const { adapter, generateCaptions } = makeSpyAdapter()
+    const getCaptionProfileDefaults = vi.fn(async () => PROFILE_DEFAULTS)
+    adapter.getCaptionProfileDefaults = getCaptionProfileDefaults
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        existingRowCount={1}
+        onDone={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(generateCaptions).toHaveBeenCalledWith('vid-1'))
+    expect(getCaptionProfileDefaults).not.toHaveBeenCalled()
+  })
+
+  it('still generates when the caption-defaults seam rejects', async () => {
+    // Seeding is a convenience. A profile lookup that 500s must never be the
+    // reason a user cannot regenerate their captions.
+    const { adapter, generateCaptions } = makeSpyAdapter()
+    adapter.getCaptionProfileDefaults = vi.fn(async () => { throw new Error('boom') })
+    const onDone = vi.fn()
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        profile="sam"
+        existingRowCount={1}
+        onDone={onDone}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(generateCaptions).toHaveBeenCalledWith('vid-1'))
+    await waitFor(() => expect(onDone).toHaveBeenCalledWith(doneCaptions, null))
+    expect(screen.queryByText('boom')).toBeNull()
+  })
+
+  it('passes no style when the profile resolves without one', async () => {
+    // A profile that sets only a font and a color must not send `style:
+    // undefined` — the host route reads presence, not value.
+    const { adapter, generateCaptions } = makeSpyAdapter()
+    const fontOnly: CaptionProfileDefaults = { fontFamily: '"Inter", system-ui, sans-serif' }
+    adapter.getCaptionProfileDefaults = vi.fn(async () => fontOnly)
+    const onDone = vi.fn()
+
+    render(
+      <CaptionRegenModal
+        adapter={adapter}
+        projectId="vid-1"
+        profile="sam"
+        existingRowCount={1}
+        onDone={onDone}
+        onClose={vi.fn()}
+      />,
+    )
+
+    await waitFor(() => expect(generateCaptions).toHaveBeenCalledWith('vid-1'))
+    await waitFor(() => expect(onDone).toHaveBeenCalledWith(doneCaptions, fontOnly))
+  })
+})

package/src/video/__tests__/VideoEditor.captionSeam.test.tsx

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { render, screen, waitFor, fireEvent } from '@testing-library/react'
 import type { CaptionEvent, EditorAdapter, ImageElement, Project, RenderEvent, VersionEntry, WaveformChunk } from '../../types'
+import type { Captions } from '../../schema'
 import VideoEditor from '../VideoEditor'
 
 // ── T1 — host-driven caption trigger seam ────────────────────────────────────
@@ -132,3 +133,104 @@ describe('VideoEditor — host-driven caption trigger seam', () => {
     await waitFor(() => expect(screen.getByText('Regenerating captions…')).toBeTruthy())
   })
 })
+
+// ── Profile-seeded caption defaults, through the real apply seam ─────────────
+//
+// The unit-level rules live in `captionProfileDefaults.test.ts`; what these
+// two prove is the WIRING — that `project.profile` reaches the host seam, and
+// that the merged track is what `applyExternal` lands on the project. There is
+// no spy for `applyExternal` (it is internal to `useProjectSync`, and it
+// deliberately calls neither `onProjectChange` nor `adapter.saveProject` — see
+// VideoEditor.captionDelete.test.tsx's note), so the assertion reads the
+// caption color back out of the Format tab's swatch, which renders
+// `project.captions.color` and falls back to '#ffffff' when unset.
+
+function readCaptionColor(): string {
+  fireEvent.click(screen.getByRole('button', { name: 'Format' }))
+  return (screen.getByLabelText('Caption text color') as HTMLInputElement).value
+}
+
+/** Adapter whose regen stream terminates with the given track. */
+function makeRegenAdapter(captions: Captions) {
+  const adapter = makeFakeAdapter()
+  adapter.generateCaptions = vi.fn(async function* (): AsyncIterable<CaptionEvent> {
+    yield { type: 'done', captions }
+  })
+  return adapter
+}
+
+describe('VideoEditor — profile-seeded caption defaults', () => {
+  it('merges the profile font/color onto a server track that set neither', async () => {
+    const adapter = makeRegenAdapter({
+      style: 'pop',
+      segments: [{ id: 'cap-new', text: 'fresh', start: 0, end: 1, words: [{ word: 'fresh', start: 0, end: 1 }] }],
+    })
+    const getCaptionProfileDefaults = vi.fn(async () => ({
+      style: 'karaoke',
+      fontFamily: '"Inter", system-ui, sans-serif',
+      color: '#112233',
+    }))
+    ;(adapter as unknown as { getCaptionProfileDefaults: unknown }).getCaptionProfileDefaults = getCaptionProfileDefaults
+
+    render(
+      <VideoEditor
+        project={makeVideoProject({ profile: 'sam' })}
+        adapter={adapter}
+        onProjectChange={vi.fn()}
+      />,
+    )
+
+    fireEvent.click(await screen.findByText('Regenerate captions'))
+
+    // The modal closes itself once the host's onDone runs, which is also when
+    // the merged track has landed.
+    await waitFor(() => expect(screen.queryByText('Regenerating captions…')).toBeNull())
+    expect(getCaptionProfileDefaults).toHaveBeenCalledWith('sam')
+    expect(adapter.generateCaptions).toHaveBeenCalledWith('vid-1', { style: 'karaoke' })
+    expect(readCaptionColor()).toBe('#112233')
+  })
+
+  it('leaves a color the server response already set alone', async () => {
+    const adapter = makeRegenAdapter({
+      style: 'pop',
+      color: '#ff0000',
+      segments: [{ id: 'cap-new', text: 'fresh', start: 0, end: 1, words: [{ word: 'fresh', start: 0, end: 1 }] }],
+    })
+    ;(adapter as unknown as { getCaptionProfileDefaults: unknown }).getCaptionProfileDefaults =
+      vi.fn(async () => ({ color: '#112233' }))
+
+    render(
+      <VideoEditor
+        project={makeVideoProject({ profile: 'sam' })}
+        adapter={adapter}
+        onProjectChange={vi.fn()}
+      />,
+    )
+
+    fireEvent.click(await screen.findByText('Regenerate captions'))
+    await waitFor(() => expect(screen.queryByText('Regenerating captions…')).toBeNull())
+    expect(readCaptionColor()).toBe('#ff0000')
+  })
+
+  it('applies the server track untouched on a host with no caption-defaults seam', async () => {
+    // Every host shipping today is in this case; the regen call must stay the
+    // bare one-argument call it has always been.
+    const adapter = makeRegenAdapter({
+      style: 'pop',
+      segments: [{ id: 'cap-new', text: 'fresh', start: 0, end: 1, words: [{ word: 'fresh', start: 0, end: 1 }] }],
+    })
+
+    render(
+      <VideoEditor
+        project={makeVideoProject({ profile: 'sam' })}
+        adapter={adapter}
+        onProjectChange={vi.fn()}
+      />,
+    )
+
+    fireEvent.click(await screen.findByText('Regenerate captions'))
+    await waitFor(() => expect(screen.queryByText('Regenerating captions…')).toBeNull())
+    expect(adapter.generateCaptions).toHaveBeenCalledWith('vid-1')
+    expect(readCaptionColor()).toBe('#ffffff')
+  })
+})

package/src/video/__tests__/captionProfileDefaults.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { EditorAdapter, Project } from '../../types'
+import type { Captions } from '../../schema'
+import { mergeCaptionProfileDefaults, resolveCaptionProfileDefaults } from '../captionProfileDefaults'
+
+// A freshly transcribed track as the host routes actually return one: a bare
+// `{ style, segments }` with no text styling at all (montaj's own
+// `steps/caption/caption.py` builds exactly this shape). Every field the
+// profile can seed is therefore absent here, which is the whole reason seeding
+// is worth doing.
+const FRESH: Captions = {
+  style: 'pop',
+  segments: [{ text: 'hola', start: 0, end: 1, words: [] }],
+}
+
+function adapterWith(
+  getCaptionProfileDefaults?: EditorAdapter<Project>['getCaptionProfileDefaults'],
+): EditorAdapter<Project> {
+  return { getCaptionProfileDefaults } as unknown as EditorAdapter<Project>
+}
+
+describe('mergeCaptionProfileDefaults', () => {
+  it('fills the fields the server left unset', () => {
+    const merged = mergeCaptionProfileDefaults(FRESH, {
+      fontFamily: '"Inter", system-ui, sans-serif',
+      color: '#112233',
+    })
+    expect(merged.fontFamily).toBe('"Inter", system-ui, sans-serif')
+    expect(merged.color).toBe('#112233')
+    expect(merged.segments).toBe(FRESH.segments)
+    expect(merged.style).toBe('pop')
+  })
+
+  it('never overwrites a color the server response already set', () => {
+    // The route returns a bare track today. If it ever starts carrying a
+    // color, that value is authored downstream of the profile and wins.
+    const withColor: Captions = { ...FRESH, color: '#ff0000' }
+    const merged = mergeCaptionProfileDefaults(withColor, { color: '#112233' })
+    expect(merged.color).toBe('#ff0000')
+  })
+
+  it('never overwrites a fontFamily the server response already set', () => {
+    const withFont: Captions = { ...FRESH, fontFamily: '"Figtree", system-ui, sans-serif' }
+    const merged = mergeCaptionProfileDefaults(withFont, {
+      fontFamily: '"Inter", system-ui, sans-serif',
+      googleFonts: ['Inter:wght@700'],
+    })
+    expect(merged.fontFamily).toBe('"Figtree", system-ui, sans-serif')
+    expect(merged.googleFonts).toBeUndefined()
+  })
+
+  it('carries googleFonts along with a seeded fontFamily', () => {
+    // `fontFamily` and `googleFonts` travel together (see the `Captions` doc
+    // comment): a family whose file is not also fetched renders as the
+    // fallback face, in the preview AND the export. Seeding one without the
+    // other is the silent half-failure this pair exists to avoid.
+    const merged = mergeCaptionProfileDefaults(FRESH, {
+      fontFamily: '"Inter", system-ui, sans-serif',
+      googleFonts: ['Inter:wght@700'],
+    })
+    expect(merged.googleFonts).toEqual(['Inter:wght@700'])
+  })
+
+  it('does not inject googleFonts when the family was not seeded', () => {
+    const withFont: Captions = { ...FRESH, fontFamily: '"Figtree", system-ui, sans-serif' }
+    const merged = mergeCaptionProfileDefaults(withFont, { googleFonts: ['Inter:wght@700'] })
+    expect(merged.googleFonts).toBeUndefined()
+  })
+
+  it('returns the very same object when there is nothing to seed', () => {
+    // Reference identity, not deep equality: the caller feeds the result
+    // straight to `applyExternal`, and a fresh object there is a state change
+    // the editor has to reconcile for no reason.
+    expect(mergeCaptionProfileDefaults(FRESH, null)).toBe(FRESH)
+    expect(mergeCaptionProfileDefaults(FRESH, undefined)).toBe(FRESH)
+    expect(mergeCaptionProfileDefaults(FRESH, {})).toBe(FRESH)
+    expect(mergeCaptionProfileDefaults(FRESH, { style: 'karaoke' })).toBe(FRESH)
+  })
+
+  it('never writes the profile style onto the track', () => {
+    // `style` seeds the GENERATION request, not the returned track: the host
+    // reports the style it actually transcribed with, and that report wins.
+    const merged = mergeCaptionProfileDefaults(FRESH, { style: 'karaoke', color: '#112233' })
+    expect(merged.style).toBe('pop')
+  })
+
+  it('treats an empty-string default as nothing to seed', () => {
+    // A host backed by a nullable column can hand back `''` for "unset".
+    expect(mergeCaptionProfileDefaults(FRESH, { fontFamily: '', color: '' })).toBe(FRESH)
+  })
+})
+
+describe('resolveCaptionProfileDefaults', () => {
+  it('returns null when the host implements no seam', async () => {
+    expect(await resolveCaptionProfileDefaults(adapterWith(), 'sam')).toBeNull()
+  })
+
+  it('returns null when the project has no profile', async () => {
+    const seam = vi.fn(async () => ({ color: '#112233' }))
+    expect(await resolveCaptionProfileDefaults(adapterWith(seam), undefined)).toBeNull()
+    expect(await resolveCaptionProfileDefaults(adapterWith(seam), '')).toBeNull()
+    expect(seam).not.toHaveBeenCalled()
+  })
+
+  it('returns null rather than throwing when the seam rejects', async () => {
+    const seam = vi.fn(async () => { throw new Error('boom') })
+    await expect(resolveCaptionProfileDefaults(adapterWith(seam), 'sam')).resolves.toBeNull()
+  })
+
+  it('returns null rather than throwing when the seam throws synchronously', async () => {
+    const seam = vi.fn(() => { throw new Error('boom') }) as unknown as EditorAdapter<Project>['getCaptionProfileDefaults']
+    await expect(resolveCaptionProfileDefaults(adapterWith(seam), 'sam')).resolves.toBeNull()
+  })
+
+  it('passes the profile name through and returns what the host answered', async () => {
+    const answer = { style: 'karaoke', color: '#112233' }
+    const seam = vi.fn(async () => answer)
+    expect(await resolveCaptionProfileDefaults(adapterWith(seam), 'sam')).toBe(answer)
+    expect(seam).toHaveBeenCalledWith('sam')
+  })
+})

package/src/video/captionProfileDefaults.ts

@@ -0,0 +1,86 @@
+/**
+ * The two halves of profile-seeded caption defaults: ask the host what a
+ * profile looks like, and fold the answer onto a freshly transcribed track.
+ *
+ * Both live here rather than inside the two components that use them because
+ * they are used at two different moments of one flow — `CaptionRegenModal`
+ * resolves the defaults *before* the stream starts (it needs the style to put
+ * on the request), and `VideoEditor` merges them *after* it ends (at the one
+ * seam that applies server-authored captions outside the undo stack). The
+ * resolution happens once, in the modal, and rides along to the merge on the
+ * `onDone` callback; neither side repeats the round trip, so they cannot
+ * disagree about what the profile said.
+ *
+ * NOT to be confused with `captionStyleDefaults.ts` next door, which is a
+ * hand-copied mirror of each render TEMPLATE's own parameter defaults. These
+ * are the HOST's defaults for one named profile, and the editor knows nothing
+ * about where they come from.
+ */
+import type { CaptionProfileDefaults, EditorAdapter, Project } from '../types'
+import type { Captions } from '../schema'
+
+/**
+ * Ask the host for `profile`'s caption defaults, best-effort.
+ *
+ * Returns `null` — never throws, never rejects — when the project has no
+ * profile, when the host implements no `getCaptionProfileDefaults`, or when
+ * that call fails in any way. Seeding is a convenience laid over the user's
+ * actual request (regenerate my captions); a profile lookup that 500s must not
+ * be the reason that request cannot be made. The synchronous `try` matters as
+ * much as the `.catch`: an adapter method that throws before returning its
+ * promise would otherwise escape past the await.
+ */
+export async function resolveCaptionProfileDefaults<P extends Project = Project>(
+  adapter: EditorAdapter<P>,
+  profile: string | undefined | null,
+): Promise<CaptionProfileDefaults | null> {
+  if (!profile || !adapter.getCaptionProfileDefaults) return null
+  try {
+    return (await adapter.getCaptionProfileDefaults(profile)) ?? null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Fold `defaults` onto a freshly transcribed `captions` track, filling only
+ * the fields the host's response left unset.
+ *
+ * Three rules, each load-bearing:
+ *
+ *  - **The server's value always wins.** The caption route returns a bare
+ *    `{ style, segments }` today, so in practice every seedable field is
+ *    absent — but a profile default is the weakest possible authority on a
+ *    track's look, below anything the host chose to state, and the day the
+ *    route starts carrying a color is not the day this should start
+ *    clobbering it.
+ *  - **`style` is never written onto the track.** It seeds the generation
+ *    REQUEST (`GenerateCaptionsOptions.style`); what comes back reports the
+ *    style actually transcribed with, and that report is the truth.
+ *  - **`googleFonts` rides with `fontFamily` or not at all.** Seeding a
+ *    family without its font spec renders the fallback face with nothing on
+ *    screen to say so (see `Captions.fontFamily`), and seeding a spec for a
+ *    family we did not apply just fetches bytes no glyph uses.
+ *
+ * Returns the ORIGINAL object by reference when there is nothing to seed. The
+ * result goes straight to `applyExternal`, and a fresh object there is a state
+ * change the editor reconciles — and, downstream, a project that differs from
+ * one produced before this feature existed, for no reason a user could name.
+ */
+export function mergeCaptionProfileDefaults(
+  captions: Captions,
+  defaults: CaptionProfileDefaults | null | undefined,
+): Captions {
+  if (!defaults) return captions
+
+  const patch: Partial<Captions> = {}
+  if (captions.fontFamily == null && defaults.fontFamily) {
+    patch.fontFamily = defaults.fontFamily
+    if (captions.googleFonts == null && defaults.googleFonts?.length) {
+      patch.googleFonts = defaults.googleFonts
+    }
+  }
+  if (captions.color == null && defaults.color) patch.color = defaults.color
+
+  return Object.keys(patch).length === 0 ? captions : { ...captions, ...patch }
+}

package/src/video/panels/LeftPanelTabs.tsx

@@ -148,8 +148,26 @@ export default function LeftPanelTabs({ tabs, defaultTabId, storageKey = DEFAULT
                 selected
                   // Label is ~10px accent TEXT → the AA-safe accent-text token
                   // (indigo-600 in light); the tint fill keeps the plain accent.
-                  ? 'text-[var(--editor-accent-text)] bg-[var(--editor-accent)]/10'
-                  : 'text-[var(--editor-text)]/60 hover:text-[var(--editor-text)] hover:bg-[var(--editor-text)]/5',
+                  //
+                  // The tint uses `color-mix(...)` baked directly into the
+                  // arbitrary value, NOT Tailwind's `/NN` opacity modifier —
+                  // that modifier only works when Tailwind itself can parse
+                  // the color to inject an alpha channel, which it cannot do
+                  // for an arbitrary `var(...)` reference. `text-[var(--x)]/60`
+                  // silently emits NO utility at all (no build error, no
+                  // fallback), in this package's own Tailwind build and in a
+                  // host's. Measured: building this component under
+                  // montaj-app/desktop/ui's Tailwind (v3.4) produced zero
+                  // `editor-text`/`editor-accent` rules for any `/NN`-modified
+                  // class here, while the identical `color-mix(in_srgb,
+                  // var(--editor-text)_60%,transparent)` arbitrary value
+                  // compiled correctly in both builds. That silent failure is
+                  // exactly what made the rail's inactive items (all but the
+                  // selected tab) unreadable — no color rule at all, so the
+                  // button fell back to inherited/default text color against
+                  // the editor's dark background.
+                  ? 'text-[var(--editor-accent-text)] bg-[color-mix(in_srgb,var(--editor-accent)_10%,transparent)]'
+                  : 'text-[color-mix(in_srgb,var(--editor-text)_60%,transparent)] hover:text-[var(--editor-text)] hover:bg-[color-mix(in_srgb,var(--editor-text)_5%,transparent)]',
               )}
             >
               {selected && (