diff --git a/.fallowrc.json b/.fallowrc.json
index 55d18a070..df3950b4c 100644
--- a/.fallowrc.json
+++ b/.fallowrc.json
@@ -49,10 +49,19 @@
       "src/features/effects/components/panels/gpu-wheels-panel.tsx",
       "src/features/effects/components/panels/gpu-curves-panel.tsx",
       "src/features/timeline/components/timeline.tsx",
-      "src/features/timeline/services/reverse-conform-service.ts"
+      "src/features/timeline/services/reverse-conform-service.ts",
+      // PR3's contract validator and pure edit engine are intentionally
+      // branch-dense boundary code; they are covered by conformance tests and
+      // should not be treated as UI health hotspots.
+      "src/features/editor/codepress/adapter.ts",
+      "src/features/editor/codepress/contract.ts",
+      "src/features/editor/codepress/document.ts",
+      "src/features/editor/codepress/edit-engine.ts",
+      "src/features/editor/codepress/timing.ts",
+      "src/features/editor/codepress/translation.ts"
     ]
   },
-  "usedClassMembers": ["addEventListener", "removeEventListener"],
+  "usedClassMembers": ["addEventListener", "removeEventListener", "subscribe"],
   "rules": {},
   "ignoreExports": [
     {
@@ -124,6 +133,37 @@
     {
       "file": "src/features/editor/deps/timeline-store.ts",
       "exports": ["*"]
+    },
+    {
+      // Controlled PR3 package surface: these exports are consumed by the
+      // future CodePress shell/worker boundary rather than the current app
+      // entrypoint. Keep them visible to type/lint/tests, not dead-code trim.
+      "file": "src/features/editor/codepress/adapter.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/contract.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/controlled-editor.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/document.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/edit-engine.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/timing.ts",
+      "exports": ["*"]
+    },
+    {
+      "file": "src/features/editor/codepress/translation.ts",
+      "exports": ["*"]
     }
   ]
 }
diff --git a/.github/workflows/publish-editor-surface.yml b/.github/workflows/publish-editor-surface.yml
new file mode 100644
index 000000000..7b3a4406a
--- /dev/null
+++ b/.github/workflows/publish-editor-surface.yml
@@ -0,0 +1,92 @@
+name: Publish FreeCut editor surface
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - codepress-main
+    tags:
+      - 'freecut-editor-surface-v*'
+
+permissions:
+  contents: read
+  # npm trusted publishing (OIDC): the job exchanges the GitHub Actions
+  # identity token for a short-lived npm credential, so there is no NPM_TOKEN
+  # to store or rotate. Requires a trusted publisher configured on npmjs.com
+  # for this repository and this workflow filename.
+  id-token: write
+
+concurrency:
+  group: publish-freecut-editor-surface
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    name: Publish @quantfive/freecut-editor-surface
+    # Manual runs are intentionally limited to staging; tag pushes are
+    # already constrained by the trigger below and must match the package
+    # version in the validation step.
+    if: github.event_name == 'push' || github.ref_name == 'staging'
+    # A merge that does not bump the version is a no-op, not a failure: npm
+    # rejects republishing an existing version, and the branch trigger fires
+    # on every qualifying merge.
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.14.0'
+          cache: npm
+          registry-url: https://registry.npmjs.org
+
+      - name: Select pinned npm
+        run: npm install --global npm@11.8.0
+
+      - name: Install locked dependencies
+        run: npm ci --ignore-scripts
+
+      - name: Verify provenance
+        run: npm run verify:provenance
+
+      - name: Validate release tag
+        if: startsWith(github.ref, 'refs/tags/')
+        shell: bash
+        run: |
+          set -euo pipefail
+          tag_version="${GITHUB_REF_NAME#freecut-editor-surface-v}"
+          package_version="$(node -p "require('./packages/freecut-editor/package.json').version")"
+          if [[ "${GITHUB_REF_NAME}" != freecut-editor-surface-v* || "${tag_version}" != "${package_version}" ]]; then
+            echo "Release tag ${GITHUB_REF_NAME} must match package version ${package_version}." >&2
+            exit 1
+          fi
+
+      - name: Build deterministic package artifact
+        run: npm run package:editor-surface
+
+      - name: Verify packed artifact as an installed consumer
+        shell: bash
+        run: |
+          set -euo pipefail
+          package_version="$(node -p "require('./packages/freecut-editor/package.json').version")"
+          artifact="artifacts/freecut-editor-surface-${package_version}.tgz"
+          test -f "${artifact}"
+          npm run test:editor-surface:consumer -- --artifact "${artifact}"
+
+      - name: Publish to the public npm registry
+        shell: bash
+        run: |
+          set -euo pipefail
+          package_version="$(node -p "require('./packages/freecut-editor/package.json').version")"
+          artifact="artifacts/freecut-editor-surface-${package_version}.tgz"
+          test -f "${artifact}"
+          if npm view "@quantfive/freecut-editor-surface@${package_version}" version >/dev/null 2>&1; then
+            echo "::notice::@quantfive/freecut-editor-surface@${package_version} is already published; nothing to do."
+            exit 0
+          fi
+          npm publish "./${artifact}" --provenance --access public
diff --git a/.github/workflows/reproducible-package.yml b/.github/workflows/reproducible-package.yml
new file mode 100644
index 000000000..5cf59cdfe
--- /dev/null
+++ b/.github/workflows/reproducible-package.yml
@@ -0,0 +1,49 @@
+name: Reproducible Package Baseline
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+      - staging
+
+permissions:
+  contents: read
+
+jobs:
+  package:
+    name: Verify and package baseline
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.14.0'
+          cache: npm
+
+      - name: Select pinned npm
+        run: npm install --global npm@11.8.0
+
+      - name: Install locked dependencies
+        run: npm ci --ignore-scripts
+
+      - name: Verify provenance, dependency, and asset inventories
+        run: npm run verify:provenance
+
+      - name: Build and package
+        run: npm run package:reproducible
+
+      - name: Rebuild and compare package bytes
+        shell: bash
+        run: |
+          artifact="$(find artifacts -maxdepth 1 -type f -name 'freecut-*.tar.gz' -print -quit)"
+          test -n "$artifact"
+          cp "$artifact" "$RUNNER_TEMP/freecut-first.tar.gz"
+          npm run package:reproducible
+          cmp --silent "$RUNNER_TEMP/freecut-first.tar.gz" "$artifact"
diff --git a/.github/workflows/sync-upstream.yml b/.github/workflows/sync-upstream.yml
new file mode 100644
index 000000000..2d266ebdd
--- /dev/null
+++ b/.github/workflows/sync-upstream.yml
@@ -0,0 +1,38 @@
+# Keep `main` a clean mirror of upstream walterlow/freecut.
+#
+# Nothing CodePress-owned is ever committed to `main`. Our work lives on the
+# `codepress-main` integration branch, and upstream reaches it through a reviewed
+# PR (`main` -> `codepress-main`) rather than by landing here directly. That keeps
+# `gh repo sync` a fast-forward, so this job never has to resolve a conflict
+# unattended.
+name: sync-upstream
+
+on:
+  schedule:
+    - cron: "0 8 * * 1" # Mondays, 08:00 UTC
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fast-forward main from upstream
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh repo sync ${{ github.repository }} --source walterlow/freecut --branch main
+
+      # Surface the delta so upstream drift is visible without anyone going
+      # looking for it. This opens nothing and merges nothing by itself.
+      - name: Report how far codepress-main trails main
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          behind="$(gh api "repos/${{ github.repository }}/compare/codepress-main...main" --jq '.ahead_by')"
+          if [ "${behind:-0}" -gt 0 ]; then
+            echo "::warning::codepress-main is $behind commit(s) behind upstream main. Open a PR from main into codepress-main to integrate."
+          else
+            echo "codepress-main is up to date with upstream main."
+          fi
diff --git a/docs/pr2-provenance-and-packaging.md b/docs/pr2-provenance-and-packaging.md
new file mode 100644
index 000000000..b8028bee4
--- /dev/null
+++ b/docs/pr2-provenance-and-packaging.md
@@ -0,0 +1,46 @@
+# PR2 provenance and reproducible packaging
+
+This fork baseline is the mechanical deliverable for [CodePress issue #5319](https://github.com/quantfive/codepress/issues/5319), PR 2. It records the selected FreeCut source and makes a clean install, build, and package check repeatable. It does not add editor behavior, embed commands, CodePress integration, or the PR 3 adapter.
+
+## Source of record
+
+The selected upstream is [`walterlow/freecut`](https://github.com/walterlow/freecut), the repository named by issue #5319. The requested [`FreeCutEditor/freecut`](https://github.com/FreeCutEditor/freecut) path was not resolvable when the fork was created. The fork is [`quantfive/freecut`](https://github.com/quantfive/freecut).
+
+The exact source revision is:
+
+```text
+4d62e8082c5eb387a96275bcbd323d28f6e41a62
+```
+
+`provenance/freecut-baseline.json` records the commit, Git tree, deterministic `git archive` checksum, fork URL, and the retained MIT license checksum. The source archive checksum is computed over:
+
+```bash
+SOURCE_DATE_EPOCH=0 git archive --format=tar \
+  --prefix=freecut-4d62e8082c5eb387a96275bcbd323d28f6e41a62/ \
+  4d62e8082c5eb387a96275bcbd323d28f6e41a62 | shasum -a 256
+```
+
+The existing `LICENSE`, `src/infrastructure/audio/THIRD_PARTY_LICENSE`, and Anime4K `NOTICE.md` are retained and copied into the package artifact's notices directory. The existing bundled Anime4K weights remain unchanged; their upstream attribution is preserved in that notice.
+
+## Inventories
+
+- `provenance/dependency-inventory.json` records every direct runtime and development dependency exactly as declared by `package.json`, plus the lockfile version and checksum. The lockfile is the install source of truth; this PR does not upgrade dependencies.
+- `provenance/asset-inventory.json` records tracked public assets, source preview assets, and the bundled Anime4K model/notice directory by file count, byte count, and a canonical SHA-256 inventory hash.
+- `provenance/freecut-baseline.json` lists the optional model identifiers and network services that are deliberately not package inputs.
+
+The optional model code remains in the upstream source, but its weights/caches are not downloaded by the package command. The baseline also excludes the loopback headless `/v1` service, remote font/Lottie services, model/CDN endpoints, Remotion, and all CodePress backend/UI/command-contract work. These exclusions are documentation and packaging boundaries only; they do not change runtime behavior.
+
+## Clean reproducible package
+
+Use Node.js 22.14.0 and npm 11.8.0, matching the CI workflow:
+
+```bash
+npm install --global npm@11.8.0
+npm ci --ignore-scripts
+npm run verify:provenance
+npm run package:reproducible
+```
+
+`package:reproducible` removes the ignored `dist/` output, runs the production build, verifies provenance/inventory checks, and writes `artifacts/freecut-<source-revision>.tar.gz`. The archive has sorted paths, normalized metadata, zero timestamps, and uid/gid 0. It contains the built `dist/`, package manifests, provenance manifests, the MIT license, and retained notices.
+
+Run the command twice and compare the resulting archive with `cmp` to verify byte-for-byte reproducibility. CI performs that comparison on every pull request and push to `main` or `staging`.
diff --git a/package.json b/package.json
index e93f1a6d3..5e5d5cdb4 100644
--- a/package.json
+++ b/package.json
@@ -8,11 +8,16 @@
     "dev:quiet": "vp dev --host --mode perf",
     "dev:compare": "node scripts/run-dev-and-perf.mjs",
     "build": "vp build",
+    "build:editor-surface": "vp build --config vite.editor-package.config.ts",
+    "test:editor-surface:consumer": "node scripts/test-editor-surface-consumer.mjs",
+    "verify:provenance": "node scripts/package-reproducible.mjs --verify-only",
+    "package:reproducible": "node scripts/package-reproducible.mjs",
+    "package:editor-surface": "node scripts/package-editor-surface.mjs",
     "build:perf": "vp build --mode perf",
-    "lint": "vp lint src headless vite.config.ts",
-    "lint:fix": "vp lint src headless vite.config.ts --fix",
-    "format": "vp fmt src headless vite.config.ts package.json .oxlintrc.json .oxfmtrc.json",
-    "format:check": "vp fmt src headless vite.config.ts package.json .oxlintrc.json .oxfmtrc.json --check",
+    "lint": "vp lint src packages/freecut-editor/src packages/freecut-editor/consumer-smoke.test.tsx packages/freecut-editor/consumer-smoke.setup.ts packages/freecut-editor/consumer-smoke-style.d.ts scripts/package-editor-surface.mjs scripts/test-editor-surface-consumer.mjs headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts",
+    "lint:fix": "vp lint src packages/freecut-editor/src packages/freecut-editor/consumer-smoke.test.tsx packages/freecut-editor/consumer-smoke.setup.ts packages/freecut-editor/consumer-smoke-style.d.ts scripts/package-editor-surface.mjs scripts/test-editor-surface-consumer.mjs headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts --fix",
+    "format": "vp fmt src packages/freecut-editor/src packages/freecut-editor/consumer-smoke.test.tsx packages/freecut-editor/consumer-smoke.setup.ts packages/freecut-editor/consumer-smoke-style.d.ts scripts/package-editor-surface.mjs scripts/test-editor-surface-consumer.mjs headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts package.json packages/freecut-editor/package.json .oxlintrc.json .oxfmtrc.json",
+    "format:check": "vp fmt src packages/freecut-editor/src packages/freecut-editor/consumer-smoke.test.tsx packages/freecut-editor/consumer-smoke.setup.ts packages/freecut-editor/consumer-smoke-style.d.ts scripts/package-editor-surface.mjs scripts/test-editor-surface-consumer.mjs headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts package.json packages/freecut-editor/package.json .oxlintrc.json .oxfmtrc.json --check",
     "check:boundaries": "node scripts/check-feature-boundaries.mjs",
     "check:deps-contracts": "node scripts/check-deps-contract-boundaries.mjs",
     "check:legacy-lib-imports": "node scripts/check-legacy-lib-imports.mjs",
@@ -24,8 +29,8 @@
     "check:edge-budgets": "node scripts/check-feature-edge-budgets.mjs",
     "report:feature-edges": "node scripts/report-feature-edges.mjs",
     "report:feature-edges:json": "node scripts/report-feature-edges.mjs --json",
-    "check": "vp check --no-fmt src headless vite.config.ts",
-    "check:fix": "vp check src headless vite.config.ts package.json .oxlintrc.json .oxfmtrc.json --fix",
+    "check": "vp check --no-fmt src packages/freecut-editor/src headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts",
+    "check:fix": "vp check src packages/freecut-editor/src headless vite.config.ts vite.editor-package.config.ts vite.editor-package.test.config.ts package.json packages/freecut-editor/package.json .oxlintrc.json .oxfmtrc.json --fix",
     "verify": "vp run check && vp run check:boundaries && vp run check:deps-contracts && vp run check:legacy-lib-imports && vp run check:deps-wrapper-health && vp run check:unused-exports && vp run check:unused-class-members && vp run check:changed-health && vp run check:edge-budgets && vp test run && vp build && npm run headless:test:portable",
     "preview": "vp preview",
     "preview:perf": "vp preview --host --strictPort --port 4173",
diff --git a/packages/freecut-editor/LICENSE b/packages/freecut-editor/LICENSE
new file mode 100644
index 000000000..887b52acb
--- /dev/null
+++ b/packages/freecut-editor/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FreeCut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/freecut-editor/README.md b/packages/freecut-editor/README.md
new file mode 100644
index 000000000..686a51203
--- /dev/null
+++ b/packages/freecut-editor/README.md
@@ -0,0 +1,74 @@
+# `@quantfive/freecut-editor-surface`
+
+This package is the versioned browser entry for FreeCut's host-backed editor
+surface. It exports the real `FreeCutEditorSurface`, the `EditorHostProvider`,
+and the typed host contract used to supply authoritative project state, media
+resolution, and bounded edit submission.
+
+The package owns the editor UI and in-memory browser runtime only. The host
+owns authentication, persistence, transport, media bytes, and short-lived
+media resolution. It does not include the standalone FreeCut app, router
+provider, workspace bootstrap, headless services, or local project storage
+bootstrap.
+
+## Usage
+
+```tsx
+import { FreeCutEditorSurface, type EditorHost } from '@quantfive/freecut-editor-surface'
+import '@quantfive/freecut-editor-surface/style.css'
+
+export function HostEditor({ host }: { host: EditorHost }) {
+  return <FreeCutEditorSurface host={host} />
+}
+```
+
+The `EditorHost` contract carries opaque media locators and authoritative
+snapshots. It never accepts filesystem paths, permanent URLs, provider keys,
+or media bytes. Supported edits are submitted through `submitEdit`; rejected
+or conflicting results return an authoritative snapshot to the surface. The
+0.3.0 surface adds an optional host-backed transcript consumer. Hosts opt into the
+transcript tab by providing `EditorHost.transcript` and explicitly enabling
+`media.transcription`. The port returns a compact status receipt and bounded
+microsecond sections, and previews source-bound caption commands with
+`willMutateTimeline: false`; only an explicit user action submits that returned
+batch through `submitEdit`. Transcript IDs, asset IDs, source hashes, cursors,
+and structured errors are opaque browser data—authentication, transport,
+provider details, URLs, paths, and media bytes remain host-owned.
+
+The same 0.3.0 surface retains the host-backed caption tracks, bounded cues,
+caption styles, and display toggles from 0.2.0.
+
+This package is built from a specific FreeCut commit. To create the local
+consumer artifact from a clean checkout, run:
+
+```bash
+npm ci --ignore-scripts
+npm run package:editor-surface
+```
+
+The command writes a deterministic tarball to `artifacts/`, which the
+workflow in `.github/workflows/publish-editor-surface.yml` then publishes.
+
+The package is published to the **public npm registry**. It is MIT licensed
+and built from a public repository, so there is no credential to distribute
+and no per-consumer access to grant.
+
+Releases publish from CI using npm trusted publishing (OIDC): the workflow
+exchanges its GitHub Actions identity token for a short-lived npm credential.
+There is no `NPM_TOKEN` secret in this repository, and none should be added.
+The trusted publisher is configured on npmjs.com against this repository and
+`.github/workflows/publish-editor-surface.yml`; changing that filename breaks
+publishing until the publisher entry is updated to match.
+
+Consumers need no registry configuration at all:
+
+```bash
+npm install @quantfive/freecut-editor-surface
+```
+
+It can then install the exact published version and keep it pinned in its
+lockfile:
+
+```bash
+npm install @quantfive/freecut-editor-surface@0.3.0
+```
diff --git a/packages/freecut-editor/consumer-smoke-style.d.ts b/packages/freecut-editor/consumer-smoke-style.d.ts
new file mode 100644
index 000000000..8141b9430
--- /dev/null
+++ b/packages/freecut-editor/consumer-smoke-style.d.ts
@@ -0,0 +1 @@
+declare module '@quantfive/freecut-editor-surface/style.css' {}
diff --git a/packages/freecut-editor/consumer-smoke.setup.ts b/packages/freecut-editor/consumer-smoke.setup.ts
new file mode 100644
index 000000000..760be9d9b
--- /dev/null
+++ b/packages/freecut-editor/consumer-smoke.setup.ts
@@ -0,0 +1,14 @@
+const storageState = new Map<string, string>()
+const storage: Storage = {
+  get length() {
+    return storageState.size
+  },
+  clear: () => storageState.clear(),
+  getItem: (key) => storageState.get(key) ?? null,
+  key: (index) => Array.from(storageState.keys())[index] ?? null,
+  removeItem: (key) => storageState.delete(key),
+  setItem: (key, value) => storageState.set(key, String(value)),
+}
+
+Object.defineProperty(window, 'localStorage', { configurable: true, value: storage })
+Object.defineProperty(globalThis, 'localStorage', { configurable: true, value: storage })
diff --git a/packages/freecut-editor/consumer-smoke.test.tsx b/packages/freecut-editor/consumer-smoke.test.tsx
new file mode 100644
index 000000000..ee07086cd
--- /dev/null
+++ b/packages/freecut-editor/consumer-smoke.test.tsx
@@ -0,0 +1,97 @@
+// @vitest-environment jsdom
+
+import '@testing-library/jest-dom'
+import '@quantfive/freecut-editor-surface/style.css'
+import { render, screen, waitFor } from '@testing-library/react'
+import { beforeAll, describe, expect, it, vi } from 'vite-plus/test'
+import {
+  FreeCutEditorSurface,
+  capabilityForCommand,
+  isHostCapabilityEnabled,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+} from '@quantfive/freecut-editor-surface'
+
+const snapshot: EmbeddedEditorSnapshot = {
+  project: {
+    id: 'consumer-smoke-project',
+    name: 'Consumer smoke project',
+    width: 1920,
+    height: 1080,
+    fps: 30,
+  },
+  timeline: {
+    timelineId: 'consumer-smoke-timeline',
+    revision: 0,
+    fps: 30,
+    durationInFrames: 300,
+    media: [],
+    tracks: [],
+    width: 1920,
+    height: 1080,
+  },
+  assets: [],
+}
+
+function fakeHost(): EditorHost {
+  return {
+    capabilities: {
+      'media.resolve': true,
+      'timeline.add': false,
+    },
+    load: vi.fn(() => snapshot),
+    resolveMedia: vi.fn(() => null),
+    submitEdit: vi.fn(() => {
+      throw new Error('consumer smoke does not submit an edit')
+    }),
+  }
+}
+
+beforeAll(() => {
+  class TestResizeObserver {
+    observe(): void {}
+    unobserve(): void {}
+    disconnect(): void {}
+  }
+  Object.assign(globalThis, {
+    ResizeObserver: TestResizeObserver,
+    requestIdleCallback: (callback: IdleRequestCallback) =>
+      setTimeout(() => callback({ didTimeout: false, timeRemaining: () => 50 }), 0),
+    cancelIdleCallback: (id: number) => clearTimeout(id),
+  })
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    value: () => ({
+      matches: false,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false,
+    }),
+  })
+  HTMLElement.prototype.scrollIntoView = () => {}
+})
+
+describe('published FreeCut browser entry', () => {
+  it('imports the package entry, mounts the real editor surfaces, and keeps host capability gates bounded', async () => {
+    const host = fakeHost()
+    render(<FreeCutEditorSurface host={host} />)
+
+    await waitFor(
+      () => {
+        expect(screen.getAllByRole('toolbar').length).toBeGreaterThanOrEqual(2)
+        expect(screen.getByRole('region', { name: 'Preview area' })).toBeInTheDocument()
+        expect(screen.getByText('Timeline')).toBeInTheDocument()
+      },
+      { timeout: 10_000 },
+    )
+
+    expect(screen.getByTestId('properties-clip-panel-host')).toBeInTheDocument()
+    expect(await screen.findByTestId('caption-editor')).toBeInTheDocument()
+    expect(host.load).toHaveBeenCalledTimes(1)
+    expect(capabilityForCommand('move_item')).toBe('timeline.move')
+    expect(capabilityForCommand('set_caption_style')).toBe('timeline.caption')
+    expect(isHostCapabilityEnabled(host.capabilities, 'timeline.add')).toBe(false)
+  })
+})
diff --git a/packages/freecut-editor/package.json b/packages/freecut-editor/package.json
new file mode 100644
index 000000000..5cabd7076
--- /dev/null
+++ b/packages/freecut-editor/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "@quantfive/freecut-editor-surface",
+  "version": "0.3.0",
+  "description": "The host-backed FreeCut browser editor surface.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/quantfive/freecut.git",
+    "directory": "packages/freecut-editor"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": [
+    "./dist/style.css"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./style.css": "./dist/style.css",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "6.9.1",
+    "@testing-library/react": "16.3.2",
+    "vite-plus": "0.2.4"
+  },
+  "peerDependencies": {
+    "react": ">=19.2.0 <20",
+    "react-dom": ">=19.2.0 <20"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}
diff --git a/packages/freecut-editor/src/index.d.ts b/packages/freecut-editor/src/index.d.ts
new file mode 100644
index 000000000..1ca774a12
--- /dev/null
+++ b/packages/freecut-editor/src/index.d.ts
@@ -0,0 +1,391 @@
+import type { ComponentType, ReactNode } from 'react'
+
+export type EditorCapability =
+  | 'project.navigate'
+  | 'project.save'
+  | 'media.resolve'
+  | 'media.import'
+  | 'media.delete'
+  | 'media.proxy'
+  | 'media.transcription'
+  | 'media.relink'
+  | 'timeline.add'
+  | 'timeline.move'
+  | 'timeline.trim'
+  | 'timeline.split'
+  | 'timeline.remove'
+  | 'timeline.track'
+  | 'timeline.caption'
+  | 'workspace.edit'
+  | 'workspace.color'
+  | 'workspace.motion'
+  | 'export.video'
+  | 'export.bundle'
+  | 'render.queue'
+
+export type EditorCapabilityMap = Readonly<Partial<Record<EditorCapability, boolean>>>
+
+export type HostMediaKind = 'video' | 'audio' | 'image' | 'lottie'
+
+export interface MediaLocator {
+  mediaId: string
+  kind: HostMediaKind
+  variant?: 'source' | 'proxy' | 'thumbnail'
+}
+
+export interface ResolvedMediaLocator {
+  source: string
+  audioSource?: string
+  expiresAt?: number
+}
+
+export interface EmbeddedEditorProject {
+  id: string
+  name: string
+  width: number
+  height: number
+  fps: number
+  backgroundColor?: string
+}
+
+export interface MediaReference {
+  media_id: string
+  media_kind: Exclude<HostMediaKind, 'lottie'>
+  content_hash: string
+  duration_us: number | null
+  availability:
+    | {
+        mode: 'local'
+        local: { device_id: string; root_id: string; file_id: string; root_generation: number }
+      }
+    | { mode: 'cloud'; cloud: { object_id: string } }
+    | {
+        mode: 'hybrid'
+        local: { device_id: string; root_id: string; file_id: string; root_generation: number }
+        cloud: { object_id: string }
+      }
+}
+
+export type FrameRateLike = number | { numerator: bigint; denominator: bigint; value: number }
+
+export interface CaptionStyle {
+  font_family?: string
+  font_size?: number
+  color?: string
+  background_color?: string
+  background_opacity?: number
+  alignment?: 'left' | 'center' | 'right'
+}
+
+export interface FreeCutFrameClip {
+  type: 'video' | 'audio' | 'image'
+  id: string
+  trackId: string
+  mediaId: string
+  from: number
+  durationInFrames: number
+  sourceStart?: number
+  sourceEnd?: number
+  volume?: number
+  speed?: number
+  opacity?: number
+  transform?: Record<string, number>
+}
+
+export interface FreeCutFrameText {
+  type: 'text'
+  id: string
+  trackId: string
+  from: number
+  durationInFrames: number
+  text: string
+  style?: Record<string, string | number>
+  opacity?: number
+  transform?: Record<string, number>
+}
+
+export interface FreeCutFrameCaptionCue {
+  type: 'caption_cue'
+  id: string
+  trackId: string
+  from: number
+  durationInFrames: number
+  text: string
+  speaker?: string | null
+  style?: CaptionStyle
+}
+
+export type FreeCutFrameItem = FreeCutFrameClip | FreeCutFrameText | FreeCutFrameCaptionCue
+
+export interface FreeCutFrameTrack {
+  id: string
+  kind: 'video' | 'audio' | 'overlay' | 'caption'
+  name: string
+  language?: string
+  locked: boolean
+  muted: boolean
+  defaultStyle?: CaptionStyle | null
+  items: readonly FreeCutFrameItem[]
+}
+
+export interface FreeCutFrameDocument {
+  timelineId: string
+  revision: number
+  fps: FrameRateLike
+  durationInFrames: number
+  media: readonly MediaReference[]
+  tracks: readonly FreeCutFrameTrack[]
+  width: number
+  height: number
+  backgroundColor?: string
+}
+
+export interface EmbeddedEditorAsset {
+  id: string
+  kind: HostMediaKind
+  fileName: string
+  mimeType: string
+  durationSeconds: number
+  width: number
+  height: number
+  fps: number
+  fileSize?: number
+  contentHash?: string
+  thumbnailLocator?: MediaLocator
+}
+
+export interface EmbeddedEditorSnapshot {
+  project: EmbeddedEditorProject
+  timeline: FreeCutFrameDocument
+  assets: readonly EmbeddedEditorAsset[]
+}
+
+export interface HostNotice {
+  kind: 'info' | 'warning' | 'error' | 'unsupported' | 'conflict'
+  message: string
+  operationId?: string
+}
+
+export declare const MAX_TRANSCRIPT_SELECTIONS: number
+export declare const MAX_TRANSCRIPT_SECTION_PAGE_SIZE: number
+export declare const MAX_TRANSCRIPT_SECTION_TEXT_BYTES: number
+export declare const MAX_TRANSCRIPT_COMMAND_TEXT_BYTES: number
+export declare const MAX_TRANSCRIPT_DURATION_US: number
+export declare const MAX_TRANSCRIPT_CURSOR_LENGTH: number
+export declare const MAX_TRANSCRIPT_QUERY_LENGTH: number
+
+export type HostTranscriptStatus =
+  | 'pending'
+  | 'running'
+  | 'succeeded'
+  | 'failed'
+  | 'stale'
+  | 'purged'
+
+export interface HostTranscriptError {
+  code: string
+  message: string
+  retryable: boolean
+  details?: Readonly<Record<string, unknown>>
+}
+
+export interface HostTranscriptStatusReceipt {
+  transcriptId: string
+  assetId: string | null
+  sourceAssetHash: string
+  status: HostTranscriptStatus
+  language?: string | null
+  durationUs: number | null
+  sectionCount: number
+  error?: HostTranscriptError | null
+}
+
+export interface HostTranscriptSection {
+  id: string
+  transcriptId: string
+  ordinal: number
+  startUs: number
+  endUs: number
+  text: string
+  speaker?: string | null
+}
+
+export interface HostTranscriptSectionsRequest {
+  transcriptId: string
+  cursor?: string | null
+  limit?: number
+  startUs?: number
+  endUs?: number
+}
+
+export interface HostTranscriptSectionsPage {
+  transcriptId: string
+  sections: readonly HostTranscriptSection[]
+  nextCursor?: string | null
+  hasMore: boolean
+}
+
+export interface HostTranscriptSearchRequest {
+  transcriptId: string
+  query: string
+  cursor?: string | null
+  limit?: number
+}
+
+export interface HostTranscriptSearchPage {
+  transcriptId: string
+  query: string
+  sections: readonly HostTranscriptSection[]
+  nextCursor?: string | null
+  hasMore: boolean
+}
+
+export interface HostTranscriptRange {
+  startUs: number
+  endUs: number
+  text?: string
+}
+
+export type HostTranscriptCommandAction = 'cut' | 'captions' | 'ripple_cut' | 'caption'
+
+export interface HostTranscriptCommandPreviewRequest {
+  transcriptId: string
+  assetId: string
+  sourceAssetHash: string
+  operationId: string
+  idempotencyKey: string
+  baseRevision: number
+  action: HostTranscriptCommandAction
+  timestampCapability: 'section' | 'word' | 'frame'
+  sectionIds?: readonly string[]
+  ranges?: readonly HostTranscriptRange[]
+  captionTrackId?: string
+  captionTrackName?: string
+  captionLanguage?: string | null
+  preconditions?: readonly object[]
+}
+
+export interface HostTranscriptCommandPreview {
+  status: 'preview' | 'replayed'
+  receiptId: string
+  transcriptId: string
+  assetId: string
+  sourceAssetHash: string
+  timestampCapability: 'section'
+  timelineId: string
+  operationId: string
+  idempotencyKey: string
+  baseRevision: number
+  commandBatch: EditCommandBatch
+  preview: Readonly<{
+    action?: string
+    sectionCount?: number
+    captionCount?: number
+    willMutateTimeline: false
+    [key: string]: unknown
+  }>
+}
+
+export interface EditorTranscriptPort {
+  getStatus(): Promise<HostTranscriptStatusReceipt | null> | HostTranscriptStatusReceipt | null
+  getSections(
+    request: HostTranscriptSectionsRequest,
+  ): Promise<HostTranscriptSectionsPage> | HostTranscriptSectionsPage
+  search?(
+    request: HostTranscriptSearchRequest,
+  ): Promise<HostTranscriptSearchPage> | HostTranscriptSearchPage
+  previewCommands(
+    request: HostTranscriptCommandPreviewRequest,
+  ): Promise<HostTranscriptCommandPreview> | HostTranscriptCommandPreview
+}
+
+export interface HostAppliedEditResult {
+  status: 'applied' | 'replayed'
+  snapshot: EmbeddedEditorSnapshot
+  result: Record<string, unknown>
+}
+
+export interface HostConflictResult {
+  status: 'conflict' | 'rejected'
+  snapshot: EmbeddedEditorSnapshot
+  result: Record<string, unknown>
+}
+
+export type HostEditResult = HostAppliedEditResult | HostConflictResult
+
+export interface EditCommand {
+  type: string
+  command_id?: string
+  [field: string]: unknown
+}
+
+export interface EditCommandBatch {
+  contract_version: 1
+  timeline_id: string
+  operation_id: string
+  idempotency_key: string
+  base_revision: number
+  preconditions: readonly object[]
+  commands: readonly EditCommand[]
+}
+
+export interface EditorHostNavigation {
+  back(): void
+}
+
+export interface EditorHost {
+  readonly capabilities: EditorCapabilityMap
+  load(): Promise<EmbeddedEditorSnapshot> | EmbeddedEditorSnapshot
+  resolveMedia(
+    locator: MediaLocator,
+  ): Promise<ResolvedMediaLocator | null> | ResolvedMediaLocator | null
+  submitEdit(batch: EditCommandBatch): Promise<HostEditResult> | HostEditResult
+  transcript?: EditorTranscriptPort
+  navigation?: EditorHostNavigation
+  notify?(notice: HostNotice): void
+}
+
+export type LocalEditorHostOptions = Omit<EditorHost, 'capabilities'> & {
+  capabilities?: EditorCapabilityMap
+}
+
+export interface EditorHostContextValue {
+  mode: 'local' | 'host'
+  capabilities: EditorCapabilityMap
+  host?: EditorHost
+}
+
+export interface EditorHostProviderProps {
+  value: EditorHostContextValue
+  children: ReactNode
+}
+
+export interface FreeCutEditorSurfaceProps {
+  host: EditorHost
+}
+
+export declare const FreeCutEditorSurface: ComponentType<FreeCutEditorSurfaceProps>
+export declare const EditorHostProvider: ComponentType<EditorHostProviderProps>
+export declare const DEFAULT_HOST_CAPABILITIES: EditorCapabilityMap
+export declare const SUPPORTED_HOST_COMMANDS: readonly [
+  'add_clip',
+  'add_text',
+  'move_item',
+  'trim_item',
+  'split_item',
+  'remove_item',
+  'add_track',
+  'update_track',
+  'add_caption_track',
+  'remove_caption_track',
+  'update_caption_track',
+  'upsert_caption_cues',
+  'remove_caption_cues',
+  'set_caption_style',
+]
+export declare function capabilityForCommand(command: string): EditorCapability | null
+export declare function isHostCapabilityEnabled(
+  capabilities: EditorCapabilityMap,
+  capability: EditorCapability,
+): boolean
+export declare function createLocalEditorHost(options: LocalEditorHostOptions): EditorHost
diff --git a/packages/freecut-editor/src/index.ts b/packages/freecut-editor/src/index.ts
new file mode 100644
index 000000000..ac374e68d
--- /dev/null
+++ b/packages/freecut-editor/src/index.ts
@@ -0,0 +1,48 @@
+export { FreeCutEditorSurface } from '@/features/editor/host/editor-surface'
+export { EditorHostProvider } from '@/features/editor/host/context-provider'
+export {
+  DEFAULT_HOST_CAPABILITIES,
+  MAX_TRANSCRIPT_COMMAND_TEXT_BYTES,
+  MAX_TRANSCRIPT_CURSOR_LENGTH,
+  MAX_TRANSCRIPT_DURATION_US,
+  MAX_TRANSCRIPT_QUERY_LENGTH,
+  MAX_TRANSCRIPT_SECTION_PAGE_SIZE,
+  MAX_TRANSCRIPT_SECTION_TEXT_BYTES,
+  MAX_TRANSCRIPT_SELECTIONS,
+  SUPPORTED_HOST_COMMANDS,
+  capabilityForCommand,
+  createLocalEditorHost,
+  isHostCapabilityEnabled,
+} from '@/features/editor/host/contract'
+export type { EditorHostContextValue } from '@/features/editor/host/context'
+export type { EditorHostProviderProps } from '@/features/editor/host/context-provider'
+export type {
+  EditorCapability,
+  EditorCapabilityMap,
+  EditorHost,
+  EditorHostNavigation,
+  EmbeddedEditorAsset,
+  EmbeddedEditorProject,
+  EmbeddedEditorSnapshot,
+  EditorTranscriptPort,
+  HostAppliedEditResult,
+  HostConflictResult,
+  HostEditResult,
+  HostMediaKind,
+  HostNotice,
+  HostTranscriptCommandAction,
+  HostTranscriptCommandPreview,
+  HostTranscriptCommandPreviewRequest,
+  HostTranscriptError,
+  HostTranscriptRange,
+  HostTranscriptSearchPage,
+  HostTranscriptSearchRequest,
+  HostTranscriptSection,
+  HostTranscriptSectionsPage,
+  HostTranscriptSectionsRequest,
+  HostTranscriptStatus,
+  HostTranscriptStatusReceipt,
+  LocalEditorHostOptions,
+  MediaLocator,
+  ResolvedMediaLocator,
+} from '@/features/editor/host/contract'
diff --git a/packages/freecut-editor/tsconfig.json b/packages/freecut-editor/tsconfig.json
new file mode 100644
index 000000000..b0ace0222
--- /dev/null
+++ b/packages/freecut-editor/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowImportingTsExtensions": false,
+    "declaration": false,
+    "declarationMap": false,
+    "emitDeclarationOnly": false,
+    "noCheck": true,
+    "noEmit": true,
+    "rootDir": "../..",
+    "paths": {
+      "@/*": ["../../src/*"]
+    },
+    "types": ["vite/client", "vite-plus/test/globals", "@webgpu/types"]
+  },
+  "include": ["./src/index.ts"]
+}
diff --git a/provenance/asset-inventory.json b/provenance/asset-inventory.json
new file mode 100644
index 000000000..430f5afeb
--- /dev/null
+++ b/provenance/asset-inventory.json
@@ -0,0 +1,42 @@
+{
+  "schema": "freecut-pr2-asset-inventory/v1",
+  "hashAlgorithm": "sha256",
+  "hashInput": "Sorted tracked file records encoded as path\\0byteCount\\0fileSha256\\n; the path is repository-relative and uses POSIX separators.",
+  "roots": [
+    {
+      "path": "public",
+      "kind": "public static assets and vendored runtime files",
+      "fileCount": 29,
+      "byteCount": 21860045,
+      "sha256": "6b1ad3214755ed907957f379982188a5e19faf29aa267564f21ed94552f29e94"
+    },
+    {
+      "path": "src/features/editor/components/transition-preview/frame-a.svg",
+      "kind": "transition preview asset",
+      "fileCount": 1,
+      "byteCount": 706,
+      "sha256": "cae3704ccb0193cfc4974dbf59107927e7694080e9c413d84059ab6572abcc5e"
+    },
+    {
+      "path": "src/features/editor/components/transition-preview/frame-b.svg",
+      "kind": "transition preview asset",
+      "fileCount": 1,
+      "byteCount": 898,
+      "sha256": "c6ee514594706fca2f4dc35e3cd24a562714dd45d7844a0a867d4552e375e221"
+    },
+    {
+      "path": "src/features/effects/components/effect-thumbnail/sample.svg",
+      "kind": "effect thumbnail asset",
+      "fileCount": 1,
+      "byteCount": 1166,
+      "sha256": "9d93be5689130f439b447f14294683a0af321b0cb9cc2c12850f6b0b181b49f9"
+    },
+    {
+      "path": "src/infrastructure/upscale/models",
+      "kind": "bundled Anime4K weights and retained notice/source",
+      "fileCount": 5,
+      "byteCount": 47322,
+      "sha256": "e3a2c4bbe898303f3ff1a4dd7d69b12aaacdd078d8a6a76a66971258155864d0"
+    }
+  ]
+}
diff --git a/provenance/dependency-inventory.json b/provenance/dependency-inventory.json
new file mode 100644
index 000000000..a9efc1877
--- /dev/null
+++ b/provenance/dependency-inventory.json
@@ -0,0 +1,85 @@
+{
+  "schema": "freecut-pr2-dependency-inventory/v1",
+  "generatedFrom": "package.json",
+  "packageName": "freecut",
+  "packageVersion": "0.0.0",
+  "packageJsonSha256": "331cb27e2fa2e50dbf9759e625e6d2b9c97db2205ee5870c8157ffbb2b14f971",
+  "lockfile": {
+    "path": "package-lock.json",
+    "lockfileVersion": 3,
+    "sha256": "b4a86741ce7891da1f63df01b6fdd4ed507e8887d5097c6a0f93fc2ea6f3420e"
+  },
+  "directDependencies": {
+    "dependencies": {
+      "@hookform/resolvers": "5.2.2",
+      "@huggingface/transformers": "4.1.0",
+      "@lottiefiles/dotlottie-web": "0.76.0",
+      "@mediabunny/aac-encoder": "1.50.8",
+      "@mediabunny/ac3": "1.50.8",
+      "@mediabunny/mp3-encoder": "1.50.8",
+      "@mediabunny/prores": "1.50.8",
+      "@radix-ui/react-accordion": "1.2.12",
+      "@radix-ui/react-alert-dialog": "1.1.15",
+      "@radix-ui/react-collapsible": "1.1.12",
+      "@radix-ui/react-context-menu": "2.2.16",
+      "@radix-ui/react-dialog": "1.1.15",
+      "@radix-ui/react-dropdown-menu": "2.1.16",
+      "@radix-ui/react-label": "2.1.8",
+      "@radix-ui/react-popover": "1.1.15",
+      "@radix-ui/react-progress": "1.1.8",
+      "@radix-ui/react-scroll-area": "1.2.10",
+      "@radix-ui/react-select": "2.2.6",
+      "@radix-ui/react-separator": "1.1.8",
+      "@radix-ui/react-slider": "1.3.6",
+      "@radix-ui/react-slot": "1.2.4",
+      "@radix-ui/react-switch": "1.2.6",
+      "@radix-ui/react-tabs": "1.1.13",
+      "@radix-ui/react-tooltip": "1.2.8",
+      "@tanstack/react-router": "1.168.22",
+      "@tanstack/react-virtual": "3.13.24",
+      "class-variance-authority": "0.7.1",
+      "clsx": "2.1.1",
+      "fflate": "0.8.2",
+      "gifuct-js": "2.1.2",
+      "i18next": "25.6.0",
+      "i18next-browser-languagedetector": "8.2.0",
+      "idb": "8.0.3",
+      "kokoro-js": "1.2.1",
+      "lucide-react": "0.468.0",
+      "mediabunny": "1.50.8",
+      "motion": "12.40.0",
+      "onnxruntime-web": "1.26.0-dev.20260410-5e55544225",
+      "react": "19.2.5",
+      "react-colorful": "5.6.1",
+      "react-dom": "19.2.5",
+      "react-hook-form": "7.72.1",
+      "react-hotkeys-hook": "5.2.4",
+      "react-i18next": "16.2.4",
+      "react-resizable-panels": "3.0.6",
+      "sonner": "2.0.7",
+      "tailwind-merge": "2.6.1",
+      "tailwindcss-animate": "1.0.7",
+      "zod": "4.3.6",
+      "zundo": "2.3.0",
+      "zustand": "5.0.12"
+    },
+    "devDependencies": {
+      "@tailwindcss/vite": "4.2.2",
+      "@tanstack/router-cli": "1.166.33",
+      "@testing-library/dom": "10.4.1",
+      "@testing-library/jest-dom": "6.9.1",
+      "@testing-library/react": "16.3.2",
+      "@types/node": "22.19.17",
+      "@types/react": "19.2.14",
+      "@types/react-dom": "19.2.3",
+      "@vitejs/plugin-react": "6.0.1",
+      "@vitest/coverage-v8": "4.1.10",
+      "@webgpu/types": "0.1.69",
+      "jsdom": "27.4.0",
+      "playwright": "1.60.0",
+      "tailwindcss": "4.2.2",
+      "typescript": "7.0.2",
+      "vite-plus": "0.2.4"
+    }
+  }
+}
diff --git a/provenance/freecut-baseline.json b/provenance/freecut-baseline.json
new file mode 100644
index 000000000..5346dde91
--- /dev/null
+++ b/provenance/freecut-baseline.json
@@ -0,0 +1,101 @@
+{
+  "schema": "freecut-pr2-provenance-baseline/v1",
+  "issue": "https://github.com/quantfive/codepress/issues/5319",
+  "scope": "PR 2 — FreeCut fork provenance and reproducible package baseline",
+  "upstream": {
+    "repository": "https://github.com/walterlow/freecut",
+    "fork": "https://github.com/quantfive/freecut",
+    "requestedRepository": "https://github.com/FreeCutEditor/freecut",
+    "requestedRepositoryStatus": "unavailable at baseline creation",
+    "selectionReason": "Issue #5319 identifies walterlow/freecut as the selected FreeCut source; the requested FreeCutEditor/freecut path was not resolvable.",
+    "revision": "4d62e8082c5eb387a96275bcbd323d28f6e41a62",
+    "revisionType": "git commit",
+    "tree": "54bf2dcc81213ba6669a6ecbed307e78dd552810",
+    "archive": {
+      "format": "tar",
+      "prefix": "freecut-4d62e8082c5eb387a96275bcbd323d28f6e41a62",
+      "sha256": "6429d2a2441502e923469332d997f3ddcb36bcfd968626e578a06b2cf9cbc7ad"
+    }
+  },
+  "license": {
+    "spdx": "MIT",
+    "path": "LICENSE",
+    "sha256": "af5b32e70d6c471cfb5f02b72dc289fd82622b7fb155c5a0332d1cc751533373"
+  },
+  "retainedNotices": [
+    {
+      "path": "src/infrastructure/audio/THIRD_PARTY_LICENSE",
+      "sha256": "a1a33180d02960ab1c5de36cf20b1a2f0fe9888d83826ad263da5db52f1b183b"
+    },
+    {
+      "path": "src/infrastructure/upscale/models/NOTICE.md",
+      "sha256": "0f82ace9b56ee97027c91838ece69c073fb2f4e58db441d23b80baab0c5a78fd"
+    }
+  ],
+  "dependencies": {
+    "packageJson": "package.json",
+    "packageJsonSha256": "331cb27e2fa2e50dbf9759e625e6d2b9c97db2205ee5870c8157ffbb2b14f971",
+    "lockfile": "package-lock.json",
+    "lockfileVersion": 3,
+    "lockfileSha256": "b4a86741ce7891da1f63df01b6fdd4ed507e8887d5097c6a0f93fc2ea6f3420e",
+    "inventory": "provenance/dependency-inventory.json"
+  },
+  "assets": {
+    "inventory": "provenance/asset-inventory.json",
+    "hashAlgorithm": "sha256"
+  },
+  "excludedOptionalModels": [
+    "Olicorne/parakeet-tdt-0.6b-v3-smoothquant-onnx",
+    "onnx-community/whisper-tiny_timestamped",
+    "onnx-community/whisper-base_timestamped",
+    "onnx-community/whisper-small_timestamped",
+    "onnx-community/whisper-large-v3-turbo_timestamped",
+    "onnx-community/gemma-4-E4B-it-ONNX",
+    "LiquidAI/LFM2.5-VL-450M-ONNX",
+    "Xenova/all-MiniLM-L6-v2",
+    "Xenova/clip-vit-base-patch32",
+    "Xenova/musicgen-small",
+    "onnx-community/Kokoro-82M-v1.0-ONNX",
+    "Supertone/supertonic-3",
+    "OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX",
+    "OpenMOSS-Team/MOSS-Audio-Tokenizer-Nano-ONNX",
+    "walterlow/RIFE_fp32_timestep"
+  ],
+  "excludedOptionalServices": [
+    "FreeCut headless loopback render service and its unauthenticated /v1 API",
+    "Hugging Face model APIs and model/CDN downloads",
+    "jsDelivr and esm.sh runtime CDN downloads",
+    "Google Fonts CSS API and remote font downloads",
+    "LottieFiles public GraphQL API and asset CDN",
+    "CodePress backend, command contract, adapters, and UI",
+    "Remotion and any procedural renderer integration"
+  ],
+  "packaging": {
+    "nodeMajor": 22,
+    "ciNodeVersion": "22.14.0",
+    "packageManager": "npm@11.8.0",
+    "installCommand": "npm ci --ignore-scripts",
+    "buildCommand": "npm run build",
+    "packageCommand": "npm run package:reproducible",
+    "artifactPattern": "artifacts/freecut-<source-revision>.tar.gz",
+    "archiveFormat": "deterministic tar.gz with sorted paths, zeroed mtimes, and uid/gid 0",
+    "contents": [
+      "dist/",
+      "LICENSE",
+      "notices/",
+      "package.json",
+      "package-lock.json",
+      "provenance/"
+    ]
+  },
+  "ciVerification": {
+    "workflow": ".github/workflows/reproducible-package.yml",
+    "checks": [
+      "source revision ancestry, tree, and archive checksum",
+      "MIT license and retained notice checksums",
+      "package and lockfile checksum plus direct dependency inventory",
+      "tracked asset counts, byte totals, and checksums",
+      "two package runs compare byte-for-byte"
+    ]
+  }
+}
diff --git a/scripts/package-editor-surface.mjs b/scripts/package-editor-surface.mjs
new file mode 100644
index 000000000..3a03bec16
--- /dev/null
+++ b/scripts/package-editor-surface.mjs
@@ -0,0 +1,207 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { execFileSync, spawnSync } from 'node:child_process'
+import { once } from 'node:events'
+import { fileURLToPath } from 'node:url'
+import { createGzip } from 'node:zlib'
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const PACKAGE_ROOT = path.join(ROOT, 'packages/freecut-editor')
+const DIST = path.join(PACKAGE_ROOT, 'dist')
+const ARTIFACTS = path.join(ROOT, 'artifacts')
+const packageJson = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'))
+const publishConfig = packageJson.publishConfig ?? {}
+const artifactName = `freecut-editor-surface-${packageJson.version}.tgz`
+const artifactPath = path.join(ARTIFACTS, artifactName)
+
+function fail(message) {
+  throw new Error(`[editor-surface-package] ${message}`)
+}
+
+function assertCondition(condition, message) {
+  if (!condition) fail(message)
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    cwd: ROOT,
+    env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' },
+    stdio: 'inherit',
+  })
+  assertCondition(result.status === 0, `${command} ${args.join(' ')} failed`)
+}
+
+function sha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex')
+}
+
+function packageFiles() {
+  const files = []
+  const visit = (directory) => {
+    for (const entry of fs.readdirSync(directory).sort()) {
+      const absolute = path.join(directory, entry)
+      const relative = path.relative(PACKAGE_ROOT, absolute).split(path.sep).join('/')
+      const stat = fs.lstatSync(absolute)
+      assertCondition(!stat.isSymbolicLink(), `symbolic link is not allowed: ${relative}`)
+      if (stat.isDirectory()) visit(absolute)
+      else if (stat.isFile()) files.push(relative)
+      else fail(`unsupported package input: ${relative}`)
+    }
+  }
+  visit(PACKAGE_ROOT)
+  return files
+}
+
+function verifyBuildBoundary() {
+  for (const required of ['index.js', 'index.d.ts', 'style.css']) {
+    assertCondition(fs.existsSync(path.join(DIST, required)), `missing package output: dist/${required}`)
+  }
+
+  const forbiddenImportPatterns = [
+    /(?:^|["'])@\/features\/workspace-gate\//,
+    /(?:^|["'])@\/headless\//,
+    /(?:^|["'])\.\/src\/headless\//,
+    /(?:^|["'])@\/app\.tsx?/,
+    /(?:^|["'])@\/infrastructure\/storage\/workspace-fs\/bootstrap/,
+    /(?:^|["'])@tanstack\/react-router["']/,
+  ]
+  for (const file of packageFiles().filter(
+    (candidate) => candidate.startsWith('dist/') && candidate.endsWith('.js'),
+  )) {
+    const javascript = fs.readFileSync(path.join(PACKAGE_ROOT, file), 'utf8')
+    for (const pattern of forbiddenImportPatterns) {
+      assertCondition(
+        !pattern.test(javascript),
+        `forbidden consumer dependency in ${file}: ${pattern}`,
+      )
+    }
+    assertCondition(!javascript.includes('@/'), `source alias leaked into ${file}`)
+    assertCondition(!javascript.includes('../../../src/'), `raw source-relative alias leaked into ${file}`)
+    assertCondition(!javascript.includes('/Users/'), `local filesystem path leaked into ${file}`)
+    assertCondition(!javascript.includes('file://'), `file URL leaked into ${file}`)
+  }
+}
+
+function verifyPackageInputs() {
+  assertCondition(packageJson.name === '@quantfive/freecut-editor-surface', 'unexpected package name')
+  assertCondition(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(packageJson.version), 'package version must be semver')
+  assertCondition(
+    publishConfig.registry === 'https://registry.npmjs.org',
+    'package must target the public npm registry',
+  )
+  assertCondition(publishConfig.access === 'public', 'package must publish with public npm access')
+  assertCondition(packageJson.exports?.['./style.css'] === './dist/style.css', 'style export must be stable')
+  assertCondition(packageJson.peerDependencies?.react, 'React must remain a peer dependency')
+  assertCondition(packageJson.peerDependencies?.['react-dom'], 'React DOM must remain a peer dependency')
+  assertCondition(fs.existsSync(path.join(PACKAGE_ROOT, 'README.md')), 'package README is missing')
+  assertCondition(fs.existsSync(path.join(PACKAGE_ROOT, 'LICENSE')), 'package LICENSE is missing')
+}
+
+// fallow-ignore-next-line complexity
+function archiveEntries(directory, archivePrefix) {
+  const entries = [{ type: 'directory', name: `${archivePrefix}/`, sourcePath: directory }]
+  for (const entry of fs.readdirSync(directory).sort()) {
+    if (entry === '.gitkeep') continue
+    const sourcePath = path.join(directory, entry)
+    const archiveName = `${archivePrefix}/${entry}`
+    const stat = fs.lstatSync(sourcePath)
+    assertCondition(!stat.isSymbolicLink(), `symbolic link is not allowed: ${archiveName}`)
+    if (stat.isDirectory()) entries.push(...archiveEntries(sourcePath, archiveName))
+    else if (stat.isFile()) entries.push({ type: 'file', name: archiveName, sourcePath })
+    else fail(`unsupported package input: ${archiveName}`)
+  }
+  return entries
+}
+
+function tarString(header, offset, length, value) {
+  const bytes = Buffer.from(value)
+  assertCondition(bytes.length <= length, `tar header field is too long: ${value}`)
+  bytes.copy(header, offset)
+}
+
+function tarOctal(header, offset, length, value) {
+  tarString(header, offset, length, `${Math.floor(value).toString(8).padStart(length - 1, '0')}\0`)
+}
+
+function tarHeader(entry) {
+  const header = Buffer.alloc(512)
+  tarString(header, 0, 100, entry.name)
+  tarOctal(header, 100, 8, entry.type === 'directory' ? 0o755 : 0o644)
+  tarOctal(header, 108, 8, 0)
+  tarOctal(header, 116, 8, 0)
+  tarOctal(header, 124, 12, entry.type === 'file' ? fs.statSync(entry.sourcePath).size : 0)
+  tarOctal(header, 136, 12, 0)
+  header.fill(0x20, 148, 156)
+  header[156] = entry.type === 'directory' ? 0x35 : 0x30
+  tarString(header, 257, 6, 'ustar\0')
+  tarString(header, 263, 2, '00')
+  const checksum = header.reduce((total, byte) => total + byte, 0)
+  tarString(header, 148, 8, `${checksum.toString(8).padStart(6, '0')}\0 `)
+  return header
+}
+
+async function writeChunk(stream, chunk) {
+  if (stream.write(chunk)) return
+  await once(stream, 'drain')
+}
+
+async function pack() {
+  fs.mkdirSync(ARTIFACTS, { recursive: true })
+  fs.rmSync(artifactPath, { force: true })
+  const staticEntries = ['LICENSE', 'README.md', 'package.json'].map((file) => ({
+    type: 'file',
+    name: `package/${file}`,
+    sourcePath: path.join(PACKAGE_ROOT, file),
+  }))
+  const entries = [
+    { type: 'directory', name: 'package/', sourcePath: PACKAGE_ROOT },
+    ...staticEntries,
+    ...archiveEntries(DIST, 'package/dist'),
+  ].sort((left, right) => left.name.localeCompare(right.name))
+
+  const gzip = createGzip({ level: 9, mtime: 0 })
+  const output = fs.createWriteStream(artifactPath)
+  gzip.pipe(output)
+  for (const entry of entries) {
+    await writeChunk(gzip, tarHeader(entry))
+    if (entry.type !== 'file') continue
+    const bytes = fs.readFileSync(entry.sourcePath)
+    await writeChunk(gzip, bytes)
+    const remainder = bytes.length % 512
+    if (remainder !== 0) await writeChunk(gzip, Buffer.alloc(512 - remainder))
+  }
+  await writeChunk(gzip, Buffer.alloc(1024))
+  gzip.end()
+  await once(output, 'close')
+  return artifactPath
+}
+
+function verifyTarball(filePath) {
+  const listing = execFileSync('tar', ['-tzf', filePath], { encoding: 'utf8' })
+  const entries = listing.split('\n').filter(Boolean)
+  assertCondition(entries.includes('package/dist/index.js'), 'tarball is missing dist/index.js')
+  assertCondition(entries.includes('package/dist/index.d.ts'), 'tarball is missing dist/index.d.ts')
+  assertCondition(entries.includes('package/dist/style.css'), 'tarball is missing dist/style.css')
+  assertCondition(entries.includes('package/package.json'), 'tarball is missing package.json')
+  assertCondition(!entries.some((entry) => entry.includes('node_modules/')), 'tarball contains node_modules')
+  assertCondition(!entries.some((entry) => entry.includes('/src/')), 'tarball contains source files')
+}
+
+async function main() {
+  verifyPackageInputs()
+  run(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['run', 'build:editor-surface'])
+  verifyBuildBoundary()
+  const artifact = await pack()
+  verifyTarball(artifact)
+  console.log(`[editor-surface-package] artifact ${path.relative(ROOT, artifact)}`)
+  console.log(`[editor-surface-package] version ${packageJson.version}`)
+  console.log(`[editor-surface-package] sha256 ${sha256(artifact)}`)
+}
+
+try {
+  await main()
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exitCode = 1
+}
diff --git a/scripts/package-reproducible.mjs b/scripts/package-reproducible.mjs
new file mode 100644
index 000000000..a64118b4c
--- /dev/null
+++ b/scripts/package-reproducible.mjs
@@ -0,0 +1,387 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { execFileSync, spawnSync } from 'node:child_process'
+import { deflateRawSync } from 'node:zlib'
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const MANIFEST_PATH = path.join(ROOT, 'provenance/freecut-baseline.json')
+const DEPENDENCY_INVENTORY_PATH = path.join(ROOT, 'provenance/dependency-inventory.json')
+const ASSET_INVENTORY_PATH = path.join(ROOT, 'provenance/asset-inventory.json')
+const verifyOnly = process.argv.includes('--verify-only')
+
+function fail(message) {
+  throw new Error(`[reproducible-package] ${message}`)
+}
+
+function assertCondition(condition, message) {
+  if (!condition) fail(message)
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch (error) {
+    fail(`could not read JSON ${path.relative(ROOT, filePath)}: ${error.message}`)
+  }
+}
+
+function sha256Bytes(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex')
+}
+
+function sha256File(relativePath) {
+  const filePath = path.join(ROOT, relativePath)
+  assertCondition(fs.existsSync(filePath), `missing file: ${relativePath}`)
+  return sha256Bytes(fs.readFileSync(filePath))
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue)
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, stableValue(value[key])]),
+    )
+  }
+  return value
+}
+
+function equalJson(left, right) {
+  return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right))
+}
+
+function gitOutput(args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: ROOT,
+      encoding: 'utf8',
+      maxBuffer: 512 * 1024 * 1024,
+    }).trim()
+  } catch (error) {
+    fail(`git ${args.join(' ')} failed: ${error.message}`)
+  }
+}
+
+function gitFiles(pathSpec) {
+  const output = gitOutput(['ls-files', '--', pathSpec])
+  return output ? output.split('\n').filter(Boolean).sort(compareStrings) : []
+}
+
+function compareStrings(left, right) {
+  if (left < right) return -1
+  if (left > right) return 1
+  return 0
+}
+
+function verifySource(manifest) {
+  const source = manifest.upstream
+  assertCondition(source.repository === 'https://github.com/walterlow/freecut', 'unexpected upstream repository')
+  assertCondition(source.fork === 'https://github.com/quantfive/freecut', 'unexpected fork repository')
+  assertCondition(/^[0-9a-f]{40}$/.test(source.revision), 'upstream revision must be a full git SHA')
+
+  gitOutput(['cat-file', '-e', `${source.revision}^{commit}`])
+  const head = gitOutput(['rev-parse', 'HEAD'])
+  const ancestry = spawnSync('git', ['merge-base', '--is-ancestor', source.revision, head], {
+    cwd: ROOT,
+    stdio: 'ignore',
+  })
+  assertCondition(ancestry.status === 0, `${source.revision} is not an ancestor of HEAD ${head}`)
+
+  const tree = gitOutput(['rev-parse', `${source.revision}^{tree}`])
+  assertCondition(tree === source.tree, `source tree mismatch: expected ${source.tree}, got ${tree}`)
+
+  const archive = spawnSync(
+    'git',
+    [
+      'archive',
+      '--format=tar',
+      `--prefix=${source.archive.prefix}/`,
+      source.revision,
+    ],
+    {
+      cwd: ROOT,
+      encoding: null,
+      env: { ...process.env, SOURCE_DATE_EPOCH: '0' },
+      maxBuffer: 512 * 1024 * 1024,
+    },
+  )
+  assertCondition(archive.status === 0, `could not archive source revision: ${archive.stderr?.toString() ?? ''}`)
+  const archiveSha256 = sha256Bytes(archive.stdout)
+  assertCondition(
+    archiveSha256 === source.archive.sha256,
+    `source archive checksum mismatch: expected ${source.archive.sha256}, got ${archiveSha256}`,
+  )
+
+  console.log(`[reproducible-package] source ${source.repository}@${source.revision} verified`)
+}
+
+function verifyNotices(manifest) {
+  assertCondition(manifest.license.spdx === 'MIT', 'the retained project license must remain MIT')
+  assertCondition(
+    sha256File(manifest.license.path) === manifest.license.sha256,
+    `license checksum mismatch: ${manifest.license.path}`,
+  )
+  const licenseText = fs.readFileSync(path.join(ROOT, manifest.license.path), 'utf8')
+  assertCondition(licenseText.includes('MIT License'), 'LICENSE does not contain the MIT heading')
+  assertCondition(
+    licenseText.includes('Permission is hereby granted'),
+    'LICENSE does not contain the MIT permission notice',
+  )
+
+  for (const notice of manifest.retainedNotices) {
+    assertCondition(
+      sha256File(notice.path) === notice.sha256,
+      `retained notice checksum mismatch: ${notice.path}`,
+    )
+  }
+  console.log('[reproducible-package] MIT license and retained notices verified')
+}
+
+function verifyDependencies(manifest) {
+  const packageJson = readJson(path.join(ROOT, manifest.dependencies.packageJson))
+  const lockfile = readJson(path.join(ROOT, manifest.dependencies.lockfile))
+  const inventory = readJson(path.join(ROOT, manifest.dependencies.inventory))
+
+  const packageJsonSha256 = sha256File(manifest.dependencies.packageJson)
+  const lockfileSha256 = sha256File(manifest.dependencies.lockfile)
+  assertCondition(
+    packageJsonSha256 === manifest.dependencies.packageJsonSha256,
+    `package.json checksum mismatch: expected ${manifest.dependencies.packageJsonSha256}, got ${packageJsonSha256}`,
+  )
+  assertCondition(
+    lockfileSha256 === manifest.dependencies.lockfileSha256,
+    `package-lock.json checksum mismatch: expected ${manifest.dependencies.lockfileSha256}, got ${lockfileSha256}`,
+  )
+  assertCondition(lockfile.lockfileVersion === manifest.dependencies.lockfileVersion, 'lockfile version mismatch')
+  assertCondition(inventory.packageName === packageJson.name, 'dependency inventory package name mismatch')
+  assertCondition(inventory.packageVersion === packageJson.version, 'dependency inventory package version mismatch')
+  assertCondition(inventory.packageJsonSha256 === packageJsonSha256, 'dependency inventory package checksum mismatch')
+  assertCondition(inventory.lockfile.sha256 === lockfileSha256, 'dependency inventory lockfile checksum mismatch')
+  assertCondition(inventory.lockfile.lockfileVersion === lockfile.lockfileVersion, 'dependency inventory lockfile version mismatch')
+
+  const directDependencies = {
+    dependencies: packageJson.dependencies ?? {},
+    devDependencies: packageJson.devDependencies ?? {},
+  }
+  assertCondition(
+    equalJson(inventory.directDependencies, directDependencies),
+    'direct dependency inventory differs from package.json',
+  )
+
+  const lockRoot = lockfile.packages?.['']
+  assertCondition(lockRoot, 'package-lock.json does not contain the root package')
+  assertCondition(equalJson(lockRoot.dependencies ?? {}, packageJson.dependencies ?? {}), 'lockfile dependencies differ from package.json')
+  assertCondition(
+    equalJson(lockRoot.devDependencies ?? {}, packageJson.devDependencies ?? {}),
+    'lockfile devDependencies differ from package.json',
+  )
+  console.log(
+    `[reproducible-package] dependency inventory verified (${Object.keys(directDependencies.dependencies).length} runtime, ${Object.keys(directDependencies.devDependencies).length} development)`,
+  )
+}
+
+function trackedAssetRecords(pathSpec) {
+  const files = gitFiles(pathSpec)
+  const records = files.map((file) => {
+    const bytes = fs.readFileSync(path.join(ROOT, file))
+    return { path: file, bytes: bytes.length, sha256: sha256Bytes(bytes) }
+  })
+  const hashInput = records
+    .sort((left, right) => compareStrings(left.path, right.path))
+    .map((record) => `${record.path}\0${record.bytes}\0${record.sha256}\n`)
+    .join('')
+  return {
+    fileCount: records.length,
+    byteCount: records.reduce((total, record) => total + record.bytes, 0),
+    sha256: sha256Bytes(hashInput),
+  }
+}
+
+function verifyAssets(manifest) {
+  const inventory = readJson(path.join(ROOT, manifest.assets.inventory))
+  assertCondition(inventory.hashAlgorithm === manifest.assets.hashAlgorithm, 'asset hash algorithm mismatch')
+  for (const root of inventory.roots) {
+    const actual = trackedAssetRecords(root.path)
+    assertCondition(actual.fileCount === root.fileCount, `asset count mismatch for ${root.path}`)
+    assertCondition(actual.byteCount === root.byteCount, `asset byte count mismatch for ${root.path}`)
+    assertCondition(actual.sha256 === root.sha256, `asset checksum mismatch for ${root.path}`)
+  }
+  console.log(`[reproducible-package] asset inventory verified (${inventory.roots.length} roots)`)
+}
+
+function verifyBaseline() {
+  const manifest = readJson(MANIFEST_PATH)
+  assertCondition(manifest.schema === 'freecut-pr2-provenance-baseline/v1', 'unexpected provenance schema')
+  assertCondition(Number(process.versions.node.split('.')[0]) >= manifest.packaging.nodeMajor, 'Node.js 22 or newer is required')
+  verifySource(manifest)
+  verifyNotices(manifest)
+  verifyDependencies(manifest)
+  verifyAssets(manifest)
+  return manifest
+}
+
+function copyTree(sourcePath, targetPath) {
+  const sourceStat = fs.lstatSync(sourcePath)
+  if (sourceStat.isSymbolicLink()) fail(`symbolic links are not allowed in package input: ${sourcePath}`)
+  if (sourceStat.isDirectory()) {
+    fs.mkdirSync(targetPath, { recursive: true })
+    for (const entry of fs.readdirSync(sourcePath).sort(compareStrings)) {
+      copyTree(path.join(sourcePath, entry), path.join(targetPath, entry))
+    }
+    return
+  }
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true })
+  fs.copyFileSync(sourcePath, targetPath)
+}
+
+function addStageFile(stageRoot, sourceRelativePath, targetRelativePath = sourceRelativePath) {
+  const sourcePath = path.join(ROOT, sourceRelativePath)
+  const targetPath = path.join(stageRoot, targetRelativePath)
+  assertCondition(fs.existsSync(sourcePath), `package input is missing: ${sourceRelativePath}`)
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true })
+  fs.copyFileSync(sourcePath, targetPath)
+}
+
+function collectArchiveEntries(directoryPath, archivePrefix) {
+  const entries = [{ type: 'directory', name: `${archivePrefix}/`, sourcePath: directoryPath }]
+  for (const entry of fs.readdirSync(directoryPath).sort(compareStrings)) {
+    const sourcePath = path.join(directoryPath, entry)
+    const archiveName = `${archivePrefix}/${entry}`
+    const stat = fs.lstatSync(sourcePath)
+    if (stat.isSymbolicLink()) fail(`symbolic links are not allowed in package input: ${sourcePath}`)
+    if (stat.isDirectory()) entries.push(...collectArchiveEntries(sourcePath, archiveName))
+    else if (stat.isFile()) entries.push({ type: 'file', name: archiveName, sourcePath })
+    else fail(`unsupported package input: ${sourcePath}`)
+  }
+  return entries
+}
+
+function writeStringField(header, offset, length, value) {
+  const bytes = Buffer.from(value)
+  assertCondition(bytes.length <= length, `tar header field is too long: ${value}`)
+  bytes.copy(header, offset)
+}
+
+function writeOctalField(header, offset, length, value) {
+  const text = Math.floor(value).toString(8).padStart(length - 1, '0') + '\0'
+  writeStringField(header, offset, length, text)
+}
+
+function tarHeader(entry) {
+  const header = Buffer.alloc(512)
+  writeStringField(header, 0, 100, entry.name)
+  writeOctalField(header, 100, 8, entry.type === 'directory' ? 0o755 : 0o644)
+  writeOctalField(header, 108, 8, 0)
+  writeOctalField(header, 116, 8, 0)
+  const size = entry.type === 'file' ? fs.statSync(entry.sourcePath).size : 0
+  writeOctalField(header, 124, 12, size)
+  writeOctalField(header, 136, 12, 0)
+  header.fill(0x20, 148, 156)
+  header[156] = entry.type === 'directory' ? 0x35 : 0x30
+  writeStringField(header, 257, 6, 'ustar\0')
+  writeStringField(header, 263, 2, '00')
+  const checksum = header.reduce((total, byte) => total + byte, 0)
+  writeStringField(header, 148, 8, `${checksum.toString(8).padStart(6, '0')}\0 `)
+  return header
+}
+
+function createTar(entries) {
+  const chunks = []
+  for (const entry of entries) {
+    chunks.push(tarHeader(entry))
+    if (entry.type !== 'file') continue
+    const bytes = fs.readFileSync(entry.sourcePath)
+    chunks.push(bytes)
+    const remainder = bytes.length % 512
+    if (remainder !== 0) chunks.push(Buffer.alloc(512 - remainder))
+  }
+  chunks.push(Buffer.alloc(1024))
+  return Buffer.concat(chunks)
+}
+
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256)
+  for (let index = 0; index < table.length; index += 1) {
+    let value = index
+    for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1
+    table[index] = value >>> 0
+  }
+  return table
+})()
+
+function crc32(bytes) {
+  let value = 0xffffffff
+  for (const byte of bytes) value = CRC32_TABLE[(value ^ byte) & 0xff] ^ (value >>> 8)
+  return (value ^ 0xffffffff) >>> 0
+}
+
+function createDeterministicGzip(tarBytes) {
+  const header = Buffer.from([0x1f, 0x8b, 0x08, 0, 0, 0, 0, 0, 0x02, 0xff])
+  const compressed = deflateRawSync(tarBytes, { level: 9 })
+  const trailer = Buffer.alloc(8)
+  trailer.writeUInt32LE(crc32(tarBytes), 0)
+  trailer.writeUInt32LE(tarBytes.length >>> 0, 4)
+  return Buffer.concat([header, compressed, trailer])
+}
+
+function runBuild() {
+  fs.rmSync(path.join(ROOT, 'dist'), { recursive: true, force: true })
+  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  const result = spawnSync(npm, ['run', 'build'], {
+    cwd: ROOT,
+    env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' },
+    stdio: 'inherit',
+  })
+  assertCondition(result.status === 0, 'npm run build failed')
+}
+
+function createPackage(manifest) {
+  const artifactDirectory = path.join(ROOT, 'artifacts')
+  const artifactPath = path.join(artifactDirectory, `freecut-${manifest.upstream.revision}.tar.gz`)
+  const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'freecut-reproducible-'))
+  const packageRoot = path.join(stage, 'freecut')
+
+  try {
+    copyTree(path.join(ROOT, 'dist'), path.join(packageRoot, 'dist'))
+    addStageFile(packageRoot, 'LICENSE')
+    addStageFile(packageRoot, 'README.md')
+    addStageFile(packageRoot, 'package.json')
+    addStageFile(packageRoot, 'package-lock.json')
+    addStageFile(packageRoot, 'src/infrastructure/audio/THIRD_PARTY_LICENSE', 'notices/THIRD_PARTY_LICENSE')
+    addStageFile(packageRoot, 'src/infrastructure/upscale/models/NOTICE.md', 'notices/upscale-models-NOTICE.md')
+    addStageFile(packageRoot, 'provenance/freecut-baseline.json')
+    addStageFile(packageRoot, 'provenance/dependency-inventory.json')
+    addStageFile(packageRoot, 'provenance/asset-inventory.json')
+
+    const entries = collectArchiveEntries(packageRoot, 'freecut')
+    const gzipBytes = createDeterministicGzip(createTar(entries))
+    fs.mkdirSync(artifactDirectory, { recursive: true })
+    fs.writeFileSync(artifactPath, gzipBytes)
+    console.log(`[reproducible-package] wrote ${path.relative(ROOT, artifactPath)} (${gzipBytes.length} bytes)`)
+    console.log(`[reproducible-package] artifact sha256 ${sha256Bytes(gzipBytes)}`)
+  } finally {
+    fs.rmSync(stage, { recursive: true, force: true })
+  }
+}
+
+function main() {
+  const manifest = verifyBaseline()
+  if (verifyOnly) {
+    console.log('[reproducible-package] verification-only run passed')
+    return
+  }
+  runBuild()
+  verifyBaseline()
+  createPackage(manifest)
+}
+
+try {
+  main()
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exitCode = 1
+}
diff --git a/scripts/test-editor-surface-consumer.mjs b/scripts/test-editor-surface-consumer.mjs
new file mode 100644
index 000000000..265a9f32b
--- /dev/null
+++ b/scripts/test-editor-surface-consumer.mjs
@@ -0,0 +1,164 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const PACKAGE_ROOT = path.join(ROOT, 'packages/freecut-editor')
+const packageJson = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'))
+const rootPackageJson = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8'))
+const artifactName = `freecut-editor-surface-${packageJson.version}.tgz`
+const defaultArtifact = path.join(ROOT, 'artifacts', artifactName)
+const fixtureFiles = [
+  'consumer-smoke.test.tsx',
+  'consumer-smoke.setup.ts',
+  'consumer-smoke-style.d.ts',
+  'vite.editor-package.test.config.ts',
+]
+
+function fail(message) {
+  throw new Error(`[editor-surface-consumer] ${message}`)
+}
+
+function assertCondition(condition, message) {
+  if (!condition) fail(message)
+}
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' },
+    stdio: 'inherit',
+  })
+  assertCondition(result.status === 0, `${command} ${args.join(' ')} failed`)
+}
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm'
+}
+
+function vpPath(fixture) {
+  return path.join(
+    fixture,
+    'node_modules',
+    '.bin',
+    process.platform === 'win32' ? 'vp.cmd' : 'vp',
+  )
+}
+
+function readArg(name) {
+  const index = process.argv.indexOf(name)
+  if (index < 0) return null
+  const value = process.argv[index + 1]
+  assertCondition(value && !value.startsWith('--'), `${name} requires a value`)
+  return value
+}
+
+function dependencySpec(name) {
+  const version = rootPackageJson.devDependencies?.[name] ?? rootPackageJson.dependencies?.[name]
+  assertCondition(version, `missing pinned fixture dependency: ${name}`)
+  return `${name}@${version}`
+}
+
+function createFixture() {
+  const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'freecut-editor-consumer-'))
+  fs.writeFileSync(
+    path.join(fixture, 'package.json'),
+    `${JSON.stringify(
+      {
+        name: 'freecut-editor-consumer-smoke-fixture',
+        private: true,
+        type: 'module',
+        version: '0.0.0',
+      },
+      null,
+      2,
+    )}\n`,
+  )
+  for (const file of fixtureFiles) {
+    const source = file === 'vite.editor-package.test.config.ts' ? path.join(ROOT, file) : path.join(PACKAGE_ROOT, file)
+    const target = file === 'vite.editor-package.test.config.ts' ? 'vite.config.ts' : file
+    fs.copyFileSync(source, path.join(fixture, target))
+  }
+  return fixture
+}
+
+function fixtureDependencies() {
+  return [
+    '@testing-library/dom',
+    '@testing-library/jest-dom',
+    '@testing-library/react',
+    '@vitejs/plugin-react',
+    'jsdom',
+    'react',
+    'react-dom',
+    'vite-plus',
+  ].map(dependencySpec)
+}
+
+function verifyInstalledPackage(fixture) {
+  const installedPackage = path.join(
+    fixture,
+    'node_modules',
+    '@quantfive',
+    'freecut-editor-surface',
+    'package.json',
+  )
+  assertCondition(fs.existsSync(installedPackage), 'packed package was not installed in fixture')
+  const installedPackageJson = JSON.parse(fs.readFileSync(installedPackage, 'utf8'))
+  assertCondition(
+    installedPackageJson.name === packageJson.name,
+    `installed package name mismatch: ${installedPackageJson.name}`,
+  )
+  assertCondition(
+    installedPackageJson.version === packageJson.version,
+    `installed package version mismatch: ${installedPackageJson.version}`,
+  )
+}
+
+function resolveArtifact() {
+  const requested = readArg('--artifact')
+  if (requested) {
+    const artifact = path.resolve(ROOT, requested)
+    assertCondition(fs.existsSync(artifact), `artifact does not exist: ${artifact}`)
+    return artifact
+  }
+
+  run(npmCommand(), ['run', 'package:editor-surface'], ROOT)
+  assertCondition(fs.existsSync(defaultArtifact), `package command did not create ${defaultArtifact}`)
+  return defaultArtifact
+}
+
+// fallow-ignore-next-line complexity
+function main() {
+  const artifact = resolveArtifact()
+  const fixture = createFixture()
+  try {
+    run(
+      npmCommand(),
+      [
+        'install',
+        '--ignore-scripts',
+        '--no-package-lock',
+        '--no-save',
+        artifact,
+        ...fixtureDependencies(),
+      ],
+      fixture,
+    )
+    verifyInstalledPackage(fixture)
+    run(vpPath(fixture), ['test', 'run', '--config', path.join(fixture, 'vite.config.ts')], fixture)
+    console.log(`[editor-surface-consumer] installed and tested ${packageJson.name}@${packageJson.version}`)
+    console.log(`[editor-surface-consumer] fixture ${fixture}`)
+  } finally {
+    fs.rmSync(fixture, { recursive: true, force: true })
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exitCode = 1
+}
diff --git a/src/features/editor/codepress/README.md b/src/features/editor/codepress/README.md
new file mode 100644
index 000000000..492ffabcb
--- /dev/null
+++ b/src/features/editor/codepress/README.md
@@ -0,0 +1,79 @@
+# Controlled CodePress/FreeCut boundary
+
+This directory is the FreeCut-side PR3 adapter boundary. Its public surface is
+the versioned, integer-microsecond command/document contract and explicit
+controlled ports:
+
+- `ControlledEditorPort` owns an in-memory document while mounted;
+- `ControlledEditEngine` applies a bounded command list atomically and is safe
+  to run in a worker;
+- `document.ts` is the only frame-native translation seam; it maps typed
+  FreeCut frame documents to/from the controlled microsecond document;
+- `ControlledRenderer` receives a frame-aligned request and returns a
+  renderer-owned payload;
+- host interfaces (`ProjectStore`, `AssetResolver`, job, presence, upload, and
+  telemetry ports) keep CodePress persistence and media resolution outside
+  FreeCut.
+
+`CodePressCommandAdapter` validates a PR1-shaped batch, checks the current
+revision and preconditions, applies it through the pure edit engine, records
+idempotent replays, and publishes the accepted controlled document. A failed
+command never replaces the document.
+
+The commit boundary is explicit: edit-engine failures return `rejected` before
+the adapter commits its document and idempotency result. Once that internal
+commit succeeds, the adapter returns `applied`; editor publication,
+subscribers, and telemetry are best-effort observers whose synchronous or
+asynchronous failures cannot change the committed result.
+
+`request_job` remains part of the canonical command vocabulary, but the pure
+engine rejects it as `unsupported_command` until a host explicitly owns the
+`MediaJobClient` dispatch. It never reports a media job as applied while doing
+nothing.
+
+## Caption UI
+
+`CaptionEditor` is the FreeCut-side controlled caption surface mounted by the
+merged host-backed editor surface. It reads the runtime controller's
+authoritative frame-native `FreeCutFrameDocument`, but every mutation is
+translated back into the canonical integer-microsecond command contract before
+it reaches `EditorHost.submitEdit`. Track display toggles use the canonical
+track mute field; cue text/timing, track defaults, cue-specific styles, and
+track/cue removal all carry the host controller's revision and precondition
+checks. The standalone adapter remains a deterministic unit-test port; the
+production caption panel does not create a project or synthetic duration.
+
+The UI rejects empty, out-of-range, overlapping, duplicate, and over-budget cue
+sets before submitting them. A rejected revision or idempotency result is shown
+as an accessible error and is never automatically rebased.
+
+The existing `headless/` browser harness and its localhost `/v1` service are
+not imported here and remain development-only implementation seams.
+
+## Timing rule
+
+The public contract is integer microseconds. FreeCut positions are integer
+frames, so all mutation timestamps are required to equal the deterministic
+canonical integer-microsecond representation of a frame at the document FPS.
+`timing.ts` uses rational `BigInt` arithmetic for alignment and nearest-frame
+conversion; it does not depend on a browser clock or floating-point remainder.
+The controlled document bridge converts each interval endpoint independently,
+so valid fractional-rate intervals (including 30000/1001) preserve their frame
+indices even when the integer-microsecond duration is not itself a canonical
+frame timestamp.
+
+## Ripple and captions
+
+`ripple_delete` operates on `[start_us, end_us)` in the selected tracks (or all
+tracks for `track_ids: null`). Downstream items shift left by the exact frame
+delta, with each shifted endpoint re-encoded from its resulting frame index.
+An item crossing both boundaries is split deterministically: the
+left-hand fragment keeps the original ID and the right-hand fragment receives a
+stable `:ripple-right` ID. Fragment suffix allocation reserves its bounded
+suffix space, so maximum-length source IDs still receive deterministic unique
+fragments. Caption cues use the same interval semantics and remain ordinary
+caption-track items in the controlled document.
+
+Frame translation constructs frame-native objects explicitly; legacy
+microsecond endpoint and property fields are not retained alongside their
+frame equivalents.
diff --git a/src/features/editor/codepress/adapter.test.ts b/src/features/editor/codepress/adapter.test.ts
new file mode 100644
index 000000000..2ec212568
--- /dev/null
+++ b/src/features/editor/codepress/adapter.test.ts
@@ -0,0 +1,1093 @@
+// @vitest-environment node
+
+import { readFileSync } from 'node:fs'
+import { describe, expect, it } from 'vite-plus/test'
+import {
+  CodePressCommandAdapter,
+  FrameTimingError,
+  assertFrameAligned,
+  controlledDocumentToFreeCutDocument,
+  createCodePressCommandAdapter,
+  freeCutDocumentToControlledDocument,
+  framesToMicroseconds,
+  isFrameAligned,
+  isVideoCommandError,
+  translateCommandBatchToFrames,
+  translateCommandToFrames,
+  validateCommandBatch,
+  validateTimelineState,
+} from './index'
+import type {
+  ClipItem,
+  EditCommandBatch,
+  MediaReference,
+  TextItem,
+  TimelineState,
+} from './contract'
+import type { ControlledEditorDocument } from './interfaces'
+import type { FrameRateLike } from './timing'
+
+function readFixture<T>(relativePath: string): T {
+  return JSON.parse(
+    readFileSync(new URL(`./fixtures/${relativePath}`, import.meta.url), 'utf8'),
+  ) as T
+}
+
+interface ValidFixture {
+  timeline: TimelineState
+  request: EditCommandBatch
+  expect: { request_valid: boolean; command_types: string[]; command_count: number }
+}
+
+const videoMedia: MediaReference = {
+  media_id: 'media-video',
+  media_kind: 'video',
+  content_hash: 'sha256:video-v1',
+  duration_us: 30_000_000,
+  availability: { mode: 'cloud', cloud: { object_id: 'object-video' } },
+}
+
+const audioMedia: MediaReference = {
+  media_id: 'media-audio',
+  media_kind: 'audio',
+  content_hash: 'sha256:audio-v1',
+  duration_us: 30_000_000,
+  availability: { mode: 'cloud', cloud: { object_id: 'object-audio' } },
+}
+
+function clip(overrides: Partial<ClipItem> = {}): ClipItem {
+  return {
+    item_type: 'clip',
+    item_id: 'clip-a',
+    track_id: 'track-video',
+    media_id: 'media-video',
+    media_kind: 'video',
+    timeline_start_us: 0,
+    timeline_end_us: 1_000_000,
+    source_start_us: 0,
+    source_end_us: 1_000_000,
+    ...overrides,
+  }
+}
+
+function text(overrides: Partial<TextItem> = {}): TextItem {
+  return {
+    item_type: 'text',
+    item_id: 'text-a',
+    track_id: 'track-video',
+    timeline_start_us: 0,
+    timeline_end_us: 1_000_000,
+    text: 'Text',
+    ...overrides,
+  }
+}
+
+function timeline(overrides: Partial<TimelineState> = {}): TimelineState {
+  return {
+    contract_version: 1,
+    schema_version: 1,
+    timeline_id: 'timeline-test',
+    revision: 0,
+    duration_us: 10_000_000,
+    media: [videoMedia, audioMedia],
+    tracks: [
+      {
+        track_id: 'track-video',
+        kind: 'video',
+        name: 'Video',
+        locked: false,
+        muted: false,
+        items: [clip()],
+      },
+      {
+        track_id: 'track-captions',
+        kind: 'caption',
+        name: 'Captions',
+        language: 'en',
+        locked: false,
+        muted: false,
+        items: [],
+      },
+    ],
+    ...overrides,
+  }
+}
+
+function documentFor(next: TimelineState, fps: FrameRateLike = 30): ControlledEditorDocument {
+  return { timeline: next, fps, width: 1920, height: 1080 }
+}
+
+function applyRequest(adapter: CodePressCommandAdapter, request: EditCommandBatch) {
+  const result = adapter.apply(request)
+  expect(result.status).toBe('applied')
+  if (result.status !== 'applied') throw new Error('request was not applied')
+  return result
+}
+
+describe('PR1 conformance fixtures', () => {
+  it.each(['valid/core-edit-batch.json', 'valid/caption-batch.json'])('accepts %s', (path) => {
+    const fixture = readFixture<ValidFixture>(path)
+    const timelineResult = validateTimelineState(fixture.timeline)
+    const requestResult = validateCommandBatch(fixture.request)
+    expect(timelineResult.ok).toBe(true)
+    expect(requestResult.ok).toBe(true)
+    if (!requestResult.ok) return
+    expect(requestResult.value.commands.map((command) => command.type)).toEqual(
+      fixture.expect.command_types,
+    )
+    expect(requestResult.value.commands).toHaveLength(fixture.expect.command_count)
+  })
+
+  it('rejects the canonical invalid caption-cue fixture', () => {
+    const fixture = readFixture<{ request: EditCommandBatch; expect: { error_codes: string[] } }>(
+      'invalid/invalid-caption-cue.json',
+    )
+    const result = validateCommandBatch(fixture.request)
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.errors.map((entry) => entry.code)).toEqual(fixture.expect.error_codes)
+    expect(result.errors[0]?.details).toMatchObject({
+      kind: 'invalid_request',
+      path: 'commands[0].cues[0]',
+    })
+  })
+
+  it.each(['errors/revision-conflict.json', 'errors/idempotency-conflict.json'])(
+    'keeps the canonical structured error shape for %s',
+    (path) => {
+      const fixture = readFixture<{
+        error: unknown
+        expect: { code: string; retryable: boolean }
+      }>(path)
+      expect(isVideoCommandError(fixture.error)).toBe(true)
+      expect(fixture.error).toMatchObject({
+        code: fixture.expect.code,
+        retryable: fixture.expect.retryable,
+        details: { kind: fixture.expect.code },
+      })
+    },
+  )
+})
+
+describe('deterministic microsecond/frame conversion', () => {
+  it('uses exact integer arithmetic for frame-aligned timestamps', () => {
+    expect(assertFrameAligned(1_000_000, 30)).toBe(30)
+    expect(framesToMicroseconds(30, 30)).toBe(1_000_000)
+    const ntsc = { numerator: 30_000n, denominator: 1_001n, value: 30_000 / 1_001 }
+    expect(framesToMicroseconds(30, ntsc)).toBe(1_001_000)
+    expect(assertFrameAligned(1_001_000, ntsc)).toBe(30)
+    expect(isFrameAligned(33_334, 30)).toBe(false)
+    expect(() => assertFrameAligned(33_334, 30)).toThrow(FrameTimingError)
+  })
+
+  it('translates every public timestamp in a batch before application', () => {
+    const fixture = readFixture<ValidFixture>('valid/core-edit-batch.json')
+    const translated = translateCommandBatchToFrames(fixture.request, 30)
+    const ripple = translated.commands.find((command) => command.type === 'ripple_delete')
+    expect(ripple).toMatchObject({ start_frame: 60, end_frame: 75 })
+    const split = translated.commands[0]
+    expect(split).toMatchObject({ at_timeline_frame: 120, at_source_frame: 120 })
+  })
+
+  it('constructs frame-native items and patches without legacy microsecond fields', () => {
+    const translatedClip = translateCommandToFrames(
+      {
+        command_id: 'add-clip',
+        type: 'add_clip',
+        track_id: 'track-video',
+        item: clip({
+          fade_in_us: 1_000_000,
+          fade_out_us: 1_000_000,
+          transition_in: { transition_type: 'crossfade', duration_us: 1_000_000 },
+          transition_out: { transition_type: 'dip_to_black', duration_us: 1_000_000 },
+          keyframes: [
+            {
+              property: 'opacity',
+              time_us: 0,
+              value: 1,
+              interpolation: 'linear',
+            },
+          ],
+        }),
+      },
+      30,
+    )
+    if (translatedClip.type !== 'add_clip') throw new Error('clip command did not translate')
+    expect(translatedClip.item).toMatchObject({
+      timeline_start_frame: 0,
+      timeline_end_frame: 30,
+      source_start_frame: 0,
+      source_end_frame: 30,
+      fade_in_frame: 30,
+      fade_out_frame: 30,
+      transition_in: { duration_frame: 30 },
+      transition_out: { duration_frame: 30 },
+      keyframes: [{ time_frame: 0 }],
+    })
+    for (const field of [
+      'timeline_start_us',
+      'timeline_end_us',
+      'source_start_us',
+      'source_end_us',
+      'fade_in_us',
+      'fade_out_us',
+    ]) {
+      expect(translatedClip.item).not.toHaveProperty(field)
+    }
+
+    const translatedText = translateCommandToFrames(
+      {
+        command_id: 'add-text',
+        type: 'add_text',
+        track_id: 'track-video',
+        item: text({
+          keyframes: [
+            {
+              property: 'opacity',
+              time_us: 0,
+              value: 1,
+              interpolation: 'linear',
+            },
+          ],
+        }),
+      },
+      30,
+    )
+    if (translatedText.type !== 'add_text') throw new Error('text command did not translate')
+    expect(translatedText.item).toMatchObject({
+      timeline_start_frame: 0,
+      timeline_end_frame: 30,
+      keyframes: [{ time_frame: 0 }],
+    })
+    expect(translatedText.item).not.toHaveProperty('timeline_start_us')
+    expect(translatedText.item).not.toHaveProperty('timeline_end_us')
+
+    const translatedCue = translateCommandToFrames(
+      {
+        command_id: 'upsert-cue',
+        type: 'upsert_caption_cues',
+        track_id: 'track-captions',
+        cues: [
+          {
+            item_type: 'caption_cue',
+            cue_id: 'cue-frame-native',
+            track_id: 'track-captions',
+            start_us: 0,
+            end_us: 1_000_000,
+            text: 'Cue',
+          },
+        ],
+      },
+      30,
+    )
+    if (translatedCue.type !== 'upsert_caption_cues')
+      throw new Error('caption command did not translate')
+    expect(translatedCue.cues[0]).toMatchObject({ start_frame: 0, end_frame: 30 })
+    expect(translatedCue.cues[0]).not.toHaveProperty('start_us')
+    expect(translatedCue.cues[0]).not.toHaveProperty('end_us')
+
+    const translatedProperties = translateCommandToFrames(
+      {
+        command_id: 'set-properties',
+        type: 'set_item_properties',
+        item_id: 'clip-a',
+        properties: {
+          fade_in_us: 1_000_000,
+          fade_out_us: null,
+          transition_in: { transition_type: 'crossfade', duration_us: 1_000_000 },
+          transition_out: null,
+          keyframes: [
+            {
+              property: 'opacity',
+              time_us: 0,
+              value: 1,
+              interpolation: 'linear',
+            },
+          ],
+        },
+      },
+      30,
+    )
+    if (translatedProperties.type !== 'set_item_properties')
+      throw new Error('properties command did not translate')
+    expect(translatedProperties.properties).toMatchObject({
+      fade_in_frame: 30,
+      fade_out_frame: null,
+      transition_in: { duration_frame: 30 },
+      transition_out: null,
+      keyframes: [{ time_frame: 0 }],
+    })
+    for (const field of ['fade_in_us', 'fade_out_us']) {
+      expect(translatedProperties.properties).not.toHaveProperty(field)
+    }
+  })
+})
+
+describe('controlled command adapter', () => {
+  it('round-trips a frame-native FreeCut document through the typed boundary', () => {
+    const frameDocument = {
+      timelineId: 'timeline-frame',
+      revision: 4,
+      fps: 30,
+      durationInFrames: 180,
+      media: [videoMedia],
+      tracks: [
+        {
+          id: 'track-video',
+          kind: 'video' as const,
+          name: 'Video',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              type: 'video' as const,
+              id: 'clip-frame',
+              trackId: 'track-video',
+              mediaId: 'media-video',
+              from: 30,
+              durationInFrames: 60,
+              sourceStart: 0,
+              sourceEnd: 60,
+            },
+          ],
+        },
+      ],
+      width: 1920,
+      height: 1080,
+    }
+    const controlled = freeCutDocumentToControlledDocument(frameDocument)
+    expect(controlled.timeline.tracks[0]?.items[0]).toMatchObject({
+      item_id: 'clip-frame',
+      timeline_start_us: 1_000_000,
+      timeline_end_us: 3_000_000,
+    })
+    const roundTrip = controlledDocumentToFreeCutDocument(controlled)
+    expect(roundTrip).toMatchObject({
+      timelineId: 'timeline-frame',
+      revision: 4,
+      durationInFrames: 180,
+      fps: 30,
+    })
+    expect(roundTrip.tracks[0]?.items[0]).toMatchObject({
+      id: 'clip-frame',
+      from: 30,
+      durationInFrames: 60,
+    })
+  })
+
+  it('round-trips nonzero-start clip, text, and caption endpoints at fractional FPS', () => {
+    const rates: readonly FrameRateLike[] = [
+      29.97,
+      { numerator: 30_000n, denominator: 1_001n, value: 30_000 / 1_001 },
+    ]
+    for (const fps of rates) {
+      const frameDocument = {
+        timelineId: 'timeline-fractional',
+        revision: 2,
+        fps,
+        durationInFrames: 180,
+        media: [videoMedia],
+        tracks: [
+          {
+            id: 'track-video',
+            kind: 'video' as const,
+            name: 'Video',
+            locked: false,
+            muted: false,
+            items: [
+              {
+                type: 'video' as const,
+                id: 'clip-fractional',
+                trackId: 'track-video',
+                mediaId: 'media-video',
+                from: 1,
+                durationInFrames: 1,
+                sourceStart: 2,
+                sourceEnd: 3,
+              },
+            ],
+          },
+          {
+            id: 'track-overlay',
+            kind: 'overlay' as const,
+            name: 'Overlay',
+            locked: false,
+            muted: false,
+            items: [
+              {
+                type: 'text' as const,
+                id: 'text-fractional',
+                trackId: 'track-overlay',
+                from: 2,
+                durationInFrames: 1,
+                text: 'Fractional text',
+              },
+            ],
+          },
+          {
+            id: 'track-captions',
+            kind: 'caption' as const,
+            name: 'Captions',
+            language: 'en',
+            locked: false,
+            muted: false,
+            items: [
+              {
+                type: 'caption_cue' as const,
+                id: 'cue-fractional',
+                trackId: 'track-captions',
+                from: 3,
+                durationInFrames: 1,
+                text: 'Fractional cue',
+              },
+            ],
+          },
+        ],
+        width: 1920,
+        height: 1080,
+      }
+      const controlled = freeCutDocumentToControlledDocument(frameDocument)
+      const clipItem = controlled.timeline.tracks[0]?.items[0]
+      const textItem = controlled.timeline.tracks[1]?.items[0]
+      const cueItem = controlled.timeline.tracks[2]?.items[0]
+      expect(clipItem).toMatchObject({
+        timeline_start_us: framesToMicroseconds(1, fps),
+        timeline_end_us: framesToMicroseconds(2, fps),
+        source_start_us: framesToMicroseconds(2, fps),
+        source_end_us: framesToMicroseconds(3, fps),
+      })
+      expect(textItem).toMatchObject({
+        timeline_start_us: framesToMicroseconds(2, fps),
+        timeline_end_us: framesToMicroseconds(3, fps),
+      })
+      expect(cueItem).toMatchObject({
+        start_us: framesToMicroseconds(3, fps),
+        end_us: framesToMicroseconds(4, fps),
+      })
+
+      const roundTrip = controlledDocumentToFreeCutDocument(controlled)
+      expect(roundTrip.tracks[0]?.items[0]).toMatchObject({ from: 1, durationInFrames: 1 })
+      expect(roundTrip.tracks[1]?.items[0]).toMatchObject({ from: 2, durationInFrames: 1 })
+      expect(roundTrip.tracks[2]?.items[0]).toMatchObject({ from: 3, durationInFrames: 1 })
+    }
+  })
+
+  it('applies the canonical core fixture atomically and reports normalized effects', () => {
+    const fixture = readFixture<ValidFixture>('valid/core-edit-batch.json')
+    const adapter = new CodePressCommandAdapter({ document: documentFor(fixture.timeline) })
+    const result = applyRequest(adapter, fixture.request)
+    expect(result.previous_revision).toBe(7)
+    expect(result.resulting_revision).toBe(8)
+    expect(result.timeline.duration_us).toBe(11_500_000)
+    expect(result.commands.map((command) => command.command_type)).toEqual(
+      fixture.expect.command_types,
+    )
+    expect(result.commands[2]?.effect.timeline_delta_us).toBe(-500_000)
+    expect(adapter.getSnapshot().revision).toBe(8)
+  })
+
+  it('applies caption cues, preserves cue order, and supports cue styles', () => {
+    const fixture = readFixture<ValidFixture>('valid/caption-batch.json')
+    const adapter = new CodePressCommandAdapter({ document: documentFor(fixture.timeline) })
+    const result = applyRequest(adapter, fixture.request)
+    const captionTrack = result.timeline.tracks.find((track) => track.track_id === 'track-captions')
+    expect(
+      captionTrack?.items.map((item) =>
+        item.item_type === 'caption_cue' ? item.cue_id : item.item_id,
+      ),
+    ).toEqual(['cue-hello', 'cue-next'])
+
+    const styled = applyRequest(adapter, {
+      contract_version: 1,
+      timeline_id: 'timeline-caption',
+      operation_id: 'operation-captions-style',
+      idempotency_key: 'timeline-caption:style:1',
+      base_revision: 3,
+      preconditions: [{ type: 'item_exists', item_id: 'cue-hello' }],
+      commands: [
+        {
+          command_id: 'command-style',
+          type: 'set_caption_style',
+          track_id: 'track-captions',
+          cue_ids: ['cue-hello'],
+          style: { color: '#00ff00', alignment: 'center' },
+        },
+      ],
+    })
+    const styledCue = styled.timeline.tracks[0]?.items[0]
+    expect(styledCue).toMatchObject({
+      cue_id: 'cue-hello',
+      style: { color: '#00ff00', alignment: 'center' },
+    })
+  })
+
+  it('ripple-deletes deterministically across tracks and leaves selected tracks isolated', () => {
+    const base = timeline({
+      tracks: [
+        {
+          track_id: 'track-video',
+          kind: 'video',
+          name: 'Video',
+          locked: false,
+          muted: false,
+          items: [
+            clip({
+              item_id: 'before',
+              timeline_start_us: 0,
+              timeline_end_us: 1_000_000,
+              source_end_us: 1_000_000,
+            }),
+            clip({
+              item_id: 'after',
+              timeline_start_us: 3_000_000,
+              timeline_end_us: 4_000_000,
+              source_start_us: 3_000_000,
+              source_end_us: 4_000_000,
+            }),
+          ],
+        },
+        {
+          track_id: 'track-captions',
+          kind: 'caption',
+          name: 'Captions',
+          language: 'en',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'cue-after',
+              track_id: 'track-captions',
+              start_us: 3_000_000,
+              end_us: 4_000_000,
+              text: 'After',
+            },
+          ],
+        },
+      ],
+    })
+    const adapter = new CodePressCommandAdapter({ document: documentFor(base) })
+    const allTracks = applyRequest(adapter, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'ripple-all',
+      idempotency_key: 'ripple-all:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'ripple',
+          type: 'ripple_delete',
+          start_us: 1_000_000,
+          end_us: 2_000_000,
+          track_ids: null,
+        },
+      ],
+    })
+    const videoAfter = allTracks.timeline.tracks[0]?.items.find(
+      (item) => itemIdForTest(item) === 'after',
+    )
+    const captionAfter = allTracks.timeline.tracks[1]?.items.find(
+      (item) => itemIdForTest(item) === 'cue-after',
+    )
+    expect(videoAfter).toMatchObject({ timeline_start_us: 2_000_000, timeline_end_us: 3_000_000 })
+    expect(captionAfter).toMatchObject({ start_us: 2_000_000, end_us: 3_000_000 })
+    expect(allTracks.timeline.duration_us).toBe(9_000_000)
+
+    const isolated = new CodePressCommandAdapter({ document: documentFor(base) })
+    const selected = applyRequest(isolated, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'ripple-video',
+      idempotency_key: 'ripple-video:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'ripple-video',
+          type: 'ripple_delete',
+          start_us: 1_000_000,
+          end_us: 2_000_000,
+          track_ids: ['track-video'],
+        },
+      ],
+    })
+    expect(selected.timeline.tracks[1]?.items[0]).toMatchObject({
+      start_us: 3_000_000,
+      end_us: 4_000_000,
+    })
+    expect(selected.timeline.duration_us).toBe(10_000_000)
+  })
+
+  it('re-encodes NTSC ripple endpoints independently at fractional FPS', () => {
+    const fps: FrameRateLike = {
+      numerator: 30_000n,
+      denominator: 1_001n,
+      value: 30_000 / 1_001,
+    }
+    const frame = (value: number) => framesToMicroseconds(value, fps)
+    const base = timeline({
+      duration_us: frame(12),
+      tracks: [
+        {
+          track_id: 'track-video',
+          kind: 'video',
+          name: 'Video',
+          locked: false,
+          muted: false,
+          items: [
+            clip({
+              item_id: 'before-ntsc',
+              timeline_start_us: frame(0),
+              timeline_end_us: frame(1),
+              source_start_us: frame(0),
+              source_end_us: frame(1),
+            }),
+            clip({
+              item_id: 'after-ntsc',
+              timeline_start_us: frame(2),
+              timeline_end_us: frame(3),
+              source_start_us: frame(2),
+              source_end_us: frame(3),
+            }),
+          ],
+        },
+        {
+          track_id: 'track-captions',
+          kind: 'caption',
+          name: 'Captions',
+          language: 'en',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'cue-after-ntsc',
+              track_id: 'track-captions',
+              start_us: frame(2),
+              end_us: frame(3),
+              text: 'After NTSC',
+            },
+          ],
+        },
+      ],
+    })
+    const adapter = new CodePressCommandAdapter({ document: documentFor(base, fps) })
+    const result = applyRequest(adapter, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'ripple-ntsc',
+      idempotency_key: 'ripple-ntsc:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'ripple-ntsc-command',
+          type: 'ripple_delete',
+          start_us: frame(1),
+          end_us: frame(2),
+          track_ids: null,
+        },
+      ],
+    })
+    const videoAfter = result.timeline.tracks[0]?.items.find(
+      (item) => itemIdForTest(item) === 'after-ntsc',
+    )
+    const captionAfter = result.timeline.tracks[1]?.items.find(
+      (item) => itemIdForTest(item) === 'cue-after-ntsc',
+    )
+    expect(videoAfter).toMatchObject({
+      timeline_start_us: frame(1),
+      timeline_end_us: frame(2),
+    })
+    expect(captionAfter).toMatchObject({ start_us: frame(1), end_us: frame(2) })
+    expect(result.timeline.duration_us).toBe(frame(11))
+    expect(validateTimelineState(result.timeline).ok).toBe(true)
+
+    const next = adapter.apply({
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'move-after-ntsc',
+      idempotency_key: 'move-after-ntsc:1',
+      base_revision: 1,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'move-after-ntsc-command',
+          type: 'move_item',
+          item_id: 'after-ntsc',
+          to_track_id: 'track-video',
+          timeline_start_us: frame(1),
+          index: 1,
+        },
+      ],
+    })
+    expect(next.status).toBe('applied')
+  })
+
+  it('keeps the left fragment ID and derives a stable right fragment for a crossing item', () => {
+    const crossing = new CodePressCommandAdapter({
+      document: documentFor(
+        timeline({
+          duration_us: 8_000_000,
+          tracks: [
+            {
+              track_id: 'track-video',
+              kind: 'video',
+              name: 'Video',
+              locked: false,
+              muted: false,
+              items: [
+                clip({
+                  item_id: 'crossing',
+                  timeline_start_us: 0,
+                  timeline_end_us: 4_000_000,
+                  source_start_us: 0,
+                  source_end_us: 4_000_000,
+                }),
+              ],
+            },
+            {
+              track_id: 'track-captions',
+              kind: 'caption',
+              name: 'Captions',
+              language: 'en',
+              locked: false,
+              muted: false,
+              items: [],
+            },
+          ],
+        }),
+      ),
+    })
+    const result = applyRequest(crossing, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'ripple-crossing',
+      idempotency_key: 'ripple-crossing:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'ripple-crossing-command',
+          type: 'ripple_delete',
+          start_us: 1_000_000,
+          end_us: 2_000_000,
+          track_ids: ['track-video'],
+        },
+      ],
+    })
+    const items = result.timeline.tracks[0]?.items
+    expect(items?.map(itemIdForTest)).toEqual(['crossing', 'crossing:ripple-right'])
+    expect(items?.[0]).toMatchObject({
+      timeline_start_us: 0,
+      timeline_end_us: 1_000_000,
+      source_end_us: 1_000_000,
+    })
+    expect(items?.[1]).toMatchObject({
+      timeline_start_us: 1_000_000,
+      timeline_end_us: 3_000_000,
+      source_start_us: 2_000_000,
+      source_end_us: 4_000_000,
+    })
+  })
+
+  it('allocates bounded ripple fragment IDs for max-length IDs and collisions', () => {
+    const maxId = 'x'.repeat(128)
+    const baseFragmentId = `${maxId.slice(0, 128 - ':ripple-right'.length)}:ripple-right`
+    const suffixFragmentId = `${maxId.slice(0, 128 - ':ripple-2'.length)}:ripple-2`
+    const base = timeline({
+      duration_us: 8_000_000,
+      tracks: [
+        {
+          track_id: 'track-video',
+          kind: 'video',
+          name: 'Video',
+          locked: false,
+          muted: false,
+          items: [
+            clip({
+              item_id: maxId,
+              timeline_start_us: 0,
+              timeline_end_us: 4_000_000,
+              source_start_us: 0,
+              source_end_us: 4_000_000,
+            }),
+            clip({
+              item_id: baseFragmentId,
+              timeline_start_us: 5_000_000,
+              timeline_end_us: 6_000_000,
+              source_start_us: 5_000_000,
+              source_end_us: 6_000_000,
+            }),
+          ],
+        },
+        {
+          track_id: 'track-captions',
+          kind: 'caption',
+          name: 'Captions',
+          language: 'en',
+          locked: false,
+          muted: false,
+          items: [],
+        },
+      ],
+    })
+    const adapter = new CodePressCommandAdapter({ document: documentFor(base) })
+    const result = applyRequest(adapter, {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'ripple-max-id',
+      idempotency_key: 'ripple-max-id:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'ripple-max-id-command',
+          type: 'ripple_delete',
+          start_us: 1_000_000,
+          end_us: 2_000_000,
+          track_ids: ['track-video'],
+        },
+      ],
+    })
+    const ids = result.timeline.tracks[0]?.items.map(itemIdForTest)
+    expect(ids).toEqual([maxId, suffixFragmentId, baseFragmentId])
+    expect(ids?.every((id) => id.length <= 128)).toBe(true)
+    expect(validateTimelineState(result.timeline).ok).toBe(true)
+  })
+
+  it('does not mutate the controlled document when a later command fails', () => {
+    const adapter = new CodePressCommandAdapter({ document: documentFor(timeline()) })
+    const result = adapter.apply({
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'atomic-failure',
+      idempotency_key: 'atomic-failure:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        { command_id: 'remove-ghost', type: 'remove_item', item_id: 'ghost' },
+        {
+          command_id: 'add-text',
+          type: 'add_text',
+          track_id: 'track-video',
+          item: text({ item_id: 'would-not-land' }),
+        },
+      ],
+    })
+    expect(result.status).toBe('rejected')
+    expect(adapter.getSnapshot().revision).toBe(0)
+    expect(adapter.getSnapshot().document.timeline.tracks[0]?.items).toHaveLength(1)
+  })
+
+  it('commits before editor, subscriber, and synchronous telemetry failures', () => {
+    const initial = documentFor(timeline())
+    const editor = {
+      getDocument: () => initial,
+      replaceDocument: () => {
+        throw new Error('editor observer failed')
+      },
+    }
+    const adapter = new CodePressCommandAdapter({
+      document: initial,
+      editor,
+      hosts: {
+        telemetryClient: {
+          emit: () => {
+            throw new Error('telemetry observer failed')
+          },
+        },
+      },
+    })
+    let subscriberCalls = 0
+    adapter.subscribe(() => {
+      subscriberCalls += 1
+      throw new Error('subscriber observer failed')
+    })
+    adapter.subscribe(() => {
+      subscriberCalls += 1
+    })
+    const request: EditCommandBatch = {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'observer-failures',
+      idempotency_key: 'observer-failures:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'move-observer-failures',
+          type: 'move_item',
+          item_id: 'clip-a',
+          to_track_id: 'track-video',
+          timeline_start_us: 1_000_000,
+          index: 0,
+        },
+      ],
+    }
+    const result = adapter.apply(request)
+    expect(result.status).toBe('applied')
+    expect(adapter.getSnapshot().revision).toBe(1)
+    expect(subscriberCalls).toBe(2)
+    const replayed = adapter.apply(request)
+    expect(replayed.status).toBe('replayed')
+  })
+
+  it('handles rejected telemetry without changing the committed result', async () => {
+    let unhandled: unknown
+    const onUnhandled = (reason: unknown) => {
+      unhandled = reason
+    }
+    process.on('unhandledRejection', onUnhandled)
+    try {
+      const adapter = new CodePressCommandAdapter({
+        document: documentFor(timeline()),
+        hosts: {
+          telemetryClient: {
+            emit: () => Promise.reject(new Error('async telemetry failed')),
+          },
+        },
+      })
+      const result = adapter.apply({
+        contract_version: 1,
+        timeline_id: 'timeline-test',
+        operation_id: 'async-telemetry-failure',
+        idempotency_key: 'async-telemetry-failure:1',
+        base_revision: 0,
+        preconditions: [],
+        commands: [
+          {
+            command_id: 'move-async-telemetry',
+            type: 'move_item',
+            item_id: 'clip-a',
+            to_track_id: 'track-video',
+            timeline_start_us: 1_000_000,
+            index: 0,
+          },
+        ],
+      })
+      expect(result.status).toBe('applied')
+      expect(adapter.getSnapshot().revision).toBe(1)
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      expect(unhandled).toBeUndefined()
+    } finally {
+      process.off('unhandledRejection', onUnhandled)
+    }
+  })
+
+  it('rejects request_job until a host dispatch boundary is implemented', () => {
+    let hostCalls = 0
+    const adapter = new CodePressCommandAdapter({
+      document: documentFor(timeline()),
+      hosts: {
+        mediaJobClient: {
+          request: () => {
+            hostCalls += 1
+            return { job_id: 'job-should-not-run' }
+          },
+        },
+      },
+    })
+    const result = adapter.apply({
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'request-job',
+      idempotency_key: 'request-job:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'request-job-command',
+          type: 'request_job',
+          job_type: 'thumbnail',
+          media_id: 'media-video',
+        },
+      ],
+    })
+    expect(result).toMatchObject({
+      status: 'rejected',
+      error: { code: 'unsupported_command', retryable: false },
+    })
+    expect(hostCalls).toBe(0)
+    expect(adapter.getSnapshot().revision).toBe(0)
+  })
+
+  it('returns explicit revision and idempotency conflicts', () => {
+    const adapter = createCodePressCommandAdapter({ document: documentFor(timeline()) })
+    const request: EditCommandBatch = {
+      contract_version: 1,
+      timeline_id: 'timeline-test',
+      operation_id: 'move-once',
+      idempotency_key: 'move:1',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'move',
+          type: 'move_item',
+          item_id: 'clip-a',
+          to_track_id: 'track-video',
+          timeline_start_us: 1_000_000,
+          index: 0,
+        },
+      ],
+    }
+    const applied = applyRequest(adapter, request)
+    const replayed = adapter.apply(request)
+    expect(replayed.status).toBe('replayed')
+    if (replayed.status === 'replayed')
+      expect(replayed.replayed_operation_id).toBe(applied.operation_id)
+
+    const idempotencyConflict = adapter.apply({
+      ...request,
+      operation_id: 'different-operation',
+      commands: [{ ...request.commands[0]!, command_id: 'different-command' }],
+    })
+    expect(idempotencyConflict).toMatchObject({
+      status: 'rejected',
+      error: { code: 'idempotency_conflict', retryable: false },
+    })
+
+    const stale = adapter.apply({ ...request, operation_id: 'stale', idempotency_key: 'stale:1' })
+    expect(stale).toMatchObject({
+      status: 'rejected',
+      error: {
+        code: 'revision_conflict',
+        retryable: true,
+        details: { rebase: { automatic: false, retry_with_revision: 1 } },
+      },
+    })
+  })
+
+  it('keeps render and media state outside the command/document contract', async () => {
+    const renderer = {
+      renderFrame: (request: {
+        frame: number
+        time_us: number
+        width: number
+        height: number
+        document: ControlledEditorDocument
+      }) => ({
+        frame: request.frame,
+        time_us: request.time_us,
+        width: request.width,
+        height: request.height,
+        payload: { source: 'renderer-only' },
+      }),
+    }
+    const adapter = new CodePressCommandAdapter({ document: documentFor(timeline()), renderer })
+    await expect(adapter.renderFrame(1_000_000)).resolves.toMatchObject({
+      frame: 30,
+      time_us: 1_000_000,
+      payload: { source: 'renderer-only' },
+    })
+    await expect(adapter.renderFrame(33_334)).rejects.toThrow(FrameTimingError)
+    expect(JSON.stringify(adapter.getSnapshot().document.timeline)).not.toContain('/Users/')
+    expect(JSON.stringify(adapter.getSnapshot().document.timeline)).not.toContain('file://')
+  })
+})
+
+function itemIdForTest(item: TimelineState['tracks'][number]['items'][number]): string {
+  return item.item_type === 'caption_cue' ? item.cue_id : item.item_id
+}
diff --git a/src/features/editor/codepress/adapter.ts b/src/features/editor/codepress/adapter.ts
new file mode 100644
index 000000000..0ec97cbdb
--- /dev/null
+++ b/src/features/editor/codepress/adapter.ts
@@ -0,0 +1,485 @@
+import { isStableIdentifier, validateCommandBatch, validateTimelineState } from './contract'
+import type {
+  EditApplyResult,
+  EditCommandBatch,
+  Precondition,
+  TimelineItem,
+  TimelineState,
+  VideoCommandError,
+} from './contract'
+import { EditEngineError, controlledEditEngine } from './edit-engine'
+import type {
+  CodePressHostAdapters,
+  ControlledEditEngine,
+  ControlledEditorDocument,
+  ControlledEditorPort,
+  ControlledRenderer,
+  EditEngineResult,
+  RenderedFrame,
+} from './interfaces'
+import { FrameTimingError, assertFrameAligned } from './timing'
+
+interface StoredOperation {
+  payload: string
+  result: Exclude<EditApplyResult, { status: 'rejected' }>
+}
+
+export interface CodePressCommandAdapterOptions {
+  document: ControlledEditorDocument
+  editor?: ControlledEditorPort
+  renderer?: ControlledRenderer
+  hosts?: CodePressHostAdapters
+  editEngine?: ControlledEditEngine
+}
+
+export interface AdapterSnapshot {
+  document: ControlledEditorDocument
+  revision: number
+}
+
+function stableSerialize(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableSerialize).join(',')}]`
+  if (value && typeof value === 'object') {
+    return `{${Object.entries(value as Record<string, unknown>)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`)
+      .join(',')}}`
+  }
+  return JSON.stringify(value)
+}
+
+function copyResult<T>(value: T): T {
+  const clone = (entry: unknown): unknown => {
+    if (entry === null || (typeof entry !== 'object' && typeof entry !== 'bigint')) return entry
+    if (typeof entry === 'bigint') return entry
+    if (Array.isArray(entry)) return entry.map(clone)
+    return Object.fromEntries(Object.entries(entry).map(([key, child]) => [key, clone(child)]))
+  }
+  return clone(value) as T
+}
+
+function emptyActual(): Record<string, string | number | boolean | null> {
+  return {}
+}
+
+function error(
+  code: VideoCommandError['code'],
+  message: string,
+  details: VideoCommandError['details'],
+  extras: Pick<VideoCommandError, 'operation_id' | 'command_id'> = {},
+): VideoCommandError {
+  const retryable = code === 'revision_conflict' || code === 'operation_in_progress'
+  return { code, message, retryable, details, ...extras }
+}
+
+function requestString(value: unknown, fallback: string): string {
+  return typeof value === 'string' && isStableIdentifier(value) ? value : fallback
+}
+
+function rejected(input: unknown, commandError: VideoCommandError): EditApplyResult {
+  const candidate = input && typeof input === 'object' ? (input as Record<string, unknown>) : {}
+  return {
+    status: 'rejected',
+    timeline_id: requestString(candidate.timeline_id, 'unknown-timeline'),
+    operation_id: requestString(candidate.operation_id, 'invalid-operation'),
+    idempotency_key: requestString(candidate.idempotency_key, 'invalid-idempotency'),
+    base_revision:
+      typeof candidate.base_revision === 'number' &&
+      Number.isSafeInteger(candidate.base_revision) &&
+      candidate.base_revision >= 0
+        ? candidate.base_revision
+        : 0,
+    error: commandError,
+  }
+}
+
+function itemId(item: TimelineItem): string {
+  return item.item_type === 'caption_cue' ? item.cue_id : item.item_id
+}
+
+function findItem(timeline: TimelineState, id: string): TimelineItem | undefined {
+  for (const track of timeline.tracks) {
+    const item = track.items.find((candidate) => itemId(candidate) === id)
+    if (item) return item
+  }
+  return undefined
+}
+
+function actualForPrecondition(
+  timeline: TimelineState,
+  precondition: Precondition,
+): Record<string, string | number | boolean | null> {
+  switch (precondition.type) {
+    case 'track_exists':
+    case 'track_absent': {
+      const track = timeline.tracks.find(
+        (candidate) => candidate.track_id === precondition.track_id,
+      )
+      return { exists: Boolean(track), track_id: track?.track_id ?? null }
+    }
+    case 'item_exists':
+    case 'item_absent': {
+      const item = findItem(timeline, precondition.item_id)
+      return { exists: Boolean(item), item_id: item ? itemId(item) : null }
+    }
+    case 'item_at': {
+      const item = findItem(timeline, precondition.item_id)
+      if (!item)
+        return {
+          exists: false,
+          item_id: null,
+          track_id: null,
+          timeline_start_us: null,
+          timeline_end_us: null,
+        }
+      return item.item_type === 'caption_cue'
+        ? {
+            exists: true,
+            item_id: item.cue_id,
+            track_id: item.track_id,
+            timeline_start_us: item.start_us,
+            timeline_end_us: item.end_us,
+          }
+        : {
+            exists: true,
+            item_id: item.item_id,
+            track_id: item.track_id,
+            timeline_start_us: item.timeline_start_us,
+            timeline_end_us: item.timeline_end_us,
+          }
+    }
+    case 'media_content_hash': {
+      const media = timeline.media.find((candidate) => candidate.media_id === precondition.media_id)
+      return {
+        exists: Boolean(media),
+        media_id: media?.media_id ?? null,
+        content_hash: media?.content_hash ?? null,
+      }
+    }
+    case 'caption_cue_at': {
+      const item = findItem(timeline, precondition.cue_id)
+      if (!item || item.item_type !== 'caption_cue')
+        return {
+          exists: false,
+          cue_id: null,
+          track_id: null,
+          start_us: null,
+          end_us: null,
+          text: null,
+        }
+      return {
+        exists: true,
+        cue_id: item.cue_id,
+        track_id: item.track_id,
+        start_us: item.start_us,
+        end_us: item.end_us,
+        text: item.text,
+      }
+    }
+  }
+}
+
+function preconditionMatches(timeline: TimelineState, precondition: Precondition): boolean {
+  const actual = actualForPrecondition(timeline, precondition)
+  switch (precondition.type) {
+    case 'track_exists':
+      return actual.exists === true
+    case 'track_absent':
+      return actual.exists === false
+    case 'item_exists':
+      return actual.exists === true
+    case 'item_absent':
+      return actual.exists === false
+    case 'item_at':
+      return (
+        actual.exists === true &&
+        actual.item_id === precondition.item_id &&
+        actual.track_id === precondition.track_id &&
+        actual.timeline_start_us === precondition.timeline_start_us &&
+        actual.timeline_end_us === precondition.timeline_end_us
+      )
+    case 'media_content_hash':
+      return actual.content_hash === precondition.content_hash
+    case 'caption_cue_at':
+      return (
+        actual.exists === true &&
+        actual.cue_id === precondition.cue_id &&
+        actual.track_id === precondition.track_id &&
+        actual.start_us === precondition.start_us &&
+        actual.end_us === precondition.end_us &&
+        actual.text === precondition.text
+      )
+  }
+}
+
+function validateCurrentTimeline(timeline: TimelineState): VideoCommandError | null {
+  const result = validateTimelineState(timeline)
+  return result.ok
+    ? null
+    : (result.errors[0] ??
+        error('invalid_timeline', 'Timeline is invalid', {
+          kind: 'invalid_timeline',
+          path: 'timeline',
+          reason: 'validation failed',
+        }))
+}
+
+/**
+ * CodePress command adapter. It owns neither durable persistence nor media
+ * resolution; it atomically translates a validated batch through the pure
+ * edit engine and publishes the resulting controlled document to its host.
+ */
+export class CodePressCommandAdapter implements ControlledEditorPort {
+  private document: ControlledEditorDocument
+  private readonly renderer?: ControlledRenderer
+  private readonly hosts: CodePressHostAdapters
+  private readonly editEngine: ControlledEditEngine
+  private readonly operations = new Map<string, StoredOperation>()
+  private readonly listeners = new Set<(document: ControlledEditorDocument) => void>()
+  private readonly externalEditor?: ControlledEditorPort
+
+  constructor(options: CodePressCommandAdapterOptions) {
+    const timelineError = validateCurrentTimeline(options.document.timeline)
+    if (timelineError) throw new Error(timelineError.message)
+    assertFrameAligned(options.document.timeline.duration_us, options.document.fps)
+    this.document = copyResult(options.document)
+    this.renderer = options.renderer
+    this.hosts = options.hosts ?? {}
+    this.editEngine = options.editEngine ?? controlledEditEngine
+    this.externalEditor = options.editor
+  }
+
+  getDocument(): ControlledEditorDocument {
+    return copyResult(this.document)
+  }
+
+  replaceDocument(document: ControlledEditorDocument): void {
+    const timelineError = validateCurrentTimeline(document.timeline)
+    if (timelineError) throw new Error(timelineError.message)
+    assertFrameAligned(document.timeline.duration_us, document.fps)
+    this.document = copyResult(document)
+    this.publishDocument(this.document)
+  }
+
+  subscribe(listener: (document: ControlledEditorDocument) => void): () => void {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  getSnapshot(): AdapterSnapshot {
+    const document = this.getDocument()
+    return { document, revision: document.timeline.revision }
+  }
+
+  /** Apply one canonical PR1 command batch synchronously and atomically. */
+  apply(input: unknown): EditApplyResult {
+    const validRequest = validateCommandBatch(input)
+    if (!validRequest.ok) {
+      const first =
+        validRequest.errors[0] ??
+        error('invalid_request', 'Request is invalid', {
+          kind: 'invalid_request',
+          path: 'request',
+          reason: 'validation failed',
+        })
+      return rejected(input, first)
+    }
+    const batch: EditCommandBatch = validRequest.value
+    const current = this.getDocument()
+    const timelineError = validateCurrentTimeline(current.timeline)
+    if (timelineError) return rejected(batch, timelineError)
+    if (batch.timeline_id !== current.timeline.timeline_id) {
+      return rejected(
+        batch,
+        error(
+          'unknown_timeline',
+          `Timeline "${batch.timeline_id}" is not loaded`,
+          { kind: 'resource', resource: 'timeline', id: batch.timeline_id },
+          { operation_id: batch.operation_id },
+        ),
+      )
+    }
+
+    const payload = stableSerialize(batch)
+    const prior = this.operations.get(batch.idempotency_key)
+    if (prior) {
+      if (prior.payload !== payload) {
+        return rejected(
+          batch,
+          error(
+            'idempotency_conflict',
+            'The idempotency key was already used for a different operation.',
+            {
+              kind: 'idempotency_conflict',
+              idempotency_key: batch.idempotency_key,
+              original_operation_id: prior.result.operation_id,
+            },
+            { operation_id: batch.operation_id },
+          ),
+        )
+      }
+      const replayed: Exclude<EditApplyResult, { status: 'rejected' }> = {
+        ...copyResult(prior.result),
+        status: 'replayed',
+        replayed_operation_id: prior.result.operation_id,
+      }
+      return copyResult(replayed)
+    }
+
+    if (batch.base_revision !== current.timeline.revision) {
+      return rejected(
+        batch,
+        error(
+          'revision_conflict',
+          'The timeline changed after this operation was prepared.',
+          {
+            kind: 'revision_conflict',
+            base_revision: batch.base_revision,
+            current_revision: current.timeline.revision,
+            rebase: {
+              status: 'required',
+              automatic: false,
+              strategy: 'refresh_then_resubmit',
+              retry_with_revision: current.timeline.revision,
+            },
+          },
+          { operation_id: batch.operation_id },
+        ),
+      )
+    }
+
+    for (const [index, precondition] of batch.preconditions.entries()) {
+      if (!preconditionMatches(current.timeline, precondition)) {
+        return rejected(
+          batch,
+          error(
+            'precondition_failed',
+            `Precondition ${index} failed.`,
+            {
+              kind: 'precondition_failed',
+              precondition_index: index,
+              precondition,
+              actual: actualForPrecondition(current.timeline, precondition) ?? emptyActual(),
+            },
+            { operation_id: batch.operation_id },
+          ),
+        )
+      }
+    }
+
+    let engineResult: EditEngineResult
+    try {
+      engineResult = this.editEngine.apply(current.timeline, batch.commands, {
+        fps: current.fps,
+      })
+    } catch (caught) {
+      const commandError =
+        caught instanceof FrameTimingError
+          ? error(
+              'invalid_request',
+              caught.message,
+              { kind: 'invalid_request', path: 'commands', reason: 'time must be frame-aligned' },
+              { operation_id: batch.operation_id },
+            )
+          : caught instanceof EditEngineError
+            ? error(
+                caught.code === 'unknown_track'
+                  ? 'unknown_track'
+                  : caught.code === 'unknown_item'
+                    ? 'unknown_item'
+                    : caught.code === 'unknown_media'
+                      ? 'unknown_media'
+                      : caught.code === 'unsupported_command'
+                        ? 'unsupported_command'
+                        : 'invalid_request',
+                caught.message,
+                { kind: 'generic', reason: caught.message },
+                {
+                  operation_id: batch.operation_id,
+                  ...(caught.command_id ? { command_id: caught.command_id } : {}),
+                },
+              )
+            : error(
+                'invalid_request',
+                caught instanceof Error ? caught.message : String(caught),
+                {
+                  kind: 'generic',
+                  reason: caught instanceof Error ? caught.message : String(caught),
+                },
+                { operation_id: batch.operation_id },
+              )
+      return rejected(batch, commandError)
+    }
+
+    const nextTimeline: TimelineState = {
+      ...engineResult.timeline,
+      revision: current.timeline.revision + 1,
+    }
+    const nextDocument = { ...current, timeline: nextTimeline }
+    const result: Exclude<EditApplyResult, { status: 'rejected' }> = {
+      status: 'applied',
+      timeline_id: batch.timeline_id,
+      operation_id: batch.operation_id,
+      idempotency_key: batch.idempotency_key,
+      base_revision: batch.base_revision,
+      previous_revision: current.timeline.revision,
+      resulting_revision: nextTimeline.revision,
+      timeline: nextTimeline,
+      commands: engineResult.commands,
+      rebase: { status: 'not_attempted', automatic: false },
+    }
+    this.document = copyResult(nextDocument)
+    this.operations.set(batch.idempotency_key, { payload, result: copyResult(result) })
+    this.publishDocument(nextDocument)
+    this.publishTelemetry(batch, nextTimeline.revision)
+    return copyResult(result)
+  }
+
+  async renderFrame(time_us: number): Promise<RenderedFrame> {
+    if (!this.renderer) throw new Error('No controlled renderer is attached')
+    const document = this.getDocument()
+    const frame = assertFrameAligned(time_us, document.fps)
+    return this.renderer.renderFrame({ document, frame, time_us })
+  }
+
+  private publishDocument(document: ControlledEditorDocument): void {
+    try {
+      this.externalEditor?.replaceDocument(copyResult(document))
+    } catch {
+      // Editor publication is an observer side effect; it cannot reject a committed edit.
+    }
+    this.notify(document)
+  }
+
+  private publishTelemetry(batch: EditCommandBatch, revision: number): void {
+    try {
+      void Promise.resolve(
+        this.hosts.telemetryClient?.emit({
+          name: 'video.timeline_operation_applied',
+          timeline_id: batch.timeline_id,
+          operation_id: batch.operation_id,
+          revision,
+          attributes: { command_count: batch.commands.length },
+        }),
+      ).catch(() => undefined)
+    } catch {
+      // Telemetry is best effort; a host failure cannot change the committed result.
+    }
+  }
+
+  private notify(document: ControlledEditorDocument = this.document): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(copyResult(document))
+      } catch {
+        // Subscribers are observers; one faulty listener must not affect the edit result.
+      }
+    }
+  }
+}
+
+export function createCodePressCommandAdapter(
+  options: CodePressCommandAdapterOptions,
+): CodePressCommandAdapter {
+  return new CodePressCommandAdapter(options)
+}
diff --git a/src/features/editor/codepress/caption-commands.test.ts b/src/features/editor/codepress/caption-commands.test.ts
new file mode 100644
index 000000000..fe017b2eb
--- /dev/null
+++ b/src/features/editor/codepress/caption-commands.test.ts
@@ -0,0 +1,304 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import { CodePressCommandAdapter } from './adapter'
+import {
+  applyCaptionCommands,
+  captionCuePrecondition,
+  createCaptionCommandBatch,
+} from './caption-commands'
+import { framesToMicroseconds, type FrameRateLike } from './timing'
+import type { ControlledEditorDocument } from './interfaces'
+
+const ntsc: FrameRateLike = {
+  numerator: 30_000n,
+  denominator: 1_001n,
+  value: 30_000 / 1_001,
+}
+
+function documentWithCaptionTrack(): ControlledEditorDocument {
+  return {
+    fps: ntsc,
+    width: 1920,
+    height: 1080,
+    timeline: {
+      contract_version: 1,
+      schema_version: 1,
+      timeline_id: 'timeline-captions',
+      revision: 0,
+      duration_us: framesToMicroseconds(180, ntsc),
+      media: [],
+      tracks: [
+        {
+          track_id: 'captions-en',
+          kind: 'caption',
+          name: 'English',
+          language: 'en',
+          locked: false,
+          muted: false,
+          items: [],
+        },
+      ],
+    },
+  }
+}
+
+function frameCue(start: number, end: number, text = 'Hello') {
+  return {
+    type: 'caption_cue' as const,
+    id: 'cue-1',
+    trackId: 'captions-en',
+    from: start,
+    durationInFrames: end - start,
+    text,
+  }
+}
+
+describe('caption command bridge', () => {
+  it('translates frame-native cue timing without leaking frame or legacy fields', () => {
+    const adapter = new CodePressCommandAdapter({ document: documentWithCaptionTrack() })
+    const batch = createCaptionCommandBatch(
+      adapter,
+      [
+        {
+          command_id: 'upsert-cue',
+          type: 'upsert_caption_cues',
+          track_id: 'captions-en',
+          cues: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'cue-1',
+              track_id: 'captions-en',
+              start_frame: 3,
+              end_frame: 31,
+              text: 'NTSC cue',
+              style: { font_size: 40, alignment: 'center' },
+            },
+          ],
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-op-1' },
+    )
+
+    const command = batch.commands[0]
+    expect(command).toMatchObject({ type: 'upsert_caption_cues' })
+    if (command?.type !== 'upsert_caption_cues') return
+    expect(command.cues[0]).toMatchObject({
+      start_us: framesToMicroseconds(3, ntsc),
+      end_us: framesToMicroseconds(31, ntsc),
+    })
+    expect(command.cues[0]).not.toHaveProperty('start_frame')
+    expect(command.cues[0]).not.toHaveProperty('end_frame')
+
+    const result = adapter.apply(batch)
+    expect(result.status).toBe('applied')
+    const cue = adapter.getSnapshot().document.timeline.tracks[0]?.items[0]
+    expect(cue).toMatchObject({
+      item_type: 'caption_cue',
+      start_us: framesToMicroseconds(3, ntsc),
+      end_us: framesToMicroseconds(31, ntsc),
+    })
+  })
+
+  it('applies add/update/remove track and cue commands plus styles atomically', () => {
+    const adapter = new CodePressCommandAdapter({
+      document: {
+        ...documentWithCaptionTrack(),
+        timeline: { ...documentWithCaptionTrack().timeline, tracks: [] },
+      },
+    })
+    const addTrack = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'add-track',
+          type: 'add_caption_track',
+          track_id: 'captions-en',
+          name: 'English',
+          language: 'en',
+          index: 0,
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-add-track' },
+    )
+    expect(addTrack.status).toBe('applied')
+
+    const cue = frameCue(10, 40)
+    const addCue = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'add-cue',
+          type: 'upsert_caption_cues',
+          track_id: 'captions-en',
+          cues: [
+            {
+              item_type: 'caption_cue',
+              cue_id: cue.id,
+              track_id: cue.trackId,
+              start_frame: cue.from,
+              end_frame: cue.from + cue.durationInFrames,
+              text: cue.text,
+            },
+          ],
+        },
+      ],
+      ntsc,
+      {
+        operationId: 'caption-add-cue',
+        preconditions: [{ type: 'track_exists', track_id: 'captions-en' }],
+      },
+    )
+    expect(addCue.status).toBe('applied')
+
+    const updatedCue = { ...cue, text: 'Updated cue', from: 12, durationInFrames: 30 }
+    const updateCue = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'update-cue',
+          type: 'upsert_caption_cues',
+          track_id: 'captions-en',
+          cues: [
+            {
+              item_type: 'caption_cue',
+              cue_id: updatedCue.id,
+              track_id: updatedCue.trackId,
+              start_frame: updatedCue.from,
+              end_frame: updatedCue.from + updatedCue.durationInFrames,
+              text: updatedCue.text,
+            },
+          ],
+        },
+      ],
+      ntsc,
+      {
+        operationId: 'caption-update-cue',
+        preconditions: [captionCuePrecondition(cue, ntsc)],
+      },
+    )
+    expect(updateCue.status).toBe('applied')
+
+    const style = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'style-cue',
+          type: 'set_caption_style',
+          track_id: 'captions-en',
+          cue_ids: ['cue-1'],
+          style: { font_size: 48, color: '#ff0', alignment: 'center' },
+        },
+      ],
+      ntsc,
+      {
+        operationId: 'caption-style-cue',
+        preconditions: [captionCuePrecondition(updatedCue, ntsc)],
+      },
+    )
+    expect(style.status).toBe('applied')
+    expect(adapter.getSnapshot().document.timeline.tracks[0]?.items[0]).toMatchObject({
+      text: 'Updated cue',
+      style: { font_size: 48, color: '#ff0' },
+    })
+
+    const trackStyle = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'style-track',
+          type: 'set_caption_style',
+          track_id: 'captions-en',
+          cue_ids: null,
+          style: { font_family: 'Inter', background_opacity: 0.6 },
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-style-track' },
+    )
+    expect(trackStyle.status).toBe('applied')
+    expect(adapter.getSnapshot().document.timeline.tracks[0]?.default_style).toMatchObject({
+      font_family: 'Inter',
+      background_opacity: 0.6,
+    })
+
+    const removedCue = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'remove-cue',
+          type: 'remove_caption_cues',
+          track_id: 'captions-en',
+          cue_ids: ['cue-1'],
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-remove-cue' },
+    )
+    expect(removedCue.status).toBe('applied')
+    expect(adapter.getSnapshot().document.timeline.tracks[0]?.items).toHaveLength(0)
+
+    const removedTrack = applyCaptionCommands(
+      adapter,
+      [
+        {
+          command_id: 'remove-track',
+          type: 'remove_caption_track',
+          track_id: 'captions-en',
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-remove-track' },
+    )
+    expect(removedTrack.status).toBe('applied')
+    expect(adapter.getSnapshot().document.timeline.tracks).toHaveLength(0)
+  })
+
+  it('preserves idempotency replay and reports revision/idempotency conflicts', () => {
+    const adapter = new CodePressCommandAdapter({ document: documentWithCaptionTrack() })
+    const batch = createCaptionCommandBatch(
+      adapter,
+      [
+        {
+          command_id: 'cue-1',
+          type: 'upsert_caption_cues',
+          track_id: 'captions-en',
+          cues: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'cue-1',
+              track_id: 'captions-en',
+              start_frame: 1,
+              end_frame: 20,
+              text: 'Replay me',
+            },
+          ],
+        },
+      ],
+      ntsc,
+      { operationId: 'caption-idempotent', idempotencyKey: 'caption-idempotent-key' },
+    )
+    expect(adapter.apply(batch).status).toBe('applied')
+    expect(adapter.apply(batch).status).toBe('replayed')
+
+    const idempotencyConflict = adapter.apply({
+      ...batch,
+      operation_id: 'different-operation',
+      commands: [{ ...batch.commands[0]!, command_id: 'different-command' }],
+    })
+    expect(idempotencyConflict).toMatchObject({
+      status: 'rejected',
+      error: { code: 'idempotency_conflict' },
+    })
+
+    const stale = adapter.apply({
+      ...batch,
+      operation_id: 'stale-operation',
+      idempotency_key: 'stale-key',
+      base_revision: 0,
+      commands: [{ ...batch.commands[0]!, command_id: 'stale-command', cues: [] }],
+    })
+    expect(stale).toMatchObject({ status: 'rejected', error: { code: 'revision_conflict' } })
+  })
+})
diff --git a/src/features/editor/codepress/caption-commands.ts b/src/features/editor/codepress/caption-commands.ts
new file mode 100644
index 000000000..7bf16819c
--- /dev/null
+++ b/src/features/editor/codepress/caption-commands.ts
@@ -0,0 +1,109 @@
+import {
+  VIDEO_COMMAND_CONTRACT_VERSION,
+  type EditApplyResult,
+  type EditCommandBatch,
+  type Precondition,
+  type TimelineRevision,
+} from './contract'
+import type { AdapterSnapshot } from './adapter'
+import type { ControlledEditorDocument } from './interfaces'
+import type { FreeCutFrameCaptionCue } from './document'
+import {
+  translateFrameCaptionCommandToCommand,
+  type CaptionCommand,
+  type FrameCaptionCommand,
+  type FrameCaptionCue,
+} from './translation'
+import { framesToMicroseconds, type FrameRateLike } from './timing'
+
+export interface CaptionDocumentPort {
+  getSnapshot(): AdapterSnapshot
+  subscribe(listener: (document: ControlledEditorDocument) => void): () => void
+}
+
+export interface CaptionCommandPort extends CaptionDocumentPort {
+  apply(input: unknown): EditApplyResult
+}
+
+export type CaptionCommandSubmitter = (
+  batch: EditCommandBatch,
+) => EditApplyResult | Promise<EditApplyResult>
+
+export interface CaptionBatchOptions {
+  operationId?: string
+  idempotencyKey?: string
+  baseRevision?: TimelineRevision
+  preconditions?: readonly Precondition[]
+}
+
+export function makeCaptionOperationId(prefix = 'caption-operation'): string {
+  const suffix =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : Math.random().toString(36).slice(2)
+  return `${prefix}-${suffix}`
+}
+
+export function frameCueToCommandCue(cue: FreeCutFrameCaptionCue): FrameCaptionCue {
+  return {
+    item_type: 'caption_cue',
+    cue_id: cue.id,
+    track_id: cue.trackId,
+    start_frame: cue.from,
+    end_frame: cue.from + cue.durationInFrames,
+    text: cue.text,
+    ...(cue.speaker !== undefined ? { speaker: cue.speaker } : {}),
+    ...(cue.style !== undefined ? { style: { ...cue.style } } : {}),
+  }
+}
+
+export function captionCuePrecondition(
+  cue: FrameCaptionCue | FreeCutFrameCaptionCue,
+  fps: FrameRateLike,
+): Precondition {
+  const normalized = 'cue_id' in cue ? cue : frameCueToCommandCue(cue)
+  return {
+    type: 'caption_cue_at',
+    track_id: normalized.track_id,
+    cue_id: normalized.cue_id,
+    start_us: framesToMicroseconds(normalized.start_frame, fps),
+    end_us: framesToMicroseconds(normalized.end_frame, fps),
+    text: normalized.text,
+  }
+}
+
+export function createCaptionCommandBatch(
+  adapter: CaptionDocumentPort,
+  frameCommands: readonly FrameCaptionCommand[],
+  fps: FrameRateLike,
+  options: CaptionBatchOptions = {},
+): EditCommandBatch {
+  const snapshot = adapter.getSnapshot()
+  const operationId = options.operationId ?? makeCaptionOperationId()
+  return {
+    contract_version: VIDEO_COMMAND_CONTRACT_VERSION,
+    timeline_id: snapshot.document.timeline.timeline_id,
+    operation_id: operationId,
+    idempotency_key: options.idempotencyKey ?? operationId,
+    base_revision: options.baseRevision ?? snapshot.revision,
+    preconditions: options.preconditions ?? [],
+    commands: frameCommands.map((command) =>
+      translateFrameCaptionCommandToCommand(command, fps),
+    ) as readonly CaptionCommand[],
+  }
+}
+
+export function applyCaptionCommands(
+  adapter: CaptionCommandPort,
+  frameCommands: readonly FrameCaptionCommand[],
+  fps: FrameRateLike,
+  options: CaptionBatchOptions = {},
+): EditApplyResult {
+  return adapter.apply(createCaptionCommandBatch(adapter, frameCommands, fps, options))
+}
+
+export function isCaptionApplySuccess(
+  result: EditApplyResult,
+): result is Extract<EditApplyResult, { status: 'applied' | 'replayed' }> {
+  return result.status === 'applied' || result.status === 'replayed'
+}
diff --git a/src/features/editor/codepress/caption-editor-view.tsx b/src/features/editor/codepress/caption-editor-view.tsx
new file mode 100644
index 000000000..f7d4b6c73
--- /dev/null
+++ b/src/features/editor/codepress/caption-editor-view.tsx
@@ -0,0 +1,833 @@
+import type { CSSProperties } from 'react'
+import { Captions, Check, Eye, EyeOff, Pencil, Plus, RotateCcw, Trash2, X } from 'lucide-react'
+
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { Switch } from '@/components/ui/switch'
+import { Textarea } from '@/components/ui/textarea'
+import { cn } from '@/shared/ui/cn'
+
+import { captionStyleOrDefault } from './caption-validation'
+import type { CaptionStyle } from './contract'
+import type { FreeCutFrameCaptionCue, FreeCutFrameDocument, FreeCutFrameTrack } from './document'
+import type { FrameRateLike } from './timing'
+
+export interface CaptionCueDraft {
+  start_frame: number
+  end_frame: number
+  text: string
+  speaker: string
+}
+
+export interface CaptionTrackDraft {
+  name: string
+  language: string
+}
+
+interface CaptionEditorViewProps {
+  adapterError: string | null
+  activeCue?: FreeCutFrameCaptionCue
+  activeTrack?: FreeCutFrameTrack
+  activeTrackId: string | null
+  announcement: string
+  busy: boolean
+  className?: string
+  currentFrame: number
+  cueDrafts: Record<string, CaptionCueDraft>
+  document: FreeCutFrameDocument | null
+  editingCueId: string | null
+  editingTrackDraft: CaptionTrackDraft | null
+  error: string | null
+  fps: FrameRateLike
+  loading: boolean
+  onAddCue: () => void
+  onAddTrack: () => void
+  onApplyStyle: () => void
+  onBeginEditCue: (cue: FreeCutFrameCaptionCue) => void
+  onCancelEditCue: (cueId: string) => void
+  onCueDraftChange: (cueId: string, draft: CaptionCueDraft) => void
+  onRemoveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onRemoveTrack: () => void
+  onRetry?: () => void
+  onSaveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onSaveTrack: () => void
+  onSeek?: (frame: number) => void
+  onSelectTrack: (trackId: string) => void
+  onStyleChange: (patch: Partial<CaptionStyle>) => void
+  onStyleTargetChange: (cueId: string | null) => void
+  onToggleDisplay: () => void
+  onTrackDraftChange: (patch: Partial<CaptionTrackDraft>) => void
+  styleDraft: CaptionStyle
+  styleTargetCueId: string | null
+  tracks: readonly FreeCutFrameTrack[]
+}
+
+interface CaptionStyleControlsProps {
+  activeTrack: FreeCutFrameTrack
+  busy: boolean
+  onApplyStyle: () => void
+  onStyleChange: (patch: Partial<CaptionStyle>) => void
+  onStyleTargetChange: (cueId: string | null) => void
+  styleDraft: CaptionStyle
+  styleTargetCueId: string | null
+}
+
+interface CaptionPreviewProps {
+  activeCue?: FreeCutFrameCaptionCue
+  activeTrack: FreeCutFrameTrack
+  currentFrame: number
+  fps: FrameRateLike
+}
+
+function frameRateValue(fps: FrameRateLike): number {
+  return typeof fps === 'number' ? fps : fps.value
+}
+
+function formatFrame(frame: number, fps: FrameRateLike): string {
+  const seconds = frame / frameRateValue(fps)
+  return `${seconds.toFixed(2)}s · frame ${frame}`
+}
+
+function CaptionStyleControls({
+  activeTrack,
+  busy,
+  onApplyStyle,
+  onStyleChange,
+  onStyleTargetChange,
+  styleDraft,
+  styleTargetCueId,
+}: CaptionStyleControlsProps) {
+  const cues = activeTrack.items.filter(
+    (item): item is FreeCutFrameCaptionCue => item.type === 'caption_cue',
+  )
+
+  return (
+    <div
+      className="rounded-md border border-border/70 bg-muted/10 p-3"
+      data-testid="caption-style-controls"
+    >
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div>
+          <h3 className="text-xs font-semibold">Caption style</h3>
+          <p className="text-[11px] text-muted-foreground">
+            Apply a default or cue-specific style through the command contract.
+          </p>
+        </div>
+        <select
+          aria-label="Caption style target"
+          value={styleTargetCueId ?? ''}
+          onChange={(event) => onStyleTargetChange(event.target.value || null)}
+          className="h-8 rounded-md border border-input bg-background px-2 text-xs"
+        >
+          <option value="">Track default</option>
+          {cues.map((cue) => (
+            <option key={cue.id} value={cue.id}>
+              Cue: {cue.text.slice(0, 24)}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div className="mt-3 grid gap-2 sm:grid-cols-2 lg:grid-cols-4">
+        <div>
+          <Label htmlFor="caption-font-family" className="text-[11px]">
+            Font
+          </Label>
+          <Input
+            id="caption-font-family"
+            value={styleDraft.font_family ?? ''}
+            onChange={(event) => onStyleChange({ font_family: event.target.value })}
+            className="mt-1 h-8 text-xs"
+            maxLength={128}
+          />
+        </div>
+        <div>
+          <Label htmlFor="caption-font-size" className="text-[11px]">
+            Size
+          </Label>
+          <Input
+            id="caption-font-size"
+            type="number"
+            min={1}
+            max={512}
+            step={1}
+            value={styleDraft.font_size ?? 42}
+            onChange={(event) => onStyleChange({ font_size: Number(event.target.value) })}
+            className="mt-1 h-8 text-xs"
+          />
+        </div>
+        <div>
+          <Label htmlFor="caption-color" className="text-[11px]">
+            Color
+          </Label>
+          <Input
+            id="caption-color"
+            type="text"
+            value={styleDraft.color ?? '#ffffff'}
+            onChange={(event) => onStyleChange({ color: event.target.value })}
+            className="mt-1 h-8 text-xs"
+            maxLength={128}
+          />
+        </div>
+        <div>
+          <Label htmlFor="caption-alignment" className="text-[11px]">
+            Alignment
+          </Label>
+          <select
+            id="caption-alignment"
+            value={styleDraft.alignment ?? 'center'}
+            onChange={(event) =>
+              onStyleChange({ alignment: event.target.value as CaptionStyle['alignment'] })
+            }
+            className="mt-1 flex h-8 w-full rounded-md border border-input bg-background px-2 text-xs"
+          >
+            <option value="left">Left</option>
+            <option value="center">Center</option>
+            <option value="right">Right</option>
+          </select>
+        </div>
+      </div>
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        className="mt-3"
+        onClick={onApplyStyle}
+        disabled={busy}
+      >
+        <Check className="mr-1.5 h-3.5 w-3.5" />
+        Apply style
+      </Button>
+    </div>
+  )
+}
+
+function CaptionPreview({ activeCue, activeTrack, currentFrame, fps }: CaptionPreviewProps) {
+  const previewStyle = captionStyleOrDefault(activeCue?.style ?? activeTrack.defaultStyle)
+
+  return (
+    <div
+      className="rounded-md border border-border/70 bg-background p-3"
+      data-testid="caption-preview"
+    >
+      <p className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+        Preview · {formatFrame(currentFrame, fps)}
+      </p>
+      <div className="mt-2 flex min-h-14 items-center justify-center rounded bg-black px-4 py-3">
+        {activeTrack.muted ? (
+          <p className="text-xs text-slate-400">Captions hidden</p>
+        ) : activeCue ? (
+          <p
+            className="max-w-full rounded px-3 py-1 text-center text-sm"
+            style={
+              {
+                fontFamily: previewStyle.font_family,
+                fontSize: `${previewStyle.font_size ?? 42}px`,
+                color: previewStyle.color,
+                backgroundColor: previewStyle.background_color,
+                textAlign: previewStyle.alignment,
+              } as CSSProperties
+            }
+          >
+            {activeCue.text}
+          </p>
+        ) : (
+          <p className="text-xs text-slate-400">No caption at this frame</p>
+        )}
+      </div>
+    </div>
+  )
+}
+
+interface CaptionCueRowProps {
+  busy: boolean
+  cue: FreeCutFrameCaptionCue
+  draft: CaptionCueDraft
+  durationInFrames: number
+  fps: FrameRateLike
+  index: number
+  isEditing: boolean
+  onBeginEdit: () => void
+  onCancelEdit: () => void
+  onDraftChange: (draft: CaptionCueDraft) => void
+  onRemove: () => void
+  onSave: () => void
+  onSeek?: () => void
+}
+
+function CaptionCueRow({
+  busy,
+  cue,
+  draft,
+  durationInFrames,
+  fps,
+  index,
+  isEditing,
+  onBeginEdit,
+  onCancelEdit,
+  onDraftChange,
+  onRemove,
+  onSave,
+  onSeek,
+}: CaptionCueRowProps) {
+  return (
+    <li className="rounded-md border border-border/70 p-3" data-testid={`caption-cue-${cue.id}`}>
+      <div className="flex items-start justify-between gap-3">
+        <button
+          type="button"
+          className="min-w-0 text-left"
+          onClick={onSeek}
+          aria-label={`Seek to cue ${index + 1} at frame ${cue.from}`}
+        >
+          <span className="block truncate text-xs font-medium">{cue.text || 'Untitled cue'}</span>
+          <span className="mt-0.5 block text-[11px] text-muted-foreground">
+            {formatFrame(cue.from, fps)} → {formatFrame(cue.from + cue.durationInFrames, fps)}
+          </span>
+        </button>
+        <div className="flex shrink-0 gap-1">
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            onClick={onBeginEdit}
+            disabled={busy}
+            aria-label={`Edit cue ${index + 1}`}
+          >
+            <Pencil className="h-3.5 w-3.5" />
+          </Button>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            onClick={onRemove}
+            disabled={busy}
+            aria-label={`Remove cue ${index + 1}`}
+          >
+            <Trash2 className="h-3.5 w-3.5 text-destructive" />
+          </Button>
+        </div>
+      </div>
+      {isEditing ? (
+        <div className="mt-3 space-y-2">
+          <div className="grid grid-cols-2 gap-2">
+            <div>
+              <Label htmlFor={`caption-${cue.id}-start`} className="text-[11px]">
+                Start frame
+              </Label>
+              <Input
+                id={`caption-${cue.id}-start`}
+                type="number"
+                min={0}
+                max={durationInFrames}
+                step={1}
+                value={draft.start_frame}
+                onChange={(event) =>
+                  onDraftChange({ ...draft, start_frame: Number(event.target.value) })
+                }
+                className="mt-1 h-8 text-xs"
+              />
+            </div>
+            <div>
+              <Label htmlFor={`caption-${cue.id}-end`} className="text-[11px]">
+                End frame
+              </Label>
+              <Input
+                id={`caption-${cue.id}-end`}
+                type="number"
+                min={1}
+                max={durationInFrames}
+                step={1}
+                value={draft.end_frame}
+                onChange={(event) =>
+                  onDraftChange({ ...draft, end_frame: Number(event.target.value) })
+                }
+                className="mt-1 h-8 text-xs"
+              />
+            </div>
+          </div>
+          <div>
+            <Label htmlFor={`caption-${cue.id}-text`} className="text-[11px]">
+              Text
+            </Label>
+            <Textarea
+              id={`caption-${cue.id}-text`}
+              value={draft.text}
+              maxLength={32000}
+              onChange={(event) => onDraftChange({ ...draft, text: event.target.value })}
+              className="mt-1 min-h-16 text-xs"
+            />
+          </div>
+          <div>
+            <Label htmlFor={`caption-${cue.id}-speaker`} className="text-[11px]">
+              Speaker (optional)
+            </Label>
+            <Input
+              id={`caption-${cue.id}-speaker`}
+              value={draft.speaker}
+              maxLength={128}
+              onChange={(event) => onDraftChange({ ...draft, speaker: event.target.value })}
+              className="mt-1 h-8 text-xs"
+            />
+          </div>
+          <div className="flex justify-end gap-2">
+            <Button
+              type="button"
+              variant="outline"
+              size="sm"
+              onClick={onCancelEdit}
+              disabled={busy}
+            >
+              <X className="mr-1.5 h-3.5 w-3.5" />
+              Cancel
+            </Button>
+            <Button type="button" size="sm" onClick={onSave} disabled={busy}>
+              <Check className="mr-1.5 h-3.5 w-3.5" />
+              Save cue
+            </Button>
+          </div>
+        </div>
+      ) : null}
+    </li>
+  )
+}
+
+interface CaptionCueListProps {
+  activeTrack: FreeCutFrameTrack
+  busy: boolean
+  cueDrafts: Record<string, CaptionCueDraft>
+  durationInFrames: number
+  editingCueId: string | null
+  fps: FrameRateLike
+  onAddCue: () => void
+  onBeginEditCue: (cue: FreeCutFrameCaptionCue) => void
+  onCancelEditCue: (cueId: string) => void
+  onCueDraftChange: (cueId: string, draft: CaptionCueDraft) => void
+  onRemoveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onSaveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onSeek?: (frame: number) => void
+}
+
+function CaptionCueList({
+  activeTrack,
+  busy,
+  cueDrafts,
+  durationInFrames,
+  editingCueId,
+  fps,
+  onAddCue,
+  onBeginEditCue,
+  onCancelEditCue,
+  onCueDraftChange,
+  onRemoveCue,
+  onSaveCue,
+  onSeek,
+}: CaptionCueListProps) {
+  const cues = activeTrack.items.filter(
+    (item): item is FreeCutFrameCaptionCue => item.type === 'caption_cue',
+  )
+
+  return (
+    <>
+      <div className="flex items-center justify-between gap-3">
+        <div>
+          <h3 className="text-xs font-semibold">Cue list</h3>
+          <p className="text-[11px] text-muted-foreground">
+            {cues.length} cue{cues.length === 1 ? '' : 's'} · {durationInFrames} frame timeline
+          </p>
+        </div>
+        <Button type="button" size="sm" onClick={onAddCue} disabled={busy}>
+          <Plus className="mr-1.5 h-3.5 w-3.5" />
+          Add cue
+        </Button>
+      </div>
+      {cues.length === 0 ? (
+        <p
+          className="rounded-md border border-dashed border-border p-4 text-center text-xs text-muted-foreground"
+          role="status"
+        >
+          No cues in this track yet.
+        </p>
+      ) : (
+        <ol
+          className="max-h-[28rem] space-y-2 overflow-y-auto"
+          aria-label={`${activeTrack.name} cues`}
+        >
+          {cues.map((cue, index) => (
+            <CaptionCueRow
+              key={cue.id}
+              busy={busy}
+              cue={cue}
+              draft={
+                cueDrafts[cue.id] ?? {
+                  start_frame: cue.from,
+                  end_frame: cue.from + cue.durationInFrames,
+                  text: cue.text,
+                  speaker: cue.speaker ?? '',
+                }
+              }
+              durationInFrames={durationInFrames}
+              fps={fps}
+              index={index}
+              isEditing={editingCueId === cue.id}
+              onBeginEdit={() => onBeginEditCue(cue)}
+              onCancelEdit={() => onCancelEditCue(cue.id)}
+              onDraftChange={(draft) => onCueDraftChange(cue.id, draft)}
+              onRemove={() => onRemoveCue(activeTrack.id, cue)}
+              onSave={() => onSaveCue(activeTrack.id, cue)}
+              onSeek={onSeek ? () => onSeek(cue.from) : undefined}
+            />
+          ))}
+        </ol>
+      )}
+    </>
+  )
+}
+
+interface CaptionTrackEditorProps {
+  activeCue?: FreeCutFrameCaptionCue
+  activeTrack: FreeCutFrameTrack
+  busy: boolean
+  cueDrafts: Record<string, CaptionCueDraft>
+  currentFrame: number
+  durationInFrames: number
+  editingCueId: string | null
+  editingTrackDraft: CaptionTrackDraft | null
+  fps: FrameRateLike
+  onAddCue: () => void
+  onApplyStyle: () => void
+  onBeginEditCue: (cue: FreeCutFrameCaptionCue) => void
+  onCancelEditCue: (cueId: string) => void
+  onCueDraftChange: (cueId: string, draft: CaptionCueDraft) => void
+  onRemoveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onSaveCue: (trackId: string, cue: FreeCutFrameCaptionCue) => void
+  onSaveTrack: () => void
+  onSeek?: (frame: number) => void
+  onStyleChange: (patch: Partial<CaptionStyle>) => void
+  onStyleTargetChange: (cueId: string | null) => void
+  onToggleDisplay: () => void
+  onTrackDraftChange: (patch: Partial<CaptionTrackDraft>) => void
+  styleDraft: CaptionStyle
+  styleTargetCueId: string | null
+}
+
+function CaptionTrackEditor({
+  activeCue,
+  activeTrack,
+  busy,
+  cueDrafts,
+  currentFrame,
+  durationInFrames,
+  editingCueId,
+  editingTrackDraft,
+  fps,
+  onAddCue,
+  onApplyStyle,
+  onBeginEditCue,
+  onCancelEditCue,
+  onCueDraftChange,
+  onRemoveCue,
+  onSaveCue,
+  onSaveTrack,
+  onSeek,
+  onStyleChange,
+  onStyleTargetChange,
+  onToggleDisplay,
+  onTrackDraftChange,
+  styleDraft,
+  styleTargetCueId,
+}: CaptionTrackEditorProps) {
+  return (
+    <>
+      <div className="grid gap-3 rounded-md border border-border/70 bg-muted/10 p-3 sm:grid-cols-[1fr_8rem_auto]">
+        <div>
+          <Label htmlFor="caption-track-name" className="text-xs">
+            Track name
+          </Label>
+          <Input
+            id="caption-track-name"
+            value={editingTrackDraft?.name ?? ''}
+            onChange={(event) => onTrackDraftChange({ name: event.target.value })}
+            className="mt-1 h-8 text-xs"
+            maxLength={128}
+          />
+        </div>
+        <div>
+          <Label htmlFor="caption-track-language" className="text-xs">
+            Language
+          </Label>
+          <Input
+            id="caption-track-language"
+            value={editingTrackDraft?.language ?? ''}
+            onChange={(event) => onTrackDraftChange({ language: event.target.value })}
+            className="mt-1 h-8 text-xs"
+            maxLength={32}
+          />
+        </div>
+        <Button
+          type="button"
+          variant="outline"
+          size="sm"
+          className="self-end"
+          onClick={onSaveTrack}
+          disabled={busy}
+        >
+          <Check className="mr-1.5 h-3.5 w-3.5" />
+          Save track
+        </Button>
+      </div>
+
+      <div className="flex flex-wrap items-center justify-between gap-3 rounded-md border border-border/70 bg-muted/10 px-3 py-2">
+        <div className="flex items-center gap-2">
+          {activeTrack.muted ? (
+            <EyeOff className="h-4 w-4 text-muted-foreground" aria-hidden="true" />
+          ) : (
+            <Eye className="h-4 w-4 text-primary" aria-hidden="true" />
+          )}
+          <Label htmlFor="caption-display-toggle" className="text-xs font-medium">
+            Display captions in preview
+          </Label>
+        </div>
+        <Switch
+          id="caption-display-toggle"
+          checked={!activeTrack.muted}
+          onCheckedChange={onToggleDisplay}
+          disabled={busy}
+          aria-label="Display captions in preview"
+        />
+      </div>
+
+      <CaptionStyleControls
+        activeTrack={activeTrack}
+        busy={busy}
+        onApplyStyle={onApplyStyle}
+        onStyleChange={onStyleChange}
+        onStyleTargetChange={onStyleTargetChange}
+        styleDraft={styleDraft}
+        styleTargetCueId={styleTargetCueId}
+      />
+
+      <CaptionPreview
+        activeCue={activeCue}
+        activeTrack={activeTrack}
+        currentFrame={currentFrame}
+        fps={fps}
+      />
+
+      <CaptionCueList
+        activeTrack={activeTrack}
+        busy={busy}
+        cueDrafts={cueDrafts}
+        durationInFrames={durationInFrames}
+        editingCueId={editingCueId}
+        fps={fps}
+        onAddCue={onAddCue}
+        onBeginEditCue={onBeginEditCue}
+        onCancelEditCue={onCancelEditCue}
+        onCueDraftChange={onCueDraftChange}
+        onRemoveCue={onRemoveCue}
+        onSaveCue={onSaveCue}
+        onSeek={onSeek}
+      />
+    </>
+  )
+}
+
+export function CaptionEditorView({
+  adapterError,
+  activeCue,
+  activeTrack,
+  activeTrackId,
+  announcement,
+  busy,
+  className,
+  currentFrame,
+  cueDrafts,
+  document,
+  editingCueId,
+  editingTrackDraft,
+  error,
+  fps,
+  loading,
+  onAddCue,
+  onAddTrack,
+  onApplyStyle,
+  onBeginEditCue,
+  onCancelEditCue,
+  onCueDraftChange,
+  onRemoveCue,
+  onRemoveTrack,
+  onRetry,
+  onSaveCue,
+  onSaveTrack,
+  onSeek,
+  onSelectTrack,
+  onStyleChange,
+  onStyleTargetChange,
+  onToggleDisplay,
+  onTrackDraftChange,
+  styleDraft,
+  styleTargetCueId,
+  tracks,
+}: CaptionEditorViewProps) {
+  if (loading) {
+    return (
+      <section
+        className={cn('rounded-lg border border-border bg-card p-4', className)}
+        data-testid="caption-editor-loading"
+        aria-busy="true"
+      >
+        <p className="text-sm text-muted-foreground" role="status">
+          Loading captions…
+        </p>
+      </section>
+    )
+  }
+
+  if (error || adapterError || !document) {
+    return (
+      <section
+        className={cn('rounded-lg border border-destructive/40 bg-card p-4', className)}
+        data-testid="caption-editor-error"
+        role="alert"
+      >
+        <div className="flex items-start justify-between gap-3">
+          <div>
+            <h2 className="text-sm font-semibold">Captions unavailable</h2>
+            <p className="mt-1 text-xs text-muted-foreground">
+              {error ?? adapterError ?? 'The caption document could not be loaded.'}
+            </p>
+          </div>
+          {onRetry ? (
+            <Button type="button" variant="outline" size="sm" onClick={onRetry}>
+              <RotateCcw className="mr-1.5 h-3.5 w-3.5" />
+              Retry
+            </Button>
+          ) : null}
+        </div>
+      </section>
+    )
+  }
+
+  return (
+    <section
+      className={cn(
+        'flex min-h-0 flex-col gap-4 rounded-lg border border-border bg-card p-4',
+        className,
+      )}
+      data-testid="caption-editor"
+      aria-label="Caption editor"
+    >
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div>
+          <div className="flex items-center gap-2">
+            <Captions className="h-4 w-4 text-primary" aria-hidden="true" />
+            <h2 className="text-sm font-semibold">Captions</h2>
+          </div>
+          <p className="mt-1 text-xs text-muted-foreground">
+            Frame-aligned cues are saved through the controlled command contract.
+          </p>
+        </div>
+        <Button
+          type="button"
+          size="sm"
+          onClick={onAddTrack}
+          disabled={busy}
+          data-testid="caption-add-track"
+        >
+          <Plus className="mr-1.5 h-3.5 w-3.5" />
+          Add track
+        </Button>
+      </div>
+
+      <p className="sr-only" aria-live="polite" data-testid="caption-editor-announcement">
+        {announcement}
+      </p>
+
+      {tracks.length === 0 ? (
+        <div
+          className="rounded-md border border-dashed border-border p-6 text-center"
+          data-testid="caption-editor-empty"
+          role="status"
+        >
+          <Captions className="mx-auto h-7 w-7 text-muted-foreground" aria-hidden="true" />
+          <p className="mt-2 text-sm font-medium">No caption tracks yet</p>
+          <p className="mt-1 text-xs text-muted-foreground">
+            Add a track to begin editing timed captions.
+          </p>
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            className="mt-4"
+            onClick={onAddTrack}
+            disabled={busy}
+          >
+            Add caption track
+          </Button>
+        </div>
+      ) : (
+        <>
+          <div className="flex flex-wrap items-end gap-2">
+            <div className="min-w-[12rem] flex-1">
+              <Label htmlFor="caption-track-select" className="text-xs">
+                Caption track
+              </Label>
+              <select
+                id="caption-track-select"
+                value={activeTrackId ?? ''}
+                onChange={(event) => onSelectTrack(event.target.value)}
+                className="mt-1 flex h-9 w-full rounded-md border border-input bg-background px-3 py-1 text-sm"
+              >
+                {tracks.map((track) => (
+                  <option key={track.id} value={track.id}>
+                    {track.name} · {track.language ?? 'und'}
+                  </option>
+                ))}
+              </select>
+            </div>
+            <Button
+              type="button"
+              variant="outline"
+              size="sm"
+              onClick={onRemoveTrack}
+              disabled={busy || !activeTrack}
+              aria-label="Remove selected caption track"
+            >
+              <Trash2 className="mr-1.5 h-3.5 w-3.5" />
+              Remove track
+            </Button>
+          </div>
+
+          {activeTrack ? (
+            <CaptionTrackEditor
+              activeCue={activeCue}
+              activeTrack={activeTrack}
+              busy={busy}
+              cueDrafts={cueDrafts}
+              currentFrame={currentFrame}
+              durationInFrames={document.durationInFrames}
+              editingCueId={editingCueId}
+              editingTrackDraft={editingTrackDraft}
+              fps={fps}
+              onAddCue={onAddCue}
+              onApplyStyle={onApplyStyle}
+              onBeginEditCue={onBeginEditCue}
+              onCancelEditCue={onCancelEditCue}
+              onCueDraftChange={onCueDraftChange}
+              onRemoveCue={onRemoveCue}
+              onSaveCue={onSaveCue}
+              onSaveTrack={onSaveTrack}
+              onSeek={onSeek}
+              onStyleChange={onStyleChange}
+              onStyleTargetChange={onStyleTargetChange}
+              onToggleDisplay={onToggleDisplay}
+              onTrackDraftChange={onTrackDraftChange}
+              styleDraft={styleDraft}
+              styleTargetCueId={styleTargetCueId}
+            />
+          ) : null}
+        </>
+      )}
+    </section>
+  )
+}
diff --git a/src/features/editor/codepress/caption-editor.test.tsx b/src/features/editor/codepress/caption-editor.test.tsx
new file mode 100644
index 000000000..3ade33a8e
--- /dev/null
+++ b/src/features/editor/codepress/caption-editor.test.tsx
@@ -0,0 +1,128 @@
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+import { CodePressCommandAdapter } from './adapter'
+import { CaptionEditor } from './caption-editor'
+import { framesToMicroseconds, type FrameRateLike } from './timing'
+import type { ControlledEditorDocument } from './interfaces'
+
+const fps: FrameRateLike = {
+  numerator: 30_000n,
+  denominator: 1_001n,
+  value: 30_000 / 1_001,
+}
+
+function adapterWithTrack(): CodePressCommandAdapter {
+  const document: ControlledEditorDocument = {
+    fps,
+    width: 1280,
+    height: 720,
+    timeline: {
+      contract_version: 1,
+      schema_version: 1,
+      timeline_id: 'timeline-caption-ui',
+      revision: 0,
+      duration_us: framesToMicroseconds(180, fps),
+      media: [],
+      tracks: [
+        {
+          track_id: 'captions-en',
+          kind: 'caption',
+          name: 'English',
+          language: 'en',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'cue-1',
+              track_id: 'captions-en',
+              start_us: framesToMicroseconds(10, fps),
+              end_us: framesToMicroseconds(40, fps),
+              text: 'Hello',
+            },
+          ],
+        },
+      ],
+    },
+  }
+  return new CodePressCommandAdapter({ document })
+}
+
+afterEach(() => cleanup())
+
+describe('CaptionEditor', () => {
+  it('shows an accessible empty state and adds a caption track through the adapter', async () => {
+    const adapter = adapterWithTrack()
+    adapter.apply({
+      contract_version: 1,
+      timeline_id: 'timeline-caption-ui',
+      operation_id: 'remove-initial-track',
+      idempotency_key: 'remove-initial-track',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        { command_id: 'remove-track', type: 'remove_caption_track', track_id: 'captions-en' },
+      ],
+    })
+    render(<CaptionEditor adapter={adapter} />)
+    expect(await screen.findByTestId('caption-editor-empty')).toHaveAttribute('role', 'status')
+    fireEvent.click(screen.getByRole('button', { name: 'Add caption track' }))
+    await waitFor(() => expect(screen.getByLabelText('Caption track')).toBeInTheDocument())
+    expect(adapter.getSnapshot().document.timeline.tracks).toHaveLength(1)
+  })
+
+  it('adds, edits, styles, toggles, seeks, and removes a bounded cue', async () => {
+    const adapter = adapterWithTrack()
+    const onSeek = vi.fn()
+    render(<CaptionEditor adapter={adapter} currentFrame={12} onSeek={onSeek} />)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Add cue' }))
+    expect(await screen.findByTestId(/caption-cue-captions-en-cue-/)).toBeInTheDocument()
+
+    const editButtons = screen.getAllByRole('button', { name: /Edit cue/ })
+    fireEvent.click(editButtons.at(-1)!)
+    const textareas = screen.getAllByLabelText('Text')
+    fireEvent.change(textareas.at(-1)!, { target: { value: 'Edited caption' } })
+    fireEvent.click(screen.getByRole('button', { name: 'Save cue' }))
+    await waitFor(() => {
+      const cues = adapter.getSnapshot().document.timeline.tracks[0]?.items ?? []
+      expect(
+        cues.some((item) => item.item_type === 'caption_cue' && item.text === 'Edited caption'),
+      ).toBe(true)
+    })
+
+    fireEvent.change(screen.getByLabelText('Size'), {
+      target: { value: '48' },
+    })
+    fireEvent.click(screen.getByRole('button', { name: 'Apply style' }))
+    await waitFor(() =>
+      expect(adapter.getSnapshot().document.timeline.tracks[0]?.default_style).toMatchObject({
+        font_size: 48,
+      }),
+    )
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Display captions in preview' }))
+    await waitFor(() => expect(adapter.getSnapshot().document.timeline.tracks[0]?.muted).toBe(true))
+
+    fireEvent.click(screen.getByRole('button', { name: /Seek to cue 1/ }))
+    expect(onSeek).toHaveBeenCalled()
+
+    const removeButtons = screen.getAllByRole('button', { name: /Remove cue/ })
+    fireEvent.click(removeButtons.at(-1)!)
+    await waitFor(() =>
+      expect(adapter.getSnapshot().document.timeline.tracks[0]?.items).toHaveLength(1),
+    )
+  })
+
+  it('renders loading and retryable error states', () => {
+    const adapter = adapterWithTrack()
+    const onRetry = vi.fn()
+    const { rerender } = render(<CaptionEditor adapter={adapter} loading />)
+    expect(screen.getByTestId('caption-editor-loading')).toHaveAttribute('aria-busy', 'true')
+    rerender(<CaptionEditor adapter={adapter} error="Network unavailable" onRetry={onRetry} />)
+    expect(screen.getByRole('alert')).toHaveTextContent('Network unavailable')
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    expect(onRetry).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/src/features/editor/codepress/caption-editor.tsx b/src/features/editor/codepress/caption-editor.tsx
new file mode 100644
index 000000000..000530548
--- /dev/null
+++ b/src/features/editor/codepress/caption-editor.tsx
@@ -0,0 +1,474 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+import {
+  applyCaptionCommands,
+  captionCuePrecondition,
+  createCaptionCommandBatch,
+  frameCueToCommandCue,
+  isCaptionApplySuccess,
+  makeCaptionOperationId,
+  type CaptionCommandSubmitter,
+  type CaptionDocumentPort,
+  type CaptionCommandPort,
+} from './caption-commands'
+import { captionStyleOrDefault, validateFrameCaptionCues } from './caption-validation'
+import {
+  controlledDocumentToFreeCutDocument,
+  type FreeCutFrameCaptionCue,
+  type FreeCutFrameDocument,
+} from './document'
+import {
+  CaptionEditorView,
+  type CaptionCueDraft,
+  type CaptionTrackDraft,
+} from './caption-editor-view'
+import type { CaptionStyle, EditApplyResult, Precondition } from './contract'
+import type { FrameRateLike } from './timing'
+
+export interface CaptionEditorProps {
+  /** The frame-document port supplied by the standalone adapter or host surface. */
+  adapter: CaptionDocumentPort
+  /** Optional async host submission path; omitted for the synchronous local adapter. */
+  submit?: CaptionCommandSubmitter
+  /** Frame currently shown by the host preview. */
+  currentFrame?: number
+  /** Host-owned loading state while an authoritative document is being fetched. */
+  loading?: boolean
+  /** Host-owned load error. Caption mutations are reported in this surface too. */
+  error?: string | null
+  onRetry?: () => void
+  onSeek?: (frame: number) => void
+  className?: string
+}
+
+const EMPTY_STYLE: CaptionStyle = captionStyleOrDefault(undefined)
+
+function frameRateValue(fps: FrameRateLike): number {
+  return typeof fps === 'number' ? fps : fps.value
+}
+
+function makeId(prefix: string, existing: ReadonlySet<string>): string {
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID().slice(0, 8)
+      : Math.random().toString(36).slice(2, 10)
+  const candidate = `${prefix}-${random}`
+  return existing.has(candidate) ? `${prefix}-${Date.now()}` : candidate
+}
+
+function snapshotToFrameDocument(adapter: CaptionDocumentPort): FreeCutFrameDocument | null {
+  try {
+    return controlledDocumentToFreeCutDocument(adapter.getSnapshot().document)
+  } catch {
+    return null
+  }
+}
+
+function draftForCue(cue: FreeCutFrameCaptionCue): CaptionCueDraft {
+  return {
+    start_frame: cue.from,
+    end_frame: cue.from + cue.durationInFrames,
+    text: cue.text,
+    speaker: cue.speaker ?? '',
+  }
+}
+
+function cueFromDraft(cue: FreeCutFrameCaptionCue, draft: CaptionCueDraft): FreeCutFrameCaptionCue {
+  return {
+    ...cue,
+    from: draft.start_frame,
+    durationInFrames: draft.end_frame - draft.start_frame,
+    text: draft.text,
+    ...(draft.speaker.trim() ? { speaker: draft.speaker.trim() } : { speaker: null }),
+  }
+}
+
+function resultMessage(result: EditApplyResult): string {
+  if (!isCaptionApplySuccess(result)) return result.error.message
+  return result.status === 'replayed' ? 'Caption edit replayed safely.' : 'Caption edit applied.'
+}
+
+export function CaptionEditor({
+  adapter,
+  submit,
+  currentFrame = 0,
+  loading = false,
+  error = null,
+  onRetry,
+  onSeek,
+  className,
+}: CaptionEditorProps) {
+  const [document, setDocument] = useState<FreeCutFrameDocument | null>(() =>
+    snapshotToFrameDocument(adapter),
+  )
+  const [adapterError, setAdapterError] = useState<string | null>(null)
+  const [announcement, setAnnouncement] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [activeTrackId, setActiveTrackId] = useState<string | null>(null)
+  const [editingCueId, setEditingCueId] = useState<string | null>(null)
+  const [cueDrafts, setCueDrafts] = useState<Record<string, CaptionCueDraft>>({})
+  const [trackDrafts, setTrackDrafts] = useState<Record<string, CaptionTrackDraft>>({})
+  const [styleTargetCueId, setStyleTargetCueId] = useState<string | null>(null)
+  const [styleDraft, setStyleDraft] = useState<CaptionStyle>(EMPTY_STYLE)
+
+  const syncDocument = useCallback(() => {
+    const next = snapshotToFrameDocument(adapter)
+    if (next) {
+      setDocument(next)
+      setAdapterError(null)
+    } else {
+      setAdapterError('The caption document could not be translated to frame-native data.')
+    }
+  }, [adapter])
+
+  useEffect(() => {
+    syncDocument()
+    return adapter.subscribe(syncDocument)
+  }, [adapter, syncDocument])
+
+  const tracks = useMemo(
+    () => document?.tracks.filter((track) => track.kind === 'caption') ?? [],
+    [document],
+  )
+  const activeTrack = tracks.find((track) => track.id === activeTrackId) ?? tracks[0]
+  const activeCue = activeTrack?.items.find(
+    (item): item is FreeCutFrameCaptionCue =>
+      item.type === 'caption_cue' &&
+      currentFrame >= item.from &&
+      currentFrame < item.from + item.durationInFrames,
+  )
+  const durationInFrames = document?.durationInFrames ?? 0
+  const fps = document?.fps ?? 30
+  const editingTrackDraft = useMemo(
+    () =>
+      activeTrack
+        ? (trackDrafts[activeTrack.id] ?? {
+            name: activeTrack.name,
+            language: activeTrack.language ?? '',
+          })
+        : null,
+    [activeTrack, trackDrafts],
+  )
+  const styleTargetCue = activeTrack?.items.find(
+    (item): item is FreeCutFrameCaptionCue =>
+      item.type === 'caption_cue' && item.id === styleTargetCueId,
+  )
+
+  useEffect(() => {
+    if (activeTrackId && tracks.some((track) => track.id === activeTrackId)) return
+    setActiveTrackId(tracks[0]?.id ?? null)
+  }, [activeTrackId, tracks])
+
+  useEffect(() => {
+    if (!activeTrack) {
+      setStyleTargetCueId(null)
+      setStyleDraft(EMPTY_STYLE)
+      return
+    }
+    const target = activeTrack.items.find(
+      (item): item is FreeCutFrameCaptionCue =>
+        item.type === 'caption_cue' && item.id === styleTargetCueId,
+    )
+    setStyleDraft(captionStyleOrDefault(target?.style ?? activeTrack.defaultStyle))
+  }, [activeTrack, styleTargetCueId])
+
+  const runCommands = useCallback(
+    (
+      commands: Parameters<typeof applyCaptionCommands>[1],
+      preconditions: readonly Precondition[] = [],
+    ): Promise<boolean> => {
+      if (busy || !document) return Promise.resolve(false)
+      setBusy(true)
+      setAdapterError(null)
+      setAnnouncement('Saving caption edit…')
+      const options = {
+        operationId: makeCaptionOperationId(),
+        preconditions,
+      }
+      const result = submit
+        ? submit(createCaptionCommandBatch(adapter, commands, fps, options))
+        : applyCaptionCommands(adapter as CaptionCommandPort, commands, fps, options)
+      return Promise.resolve(result)
+        .then((applied) => {
+          const message = resultMessage(applied)
+          if (applied.status === 'rejected') {
+            setAdapterError(message)
+            setAnnouncement(
+              'Caption edit was rejected. Refresh the authoritative revision before retrying.',
+            )
+            return false
+          }
+          syncDocument()
+          setAnnouncement(message)
+          return true
+        })
+        .catch((caught) => {
+          const message = caught instanceof Error ? caught.message : 'Caption edit failed.'
+          setAdapterError(message)
+          setAnnouncement('Caption edit failed.')
+          return false
+        })
+        .finally(() => setBusy(false))
+    },
+    [adapter, busy, document, fps, submit, syncDocument],
+  )
+
+  const addTrack = useCallback(async () => {
+    const ids = new Set(tracks.map((track) => track.id))
+    const trackId = makeId('caption-track', ids)
+    const applied = await runCommands([
+      {
+        command_id: makeCaptionOperationId('add-caption-track'),
+        type: 'add_caption_track',
+        track_id: trackId,
+        name: `Captions ${tracks.length + 1}`,
+        language: 'en',
+        index: document?.tracks.length ?? 0,
+      },
+    ])
+    if (applied) setActiveTrackId(trackId)
+  }, [document?.tracks.length, runCommands, tracks])
+
+  const removeTrack = useCallback(async () => {
+    if (!activeTrack) return
+    await runCommands(
+      [
+        {
+          command_id: makeCaptionOperationId('remove-caption-track'),
+          type: 'remove_caption_track',
+          track_id: activeTrack.id,
+        },
+      ],
+      [{ type: 'track_exists', track_id: activeTrack.id }],
+    )
+  }, [activeTrack, runCommands])
+
+  const saveTrack = useCallback(async () => {
+    if (!activeTrack || !editingTrackDraft) return
+    if (!editingTrackDraft.name.trim() || editingTrackDraft.name.length > 128) {
+      setAdapterError('Track name must be non-empty and at most 128 characters.')
+      return
+    }
+    if (editingTrackDraft.language.length > 32) {
+      setAdapterError('Track language must be at most 32 characters.')
+      return
+    }
+    await runCommands(
+      [
+        {
+          command_id: makeCaptionOperationId('update-caption-track'),
+          type: 'update_caption_track',
+          track_id: activeTrack.id,
+          name: editingTrackDraft.name.trim(),
+          language: editingTrackDraft.language.trim() || 'und',
+        },
+      ],
+      [{ type: 'track_exists', track_id: activeTrack.id }],
+    )
+  }, [activeTrack, editingTrackDraft, runCommands])
+
+  const toggleDisplay = useCallback(async () => {
+    if (!activeTrack) return
+    await runCommands(
+      [
+        {
+          command_id: makeCaptionOperationId('toggle-caption-track'),
+          type: 'update_track',
+          track_id: activeTrack.id,
+          muted: !activeTrack.muted,
+        },
+      ],
+      [{ type: 'track_exists', track_id: activeTrack.id }],
+    )
+  }, [activeTrack, runCommands])
+
+  const addCue = useCallback(async () => {
+    if (!activeTrack || durationInFrames < 2) {
+      setAdapterError('The timeline is too short to add a caption cue.')
+      return
+    }
+    const cues = activeTrack.items.filter(
+      (item): item is FreeCutFrameCaptionCue => item.type === 'caption_cue',
+    )
+    const startFrame = cues.reduce(
+      (latest, cue) => Math.max(latest, cue.from + cue.durationInFrames),
+      0,
+    )
+    const endFrame = Math.min(
+      durationInFrames,
+      startFrame + Math.max(1, Math.round(frameRateValue(fps))),
+    )
+    if (endFrame <= startFrame) {
+      setAdapterError('There is no bounded space left for another caption cue.')
+      return
+    }
+    const cueId = makeId(`${activeTrack.id}-cue`, new Set(cues.map((cue) => cue.id)))
+    const cue: FreeCutFrameCaptionCue = {
+      type: 'caption_cue',
+      id: cueId,
+      trackId: activeTrack.id,
+      from: startFrame,
+      durationInFrames: endFrame - startFrame,
+      text: 'New caption',
+    }
+    if (validateFrameCaptionCues([...cues, cue], durationInFrames).length > 0) {
+      setAdapterError('The new caption cue would exceed the bounded track range.')
+      return
+    }
+    const applied = await runCommands(
+      [
+        {
+          command_id: makeCaptionOperationId('add-caption-cue'),
+          type: 'upsert_caption_cues',
+          track_id: activeTrack.id,
+          cues: [frameCueToCommandCue(cue)],
+        },
+      ],
+      [{ type: 'track_exists', track_id: activeTrack.id }],
+    )
+    if (applied) {
+      setEditingCueId(cueId)
+      setCueDrafts((previous) => ({ ...previous, [cueId]: draftForCue(cue) }))
+    }
+  }, [activeTrack, durationInFrames, fps, runCommands])
+
+  const beginEditCue = useCallback((cue: FreeCutFrameCaptionCue) => {
+    setEditingCueId(cue.id)
+    setCueDrafts((previous) => ({ ...previous, [cue.id]: previous[cue.id] ?? draftForCue(cue) }))
+  }, [])
+
+  const cancelEditCue = useCallback((cueId: string) => {
+    setEditingCueId((current) => (current === cueId ? null : current))
+  }, [])
+
+  const saveCue = useCallback(
+    async (trackId: string, cue: FreeCutFrameCaptionCue) => {
+      const draft = cueDrafts[cue.id] ?? draftForCue(cue)
+      const nextCue = cueFromDraft(cue, draft)
+      const cues =
+        tracks
+          .find((track) => track.id === trackId)
+          ?.items.filter((item): item is FreeCutFrameCaptionCue => item.type === 'caption_cue')
+          .map((candidate) => (candidate.id === cue.id ? nextCue : candidate)) ?? []
+      const issues = validateFrameCaptionCues(cues, durationInFrames)
+      if (issues.length > 0) {
+        setAdapterError(issues[0]?.message ?? 'Cue timing is invalid.')
+        return
+      }
+      const applied = await runCommands(
+        [
+          {
+            command_id: makeCaptionOperationId('update-caption-cue'),
+            type: 'upsert_caption_cues',
+            track_id: trackId,
+            cues: [frameCueToCommandCue(nextCue)],
+          },
+        ],
+        [captionCuePrecondition(cue, fps)],
+      )
+      if (applied) setEditingCueId(null)
+    },
+    [cueDrafts, durationInFrames, fps, runCommands, tracks],
+  )
+
+  const removeCue = useCallback(
+    async (trackId: string, cue: FreeCutFrameCaptionCue) => {
+      await runCommands(
+        [
+          {
+            command_id: makeCaptionOperationId('remove-caption-cue'),
+            type: 'remove_caption_cues',
+            track_id: trackId,
+            cue_ids: [cue.id],
+          },
+        ],
+        [captionCuePrecondition(cue, fps)],
+      )
+    },
+    [fps, runCommands],
+  )
+
+  const applyStyle = useCallback(async () => {
+    if (!activeTrack) return
+    const cue = styleTargetCue
+    await runCommands(
+      [
+        {
+          command_id: makeCaptionOperationId('set-caption-style'),
+          type: 'set_caption_style',
+          track_id: activeTrack.id,
+          cue_ids: cue ? [cue.id] : null,
+          style: styleDraft,
+        },
+      ],
+      [
+        { type: 'track_exists', track_id: activeTrack.id },
+        ...(cue ? [captionCuePrecondition(cue, fps)] : []),
+      ],
+    )
+  }, [activeTrack, fps, runCommands, styleDraft, styleTargetCue])
+
+  const updateTrackDraft = useCallback(
+    (patch: Partial<CaptionTrackDraft>) => {
+      if (!activeTrack) return
+      setTrackDrafts((previous) => ({
+        ...previous,
+        [activeTrack.id]: {
+          name: previous[activeTrack.id]?.name ?? activeTrack.name,
+          language: previous[activeTrack.id]?.language ?? activeTrack.language ?? '',
+          ...patch,
+        },
+      }))
+    },
+    [activeTrack],
+  )
+
+  const updateStyleDraft = useCallback((patch: Partial<CaptionStyle>) => {
+    setStyleDraft((previous) => ({ ...previous, ...patch }))
+  }, [])
+
+  return (
+    <CaptionEditorView
+      adapterError={adapterError}
+      activeCue={activeCue}
+      activeTrack={activeTrack}
+      activeTrackId={activeTrack?.id ?? activeTrackId}
+      announcement={announcement}
+      busy={busy}
+      className={className}
+      currentFrame={currentFrame}
+      cueDrafts={cueDrafts}
+      document={document}
+      editingCueId={editingCueId}
+      editingTrackDraft={editingTrackDraft}
+      error={error}
+      fps={fps}
+      loading={loading}
+      onAddCue={addCue}
+      onAddTrack={addTrack}
+      onApplyStyle={applyStyle}
+      onBeginEditCue={beginEditCue}
+      onCancelEditCue={cancelEditCue}
+      onCueDraftChange={(cueId, draft) =>
+        setCueDrafts((previous) => ({ ...previous, [cueId]: draft }))
+      }
+      onRemoveCue={removeCue}
+      onRemoveTrack={removeTrack}
+      onRetry={onRetry}
+      onSaveCue={saveCue}
+      onSaveTrack={saveTrack}
+      onSeek={onSeek}
+      onSelectTrack={(trackId) => {
+        setActiveTrackId(trackId)
+        setEditingCueId(null)
+      }}
+      onStyleChange={updateStyleDraft}
+      onStyleTargetChange={setStyleTargetCueId}
+      onToggleDisplay={toggleDisplay}
+      onTrackDraftChange={updateTrackDraft}
+      styleDraft={styleDraft}
+      styleTargetCueId={styleTargetCueId}
+      tracks={tracks}
+    />
+  )
+}
diff --git a/src/features/editor/codepress/caption-validation.test.ts b/src/features/editor/codepress/caption-validation.test.ts
new file mode 100644
index 000000000..9ec053a5f
--- /dev/null
+++ b/src/features/editor/codepress/caption-validation.test.ts
@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import {
+  MAX_CAPTION_CUES_PER_COMMAND,
+  validateCommandBatch,
+  validateTimelineState,
+} from './contract'
+import { validateFrameCaptionCue, validateFrameCaptionCues } from './caption-validation'
+import type { CaptionFrameCue } from './caption-validation'
+
+function cue(id: string, start: number, end: number, text = id): CaptionFrameCue {
+  return {
+    type: 'caption_cue',
+    id,
+    trackId: 'captions-en',
+    from: start,
+    durationInFrames: end - start,
+    text,
+  }
+}
+
+function timelineWith(cues: Array<{ id: string; start: number; end: number }>) {
+  return {
+    contract_version: 1 as const,
+    schema_version: 1 as const,
+    timeline_id: 'timeline-captions',
+    revision: 0,
+    duration_us: 10_000_000,
+    media: [],
+    tracks: [
+      {
+        track_id: 'captions-en',
+        kind: 'caption' as const,
+        name: 'English',
+        language: 'en',
+        locked: false,
+        muted: false,
+        items: cues.map(({ id, start, end }) => ({
+          item_type: 'caption_cue' as const,
+          cue_id: id,
+          track_id: 'captions-en',
+          start_us: start,
+          end_us: end,
+          text: id,
+        })),
+      },
+    ],
+  }
+}
+
+describe('frame-native caption bounds', () => {
+  it('rejects malformed, empty, and out-of-range cues', () => {
+    expect(validateFrameCaptionCue(cue('empty', 10, 10, ' '), 60).map((item) => item.code)).toEqual(
+      ['invalid_text', 'invalid_range'],
+    )
+    expect(validateFrameCaptionCue(cue('outside', 0, 61), 60).map((item) => item.code)).toContain(
+      'out_of_bounds',
+    )
+  })
+
+  it('rejects overlapping, duplicate, and over-budget cue sets', () => {
+    const issues = validateFrameCaptionCues(
+      [cue('one', 0, 20), cue('two', 19, 30), cue('two', 31, 40)],
+      60,
+    )
+    expect(issues.map((item) => item.code)).toEqual(
+      expect.arrayContaining(['overlap', 'invalid_id']),
+    )
+
+    const tooMany = Array.from({ length: MAX_CAPTION_CUES_PER_COMMAND + 1 }, (_, index) =>
+      cue(`cue-${index}`, index * 2, index * 2 + 1),
+    )
+    expect(
+      validateFrameCaptionCues(tooMany, tooMany.length * 2).map((item) => item.code),
+    ).toContain('too_many_cues')
+  })
+})
+
+describe('canonical caption validation', () => {
+  it('rejects overlapping timeline cues before an adapter can mount them', () => {
+    const result = validateTimelineState(
+      timelineWith([
+        { id: 'one', start: 0, end: 2_000_000 },
+        { id: 'two', start: 1_000_000, end: 3_000_000 },
+      ]),
+    )
+    expect(result).toMatchObject({ ok: false })
+    if (result.ok) return
+    expect(result.errors.some((error) => error.message.includes('must not overlap'))).toBe(true)
+  })
+
+  it('rejects malformed style and overlapping upsert commands', () => {
+    const result = validateCommandBatch({
+      contract_version: 1,
+      timeline_id: 'timeline-captions',
+      operation_id: 'caption-invalid',
+      idempotency_key: 'caption-invalid',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'upsert',
+          type: 'upsert_caption_cues',
+          track_id: 'captions-en',
+          cues: [
+            {
+              item_type: 'caption_cue',
+              cue_id: 'one',
+              track_id: 'captions-en',
+              start_us: 0,
+              end_us: 2_000_000,
+              text: 'one',
+            },
+            {
+              item_type: 'caption_cue',
+              cue_id: 'two',
+              track_id: 'captions-en',
+              start_us: 1_000_000,
+              end_us: 3_000_000,
+              text: 'two',
+            },
+          ],
+        },
+        {
+          command_id: 'style',
+          type: 'set_caption_style',
+          track_id: 'captions-en',
+          cue_ids: null,
+          style: { font_size: 0, background_opacity: 2 },
+        },
+      ],
+    })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.errors.map((error) => error.code)).toEqual(
+      expect.arrayContaining(['invalid_request']),
+    )
+    expect(result.errors.some((error) => error.message.includes('must not overlap'))).toBe(true)
+    expect(result.errors.some((error) => error.message.includes('background_opacity'))).toBe(true)
+  })
+})
diff --git a/src/features/editor/codepress/caption-validation.ts b/src/features/editor/codepress/caption-validation.ts
new file mode 100644
index 000000000..27d92ec4f
--- /dev/null
+++ b/src/features/editor/codepress/caption-validation.ts
@@ -0,0 +1,118 @@
+import {
+  MAX_CAPTION_CUES_PER_COMMAND,
+  MAX_ID_LENGTH,
+  MAX_TEXT_LENGTH,
+  type CaptionStyle,
+} from './contract'
+import type { FreeCutFrameCaptionCue } from './document'
+
+export type CaptionValidationCode =
+  | 'invalid_id'
+  | 'invalid_text'
+  | 'invalid_range'
+  | 'out_of_bounds'
+  | 'overlap'
+  | 'too_many_cues'
+
+export interface CaptionValidationIssue {
+  code: CaptionValidationCode
+  message: string
+  cue_id?: string
+}
+
+export type CaptionFrameCue = FreeCutFrameCaptionCue
+
+function issue(
+  code: CaptionValidationCode,
+  message: string,
+  cue_id?: string,
+): CaptionValidationIssue {
+  return cue_id === undefined ? { code, message } : { code, message, cue_id }
+}
+
+function isSafeFrame(value: number): boolean {
+  return Number.isSafeInteger(value) && value >= 0
+}
+
+/** Validate a frame-native cue before it is translated into microseconds. */
+export function validateFrameCaptionCue(
+  cue: CaptionFrameCue,
+  durationInFrames: number,
+): readonly CaptionValidationIssue[] {
+  const issues: CaptionValidationIssue[] = []
+  if (cue.id.length === 0 || cue.id.length > MAX_ID_LENGTH)
+    issues.push(issue('invalid_id', `Cue IDs must be 1–${MAX_ID_LENGTH} characters`, cue.id))
+  if (cue.text.trim().length === 0 || cue.text.length > MAX_TEXT_LENGTH)
+    issues.push(
+      issue(
+        'invalid_text',
+        `Cue text must be non-empty and at most ${MAX_TEXT_LENGTH} characters`,
+        cue.id,
+      ),
+    )
+  if (!isSafeFrame(cue.from) || !isSafeFrame(cue.durationInFrames) || cue.durationInFrames <= 0)
+    issues.push(issue('invalid_range', 'Cue end must be after cue start', cue.id))
+  if (
+    isSafeFrame(cue.from) &&
+    isSafeFrame(cue.durationInFrames) &&
+    cue.from + cue.durationInFrames > durationInFrames
+  ) {
+    issues.push(issue('out_of_bounds', 'Cue must stay within the timeline duration', cue.id))
+  }
+  return issues
+}
+
+/** Validate a complete track view, including deterministic non-overlap rules. */
+export function validateFrameCaptionCues(
+  cues: readonly CaptionFrameCue[],
+  durationInFrames: number,
+): readonly CaptionValidationIssue[] {
+  const issues: CaptionValidationIssue[] = []
+  if (cues.length > MAX_CAPTION_CUES_PER_COMMAND) {
+    issues.push(
+      issue(
+        'too_many_cues',
+        `A caption operation may contain at most ${MAX_CAPTION_CUES_PER_COMMAND} cues`,
+      ),
+    )
+  }
+  const seen = new Set<string>()
+  const sorted = [...cues]
+    .map((cue) => {
+      if (seen.has(cue.id))
+        issues.push(issue('invalid_id', 'Cue IDs must be unique within a track', cue.id))
+      seen.add(cue.id)
+      issues.push(...validateFrameCaptionCue(cue, durationInFrames))
+      return cue
+    })
+    .sort(
+      (left, right) =>
+        left.from - right.from ||
+        left.from + left.durationInFrames - (right.from + right.durationInFrames),
+    )
+
+  for (let index = 1; index < sorted.length; index += 1) {
+    const previous = sorted[index - 1]!
+    const current = sorted[index]!
+    if (
+      isSafeFrame(previous.from + previous.durationInFrames) &&
+      isSafeFrame(current.from) &&
+      current.from < previous.from + previous.durationInFrames
+    ) {
+      issues.push(issue('overlap', `Cue overlaps the preceding cue (${previous.id})`, current.id))
+    }
+  }
+  return issues
+}
+
+export function captionStyleOrDefault(style: CaptionStyle | null | undefined): CaptionStyle {
+  return {
+    font_family: 'Inter',
+    font_size: 42,
+    color: '#ffffff',
+    background_color: '#000000',
+    background_opacity: 0.6,
+    alignment: 'center',
+    ...(style ?? {}),
+  }
+}
diff --git a/src/features/editor/codepress/contract.ts b/src/features/editor/codepress/contract.ts
new file mode 100644
index 000000000..dc4aebbcb
--- /dev/null
+++ b/src/features/editor/codepress/contract.ts
@@ -0,0 +1,1369 @@
+/**
+ * The FreeCut-side view of the CodePress video command contract.
+ *
+ * CodePress owns the wire package.  This file intentionally mirrors its
+ * language-neutral field names instead of importing FreeCut's persisted
+ * project schema or the development-only headless API.  Keeping the boundary
+ * here makes the adapter usable by a browser editor, a worker, and tests
+ * without giving any of those callers a filesystem or HTTP seam.
+ */
+
+export const VIDEO_COMMAND_CONTRACT_VERSION = 1 as const
+export const VIDEO_TIMELINE_SCHEMA_VERSION = 1 as const
+
+export const MAX_COMMANDS_PER_OPERATION = 64
+export const MAX_PRECONDITIONS_PER_OPERATION = 128
+export const MAX_CAPTION_CUES_PER_COMMAND = 512
+export const MAX_TRACKS_PER_TIMELINE = 128
+export const MAX_ITEMS_PER_TRACK = 4096
+export const MAX_ID_LENGTH = 128
+export const MAX_TEXT_LENGTH = 32_000
+
+export type Brand<T, Name extends string> = T & { readonly __brand: Name }
+export type TimelineId = string
+export type TimelineItemId = string
+export type TrackId = string
+export type MediaId = string
+export type AssetId = MediaId
+export type DeviceId = string
+export type MediaRootId = string
+export type LocalFileId = string
+export type CloudObjectId = string
+export type ContentHash = string
+export type OperationId = string
+export type IdempotencyKey = string
+export type CommandId = string
+export type CaptionCueId = TimelineItemId
+export type ActorId = string
+export type Microseconds = number
+export type TimelineRevision = number
+
+export const MEDIA_KINDS = ['video', 'audio', 'image'] as const
+export type MediaKind = (typeof MEDIA_KINDS)[number]
+
+export interface LocalMediaReference {
+  device_id: DeviceId
+  root_id: MediaRootId
+  file_id: LocalFileId
+  root_generation: number
+}
+
+export interface CloudMediaReference {
+  object_id: CloudObjectId
+}
+
+export type MediaAvailability =
+  | { mode: 'local'; local: LocalMediaReference; cloud?: never }
+  | { mode: 'cloud'; local?: never; cloud: CloudMediaReference }
+  | { mode: 'hybrid'; local: LocalMediaReference; cloud: CloudMediaReference }
+
+export interface MediaReference {
+  media_id: MediaId
+  media_kind: MediaKind
+  content_hash: ContentHash
+  duration_us: Microseconds | null
+  availability: MediaAvailability
+}
+export type MediaRef = MediaReference
+
+export interface Transform {
+  position_x: number
+  position_y: number
+  scale_x: number
+  scale_y: number
+  rotation_degrees: number
+  anchor_x: number
+  anchor_y: number
+}
+
+export interface CaptionStyle {
+  font_family?: string
+  font_size?: number
+  color?: string
+  background_color?: string
+  background_opacity?: number
+  alignment?: 'left' | 'center' | 'right'
+}
+
+export interface TextStyle {
+  font_family?: string
+  font_size?: number
+  color?: string
+  alignment?: 'left' | 'center' | 'right'
+}
+
+export interface Transition {
+  transition_type: 'crossfade' | 'dip_to_black' | 'dip_to_white' | 'wipe'
+  duration_us: Microseconds
+}
+
+export interface Effect {
+  effect_type: 'blur' | 'brightness' | 'contrast' | 'grayscale' | 'saturation'
+  amount: number
+}
+
+export interface Keyframe {
+  property:
+    | 'position_x'
+    | 'position_y'
+    | 'scale_x'
+    | 'scale_y'
+    | 'rotation_degrees'
+    | 'opacity'
+    | 'volume'
+  time_us: Microseconds
+  value: number
+  interpolation: 'step' | 'linear' | 'bezier'
+}
+
+export interface ClipItem {
+  item_type: 'clip'
+  item_id: TimelineItemId
+  track_id: TrackId
+  media_id: MediaId
+  media_kind: MediaKind
+  timeline_start_us: Microseconds
+  timeline_end_us: Microseconds
+  source_start_us: Microseconds
+  source_end_us: Microseconds
+  transform?: Transform
+  opacity?: number
+  volume?: number
+  speed?: number
+  fade_in_us?: Microseconds
+  fade_out_us?: Microseconds
+  transition_in?: Transition | null
+  transition_out?: Transition | null
+  effects?: readonly Effect[]
+  keyframes?: readonly Keyframe[]
+}
+
+export interface TextItem {
+  item_type: 'text'
+  item_id: TimelineItemId
+  track_id: TrackId
+  timeline_start_us: Microseconds
+  timeline_end_us: Microseconds
+  text: string
+  style?: TextStyle
+  transform?: Transform
+  opacity?: number
+  keyframes?: readonly Keyframe[]
+}
+
+export interface CaptionCue {
+  item_type: 'caption_cue'
+  cue_id: CaptionCueId
+  track_id: TrackId
+  start_us: Microseconds
+  end_us: Microseconds
+  text: string
+  speaker?: string | null
+  style?: CaptionStyle
+}
+
+export type TimelineItem = ClipItem | TextItem | CaptionCue
+export type TimelineItemInput = ClipItem | TextItem
+export const TRACK_KINDS = ['video', 'audio', 'overlay', 'caption'] as const
+export type TrackKind = (typeof TRACK_KINDS)[number]
+
+export interface TimelineTrack {
+  track_id: TrackId
+  kind: TrackKind
+  name: string
+  language?: string
+  locked: boolean
+  muted: boolean
+  /** Optional FreeCut-side extension for caption-track defaults. */
+  default_style?: CaptionStyle | null
+  items: readonly TimelineItem[]
+}
+
+export interface TimelineState {
+  contract_version: typeof VIDEO_COMMAND_CONTRACT_VERSION
+  schema_version: typeof VIDEO_TIMELINE_SCHEMA_VERSION
+  timeline_id: TimelineId
+  revision: TimelineRevision
+  duration_us: Microseconds
+  media: readonly MediaReference[]
+  tracks: readonly TimelineTrack[]
+}
+
+export interface AddClipCommand {
+  command_id: CommandId
+  type: 'add_clip'
+  track_id: TrackId
+  item: ClipItem
+  index?: number
+}
+export interface AddTextCommand {
+  command_id: CommandId
+  type: 'add_text'
+  track_id: TrackId
+  item: TextItem
+  index?: number
+}
+export interface DuplicateItemCommand {
+  command_id: CommandId
+  type: 'duplicate_item'
+  item_id: TimelineItemId
+  new_item_id: TimelineItemId
+  to_track_id: TrackId
+  timeline_start_us?: Microseconds
+  index?: number
+}
+export interface RemoveItemCommand {
+  command_id: CommandId
+  type: 'remove_item'
+  item_id: TimelineItemId
+}
+export interface MoveItemCommand {
+  command_id: CommandId
+  type: 'move_item'
+  item_id: TimelineItemId
+  to_track_id: TrackId
+  timeline_start_us: Microseconds
+  index: number
+}
+export interface TrimItemCommand {
+  command_id: CommandId
+  type: 'trim_item'
+  item_id: TimelineItemId
+  edge: 'start' | 'end'
+  timeline_us: Microseconds
+  source_us: Microseconds
+}
+export interface SplitItemCommand {
+  command_id: CommandId
+  type: 'split_item'
+  item_id: TimelineItemId
+  at_timeline_us: Microseconds
+  at_source_us: Microseconds
+  left_item_id: TimelineItemId
+  right_item_id: TimelineItemId
+}
+export interface RippleDeleteCommand {
+  command_id: CommandId
+  type: 'ripple_delete'
+  start_us: Microseconds
+  end_us: Microseconds
+  track_ids: readonly TrackId[] | null
+}
+export interface AddTrackCommand {
+  command_id: CommandId
+  type: 'add_track'
+  track: Omit<TimelineTrack, 'items'> & { items?: readonly [] }
+  index: number
+}
+export interface RemoveTrackCommand {
+  command_id: CommandId
+  type: 'remove_track'
+  track_id: TrackId
+}
+export interface MoveTrackCommand {
+  command_id: CommandId
+  type: 'move_track'
+  track_id: TrackId
+  to_index: number
+}
+export interface UpdateTrackCommand {
+  command_id: CommandId
+  type: 'update_track'
+  track_id: TrackId
+  name?: string
+  language?: string | null
+  locked?: boolean
+  muted?: boolean
+}
+export interface AddCaptionTrackCommand {
+  command_id: CommandId
+  type: 'add_caption_track'
+  track_id: TrackId
+  name: string
+  language: string
+  index: number
+}
+export interface RemoveCaptionTrackCommand {
+  command_id: CommandId
+  type: 'remove_caption_track'
+  track_id: TrackId
+}
+export interface UpdateCaptionTrackCommand {
+  command_id: CommandId
+  type: 'update_caption_track'
+  track_id: TrackId
+  name?: string
+  language?: string
+  default_style?: CaptionStyle | null
+}
+export interface UpsertCaptionCuesCommand {
+  command_id: CommandId
+  type: 'upsert_caption_cues'
+  track_id: TrackId
+  cues: readonly CaptionCue[]
+}
+export interface RemoveCaptionCuesCommand {
+  command_id: CommandId
+  type: 'remove_caption_cues'
+  track_id: TrackId
+  cue_ids: readonly CaptionCueId[]
+}
+
+export interface ItemPropertiesPatch {
+  transform?: Transform | null
+  opacity?: number
+  volume?: number
+  speed?: number
+  fade_in_us?: Microseconds | null
+  fade_out_us?: Microseconds | null
+  text?: string
+  text_style?: TextStyle | null
+  effects?: readonly Effect[]
+  keyframes?: readonly Keyframe[]
+  transition_in?: Transition | null
+  transition_out?: Transition | null
+}
+export interface SetItemPropertiesCommand {
+  command_id: CommandId
+  type: 'set_item_properties'
+  item_id: TimelineItemId
+  properties: ItemPropertiesPatch
+}
+export interface SetCaptionStyleCommand {
+  command_id: CommandId
+  type: 'set_caption_style'
+  track_id: TrackId
+  cue_ids: readonly CaptionCueId[] | null
+  style: CaptionStyle
+}
+
+export const VIDEO_JOB_TYPES = [
+  'inspect',
+  'proxy',
+  'thumbnail',
+  'contact_sheet',
+  'waveform',
+  'transcribe',
+  'analysis',
+  'preview',
+  'export',
+  'cloud_upload',
+] as const
+export type VideoJobType = (typeof VIDEO_JOB_TYPES)[number]
+export interface RequestJobCommand {
+  command_id: CommandId
+  type: 'request_job'
+  job_type: VideoJobType
+  media_id?: MediaId
+  timeline_revision?: TimelineRevision
+  options?: Readonly<Record<string, string | number | boolean | null>>
+}
+
+export type EditCommand =
+  | AddClipCommand
+  | AddTextCommand
+  | DuplicateItemCommand
+  | RemoveItemCommand
+  | MoveItemCommand
+  | TrimItemCommand
+  | SplitItemCommand
+  | RippleDeleteCommand
+  | AddTrackCommand
+  | RemoveTrackCommand
+  | MoveTrackCommand
+  | UpdateTrackCommand
+  | AddCaptionTrackCommand
+  | RemoveCaptionTrackCommand
+  | UpdateCaptionTrackCommand
+  | UpsertCaptionCuesCommand
+  | RemoveCaptionCuesCommand
+  | SetItemPropertiesCommand
+  | SetCaptionStyleCommand
+  | RequestJobCommand
+export type VideoCommand = EditCommand
+
+export interface EditCommandBatch {
+  contract_version: typeof VIDEO_COMMAND_CONTRACT_VERSION
+  timeline_id: TimelineId
+  operation_id: OperationId
+  idempotency_key: IdempotencyKey
+  base_revision: TimelineRevision
+  preconditions: readonly Precondition[]
+  commands: readonly EditCommand[]
+}
+export type CommandBatch = EditCommandBatch
+export type CommandType = EditCommand['type']
+
+export const COMMAND_BATCH_LIMITS = {
+  max_commands: MAX_COMMANDS_PER_OPERATION,
+  max_preconditions: MAX_PRECONDITIONS_PER_OPERATION,
+  max_caption_cues_per_command: MAX_CAPTION_CUES_PER_COMMAND,
+} as const
+
+export function commandType(command: EditCommand): CommandType {
+  return command.type
+}
+
+export function itemIdFromCommand(command: EditCommand): TimelineItemId | null {
+  switch (command.type) {
+    case 'add_clip':
+    case 'add_text':
+      return command.item.item_id
+    case 'duplicate_item':
+      return command.new_item_id
+    case 'remove_item':
+    case 'move_item':
+    case 'trim_item':
+    case 'split_item':
+    case 'set_item_properties':
+      return command.item_id
+    case 'upsert_caption_cues':
+      return command.cues[0]?.cue_id ?? null
+    case 'remove_caption_cues':
+      return command.cue_ids[0] ?? null
+    case 'set_caption_style':
+      return command.cue_ids?.[0] ?? null
+    default:
+      return null
+  }
+}
+
+export function isTimelineItemCommand(
+  command: EditCommand,
+): command is Exclude<
+  EditCommand,
+  | AddTrackCommand
+  | RemoveTrackCommand
+  | MoveTrackCommand
+  | UpdateTrackCommand
+  | AddCaptionTrackCommand
+  | RemoveCaptionTrackCommand
+  | UpdateCaptionTrackCommand
+  | UpsertCaptionCuesCommand
+  | RemoveCaptionCuesCommand
+  | SetCaptionStyleCommand
+  | RequestJobCommand
+  | RippleDeleteCommand
+> {
+  return itemIdFromCommand(command) !== null
+}
+
+export type CommandItem = TimelineItem
+
+export interface TrackExistsPrecondition {
+  type: 'track_exists'
+  track_id: TrackId
+}
+export interface TrackAbsentPrecondition {
+  type: 'track_absent'
+  track_id: TrackId
+}
+export interface ItemExistsPrecondition {
+  type: 'item_exists'
+  item_id: TimelineItemId
+}
+export interface ItemAbsentPrecondition {
+  type: 'item_absent'
+  item_id: TimelineItemId
+}
+export interface ItemAtPrecondition {
+  type: 'item_at'
+  item_id: TimelineItemId
+  track_id: TrackId
+  timeline_start_us: Microseconds
+  timeline_end_us: Microseconds
+}
+export interface MediaContentHashPrecondition {
+  type: 'media_content_hash'
+  media_id: MediaId
+  content_hash: ContentHash
+}
+export interface CaptionCueAtPrecondition {
+  type: 'caption_cue_at'
+  track_id: TrackId
+  cue_id: TimelineItemId
+  start_us: Microseconds
+  end_us: Microseconds
+  text: string
+}
+export type Precondition =
+  | TrackExistsPrecondition
+  | TrackAbsentPrecondition
+  | ItemExistsPrecondition
+  | ItemAbsentPrecondition
+  | ItemAtPrecondition
+  | MediaContentHashPrecondition
+  | CaptionCueAtPrecondition
+
+export interface CommandEffect {
+  created_item_ids: readonly string[]
+  updated_item_ids: readonly string[]
+  deleted_item_ids: readonly string[]
+  moved_item_ids: readonly string[]
+  created_track_ids: readonly string[]
+  updated_track_ids: readonly string[]
+  deleted_track_ids: readonly string[]
+  timeline_delta_us: number
+}
+export interface AppliedCommandResult {
+  command_id: CommandId
+  command_type: CommandType
+  status: 'applied'
+  effect: CommandEffect
+}
+export interface OperationResultMetadata {
+  timeline_id: TimelineId
+  operation_id: OperationId
+  idempotency_key: IdempotencyKey
+  base_revision: TimelineRevision
+  previous_revision: TimelineRevision
+  resulting_revision: TimelineRevision
+}
+export interface AppliedOperationResult extends OperationResultMetadata {
+  status: 'applied'
+  timeline: TimelineState
+  commands: readonly AppliedCommandResult[]
+  rebase: { status: 'not_attempted'; automatic: false }
+}
+export interface ReplayedOperationResult extends OperationResultMetadata {
+  status: 'replayed'
+  replayed_operation_id: OperationId
+  timeline: TimelineState
+  commands: readonly AppliedCommandResult[]
+  rebase: { status: 'not_attempted'; automatic: false }
+}
+export interface RejectedOperationResult {
+  status: 'rejected'
+  timeline_id: TimelineId
+  operation_id: OperationId
+  idempotency_key: IdempotencyKey
+  base_revision: TimelineRevision
+  error: VideoCommandError
+}
+export type EditApplyResult =
+  | AppliedOperationResult
+  | ReplayedOperationResult
+  | RejectedOperationResult
+export type ApplyResult = EditApplyResult
+
+export type VideoCommandErrorCode =
+  | 'invalid_request'
+  | 'invalid_timeline'
+  | 'revision_conflict'
+  | 'precondition_failed'
+  | 'idempotency_conflict'
+  | 'operation_in_progress'
+  | 'unknown_timeline'
+  | 'unknown_media'
+  | 'unknown_track'
+  | 'unknown_item'
+  | 'media_unavailable'
+  | 'unsupported_command'
+  | 'limit_exceeded'
+  | 'permission_denied'
+
+export interface RevisionConflictDetails {
+  kind: 'revision_conflict'
+  base_revision: TimelineRevision
+  current_revision: TimelineRevision
+  rebase: {
+    status: 'required'
+    automatic: false
+    strategy: 'refresh_then_resubmit'
+    retry_with_revision: TimelineRevision
+  }
+  changed_operation_ids?: readonly OperationId[]
+}
+export interface PreconditionsFailedDetails {
+  kind: 'precondition_failed'
+  precondition_index: number
+  precondition: Precondition
+  actual: Readonly<Record<string, string | number | boolean | null>>
+}
+export interface IdempotencyConflictDetails {
+  kind: 'idempotency_conflict'
+  idempotency_key: IdempotencyKey
+  original_operation_id: OperationId
+}
+export interface InvalidRequestDetails {
+  kind: 'invalid_request'
+  path: string
+  reason: string
+}
+export interface InvalidTimelineDetails {
+  kind: 'invalid_timeline'
+  path: string
+  reason: string
+}
+export interface ResourceErrorDetails {
+  kind: 'resource'
+  resource: 'timeline' | 'media' | 'track' | 'item'
+  id: string
+}
+export interface LimitErrorDetails {
+  kind: 'limit'
+  path: string
+  limit: number
+  actual: number
+}
+export interface GenericErrorDetails {
+  kind: 'generic'
+  reason: string
+  path?: string
+}
+export type VideoCommandErrorDetails =
+  | RevisionConflictDetails
+  | PreconditionsFailedDetails
+  | IdempotencyConflictDetails
+  | InvalidRequestDetails
+  | InvalidTimelineDetails
+  | ResourceErrorDetails
+  | LimitErrorDetails
+  | GenericErrorDetails
+export interface VideoCommandError {
+  code: VideoCommandErrorCode
+  message: string
+  retryable: boolean
+  operation_id?: OperationId
+  command_id?: CommandId
+  details: VideoCommandErrorDetails
+}
+
+export interface ValidationSuccess<T> {
+  ok: true
+  value: T
+}
+export interface ValidationFailure {
+  ok: false
+  errors: readonly VideoCommandError[]
+}
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure
+
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u
+
+export function isStableIdentifier(value: unknown): value is string {
+  return typeof value === 'string' && IDENTIFIER_PATTERN.test(value)
+}
+
+export function isMicroseconds(value: unknown): value is Microseconds {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+}
+
+export function asMicroseconds(value: number): Microseconds {
+  if (!isMicroseconds(value)) throw new Error('Microseconds must be a safe, non-negative integer')
+  return value
+}
+
+export function isTimelineRevision(value: unknown): value is TimelineRevision {
+  return isMicroseconds(value)
+}
+
+export function asTimelineRevision(value: number): TimelineRevision {
+  if (!isTimelineRevision(value))
+    throw new Error('Timeline revisions must be safe, non-negative integers')
+  return value
+}
+
+export function asStableIdentifier<T extends string>(value: string): T {
+  if (!isStableIdentifier(value))
+    throw new Error(`Identifier must be 1-${MAX_ID_LENGTH} non-whitespace characters`)
+  return value as T
+}
+
+export function isVideoCommandError(value: unknown): value is VideoCommandError {
+  if (!value || typeof value !== 'object') return false
+  const candidate = value as Partial<VideoCommandError>
+  return (
+    typeof candidate.code === 'string' &&
+    typeof candidate.message === 'string' &&
+    typeof candidate.retryable === 'boolean' &&
+    typeof candidate.details === 'object' &&
+    candidate.details !== null
+  )
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function invalidRequest(path: string, reason: string): VideoCommandError {
+  return {
+    code: 'invalid_request',
+    message: `${path}: ${reason}`,
+    retryable: false,
+    details: { kind: 'invalid_request', path, reason },
+  }
+}
+
+function invalidTimeline(path: string, reason: string): VideoCommandError {
+  return {
+    code: 'invalid_timeline',
+    message: `${path}: ${reason}`,
+    retryable: false,
+    details: { kind: 'invalid_timeline', path, reason },
+  }
+}
+
+function checkIdentifier(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): value is string {
+  if (!isStableIdentifier(value)) {
+    errors.push(
+      invalidRequest(path, `must be a non-empty identifier of at most ${MAX_ID_LENGTH} characters`),
+    )
+    return false
+  }
+  return true
+}
+
+function checkMicroseconds(value: unknown, path: string, errors: VideoCommandError[]): boolean {
+  if (!isMicroseconds(value)) {
+    errors.push(invalidRequest(path, 'must be a safe, non-negative integer in microseconds'))
+    return false
+  }
+  return true
+}
+
+function checkString(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+  max = MAX_TEXT_LENGTH,
+): boolean {
+  if (typeof value !== 'string' || value.length > max) {
+    errors.push(invalidRequest(path, `must be a string of at most ${max} characters`))
+    return false
+  }
+  return true
+}
+
+function checkInterval(
+  start: unknown,
+  end: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): boolean {
+  const startOk = checkMicroseconds(start, `${path}.start_us`, errors)
+  const endOk = checkMicroseconds(end, `${path}.end_us`, errors)
+  if (startOk && endOk && (end as number) <= (start as number)) {
+    errors.push(invalidRequest(path, 'end must be greater than start'))
+    return false
+  }
+  return startOk && endOk
+}
+
+function validateCaptionStyle(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): value is CaptionStyle {
+  if (!isRecord(value)) {
+    errors.push(invalidRequest(path, 'must be an object'))
+    return false
+  }
+  if (value.font_family !== undefined)
+    checkString(value.font_family, `${path}.font_family`, errors, MAX_ID_LENGTH)
+  if (value.font_size !== undefined) {
+    if (
+      typeof value.font_size !== 'number' ||
+      !Number.isFinite(value.font_size) ||
+      value.font_size <= 0 ||
+      value.font_size > 512
+    ) {
+      errors.push(invalidRequest(`${path}.font_size`, 'must be a finite number between 0 and 512'))
+    }
+  }
+  if (value.color !== undefined) checkString(value.color, `${path}.color`, errors, 128)
+  if (value.background_color !== undefined)
+    checkString(value.background_color, `${path}.background_color`, errors, 128)
+  if (value.background_opacity !== undefined) {
+    if (
+      typeof value.background_opacity !== 'number' ||
+      !Number.isFinite(value.background_opacity) ||
+      value.background_opacity < 0 ||
+      value.background_opacity > 1
+    ) {
+      errors.push(
+        invalidRequest(`${path}.background_opacity`, 'must be a finite number between 0 and 1'),
+      )
+    }
+  }
+  if (
+    value.alignment !== undefined &&
+    value.alignment !== 'left' &&
+    value.alignment !== 'center' &&
+    value.alignment !== 'right'
+  ) {
+    errors.push(invalidRequest(`${path}.alignment`, 'must be left, center, or right'))
+  }
+  return true
+}
+
+function checkIndex(value: unknown, path: string, errors: VideoCommandError[]): void {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+    errors.push(invalidRequest(path, 'must be a non-negative integer'))
+  }
+}
+
+function checkArray(value: unknown, path: string, errors: VideoCommandError[]): value is unknown[] {
+  if (!Array.isArray(value)) {
+    errors.push(invalidRequest(path, 'must be an array'))
+    return false
+  }
+  return true
+}
+
+function checkTrackKind(value: unknown): value is TrackKind {
+  return typeof value === 'string' && (TRACK_KINDS as readonly string[]).includes(value)
+}
+
+function checkMediaKind(value: unknown): value is MediaKind {
+  return typeof value === 'string' && (MEDIA_KINDS as readonly string[]).includes(value)
+}
+
+function validateMedia(value: unknown, path: string, errors: VideoCommandError[]): void {
+  if (!isRecord(value)) {
+    errors.push(invalidRequest(path, 'must be an object'))
+    return
+  }
+  checkIdentifier(value.media_id, `${path}.media_id`, errors)
+  if (!checkMediaKind(value.media_kind))
+    errors.push(invalidRequest(`${path}.media_kind`, 'must be video, audio, or image'))
+  checkIdentifier(value.content_hash, `${path}.content_hash`, errors)
+  if (value.duration_us !== null)
+    checkMicroseconds(value.duration_us, `${path}.duration_us`, errors)
+  if (!isRecord(value.availability)) {
+    errors.push(invalidRequest(`${path}.availability`, 'must be an object'))
+    return
+  }
+  const mode = value.availability.mode
+  if (mode !== 'local' && mode !== 'cloud' && mode !== 'hybrid') {
+    errors.push(invalidRequest(`${path}.availability.mode`, 'must be local, cloud, or hybrid'))
+    return
+  }
+  const local = value.availability.local
+  const cloud = value.availability.cloud
+  if (mode !== 'cloud' && !isRecord(local))
+    errors.push(invalidRequest(`${path}.availability.local`, 'is required'))
+  if (mode !== 'local' && !isRecord(cloud))
+    errors.push(invalidRequest(`${path}.availability.cloud`, 'is required'))
+  if (isRecord(local)) {
+    checkIdentifier(local.device_id, `${path}.availability.local.device_id`, errors)
+    checkIdentifier(local.root_id, `${path}.availability.local.root_id`, errors)
+    checkIdentifier(local.file_id, `${path}.availability.local.file_id`, errors)
+    if (
+      typeof local.root_generation !== 'number' ||
+      !Number.isSafeInteger(local.root_generation) ||
+      local.root_generation < 1
+    ) {
+      errors.push(
+        invalidRequest(
+          `${path}.availability.local.root_generation`,
+          'must be a positive safe integer',
+        ),
+      )
+    }
+  }
+  if (isRecord(cloud))
+    checkIdentifier(cloud.object_id, `${path}.availability.cloud.object_id`, errors)
+}
+
+function validateCaptionCue(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): value is CaptionCue {
+  if (!isRecord(value)) {
+    errors.push(invalidRequest(path, 'must be an object'))
+    return false
+  }
+  if (value.item_type !== 'caption_cue')
+    errors.push(invalidRequest(`${path}.item_type`, 'must be caption_cue'))
+  checkIdentifier(value.cue_id, `${path}.cue_id`, errors)
+  checkIdentifier(value.track_id, `${path}.track_id`, errors)
+  checkInterval(value.start_us, value.end_us, path, errors)
+  checkString(value.text, `${path}.text`, errors)
+  if (value.speaker !== undefined && value.speaker !== null)
+    checkString(value.speaker, `${path}.speaker`, errors, MAX_ID_LENGTH)
+  if (value.style !== undefined) validateCaptionStyle(value.style, `${path}.style`, errors)
+  return true
+}
+
+function validateTimelineItem(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): value is TimelineItem {
+  if (!isRecord(value)) {
+    errors.push(invalidTimeline(path, 'must be an object'))
+    return false
+  }
+  if (value.item_type === 'caption_cue') return validateCaptionCue(value, path, errors)
+  if (value.item_type !== 'clip' && value.item_type !== 'text') {
+    errors.push(invalidTimeline(`${path}.item_type`, 'must be clip, text, or caption_cue'))
+    return false
+  }
+  checkIdentifier(value.item_id, `${path}.item_id`, errors)
+  checkIdentifier(value.track_id, `${path}.track_id`, errors)
+  checkInterval(value.timeline_start_us, value.timeline_end_us, `${path}.timeline`, errors)
+  if (value.item_type === 'clip') {
+    checkIdentifier(value.media_id, `${path}.media_id`, errors)
+    if (!checkMediaKind(value.media_kind))
+      errors.push(invalidTimeline(`${path}.media_kind`, 'must be video, audio, or image'))
+    checkInterval(value.source_start_us, value.source_end_us, `${path}.source`, errors)
+  } else {
+    checkString(value.text, `${path}.text`, errors)
+  }
+  return true
+}
+
+function validateTrack(
+  value: unknown,
+  path: string,
+  errors: VideoCommandError[],
+): value is TimelineTrack {
+  if (!isRecord(value)) {
+    errors.push(invalidTimeline(path, 'must be an object'))
+    return false
+  }
+  checkIdentifier(value.track_id, `${path}.track_id`, errors)
+  if (!checkTrackKind(value.kind))
+    errors.push(invalidTimeline(`${path}.kind`, 'must be video, audio, overlay, or caption'))
+  checkString(value.name, `${path}.name`, errors, MAX_ID_LENGTH)
+  if (value.language !== undefined) checkString(value.language, `${path}.language`, errors, 32)
+  if (typeof value.locked !== 'boolean')
+    errors.push(invalidTimeline(`${path}.locked`, 'must be a boolean'))
+  if (typeof value.muted !== 'boolean')
+    errors.push(invalidTimeline(`${path}.muted`, 'must be a boolean'))
+  if (value.default_style !== undefined && value.default_style !== null)
+    validateCaptionStyle(value.default_style, `${path}.default_style`, errors)
+  if (!Array.isArray(value.items)) {
+    errors.push(invalidTimeline(`${path}.items`, 'must be an array'))
+    return false
+  }
+  if (value.items.length > MAX_ITEMS_PER_TRACK)
+    errors.push(
+      invalidTimeline(`${path}.items`, `must contain at most ${MAX_ITEMS_PER_TRACK} items`),
+    )
+  return true
+}
+
+export function validateTimelineState(input: unknown): ValidationResult<TimelineState> {
+  const errors: VideoCommandError[] = []
+  if (!isRecord(input))
+    return { ok: false, errors: [invalidTimeline('timeline', 'must be an object')] }
+  if (input.contract_version !== VIDEO_COMMAND_CONTRACT_VERSION)
+    errors.push(invalidTimeline('contract_version', 'is not supported'))
+  if (input.schema_version !== VIDEO_TIMELINE_SCHEMA_VERSION)
+    errors.push(invalidTimeline('schema_version', 'is not supported'))
+  checkIdentifier(input.timeline_id, 'timeline_id', errors)
+  if (!isTimelineRevision(input.revision))
+    errors.push(invalidTimeline('revision', 'must be a safe, non-negative integer'))
+  checkMicroseconds(input.duration_us, 'duration_us', errors)
+
+  const mediaIds = new Set<string>()
+  if (!Array.isArray(input.media)) errors.push(invalidTimeline('media', 'must be an array'))
+  else {
+    for (const [index, media] of input.media.entries()) {
+      const path = `media[${index}]`
+      validateMedia(media, path, errors)
+      if (isRecord(media) && isStableIdentifier(media.media_id)) {
+        if (mediaIds.has(media.media_id))
+          errors.push(invalidTimeline(`${path}.media_id`, 'must be unique'))
+        mediaIds.add(media.media_id)
+      }
+    }
+  }
+  const mediaValues = Array.isArray(input.media) ? input.media : []
+
+  const trackIds = new Set<string>()
+  const itemIds = new Set<string>()
+  if (!Array.isArray(input.tracks)) errors.push(invalidTimeline('tracks', 'must be an array'))
+  else {
+    if (input.tracks.length > MAX_TRACKS_PER_TIMELINE)
+      errors.push(
+        invalidTimeline('tracks', `must contain at most ${MAX_TRACKS_PER_TIMELINE} tracks`),
+      )
+    for (const [trackIndex, track] of input.tracks.entries()) {
+      const path = `tracks[${trackIndex}]`
+      if (!validateTrack(track, path, errors) || !isRecord(track)) continue
+      const trackId = String(track.track_id)
+      if (trackIds.has(trackId)) errors.push(invalidTimeline(`${path}.track_id`, 'must be unique'))
+      trackIds.add(trackId)
+      if (!Array.isArray(track.items)) continue
+      const captionRanges: Array<{ index: number; start: number; end: number }> = []
+      for (const [itemIndex, item] of track.items.entries()) {
+        const itemPath = `${path}.items[${itemIndex}]`
+        if (!validateTimelineItem(item, itemPath, errors) || !isRecord(item)) continue
+        const id = item.item_type === 'caption_cue' ? item.cue_id : item.item_id
+        if (isStableIdentifier(id)) {
+          if (itemIds.has(id)) errors.push(invalidTimeline(itemPath, 'item ID must be unique'))
+          itemIds.add(id)
+        }
+        if (item.track_id !== track.track_id)
+          errors.push(invalidTimeline(`${itemPath}.track_id`, 'must match its containing track'))
+        if (item.item_type === 'clip') {
+          const media = mediaValues.find(
+            (candidate: unknown) => isRecord(candidate) && candidate.media_id === item.media_id,
+          )
+          if (!media)
+            errors.push(invalidTimeline(`${itemPath}.media_id`, 'must reference timeline.media'))
+          else if (media.media_kind !== item.media_kind)
+            errors.push(
+              invalidTimeline(`${itemPath}.media_kind`, 'must match the referenced media'),
+            )
+        }
+        if (track.kind === 'caption' && item.item_type !== 'caption_cue')
+          errors.push(invalidTimeline(itemPath, 'caption tracks may only contain caption cues'))
+        if (track.kind !== 'caption' && item.item_type === 'caption_cue')
+          errors.push(invalidTimeline(itemPath, 'caption cues must belong to a caption track'))
+        if (track.kind === 'audio' && item.item_type === 'clip' && item.media_kind !== 'audio')
+          errors.push(invalidTimeline(itemPath, 'audio tracks may only contain audio clips'))
+        const end = item.item_type === 'caption_cue' ? item.end_us : item.timeline_end_us
+        if (isMicroseconds(end) && isMicroseconds(input.duration_us) && end > input.duration_us)
+          errors.push(invalidTimeline(itemPath, 'item must end within timeline duration'))
+        if (
+          track.kind === 'caption' &&
+          item.item_type === 'caption_cue' &&
+          isMicroseconds(item.start_us) &&
+          isMicroseconds(item.end_us)
+        ) {
+          captionRanges.push({ index: itemIndex, start: item.start_us, end: item.end_us })
+        }
+      }
+      if (track.kind === 'caption') {
+        captionRanges.sort((left, right) => left.start - right.start || left.end - right.end)
+        for (let index = 1; index < captionRanges.length; index += 1) {
+          const previous = captionRanges[index - 1]!
+          const current = captionRanges[index]!
+          if (current.start < previous.end) {
+            errors.push(
+              invalidTimeline(
+                `${path}.items[${current.index}]`,
+                'caption cues must not overlap within a track',
+              ),
+            )
+          }
+        }
+      }
+    }
+  }
+  return errors.length > 0
+    ? { ok: false, errors }
+    : { ok: true, value: input as unknown as TimelineState }
+}
+
+function validatePrecondition(value: unknown, path: string, errors: VideoCommandError[]): void {
+  if (!isRecord(value)) {
+    errors.push(invalidRequest(path, 'must be an object'))
+    return
+  }
+  if (typeof value.type !== 'string') {
+    errors.push(invalidRequest(`${path}.type`, 'is required'))
+    return
+  }
+  switch (value.type) {
+    case 'track_exists':
+    case 'track_absent':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      break
+    case 'item_exists':
+    case 'item_absent':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      break
+    case 'item_at':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      checkInterval(value.timeline_start_us, value.timeline_end_us, `${path}.timeline`, errors)
+      break
+    case 'media_content_hash':
+      checkIdentifier(value.media_id, `${path}.media_id`, errors)
+      checkIdentifier(value.content_hash, `${path}.content_hash`, errors)
+      break
+    case 'caption_cue_at':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      checkIdentifier(value.cue_id, `${path}.cue_id`, errors)
+      checkInterval(value.start_us, value.end_us, path, errors)
+      checkString(value.text, `${path}.text`, errors)
+      break
+    default:
+      errors.push(invalidRequest(`${path}.type`, 'is not a supported precondition'))
+  }
+}
+
+function validateCommand(value: unknown, path: string, errors: VideoCommandError[]): void {
+  if (!isRecord(value)) {
+    errors.push(invalidRequest(path, 'must be an object'))
+    return
+  }
+  checkIdentifier(value.command_id, `${path}.command_id`, errors)
+  if (typeof value.type !== 'string') {
+    errors.push(invalidRequest(`${path}.type`, 'is required'))
+    return
+  }
+  switch (value.type) {
+    case 'add_clip':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.index !== undefined) checkIndex(value.index, `${path}.index`, errors)
+      if (!isRecord(value.item)) errors.push(invalidRequest(`${path}.item`, 'must be an object'))
+      else {
+        if (value.item.item_type !== 'clip')
+          errors.push(invalidRequest(`${path}.item.item_type`, 'must be clip'))
+        validateTimelineItem(value.item, `${path}.item`, errors)
+        if (value.item.track_id !== value.track_id)
+          errors.push(invalidRequest(`${path}.item.track_id`, 'must match track_id'))
+      }
+      break
+    case 'add_text':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.index !== undefined) checkIndex(value.index, `${path}.index`, errors)
+      if (!isRecord(value.item)) errors.push(invalidRequest(`${path}.item`, 'must be an object'))
+      else {
+        if (value.item.item_type !== 'text')
+          errors.push(invalidRequest(`${path}.item.item_type`, 'must be text'))
+        validateTimelineItem(value.item, `${path}.item`, errors)
+        if (value.item.track_id !== value.track_id)
+          errors.push(invalidRequest(`${path}.item.track_id`, 'must match track_id'))
+      }
+      break
+    case 'duplicate_item':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      checkIdentifier(value.new_item_id, `${path}.new_item_id`, errors)
+      checkIdentifier(value.to_track_id, `${path}.to_track_id`, errors)
+      if (value.item_id === value.new_item_id)
+        errors.push(invalidRequest(path, 'new item ID must differ from source item ID'))
+      if (value.timeline_start_us !== undefined)
+        checkMicroseconds(value.timeline_start_us, `${path}.timeline_start_us`, errors)
+      if (value.index !== undefined) checkIndex(value.index, `${path}.index`, errors)
+      break
+    case 'remove_item':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      break
+    case 'move_item':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      checkIdentifier(value.to_track_id, `${path}.to_track_id`, errors)
+      checkMicroseconds(value.timeline_start_us, `${path}.timeline_start_us`, errors)
+      checkIndex(value.index, `${path}.index`, errors)
+      break
+    case 'trim_item':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      if (value.edge !== 'start' && value.edge !== 'end')
+        errors.push(invalidRequest(`${path}.edge`, 'must be start or end'))
+      checkMicroseconds(value.timeline_us, `${path}.timeline_us`, errors)
+      checkMicroseconds(value.source_us, `${path}.source_us`, errors)
+      break
+    case 'split_item':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      checkMicroseconds(value.at_timeline_us, `${path}.at_timeline_us`, errors)
+      checkMicroseconds(value.at_source_us, `${path}.at_source_us`, errors)
+      checkIdentifier(value.left_item_id, `${path}.left_item_id`, errors)
+      checkIdentifier(value.right_item_id, `${path}.right_item_id`, errors)
+      if (new Set([value.item_id, value.left_item_id, value.right_item_id]).size !== 3)
+        errors.push(invalidRequest(path, 'split item IDs must all be distinct'))
+      break
+    case 'ripple_delete':
+      checkInterval(value.start_us, value.end_us, path, errors)
+      if (value.track_ids !== null && !checkArray(value.track_ids, `${path}.track_ids`, errors))
+        return
+      if (Array.isArray(value.track_ids)) {
+        const ids = new Set<string>()
+        for (const [index, id] of value.track_ids.entries()) {
+          if (checkIdentifier(id, `${path}.track_ids[${index}]`, errors)) {
+            if (ids.has(id))
+              errors.push(invalidRequest(`${path}.track_ids[${index}]`, 'must be unique'))
+            ids.add(id)
+          }
+        }
+      }
+      break
+    case 'add_track':
+      checkIndex(value.index, `${path}.index`, errors)
+      if (!isRecord(value.track)) errors.push(invalidRequest(`${path}.track`, 'must be an object'))
+      else {
+        checkIdentifier(value.track.track_id, `${path}.track.track_id`, errors)
+        if (!checkTrackKind(value.track.kind))
+          errors.push(invalidRequest(`${path}.track.kind`, 'must be a supported track kind'))
+        checkString(value.track.name, `${path}.track.name`, errors, MAX_ID_LENGTH)
+        if (
+          value.track.items !== undefined &&
+          (!Array.isArray(value.track.items) || value.track.items.length !== 0)
+        )
+          errors.push(
+            invalidRequest(`${path}.track.items`, 'must be omitted or empty when adding a track'),
+          )
+      }
+      break
+    case 'remove_track':
+    case 'move_track':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.type === 'move_track') checkIndex(value.to_index, `${path}.to_index`, errors)
+      break
+    case 'update_track':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.name !== undefined) checkString(value.name, `${path}.name`, errors, MAX_ID_LENGTH)
+      if (value.language !== undefined && value.language !== null)
+        checkString(value.language, `${path}.language`, errors, 32)
+      if (value.locked !== undefined && typeof value.locked !== 'boolean')
+        errors.push(invalidRequest(`${path}.locked`, 'must be a boolean'))
+      if (value.muted !== undefined && typeof value.muted !== 'boolean')
+        errors.push(invalidRequest(`${path}.muted`, 'must be a boolean'))
+      break
+    case 'add_caption_track':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      checkString(value.name, `${path}.name`, errors, MAX_ID_LENGTH)
+      checkString(value.language, `${path}.language`, errors, 32)
+      checkIndex(value.index, `${path}.index`, errors)
+      break
+    case 'remove_caption_track':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      break
+    case 'update_caption_track':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.name !== undefined) checkString(value.name, `${path}.name`, errors, MAX_ID_LENGTH)
+      if (value.language !== undefined) checkString(value.language, `${path}.language`, errors, 32)
+      if (value.default_style !== undefined && value.default_style !== null)
+        validateCaptionStyle(value.default_style, `${path}.default_style`, errors)
+      break
+    case 'upsert_caption_cues':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (checkArray(value.cues, `${path}.cues`, errors)) {
+        if (value.cues.length > MAX_CAPTION_CUES_PER_COMMAND)
+          errors.push(
+            invalidRequest(
+              `${path}.cues`,
+              `must contain at most ${MAX_CAPTION_CUES_PER_COMMAND} cues`,
+            ),
+          )
+        const ids = new Set<string>()
+        for (const [index, cue] of value.cues.entries()) {
+          validateCaptionCue(cue, `${path}.cues[${index}]`, errors)
+          if (isRecord(cue) && cue.track_id !== value.track_id)
+            errors.push(invalidRequest(`${path}.cues[${index}].track_id`, 'must match track_id'))
+          if (isRecord(cue) && isStableIdentifier(cue.cue_id)) {
+            if (ids.has(cue.cue_id))
+              errors.push(
+                invalidRequest(
+                  `${path}.cues[${index}].cue_id`,
+                  'must be unique within the command',
+                ),
+              )
+            ids.add(cue.cue_id)
+          }
+        }
+        const ranges = value.cues
+          .map((cue, index) =>
+            isRecord(cue) && isMicroseconds(cue.start_us) && isMicroseconds(cue.end_us)
+              ? { index, start: cue.start_us, end: cue.end_us }
+              : null,
+          )
+          .filter((range): range is { index: number; start: number; end: number } => range !== null)
+          .sort((left, right) => left.start - right.start || left.end - right.end)
+        for (let index = 1; index < ranges.length; index += 1) {
+          const previous = ranges[index - 1]!
+          const current = ranges[index]!
+          if (current.start < previous.end)
+            errors.push(
+              invalidRequest(
+                `${path}.cues[${current.index}]`,
+                'caption cues must not overlap within a track',
+              ),
+            )
+        }
+      }
+      break
+    case 'remove_caption_cues':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (checkArray(value.cue_ids, `${path}.cue_ids`, errors)) {
+        const ids = new Set<string>()
+        for (const [index, id] of value.cue_ids.entries()) {
+          if (checkIdentifier(id, `${path}.cue_ids[${index}]`, errors)) {
+            if (ids.has(id))
+              errors.push(invalidRequest(`${path}.cue_ids[${index}]`, 'must be unique'))
+            ids.add(id)
+          }
+        }
+      }
+      break
+    case 'set_item_properties':
+      checkIdentifier(value.item_id, `${path}.item_id`, errors)
+      if (!isRecord(value.properties))
+        errors.push(invalidRequest(`${path}.properties`, 'must be an object'))
+      else if (value.properties.text !== undefined)
+        checkString(value.properties.text, `${path}.properties.text`, errors)
+      break
+    case 'set_caption_style':
+      checkIdentifier(value.track_id, `${path}.track_id`, errors)
+      if (value.cue_ids !== null && checkArray(value.cue_ids, `${path}.cue_ids`, errors)) {
+        for (const [index, id] of value.cue_ids.entries())
+          checkIdentifier(id, `${path}.cue_ids[${index}]`, errors)
+      }
+      validateCaptionStyle(value.style, `${path}.style`, errors)
+      break
+    case 'request_job':
+      if (
+        !(
+          typeof value.job_type === 'string' &&
+          (VIDEO_JOB_TYPES as readonly string[]).includes(value.job_type)
+        )
+      )
+        errors.push(invalidRequest(`${path}.job_type`, 'is not a supported job type'))
+      if (value.media_id !== undefined) checkIdentifier(value.media_id, `${path}.media_id`, errors)
+      if (value.timeline_revision !== undefined && !isTimelineRevision(value.timeline_revision))
+        errors.push(
+          invalidRequest(`${path}.timeline_revision`, 'must be a safe, non-negative integer'),
+        )
+      if (value.options !== undefined && !isRecord(value.options))
+        errors.push(invalidRequest(`${path}.options`, 'must be an object'))
+      break
+    default:
+      errors.push(invalidRequest(`${path}.type`, 'is not a supported command'))
+  }
+}
+
+export function validateCommandBatch(input: unknown): ValidationResult<EditCommandBatch> {
+  const errors: VideoCommandError[] = []
+  if (!isRecord(input))
+    return { ok: false, errors: [invalidRequest('request', 'must be an object')] }
+  if (input.contract_version !== VIDEO_COMMAND_CONTRACT_VERSION)
+    errors.push(invalidRequest('contract_version', 'is not supported'))
+  checkIdentifier(input.timeline_id, 'timeline_id', errors)
+  checkIdentifier(input.operation_id, 'operation_id', errors)
+  checkIdentifier(input.idempotency_key, 'idempotency_key', errors)
+  if (!isTimelineRevision(input.base_revision))
+    errors.push(invalidRequest('base_revision', 'must be a safe, non-negative integer'))
+  if (checkArray(input.preconditions, 'preconditions', errors)) {
+    if (input.preconditions.length > MAX_PRECONDITIONS_PER_OPERATION)
+      errors.push(
+        invalidRequest(
+          'preconditions',
+          `must contain at most ${MAX_PRECONDITIONS_PER_OPERATION} entries`,
+        ),
+      )
+    for (const [index, precondition] of input.preconditions.entries())
+      validatePrecondition(precondition, `preconditions[${index}]`, errors)
+  }
+  if (checkArray(input.commands, 'commands', errors)) {
+    if (input.commands.length === 0)
+      errors.push(invalidRequest('commands', 'must contain at least one command'))
+    if (input.commands.length > MAX_COMMANDS_PER_OPERATION)
+      errors.push(
+        invalidRequest('commands', `must contain at most ${MAX_COMMANDS_PER_OPERATION} commands`),
+      )
+    const commandIds = new Set<string>()
+    for (const [index, command] of input.commands.entries()) {
+      validateCommand(command, `commands[${index}]`, errors)
+      if (isRecord(command) && isStableIdentifier(command.command_id)) {
+        if (commandIds.has(command.command_id))
+          errors.push(
+            invalidRequest(`commands[${index}].command_id`, 'must be unique within the batch'),
+          )
+        commandIds.add(command.command_id)
+      }
+    }
+  }
+  return errors.length > 0
+    ? { ok: false, errors }
+    : { ok: true, value: input as unknown as EditCommandBatch }
+}
diff --git a/src/features/editor/codepress/controlled-editor.ts b/src/features/editor/codepress/controlled-editor.ts
new file mode 100644
index 000000000..297362a6a
--- /dev/null
+++ b/src/features/editor/codepress/controlled-editor.ts
@@ -0,0 +1,10 @@
+/** Stable alias for hosts that want the controlled editor boundary by name. */
+export {
+  CodePressCommandAdapter as ControlledEditor,
+  createCodePressCommandAdapter as createControlledEditor,
+} from './adapter'
+export type {
+  CodePressCommandAdapterOptions as ControlledEditorOptions,
+  AdapterSnapshot as ControlledEditorSnapshot,
+} from './adapter'
+export type { ControlledEditorDocument, ControlledEditorPort } from './interfaces'
diff --git a/src/features/editor/codepress/document.ts b/src/features/editor/codepress/document.ts
new file mode 100644
index 000000000..bbb2a77a2
--- /dev/null
+++ b/src/features/editor/codepress/document.ts
@@ -0,0 +1,354 @@
+import type {
+  CaptionStyle,
+  ClipItem,
+  MediaReference,
+  TextItem,
+  TimelineItem,
+  TimelineState,
+  TimelineTrack,
+} from './contract'
+import type { ControlledEditorDocument } from './interfaces'
+import {
+  assertFrameAligned,
+  framesToMicroseconds,
+  normalizeFrameRate,
+  type FrameRateLike,
+} from './timing'
+
+/** Minimal frame-native document shape expected from a FreeCut host. */
+export interface FreeCutFrameClip {
+  type: 'video' | 'audio' | 'image'
+  id: string
+  trackId: string
+  mediaId: string
+  from: number
+  durationInFrames: number
+  sourceStart?: number
+  sourceEnd?: number
+  volume?: number
+  speed?: number
+  opacity?: number
+  transform?: Record<string, number>
+}
+
+export interface FreeCutFrameText {
+  type: 'text'
+  id: string
+  trackId: string
+  from: number
+  durationInFrames: number
+  text: string
+  style?: Record<string, string | number>
+  opacity?: number
+  transform?: Record<string, number>
+}
+
+export interface FreeCutFrameCaptionCue {
+  type: 'caption_cue'
+  id: string
+  trackId: string
+  from: number
+  durationInFrames: number
+  text: string
+  speaker?: string | null
+  style?: CaptionStyle
+}
+
+export type FreeCutFrameItem = FreeCutFrameClip | FreeCutFrameText | FreeCutFrameCaptionCue
+
+export interface FreeCutFrameTrack {
+  id: string
+  kind: 'video' | 'audio' | 'overlay' | 'caption'
+  name: string
+  language?: string
+  locked: boolean
+  muted: boolean
+  defaultStyle?: CaptionStyle | null
+  items: readonly FreeCutFrameItem[]
+}
+
+export interface FreeCutFrameDocument {
+  timelineId: string
+  revision: number
+  fps: FrameRateLike
+  durationInFrames: number
+  media: readonly MediaReference[]
+  tracks: readonly FreeCutFrameTrack[]
+  width: number
+  height: number
+  backgroundColor?: string
+}
+
+export class FreeCutDocumentConversionError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'FreeCutDocumentConversionError'
+  }
+}
+
+function frameRange(
+  item: FreeCutFrameItem,
+  fps: FrameRateLike,
+): { start_us: number; end_us: number } {
+  if (
+    !Number.isSafeInteger(item.from) ||
+    item.from < 0 ||
+    !Number.isSafeInteger(item.durationInFrames) ||
+    item.durationInFrames <= 0
+  ) {
+    throw new FreeCutDocumentConversionError(
+      `Item "${item.id}" must have non-negative integer frame bounds`,
+    )
+  }
+  const start_us = framesToMicroseconds(item.from, fps)
+  const end_us = framesToMicroseconds(item.from + item.durationInFrames, fps)
+  if (end_us <= start_us)
+    throw new FreeCutDocumentConversionError(`Item "${item.id}" has an empty frame range`)
+  return { start_us, end_us }
+}
+
+function toContractItem(item: FreeCutFrameItem, fps: FrameRateLike): TimelineItem {
+  const range = frameRange(item, fps)
+  if (item.type === 'caption_cue') {
+    return {
+      item_type: 'caption_cue',
+      cue_id: item.id,
+      track_id: item.trackId,
+      start_us: range.start_us,
+      end_us: range.end_us,
+      text: item.text,
+      ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
+      ...(item.style !== undefined ? { style: { ...item.style } } : {}),
+    }
+  }
+  if (item.type === 'text') {
+    return {
+      item_type: 'text',
+      item_id: item.id,
+      track_id: item.trackId,
+      timeline_start_us: range.start_us,
+      timeline_end_us: range.end_us,
+      text: item.text,
+      ...(item.style
+        ? {
+            style: {
+              ...(typeof item.style.font_family === 'string'
+                ? { font_family: item.style.font_family }
+                : {}),
+              ...(typeof item.style.font_size === 'number'
+                ? { font_size: item.style.font_size }
+                : {}),
+              ...(typeof item.style.color === 'string' ? { color: item.style.color } : {}),
+              ...(item.style.alignment === 'left' ||
+              item.style.alignment === 'center' ||
+              item.style.alignment === 'right'
+                ? { alignment: item.style.alignment }
+                : {}),
+            },
+          }
+        : {}),
+      ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+      ...(item.transform ? { transform: toTransform(item.transform) } : {}),
+    }
+  }
+  const mediaKind = item.type
+  const sourceStart = item.sourceStart ?? item.from
+  const sourceEnd = item.sourceEnd ?? sourceStart + item.durationInFrames
+  if (
+    !Number.isSafeInteger(sourceStart) ||
+    !Number.isSafeInteger(sourceEnd) ||
+    sourceEnd <= sourceStart
+  ) {
+    throw new FreeCutDocumentConversionError(`Clip "${item.id}" has invalid source bounds`)
+  }
+  return {
+    item_type: 'clip',
+    item_id: item.id,
+    track_id: item.trackId,
+    media_id: item.mediaId,
+    media_kind: mediaKind,
+    timeline_start_us: range.start_us,
+    timeline_end_us: range.end_us,
+    source_start_us: framesToMicroseconds(sourceStart, fps),
+    source_end_us: framesToMicroseconds(sourceEnd, fps),
+    ...(item.volume !== undefined ? { volume: item.volume } : {}),
+    ...(item.speed !== undefined ? { speed: item.speed } : {}),
+    ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+    ...(item.transform ? { transform: toTransform(item.transform) } : {}),
+  }
+}
+
+function toTransform(value: Record<string, number>): ClipItem['transform'] {
+  return {
+    position_x: value.position_x ?? value.x ?? 0,
+    position_y: value.position_y ?? value.y ?? 0,
+    scale_x: value.scale_x ?? value.scaleX ?? 1,
+    scale_y: value.scale_y ?? value.scaleY ?? 1,
+    rotation_degrees: value.rotation_degrees ?? value.rotation ?? 0,
+    anchor_x: value.anchor_x ?? value.anchorX ?? 0,
+    anchor_y: value.anchor_y ?? value.anchorY ?? 0,
+  }
+}
+
+function fromTransform(
+  value: ClipItem['transform'] | TextItem['transform'] | undefined,
+): Record<string, number> | undefined {
+  if (!value) return undefined
+  return {
+    position_x: value.position_x,
+    position_y: value.position_y,
+    scale_x: value.scale_x,
+    scale_y: value.scale_y,
+    rotation_degrees: value.rotation_degrees,
+    anchor_x: value.anchor_x,
+    anchor_y: value.anchor_y,
+  }
+}
+
+function toTrack(track: FreeCutFrameTrack, fps: FrameRateLike): TimelineTrack {
+  return {
+    track_id: track.id,
+    kind: track.kind,
+    name: track.name,
+    ...(track.language !== undefined ? { language: track.language } : {}),
+    locked: track.locked,
+    muted: track.muted,
+    ...(track.defaultStyle !== undefined ? { default_style: track.defaultStyle } : {}),
+    items: track.items.map((item) => toContractItem(item, fps)),
+  }
+}
+
+export function freeCutDocumentToControlledDocument(
+  input: FreeCutFrameDocument,
+): ControlledEditorDocument {
+  try {
+    normalizeFrameRate(input.fps)
+  } catch (error) {
+    throw new FreeCutDocumentConversionError(
+      error instanceof Error ? error.message : 'fps must be a finite positive rate',
+    )
+  }
+  if (!Number.isSafeInteger(input.durationInFrames) || input.durationInFrames < 0)
+    throw new FreeCutDocumentConversionError('durationInFrames must be a safe non-negative integer')
+  const timeline: TimelineState = {
+    contract_version: 1,
+    schema_version: 1,
+    timeline_id: input.timelineId,
+    revision: input.revision,
+    duration_us: framesToMicroseconds(input.durationInFrames, input.fps),
+    media: input.media,
+    tracks: input.tracks.map((track) => toTrack(track, input.fps)),
+  }
+  return {
+    timeline,
+    fps: input.fps,
+    width: input.width,
+    height: input.height,
+    ...(input.backgroundColor !== undefined ? { background_color: input.backgroundColor } : {}),
+  }
+}
+
+interface FrameBounds {
+  start: number
+  end: number
+}
+
+function frameBounds(
+  start_us: number,
+  end_us: number,
+  fps: FrameRateLike,
+  label: string,
+): FrameBounds {
+  const start = assertFrameAligned(start_us, fps)
+  const end = assertFrameAligned(end_us, fps)
+  if (end <= start) throw new FreeCutDocumentConversionError(`${label} has an empty frame range`)
+  return { start, end }
+}
+
+function fromContractItem(item: TimelineItem, fps: FrameRateLike): FreeCutFrameItem {
+  if (item.item_type === 'caption_cue') {
+    const range = frameBounds(item.start_us, item.end_us, fps, `Caption cue "${item.cue_id}"`)
+    return {
+      type: 'caption_cue',
+      id: item.cue_id,
+      trackId: item.track_id,
+      from: range.start,
+      durationInFrames: range.end - range.start,
+      text: item.text,
+      ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
+      ...(item.style !== undefined ? { style: { ...item.style } } : {}),
+    }
+  }
+  if (item.item_type === 'text') {
+    const range = frameBounds(
+      item.timeline_start_us,
+      item.timeline_end_us,
+      fps,
+      `Text item "${item.item_id}"`,
+    )
+    return {
+      type: 'text',
+      id: item.item_id,
+      trackId: item.track_id,
+      from: range.start,
+      durationInFrames: range.end - range.start,
+      text: item.text,
+      ...(item.style ? { style: { ...item.style } } : {}),
+      ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+      ...(item.transform ? { transform: fromTransform(item.transform) } : {}),
+    }
+  }
+  const timelineRange = frameBounds(
+    item.timeline_start_us,
+    item.timeline_end_us,
+    fps,
+    `Clip "${item.item_id}"`,
+  )
+  const sourceRange = frameBounds(
+    item.source_start_us,
+    item.source_end_us,
+    fps,
+    `Clip "${item.item_id}" source`,
+  )
+  return {
+    type: item.media_kind,
+    id: item.item_id,
+    trackId: item.track_id,
+    mediaId: item.media_id,
+    from: timelineRange.start,
+    durationInFrames: timelineRange.end - timelineRange.start,
+    sourceStart: sourceRange.start,
+    sourceEnd: sourceRange.end,
+    ...(item.volume !== undefined ? { volume: item.volume } : {}),
+    ...(item.speed !== undefined ? { speed: item.speed } : {}),
+    ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+    ...(item.transform ? { transform: fromTransform(item.transform) } : {}),
+  }
+}
+
+export function controlledDocumentToFreeCutDocument(
+  document: ControlledEditorDocument,
+): FreeCutFrameDocument {
+  return {
+    timelineId: document.timeline.timeline_id,
+    revision: document.timeline.revision,
+    fps: document.fps,
+    durationInFrames: assertFrameAligned(document.timeline.duration_us, document.fps),
+    media: document.timeline.media,
+    tracks: document.timeline.tracks.map((track) => ({
+      id: track.track_id,
+      kind: track.kind,
+      name: track.name,
+      ...(track.language !== undefined ? { language: track.language } : {}),
+      locked: track.locked,
+      muted: track.muted,
+      ...(track.default_style !== undefined ? { defaultStyle: track.default_style } : {}),
+      items: track.items.map((item) => fromContractItem(item, document.fps)),
+    })),
+    width: document.width,
+    height: document.height,
+    ...(document.background_color !== undefined
+      ? { backgroundColor: document.background_color }
+      : {}),
+  }
+}
diff --git a/src/features/editor/codepress/edit-engine.ts b/src/features/editor/codepress/edit-engine.ts
new file mode 100644
index 000000000..dc49a5dcd
--- /dev/null
+++ b/src/features/editor/codepress/edit-engine.ts
@@ -0,0 +1,954 @@
+import {
+  assertFrameAligned,
+  framesToMicroseconds,
+  normalizeFrameRate,
+  type FrameRateLike,
+} from './timing'
+import type {
+  AddCaptionTrackCommand,
+  AddClipCommand,
+  AddTextCommand,
+  AppliedCommandResult,
+  CaptionCue,
+  ClipItem,
+  CommandEffect,
+  EditCommand,
+  Effect,
+  ItemPropertiesPatch,
+  Keyframe,
+  MoveItemCommand,
+  SetItemPropertiesCommand,
+  TimelineItem,
+  TimelineState,
+  TimelineTrack,
+  TrackId,
+} from './contract'
+import { MAX_ID_LENGTH, validateTimelineState } from './contract'
+import type { ControlledEditEngine, EditEngineContext, EditEngineResult } from './interfaces'
+
+export class EditEngineError extends Error {
+  readonly code:
+    | 'unknown_track'
+    | 'unknown_item'
+    | 'unknown_media'
+    | 'invalid_request'
+    | 'unsupported_command'
+  readonly command_id?: string
+
+  constructor(code: EditEngineError['code'], message: string, command_id?: string) {
+    super(message)
+    this.name = 'EditEngineError'
+    this.code = code
+    this.command_id = command_id
+  }
+}
+
+interface LocatedItem {
+  item: TimelineItem
+  trackIndex: number
+  itemIndex: number
+}
+
+interface MutableTimeline extends TimelineState {
+  tracks: TimelineTrack[]
+}
+
+function emptyEffect(timeline_delta_us = 0): CommandEffect {
+  return {
+    created_item_ids: [],
+    updated_item_ids: [],
+    deleted_item_ids: [],
+    moved_item_ids: [],
+    created_track_ids: [],
+    updated_track_ids: [],
+    deleted_track_ids: [],
+    timeline_delta_us,
+  }
+}
+
+function cloneItem(item: TimelineItem): TimelineItem {
+  if (item.item_type === 'caption_cue') {
+    return { ...item, style: item.style ? { ...item.style } : undefined }
+  }
+  if (item.item_type === 'text') {
+    return {
+      ...item,
+      transform: item.transform ? { ...item.transform } : undefined,
+      keyframes: item.keyframes?.map((keyframe) => ({ ...keyframe })),
+      style: item.style ? { ...item.style } : undefined,
+    }
+  }
+  return {
+    ...item,
+    transform: item.transform ? { ...item.transform } : undefined,
+    effects: item.effects?.map((effect) => ({ ...effect })),
+    keyframes: item.keyframes?.map((keyframe) => ({ ...keyframe })),
+    transition_in: item.transition_in ? { ...item.transition_in } : item.transition_in,
+    transition_out: item.transition_out ? { ...item.transition_out } : item.transition_out,
+  }
+}
+
+function cloneTimeline(timeline: TimelineState): MutableTimeline {
+  return {
+    ...timeline,
+    media: timeline.media.map((media) => ({ ...media })),
+    tracks: timeline.tracks.map((track) => ({
+      ...track,
+      default_style: track.default_style ? { ...track.default_style } : track.default_style,
+      items: track.items.map(cloneItem),
+    })),
+  }
+}
+
+function allItems(timeline: MutableTimeline): TimelineItem[] {
+  return timeline.tracks.flatMap((track) => track.items)
+}
+
+function findTrack(timeline: MutableTimeline, trackId: TrackId, commandId?: string): TimelineTrack {
+  const track = timeline.tracks.find((candidate) => candidate.track_id === trackId)
+  if (!track)
+    throw new EditEngineError('unknown_track', `Track "${trackId}" does not exist`, commandId)
+  return track
+}
+
+function findItem(timeline: MutableTimeline, itemId: string, commandId?: string): LocatedItem {
+  for (const [trackIndex, track] of timeline.tracks.entries()) {
+    const itemIndex = track.items.findIndex((item) =>
+      item.item_type === 'caption_cue' ? item.cue_id === itemId : item.item_id === itemId,
+    )
+    if (itemIndex >= 0) return { item: track.items[itemIndex]!, trackIndex, itemIndex }
+  }
+  throw new EditEngineError('unknown_item', `Item "${itemId}" does not exist`, commandId)
+}
+
+function itemId(item: TimelineItem): string {
+  return item.item_type === 'caption_cue' ? item.cue_id : item.item_id
+}
+
+function itemStart(item: TimelineItem): number {
+  return item.item_type === 'caption_cue' ? item.start_us : item.timeline_start_us
+}
+
+function itemEnd(item: TimelineItem): number {
+  return item.item_type === 'caption_cue' ? item.end_us : item.timeline_end_us
+}
+
+function replaceTrackItems(
+  timeline: MutableTimeline,
+  trackIndex: number,
+  items: TimelineItem[],
+): void {
+  timeline.tracks[trackIndex] = { ...timeline.tracks[trackIndex]!, items }
+}
+
+function insertAt<T>(values: readonly T[], value: T, index: number | undefined): T[] {
+  const next = [...values]
+  const target = Math.min(Math.max(index ?? next.length, 0), next.length)
+  next.splice(target, 0, value)
+  return next
+}
+
+function setItemAt(timeline: MutableTimeline, located: LocatedItem, item: TimelineItem): void {
+  const track = timeline.tracks[located.trackIndex]!
+  const items = [...track.items]
+  items[located.itemIndex] = item
+  replaceTrackItems(timeline, located.trackIndex, items)
+}
+
+function removeItemAt(timeline: MutableTimeline, located: LocatedItem): void {
+  const track = timeline.tracks[located.trackIndex]!
+  replaceTrackItems(
+    timeline,
+    located.trackIndex,
+    track.items.filter((_, index) => index !== located.itemIndex),
+  )
+}
+
+function setItemPosition(item: TimelineItem, start_us: number, end_us: number): TimelineItem {
+  if (item.item_type === 'caption_cue') return { ...item, start_us, end_us }
+  return { ...item, timeline_start_us: start_us, timeline_end_us: end_us }
+}
+
+function setItemTrack(item: TimelineItem, track_id: TrackId): TimelineItem {
+  return item.item_type === 'caption_cue' ? { ...item, track_id } : { ...item, track_id }
+}
+
+function roundedRatio(numerator: bigint, denominator: bigint): bigint {
+  const quotient = numerator / denominator
+  const remainder = numerator % denominator
+  return remainder * 2n >= denominator ? quotient + 1n : quotient
+}
+
+function sourceAtTimelineFrame(item: ClipItem, timelineFrame: number, fps: FrameRateLike): number {
+  const timelineStartFrame = assertFrameAligned(item.timeline_start_us, fps)
+  const timelineEndFrame = assertFrameAligned(item.timeline_end_us, fps)
+  const sourceStartFrame = assertFrameAligned(item.source_start_us, fps)
+  const sourceEndFrame = assertFrameAligned(item.source_end_us, fps)
+  const timelineDuration = timelineEndFrame - timelineStartFrame
+  const sourceDuration = sourceEndFrame - sourceStartFrame
+  if (timelineFrame <= timelineStartFrame) return item.source_start_us
+  if (timelineFrame >= timelineEndFrame) return item.source_end_us
+  const sourceOffset = roundedRatio(
+    BigInt(timelineFrame - timelineStartFrame) * BigInt(sourceDuration),
+    BigInt(timelineDuration),
+  )
+  return framesToMicroseconds(sourceStartFrame + Number(sourceOffset), fps)
+}
+
+function frameRangeFor(item: TimelineItem, fps: FrameRateLike): { start: number; end: number } {
+  return {
+    start: assertFrameAligned(itemStart(item), fps),
+    end: assertFrameAligned(itemEnd(item), fps),
+  }
+}
+
+function setItemFramePosition(
+  item: TimelineItem,
+  startFrame: number,
+  endFrame: number,
+  fps: FrameRateLike,
+): TimelineItem {
+  return setItemPosition(
+    item,
+    framesToMicroseconds(startFrame, fps),
+    framesToMicroseconds(endFrame, fps),
+  )
+}
+
+function shiftItemByFrames(
+  item: TimelineItem,
+  deltaFrames: number,
+  fps: FrameRateLike,
+): TimelineItem {
+  const range = frameRangeFor(item, fps)
+  return setItemFramePosition(item, range.start - deltaFrames, range.end - deltaFrames, fps)
+}
+
+function deriveFragmentId(originalId: string, usedIds: Set<string>): string {
+  const candidate = (suffix: string): string =>
+    `${originalId.slice(0, Math.max(0, MAX_ID_LENGTH - suffix.length))}${suffix}`
+  const base = candidate(':ripple-right')
+  if (!usedIds.has(base)) return base
+  for (let suffix = 2; suffix < 10_000; suffix += 1) {
+    const collisionSafe = candidate(`:ripple-${suffix}`)
+    if (!usedIds.has(collisionSafe)) return collisionSafe
+  }
+  throw new EditEngineError(
+    'invalid_request',
+    `Cannot derive a unique ripple fragment ID for "${originalId}"`,
+  )
+}
+
+function trimItemToFrameRange(
+  item: TimelineItem,
+  startFrame: number,
+  endFrame: number,
+  fps: FrameRateLike,
+): TimelineItem {
+  const start_us = framesToMicroseconds(startFrame, fps)
+  const end_us = framesToMicroseconds(endFrame, fps)
+  if (item.item_type === 'clip') {
+    return {
+      ...item,
+      timeline_start_us: start_us,
+      timeline_end_us: end_us,
+      source_start_us: sourceAtTimelineFrame(item, startFrame, fps),
+      source_end_us: sourceAtTimelineFrame(item, endFrame, fps),
+    }
+  }
+  return setItemPosition(item, start_us, end_us)
+}
+
+function expandRippleItem(
+  item: TimelineItem,
+  startFrame: number,
+  endFrame: number,
+  deltaFrames: number,
+  fps: FrameRateLike,
+  usedIds: Set<string>,
+): { items: TimelineItem[]; created: string[]; updated: string[]; deleted: string[] } {
+  const id = itemId(item)
+  const range = frameRangeFor(item, fps)
+  if (range.end <= startFrame) return { items: [item], created: [], updated: [], deleted: [] }
+  if (range.start >= endFrame)
+    return {
+      items: [shiftItemByFrames(item, deltaFrames, fps)],
+      created: [],
+      updated: [id],
+      deleted: [],
+    }
+
+  const hasLeft = range.start < startFrame
+  const hasRight = range.end > endFrame
+  if (!hasLeft && !hasRight) return { items: [], created: [], updated: [], deleted: [id] }
+
+  const result: TimelineItem[] = []
+  const created: string[] = []
+  const updated = [id]
+  const deleted: string[] = []
+  if (hasLeft) result.push(trimItemToFrameRange(item, range.start, startFrame, fps))
+  if (hasRight) {
+    const right = trimItemToFrameRange(item, endFrame, range.end, fps)
+    const shifted = shiftItemByFrames(right, deltaFrames, fps)
+    if (hasLeft) {
+      const fragmentId = deriveFragmentId(id, usedIds)
+      usedIds.add(fragmentId)
+      result.push(
+        shifted.item_type === 'caption_cue'
+          ? { ...shifted, cue_id: fragmentId }
+          : { ...shifted, item_id: fragmentId },
+      )
+      created.push(fragmentId)
+    } else {
+      result.push(shifted)
+    }
+  }
+  return { items: result, created, updated, deleted }
+}
+
+function ensureTrackCompatibility(
+  track: TimelineTrack,
+  item: TimelineItem,
+  commandId: string,
+): void {
+  if (track.kind === 'caption' && item.item_type !== 'caption_cue')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${track.track_id}" accepts caption cues only`,
+      commandId,
+    )
+  if (track.kind !== 'caption' && item.item_type === 'caption_cue')
+    throw new EditEngineError(
+      'invalid_request',
+      `Caption cue "${itemId(item)}" requires a caption track`,
+      commandId,
+    )
+  if (track.kind === 'audio' && item.item_type === 'clip' && item.media_kind !== 'audio')
+    throw new EditEngineError(
+      'invalid_request',
+      `Audio track "${track.track_id}" accepts audio clips only`,
+      commandId,
+    )
+}
+
+function ensureUniqueItemId(timeline: MutableTimeline, id: string, commandId: string): void {
+  if (allItems(timeline).some((item) => itemId(item) === id))
+    throw new EditEngineError('invalid_request', `Item ID "${id}" already exists`, commandId)
+}
+
+function ensureMedia(timeline: MutableTimeline, mediaId: string, commandId: string): void {
+  if (!timeline.media.some((media) => media.media_id === mediaId))
+    throw new EditEngineError('unknown_media', `Media "${mediaId}" does not exist`, commandId)
+}
+
+function recomputeDuration(timeline: MutableTimeline): void {
+  const maxEnd = allItems(timeline).reduce((max, item) => Math.max(max, itemEnd(item)), 0)
+  if (maxEnd > timeline.duration_us) timeline.duration_us = maxEnd
+}
+
+function applyAddClip(timeline: MutableTimeline, command: AddClipCommand): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  const item = cloneItem(command.item) as ClipItem
+  ensureMedia(timeline, item.media_id, command.command_id)
+  ensureUniqueItemId(timeline, item.item_id, command.command_id)
+  ensureTrackCompatibility(track, item, command.command_id)
+  replaceTrackItems(
+    timeline,
+    timeline.tracks.indexOf(track),
+    insertAt(track.items, item, command.index),
+  )
+  recomputeDuration(timeline)
+  return { ...emptyEffect(), created_item_ids: [item.item_id] }
+}
+
+function applyAddText(timeline: MutableTimeline, command: AddTextCommand): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  const item = cloneItem(command.item) as Extract<TimelineItem, { item_type: 'text' }>
+  ensureUniqueItemId(timeline, item.item_id, command.command_id)
+  ensureTrackCompatibility(track, item, command.command_id)
+  replaceTrackItems(
+    timeline,
+    timeline.tracks.indexOf(track),
+    insertAt(track.items, item, command.index),
+  )
+  recomputeDuration(timeline)
+  return { ...emptyEffect(), created_item_ids: [item.item_id] }
+}
+
+function applyDuplicate(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'duplicate_item' }>,
+): CommandEffect {
+  const source = findItem(timeline, command.item_id, command.command_id).item
+  const target = findTrack(timeline, command.to_track_id, command.command_id)
+  ensureUniqueItemId(timeline, command.new_item_id, command.command_id)
+  const duplicate = cloneItem(source)
+  const sourceStart = itemStart(source)
+  const targetStart = command.timeline_start_us ?? sourceStart
+  const shifted = setItemPosition(
+    duplicate,
+    targetStart,
+    targetStart + (itemEnd(source) - sourceStart),
+  )
+  const withId =
+    shifted.item_type === 'caption_cue'
+      ? { ...shifted, cue_id: command.new_item_id, track_id: target.track_id }
+      : { ...shifted, item_id: command.new_item_id, track_id: target.track_id }
+  ensureTrackCompatibility(target, withId, command.command_id)
+  replaceTrackItems(
+    timeline,
+    timeline.tracks.indexOf(target),
+    insertAt(target.items, withId, command.index),
+  )
+  recomputeDuration(timeline)
+  return { ...emptyEffect(), created_item_ids: [command.new_item_id] }
+}
+
+function applyRemoveItem(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'remove_item' }>,
+): CommandEffect {
+  const located = findItem(timeline, command.item_id, command.command_id)
+  removeItemAt(timeline, located)
+  return { ...emptyEffect(), deleted_item_ids: [command.item_id] }
+}
+
+function applyMoveItem(timeline: MutableTimeline, command: MoveItemCommand): CommandEffect {
+  const located = findItem(timeline, command.item_id, command.command_id)
+  const target = findTrack(timeline, command.to_track_id, command.command_id)
+  ensureTrackCompatibility(target, located.item, command.command_id)
+  const oldStart = itemStart(located.item)
+  const moved = setItemPosition(
+    setItemTrack(located.item, target.track_id),
+    command.timeline_start_us,
+    command.timeline_start_us + itemEnd(located.item) - oldStart,
+  )
+  const sourceTrack = timeline.tracks[located.trackIndex]!
+  const sourceItems = sourceTrack.items.filter((_, index) => index !== located.itemIndex)
+  const targetIndex = timeline.tracks.indexOf(target)
+  replaceTrackItems(timeline, located.trackIndex, sourceItems)
+  const targetItems = targetIndex === located.trackIndex ? sourceItems : target.items
+  replaceTrackItems(timeline, targetIndex, insertAt(targetItems, moved, command.index))
+  return {
+    ...emptyEffect(),
+    moved_item_ids: [command.item_id],
+    updated_item_ids: [command.item_id],
+  }
+}
+
+function applyTrim(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'trim_item' }>,
+): CommandEffect {
+  const located = findItem(timeline, command.item_id, command.command_id)
+  const item = located.item
+  const next =
+    command.edge === 'start'
+      ? item.item_type === 'clip'
+        ? { ...item, timeline_start_us: command.timeline_us, source_start_us: command.source_us }
+        : item.item_type === 'caption_cue'
+          ? { ...item, start_us: command.timeline_us }
+          : { ...item, timeline_start_us: command.timeline_us }
+      : item.item_type === 'clip'
+        ? { ...item, timeline_end_us: command.timeline_us, source_end_us: command.source_us }
+        : item.item_type === 'caption_cue'
+          ? { ...item, end_us: command.timeline_us }
+          : { ...item, timeline_end_us: command.timeline_us }
+  if (itemEnd(next) <= itemStart(next))
+    throw new EditEngineError(
+      'invalid_request',
+      `Trim would make item "${command.item_id}" empty`,
+      command.command_id,
+    )
+  setItemAt(timeline, located, next)
+  return { ...emptyEffect(), updated_item_ids: [command.item_id] }
+}
+
+function applySplit(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'split_item' }>,
+): CommandEffect {
+  const located = findItem(timeline, command.item_id, command.command_id)
+  if (located.item.item_type === 'caption_cue')
+    throw new EditEngineError(
+      'unsupported_command',
+      'Caption cues use upsert_caption_cues rather than split_item',
+      command.command_id,
+    )
+  if (
+    command.at_timeline_us <= located.item.timeline_start_us ||
+    command.at_timeline_us >= located.item.timeline_end_us
+  )
+    throw new EditEngineError(
+      'invalid_request',
+      'Split must be inside the item range',
+      command.command_id,
+    )
+  ensureUniqueItemId(timeline, command.left_item_id, command.command_id)
+  ensureUniqueItemId(timeline, command.right_item_id, command.command_id)
+  const item = located.item
+  const left =
+    item.item_type === 'clip'
+      ? {
+          ...item,
+          item_id: command.left_item_id,
+          timeline_end_us: command.at_timeline_us,
+          source_end_us: command.at_source_us,
+        }
+      : { ...item, item_id: command.left_item_id, timeline_end_us: command.at_timeline_us }
+  const right =
+    item.item_type === 'clip'
+      ? {
+          ...item,
+          item_id: command.right_item_id,
+          timeline_start_us: command.at_timeline_us,
+          source_start_us: command.at_source_us,
+        }
+      : { ...item, item_id: command.right_item_id, timeline_start_us: command.at_timeline_us }
+  const track = timeline.tracks[located.trackIndex]!
+  const items = [...track.items]
+  items.splice(located.itemIndex, 1, left, right)
+  replaceTrackItems(timeline, located.trackIndex, items)
+  return {
+    ...emptyEffect(),
+    created_item_ids: [command.left_item_id, command.right_item_id],
+    deleted_item_ids: [command.item_id],
+  }
+}
+
+function applyRippleDelete(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'ripple_delete' }>,
+  fps: FrameRateLike,
+): CommandEffect {
+  const startFrame = assertFrameAligned(command.start_us, fps)
+  const endFrame = assertFrameAligned(command.end_us, fps)
+  const deltaFrames = endFrame - startFrame
+  const previousDuration = timeline.duration_us
+  const selected = command.track_ids === null ? null : new Set(command.track_ids)
+  for (const trackId of selected ?? []) findTrack(timeline, trackId, command.command_id)
+  const usedIds = new Set(allItems(timeline).map(itemId))
+  const created: string[] = []
+  const updated: string[] = []
+  const deleted: string[] = []
+  for (const [trackIndex, track] of timeline.tracks.entries()) {
+    if (selected !== null && !selected.has(track.track_id)) continue
+    const nextItems: TimelineItem[] = []
+    for (const item of track.items) {
+      const result = expandRippleItem(item, startFrame, endFrame, deltaFrames, fps, usedIds)
+      nextItems.push(...result.items)
+      created.push(...result.created)
+      updated.push(...result.updated)
+      deleted.push(...result.deleted)
+    }
+    replaceTrackItems(timeline, trackIndex, nextItems)
+  }
+  if (selected === null) {
+    const previousDurationFrames = assertFrameAligned(previousDuration, fps)
+    timeline.duration_us = framesToMicroseconds(
+      Math.max(0, previousDurationFrames - deltaFrames),
+      fps,
+    )
+  }
+  recomputeDuration(timeline)
+  const durationDelta = selected === null ? timeline.duration_us - previousDuration : 0
+  return {
+    ...emptyEffect(durationDelta),
+    created_item_ids: created,
+    updated_item_ids: [...new Set(updated.filter((id) => !deleted.includes(id)))],
+    deleted_item_ids: [...new Set(deleted)],
+  }
+}
+
+function applyAddTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'add_track' }>,
+): CommandEffect {
+  if (timeline.tracks.some((track) => track.track_id === command.track.track_id))
+    throw new EditEngineError(
+      'invalid_request',
+      `Track ID "${command.track.track_id}" already exists`,
+      command.command_id,
+    )
+  const track: TimelineTrack = { ...command.track, items: [] }
+  timeline.tracks = insertAt(timeline.tracks, track, command.index)
+  return { ...emptyEffect(), created_track_ids: [track.track_id] }
+}
+
+function applyRemoveTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'remove_track' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  const deletedItemIds = track.items.map(itemId)
+  timeline.tracks = timeline.tracks.filter((candidate) => candidate.track_id !== command.track_id)
+  return {
+    ...emptyEffect(),
+    deleted_track_ids: [command.track_id],
+    deleted_item_ids: deletedItemIds,
+  }
+}
+
+function applyMoveTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'move_track' }>,
+): CommandEffect {
+  const sourceIndex = timeline.tracks.findIndex((track) => track.track_id === command.track_id)
+  if (sourceIndex < 0) findTrack(timeline, command.track_id, command.command_id)
+  const [track] = timeline.tracks.splice(sourceIndex, 1)
+  timeline.tracks.splice(Math.min(command.to_index, timeline.tracks.length), 0, track!)
+  return { ...emptyEffect(), updated_track_ids: [command.track_id] }
+}
+
+function applyUpdateTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'update_track' }>,
+): CommandEffect {
+  const located = findTrack(timeline, command.track_id, command.command_id)
+  const index = timeline.tracks.indexOf(located)
+  timeline.tracks[index] = {
+    ...located,
+    ...(command.name !== undefined ? { name: command.name } : {}),
+    ...(command.language !== undefined ? { language: command.language ?? undefined } : {}),
+    ...(command.locked !== undefined ? { locked: command.locked } : {}),
+    ...(command.muted !== undefined ? { muted: command.muted } : {}),
+  }
+  return { ...emptyEffect(), updated_track_ids: [command.track_id] }
+}
+
+function applyAddCaptionTrack(
+  timeline: MutableTimeline,
+  command: AddCaptionTrackCommand,
+): CommandEffect {
+  if (timeline.tracks.some((track) => track.track_id === command.track_id))
+    throw new EditEngineError(
+      'invalid_request',
+      `Track ID "${command.track_id}" already exists`,
+      command.command_id,
+    )
+  const track: TimelineTrack = {
+    track_id: command.track_id,
+    kind: 'caption',
+    name: command.name,
+    language: command.language,
+    locked: false,
+    muted: false,
+    items: [],
+  }
+  timeline.tracks = insertAt(timeline.tracks, track, command.index)
+  return { ...emptyEffect(), created_track_ids: [track.track_id] }
+}
+
+function applyRemoveCaptionTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'remove_caption_track' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  if (track.kind !== 'caption')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${command.track_id}" is not a caption track`,
+      command.command_id,
+    )
+  return applyRemoveTrack(timeline, {
+    command_id: command.command_id,
+    type: 'remove_track',
+    track_id: command.track_id,
+  })
+}
+
+function applyUpdateCaptionTrack(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'update_caption_track' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  if (track.kind !== 'caption')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${command.track_id}" is not a caption track`,
+      command.command_id,
+    )
+  const index = timeline.tracks.indexOf(track)
+  timeline.tracks[index] = {
+    ...track,
+    ...(command.name !== undefined ? { name: command.name } : {}),
+    ...(command.language !== undefined ? { language: command.language } : {}),
+    ...(command.default_style !== undefined
+      ? { default_style: command.default_style ? { ...command.default_style } : null }
+      : {}),
+  }
+  return { ...emptyEffect(), updated_track_ids: [command.track_id] }
+}
+
+function applyUpsertCaptionCues(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'upsert_caption_cues' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  if (track.kind !== 'caption')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${command.track_id}" is not a caption track`,
+      command.command_id,
+    )
+  const incoming = command.cues.map((cue) => ({
+    ...cue,
+    style: cue.style ? { ...cue.style } : undefined,
+  }))
+  const incomingIds = new Set(incoming.map((cue) => cue.cue_id))
+  const previous = track.items.filter(
+    (item): item is CaptionCue => item.item_type === 'caption_cue',
+  )
+  const created = incoming
+    .filter((cue) => !previous.some((existing) => existing.cue_id === cue.cue_id))
+    .map((cue) => cue.cue_id)
+  const updated = incoming
+    .filter((cue) => previous.some((existing) => existing.cue_id === cue.cue_id))
+    .map((cue) => cue.cue_id)
+  const retained = previous.filter((cue) => !incomingIds.has(cue.cue_id))
+  const items = [...retained, ...incoming].sort(
+    (left, right) =>
+      left.start_us - right.start_us ||
+      left.end_us - right.end_us ||
+      left.cue_id.localeCompare(right.cue_id),
+  )
+  replaceTrackItems(timeline, timeline.tracks.indexOf(track), items)
+  recomputeDuration(timeline)
+  return { ...emptyEffect(), created_item_ids: created, updated_item_ids: updated }
+}
+
+function applyRemoveCaptionCues(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'remove_caption_cues' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  if (track.kind !== 'caption')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${command.track_id}" is not a caption track`,
+      command.command_id,
+    )
+  const ids = new Set(command.cue_ids)
+  const deleted = track.items
+    .filter((item) => item.item_type === 'caption_cue' && ids.has(item.cue_id))
+    .map(itemId)
+  replaceTrackItems(
+    timeline,
+    timeline.tracks.indexOf(track),
+    track.items.filter((item) => item.item_type !== 'caption_cue' || !ids.has(item.cue_id)),
+  )
+  return { ...emptyEffect(), deleted_item_ids: deleted }
+}
+
+function applyProperties(
+  timeline: MutableTimeline,
+  command: SetItemPropertiesCommand,
+): CommandEffect {
+  const located = findItem(timeline, command.item_id, command.command_id)
+  if (located.item.item_type === 'caption_cue')
+    throw new EditEngineError(
+      'unsupported_command',
+      'Use caption commands to edit caption cues',
+      command.command_id,
+    )
+  const patch: ItemPropertiesPatch = command.properties
+  const item = located.item
+  const next: TimelineItem = {
+    ...item,
+    ...(patch.transform !== undefined
+      ? { transform: patch.transform ? { ...patch.transform } : undefined }
+      : {}),
+    ...(patch.opacity !== undefined ? { opacity: patch.opacity } : {}),
+    ...(patch.volume !== undefined ? { volume: patch.volume } : {}),
+    ...(patch.speed !== undefined ? { speed: patch.speed } : {}),
+    ...(patch.fade_in_us !== undefined ? { fade_in_us: patch.fade_in_us ?? undefined } : {}),
+    ...(patch.fade_out_us !== undefined ? { fade_out_us: patch.fade_out_us ?? undefined } : {}),
+    ...(patch.effects !== undefined
+      ? { effects: patch.effects.map((effect: Effect) => ({ ...effect })) }
+      : {}),
+    ...(patch.keyframes !== undefined
+      ? { keyframes: patch.keyframes.map((keyframe: Keyframe) => ({ ...keyframe })) }
+      : {}),
+    ...(patch.transition_in !== undefined
+      ? { transition_in: patch.transition_in ? { ...patch.transition_in } : undefined }
+      : {}),
+    ...(patch.transition_out !== undefined
+      ? { transition_out: patch.transition_out ? { ...patch.transition_out } : undefined }
+      : {}),
+    ...(item.item_type === 'text' && patch.text !== undefined ? { text: patch.text } : {}),
+    ...(item.item_type === 'text' && patch.text_style !== undefined
+      ? { style: patch.text_style ? { ...patch.text_style } : undefined }
+      : {}),
+  } as TimelineItem
+  setItemAt(timeline, located, next)
+  return { ...emptyEffect(), updated_item_ids: [command.item_id] }
+}
+
+function applyCaptionStyle(
+  timeline: MutableTimeline,
+  command: Extract<EditCommand, { type: 'set_caption_style' }>,
+): CommandEffect {
+  const track = findTrack(timeline, command.track_id, command.command_id)
+  if (track.kind !== 'caption')
+    throw new EditEngineError(
+      'invalid_request',
+      `Track "${command.track_id}" is not a caption track`,
+      command.command_id,
+    )
+  if (command.cue_ids === null) {
+    const index = timeline.tracks.indexOf(track)
+    timeline.tracks[index] = { ...track, default_style: { ...command.style } }
+    return { ...emptyEffect(), updated_track_ids: [command.track_id] }
+  }
+  const ids = new Set(command.cue_ids)
+  const updated: string[] = []
+  const items = track.items.map((item) => {
+    if (item.item_type !== 'caption_cue' || !ids.has(item.cue_id)) return item
+    updated.push(item.cue_id)
+    return { ...item, style: { ...command.style } }
+  })
+  replaceTrackItems(timeline, timeline.tracks.indexOf(track), items)
+  return { ...emptyEffect(), updated_item_ids: updated }
+}
+
+function applyCommand(
+  timeline: MutableTimeline,
+  command: EditCommand,
+  fps: FrameRateLike,
+): CommandEffect {
+  // All command time fields are public microseconds. Conversion is performed
+  // before mutation so a non-frame-aligned batch can never partially apply.
+  switch (command.type) {
+    case 'add_clip':
+      assertFrameAligned(command.item.timeline_start_us, fps)
+      assertFrameAligned(command.item.timeline_end_us, fps)
+      assertFrameAligned(command.item.source_start_us, fps)
+      assertFrameAligned(command.item.source_end_us, fps)
+      return applyAddClip(timeline, command)
+    case 'add_text':
+      assertFrameAligned(command.item.timeline_start_us, fps)
+      assertFrameAligned(command.item.timeline_end_us, fps)
+      return applyAddText(timeline, command)
+    case 'duplicate_item':
+      if (command.timeline_start_us !== undefined)
+        assertFrameAligned(command.timeline_start_us, fps)
+      return applyDuplicate(timeline, command)
+    case 'remove_item':
+      return applyRemoveItem(timeline, command)
+    case 'move_item':
+      assertFrameAligned(command.timeline_start_us, fps)
+      return applyMoveItem(timeline, command)
+    case 'trim_item':
+      assertFrameAligned(command.timeline_us, fps)
+      assertFrameAligned(command.source_us, fps)
+      return applyTrim(timeline, command)
+    case 'split_item':
+      assertFrameAligned(command.at_timeline_us, fps)
+      assertFrameAligned(command.at_source_us, fps)
+      return applySplit(timeline, command)
+    case 'ripple_delete':
+      return applyRippleDelete(timeline, command, fps)
+    case 'add_track':
+      return applyAddTrack(timeline, command)
+    case 'remove_track':
+      return applyRemoveTrack(timeline, command)
+    case 'move_track':
+      return applyMoveTrack(timeline, command)
+    case 'update_track':
+      return applyUpdateTrack(timeline, command)
+    case 'add_caption_track':
+      return applyAddCaptionTrack(timeline, command)
+    case 'remove_caption_track':
+      return applyRemoveCaptionTrack(timeline, command)
+    case 'update_caption_track':
+      return applyUpdateCaptionTrack(timeline, command)
+    case 'upsert_caption_cues':
+      for (const cue of command.cues) {
+        assertFrameAligned(cue.start_us, fps)
+        assertFrameAligned(cue.end_us, fps)
+      }
+      return applyUpsertCaptionCues(timeline, command)
+    case 'remove_caption_cues':
+      return applyRemoveCaptionCues(timeline, command)
+    case 'set_item_properties':
+      for (const keyframe of command.properties.keyframes ?? [])
+        assertFrameAligned(keyframe.time_us, fps)
+      return applyProperties(timeline, command)
+    case 'set_caption_style':
+      return applyCaptionStyle(timeline, command)
+    case 'request_job':
+      throw new EditEngineError(
+        'unsupported_command',
+        'request_job must be dispatched through a MediaJobClient host adapter',
+        command.command_id,
+      )
+    default:
+      return assertNever(command)
+  }
+}
+
+function assertNever(value: never): never {
+  throw new EditEngineError(
+    'unsupported_command',
+    `Unsupported command ${(value as { type?: string }).type ?? 'unknown'}`,
+  )
+}
+
+function validateAndPrepare(timeline: TimelineState, context: EditEngineContext): MutableTimeline {
+  try {
+    normalizeFrameRate(context.fps)
+  } catch (error) {
+    throw new EditEngineError(
+      'invalid_request',
+      error instanceof Error ? error.message : 'fps must be a finite positive rate',
+    )
+  }
+  const valid = validateTimelineState(timeline)
+  if (!valid.ok)
+    throw new EditEngineError('invalid_request', valid.errors[0]?.message ?? 'timeline is invalid')
+  assertFrameAligned(timeline.duration_us, context.fps)
+  for (const item of allItems(timeline as MutableTimeline)) {
+    assertFrameAligned(itemStart(item), context.fps)
+    assertFrameAligned(itemEnd(item), context.fps)
+    if (item.item_type === 'clip') {
+      assertFrameAligned(item.source_start_us, context.fps)
+      assertFrameAligned(item.source_end_us, context.fps)
+    }
+  }
+  return cloneTimeline(timeline)
+}
+
+export function applyEditCommands(
+  timeline: TimelineState,
+  commands: readonly EditCommand[],
+  context: EditEngineContext,
+): EditEngineResult {
+  const next = validateAndPrepare(timeline, context)
+  const applied: AppliedCommandResult[] = []
+  for (const command of commands) {
+    const previousDuration = next.duration_us
+    const commandEffect = applyCommand(next, command, context.fps)
+    const actualDelta = next.duration_us - previousDuration
+    const effect =
+      commandEffect.timeline_delta_us === actualDelta
+        ? commandEffect
+        : { ...commandEffect, timeline_delta_us: actualDelta }
+    applied.push({
+      command_id: command.command_id,
+      command_type: command.type,
+      status: 'applied',
+      effect,
+    })
+  }
+  const validated = validateTimelineState(next)
+  if (!validated.ok)
+    throw new EditEngineError(
+      'invalid_request',
+      validated.errors[0]?.message ?? 'edit produced an invalid timeline',
+    )
+  return { timeline: next, commands: applied }
+}
+
+export const controlledEditEngine: ControlledEditEngine = {
+  apply: applyEditCommands,
+}
diff --git a/src/features/editor/codepress/fixtures/README.md b/src/features/editor/codepress/fixtures/README.md
new file mode 100644
index 000000000..31bdfe08e
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/README.md
@@ -0,0 +1,8 @@
+# PR1 conformance fixtures
+
+These are the language-neutral CodePress PR1 fixtures copied into the
+FreeCut-side adapter test surface. They are intentionally limited to the
+stable wire fields: no FreeCut paths, blob URLs, workspace handles, or raw
+media bytes are included. The adapter tests load them as JSON so the same
+validation, command order, and structured conflict shapes can be checked from
+the fork without importing the CodePress repository.
diff --git a/src/features/editor/codepress/fixtures/errors/idempotency-conflict.json b/src/features/editor/codepress/fixtures/errors/idempotency-conflict.json
new file mode 100644
index 000000000..bb5a611a3
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/errors/idempotency-conflict.json
@@ -0,0 +1,20 @@
+{
+  "fixture_version": 1,
+  "id": "idempotency-conflict",
+  "kind": "structured_error",
+  "error": {
+    "code": "idempotency_conflict",
+    "message": "The idempotency key was already used for a different operation.",
+    "retryable": false,
+    "details": {
+      "kind": "idempotency_conflict",
+      "idempotency_key": "timeline-demo:cut-intro:v1",
+      "original_operation_id": "operation-cut-intro"
+    }
+  },
+  "expect": {
+    "code": "idempotency_conflict",
+    "retryable": false,
+    "idempotency_key": "timeline-demo:cut-intro:v1"
+  }
+}
diff --git a/src/features/editor/codepress/fixtures/errors/revision-conflict.json b/src/features/editor/codepress/fixtures/errors/revision-conflict.json
new file mode 100644
index 000000000..c97a1f8d3
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/errors/revision-conflict.json
@@ -0,0 +1,27 @@
+{
+  "fixture_version": 1,
+  "id": "revision-conflict",
+  "kind": "structured_error",
+  "error": {
+    "code": "revision_conflict",
+    "message": "The timeline changed after this operation was prepared.",
+    "retryable": true,
+    "details": {
+      "kind": "revision_conflict",
+      "base_revision": 7,
+      "current_revision": 9,
+      "rebase": {
+        "status": "required",
+        "automatic": false,
+        "strategy": "refresh_then_resubmit",
+        "retry_with_revision": 9
+      }
+    }
+  },
+  "expect": {
+    "code": "revision_conflict",
+    "retryable": true,
+    "automatic_rebase": false,
+    "retry_with_revision": 9
+  }
+}
diff --git a/src/features/editor/codepress/fixtures/index.json b/src/features/editor/codepress/fixtures/index.json
new file mode 100644
index 000000000..c1b33dc95
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/index.json
@@ -0,0 +1,10 @@
+{
+  "fixture_version": 1,
+  "fixtures": [
+    "valid/core-edit-batch.json",
+    "valid/caption-batch.json",
+    "invalid/invalid-caption-cue.json",
+    "errors/revision-conflict.json",
+    "errors/idempotency-conflict.json"
+  ]
+}
diff --git a/src/features/editor/codepress/fixtures/invalid/invalid-caption-cue.json b/src/features/editor/codepress/fixtures/invalid/invalid-caption-cue.json
new file mode 100644
index 000000000..427f0bd57
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/invalid/invalid-caption-cue.json
@@ -0,0 +1,31 @@
+{
+  "fixture_version": 1,
+  "id": "invalid-caption-cue",
+  "kind": "invalid_command_batch",
+  "request": {
+    "contract_version": 1,
+    "timeline_id": "timeline-caption",
+    "operation_id": "operation-invalid-caption",
+    "idempotency_key": "timeline-caption:invalid-caption:1",
+    "base_revision": 2,
+    "preconditions": [],
+    "commands": [
+      {
+        "command_id": "command-invalid-cue",
+        "type": "upsert_caption_cues",
+        "track_id": "track-captions",
+        "cues": [
+          {
+            "item_type": "caption_cue",
+            "cue_id": "cue-invalid",
+            "track_id": "track-captions",
+            "start_us": 5000000,
+            "end_us": 5000000,
+            "text": "An empty range is not valid."
+          }
+        ]
+      }
+    ]
+  },
+  "expect": { "request_valid": false, "error_codes": ["invalid_request"] }
+}
diff --git a/src/features/editor/codepress/fixtures/valid/caption-batch.json b/src/features/editor/codepress/fixtures/valid/caption-batch.json
new file mode 100644
index 000000000..fe6924680
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/valid/caption-batch.json
@@ -0,0 +1,71 @@
+{
+  "fixture_version": 1,
+  "id": "caption-batch",
+  "kind": "valid_command_batch",
+  "timeline": {
+    "contract_version": 1,
+    "schema_version": 1,
+    "timeline_id": "timeline-caption",
+    "revision": 2,
+    "duration_us": 8000000,
+    "media": [],
+    "tracks": [
+      {
+        "track_id": "track-captions",
+        "kind": "caption",
+        "name": "English captions",
+        "language": "en",
+        "locked": false,
+        "muted": false,
+        "items": []
+      }
+    ]
+  },
+  "request": {
+    "contract_version": 1,
+    "timeline_id": "timeline-caption",
+    "operation_id": "operation-captions-1",
+    "idempotency_key": "timeline-caption:captions:1",
+    "base_revision": 2,
+    "preconditions": [{ "type": "track_exists", "track_id": "track-captions" }],
+    "commands": [
+      {
+        "command_id": "command-upsert-captions",
+        "type": "upsert_caption_cues",
+        "track_id": "track-captions",
+        "cues": [
+          {
+            "item_type": "caption_cue",
+            "cue_id": "cue-hello",
+            "track_id": "track-captions",
+            "start_us": 1000000,
+            "end_us": 2500000,
+            "text": "Hello, world!"
+          },
+          {
+            "item_type": "caption_cue",
+            "cue_id": "cue-next",
+            "track_id": "track-captions",
+            "start_us": 3000000,
+            "end_us": 4500000,
+            "text": "This is a caption cue."
+          }
+        ]
+      },
+      {
+        "command_id": "command-move-caption",
+        "type": "move_item",
+        "item_id": "cue-hello",
+        "to_track_id": "track-captions",
+        "timeline_start_us": 1200000,
+        "index": 0
+      }
+    ]
+  },
+  "expect": {
+    "timeline_valid": true,
+    "request_valid": true,
+    "command_types": ["upsert_caption_cues", "move_item"],
+    "command_count": 2
+  }
+}
diff --git a/src/features/editor/codepress/fixtures/valid/core-edit-batch.json b/src/features/editor/codepress/fixtures/valid/core-edit-batch.json
new file mode 100644
index 000000000..e833ab5ba
--- /dev/null
+++ b/src/features/editor/codepress/fixtures/valid/core-edit-batch.json
@@ -0,0 +1,150 @@
+{
+  "fixture_version": 1,
+  "id": "core-edit-batch",
+  "kind": "valid_command_batch",
+  "timeline": {
+    "contract_version": 1,
+    "schema_version": 1,
+    "timeline_id": "timeline-demo",
+    "revision": 7,
+    "duration_us": 12000000,
+    "media": [
+      {
+        "media_id": "media-speaker",
+        "media_kind": "video",
+        "content_hash": "sha256:speaker-v1",
+        "duration_us": 30000000,
+        "availability": {
+          "mode": "hybrid",
+          "local": {
+            "device_id": "device-owner",
+            "root_id": "root-shared",
+            "file_id": "file-speaker",
+            "root_generation": 3
+          },
+          "cloud": { "object_id": "object-speaker-original" }
+        }
+      },
+      {
+        "media_id": "media-music",
+        "media_kind": "audio",
+        "content_hash": "sha256:music-v1",
+        "duration_us": 60000000,
+        "availability": {
+          "mode": "cloud",
+          "cloud": { "object_id": "object-music-original" }
+        }
+      }
+    ],
+    "tracks": [
+      {
+        "track_id": "track-video",
+        "kind": "video",
+        "name": "Video",
+        "locked": false,
+        "muted": false,
+        "items": [
+          {
+            "item_type": "clip",
+            "item_id": "item-speaker",
+            "track_id": "track-video",
+            "media_id": "media-speaker",
+            "media_kind": "video",
+            "timeline_start_us": 0,
+            "timeline_end_us": 12000000,
+            "source_start_us": 0,
+            "source_end_us": 12000000
+          }
+        ]
+      },
+      {
+        "track_id": "track-music",
+        "kind": "audio",
+        "name": "Music",
+        "locked": false,
+        "muted": false,
+        "items": [
+          {
+            "item_type": "clip",
+            "item_id": "item-music",
+            "track_id": "track-music",
+            "media_id": "media-music",
+            "media_kind": "audio",
+            "timeline_start_us": 0,
+            "timeline_end_us": 12000000,
+            "source_start_us": 0,
+            "source_end_us": 12000000,
+            "volume": 0.7
+          }
+        ]
+      }
+    ]
+  },
+  "request": {
+    "contract_version": 1,
+    "timeline_id": "timeline-demo",
+    "operation_id": "operation-cut-intro",
+    "idempotency_key": "timeline-demo:cut-intro:v1",
+    "base_revision": 7,
+    "preconditions": [
+      {
+        "type": "item_at",
+        "item_id": "item-speaker",
+        "track_id": "track-video",
+        "timeline_start_us": 0,
+        "timeline_end_us": 12000000
+      },
+      {
+        "type": "media_content_hash",
+        "media_id": "media-speaker",
+        "content_hash": "sha256:speaker-v1"
+      }
+    ],
+    "commands": [
+      {
+        "command_id": "command-split-speaker",
+        "type": "split_item",
+        "item_id": "item-speaker",
+        "at_timeline_us": 4000000,
+        "at_source_us": 4000000,
+        "left_item_id": "item-speaker-left",
+        "right_item_id": "item-speaker-right"
+      },
+      {
+        "command_id": "command-trim-left",
+        "type": "trim_item",
+        "item_id": "item-speaker-left",
+        "edge": "start",
+        "timeline_us": 1000000,
+        "source_us": 1000000
+      },
+      {
+        "command_id": "command-ripple-delete",
+        "type": "ripple_delete",
+        "start_us": 2000000,
+        "end_us": 2500000,
+        "track_ids": null
+      },
+      {
+        "command_id": "command-move-music",
+        "type": "move_item",
+        "item_id": "item-music",
+        "to_track_id": "track-music",
+        "timeline_start_us": 0,
+        "index": 0
+      },
+      {
+        "command_id": "command-move-video-track",
+        "type": "move_track",
+        "track_id": "track-video",
+        "to_index": 0
+      }
+    ]
+  },
+  "expect": {
+    "timeline_valid": true,
+    "request_valid": true,
+    "command_types": ["split_item", "trim_item", "ripple_delete", "move_item", "move_track"],
+    "command_count": 5
+  }
+}
diff --git a/src/features/editor/codepress/index.ts b/src/features/editor/codepress/index.ts
new file mode 100644
index 000000000..bdaa3cf49
--- /dev/null
+++ b/src/features/editor/codepress/index.ts
@@ -0,0 +1,11 @@
+export * from './adapter'
+export * from './caption-commands'
+export * from './caption-editor'
+export * from './caption-validation'
+export * from './contract'
+export * from './controlled-editor'
+export * from './document'
+export * from './edit-engine'
+export * from './interfaces'
+export * from './timing'
+export * from './translation'
diff --git a/src/features/editor/codepress/interfaces.ts b/src/features/editor/codepress/interfaces.ts
new file mode 100644
index 000000000..e7f7ab4f6
--- /dev/null
+++ b/src/features/editor/codepress/interfaces.ts
@@ -0,0 +1,138 @@
+import type {
+  AppliedCommandResult,
+  EditApplyResult,
+  EditCommandBatch,
+  EditCommand,
+  MediaId,
+  TimelineState,
+  TimelineRevision,
+} from './contract'
+import type { FrameRateLike } from './timing'
+
+/** Data the controlled editor owns while it is mounted. It is not persistence. */
+export interface ControlledEditorDocument {
+  timeline: TimelineState
+  fps: FrameRateLike
+  width: number
+  height: number
+  background_color?: string
+}
+
+/** The narrow state port a host supplies to a controlled editor surface. */
+export interface ControlledEditorPort {
+  getDocument(): ControlledEditorDocument
+  replaceDocument(document: ControlledEditorDocument): void
+  subscribe?(listener: (document: ControlledEditorDocument) => void): () => void
+}
+
+export interface EditEngineContext {
+  fps: FrameRateLike
+}
+
+export interface EditEngineResult {
+  timeline: TimelineState
+  commands: readonly AppliedCommandResult[]
+}
+
+/** Pure, worker-safe application boundary. Implementations must be atomic. */
+export interface ControlledEditEngine {
+  apply(
+    timeline: TimelineState,
+    commands: readonly EditCommand[],
+    context: EditEngineContext,
+  ): EditEngineResult
+}
+
+export interface RenderFrameRequest {
+  document: ControlledEditorDocument
+  frame: number
+  time_us: number
+  width?: number
+  height?: number
+}
+
+export interface RenderedFrame {
+  frame: number
+  time_us: number
+  width: number
+  height: number
+  /** Renderer-specific pixels/image handle; never part of a command result. */
+  payload: unknown
+}
+
+/** Rendering is deliberately a port: no renderer or media URL is in the command contract. */
+export interface ControlledRenderer {
+  renderFrame(request: RenderFrameRequest): Promise<RenderedFrame> | RenderedFrame
+}
+
+export interface ProjectRevision {
+  timeline: TimelineState
+  revision: TimelineRevision
+}
+
+/** CodePress-owned persistence boundary; FreeCut never writes the project store directly. */
+export interface ProjectStore {
+  loadCurrentRevision(timelineId: string): Promise<ProjectRevision> | ProjectRevision
+  submitOperation?(batch: EditCommandBatch): Promise<EditApplyResult> | EditApplyResult
+  subscribe?(timelineId: string, listener: (revision: ProjectRevision) => void): () => void
+}
+
+export interface ResolvedAsset {
+  media_id: MediaId
+  kind: 'local' | 'cloud'
+  /** Short-lived host locator; never copied into TimelineState. */
+  source: string
+}
+
+export interface AssetResolver {
+  resolve(mediaId: MediaId): Promise<ResolvedAsset> | ResolvedAsset
+}
+
+export interface UploadClient {
+  upload(mediaId: MediaId): Promise<{ media_id: MediaId; status: 'uploaded' | 'already_available' }>
+}
+
+export interface MediaJobClient {
+  request(input: {
+    job_type: import('./contract').VideoJobType
+    media_id?: MediaId
+    timeline_revision?: TimelineRevision
+    options?: Readonly<Record<string, string | number | boolean | null>>
+  }): Promise<{ job_id: string }> | { job_id: string }
+}
+
+export interface RenderJobClient {
+  request(input: {
+    kind: 'preview' | 'export'
+    timeline_id: string
+    revision: TimelineRevision
+    options?: Readonly<Record<string, string | number | boolean | null>>
+  }): Promise<{ job_id: string }> | { job_id: string }
+  cancel?(jobId: string): Promise<void> | void
+}
+
+export interface PresenceClient {
+  getStatus():
+    | Promise<{ available: boolean; label?: string }>
+    | { available: boolean; label?: string }
+}
+
+export interface TelemetryClient {
+  emit(event: {
+    name: string
+    timeline_id?: string
+    operation_id?: string
+    revision?: TimelineRevision
+    attributes?: Readonly<Record<string, string | number | boolean | null>>
+  }): Promise<void> | void
+}
+
+export interface CodePressHostAdapters {
+  projectStore?: ProjectStore
+  assetResolver?: AssetResolver
+  uploadClient?: UploadClient
+  mediaJobClient?: MediaJobClient
+  renderJobClient?: RenderJobClient
+  presenceClient?: PresenceClient
+  telemetryClient?: TelemetryClient
+}
diff --git a/src/features/editor/codepress/timing.ts b/src/features/editor/codepress/timing.ts
new file mode 100644
index 000000000..696e663f0
--- /dev/null
+++ b/src/features/editor/codepress/timing.ts
@@ -0,0 +1,176 @@
+/**
+ * Deterministic time conversion at the CodePress/FreeCut boundary.
+ *
+ * FreeCut stores positions as integer frames while the public command
+ * contract stores integer microseconds.  Floating-point multiplication is
+ * deliberately not used for the decision whether a command is frame aligned;
+ * the rational arithmetic below makes that decision stable across browsers,
+ * workers, and Node.
+ */
+
+export interface FrameRate {
+  readonly numerator: bigint
+  readonly denominator: bigint
+  readonly value: number
+}
+
+/** A numeric rate is convenient for ordinary documents; the rational form
+ * preserves exact NTSC-style rates such as 30000/1001. */
+export type FrameRateLike = number | FrameRate
+
+export type TimingRounding = 'nearest' | 'floor' | 'ceil'
+
+export class FrameTimingError extends Error {
+  readonly microseconds: number
+  readonly fps: number
+
+  constructor(microseconds: number, fps: FrameRateLike) {
+    const value = typeof fps === 'number' ? fps : fps.value
+    super(`${microseconds}µs is not aligned to an integer frame at ${value}fps`)
+    this.name = 'FrameTimingError'
+    this.microseconds = microseconds
+    this.fps = value
+  }
+}
+
+function gcd(left: bigint, right: bigint): bigint {
+  let a = left < 0n ? -left : left
+  let b = right < 0n ? -right : right
+  while (b !== 0n) {
+    const next = a % b
+    a = b
+    b = next
+  }
+  return a
+}
+
+function decimalToRational(value: number): { numerator: bigint; denominator: bigint } {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new RangeError('fps must be a finite positive number')
+  const text = String(value).toLowerCase()
+  const [mantissa, exponentText] = text.split('e')
+  const exponent = exponentText ? Number(exponentText) : 0
+  const [whole, fraction = ''] = mantissa!.split('.')
+  const digits = `${whole}${fraction}`
+  let numerator = BigInt(digits)
+  let denominator = 10n ** BigInt(fraction.length)
+  if (exponent > 0) numerator *= 10n ** BigInt(exponent)
+  if (exponent < 0) denominator *= 10n ** BigInt(-exponent)
+  const divisor = gcd(numerator, denominator)
+  return { numerator: numerator / divisor, denominator: denominator / divisor }
+}
+
+export function normalizeFrameRate(fps: FrameRateLike): FrameRate {
+  if (typeof fps === 'number') {
+    const rational = decimalToRational(fps)
+    return { ...rational, value: fps }
+  }
+  if (
+    typeof fps.numerator !== 'bigint' ||
+    typeof fps.denominator !== 'bigint' ||
+    fps.numerator <= 0n ||
+    fps.denominator <= 0n ||
+    !Number.isFinite(fps.value) ||
+    fps.value <= 0
+  )
+    throw new RangeError('fps must be a finite positive rational rate')
+  const divisor = gcd(fps.numerator, fps.denominator)
+  return {
+    numerator: fps.numerator / divisor,
+    denominator: fps.denominator / divisor,
+    value: fps.value,
+  }
+}
+
+function assertMicroseconds(value: number): void {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError('microseconds must be a safe non-negative integer')
+}
+
+function assertFrames(value: number): void {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError('frames must be a safe non-negative integer')
+}
+
+function divideRounded(numerator: bigint, denominator: bigint, rounding: TimingRounding): bigint {
+  if (denominator <= 0n) throw new RangeError('denominator must be positive')
+  const quotient = numerator / denominator
+  const remainder = numerator % denominator
+  if (remainder === 0n) return quotient
+  if (rounding === 'floor') return quotient
+  if (rounding === 'ceil') return quotient + 1n
+  return remainder * 2n >= denominator ? quotient + 1n : quotient
+}
+
+/** Convert an integer microsecond timestamp to a frame, requiring alignment by default. */
+export function microsecondsToFrames(
+  microseconds: number,
+  fps: FrameRateLike,
+  options: { rounding?: TimingRounding; requireAligned?: boolean } = {},
+): number {
+  assertMicroseconds(microseconds)
+  const rate = typeof fps === 'number' ? normalizeFrameRate(fps) : fps
+  const numerator = BigInt(microseconds) * rate.numerator
+  const denominator = 1_000_000n * rate.denominator
+  const frame = divideRounded(numerator, denominator, options.rounding ?? 'nearest')
+  if (options.requireAligned !== false) {
+    // A frame duration is often fractional in microseconds (for example
+    // 29.97fps). The contract remains integer-valued, so alignment means the
+    // canonical nearest-integer-microsecond representation of that frame,
+    // rather than requiring an impossible exact rational value.
+    const canonical = divideRounded(
+      frame * 1_000_000n * rate.denominator,
+      rate.numerator,
+      'nearest',
+    )
+    if (canonical !== BigInt(microseconds)) throw new FrameTimingError(microseconds, rate.value)
+  }
+  const result = Number(frame)
+  assertFrames(result)
+  return result
+}
+
+/** Convert an integer frame position to the nearest integer microsecond. */
+export function framesToMicroseconds(
+  frames: number,
+  fps: FrameRateLike,
+  rounding: TimingRounding = 'nearest',
+): number {
+  assertFrames(frames)
+  const rate = typeof fps === 'number' ? normalizeFrameRate(fps) : fps
+  const numerator = BigInt(frames) * 1_000_000n * rate.denominator
+  const microseconds = divideRounded(numerator, rate.numerator, rounding)
+  const result = Number(microseconds)
+  assertMicroseconds(result)
+  return result
+}
+
+export function isFrameAligned(microseconds: number, fps: FrameRateLike): boolean {
+  try {
+    microsecondsToFrames(microseconds, fps)
+    return true
+  } catch (error) {
+    if (error instanceof FrameTimingError) return false
+    throw error
+  }
+}
+
+export function assertFrameAligned(microseconds: number, fps: FrameRateLike): number {
+  return microsecondsToFrames(microseconds, fps, { requireAligned: true })
+}
+
+export interface FrameInterval {
+  start: number
+  end: number
+}
+
+export function microsecondIntervalToFrames(
+  start_us: number,
+  end_us: number,
+  fps: FrameRateLike,
+): FrameInterval {
+  const start = assertFrameAligned(start_us, fps)
+  const end = assertFrameAligned(end_us, fps)
+  if (end <= start) throw new RangeError('end_us must be greater than start_us')
+  return { start, end }
+}
diff --git a/src/features/editor/codepress/translation.ts b/src/features/editor/codepress/translation.ts
new file mode 100644
index 000000000..005182921
--- /dev/null
+++ b/src/features/editor/codepress/translation.ts
@@ -0,0 +1,347 @@
+import { assertFrameAligned, framesToMicroseconds, type FrameRateLike } from './timing'
+import type {
+  CaptionCue,
+  ClipItem,
+  EditCommand,
+  EditCommandBatch,
+  ItemPropertiesPatch,
+  Keyframe,
+  TextItem,
+  TimelineItem,
+  Transition,
+} from './contract'
+
+export type Frame = number
+
+export type FrameClipItem = Omit<
+  ClipItem,
+  | 'timeline_start_us'
+  | 'timeline_end_us'
+  | 'source_start_us'
+  | 'source_end_us'
+  | 'fade_in_us'
+  | 'fade_out_us'
+  | 'transition_in'
+  | 'transition_out'
+  | 'keyframes'
+> & {
+  timeline_start_frame: Frame
+  timeline_end_frame: Frame
+  source_start_frame: Frame
+  source_end_frame: Frame
+  fade_in_frame?: Frame
+  fade_out_frame?: Frame
+  transition_in?: FrameTransition | null
+  transition_out?: FrameTransition | null
+  keyframes?: readonly FrameKeyframe[]
+}
+
+export type FrameTextItem = Omit<
+  TextItem,
+  'timeline_start_us' | 'timeline_end_us' | 'keyframes'
+> & {
+  timeline_start_frame: Frame
+  timeline_end_frame: Frame
+  keyframes?: readonly FrameKeyframe[]
+}
+
+export type FrameCaptionCue = Omit<CaptionCue, 'start_us' | 'end_us'> & {
+  start_frame: Frame
+  end_frame: Frame
+}
+
+export type FrameItem = FrameClipItem | FrameTextItem | FrameCaptionCue
+
+export interface FrameTransition {
+  transition_type: Transition['transition_type']
+  duration_frame: Frame
+}
+
+export interface FrameKeyframe extends Omit<Keyframe, 'time_us'> {
+  time_frame: Frame
+}
+
+export type FrameItemPropertiesPatch = Omit<
+  ItemPropertiesPatch,
+  'fade_in_us' | 'fade_out_us' | 'transition_in' | 'transition_out' | 'keyframes'
+> & {
+  fade_in_frame?: Frame | null
+  fade_out_frame?: Frame | null
+  transition_in?: FrameTransition | null
+  transition_out?: FrameTransition | null
+  keyframes?: readonly FrameKeyframe[]
+}
+
+export type FrameEditCommand =
+  | (Omit<Extract<EditCommand, { type: 'add_clip' }>, 'item'> & { item: FrameClipItem })
+  | (Omit<Extract<EditCommand, { type: 'add_text' }>, 'item'> & { item: FrameTextItem })
+  | (Omit<Extract<EditCommand, { type: 'duplicate_item' }>, 'timeline_start_us'> & {
+      timeline_start_frame?: Frame
+    })
+  | Extract<EditCommand, { type: 'remove_item' }>
+  | (Omit<Extract<EditCommand, { type: 'move_item' }>, 'timeline_start_us'> & {
+      timeline_start_frame: Frame
+    })
+  | (Omit<Extract<EditCommand, { type: 'trim_item' }>, 'timeline_us' | 'source_us'> & {
+      timeline_frame: Frame
+      source_frame: Frame
+    })
+  | (Omit<Extract<EditCommand, { type: 'split_item' }>, 'at_timeline_us' | 'at_source_us'> & {
+      at_timeline_frame: Frame
+      at_source_frame: Frame
+    })
+  | (Omit<Extract<EditCommand, { type: 'ripple_delete' }>, 'start_us' | 'end_us'> & {
+      start_frame: Frame
+      end_frame: Frame
+    })
+  | Extract<
+      EditCommand,
+      {
+        type:
+          | 'add_track'
+          | 'remove_track'
+          | 'move_track'
+          | 'update_track'
+          | 'add_caption_track'
+          | 'remove_caption_track'
+          | 'update_caption_track'
+      }
+    >
+  | (Omit<Extract<EditCommand, { type: 'upsert_caption_cues' }>, 'cues'> & {
+      cues: readonly FrameCaptionCue[]
+    })
+  | Extract<EditCommand, { type: 'remove_caption_cues' }>
+  | (Omit<Extract<EditCommand, { type: 'set_item_properties' }>, 'properties'> & {
+      properties: FrameItemPropertiesPatch
+    })
+  | Extract<EditCommand, { type: 'set_caption_style' | 'request_job' }>
+
+export type CaptionCommand = Extract<
+  EditCommand,
+  {
+    type:
+      | 'add_caption_track'
+      | 'remove_caption_track'
+      | 'update_caption_track'
+      | 'upsert_caption_cues'
+      | 'remove_caption_cues'
+      | 'set_caption_style'
+      | 'update_track'
+  }
+>
+
+export type FrameCaptionCommand = Extract<
+  FrameEditCommand,
+  {
+    type:
+      | 'add_caption_track'
+      | 'remove_caption_track'
+      | 'update_caption_track'
+      | 'upsert_caption_cues'
+      | 'remove_caption_cues'
+      | 'set_caption_style'
+      | 'update_track'
+  }
+>
+
+export interface FrameEditCommandBatch extends Omit<EditCommandBatch, 'commands'> {
+  fps: FrameRateLike
+  commands: readonly FrameEditCommand[]
+}
+
+function transitionToFrames(
+  transition: Transition | null | undefined,
+  fps: FrameRateLike,
+): FrameTransition | null | undefined {
+  if (transition === undefined) return undefined
+  if (transition === null) return null
+  return {
+    transition_type: transition.transition_type,
+    duration_frame: assertFrameAligned(transition.duration_us, fps),
+  }
+}
+
+function keyframeToFrames(keyframe: Keyframe, fps: FrameRateLike): FrameKeyframe {
+  return {
+    property: keyframe.property,
+    time_frame: assertFrameAligned(keyframe.time_us, fps),
+    value: keyframe.value,
+    interpolation: keyframe.interpolation,
+  }
+}
+
+function itemToFrames(item: TimelineItem, fps: FrameRateLike): FrameItem {
+  if (item.item_type === 'caption_cue') {
+    return {
+      item_type: 'caption_cue',
+      cue_id: item.cue_id,
+      track_id: item.track_id,
+      text: item.text,
+      ...(item.speaker !== undefined ? { speaker: item.speaker } : {}),
+      ...(item.style !== undefined ? { style: item.style } : {}),
+      start_frame: assertFrameAligned(item.start_us, fps),
+      end_frame: assertFrameAligned(item.end_us, fps),
+    }
+  }
+  if (item.item_type === 'text') {
+    return {
+      item_type: 'text',
+      item_id: item.item_id,
+      track_id: item.track_id,
+      text: item.text,
+      ...(item.style !== undefined ? { style: item.style } : {}),
+      ...(item.transform !== undefined ? { transform: item.transform } : {}),
+      ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+      timeline_start_frame: assertFrameAligned(item.timeline_start_us, fps),
+      timeline_end_frame: assertFrameAligned(item.timeline_end_us, fps),
+      keyframes: item.keyframes?.map((keyframe) => keyframeToFrames(keyframe, fps)),
+    }
+  }
+  return {
+    item_type: 'clip',
+    item_id: item.item_id,
+    track_id: item.track_id,
+    media_id: item.media_id,
+    media_kind: item.media_kind,
+    ...(item.transform !== undefined ? { transform: item.transform } : {}),
+    ...(item.opacity !== undefined ? { opacity: item.opacity } : {}),
+    ...(item.volume !== undefined ? { volume: item.volume } : {}),
+    ...(item.speed !== undefined ? { speed: item.speed } : {}),
+    ...(item.effects !== undefined ? { effects: item.effects } : {}),
+    timeline_start_frame: assertFrameAligned(item.timeline_start_us, fps),
+    timeline_end_frame: assertFrameAligned(item.timeline_end_us, fps),
+    source_start_frame: assertFrameAligned(item.source_start_us, fps),
+    source_end_frame: assertFrameAligned(item.source_end_us, fps),
+    fade_in_frame:
+      item.fade_in_us === undefined ? undefined : assertFrameAligned(item.fade_in_us, fps),
+    fade_out_frame:
+      item.fade_out_us === undefined ? undefined : assertFrameAligned(item.fade_out_us, fps),
+    transition_in: transitionToFrames(item.transition_in, fps),
+    transition_out: transitionToFrames(item.transition_out, fps),
+    keyframes: item.keyframes?.map((keyframe) => keyframeToFrames(keyframe, fps)),
+  }
+}
+
+function propertiesToFrames(
+  properties: ItemPropertiesPatch,
+  fps: FrameRateLike,
+): FrameItemPropertiesPatch {
+  return {
+    ...(properties.transform !== undefined ? { transform: properties.transform } : {}),
+    ...(properties.opacity !== undefined ? { opacity: properties.opacity } : {}),
+    ...(properties.volume !== undefined ? { volume: properties.volume } : {}),
+    ...(properties.speed !== undefined ? { speed: properties.speed } : {}),
+    ...(properties.text !== undefined ? { text: properties.text } : {}),
+    ...(properties.text_style !== undefined ? { text_style: properties.text_style } : {}),
+    ...(properties.effects !== undefined ? { effects: properties.effects } : {}),
+    fade_in_frame:
+      properties.fade_in_us === undefined
+        ? undefined
+        : properties.fade_in_us === null
+          ? null
+          : assertFrameAligned(properties.fade_in_us, fps),
+    fade_out_frame:
+      properties.fade_out_us === undefined
+        ? undefined
+        : properties.fade_out_us === null
+          ? null
+          : assertFrameAligned(properties.fade_out_us, fps),
+    transition_in: transitionToFrames(properties.transition_in, fps),
+    transition_out: transitionToFrames(properties.transition_out, fps),
+    keyframes: properties.keyframes?.map((keyframe) => keyframeToFrames(keyframe, fps)),
+  }
+}
+
+export function translateCommandToFrames(
+  command: EditCommand,
+  fps: FrameRateLike,
+): FrameEditCommand {
+  switch (command.type) {
+    case 'add_clip':
+      return { ...command, item: itemToFrames(command.item, fps) as FrameClipItem }
+    case 'add_text':
+      return { ...command, item: itemToFrames(command.item, fps) as FrameTextItem }
+    case 'duplicate_item':
+      return {
+        ...command,
+        ...(command.timeline_start_us === undefined
+          ? {}
+          : { timeline_start_frame: assertFrameAligned(command.timeline_start_us, fps) }),
+      }
+    case 'remove_item':
+      return command
+    case 'move_item':
+      return {
+        ...command,
+        timeline_start_frame: assertFrameAligned(command.timeline_start_us, fps),
+      }
+    case 'trim_item':
+      return {
+        ...command,
+        timeline_frame: assertFrameAligned(command.timeline_us, fps),
+        source_frame: assertFrameAligned(command.source_us, fps),
+      }
+    case 'split_item':
+      return {
+        ...command,
+        at_timeline_frame: assertFrameAligned(command.at_timeline_us, fps),
+        at_source_frame: assertFrameAligned(command.at_source_us, fps),
+      }
+    case 'ripple_delete':
+      return {
+        ...command,
+        start_frame: assertFrameAligned(command.start_us, fps),
+        end_frame: assertFrameAligned(command.end_us, fps),
+      }
+    case 'upsert_caption_cues':
+      return {
+        ...command,
+        cues: command.cues.map((cue) => itemToFrames(cue, fps) as FrameCaptionCue),
+      }
+    case 'set_item_properties':
+      return { ...command, properties: propertiesToFrames(command.properties, fps) }
+    case 'add_track':
+    case 'remove_track':
+    case 'move_track':
+    case 'update_track':
+    case 'add_caption_track':
+    case 'remove_caption_track':
+    case 'update_caption_track':
+    case 'remove_caption_cues':
+    case 'set_caption_style':
+    case 'request_job':
+      return command
+  }
+}
+
+export function translateCommandBatchToFrames(
+  batch: EditCommandBatch,
+  fps: FrameRateLike,
+): FrameEditCommandBatch {
+  return {
+    ...batch,
+    fps,
+    commands: batch.commands.map((command) => translateCommandToFrames(command, fps)),
+  }
+}
+
+/** Translate the frame-only caption surface back to the canonical wire shape. */
+export function translateFrameCaptionCommandToCommand(
+  command: FrameCaptionCommand,
+  fps: FrameRateLike,
+): CaptionCommand {
+  if (command.type !== 'upsert_caption_cues') return command
+  return {
+    ...command,
+    cues: command.cues.map((cue) => ({
+      item_type: 'caption_cue',
+      cue_id: cue.cue_id,
+      track_id: cue.track_id,
+      start_us: framesToMicroseconds(cue.start_frame, fps),
+      end_us: framesToMicroseconds(cue.end_frame, fps),
+      text: cue.text,
+      ...(cue.speaker !== undefined ? { speaker: cue.speaker } : {}),
+      ...(cue.style !== undefined ? { style: { ...cue.style } } : {}),
+    })),
+  }
+}
diff --git a/src/features/editor/components/editor.tsx b/src/features/editor/components/editor.tsx
index ac1a99133..716696b54 100644
--- a/src/features/editor/components/editor.tsx
+++ b/src/features/editor/components/editor.tsx
@@ -168,6 +168,11 @@ function preloadBundleExportDialog() {
 }
 
 /** Project metadata passed from route loader (timeline loaded separately via loadTimeline) */
+interface LoadedEditorHostRuntime {
+  mountStores(): void
+  unmountStores(): void
+}
+
 interface EditorProps {
   projectId: string
   project: {
@@ -183,6 +188,9 @@ interface EditorProps {
     currentSchemaVersion: number
     requiresUpgrade: boolean
   }
+  hostRuntime?: LoadedEditorHostRuntime
+  onNavigateBack?: () => void
+  onRefreshMigration?: () => Promise<void>
 }
 
 /**
@@ -203,6 +211,7 @@ const startedUpgradeBackups = new Map<string, Promise<void>>()
  */
 export const Editor = memo(function Editor({ projectId, project, migration }: EditorProps) {
   const { t } = useTranslation()
+  const router = useRouter()
   const [upgradeApproved, setUpgradeApproved] = useState(!migration.requiresUpgrade)
   const backupName = formatProjectUpgradeBackupName(
     project.name,
@@ -278,6 +287,18 @@ export const Editor = memo(function Editor({ projectId, project, migration }: Ed
     t,
   ])
 
+  const onNavigateBack = useCallback(() => {
+    void router.navigate({ to: '/projects' })
+  }, [router])
+  const onRefreshMigration = useCallback(
+    () =>
+      router.invalidate({
+        filter: (match) =>
+          match.routeId === EDITOR_PROJECT_ROUTE_ID && match.params.projectId === projectId,
+      }),
+    [projectId, router],
+  )
+
   if (!upgradeApproved) {
     return (
       <div className="min-h-screen bg-background flex items-center justify-center">
@@ -288,7 +309,15 @@ export const Editor = memo(function Editor({ projectId, project, migration }: Ed
     )
   }
 
-  return <LoadedEditor projectId={projectId} project={project} migration={migration} />
+  return (
+    <LoadedEditor
+      projectId={projectId}
+      project={project}
+      migration={migration}
+      onNavigateBack={onNavigateBack}
+      onRefreshMigration={onRefreshMigration}
+    />
+  )
 })
 
 const EditorDialogHost = memo(function EditorDialogHost({ projectId }: { projectId: string }) {
@@ -363,6 +392,28 @@ const TimelineDialogHost = memo(function TimelineDialogHost() {
   )
 })
 
+const LocalRouterBridge = memo(function LocalRouterBridge({
+  projectId,
+  onReady,
+}: {
+  projectId: string
+  onReady: (invalidate: () => Promise<void>) => void
+}) {
+  const router = useRouter()
+  const invalidate = useCallback(
+    () =>
+      router.invalidate({
+        filter: (match) =>
+          match.routeId === EDITOR_PROJECT_ROUTE_ID && match.params.projectId === projectId,
+      }),
+    [projectId, router],
+  )
+
+  onReady(invalidate)
+
+  return null
+})
+
 const AutoSaveController = memo(function AutoSaveController({
   onSave,
 }: {
@@ -378,13 +429,16 @@ const TimelineShortcutsController = memo(function TimelineShortcutsController()
   return null
 })
 
+// fallow-ignore-next-line complexity
 export const LoadedEditor = memo(function LoadedEditor({
   projectId,
   project,
   migration,
+  hostRuntime,
+  onNavigateBack,
+  onRefreshMigration,
 }: EditorProps) {
   const { t } = useTranslation()
-  const router = useRouter()
   const [exportDialogOpen, setExportDialogOpen] = useState(false)
   const [bundleExportDialogOpen, setBundleExportDialogOpen] = useState(false)
   const [renderQueueOpen, setRenderQueueOpen] = useState(false)
@@ -402,6 +456,7 @@ export const LoadedEditor = memo(function LoadedEditor({
   const workspace = useEditorStore((s) => s.workspace)
   const isMaskEditingActive = useMaskEditorStore((s) => s.isEditing)
   const hasRefreshedMigrationStateRef = useRef(false)
+  const localRefreshMigrationRef = useRef<(() => Promise<void>) | null>(null)
   const timelinePanelRef = useRef<ImperativePanelHandle>(null)
   const previousWorkspaceRef = useRef(workspace)
 
@@ -412,9 +467,13 @@ export const LoadedEditor = memo(function LoadedEditor({
     hasRefreshedMigrationStateRef.current = false
   }, [projectId])
 
+  const setLocalRefreshMigration = useCallback((invalidate: () => Promise<void>) => {
+    localRefreshMigrationRef.current = invalidate
+  }, [])
+
   useEffect(() => {
-    rememberLastEditorProjectId(projectId)
-  }, [projectId])
+    if (!hostRuntime) rememberLastEditorProjectId(projectId)
+  }, [hostRuntime, projectId])
 
   // Initialize transition chain subscription (pre-computes chains from timeline data)
   // This subscription recomputes chains when items/transitions change - deferred to idle
@@ -432,6 +491,7 @@ export const LoadedEditor = memo(function LoadedEditor({
 
   // Preload export dialogs during idle time so they open instantly.
   useEffect(() => {
+    if (hostRuntime) return
     const id = requestIdleCallback(() => {
       // Best-effort idle preloads: swallow rejections (offline chunk load, or
       // the dynamic import racing test-environment teardown). The real load
@@ -440,11 +500,12 @@ export const LoadedEditor = memo(function LoadedEditor({
       void preloadBundleExportDialog().catch(() => {})
     })
     return () => cancelIdleCallback(id)
-  }, [])
+  }, [hostRuntime])
 
   // Prewarm effect preview thumbnails during idle time without making the
   // effects feature part of the initial editor route chunk.
   useEffect(() => {
+    if (hostRuntime) return
     const id = requestIdleCallback(() => {
       // Best-effort prewarm — ignore failures, including the import() promise
       // rejecting when it resolves after the test environment is torn down.
@@ -453,10 +514,20 @@ export const LoadedEditor = memo(function LoadedEditor({
         .catch(() => {})
     })
     return () => cancelIdleCallback(id)
-  }, [])
+  }, [hostRuntime])
 
   // Initialize timeline from project data (or create default tracks for new projects).
   useEffect(() => {
+    if (hostRuntime) {
+      hostRuntime.mountStores()
+      return () => {
+        hostRuntime.unmountStores()
+        usePlaybackStore.getState().setPreviewFrame(null)
+        usePlaybackStore.getState().pause()
+        clearPreviewAudioCache()
+      }
+    }
+
     const { setCurrentProject: setMediaProject, loadMediaItems } = useMediaLibraryStore.getState()
     const { setCurrentProject } = useProjectStore.getState()
     const playbackStore = usePlaybackStore.getState()
@@ -505,10 +576,8 @@ export const LoadedEditor = memo(function LoadedEditor({
 
         // Refresh the editor route metadata once the approved legacy project has
         // opened successfully so future reopens do not briefly show the upgrade prompt.
-        await router.invalidate({
-          filter: (match) =>
-            match.routeId === EDITOR_PROJECT_ROUTE_ID && match.params.projectId === projectId,
-        })
+        const refreshMigration = onRefreshMigration ?? localRefreshMigrationRef.current
+        await refreshMigration?.()
       } catch (error) {
         logger.error('Failed to load timeline:', error)
       }
@@ -534,7 +603,8 @@ export const LoadedEditor = memo(function LoadedEditor({
     project.name,
     project.width,
     projectId,
-    router,
+    hostRuntime,
+    onRefreshMigration,
   ])
 
   useEffect(() => {
@@ -557,7 +627,7 @@ export const LoadedEditor = memo(function LoadedEditor({
     const timelinePanel = timelinePanelRef.current
     if (!timelinePanel) return
 
-    saveWorkspaceTimelineSize(previousWorkspace, timelinePanel.getSize())
+    if (!hostRuntime) saveWorkspaceTimelineSize(previousWorkspace, timelinePanel.getSize())
 
     const targetSize =
       loadWorkspaceTimelineSize(workspace) ??
@@ -566,7 +636,7 @@ export const LoadedEditor = memo(function LoadedEditor({
     timelinePanel.resize(
       Math.min(editorLayout.timelineMaxSize, Math.max(editorLayout.timelineMinSize, targetSize)),
     )
-  }, [workspace, editorLayout])
+  }, [editorLayout, hostRuntime, workspace])
 
   useEffect(() => {
     const timelineState = useTimelineStore.getState()
@@ -652,8 +722,9 @@ export const LoadedEditor = memo(function LoadedEditor({
 
   // Enable keyboard shortcuts
   useEditorHotkeys({
-    onSave: handleSave,
-    onExport: handleExport,
+    onSave: hostRuntime ? undefined : handleSave,
+    onExport: hostRuntime ? undefined : handleExport,
+    enableLocalUi: !hostRuntime,
   })
 
   // Enable transition breakage notifications
@@ -673,19 +744,23 @@ export const LoadedEditor = memo(function LoadedEditor({
       role="application"
       aria-label={t('editor.editor.appLabel')}
     >
-      <AutoSaveController onSave={handleSave} />
-      <TimelineShortcutsController />
+      {!hostRuntime && <AutoSaveController onSave={handleSave} />}
+      {!hostRuntime && <TimelineShortcutsController />}
+      {!hostRuntime && (
+        <LocalRouterBridge projectId={projectId} onReady={setLocalRefreshMigration} />
+      )}
 
       {/* Top Toolbar */}
       <InteractionLockRegion locked={isMaskEditingActive}>
         <Toolbar
           projectId={projectId}
           project={project}
-          onSave={handleSave}
-          onExport={handleExport}
-          onExportBundle={handleExportBundle}
-          onOpenRenderQueue={handleOpenRenderQueue}
-          renderQueueCount={renderQueueActiveCount}
+          onBack={onNavigateBack}
+          onSave={hostRuntime ? undefined : handleSave}
+          onExport={hostRuntime ? undefined : handleExport}
+          onExportBundle={hostRuntime ? undefined : handleExportBundle}
+          onOpenRenderQueue={hostRuntime ? undefined : handleOpenRenderQueue}
+          renderQueueCount={hostRuntime ? 0 : renderQueueActiveCount}
         />
       </InteractionLockRegion>
 
@@ -806,46 +881,48 @@ export const LoadedEditor = memo(function LoadedEditor({
         )}
       </div>
 
-      <Suspense fallback={null}>
-        {/* Export Dialog */}
-        {exportDialogOpen && (
-          <LazyExportDialog
-            open={exportDialogOpen}
-            onClose={() => setExportDialogOpen(false)}
-            onOpenRenderQueue={handleOpenRenderQueue}
-          />
-        )}
-
-        {/* Exports + render queue dialog */}
-        {renderQueueOpen && (
-          <LazyExportsDialog
-            open={renderQueueOpen}
-            onClose={() => setRenderQueueOpen(false)}
-            projectId={projectId}
-          />
-        )}
-
-        {/* Bundle Export Dialog */}
-        {bundleExportDialogOpen && (
-          <LazyBundleExportDialog
-            open={bundleExportDialogOpen}
-            onClose={() => {
-              setBundleExportDialogOpen(false)
-              setBundleFileHandle(undefined)
-            }}
-            projectId={projectId}
-            onBeforeExport={handleSave}
-            fileHandle={bundleFileHandle}
-          />
-        )}
-      </Suspense>
+      {!hostRuntime && (
+        <Suspense fallback={null}>
+          {/* Export Dialog */}
+          {exportDialogOpen && (
+            <LazyExportDialog
+              open={exportDialogOpen}
+              onClose={() => setExportDialogOpen(false)}
+              onOpenRenderQueue={handleOpenRenderQueue}
+            />
+          )}
+
+          {/* Exports + render queue dialog */}
+          {renderQueueOpen && (
+            <LazyExportsDialog
+              open={renderQueueOpen}
+              onClose={() => setRenderQueueOpen(false)}
+              projectId={projectId}
+            />
+          )}
+
+          {/* Bundle Export Dialog */}
+          {bundleExportDialogOpen && (
+            <LazyBundleExportDialog
+              open={bundleExportDialogOpen}
+              onClose={() => {
+                setBundleExportDialogOpen(false)
+                setBundleFileHandle(undefined)
+              }}
+              projectId={projectId}
+              onBeforeExport={handleSave}
+              fileHandle={bundleFileHandle}
+            />
+          )}
+        </Suspense>
+      )}
 
       {/* Restores/persists the per-project queue, and drains it serially. */}
-      <RenderQueuePersistence projectId={projectId} />
-      <RenderQueueRunner />
+      {!hostRuntime && <RenderQueuePersistence projectId={projectId} />}
+      {!hostRuntime && <RenderQueueRunner />}
 
-      <EditorDialogHost projectId={projectId} />
-      <TimelineDialogHost />
+      {!hostRuntime && <EditorDialogHost projectId={projectId} />}
+      {!hostRuntime && <TimelineDialogHost />}
 
       {/* Single global cursor-readout for IO (in/out) drags across all surfaces. */}
       <IoDragReadout />
diff --git a/src/features/editor/components/media-sidebar.tsx b/src/features/editor/components/media-sidebar.tsx
index 5a02fbefe..5d57f3ae8 100644
--- a/src/features/editor/components/media-sidebar.tsx
+++ b/src/features/editor/components/media-sidebar.tsx
@@ -60,6 +60,8 @@ import { EffectThumbnail, useGpuEffectPreviewData } from '@/features/editor/deps
 import { createLogger } from '@/shared/logging/logger'
 import { useSettingsStore } from '@/features/editor/deps/settings'
 import { resolveGeneratedLayerCanvasSize } from '../utils/generated-layer-canvas-size'
+import { useEditorCapability, useEditorHostContext, useEditorHostMode } from '../host/context'
+import { HostTranscriptEditor } from '../host/transcript-editor'
 const LazyAiPanel = lazy(() => import('./ai-tab').then((m) => ({ default: m.AiTab })))
 const LazyTranscriptEditorPanel = lazy(() =>
   importTranscriptEditorPanel().then(({ TranscriptEditorPanel }) => ({
@@ -288,6 +290,10 @@ const ADD_TEXT_TEMPLATE_LABEL = 'Add Text'
 
 export const MediaSidebar = memo(function MediaSidebar() {
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
+  const { host } = useEditorHostContext()
+  const canAddTimeline = useEditorCapability('timeline.add')
+  const canTranscribe = useEditorCapability('media.transcription')
   const editorDensity = useSettingsStore((s) => s.editorDensity)
   const editorLayout = getEditorLayout(editorDensity)
   // Use granular selectors - Zustand v5 best practice
@@ -383,6 +389,7 @@ export const MediaSidebar = memo(function MediaSidebar() {
   // the same preset onto the canvas does (minus the cursor-driven position).
   const handleAddText = useCallback(
     (presetId?: (typeof TEXT_STYLE_PRESETS)[number]['id']) => {
+      if (!canAddTimeline) return
       // Read all needed state from stores directly to avoid subscriptions
       const { tracks, fps, addItemOnNewTrack } = useTimelineStore.getState()
       const { activeTrackId, selectItems, setActiveTrack } = useSelectionStore.getState()
@@ -422,58 +429,65 @@ export const MediaSidebar = memo(function MediaSidebar() {
       setActiveTrack(newTrack.trackId)
       selectItems([textItem.id])
     },
-    [t],
+    [canAddTimeline, t],
   )
 
   // Add shape item on its own new layer at the playhead, matching the canvas drop.
-  const handleAddShape = useCallback((shapeType: ShapeType, shapePreset?: 'solid' | 'gradient') => {
-    // Read all needed state from stores directly to avoid subscriptions
-    const { tracks, fps, addItemOnNewTrack } = useTimelineStore.getState()
-    const { activeTrackId, selectItems, setActiveTrack } = useSelectionStore.getState()
-    const currentProject = useProjectStore.getState().currentProject
-    const activeCompositionId =
-      useCompositionNavigationStore.getState().activeCompositionId
-    const activeComposition = activeCompositionId
-      ? useCompositionsStore.getState().getComposition(activeCompositionId)
-      : undefined
-
-    const newTrack = createOverlayLayerTrack({ tracks, activeTrackId })
-
-    if (!newTrack) {
-      logger.warn('No available track for shape item')
-      return
-    }
+  const handleAddShape = useCallback(
+    (shapeType: ShapeType, shapePreset?: 'solid' | 'gradient') => {
+      if (hostMode || !canAddTimeline) return
+      // Read all needed state from stores directly to avoid subscriptions
+      const { tracks, fps, addItemOnNewTrack } = useTimelineStore.getState()
+      const { activeTrackId, selectItems, setActiveTrack } = useSelectionStore.getState()
+      const currentProject = useProjectStore.getState().currentProject
+      const activeCompositionId = useCompositionNavigationStore.getState().activeCompositionId
+      const activeComposition = activeCompositionId
+        ? useCompositionsStore.getState().getComposition(activeCompositionId)
+        : undefined
 
-    const { width: canvasWidth, height: canvasHeight } = resolveGeneratedLayerCanvasSize(
-      activeComposition,
-      currentProject?.metadata,
-    )
+      const newTrack = createOverlayLayerTrack({ tracks, activeTrackId })
 
-    const placement = {
-      trackId: newTrack.trackId,
-      from: Math.max(0, usePlaybackStore.getState().currentFrame),
-      durationInFrames: getDefaultGeneratedLayerDurationInFrames(fps),
-      canvasWidth,
-      canvasHeight,
-      shapeType,
-    }
-    const shapeItem: ShapeItem =
-      shapePreset === 'solid'
-        ? createDefaultSolidColorItem(placement)
-        : shapePreset === 'gradient'
-          ? createDefaultGradientItem(placement)
-          : createDefaultShapeItem(placement)
-
-    addItemOnNewTrack(shapeItem, newTrack.tracks)
-    setActiveTrack(newTrack.trackId)
-    selectItems([shapeItem.id])
-  }, [])
+      if (!newTrack) {
+        logger.warn('No available track for shape item')
+        return
+      }
+
+      const { width: canvasWidth, height: canvasHeight } = resolveGeneratedLayerCanvasSize(
+        activeComposition,
+        currentProject?.metadata,
+      )
+
+      const placement = {
+        trackId: newTrack.trackId,
+        from: Math.max(0, usePlaybackStore.getState().currentFrame),
+        durationInFrames: getDefaultGeneratedLayerDurationInFrames(fps),
+        canvasWidth,
+        canvasHeight,
+        shapeType,
+      }
+      const shapeItem: ShapeItem =
+        shapePreset === 'solid'
+          ? createDefaultSolidColorItem(placement)
+          : shapePreset === 'gradient'
+            ? createDefaultGradientItem(placement)
+            : createDefaultShapeItem(placement)
+
+      addItemOnNewTrack(shapeItem, newTrack.tracks)
+      setActiveTrack(newTrack.trackId)
+      selectItems([shapeItem.id])
+    },
+    [canAddTimeline, hostMode],
+  )
 
   // Add adjustment layer to timeline at the best available position
   // Optionally with pre-applied effects and custom label
-  const handleAddAdjustmentLayer = useCallback((effects?: VisualEffect[], label?: string) => {
-    addAdjustmentLayer(effects, label)
-  }, [])
+  const handleAddAdjustmentLayer = useCallback(
+    (effects?: VisualEffect[], label?: string) => {
+      if (hostMode || !canAddTimeline) return
+      addAdjustmentLayer(effects, label)
+    },
+    [canAddTimeline, hostMode],
+  )
 
   // Create adjustment layer with preset effects
   const handleAddPreset = useCallback(
@@ -488,6 +502,7 @@ export const MediaSidebar = memo(function MediaSidebar() {
   // Add a single GPU effect — to selected clips, or as adjustment layer if nothing selected
   const handleAddGpuEffect = useCallback(
     (gpuEffectId: string) => {
+      if (hostMode || !canAddTimeline) return
       const { selectedItemIds } = useSelectionStore.getState()
       const { items, addEffect } = useTimelineStore.getState()
 
@@ -513,7 +528,7 @@ export const MediaSidebar = memo(function MediaSidebar() {
         ])
       }
     },
-    [handleAddAdjustmentLayer],
+    [canAddTimeline, handleAddAdjustmentLayer, hostMode],
   )
 
   const { gpuCategories, triggerPreviews } = useGpuEffectPreviewData()
@@ -544,6 +559,14 @@ export const MediaSidebar = memo(function MediaSidebar() {
     { id: 'transcript' as const, icon: Captions, label: t('transcript.tabLabel') },
     { id: 'ai' as const, icon: WandSparkles, label: t('editor.mediaSidebar.ai') },
   ]
+  const visibleCategories = hostMode
+    ? categories.filter(
+        ({ id }) =>
+          id === 'media' ||
+          (id === 'text' && canAddTimeline) ||
+          (id === 'transcript' && canTranscribe && !!host?.transcript),
+      )
+    : categories
 
   const shouldSuppressGeneratedItemClick = useCallback(() => {
     if (!suppressGeneratedItemClickRef.current) {
@@ -620,7 +643,7 @@ export const MediaSidebar = memo(function MediaSidebar() {
 
         {/* Category Icons */}
         <div className="flex flex-col gap-1 py-1.5">
-          {categories.map(({ id, icon: Icon, label }) => (
+          {visibleCategories.map(({ id, icon: Icon, label }) => (
             <button
               key={id}
               onClick={() => {
@@ -1150,11 +1173,13 @@ export const MediaSidebar = memo(function MediaSidebar() {
             <div
               className={`min-h-0 flex-1 overflow-hidden ${activeTab === 'transcript' ? 'block' : 'hidden'}`}
             >
-              {activeTab === 'transcript' && (
+              {activeTab === 'transcript' && hostMode ? (
+                <HostTranscriptEditor active />
+              ) : activeTab === 'transcript' ? (
                 <Suspense fallback={null}>
                   <LazyTranscriptEditorPanel active />
                 </Suspense>
-              )}
+              ) : null}
             </div>
 
             {/* AI Tab */}
diff --git a/src/features/editor/components/mini-timeline/use-clip-thumbnails.ts b/src/features/editor/components/mini-timeline/use-clip-thumbnails.ts
index 00db3af27..e8d366b14 100644
--- a/src/features/editor/components/mini-timeline/use-clip-thumbnails.ts
+++ b/src/features/editor/components/mini-timeline/use-clip-thumbnails.ts
@@ -7,6 +7,7 @@ import {
 } from '@/features/editor/deps/media-library'
 import { useFilmstrip, type FilmstripFrame } from '@/features/editor/deps/timeline-hooks'
 import type { MiniFilmTileClip } from './types'
+import { useEditorHostMode } from '@/features/editor/host/context'
 
 /**
  * Resolve poster thumbnails (the per-media frame captured at import) for clips
@@ -15,6 +16,7 @@ import type { MiniFilmTileClip } from './types'
  * URLs — read only, never revoke here.
  */
 export function useMediaPosterUrls(mediaIds: readonly string[]): Map<string, string> {
+  const hostMode = useEditorHostMode()
   const [posterUrls, setPosterUrls] = useState<Map<string, string>>(() => new Map())
 
   // Reactive snapshot of which media have a poster available, so a clip painted
@@ -30,6 +32,7 @@ export function useMediaPosterUrls(mediaIds: readonly string[]): Map<string, str
   )
 
   useEffect(() => {
+    if (hostMode) return
     const missing = Object.entries(thumbnailIds)
       .filter(([id, thumbnailId]) => thumbnailId && !posterUrls.has(id))
       .map(([id]) => id)
@@ -63,7 +66,7 @@ export function useMediaPosterUrls(mediaIds: readonly string[]): Map<string, str
     return () => {
       cancelled = true
     }
-  }, [thumbnailIds, posterUrls])
+  }, [hostMode, thumbnailIds, posterUrls])
 
   return posterUrls
 }
@@ -75,6 +78,7 @@ export function useMediaPosterUrls(mediaIds: readonly string[]): Map<string, str
  * to the import poster so a tile never flashes black.
  */
 export function useClipStartFrameUrl(clip: MiniFilmTileClip, projectFps: number): string | null {
+  const hostMode = useEditorHostMode()
   const isVideo = clip.type === 'video' && Boolean(clip.mediaId)
   const mediaId = clip.mediaId ?? ''
 
@@ -93,7 +97,7 @@ export function useClipStartFrameUrl(clip: MiniFilmTileClip, projectFps: number)
   const blobUrl = resolved?.mediaId === mediaId ? resolved.url : null
 
   useEffect(() => {
-    if (!isVideo || !mediaId || blobUrl) return
+    if (hostMode || !isVideo || !mediaId || blobUrl) return
     let cancelled = false
     void resolveMediaUrl(mediaId)
       .then((url) => {
@@ -105,7 +109,7 @@ export function useClipStartFrameUrl(clip: MiniFilmTileClip, projectFps: number)
     return () => {
       cancelled = true
     }
-  }, [isVideo, mediaId, blobUrl])
+  }, [blobUrl, hostMode, isVideo, mediaId])
 
   // Source-frame -> seconds, mirroring clip-content's conversion. Prefer the
   // media's real duration (duration-ratio) over source-fps division when known.
@@ -133,7 +137,7 @@ export function useClipStartFrameUrl(clip: MiniFilmTileClip, projectFps: number)
     blobUrl,
     duration: sourceDurationSeconds,
     isVisible: isVideo,
-    enabled: isVideo,
+    enabled: isVideo && !hostMode,
     priorityWindow,
     targetFrameIndices,
   })
diff --git a/src/features/editor/components/preview-area.tsx b/src/features/editor/components/preview-area.tsx
index 8e45ca8ee..b9eb0587f 100644
--- a/src/features/editor/components/preview-area.tsx
+++ b/src/features/editor/components/preview-area.tsx
@@ -314,6 +314,7 @@ export const PreviewArea = memo(function PreviewArea({
   )
 
   const sourcePreviewMediaId = useEditorStore((s) => s.sourcePreviewMediaId)
+  const hostMode = useEditorStore((s) => s.hostMode)
   const colorScopesOpen = useEditorStore((s) => s.colorScopesOpen)
   const workspace = useEditorStore((s) => s.workspace)
   const scopesPanelOpen = workspace === 'color' && colorScopesOpen
@@ -571,12 +572,18 @@ export const PreviewArea = memo(function PreviewArea({
             className="flex-1 min-h-0 relative overflow-hidden"
             aria-label="Preview canvas region"
           >
-            <ProgramPreviewSurface
-              project={liveProject}
-              containerSize={containerSize}
-              suspendOverlay={isPanelDragging}
-              chrome={previewChrome}
-            />
+            <div
+              className={hostMode ? 'h-full min-h-0 pointer-events-none select-none' : undefined}
+              inert={hostMode}
+              aria-disabled={hostMode || undefined}
+            >
+              <ProgramPreviewSurface
+                project={liveProject}
+                containerSize={containerSize}
+                suspendOverlay={isPanelDragging}
+                chrome={previewChrome}
+              />
+            </div>
           </div>
 
           {isPenModeActive ? (
@@ -687,7 +694,7 @@ export const PreviewArea = memo(function PreviewArea({
           ) : (
             <InteractionLockRegion locked={false} overlayClassName="rounded-none">
               <div className="flex flex-col flex-shrink-0">
-                {previewChrome === 'edit' && (
+                {previewChrome === 'edit' && !hostMode && (
                   <div className="border-t border-border panel-header flex h-7 items-center justify-center overflow-hidden px-3">
                     <div className="flex items-center gap-0">
                       <AlignmentToolbar projectSize={{ width, height }} />
diff --git a/src/features/editor/components/properties-sidebar/index.test.tsx b/src/features/editor/components/properties-sidebar/index.test.tsx
index 8ab23285f..00ddcbe06 100644
--- a/src/features/editor/components/properties-sidebar/index.test.tsx
+++ b/src/features/editor/components/properties-sidebar/index.test.tsx
@@ -4,7 +4,16 @@ import {
   useCompositionNavigationStore,
   useCompositionsStore,
   useItemsStore,
+  useTimelineSettingsStore,
 } from '@/features/editor/deps/timeline-store'
+import { HostCaptionEditorProvider } from '@/features/editor/host/caption-editor-context'
+import { EditorHostProvider } from '@/features/editor/host/context-provider'
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+} from '@/features/editor/host/contract'
+import { EmbeddedEditorHostRuntime } from '@/features/editor/host/runtime'
 import { useEditorStore } from '@/shared/state/editor'
 import { useSelectionStore } from '@/shared/state/selection'
 import type { AudioItem, VideoItem } from '@/types/timeline'
@@ -72,6 +81,27 @@ const CLIP_A_VIDEO_LINKED: VideoItem = {
   linkedGroupId: 'linked-a',
 }
 
+const HOST_CAPTION_SNAPSHOT: EmbeddedEditorSnapshot = {
+  project: {
+    id: 'host-caption-project',
+    name: 'Host captions',
+    width: 1920,
+    height: 1080,
+    fps: 30,
+  },
+  timeline: {
+    timelineId: 'host-caption-timeline',
+    revision: 0,
+    fps: 30,
+    durationInFrames: 180,
+    media: [],
+    tracks: [],
+    width: 1920,
+    height: 1080,
+  },
+  assets: [],
+}
+
 function resetStores(items: Array<VideoItem | AudioItem>, selectedItemIds: string[]) {
   useEditorStore.setState({
     rightSidebarOpen: true,
@@ -110,6 +140,36 @@ describe('PropertiesSidebar', () => {
     expect(screen.getByText('Canvas Panel')).toBeInTheDocument()
   })
 
+  it('mounts the host-backed caption editor in the properties surface', async () => {
+    resetStores([], [])
+    useTimelineSettingsStore.getState().setTimelineLoading(false)
+    const host: EditorHost = {
+      capabilities: DEFAULT_HOST_CAPABILITIES,
+      load: () => HOST_CAPTION_SNAPSHOT,
+      resolveMedia: () => null,
+      submitEdit: () => {
+        throw new Error('not used by properties mount test')
+      },
+    }
+    const runtime = new EmbeddedEditorHostRuntime(host, HOST_CAPTION_SNAPSHOT)
+
+    render(
+      <EditorHostProvider value={{ mode: 'host', capabilities: DEFAULT_HOST_CAPABILITIES, host }}>
+        <HostCaptionEditorProvider runtime={runtime}>
+          <PropertiesSidebar />
+        </HostCaptionEditorProvider>
+      </EditorHostProvider>,
+    )
+
+    expect(await screen.findByTestId('caption-editor')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Add caption track' })).toBeInTheDocument()
+    expect(
+      screen
+        .getByTestId('properties-clip-panel-host')
+        .closest('[data-host-disabled="local-properties"]'),
+    ).toHaveAttribute('inert')
+  })
+
   it('identifies the active composition when Motion has no layer selection', () => {
     resetStores([], [])
     useEditorStore.setState({ workspace: 'motion' })
diff --git a/src/features/editor/components/properties-sidebar/index.tsx b/src/features/editor/components/properties-sidebar/index.tsx
index 621c0507d..116a2d7e5 100644
--- a/src/features/editor/components/properties-sidebar/index.tsx
+++ b/src/features/editor/components/properties-sidebar/index.tsx
@@ -8,6 +8,7 @@ import {
   useMemo,
   useRef,
   useState,
+  type ReactNode,
 } from 'react'
 import { motion, useReducedMotion } from 'motion/react'
 import { useTranslation } from 'react-i18next'
@@ -23,6 +24,8 @@ import { useEditorStore } from '@/shared/state/editor'
 import { useSelectionStore } from '@/shared/state/selection'
 import type { TimelineItem } from '@/types/timeline'
 import { CanvasPanel } from './canvas-panel'
+import { HostCaptionEditor } from '@/features/editor/host/caption-editor-context'
+import { useEditorHostMode } from '@/features/editor/host/context'
 import { useSettingsStore } from '@/features/editor/deps/settings'
 import {
   EDITOR_LAYOUT_CSS_VALUES,
@@ -52,6 +55,26 @@ function PropertiesPanelLoadingFallback() {
   )
 }
 
+function HostDisabledLocalProperties({
+  disabled,
+  children,
+}: {
+  disabled: boolean
+  children: ReactNode
+}) {
+  if (!disabled) return <>{children}</>
+  return (
+    <div
+      className="relative pointer-events-none select-none opacity-60"
+      aria-disabled="true"
+      data-host-disabled="local-properties"
+      inert
+    >
+      {children}
+    </div>
+  )
+}
+
 type HeaderItem = Pick<TimelineItem, 'id' | 'label' | 'linkedGroupId' | 'type'>
 
 function buildClipHeaderGroups(items: HeaderItem[]) {
@@ -126,6 +149,7 @@ function getClipHeader(items: HeaderItem[]) {
  */
 export const PropertiesSidebar = memo(function PropertiesSidebar() {
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
   const editorDensity = useSettingsStore((s) => s.editorDensity)
   const editorLayout = getEditorLayout(editorDensity)
   // Use granular selectors - Zustand v5 best practice
@@ -303,16 +327,11 @@ export const PropertiesSidebar = memo(function PropertiesSidebar() {
                 </Button>
                 <Settings2 className="w-3 h-3 shrink-0 text-muted-foreground" />
                 <h2 className="min-w-0 flex items-center gap-1.5 text-xs font-semibold text-muted-foreground">
-                  <span className="shrink-0 uppercase tracking-wide">
-                    {headerLabel}
-                  </span>
+                  <span className="shrink-0 uppercase tracking-wide">{headerLabel}</span>
                   {headerContext && (
                     <>
                       <span className="shrink-0">-</span>
-                      <span
-                        className="truncate normal-case tracking-normal"
-                        title={headerTitle}
-                      >
+                      <span className="truncate normal-case tracking-normal" title={headerTitle}>
                         {headerContext}
                       </span>
                     </>
@@ -342,37 +361,40 @@ export const PropertiesSidebar = memo(function PropertiesSidebar() {
               }
             >
               {selectedTransitionId ? (
-                <Suspense fallback={null}>
-                  <LazyTransitionPanel />
-                </Suspense>
+                <HostDisabledLocalProperties disabled={hostMode}>
+                  <Suspense fallback={null}>
+                    <LazyTransitionPanel />
+                  </Suspense>
+                </HostDisabledLocalProperties>
               ) : selectedMarkerId ? (
-                <Suspense fallback={null}>
-                  <LazyMarkerPanel />
-                </Suspense>
+                <HostDisabledLocalProperties disabled={hostMode}>
+                  <Suspense fallback={null}>
+                    <LazyMarkerPanel />
+                  </Suspense>
+                </HostDisabledLocalProperties>
               ) : (
                 <>
-                  {/* Mount the lazy inspector before the first selection. Once
-                      its chunk resolves it stays subscribed while hidden, so a
-                      selection made during playback can commit synchronously
-                      instead of waiting for a starved Suspense retry. */}
-                  <div
-                    data-testid="properties-clip-panel-host"
-                    hidden={!hasClipSelection}
-                    className={
-                      workspace === 'motion' && clipInspectorTab === 'motion'
-                        ? 'h-full min-h-0'
-                        : undefined
-                    }
-                  >
-                    <Suspense fallback={<PropertiesPanelLoadingFallback />}>
-                      <LazyClipPanel />
-                    </Suspense>
-                  </div>
-                  {!hasClipSelection && (
-                    <div>
-                      <CanvasPanel />
+                  <HostDisabledLocalProperties disabled={hostMode}>
+                    {/* Mount the lazy inspector before the first selection. Once
+                        its chunk resolves it stays subscribed while hidden, so a
+                        selection made during playback can commit synchronously
+                        instead of waiting for a starved Suspense retry. */}
+                    <div
+                      data-testid="properties-clip-panel-host"
+                      hidden={!hasClipSelection}
+                      className={
+                        workspace === 'motion' && clipInspectorTab === 'motion'
+                          ? 'h-full min-h-0'
+                          : undefined
+                      }
+                    >
+                      <Suspense fallback={<PropertiesPanelLoadingFallback />}>
+                        <LazyClipPanel />
+                      </Suspense>
                     </div>
-                  )}
+                    {!hasClipSelection && <CanvasPanel />}
+                  </HostDisabledLocalProperties>
+                  {!hasClipSelection && hostMode ? <HostCaptionEditor /> : null}
                 </>
               )}
             </div>
diff --git a/src/features/editor/components/toolbar.tsx b/src/features/editor/components/toolbar.tsx
index 5f19cfb1b..8a9538283 100644
--- a/src/features/editor/components/toolbar.tsx
+++ b/src/features/editor/components/toolbar.tsx
@@ -1,5 +1,4 @@
-import { memo, useEffect, useMemo, useRef, useState } from 'react'
-import { useNavigate } from '@tanstack/react-router'
+import { lazy, memo, Suspense, useEffect, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
   ArrowLeft,
@@ -28,7 +27,6 @@ import {
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { Separator } from '@/components/ui/separator'
 import { LocalInferenceStatusPill } from './local-inference-status-pill'
-import { ProjectDebugPanel } from './project-debug-panel'
 import { SettingsDialog } from './settings-dialog'
 import { ShortcutsDialog } from './shortcuts-dialog'
 import { UnsavedChangesDialog } from './unsaved-changes-dialog'
@@ -41,8 +39,12 @@ import { LanguageSwitcher } from '@/shared/ui/language-switcher'
 import { useDebugStore } from '@/features/editor/stores/debug-store'
 import { useItemsStore, useTimelineStore } from '@/features/editor/deps/timeline-store'
 import { useMediaLibraryStore } from '@/features/editor/deps/media-library'
+import { useEditorHostMode } from '../host/context'
 
 const SAVE_ANIMATION_MIN_MS = 1800
+const LazyProjectDebugPanel = lazy(() =>
+  import('./project-debug-panel').then((module) => ({ default: module.ProjectDebugPanel })),
+)
 
 const SaveDirtyIndicator = memo(function SaveDirtyIndicator() {
   const isDirty = useTimelineStore((state) => state.isDirty)
@@ -68,6 +70,7 @@ interface ToolbarProps {
     fps: number
   }
   onSave?: () => Promise<void>
+  onBack?: () => void
   onExport?: () => void
   onExportBundle?: () => void
   onOpenRenderQueue?: () => void
@@ -78,14 +81,15 @@ interface ToolbarProps {
 export const Toolbar = memo(function Toolbar({
   projectId,
   project,
+  onBack,
   onSave,
   onExport,
   onExportBundle,
   onOpenRenderQueue,
   renderQueueCount = 0,
 }: ToolbarProps) {
-  const navigate = useNavigate()
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
   const [showUnsavedDialog, setShowUnsavedDialog] = useState(false)
   const [showShortcutsDialog, setShowShortcutsDialog] = useState(false)
   const [showSettingsDialog, setShowSettingsDialog] = useState(false)
@@ -98,18 +102,15 @@ export const Toolbar = memo(function Toolbar({
   const maxItemEndFrame = useItemsStore((state) => state.maxItemEndFrame)
   const mediaDependencyIds = useItemsStore((state) => state.mediaDependencyIds)
   const brokenMediaIds = useMediaLibraryStore((state) => state.brokenMediaIds)
-  const projectSummary = useMemo(
-    () => {
-      const projectMediaIds = new Set(mediaDependencyIds)
-      return {
-        durationSeconds: project.fps > 0 ? maxItemEndFrame / project.fps : 0,
-        clipCount: itemCount,
-        mediaCount: mediaDependencyIds.length,
-        brokenMediaCount: brokenMediaIds.filter((mediaId) => projectMediaIds.has(mediaId)).length,
-      }
-    },
-    [brokenMediaIds, itemCount, maxItemEndFrame, mediaDependencyIds, project.fps],
-  )
+  const projectSummary = useMemo(() => {
+    const projectMediaIds = new Set(mediaDependencyIds)
+    return {
+      durationSeconds: project.fps > 0 ? maxItemEndFrame / project.fps : 0,
+      clipCount: itemCount,
+      mediaCount: mediaDependencyIds.length,
+      brokenMediaCount: brokenMediaIds.filter((mediaId) => projectMediaIds.has(mediaId)).length,
+    }
+  }, [brokenMediaIds, itemCount, maxItemEndFrame, mediaDependencyIds, project.fps])
 
   useEffect(() => {
     setHasUnseenWhatsNew(hasUnseenChangelog())
@@ -130,10 +131,10 @@ export const Toolbar = memo(function Toolbar({
 
   const handleBackClick = () => {
     if (useTimelineStore.getState().isDirty) {
-      setShowUnsavedDialog(true)
-    } else {
-      navigate({ to: '/projects' })
+      if (onSave && onBack) setShowUnsavedDialog(true)
+      return
     }
+    onBack?.()
   }
 
   const handleSave = async () => {
@@ -178,6 +179,7 @@ export const Toolbar = memo(function Toolbar({
           size="icon"
           className="h-8 w-8"
           onClick={handleBackClick}
+          disabled={!onBack}
           data-tooltip={t('toolbar.backToProjects')}
           data-tooltip-side="right"
           aria-label={t('toolbar.backToProjectsAria')}
@@ -185,12 +187,15 @@ export const Toolbar = memo(function Toolbar({
           <ArrowLeft className="h-4 w-4" />
         </Button>
 
-        <UnsavedChangesDialog
-          open={showUnsavedDialog}
-          onOpenChange={setShowUnsavedDialog}
-          onSave={handleSave}
-          projectName={project?.name}
-        />
+        {onSave && onBack && (
+          <UnsavedChangesDialog
+            open={showUnsavedDialog}
+            onOpenChange={setShowUnsavedDialog}
+            onSave={handleSave}
+            onNavigateBack={onBack}
+            projectName={project?.name}
+          />
+        )}
 
         <Separator orientation="vertical" className="h-5" />
 
@@ -216,16 +221,18 @@ export const Toolbar = memo(function Toolbar({
         <WorkspaceSwitcher />
       </div>
 
-      <LocalInferenceStatusPill />
+      {!hostMode && <LocalInferenceStatusPill />}
 
       <ShortcutsDialog open={showShortcutsDialog} onOpenChange={setShowShortcutsDialog} />
 
-      <SettingsDialog open={showSettingsDialog} onOpenChange={setShowSettingsDialog} />
+      {!hostMode && (
+        <SettingsDialog open={showSettingsDialog} onOpenChange={setShowSettingsDialog} />
+      )}
 
       <WhatsNewDialog open={showWhatsNewDialog} onOpenChange={setShowWhatsNewDialog} />
 
       <div className="flex items-center gap-1.5">
-        {import.meta.env.DEV && import.meta.env.VITE_SHOW_DEBUG_PANEL !== 'false' && (
+        {!hostMode && import.meta.env.DEV && import.meta.env.VITE_SHOW_DEBUG_PANEL !== 'false' && (
           <DebugPopover projectId={projectId} />
         )}
 
@@ -292,6 +299,7 @@ export const Toolbar = memo(function Toolbar({
           size="icon"
           className="h-7 w-7"
           onClick={() => setShowSettingsDialog(true)}
+          disabled={hostMode}
           data-tooltip={t('toolbar.settings')}
           data-tooltip-side="bottom"
           aria-label={t('toolbar.settings')}
@@ -319,6 +327,7 @@ export const Toolbar = memo(function Toolbar({
           size="sm"
           className="gap-1.5"
           onClick={handleSave}
+          disabled={!onSave}
           aria-label={t('toolbar.saveAria')}
         >
           <div className="relative">
@@ -351,25 +360,31 @@ export const Toolbar = memo(function Toolbar({
           </Button>
         )}
 
-        <DropdownMenu>
-          <DropdownMenuTrigger asChild>
-            <Button size="sm" className="gap-1.5 glow-primary-sm">
-              <Download className="h-4 w-4" />
-              {t('toolbar.export')}
-              <ChevronDown className="h-3 w-3" />
-            </Button>
-          </DropdownMenuTrigger>
-          <DropdownMenuContent align="end">
-            <DropdownMenuItem onClick={onExport} className="gap-2">
-              <Video className="h-4 w-4" />
-              {t('toolbar.exportVideo')}
-            </DropdownMenuItem>
-            <DropdownMenuItem onClick={onExportBundle} className="gap-2">
-              <FolderArchive className="h-4 w-4" />
-              {t('toolbar.downloadProjectZip')}
-            </DropdownMenuItem>
-          </DropdownMenuContent>
-        </DropdownMenu>
+        {(onExport || onExportBundle) && (
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button size="sm" className="gap-1.5 glow-primary-sm">
+                <Download className="h-4 w-4" />
+                {t('toolbar.export')}
+                <ChevronDown className="h-3 w-3" />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end">
+              <DropdownMenuItem onClick={onExport} disabled={!onExport} className="gap-2">
+                <Video className="h-4 w-4" />
+                {t('toolbar.exportVideo')}
+              </DropdownMenuItem>
+              <DropdownMenuItem
+                onClick={onExportBundle}
+                disabled={!onExportBundle}
+                className="gap-2"
+              >
+                <FolderArchive className="h-4 w-4" />
+                {t('toolbar.downloadProjectZip')}
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        )}
       </div>
     </div>
   )
@@ -444,7 +459,9 @@ function DebugPopover({ projectId }: { projectId: string }) {
         sideOffset={8}
         className="w-64 p-0 bg-zinc-900 border-zinc-700 text-zinc-100"
       >
-        <ProjectDebugPanel projectId={projectId} />
+        <Suspense fallback={null}>
+          <LazyProjectDebugPanel projectId={projectId} />
+        </Suspense>
       </PopoverContent>
     </Popover>
   )
diff --git a/src/features/editor/components/unsaved-changes-dialog.tsx b/src/features/editor/components/unsaved-changes-dialog.tsx
index e6119ca44..fe12e67d0 100644
--- a/src/features/editor/components/unsaved-changes-dialog.tsx
+++ b/src/features/editor/components/unsaved-changes-dialog.tsx
@@ -1,5 +1,4 @@
 import { useState } from 'react'
-import { useNavigate } from '@tanstack/react-router'
 import { Trans, useTranslation } from 'react-i18next'
 import {
   AlertDialog,
@@ -21,6 +20,7 @@ interface UnsavedChangesDialogProps {
   open: boolean
   onOpenChange: (open: boolean) => void
   onSave: () => Promise<void>
+  onNavigateBack: () => void
   projectName?: string
 }
 
@@ -28,9 +28,9 @@ export function UnsavedChangesDialog({
   open,
   onOpenChange,
   onSave,
+  onNavigateBack,
   projectName,
 }: UnsavedChangesDialogProps) {
-  const navigate = useNavigate()
   const { t } = useTranslation()
   const [isSaving, setIsSaving] = useState(false)
 
@@ -39,7 +39,7 @@ export function UnsavedChangesDialog({
     try {
       await onSave()
       onOpenChange(false)
-      navigate({ to: '/projects' })
+      onNavigateBack()
     } catch (error) {
       logger.error('Failed to save project:', error)
       // Keep dialog open on error
@@ -50,7 +50,7 @@ export function UnsavedChangesDialog({
 
   const handleDiscard = () => {
     onOpenChange(false)
-    navigate({ to: '/projects' })
+    onNavigateBack()
   }
 
   return (
diff --git a/src/features/editor/components/whats-new-dialog.tsx b/src/features/editor/components/whats-new-dialog.tsx
index 0e28a81d1..5b76084bc 100644
--- a/src/features/editor/components/whats-new-dialog.tsx
+++ b/src/features/editor/components/whats-new-dialog.tsx
@@ -1,6 +1,5 @@
 import { useEffect, useMemo, useState, type ComponentType } from 'react'
 import { useTranslation } from 'react-i18next'
-import { Link } from '@tanstack/react-router'
 import { Sparkles, Bug, Zap, ArrowRight } from 'lucide-react'
 import { i18n } from '@/i18n'
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog'
@@ -134,13 +133,15 @@ export function WhatsNewDialog({ open, onOpenChange }: WhatsNewDialogProps) {
               ? t('editor.whatsNew.released', { version: latestReleaseVersion })
               : t('editor.whatsNew.preRelease')}
           </span>
-          <Link
-            to="/changelog"
+          <a
+            href="/changelog"
+            target="_blank"
+            rel="noopener noreferrer"
             className="flex items-center gap-1 hover:text-foreground hover:underline"
           >
             {t('editor.whatsNew.fullChangelog')}
             <ArrowRight className="h-3 w-3" />
-          </Link>
+          </a>
         </div>
       </DialogContent>
     </Dialog>
diff --git a/src/features/editor/components/workspace-switcher.tsx b/src/features/editor/components/workspace-switcher.tsx
index 2f458ce07..ba388b9b7 100644
--- a/src/features/editor/components/workspace-switcher.tsx
+++ b/src/features/editor/components/workspace-switcher.tsx
@@ -5,6 +5,7 @@ import type { LucideIcon } from 'lucide-react'
 import { useEditorStore } from '@/shared/state/editor'
 import { cn } from '@/shared/ui/cn'
 import type { EditorWorkspaceId } from '@/config/editor-workspaces'
+import { useEditorCapability } from '../host/context'
 
 const WORKSPACE_ITEMS: readonly {
   id: EditorWorkspaceId
@@ -25,6 +26,12 @@ export const WorkspaceSwitcher = memo(function WorkspaceSwitcher() {
   const { t } = useTranslation()
   const workspace = useEditorStore((s) => s.workspace)
   const setWorkspace = useEditorStore((s) => s.setWorkspace)
+  const canUseColor = useEditorCapability('workspace.color')
+  const canUseMotion = useEditorCapability('workspace.motion')
+  const visibleWorkspaceItems = WORKSPACE_ITEMS.filter(
+    ({ id }) =>
+      id === 'edit' || (id === 'color' && canUseColor) || (id === 'motion' && canUseMotion),
+  )
 
   return (
     <div
@@ -32,7 +39,7 @@ export const WorkspaceSwitcher = memo(function WorkspaceSwitcher() {
       aria-label={t('toolbar.workspaces.label')}
       className="flex items-center gap-0.5 rounded-md bg-muted p-0.5"
     >
-      {WORKSPACE_ITEMS.map(({ id, icon: Icon, labelKey }) => {
+      {visibleWorkspaceItems.map(({ id, icon: Icon, labelKey }) => {
         const isActive = workspace === id
         return (
           <button
diff --git a/src/features/editor/deps/media-library-contract.ts b/src/features/editor/deps/media-library-contract.ts
index 86b8120f8..718fdc7f3 100644
--- a/src/features/editor/deps/media-library-contract.ts
+++ b/src/features/editor/deps/media-library-contract.ts
@@ -7,7 +7,10 @@ export { useMediaLibraryStore } from '@/features/media-library/stores/media-libr
 export { useEmbeddedSubtitlePickerStore } from '@/features/media-library/stores/embedded-subtitle-picker-store'
 export { useSubtitleScanProgressStore } from '@/features/media-library/stores/subtitle-scan-progress-store'
 export { getSharedProxyKey } from '@/features/media-library/utils/proxy-key'
-export { resolveMediaUrl } from '@/features/media-library/utils/media-resolver'
+export {
+  installRuntimeMediaResolver,
+  resolveMediaUrl,
+} from '@/features/media-library/utils/media-resolver'
 export {
   clearMediaDragData,
   getMediaDragData,
diff --git a/src/features/editor/hooks/use-editor-hotkeys.ts b/src/features/editor/hooks/use-editor-hotkeys.ts
index b9604c972..aeb6b5ad7 100644
--- a/src/features/editor/hooks/use-editor-hotkeys.ts
+++ b/src/features/editor/hooks/use-editor-hotkeys.ts
@@ -8,6 +8,7 @@ import { useSceneBrowserStore } from '@/features/editor/deps/scene-browser'
 interface EditorHotkeyCallbacks {
   onSave?: () => void
   onExport?: () => void
+  enableLocalUi?: boolean
 }
 
 /**
@@ -24,6 +25,7 @@ interface EditorHotkeyCallbacks {
  */
 export function useEditorHotkeys(callbacks: EditorHotkeyCallbacks = {}) {
   const hotkeys = useResolvedHotkeys()
+  const enableLocalUi = callbacks.enableLocalUi ?? true
 
   // Save: Cmd/Ctrl+S
   useHotkeys(
@@ -57,11 +59,12 @@ export function useEditorHotkeys(callbacks: EditorHotkeyCallbacks = {}) {
   useHotkeys(
     hotkeys.OPEN_SCENE_BROWSER,
     (event) => {
+      if (!enableLocalUi) return
       event.preventDefault()
       useSceneBrowserStore.getState().openBrowser({ focus: true })
     },
     { ...HOTKEY_OPTIONS, eventListenerOptions: { capture: true } },
-    [],
+    [enableLocalUi],
   )
 
   // Workspace switching: Alt+1 (Edit), Alt+2 (Color), Alt+3 (Motion).
@@ -69,30 +72,33 @@ export function useEditorHotkeys(callbacks: EditorHotkeyCallbacks = {}) {
   useHotkeys(
     hotkeys.WORKSPACE_EDIT,
     (event) => {
+      if (!enableLocalUi) return
       event.preventDefault()
       useEditorStore.getState().setWorkspace('edit')
     },
     HOTKEY_OPTIONS,
-    [],
+    [enableLocalUi],
   )
 
   useHotkeys(
     hotkeys.WORKSPACE_COLOR,
     (event) => {
+      if (!enableLocalUi) return
       event.preventDefault()
       useEditorStore.getState().setWorkspace('color')
     },
     HOTKEY_OPTIONS,
-    [],
+    [enableLocalUi],
   )
 
   useHotkeys(
     hotkeys.WORKSPACE_ANIMATE,
     (event) => {
+      if (!enableLocalUi) return
       event.preventDefault()
       useEditorStore.getState().setWorkspace('motion')
     },
     HOTKEY_OPTIONS,
-    [],
+    [enableLocalUi],
   )
 }
diff --git a/src/features/editor/host/caption-editor-context.test.tsx b/src/features/editor/host/caption-editor-context.test.tsx
new file mode 100644
index 000000000..49e1cbedb
--- /dev/null
+++ b/src/features/editor/host/caption-editor-context.test.tsx
@@ -0,0 +1,129 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+import {
+  controlledDocumentToFreeCutDocument,
+  createCodePressCommandAdapter,
+  freeCutDocumentToControlledDocument,
+  type EditCommandBatch,
+} from '@/features/editor/codepress'
+import { useTimelineSettingsStore } from '@/features/editor/deps/timeline-store'
+import { HostCaptionEditor, HostCaptionEditorProvider } from './caption-editor-context'
+import { EditorHostProvider } from './context-provider'
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+  type HostEditResult,
+} from './contract'
+import { EmbeddedEditorHostRuntime } from './runtime'
+
+function snapshot(): EmbeddedEditorSnapshot {
+  return {
+    project: {
+      id: 'host-caption-project',
+      name: 'Host captions',
+      width: 1920,
+      height: 1080,
+      fps: 30,
+    },
+    timeline: {
+      timelineId: 'host-caption-timeline',
+      revision: 0,
+      fps: 30,
+      durationInFrames: 180,
+      media: [],
+      tracks: [],
+      width: 1920,
+      height: 1080,
+    },
+    assets: [],
+  }
+}
+
+function createHarness(initial: EmbeddedEditorSnapshot) {
+  const remoteAdapter = createCodePressCommandAdapter({
+    document: freeCutDocumentToControlledDocument(initial.timeline),
+  })
+  let remoteSnapshot = initial
+  const submitEdit = vi.fn(async (batch: EditCommandBatch): Promise<HostEditResult> => {
+    const result = remoteAdapter.apply(batch)
+    if (result.status === 'rejected') {
+      return {
+        status: 'rejected',
+        snapshot: remoteSnapshot,
+        result,
+      }
+    }
+    remoteSnapshot = {
+      ...remoteSnapshot,
+      timeline: controlledDocumentToFreeCutDocument(remoteAdapter.getDocument()),
+    }
+    return { status: result.status, snapshot: remoteSnapshot, result }
+  })
+  const host: EditorHost = {
+    capabilities: DEFAULT_HOST_CAPABILITIES,
+    load: () => initial,
+    resolveMedia: () => null,
+    submitEdit,
+  }
+  return { host, submitEdit, runtime: new EmbeddedEditorHostRuntime(host, initial) }
+}
+
+afterEach(() => cleanup())
+
+describe('host-backed caption editor', () => {
+  it('submits caption edits through the host controller instead of a local document', async () => {
+    useTimelineSettingsStore.getState().setTimelineLoading(false)
+    const harness = createHarness(snapshot())
+    render(
+      <EditorHostProvider
+        value={{ mode: 'host', capabilities: DEFAULT_HOST_CAPABILITIES, host: harness.host }}
+      >
+        <HostCaptionEditorProvider runtime={harness.runtime}>
+          <HostCaptionEditor />
+        </HostCaptionEditorProvider>
+      </EditorHostProvider>,
+    )
+
+    expect(await screen.findByTestId('caption-editor-empty')).toBeInTheDocument()
+    fireEvent.click(screen.getByRole('button', { name: 'Add caption track' }))
+
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Add cue' })).toBeInTheDocument())
+    expect(harness.submitEdit).toHaveBeenCalledTimes(1)
+    const trackBatch = harness.submitEdit.mock.calls[0]?.[0]
+    expect(trackBatch).toMatchObject({
+      base_revision: 0,
+      commands: [{ type: 'add_caption_track' }],
+    })
+    expect(JSON.stringify(trackBatch)).not.toContain('_us')
+
+    fireEvent.click(screen.getByRole('button', { name: 'Add cue' }))
+    await waitFor(() => expect(screen.getByTestId(/caption-cue-/)).toBeInTheDocument())
+    expect(harness.submitEdit).toHaveBeenCalledTimes(2)
+    expect(harness.submitEdit.mock.calls[1]?.[0].commands[0]).toMatchObject({
+      type: 'upsert_caption_cues',
+    })
+  })
+
+  it('shows a capability error without enabling a bespoke local fallback', async () => {
+    useTimelineSettingsStore.getState().setTimelineLoading(false)
+    const initial = snapshot()
+    const harness = createHarness(initial)
+    const capabilities = { ...DEFAULT_HOST_CAPABILITIES, 'timeline.caption': false }
+    render(
+      <EditorHostProvider value={{ mode: 'host', capabilities, host: harness.host }}>
+        <HostCaptionEditorProvider runtime={harness.runtime}>
+          <HostCaptionEditor />
+        </HostCaptionEditorProvider>
+      </EditorHostProvider>,
+    )
+
+    expect(await screen.findByTestId('caption-editor-error')).toHaveTextContent(
+      'Caption editing is unavailable for this host.',
+    )
+    expect(harness.submitEdit).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/features/editor/host/caption-editor-context.tsx b/src/features/editor/host/caption-editor-context.tsx
new file mode 100644
index 000000000..198d2fbf3
--- /dev/null
+++ b/src/features/editor/host/caption-editor-context.tsx
@@ -0,0 +1,104 @@
+import { createContext, useContext, useMemo, type ReactNode } from 'react'
+
+import {
+  CaptionEditor,
+  type CaptionCommandSubmitter,
+  type CaptionDocumentPort,
+} from '@/features/editor/codepress'
+import type { EditApplyResult, EditCommandBatch } from '@/features/editor/codepress/contract'
+import { useTimelineSettingsStore } from '@/features/editor/deps/timeline-store'
+import { usePlaybackStore } from '@/shared/state/playback'
+import { useEditorCapability } from './context'
+import { hostSnapshotToControlledDocument } from './document'
+import { EmbeddedEditorHostRuntime } from './runtime'
+
+interface HostCaptionEditorValue {
+  adapter: CaptionDocumentPort
+  submit: CaptionCommandSubmitter
+}
+
+const HostCaptionEditorContext = createContext<HostCaptionEditorValue | null>(null)
+
+function unsupportedResult(batch: EditCommandBatch, message: string): EditApplyResult {
+  return {
+    status: 'rejected',
+    timeline_id: batch.timeline_id,
+    operation_id: batch.operation_id,
+    idempotency_key: batch.idempotency_key,
+    base_revision: batch.base_revision,
+    error: {
+      code: 'unsupported_command',
+      message,
+      retryable: false,
+      operation_id: batch.operation_id,
+      details: { kind: 'generic', reason: message },
+    },
+  }
+}
+
+function createHostCaptionEditorValue(runtime: EmbeddedEditorHostRuntime): HostCaptionEditorValue {
+  const adapter: CaptionDocumentPort = {
+    getSnapshot() {
+      const document = runtime.controller.getDocument()
+      return { document, revision: document.timeline.revision }
+    },
+    subscribe(listener) {
+      return runtime.controller.subscribe((snapshot) => {
+        listener(hostSnapshotToControlledDocument(snapshot))
+      })
+    },
+  }
+
+  const submit: CaptionCommandSubmitter = async (batch) => {
+    const result = await runtime.controller.submitEdit(batch)
+    if (result.status === 'unsupported') return unsupportedResult(batch, result.reason)
+    return result.result
+  }
+
+  return { adapter, submit }
+}
+
+export function HostCaptionEditorProvider({
+  runtime,
+  children,
+}: {
+  runtime: EmbeddedEditorHostRuntime
+  children: ReactNode
+}) {
+  const value = useMemo(() => createHostCaptionEditorValue(runtime), [runtime])
+  return (
+    <HostCaptionEditorContext.Provider value={value}>{children}</HostCaptionEditorContext.Provider>
+  )
+}
+
+function useHostCaptionEditorValue(): HostCaptionEditorValue | null {
+  return useContext(HostCaptionEditorContext)
+}
+
+/**
+ * Caption UI mounted inside the merged host-backed surface. It reads the
+ * controller's authoritative document and submits the same host command path;
+ * it never invents a project, duration, adapter, or persistence store.
+ */
+export function HostCaptionEditor() {
+  const value = useHostCaptionEditorValue()
+  const canEdit = useEditorCapability('timeline.caption')
+  const currentFrame = usePlaybackStore((state) => state.currentFrame)
+  const setCurrentFrame = usePlaybackStore((state) => state.setCurrentFrame)
+  const loading = useTimelineSettingsStore((state) => state.isTimelineLoading)
+
+  if (!value) return null
+
+  return (
+    <div className="mt-4 border-t border-border pt-4" data-testid="editor-caption-host">
+      <CaptionEditor
+        adapter={value.adapter}
+        submit={canEdit ? value.submit : undefined}
+        currentFrame={currentFrame}
+        loading={loading}
+        error={canEdit ? undefined : 'Caption editing is unavailable for this host.'}
+        onSeek={setCurrentFrame}
+      />
+    </div>
+  )
+}
diff --git a/src/features/editor/host/context-provider.tsx b/src/features/editor/host/context-provider.tsx
new file mode 100644
index 000000000..1a7315517
--- /dev/null
+++ b/src/features/editor/host/context-provider.tsx
@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react'
+import { EditorHostContext, type EditorHostContextValue } from './context'
+
+export interface EditorHostProviderProps {
+  value: EditorHostContextValue
+  children: ReactNode
+}
+
+export function EditorHostProvider({ value, children }: EditorHostProviderProps) {
+  return <EditorHostContext.Provider value={value}>{children}</EditorHostContext.Provider>
+}
diff --git a/src/features/editor/host/context.ts b/src/features/editor/host/context.ts
new file mode 100644
index 000000000..9e8e769d9
--- /dev/null
+++ b/src/features/editor/host/context.ts
@@ -0,0 +1,33 @@
+import { createContext, useContext } from 'react'
+import {
+  isHostCapabilityEnabled,
+  type EditorCapability,
+  type EditorCapabilityMap,
+  type EditorHost,
+} from './contract'
+
+export interface EditorHostContextValue {
+  mode: 'local' | 'host'
+  capabilities: EditorCapabilityMap
+  host?: EditorHost
+}
+
+const localContext: EditorHostContextValue = {
+  mode: 'local',
+  capabilities: {},
+}
+
+export const EditorHostContext = createContext<EditorHostContextValue>(localContext)
+
+export function useEditorHostContext(): EditorHostContextValue {
+  return useContext(EditorHostContext)
+}
+
+export function useEditorHostMode(): boolean {
+  return useEditorHostContext().mode === 'host'
+}
+
+export function useEditorCapability(capability: EditorCapability): boolean {
+  const { mode, capabilities } = useEditorHostContext()
+  return mode === 'local' || isHostCapabilityEnabled(capabilities, capability)
+}
diff --git a/src/features/editor/host/contract.ts b/src/features/editor/host/contract.ts
new file mode 100644
index 000000000..53d7fb2f7
--- /dev/null
+++ b/src/features/editor/host/contract.ts
@@ -0,0 +1,369 @@
+import type {
+  EditApplyResult,
+  EditCommandBatch,
+  EditCommand,
+  Microseconds,
+  Precondition,
+  TimelineRevision,
+} from '@/features/editor/codepress/contract'
+import type { FreeCutFrameDocument } from '@/features/editor/codepress/document'
+
+/**
+ * The browser surface is deliberately a port.  It knows how to render and
+ * translate a bounded editor command, but it does not know how the host
+ * authenticates, stores, or transports that command.
+ */
+export type EditorCapability =
+  | 'project.navigate'
+  | 'project.save'
+  | 'media.resolve'
+  | 'media.import'
+  | 'media.delete'
+  | 'media.proxy'
+  | 'media.transcription'
+  | 'media.relink'
+  | 'timeline.add'
+  | 'timeline.move'
+  | 'timeline.trim'
+  | 'timeline.split'
+  | 'timeline.remove'
+  | 'timeline.track'
+  | 'timeline.caption'
+  | 'workspace.edit'
+  | 'workspace.color'
+  | 'workspace.motion'
+  | 'export.video'
+  | 'export.bundle'
+  | 'render.queue'
+
+export type EditorCapabilityMap = Readonly<Partial<Record<EditorCapability, boolean>>>
+
+export const DEFAULT_HOST_CAPABILITIES: EditorCapabilityMap = {
+  'project.navigate': false,
+  'project.save': false,
+  'media.resolve': true,
+  'media.import': false,
+  'media.delete': false,
+  'media.proxy': false,
+  'media.transcription': false,
+  'media.relink': false,
+  'timeline.add': true,
+  'timeline.move': true,
+  'timeline.trim': true,
+  'timeline.split': true,
+  'timeline.remove': true,
+  'timeline.track': true,
+  'timeline.caption': true,
+  'workspace.edit': true,
+  'workspace.color': false,
+  'workspace.motion': false,
+  'export.video': false,
+  'export.bundle': false,
+  'render.queue': false,
+}
+
+export type HostMediaKind = 'video' | 'audio' | 'image' | 'lottie'
+
+/** Opaque control-plane reference.  It never contains a path, URL, or bytes. */
+export interface MediaLocator {
+  mediaId: string
+  kind: HostMediaKind
+  variant?: 'source' | 'proxy' | 'thumbnail'
+}
+
+/** Runtime-only result of resolving a locator.  It must never enter a snapshot. */
+export interface ResolvedMediaLocator {
+  source: string
+  audioSource?: string
+  expiresAt?: number
+}
+
+export interface EmbeddedEditorProject {
+  id: string
+  name: string
+  width: number
+  height: number
+  fps: number
+  backgroundColor?: string
+}
+
+/** Asset metadata is descriptive and path-free; playback is a separate port. */
+export interface EmbeddedEditorAsset {
+  id: string
+  kind: HostMediaKind
+  fileName: string
+  mimeType: string
+  durationSeconds: number
+  width: number
+  height: number
+  fps: number
+  fileSize?: number
+  contentHash?: string
+  thumbnailLocator?: MediaLocator
+}
+
+export interface EmbeddedEditorSnapshot {
+  project: EmbeddedEditorProject
+  timeline: FreeCutFrameDocument
+  assets: readonly EmbeddedEditorAsset[]
+}
+
+export interface HostNotice {
+  kind: 'info' | 'warning' | 'error' | 'unsupported' | 'conflict'
+  message: string
+  operationId?: string
+}
+
+/** Maximum section/range selection accepted by the PR9B transcript adapter. */
+export const MAX_TRANSCRIPT_SELECTIONS = 64
+/** The backend exposes at most this many sections per bounded page. */
+export const MAX_TRANSCRIPT_SECTION_PAGE_SIZE = 50
+/** Maximum UTF-8 bytes accepted for one bounded transcript section. */
+export const MAX_TRANSCRIPT_SECTION_TEXT_BYTES = 4_000
+/** Maximum UTF-8 bytes accepted for one generated transcript command. */
+export const MAX_TRANSCRIPT_COMMAND_TEXT_BYTES = 64 * 1024
+/** Maximum source duration representable by a transcript command selection. */
+export const MAX_TRANSCRIPT_DURATION_US = 3_600_000_000
+/** Maximum cursor/query payload size accepted by the browser port. */
+export const MAX_TRANSCRIPT_CURSOR_LENGTH = 256
+export const MAX_TRANSCRIPT_QUERY_LENGTH = 256
+
+export type HostTranscriptStatus =
+  | 'pending'
+  | 'running'
+  | 'succeeded'
+  | 'failed'
+  | 'stale'
+  | 'purged'
+
+/** Safe, structured transcript failure information from the application host. */
+export interface HostTranscriptError {
+  code: string
+  message: string
+  retryable: boolean
+  details?: Readonly<Record<string, unknown>>
+}
+
+/**
+ * Compact source-bound transcript receipt.  The host owns authorization and
+ * transport; FreeCut receives only opaque IDs, a source hash, status, and
+ * bounded recovery information.
+ */
+export interface HostTranscriptStatusReceipt {
+  transcriptId: string
+  assetId: string | null
+  sourceAssetHash: string
+  status: HostTranscriptStatus
+  language?: string | null
+  durationUs: Microseconds | null
+  sectionCount: number
+  error?: HostTranscriptError | null
+}
+
+/** One bounded, source-addressable transcript section. */
+export interface HostTranscriptSection {
+  id: string
+  transcriptId: string
+  ordinal: number
+  startUs: Microseconds
+  endUs: Microseconds
+  text: string
+  speaker?: string | null
+}
+
+export interface HostTranscriptSectionsRequest {
+  transcriptId: string
+  cursor?: string | null
+  limit?: number
+  startUs?: Microseconds
+  endUs?: Microseconds
+}
+
+export interface HostTranscriptSectionsPage {
+  transcriptId: string
+  sections: readonly HostTranscriptSection[]
+  nextCursor?: string | null
+  hasMore: boolean
+}
+
+export interface HostTranscriptSearchRequest {
+  transcriptId: string
+  query: string
+  cursor?: string | null
+  limit?: number
+}
+
+export interface HostTranscriptSearchPage {
+  transcriptId: string
+  query: string
+  sections: readonly HostTranscriptSection[]
+  nextCursor?: string | null
+  hasMore: boolean
+}
+
+/** A positive integer-microsecond source range selected for preview. */
+export interface HostTranscriptRange {
+  startUs: Microseconds
+  endUs: Microseconds
+  text?: string
+}
+
+export type HostTranscriptCommandAction = 'cut' | 'captions' | 'ripple_cut' | 'caption'
+
+/** PR9B request shape.  It previews only; it never mutates the host timeline. */
+export interface HostTranscriptCommandPreviewRequest {
+  transcriptId: string
+  assetId: string
+  sourceAssetHash: string
+  operationId: string
+  idempotencyKey: string
+  baseRevision: TimelineRevision
+  action: HostTranscriptCommandAction
+  timestampCapability: 'section' | 'word' | 'frame'
+  sectionIds?: readonly string[]
+  ranges?: readonly HostTranscriptRange[]
+  captionTrackId?: string
+  captionTrackName?: string
+  captionLanguage?: string | null
+  preconditions?: readonly Precondition[]
+}
+
+export interface HostTranscriptCommandPreview {
+  status: 'preview' | 'replayed'
+  receiptId: string
+  transcriptId: string
+  assetId: string
+  sourceAssetHash: string
+  timestampCapability: 'section'
+  timelineId: string
+  operationId: string
+  idempotencyKey: string
+  baseRevision: TimelineRevision
+  commandBatch: EditCommandBatch
+  preview: Readonly<{
+    action?: string
+    sectionCount?: number
+    captionCount?: number
+    willMutateTimeline: false
+    [key: string]: unknown
+  }>
+}
+
+/**
+ * Optional host-backed transcript consumer port.  Implementations may use an
+ * authenticated API, desktop bridge, or another application-owned transport;
+ * those details never enter the FreeCut surface.
+ */
+export interface EditorTranscriptPort {
+  getStatus(): Promise<HostTranscriptStatusReceipt | null> | HostTranscriptStatusReceipt | null
+  getSections(
+    request: HostTranscriptSectionsRequest,
+  ): Promise<HostTranscriptSectionsPage> | HostTranscriptSectionsPage
+  search?(
+    request: HostTranscriptSearchRequest,
+  ): Promise<HostTranscriptSearchPage> | HostTranscriptSearchPage
+  previewCommands(
+    request: HostTranscriptCommandPreviewRequest,
+  ): Promise<HostTranscriptCommandPreview> | HostTranscriptCommandPreview
+}
+
+export interface HostAppliedEditResult {
+  status: 'applied' | 'replayed'
+  snapshot: EmbeddedEditorSnapshot
+  result: Extract<EditApplyResult, { status: 'applied' | 'replayed' }>
+}
+
+export interface HostConflictResult {
+  status: 'conflict' | 'rejected'
+  snapshot: EmbeddedEditorSnapshot
+  result: Extract<EditApplyResult, { status: 'rejected' }>
+}
+
+export type HostEditResult = HostAppliedEditResult | HostConflictResult
+
+export interface EditorHostNavigation {
+  back(): void
+}
+
+export interface EditorHost {
+  readonly capabilities: EditorCapabilityMap
+  load(): Promise<EmbeddedEditorSnapshot> | EmbeddedEditorSnapshot
+  resolveMedia(
+    locator: MediaLocator,
+  ): Promise<ResolvedMediaLocator | null> | ResolvedMediaLocator | null
+  submitEdit(batch: EditCommandBatch): Promise<HostEditResult> | HostEditResult
+  /** Optional application-issued transcript read/preview boundary. */
+  transcript?: EditorTranscriptPort
+  navigation?: EditorHostNavigation
+  notify?(notice: HostNotice): void
+}
+
+/** Commands the first host surface can translate without guessing. */
+export const SUPPORTED_HOST_COMMANDS = [
+  'add_clip',
+  'add_text',
+  'move_item',
+  'trim_item',
+  'split_item',
+  'remove_item',
+  'add_track',
+  'update_track',
+  'add_caption_track',
+  'remove_caption_track',
+  'update_caption_track',
+  'upsert_caption_cues',
+  'remove_caption_cues',
+  'set_caption_style',
+] as const satisfies readonly EditCommand['type'][]
+
+export function capabilityForCommand(command: EditCommand['type']): EditorCapability | null {
+  switch (command) {
+    case 'add_clip':
+    case 'add_text':
+      return 'timeline.add'
+    case 'move_item':
+      return 'timeline.move'
+    case 'trim_item':
+      return 'timeline.trim'
+    case 'split_item':
+      return 'timeline.split'
+    case 'remove_item':
+      return 'timeline.remove'
+    case 'add_track':
+      return 'timeline.track'
+    case 'update_track':
+    case 'add_caption_track':
+    case 'remove_caption_track':
+    case 'update_caption_track':
+    case 'upsert_caption_cues':
+    case 'remove_caption_cues':
+    case 'set_caption_style':
+      return 'timeline.caption'
+    default:
+      return null
+  }
+}
+
+export function isHostCapabilityEnabled(
+  capabilities: EditorCapabilityMap,
+  capability: EditorCapability,
+): boolean {
+  return capabilities[capability] === true
+}
+
+/**
+ * Small adapter useful for a standalone host or a later CodePress host.  The
+ * adapter only normalizes optional callbacks; it does not introduce storage,
+ * HTTP, authentication, or media-byte dependencies.
+ */
+export type LocalEditorHostOptions = Omit<EditorHost, 'capabilities'> & {
+  capabilities?: EditorCapabilityMap
+}
+
+export function createLocalEditorHost(options: LocalEditorHostOptions): EditorHost {
+  const { capabilities = {}, ...callbacks } = options
+  return {
+    ...callbacks,
+    capabilities,
+  }
+}
diff --git a/src/features/editor/host/controller.test.ts b/src/features/editor/host/controller.test.ts
new file mode 100644
index 000000000..91963a3b2
--- /dev/null
+++ b/src/features/editor/host/controller.test.ts
@@ -0,0 +1,440 @@
+// @vitest-environment node
+
+import { readFileSync } from 'node:fs'
+import { describe, expect, it, vi } from 'vite-plus/test'
+import {
+  controlledDocumentToFreeCutDocument,
+  createCodePressCommandAdapter,
+  freeCutDocumentToControlledDocument,
+  type EditCommandBatch,
+  type MediaReference,
+} from '@/features/editor/codepress'
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  SUPPORTED_HOST_COMMANDS,
+  capabilityForCommand,
+  createLocalEditorHost,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+  type HostEditResult,
+  type MediaLocator,
+} from './contract'
+import { HostEditorController, deriveSupportedHostEdit } from './controller'
+import { hostSnapshotToNativeTimeline, nativeTimelineToFrameDocument } from './document'
+import { EmbeddedEditorHostRuntime } from './runtime'
+import { useMediaLibraryStore } from '@/features/editor/deps/media-library'
+import { useTimelineStore } from '@/features/editor/deps/timeline-store'
+
+const mediaReference: MediaReference = {
+  media_id: 'media-1',
+  media_kind: 'video',
+  content_hash: 'sha256:media-1',
+  duration_us: 10_000_000,
+  availability: { mode: 'cloud', cloud: { object_id: 'opaque-media-object-1' } },
+}
+
+function snapshot(
+  overrides: Partial<EmbeddedEditorSnapshot['timeline']> = {},
+): EmbeddedEditorSnapshot {
+  return {
+    project: {
+      id: 'project-1',
+      name: 'Host project',
+      width: 1920,
+      height: 1080,
+      fps: 30,
+      backgroundColor: '#000000',
+    },
+    timeline: {
+      timelineId: 'timeline-1',
+      revision: 0,
+      fps: 30,
+      durationInFrames: 300,
+      media: [mediaReference],
+      tracks: [
+        {
+          id: 'track-1',
+          kind: 'video',
+          name: 'Video 1',
+          locked: false,
+          muted: false,
+          items: [
+            {
+              type: 'video',
+              id: 'clip-1',
+              trackId: 'track-1',
+              mediaId: 'media-1',
+              from: 0,
+              durationInFrames: 60,
+              sourceStart: 0,
+              sourceEnd: 60,
+            },
+          ],
+        },
+      ],
+      width: 1920,
+      height: 1080,
+      backgroundColor: '#000000',
+      ...overrides,
+    },
+    assets: [
+      {
+        id: 'media-1',
+        kind: 'video',
+        fileName: 'host-video.mp4',
+        mimeType: 'video/mp4',
+        durationSeconds: 10,
+        width: 1920,
+        height: 1080,
+        fps: 30,
+        contentHash: 'sha256:media-1',
+      },
+    ],
+  }
+}
+
+function movedSnapshot(): EmbeddedEditorSnapshot {
+  const base = snapshot()
+  const [track] = base.timeline.tracks
+  return {
+    ...base,
+    timeline: {
+      ...base.timeline,
+      tracks: [
+        {
+          ...track!,
+          items: [{ ...track!.items[0]!, from: 30 }],
+        },
+      ],
+    },
+  }
+}
+
+interface FakeHostHarness {
+  host: EditorHost
+  submitEdit: ReturnType<typeof vi.fn>
+  remoteAdapter: ReturnType<typeof createCodePressCommandAdapter>
+  getRemoteSnapshot: () => EmbeddedEditorSnapshot
+}
+
+function createFakeHost(
+  initial: EmbeddedEditorSnapshot,
+  capabilities: EditorHost['capabilities'] = DEFAULT_HOST_CAPABILITIES,
+): FakeHostHarness {
+  const remoteAdapter = createCodePressCommandAdapter({
+    document: freeCutDocumentToControlledDocument(initial.timeline),
+  })
+  let remoteSnapshot = initial
+  const submitEdit = vi.fn(async (batch: EditCommandBatch): Promise<HostEditResult> => {
+    const result = remoteAdapter.apply(batch)
+    if (result.status === 'rejected') {
+      return {
+        status: result.error.code === 'revision_conflict' ? 'conflict' : 'rejected',
+        snapshot: remoteSnapshot,
+        result,
+      }
+    }
+
+    remoteSnapshot = {
+      ...remoteSnapshot,
+      timeline: controlledDocumentToFreeCutDocument(remoteAdapter.getDocument()),
+    }
+    return { status: result.status, snapshot: remoteSnapshot, result }
+  })
+  const host: EditorHost = {
+    capabilities,
+    load: () => initial,
+    resolveMedia: vi.fn(async (locator: MediaLocator) => ({
+      source: `https://host.invalid/media/${locator.mediaId}`,
+      expiresAt: 123,
+    })),
+    submitEdit,
+  }
+  return { host, submitEdit, remoteAdapter, getRemoteSnapshot: () => remoteSnapshot }
+}
+
+function commandForMove(initial: EmbeddedEditorSnapshot): EditCommandBatch {
+  const derived = deriveSupportedHostEdit(initial.timeline, movedSnapshot().timeline, {
+    operationId: 'operation-move-1',
+    idempotencyKey: 'idempotency-move-1',
+  })
+  expect(derived.batch).not.toBeNull()
+  return derived.batch!
+}
+
+describe('embedded FreeCut host controller', () => {
+  it('loads a fake-host snapshot and resolves an opaque media locator', async () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial, {})
+    const loaded = await harness.host.load()
+    const controller = new HostEditorController(harness.host, loaded)
+    const locator: MediaLocator = { mediaId: 'media-1', kind: 'video', variant: 'source' }
+
+    expect(controller.getSnapshot().project.id).toBe('project-1')
+    await expect(controller.resolveMedia(locator)).resolves.toMatchObject({
+      source: 'https://host.invalid/media/media-1',
+    })
+    expect(harness.host.resolveMedia).toHaveBeenCalledWith(locator)
+    expect(hostSnapshotToNativeTimeline(initial).items[0]).toMatchObject({
+      mediaId: 'media-1',
+      src: '',
+    })
+  })
+
+  it('keeps caption styles and caption-role items on the host-backed native bridge', () => {
+    const initial = snapshot({
+      tracks: [
+        {
+          id: 'caption-track',
+          kind: 'caption',
+          name: 'English',
+          language: 'en',
+          locked: false,
+          muted: false,
+          defaultStyle: { font_family: 'Inter', background_opacity: 0.6 },
+          items: [
+            {
+              type: 'caption_cue',
+              id: 'caption-cue',
+              trackId: 'caption-track',
+              from: 10,
+              durationInFrames: 30,
+              text: 'Hello host',
+              style: { font_size: 48, alignment: 'center', background_opacity: 0.35 },
+            },
+          ],
+        },
+      ],
+    })
+    const native = hostSnapshotToNativeTimeline(initial)
+    expect(native.items[0]).toMatchObject({
+      type: 'text',
+      textRole: 'caption',
+      fontSize: 48,
+      textAlign: 'center',
+      backgroundOpacity: 0.35,
+    })
+
+    const converted = nativeTimelineToFrameDocument(
+      { tracks: native.tracks, items: native.items, fps: native.fps },
+      initial.timeline,
+    )
+    expect(converted).toMatchObject({ ok: true })
+    if (!converted.ok) return
+    expect(converted.document.tracks[0]).toMatchObject({
+      kind: 'caption',
+      defaultStyle: { font_family: 'Inter', background_opacity: 0.6 },
+    })
+    expect(converted.document.tracks[0]?.items[0]).toMatchObject({
+      type: 'caption_cue',
+      id: 'caption-cue',
+      from: 10,
+      durationInFrames: 30,
+      style: { background_opacity: 0.35 },
+    })
+    expect(capabilityForCommand('set_caption_style')).toBe('timeline.caption')
+  })
+
+  it('submits a supported edit and replaces state with the authoritative revision', async () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial)
+    const controller = new HostEditorController(harness.host, initial)
+    const batch = commandForMove(initial)
+
+    const result = await controller.submitEdit(batch)
+
+    expect(result.status).toBe('applied')
+    expect(harness.submitEdit).toHaveBeenCalledWith(batch)
+    expect(controller.getSnapshot().timeline.revision).toBe(1)
+    expect(controller.getSnapshot().timeline.tracks[0]!.items[0]).toMatchObject({ from: 30 })
+  })
+
+  it('keeps transformed clip moves supported across native transform key names', () => {
+    const base = snapshot()
+    const track = base.timeline.tracks[0]!
+    const transformed = {
+      ...base,
+      timeline: {
+        ...base.timeline,
+        tracks: [
+          {
+            ...track,
+            items: [
+              {
+                ...track.items[0]!,
+                transform: {
+                  position_x: 12,
+                  position_y: -8,
+                  scale_x: 1,
+                  scale_y: 1,
+                  rotation_degrees: 0,
+                  anchor_x: 0,
+                  anchor_y: 0,
+                },
+              },
+            ],
+          },
+        ],
+      },
+    }
+    const next = {
+      ...transformed,
+      timeline: {
+        ...transformed.timeline,
+        tracks: [
+          {
+            ...transformed.timeline.tracks[0]!,
+            items: [{ ...transformed.timeline.tracks[0]!.items[0]!, from: 30 }],
+          },
+        ],
+      },
+    }
+
+    expect(
+      deriveSupportedHostEdit(transformed.timeline, next.timeline, {
+        operationId: 'operation-transformed-move',
+        idempotencyKey: 'idempotency-transformed-move',
+      }).batch?.commands[0]?.type,
+    ).toBe('move_item')
+  })
+
+  it('supports authoritative replacement and idempotent replay', async () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial)
+    const controller = new HostEditorController(harness.host, initial)
+    const batch = commandForMove(initial)
+
+    await expect(controller.submitEdit(batch)).resolves.toMatchObject({ status: 'applied' })
+    await expect(controller.submitEdit(batch)).resolves.toMatchObject({ status: 'replayed' })
+
+    const replacement = {
+      ...initial,
+      timeline: { ...initial.timeline, revision: 17, durationInFrames: 600 },
+    }
+    controller.replaceAuthoritativeSnapshot(replacement)
+    expect(controller.getSnapshot().timeline.revision).toBe(17)
+    expect(controller.getDocument().timeline.revision).toBe(17)
+  })
+
+  it('returns a conflict and adopts the host snapshot when the remote revision is stale', async () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial)
+    const remoteChange = harness.remoteAdapter.apply({
+      contract_version: 1,
+      timeline_id: 'timeline-1',
+      operation_id: 'remote-change',
+      idempotency_key: 'remote-change-idem',
+      base_revision: 0,
+      preconditions: [],
+      commands: [
+        {
+          command_id: 'remote-move',
+          type: 'move_item',
+          item_id: 'clip-1',
+          to_track_id: 'track-1',
+          timeline_start_us: 1_000_000,
+          index: 0,
+        },
+      ],
+    })
+    expect(remoteChange.status).toBe('applied')
+    const conflictSnapshot = {
+      ...initial,
+      timeline: {
+        ...initial.timeline,
+        revision: 1,
+        tracks: [
+          {
+            ...initial.timeline.tracks[0]!,
+            items: [{ ...initial.timeline.tracks[0]!.items[0]!, from: 30 }],
+          },
+        ],
+      },
+    }
+    harness.submitEdit.mockImplementation(async (batch: EditCommandBatch) => {
+      const result = harness.remoteAdapter.apply(batch)
+      if (result.status !== 'rejected') throw new Error('expected stale remote revision')
+      return { status: 'conflict', snapshot: conflictSnapshot, result }
+    })
+    const controller = new HostEditorController(harness.host, initial)
+    const result = await controller.submitEdit(commandForMove(initial))
+
+    expect(result.status).toBe('conflict')
+    expect(controller.getSnapshot().timeline.revision).toBe(1)
+    expect(controller.getSnapshot().timeline.tracks[0]!.items[0]).toMatchObject({ from: 30 })
+  })
+
+  it('gates unsupported capabilities before calling the host', async () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial, {
+      ...DEFAULT_HOST_CAPABILITIES,
+      'timeline.move': false,
+    })
+    const controller = new HostEditorController(harness.host, initial)
+
+    const result = await controller.submitEdit(commandForMove(initial))
+
+    expect(result.status).toBe('unsupported')
+    expect(harness.submitEdit).not.toHaveBeenCalled()
+    expect(controller.getSnapshot().timeline.revision).toBe(0)
+  })
+
+  it('keeps host mode outside local persistence and blob-url acquisition', async () => {
+    const runtimeSource = readFileSync(new URL('./runtime.ts', import.meta.url), 'utf8')
+    expect(runtimeSource).not.toMatch(
+      /\b(loadTimeline|saveTimeline|loadMediaItems|getProject|updateProject)\b/,
+    )
+
+    const { installRuntimeMediaResolver, resolveMediaUrl } =
+      await import('@/features/editor/deps/media-library')
+    const createObjectUrl = vi.spyOn(URL, 'createObjectURL')
+    const cleanup = installRuntimeMediaResolver((mediaId) => `https://host.invalid/${mediaId}`)
+    await expect(resolveMediaUrl('media-1')).resolves.toBe('https://host.invalid/media-1')
+    expect(createObjectUrl).not.toHaveBeenCalled()
+    cleanup()
+    createObjectUrl.mockRestore()
+  })
+
+  it('mounts host stores without invoking local project or timeline loaders', () => {
+    const initial = snapshot()
+    const harness = createFakeHost(initial)
+    const loadTimeline = vi.spyOn(useTimelineStore.getState(), 'loadTimeline')
+    const loadMediaItems = vi.spyOn(useMediaLibraryStore.getState(), 'loadMediaItems')
+    const runtime = new EmbeddedEditorHostRuntime(harness.host, initial)
+
+    runtime.mountStores()
+    runtime.unmountStores()
+
+    expect(loadTimeline).not.toHaveBeenCalled()
+    expect(loadMediaItems).not.toHaveBeenCalled()
+    loadTimeline.mockRestore()
+    loadMediaItems.mockRestore()
+  })
+
+  it('keeps the public host adapter bounded to the supported command slice', () => {
+    expect(SUPPORTED_HOST_COMMANDS).toEqual([
+      'add_clip',
+      'add_text',
+      'move_item',
+      'trim_item',
+      'split_item',
+      'remove_item',
+      'add_track',
+      'update_track',
+      'add_caption_track',
+      'remove_caption_track',
+      'update_caption_track',
+      'upsert_caption_cues',
+      'remove_caption_cues',
+      'set_caption_style',
+    ])
+    const adapter = createLocalEditorHost({
+      load: () => snapshot(),
+      resolveMedia: () => null,
+      submitEdit: () => {
+        throw new Error('not used')
+      },
+    })
+    expect(adapter.capabilities).toEqual({})
+  })
+})
diff --git a/src/features/editor/host/controller.ts b/src/features/editor/host/controller.ts
new file mode 100644
index 000000000..e96318ba9
--- /dev/null
+++ b/src/features/editor/host/controller.ts
@@ -0,0 +1,476 @@
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  capabilityForCommand,
+  isHostCapabilityEnabled,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+  type HostEditResult,
+  type HostNotice,
+  type MediaLocator,
+  type ResolvedMediaLocator,
+} from './contract'
+import {
+  createCodePressCommandAdapter,
+  type EditCommand,
+  type EditCommandBatch,
+  type FreeCutFrameDocument,
+  type FreeCutFrameItem,
+  type Precondition,
+} from '@/features/editor/codepress'
+import { framesToMicroseconds, type FrameRateLike } from '@/features/editor/codepress/timing'
+import { freeCutDocumentToControlledDocument } from '@/features/editor/codepress/document'
+import type { ControlledEditorDocument } from '@/features/editor/codepress/interfaces'
+import { hostSnapshotToControlledDocument } from './document'
+
+export type HostControllerResult =
+  | HostEditResult
+  | {
+      status: 'unsupported'
+      snapshot: EmbeddedEditorSnapshot
+      reason: string
+    }
+
+function clone<T>(value: T): T {
+  if (typeof structuredClone === 'function') return structuredClone(value)
+  return JSON.parse(JSON.stringify(value)) as T
+}
+
+function stableSerialize(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableSerialize).join(',')}]`
+  if (value && typeof value === 'object') {
+    return `{${Object.entries(value as Record<string, unknown>)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`)
+      .join(',')}}`
+  }
+  return JSON.stringify(value)
+}
+
+function itemMap(
+  document: FreeCutFrameDocument,
+): Map<string, FreeCutFrameDocument['tracks'][number]['items'][number]> {
+  return new Map(
+    document.tracks.flatMap((track) => track.items.map((item) => [item.id, item] as const)),
+  )
+}
+
+type FrameClip = Extract<FreeCutFrameItem, { type: 'video' | 'audio' | 'image' }>
+
+function isFrameClip(item: FreeCutFrameItem): item is FrameClip {
+  return item.type === 'video' || item.type === 'audio' || item.type === 'image'
+}
+
+function sourceBounds(item: FrameClip): [number, number] {
+  const start = item.sourceStart ?? item.from
+  return [start, item.sourceEnd ?? start + item.durationInFrames]
+}
+
+function trackIndex(document: FreeCutFrameDocument, trackId: string): number {
+  return Math.max(
+    0,
+    document.tracks.findIndex((track) => track.id === trackId),
+  )
+}
+
+function itemLocation(document: FreeCutFrameDocument, itemIdToFind: string) {
+  for (const track of document.tracks) {
+    const index = track.items.findIndex((item) => item.id === itemIdToFind)
+    if (index >= 0) return { track, index }
+  }
+  return null
+}
+
+function preconditionForItem(
+  item: FreeCutFrameDocument['tracks'][number]['items'][number],
+  fps: FrameRateLike,
+): Precondition {
+  if (item.type === 'caption_cue') {
+    return {
+      type: 'caption_cue_at',
+      track_id: item.trackId,
+      cue_id: item.id,
+      start_us: framesToMicroseconds(item.from, fps),
+      end_us: framesToMicroseconds(item.from + item.durationInFrames, fps),
+      text: item.text,
+    }
+  }
+  return {
+    type: 'item_at',
+    item_id: item.id,
+    track_id: item.trackId,
+    timeline_start_us: framesToMicroseconds(item.from, fps),
+    timeline_end_us: framesToMicroseconds(item.from + item.durationInFrames, fps),
+  }
+}
+
+function withoutPosition(item: unknown): unknown {
+  if (!item || typeof item !== 'object') return item
+  const copy = { ...(item as Record<string, unknown>) }
+  delete copy.trackId
+  delete copy.from
+  delete copy.durationInFrames
+  delete copy.sourceStart
+  delete copy.sourceEnd
+  delete copy.transform
+  return copy
+}
+
+function firstNumericValue(
+  value: Record<string, unknown>,
+  keys: readonly string[],
+  fallback: number,
+): number {
+  for (const key of keys) {
+    const candidate = value[key]
+    if (typeof candidate === 'number') return candidate
+  }
+  return fallback
+}
+
+function normalizedTransform(item: unknown): Record<string, number> | null {
+  if (!item || typeof item !== 'object') return null
+  const transform = (item as Record<string, unknown>).transform
+  if (!transform || typeof transform !== 'object') return null
+  const value = transform as Record<string, unknown>
+  return {
+    x: firstNumericValue(value, ['x', 'position_x'], 0),
+    y: firstNumericValue(value, ['y', 'position_y'], 0),
+    scaleX: firstNumericValue(value, ['scaleX', 'scale_x'], 1),
+    scaleY: firstNumericValue(value, ['scaleY', 'scale_y'], 1),
+    rotation: firstNumericValue(value, ['rotation', 'rotation_degrees'], 0),
+    anchorX: firstNumericValue(value, ['anchorX', 'anchor_x'], 0),
+    anchorY: firstNumericValue(value, ['anchorY', 'anchor_y'], 0),
+    opacity: firstNumericValue(value, ['opacity'], 1),
+  }
+}
+
+function transformsEquivalent(left: unknown, right: unknown): boolean {
+  return stableSerialize(normalizedTransform(left)) === stableSerialize(normalizedTransform(right))
+}
+
+function positionOnly(item: unknown): unknown {
+  if (!item || typeof item !== 'object') return item
+  const value = item as Record<string, unknown>
+  return {
+    trackId: value.trackId,
+    from: value.from,
+    durationInFrames: value.durationInFrames,
+    sourceStart: value.sourceStart,
+    sourceEnd: value.sourceEnd,
+  }
+}
+
+function commandItemFromDocument(
+  document: FreeCutFrameDocument,
+  id: string,
+): Extract<EditCommand, { type: 'add_clip' | 'add_text' }>['item'] | null {
+  const item = itemMap(document).get(id)
+  if (!item || item.type === 'caption_cue') return null
+  const controlled = freeCutDocumentToControlledDocument(document).timeline
+  const located = controlled.tracks
+    .flatMap((track) => track.items)
+    .find((candidate) => candidate.item_type !== 'caption_cue' && candidate.item_id === id)
+  if (!located || (located.item_type !== 'clip' && located.item_type !== 'text')) return null
+  return located
+}
+
+function splitLeftId(originalId: string): string {
+  const suffix = ':left'
+  return `${originalId.slice(0, Math.max(1, 128 - suffix.length))}${suffix}`
+}
+
+function commandIdsForChanges(
+  previous: FreeCutFrameDocument,
+  next: FreeCutFrameDocument,
+): {
+  added: string[]
+  removed: string[]
+  changed: string[]
+} {
+  const previousItems = itemMap(previous)
+  const nextItems = itemMap(next)
+  const added = [...nextItems.keys()].filter((id) => !previousItems.has(id))
+  const removed = [...previousItems.keys()].filter((id) => !nextItems.has(id))
+  const changed = [...nextItems.keys()].filter((id) => {
+    const before = previousItems.get(id)
+    const after = nextItems.get(id)
+    return (
+      before !== undefined &&
+      after !== undefined &&
+      stableSerialize(before) !== stableSerialize(after)
+    )
+  })
+  return { added, removed, changed }
+}
+
+export interface DerivedHostEdit {
+  batch: EditCommandBatch | null
+  reason?: string
+}
+
+/**
+ * Derive one bounded command batch from the real editor's frame-native store
+ * change.  Ambiguous or unsupported changes fail closed instead of being
+ * silently ignored or written to local persistence.
+ */
+// fallow-ignore-next-line complexity
+export function deriveSupportedHostEdit(
+  previous: FreeCutFrameDocument,
+  next: FreeCutFrameDocument,
+  options: { operationId?: string; idempotencyKey?: string } = {},
+): DerivedHostEdit {
+  const { added, removed, changed } = commandIdsForChanges(previous, next)
+  const previousItems = itemMap(previous)
+  const nextItems = itemMap(next)
+  const fps = previous.fps
+  const operationId = options.operationId ?? `op-${crypto.randomUUID()}`
+  const idempotencyKey = options.idempotencyKey ?? `idem-${crypto.randomUUID()}`
+  const commands: EditCommand[] = []
+  const preconditions: Precondition[] = []
+  const previousTrackIds = new Set(previous.tracks.map((track) => track.id))
+  const addedTracks = next.tracks.filter((track) => !previousTrackIds.has(track.id))
+
+  for (const track of addedTracks) {
+    commands.push({
+      command_id: `add-track-${track.id}`,
+      type: 'add_track',
+      track: {
+        track_id: track.id,
+        kind: track.kind,
+        name: track.name,
+        locked: track.locked,
+        muted: track.muted,
+        items: [],
+      },
+      index: trackIndex(next, track.id),
+    })
+    preconditions.push({ type: 'track_absent', track_id: track.id })
+  }
+
+  if (
+    addedTracks.length > 0 &&
+    removed.length === 0 &&
+    added.length === 0 &&
+    changed.length === 0
+  ) {
+    // Track creation is already represented by the add_track commands above.
+  } else if (removed.length === 1 && added.length === 0 && changed.length === 0) {
+    const id = removed[0]!
+    const before = previousItems.get(id)!
+    if (before.type === 'caption_cue')
+      return { batch: null, reason: 'Caption removal is not supported' }
+    commands.push({ command_id: `remove-${id}`, type: 'remove_item', item_id: id })
+    preconditions.push(preconditionForItem(before, fps))
+  } else if (added.length === 1 && removed.length === 0 && changed.length === 0) {
+    const id = added[0]!
+    const after = nextItems.get(id)!
+    const location = itemLocation(next, id)
+    const item = commandItemFromDocument(next, id)
+    if (!location || !item)
+      return { batch: null, reason: 'The added item is not a supported clip or text item' }
+    if (after.type === 'caption_cue')
+      return { batch: null, reason: 'Caption insertion is not supported' }
+    commands.push({
+      command_id: `add-${id}`,
+      type: after.type === 'text' ? 'add_text' : 'add_clip',
+      track_id: after.trackId,
+      item,
+      index: location.index,
+    } as EditCommand)
+    if (!addedTracks.some((track) => track.id === after.trackId)) {
+      preconditions.push({ type: 'track_exists', track_id: after.trackId })
+    }
+    preconditions.push({ type: 'item_absent', item_id: id })
+  } else if (added.length === 1 && removed.length === 0 && changed.length === 1) {
+    const leftId = changed[0]!
+    const rightId = added[0]!
+    const before = previousItems.get(leftId)
+    const left = nextItems.get(leftId)
+    const right = nextItems.get(rightId)
+    if (
+      !before ||
+      !left ||
+      !right ||
+      !isFrameClip(before) ||
+      !isFrameClip(left) ||
+      !isFrameClip(right)
+    ) {
+      return { batch: null, reason: 'The split change is not a supported clip or text item' }
+    }
+    const splitMatches =
+      left.trackId === right.trackId &&
+      left.from === before.from &&
+      left.from + left.durationInFrames === right.from &&
+      right.from + right.durationInFrames === before.from + before.durationInFrames &&
+      stableSerialize(withoutPosition(before)) === stableSerialize(withoutPosition(left)) &&
+      transformsEquivalent(before, left) &&
+      stableSerialize(positionOnly(before)) !== stableSerialize(positionOnly(left))
+    if (!splitMatches) return { batch: null, reason: 'The timeline change is ambiguous' }
+    const [splitSource] = sourceBounds(right)
+    commands.push({
+      command_id: `split-${leftId}`,
+      type: 'split_item',
+      item_id: leftId,
+      at_timeline_us: framesToMicroseconds(right.from, fps),
+      at_source_us: framesToMicroseconds(splitSource, fps),
+      left_item_id: splitLeftId(leftId),
+      right_item_id: rightId,
+    })
+    preconditions.push(preconditionForItem(before, fps))
+  } else if (removed.length === 0 && added.length === 0 && changed.length === 1) {
+    const id = changed[0]!
+    const before = previousItems.get(id)!
+    const after = nextItems.get(id)!
+    if (before.type === 'caption_cue' || after.type === 'caption_cue') {
+      return { batch: null, reason: 'Caption edits are not supported in the first host slice' }
+    }
+    const metadataUnchanged =
+      stableSerialize(withoutPosition(before)) === stableSerialize(withoutPosition(after))
+    const transformUnchanged = transformsEquivalent(before, after)
+    const sourceUnchanged =
+      isFrameClip(before) && isFrameClip(after)
+        ? sourceBounds(before)[0] === sourceBounds(after)[0] &&
+          sourceBounds(before)[1] === sourceBounds(after)[1]
+        : before.type === after.type
+    const timelineUnchanged =
+      before.from === after.from && before.durationInFrames === after.durationInFrames
+    const onlyPositionChanged =
+      metadataUnchanged && transformUnchanged && sourceUnchanged && !timelineUnchanged
+    const onlyTrimChanged =
+      metadataUnchanged &&
+      transformUnchanged &&
+      before.trackId === after.trackId &&
+      !sourceUnchanged
+    const location = itemLocation(next, id)
+    if (!location) return { batch: null, reason: 'The changed item no longer has a track' }
+
+    if (onlyPositionChanged) {
+      commands.push({
+        command_id: `move-${id}`,
+        type: 'move_item',
+        item_id: id,
+        to_track_id: after.trackId,
+        timeline_start_us: framesToMicroseconds(after.from, fps),
+        index: location.index,
+      })
+      preconditions.push(preconditionForItem(before, fps))
+    } else if (onlyTrimChanged) {
+      const edge = after.from !== before.from ? 'start' : 'end'
+      const timelineFrame = edge === 'start' ? after.from : after.from + after.durationInFrames
+      if (!isFrameClip(after)) {
+        return { batch: null, reason: 'Text trimming is not supported in the first host slice' }
+      }
+      const [, afterSourceEnd] = sourceBounds(after)
+      const [afterSourceStart] = sourceBounds(after)
+      const sourceFrame = edge === 'start' ? afterSourceStart : afterSourceEnd
+      commands.push({
+        command_id: `trim-${id}`,
+        type: 'trim_item',
+        item_id: id,
+        edge,
+        timeline_us: framesToMicroseconds(timelineFrame, fps),
+        source_us: framesToMicroseconds(sourceFrame, fps),
+      })
+      preconditions.push(preconditionForItem(before, fps))
+    } else {
+      return {
+        batch: null,
+        reason: 'Property, effect, or animation edits are unsupported by the host slice',
+      }
+    }
+  } else {
+    return { batch: null, reason: 'Multiple or ambiguous timeline changes are unsupported' }
+  }
+
+  if (commands.length === 0) return { batch: null, reason: 'No supported edit was detected' }
+  return {
+    batch: {
+      contract_version: 1,
+      timeline_id: previous.timelineId,
+      operation_id: operationId,
+      idempotency_key: idempotencyKey,
+      base_revision: previous.revision,
+      preconditions,
+      commands,
+    },
+  }
+}
+
+export class HostEditorController {
+  private snapshot: EmbeddedEditorSnapshot
+  private readonly host: EditorHost
+  private readonly capabilities
+  private readonly adapter
+  private readonly listeners = new Set<(snapshot: EmbeddedEditorSnapshot) => void>()
+
+  constructor(host: EditorHost, snapshot: EmbeddedEditorSnapshot) {
+    this.host = host
+    this.capabilities = { ...DEFAULT_HOST_CAPABILITIES, ...host.capabilities }
+    this.snapshot = clone(snapshot)
+    const document = hostSnapshotToControlledDocument(snapshot)
+    this.adapter = createCodePressCommandAdapter({ document })
+  }
+
+  getSnapshot(): EmbeddedEditorSnapshot {
+    return clone(this.snapshot)
+  }
+
+  getDocument(): ControlledEditorDocument {
+    return this.adapter.getDocument()
+  }
+
+  subscribe(listener: (snapshot: EmbeddedEditorSnapshot) => void): () => void {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  replaceAuthoritativeSnapshot(snapshot: EmbeddedEditorSnapshot): void {
+    this.snapshot = clone(snapshot)
+    this.adapter.replaceDocument(hostSnapshotToControlledDocument(snapshot))
+    for (const listener of this.listeners) {
+      listener(this.getSnapshot())
+    }
+  }
+
+  async resolveMedia(locator: MediaLocator): Promise<ResolvedMediaLocator | null> {
+    if (!isHostCapabilityEnabled(this.capabilities, 'media.resolve')) return null
+    return this.host.resolveMedia(locator)
+  }
+
+  async submitEdit(batch: EditCommandBatch): Promise<HostControllerResult> {
+    const unsupported = batch.commands.find((command) => {
+      const capability = capabilityForCommand(command.type)
+      return !capability || !isHostCapabilityEnabled(this.capabilities, capability)
+    })
+    if (unsupported) {
+      const reason = `The host does not support ${unsupported.type}`
+      this.notify({ kind: 'unsupported', message: reason, operationId: batch.operation_id })
+      return { status: 'unsupported', snapshot: this.getSnapshot(), reason }
+    }
+
+    const localResult = this.adapter.apply(batch)
+    if (localResult.status === 'rejected') {
+      this.notify({
+        kind: 'error',
+        message: localResult.error.message,
+        operationId: batch.operation_id,
+      })
+      return { status: 'rejected', snapshot: this.getSnapshot(), result: localResult }
+    }
+
+    const remoteResult = await this.host.submitEdit(batch)
+    this.replaceAuthoritativeSnapshot(remoteResult.snapshot)
+    if (remoteResult.status === 'conflict') {
+      this.notify({
+        kind: 'conflict',
+        message: remoteResult.result.error.message,
+        operationId: batch.operation_id,
+      })
+    }
+    return remoteResult
+  }
+
+  private notify(notice: HostNotice): void {
+    this.host.notify?.(notice)
+  }
+}
diff --git a/src/features/editor/host/document.ts b/src/features/editor/host/document.ts
new file mode 100644
index 000000000..4db85eccb
--- /dev/null
+++ b/src/features/editor/host/document.ts
@@ -0,0 +1,366 @@
+import {
+  freeCutDocumentToControlledDocument,
+  type FreeCutFrameDocument,
+  type FreeCutFrameItem,
+} from '@/features/editor/codepress/document'
+import type { EmbeddedEditorAsset, EmbeddedEditorSnapshot } from './contract'
+import type { ControlledEditorDocument } from '@/features/editor/codepress/interfaces'
+import type { TimelineItem, TimelineTrack } from '@/types/timeline'
+import type { TimelineState } from '@/features/editor/deps/timeline-store'
+import type { MediaMetadata } from '@/types/storage'
+import { DEFAULT_TRACK_HEIGHT } from '@/shared/timeline/defaults'
+
+export interface HostNativeTimeline {
+  tracks: TimelineTrack[]
+  items: TimelineItem[]
+  fps: number
+}
+
+export interface NativeTimelineConversionFailure {
+  reason: string
+  itemId?: string
+}
+
+export type NativeTimelineConversionResult =
+  | { ok: true; document: FreeCutFrameDocument }
+  | { ok: false; failure: NativeTimelineConversionFailure }
+
+function safeDurationFrames(asset: EmbeddedEditorAsset, fps: number): number {
+  if (!Number.isFinite(asset.durationSeconds) || asset.durationSeconds <= 0) return 1
+  return Math.max(1, Math.round(asset.durationSeconds * fps))
+}
+
+// fallow-ignore-next-line complexity
+function nativeTransformToFrame(
+  transform: TimelineItem['transform'],
+): Record<string, number> | undefined {
+  if (!transform) return undefined
+  return {
+    x: transform.x ?? 0,
+    y: transform.y ?? 0,
+    width: transform.width ?? 0,
+    height: transform.height ?? 0,
+    anchorX: transform.anchorX ?? 0,
+    anchorY: transform.anchorY ?? 0,
+    rotation: transform.rotation ?? 0,
+    opacity: transform.opacity ?? 1,
+  }
+}
+
+function frameTransformToNative(
+  transform: Record<string, number> | undefined,
+): NonNullable<TimelineItem['transform']> | undefined {
+  if (!transform) return undefined
+  return {
+    x: transform.x ?? transform.position_x ?? 0,
+    y: transform.y ?? transform.position_y ?? 0,
+    width: transform.width,
+    height: transform.height,
+    anchorX: transform.anchorX ?? transform.anchor_x,
+    anchorY: transform.anchorY ?? transform.anchor_y,
+    rotation: transform.rotation ?? transform.rotation_degrees,
+    opacity: transform.opacity,
+  }
+}
+
+function assetById(assets: readonly EmbeddedEditorAsset[]): Map<string, EmbeddedEditorAsset> {
+  return new Map(assets.map((asset) => [asset.id, asset]))
+}
+
+function mediaMetadataFromAsset(asset: EmbeddedEditorAsset): MediaMetadata {
+  return {
+    id: asset.id,
+    // Host assets are intentionally not represented as workspace, OPFS, or
+    // File System Access records.  Their source is resolved by the host port.
+    storageType: 'host',
+    contentHash: asset.contentHash,
+    fileName: asset.fileName,
+    fileSize: asset.fileSize ?? 0,
+    mimeType: asset.mimeType,
+    duration: asset.durationSeconds,
+    width: asset.width,
+    height: asset.height,
+    fps: asset.fps,
+    codec: 'host-managed',
+    bitrate: 0,
+    thumbnailId: undefined,
+    tags: [],
+    createdAt: 0,
+    updatedAt: 0,
+  }
+}
+
+export function hostAssetsToMediaMetadata(assets: readonly EmbeddedEditorAsset[]): MediaMetadata[] {
+  return assets.map(mediaMetadataFromAsset)
+}
+
+function nativeTrackFromHostTrack(
+  track: FreeCutFrameDocument['tracks'][number],
+  index: number,
+): TimelineTrack {
+  const kind = track.kind === 'audio' ? 'audio' : 'video'
+  return {
+    id: track.id,
+    name: track.name,
+    kind,
+    height: DEFAULT_TRACK_HEIGHT,
+    locked: track.locked,
+    syncLock: true,
+    visible: true,
+    muted: track.muted,
+    solo: false,
+    order: index,
+    items: [],
+  }
+}
+
+// fallow-ignore-next-line complexity
+function nativeItemFromHostItem(
+  item: FreeCutFrameItem,
+  assets: Map<string, EmbeddedEditorAsset>,
+): TimelineItem {
+  if (item.type === 'text') {
+    const textColor = typeof item.style?.color === 'string' ? item.style.color : '#ffffff'
+    return {
+      id: item.id,
+      type: 'text',
+      trackId: item.trackId,
+      from: item.from,
+      durationInFrames: item.durationInFrames,
+      label: item.text || 'Text',
+      text: item.text,
+      color: textColor,
+      ...(typeof item.style?.font_family === 'string'
+        ? { fontFamily: item.style.font_family }
+        : {}),
+      ...(typeof item.style?.font_size === 'number' ? { fontSize: item.style.font_size } : {}),
+      ...(item.style?.alignment === 'left' ||
+      item.style?.alignment === 'center' ||
+      item.style?.alignment === 'right'
+        ? { textAlign: item.style.alignment }
+        : {}),
+      ...(item.opacity !== undefined ? { transform: { opacity: item.opacity } } : {}),
+      ...(item.transform ? { transform: frameTransformToNative(item.transform) } : {}),
+    }
+  }
+
+  if (item.type === 'caption_cue') {
+    const style = item.style
+    return {
+      id: item.id,
+      type: 'text',
+      trackId: item.trackId,
+      from: item.from,
+      durationInFrames: item.durationInFrames,
+      label: item.text || 'Caption',
+      text: item.text,
+      textRole: 'caption',
+      color: style?.color ?? '#ffffff',
+      ...(typeof style?.font_family === 'string' ? { fontFamily: style.font_family } : {}),
+      ...(typeof style?.font_size === 'number' ? { fontSize: style.font_size } : {}),
+      ...(typeof style?.background_color === 'string'
+        ? { backgroundColor: style.background_color }
+        : {}),
+      ...(typeof style?.background_opacity === 'number'
+        ? { backgroundOpacity: style.background_opacity }
+        : {}),
+      ...(style?.alignment === 'left' ||
+      style?.alignment === 'center' ||
+      style?.alignment === 'right'
+        ? { textAlign: style.alignment }
+        : {}),
+    }
+  }
+
+  const asset = assets.get(item.mediaId)
+  const sourceDuration = asset ? safeDurationFrames(asset, asset.fps || 30) : undefined
+  const sourceStart = item.sourceStart ?? item.from
+  const sourceEnd = item.sourceEnd ?? sourceStart + item.durationInFrames
+  const common = {
+    id: item.id,
+    trackId: item.trackId,
+    from: item.from,
+    durationInFrames: item.durationInFrames,
+    label: asset?.fileName ?? item.mediaId,
+    mediaId: item.mediaId,
+    src: '',
+    ...(sourceDuration !== undefined ? { sourceDuration } : {}),
+    sourceStart,
+    sourceEnd,
+    ...(item.volume !== undefined ? { volume: item.volume } : {}),
+    ...(item.speed !== undefined ? { speed: item.speed } : {}),
+    ...(item.opacity !== undefined ? { transform: { opacity: item.opacity } } : {}),
+    ...(item.transform ? { transform: frameTransformToNative(item.transform) } : {}),
+  }
+
+  if (item.type === 'audio') return { ...common, type: 'audio' }
+  if (item.type === 'image') return { ...common, type: 'image' }
+  return { ...common, type: 'video' }
+}
+
+export function hostSnapshotToNativeTimeline(snapshot: EmbeddedEditorSnapshot): HostNativeTimeline {
+  const assets = assetById(snapshot.assets)
+  const tracks = snapshot.timeline.tracks.map(nativeTrackFromHostTrack)
+  const items = snapshot.timeline.tracks.flatMap((track) =>
+    track.items.map((item) => nativeItemFromHostItem(item, assets)),
+  )
+  return { tracks, items, fps: snapshot.project.fps }
+}
+
+export function hostSnapshotToControlledDocument(
+  snapshot: EmbeddedEditorSnapshot,
+): ControlledEditorDocument {
+  return freeCutDocumentToControlledDocument(snapshot.timeline)
+}
+
+export function hostSnapshotToProject(snapshot: EmbeddedEditorSnapshot) {
+  return {
+    id: snapshot.project.id,
+    name: snapshot.project.name,
+    description: '',
+    duration: snapshot.timeline.durationInFrames / snapshot.project.fps,
+    schemaVersion: 1,
+    metadata: {
+      width: snapshot.project.width,
+      height: snapshot.project.height,
+      fps: snapshot.project.fps,
+      backgroundColor: snapshot.project.backgroundColor,
+    },
+    createdAt: 0,
+    updatedAt: 0,
+  }
+}
+
+// fallow-ignore-next-line complexity
+function frameItemToNativeComparable(
+  item: TimelineItem,
+):
+  | Extract<FreeCutFrameItem, { type: 'video' | 'audio' | 'image' }>
+  | Extract<FreeCutFrameItem, { type: 'text' }>
+  | Extract<FreeCutFrameItem, { type: 'caption_cue' }>
+  | NativeTimelineConversionFailure {
+  if (item.type === 'video' || item.type === 'audio' || item.type === 'image') {
+    if (!item.mediaId) return { reason: `Media item "${item.id}" has no mediaId`, itemId: item.id }
+    return {
+      type: item.type,
+      id: item.id,
+      trackId: item.trackId,
+      mediaId: item.mediaId,
+      from: item.from,
+      durationInFrames: item.durationInFrames,
+      sourceStart: item.sourceStart,
+      sourceEnd: item.sourceEnd,
+      volume: item.volume,
+      speed: item.speed,
+      opacity: item.transform?.opacity,
+      transform: nativeTransformToFrame(item.transform),
+    }
+  }
+
+  if (item.type === 'text' && item.textRole === 'caption') {
+    const style = {
+      ...(item.fontFamily ? { font_family: item.fontFamily } : {}),
+      ...(item.fontSize !== undefined ? { font_size: item.fontSize } : {}),
+      ...(item.color && item.color !== '#ffffff' ? { color: item.color } : {}),
+      ...(item.backgroundColor ? { background_color: item.backgroundColor } : {}),
+      ...(item.backgroundOpacity !== undefined
+        ? { background_opacity: item.backgroundOpacity }
+        : {}),
+      ...(item.textAlign ? { alignment: item.textAlign } : {}),
+    }
+    return {
+      type: 'caption_cue',
+      id: item.id,
+      trackId: item.trackId,
+      from: item.from,
+      durationInFrames: item.durationInFrames,
+      text: item.text,
+      ...(Object.keys(style).length > 0 ? { style } : {}),
+    }
+  }
+
+  if (item.type === 'text') {
+    return {
+      type: 'text',
+      id: item.id,
+      trackId: item.trackId,
+      from: item.from,
+      durationInFrames: item.durationInFrames,
+      text: item.text,
+      style: {
+        ...(item.fontFamily ? { font_family: item.fontFamily } : {}),
+        ...(item.fontSize !== undefined ? { font_size: item.fontSize } : {}),
+        ...(item.color && item.color !== '#ffffff' ? { color: item.color } : {}),
+        ...(item.textAlign ? { alignment: item.textAlign } : {}),
+      },
+      opacity: item.transform?.opacity,
+      transform: nativeTransformToFrame(item.transform),
+    }
+  }
+
+  return { reason: `Unsupported native timeline item type "${item.type}"`, itemId: item.id }
+}
+
+/**
+ * Convert only the bounded native editor shape back into the neutral frame
+ * document.  Shapes, compositions, subtitles, Lottie, effects, and animation
+ * edits fail closed so a host action can be visibly rejected and restored.
+ */
+export function nativeTimelineToFrameDocument(
+  state: Pick<TimelineState, 'tracks' | 'items' | 'fps'>,
+  authoritative: FreeCutFrameDocument,
+): NativeTimelineConversionResult {
+  const trackIds = new Set(state.tracks.map((track) => track.id))
+  const itemsByTrack = new Map<string, FreeCutFrameItem[]>()
+  for (const item of state.items) {
+    if (!trackIds.has(item.trackId)) {
+      return {
+        ok: false,
+        failure: {
+          reason: `Timeline item "${item.id}" references a missing track`,
+          itemId: item.id,
+        },
+      }
+    }
+    const converted = frameItemToNativeComparable(item)
+    if ('reason' in converted) return { ok: false, failure: converted }
+    const list = itemsByTrack.get(item.trackId) ?? []
+    list.push(converted)
+    itemsByTrack.set(item.trackId, list)
+  }
+
+  const tracks = state.tracks.map((track) => {
+    const authoritativeTrack = authoritative.tracks.find((candidate) => candidate.id === track.id)
+    return {
+      id: track.id,
+      kind:
+        authoritativeTrack?.kind ??
+        (track.kind === 'audio' ? ('audio' as const) : ('video' as const)),
+      name: track.name,
+      ...(authoritativeTrack?.language !== undefined
+        ? { language: authoritativeTrack.language }
+        : {}),
+      locked: track.locked,
+      muted: track.muted,
+      ...(authoritativeTrack?.defaultStyle !== undefined
+        ? { defaultStyle: authoritativeTrack.defaultStyle }
+        : {}),
+      items: itemsByTrack.get(track.id) ?? [],
+    }
+  })
+
+  const durationInFrames = Math.max(
+    authoritative.durationInFrames,
+    ...state.items.map((item) => item.from + item.durationInFrames),
+  )
+  return {
+    ok: true,
+    document: {
+      ...authoritative,
+      revision: authoritative.revision,
+      fps: state.fps,
+      durationInFrames,
+      tracks,
+    },
+  }
+}
diff --git a/src/features/editor/host/editor-surface.test.tsx b/src/features/editor/host/editor-surface.test.tsx
new file mode 100644
index 000000000..e037c422b
--- /dev/null
+++ b/src/features/editor/host/editor-surface.test.tsx
@@ -0,0 +1,56 @@
+// @vitest-environment jsdom
+
+import { useEditorHostContext } from './context'
+import { render, screen, waitFor } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vite-plus/test'
+import type { EditorHost, EmbeddedEditorSnapshot } from './contract'
+
+vi.mock('@/features/editor/components/editor', () => ({
+  LoadedEditor: ({ projectId }: { projectId: string }) => {
+    const { mode } = useEditorHostContext()
+    return (
+      <div data-testid="loaded-editor">
+        {mode}:{projectId}
+      </div>
+    )
+  },
+}))
+
+import { FreeCutEditorSurface } from './editor-surface'
+
+const fakeSnapshot: EmbeddedEditorSnapshot = {
+  project: { id: 'surface-project', name: 'Surface', width: 1920, height: 1080, fps: 30 },
+  timeline: {
+    timelineId: 'surface-timeline',
+    revision: 0,
+    fps: 30,
+    durationInFrames: 30,
+    media: [],
+    tracks: [],
+    width: 1920,
+    height: 1080,
+  },
+  assets: [],
+}
+
+function fakeHost(): EditorHost {
+  return {
+    capabilities: { 'media.resolve': true, 'workspace.edit': true },
+    load: vi.fn(async () => fakeSnapshot),
+    resolveMedia: vi.fn(() => null),
+    submitEdit: vi.fn(() => {
+      throw new Error('not used by surface mount test')
+    }),
+  }
+}
+
+describe('FreeCut host browser surface', () => {
+  it('injects a fake host into the real LoadedEditor entry', async () => {
+    const host = fakeHost()
+    render(<FreeCutEditorSurface host={host} />)
+
+    await waitFor(() => expect(screen.getByTestId('loaded-editor')).toBeInTheDocument())
+    expect(screen.getByTestId('loaded-editor')).toHaveTextContent('host:surface-project')
+    expect(host.load).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/src/features/editor/host/editor-surface.tsx b/src/features/editor/host/editor-surface.tsx
new file mode 100644
index 000000000..cf3b69fb8
--- /dev/null
+++ b/src/features/editor/host/editor-surface.tsx
@@ -0,0 +1,106 @@
+import { useEffect, useState } from 'react'
+import { I18nextProvider } from 'react-i18next'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { GlobalTooltip } from '@/components/ui/global-tooltip'
+import { ErrorBoundary } from '@/app/error-boundary'
+import { i18n, i18nReady } from '@/i18n'
+import { LoadedEditor } from '@/features/editor/components/editor'
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  isHostCapabilityEnabled,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+} from './contract'
+import { EditorHostProvider } from './context-provider'
+import { HostCaptionEditorProvider } from './caption-editor-context'
+import { HostTranscriptEditorProvider } from './transcript-editor-context'
+import { EmbeddedEditorHostRuntime } from './runtime'
+import '@/index.css'
+
+interface HostSurfaceState {
+  snapshot: EmbeddedEditorSnapshot
+  runtime: EmbeddedEditorHostRuntime
+}
+
+/**
+ * Importable, host-backed browser entry for the real FreeCut editor tree.
+ * Consumers provide authority and ports; this component provides only the
+ * FreeCut providers, i18n, CSS, and existing LoadedEditor layout.
+ */
+export function FreeCutEditorSurface({ host }: { host: EditorHost }) {
+  const [state, setState] = useState<HostSurfaceState | null>(null)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    setState(null)
+    setError(null)
+    void Promise.all([Promise.resolve(host.load()), i18nReady])
+      .then(([snapshot]) => {
+        if (cancelled) return
+        setState({ snapshot, runtime: new EmbeddedEditorHostRuntime(host, snapshot) })
+      })
+      .catch((caught) => {
+        if (!cancelled) setError(caught instanceof Error ? caught : new Error(String(caught)))
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [host])
+
+  if (error) {
+    return (
+      <div
+        className="flex min-h-screen items-center justify-center bg-background p-6 text-sm text-destructive"
+        role="alert"
+      >
+        {error.message}
+      </div>
+    )
+  }
+
+  if (!state) {
+    return (
+      <div
+        className="flex min-h-screen items-center justify-center bg-background p-6 text-sm text-muted-foreground"
+        aria-busy="true"
+      >
+        Loading editor…
+      </div>
+    )
+  }
+
+  const capabilities = { ...DEFAULT_HOST_CAPABILITIES, ...host.capabilities }
+  const onNavigateBack =
+    host.navigation && isHostCapabilityEnabled(capabilities, 'project.navigate')
+      ? () => host.navigation!.back()
+      : undefined
+  return (
+    <I18nextProvider i18n={i18n}>
+      <TooltipProvider delayDuration={300}>
+        <EditorHostProvider value={{ mode: 'host', capabilities, host }}>
+          <HostCaptionEditorProvider runtime={state.runtime}>
+            <HostTranscriptEditorProvider runtime={state.runtime}>
+              <ErrorBoundary level="feature">
+                <div data-freecut-editor-surface="host" className="h-screen min-h-0">
+                  <LoadedEditor
+                    projectId={state.snapshot.project.id}
+                    project={state.snapshot.project}
+                    migration={{
+                      storedSchemaVersion: 1,
+                      currentSchemaVersion: 1,
+                      requiresUpgrade: false,
+                    }}
+                    hostRuntime={state.runtime}
+                    onNavigateBack={onNavigateBack}
+                  />
+                </div>
+              </ErrorBoundary>
+            </HostTranscriptEditorProvider>
+          </HostCaptionEditorProvider>
+        </EditorHostProvider>
+        <GlobalTooltip />
+      </TooltipProvider>
+    </I18nextProvider>
+  )
+}
diff --git a/src/features/editor/host/index.ts b/src/features/editor/host/index.ts
new file mode 100644
index 000000000..10447f0de
--- /dev/null
+++ b/src/features/editor/host/index.ts
@@ -0,0 +1,67 @@
+// fallow-ignore-file unused-file
+
+export { FreeCutEditorSurface } from './editor-surface'
+export { useEditorCapability, useEditorHostContext, useEditorHostMode } from './context'
+export { EditorHostProvider } from './context-provider'
+export type { EditorHostContextValue } from './context'
+export type { EditorHostProviderProps } from './context-provider'
+export {
+  DEFAULT_HOST_CAPABILITIES,
+  MAX_TRANSCRIPT_CURSOR_LENGTH,
+  MAX_TRANSCRIPT_COMMAND_TEXT_BYTES,
+  MAX_TRANSCRIPT_DURATION_US,
+  MAX_TRANSCRIPT_QUERY_LENGTH,
+  MAX_TRANSCRIPT_SECTION_PAGE_SIZE,
+  MAX_TRANSCRIPT_SECTION_TEXT_BYTES,
+  MAX_TRANSCRIPT_SELECTIONS,
+  SUPPORTED_HOST_COMMANDS,
+  capabilityForCommand,
+  createLocalEditorHost,
+  isHostCapabilityEnabled,
+} from './contract'
+export type {
+  EditorCapability,
+  EditorCapabilityMap,
+  EditorHost,
+  EditorHostNavigation,
+  EmbeddedEditorAsset,
+  EmbeddedEditorProject,
+  EmbeddedEditorSnapshot,
+  EditorTranscriptPort,
+  HostAppliedEditResult,
+  HostConflictResult,
+  HostEditResult,
+  HostMediaKind,
+  HostNotice,
+  HostTranscriptCommandAction,
+  HostTranscriptCommandPreview,
+  HostTranscriptCommandPreviewRequest,
+  HostTranscriptError,
+  HostTranscriptRange,
+  HostTranscriptSearchPage,
+  HostTranscriptSearchRequest,
+  HostTranscriptSection,
+  HostTranscriptSectionsPage,
+  HostTranscriptSectionsRequest,
+  HostTranscriptStatus,
+  HostTranscriptStatusReceipt,
+  LocalEditorHostOptions,
+  MediaLocator,
+  ResolvedMediaLocator,
+} from './contract'
+export { EmbeddedEditorHostRuntime } from './runtime'
+export type { EmbeddedEditorHostRuntimeContract } from './runtime'
+export { HostEditorController, deriveSupportedHostEdit } from './controller'
+export type { DerivedHostEdit, HostControllerResult } from './controller'
+export {
+  hostAssetsToMediaMetadata,
+  hostSnapshotToControlledDocument,
+  hostSnapshotToNativeTimeline,
+  hostSnapshotToProject,
+  nativeTimelineToFrameDocument,
+} from './document'
+export type {
+  HostNativeTimeline,
+  NativeTimelineConversionFailure,
+  NativeTimelineConversionResult,
+} from './document'
diff --git a/src/features/editor/host/runtime.ts b/src/features/editor/host/runtime.ts
new file mode 100644
index 000000000..7d2960ee2
--- /dev/null
+++ b/src/features/editor/host/runtime.ts
@@ -0,0 +1,299 @@
+import {
+  installRuntimeMediaResolver,
+  useMediaLibraryStore,
+} from '@/features/editor/deps/media-library'
+import { useProjectStore } from '@/features/editor/deps/projects'
+import {
+  useCompositionNavigationStore,
+  useCompositionsStore,
+  useItemsStore,
+  useTimelineCommandStore,
+  useTimelineSettingsStore,
+  useTimelineStore,
+} from '@/features/editor/deps/timeline-store'
+import { usePlaybackStore } from '@/shared/state/playback'
+import { useEditorStore } from '@/shared/state/editor'
+import { useSelectionStore } from '@/shared/state/selection'
+import { useGizmoStore, useMaskEditorStore } from '@/features/editor/deps/preview'
+import {
+  isHostCapabilityEnabled,
+  type EmbeddedEditorSnapshot,
+  type EditorHost,
+  type HostNotice,
+} from './contract'
+import { HostEditorController, deriveSupportedHostEdit } from './controller'
+import {
+  hostAssetsToMediaMetadata,
+  hostSnapshotToNativeTimeline,
+  hostSnapshotToProject,
+  nativeTimelineToFrameDocument,
+} from './document'
+
+export interface EmbeddedEditorHostRuntimeContract {
+  mountStores(): void
+  unmountStores(): void
+}
+
+function scheduleMicrotask(callback: () => void): void {
+  if (typeof queueMicrotask === 'function') queueMicrotask(callback)
+  else void Promise.resolve().then(callback)
+}
+
+/**
+ * Bridges the real FreeCut Zustand editor stores to a host controller.  The
+ * stores remain an in-memory rendering implementation; every supported edit
+ * must cross the controller before the next authoritative snapshot is kept.
+ */
+export class EmbeddedEditorHostRuntime implements EmbeddedEditorHostRuntimeContract {
+  readonly controller: HostEditorController
+  readonly host: EditorHost
+  readonly projectId: string
+
+  private mounted = false
+  private applyingAuthoritative = false
+  private reconcileScheduled = false
+  private editInFlight = false
+  private unsubscribeResolver: (() => void) | null = null
+  private unsubscribeController: (() => void) | null = null
+  private unsubscribeTimeline: (() => void) | null = null
+  private authoritativeSnapshot: EmbeddedEditorSnapshot
+
+  constructor(host: EditorHost, snapshot: EmbeddedEditorSnapshot) {
+    this.host = host
+    this.projectId = snapshot.project.id
+    this.authoritativeSnapshot = snapshot
+    this.controller = new HostEditorController(host, snapshot)
+  }
+
+  mountStores(): void {
+    if (this.mounted) return
+    this.mounted = true
+    useEditorStore.setState({ hostMode: true })
+    useSelectionStore.getState().clearSelection()
+    useSelectionStore.getState().setActiveTool('select')
+    useGizmoStore.getState().cancelInteraction()
+    useGizmoStore.getState().clearPreview()
+    useMaskEditorStore.getState().stopEditing()
+    this.applySnapshotToStores(this.authoritativeSnapshot)
+
+    this.unsubscribeResolver = installRuntimeMediaResolver(async (mediaId) => {
+      const asset = this.authoritativeSnapshot.assets.find((candidate) => candidate.id === mediaId)
+      if (!asset) return null
+      const resolved = await this.controller.resolveMedia({
+        mediaId,
+        kind: asset.kind,
+        variant: 'source',
+      })
+      return resolved?.source ?? null
+    })
+
+    this.unsubscribeController = this.controller.subscribe((snapshot) => {
+      this.authoritativeSnapshot = snapshot
+      this.applySnapshotToStores(snapshot)
+    })
+    this.unsubscribeTimeline = useTimelineStore.subscribe(() => this.scheduleReconcile())
+  }
+
+  unmountStores(): void {
+    if (!this.mounted) return
+    this.mounted = false
+    this.unsubscribeTimeline?.()
+    this.unsubscribeTimeline = null
+    this.unsubscribeController?.()
+    this.unsubscribeController = null
+    this.unsubscribeResolver?.()
+    this.unsubscribeResolver = null
+
+    usePlaybackStore.getState().pause()
+    useGizmoStore.getState().cancelInteraction()
+    useGizmoStore.getState().clearPreview()
+    useMaskEditorStore.getState().stopEditing()
+    useSelectionStore.getState().clearSelection()
+    useEditorStore.setState({ hostMode: false })
+    useSelectionStore.getState().setActiveTool('select')
+    useMediaLibraryStore.getState().setCurrentProject(null)
+    useProjectStore.getState().setCurrentProject(null)
+    useTimelineStore.getState().clearTimeline()
+    useTimelineSettingsStore.getState().setTimelineLoading(false)
+    useTimelineCommandStore.getState().clearHistory()
+  }
+
+  private applySnapshotToStores(snapshot: EmbeddedEditorSnapshot): void {
+    const native = hostSnapshotToNativeTimeline(snapshot)
+    this.applyingAuthoritative = true
+    try {
+      useProjectStore.getState().setCurrentProject(hostSnapshotToProject(snapshot))
+      // The first host slice exposes the normal Edit layout only.  Set this
+      // in memory so a local user's persisted Color/Motion preference cannot
+      // activate an unsupported host workspace.  Preserve the active sidebar
+      // tab when host mode still shows it: resetting it on every authoritative
+      // snapshot would unmount the transcript panel mid-apply, losing its
+      // applied/conflict state before the user can see it.
+      const currentTab = useEditorStore.getState().activeTab
+      const currentTabVisibleInHostMode =
+        currentTab === 'media' ||
+        (currentTab === 'text' &&
+          isHostCapabilityEnabled(this.host.capabilities, 'timeline.add')) ||
+        (currentTab === 'transcript' &&
+          isHostCapabilityEnabled(this.host.capabilities, 'media.transcription') &&
+          this.host.transcript !== undefined)
+      useEditorStore.setState({
+        workspace: 'edit',
+        activeTab: currentTabVisibleInHostMode ? currentTab : 'media',
+      })
+
+      const mediaItems = hostAssetsToMediaMetadata(snapshot.assets)
+      useMediaLibraryStore.getState().setCurrentProject(snapshot.project.id)
+      useMediaLibraryStore.setState({
+        currentProjectId: snapshot.project.id,
+        mediaItems,
+        mediaById: Object.fromEntries(mediaItems.map((media) => [media.id, media])),
+        isLoading: false,
+        error: null,
+        brokenMediaIds: [],
+        brokenMediaInfo: new Map(),
+        orphanedClips: [],
+        transcriptStatus: new Map(),
+        transcriptProgress: new Map(),
+      })
+
+      // Set the domain stores directly through their existing in-memory bulk
+      // setters; no timeline persistence module is imported or called here.
+      useItemsStore.getState().setTracks(native.tracks)
+      useItemsStore.getState().setItems(native.items)
+      useTimelineStore.setState({
+        transitions: [],
+        keyframes: [],
+        markers: [],
+        inPoint: null,
+        outPoint: null,
+      })
+      useCompositionsStore.getState().setCompositions([])
+      useCompositionNavigationStore.getState().resetToRoot()
+      useTimelineSettingsStore.getState().setFps(native.fps)
+      useTimelineSettingsStore.getState().setScrollPosition(0)
+      useTimelineSettingsStore.getState().setTimelineLoading(false)
+      useTimelineSettingsStore.getState().markClean()
+      useTimelineStore.temporal.getState().clear()
+      usePlaybackStore.getState().setCurrentFrame(0)
+    } finally {
+      this.applyingAuthoritative = false
+    }
+  }
+
+  private scheduleReconcile(): void {
+    if (!this.mounted || this.applyingAuthoritative || this.reconcileScheduled) return
+    this.reconcileScheduled = true
+    scheduleMicrotask(() => {
+      this.reconcileScheduled = false
+      if (!this.mounted || this.applyingAuthoritative) return
+      void this.reconcileTimeline()
+    })
+  }
+
+  // fallow-ignore-next-line complexity
+  private async reconcileTimeline(): Promise<void> {
+    const authoritativeDocument = this.authoritativeSnapshot.timeline
+    const unsupportedStoreMutation = this.findUnsupportedStoreMutation()
+    if (unsupportedStoreMutation) {
+      this.restoreAuthoritative('unsupported', unsupportedStoreMutation)
+      return
+    }
+
+    const converted = nativeTimelineToFrameDocument(
+      useTimelineStore.getState(),
+      authoritativeDocument,
+    )
+    if (!converted.ok) {
+      this.restoreAuthoritative('unsupported', converted.failure.reason)
+      return
+    }
+
+    const derived = deriveSupportedHostEdit(authoritativeDocument, converted.document)
+    if (!derived.batch) {
+      // Changes to transient view state do not constitute edits.  Anything
+      // else is restored and surfaced as a visible host notice.
+      if (derived.reason !== 'No supported edit was detected') {
+        this.restoreAuthoritative('unsupported', derived.reason ?? 'Unsupported host edit')
+      }
+      return
+    }
+
+    if (this.editInFlight) {
+      this.restoreAuthoritative('unsupported', 'Wait for the current host edit to finish')
+      return
+    }
+
+    this.editInFlight = true
+    try {
+      const result = await this.controller.submitEdit(derived.batch)
+      if (result.status === 'unsupported') {
+        this.restoreAuthoritative('unsupported', result.reason)
+      }
+      // Applied, replayed, conflict, and rejected results all replace the
+      // local store through the controller subscription or this fallback.
+      if (result.status === 'rejected')
+        this.restoreAuthoritative('error', result.result.error.message)
+    } catch (error) {
+      this.restoreAuthoritative(
+        'error',
+        error instanceof Error ? error.message : 'Host edit submission failed',
+      )
+    } finally {
+      this.editInFlight = false
+    }
+  }
+
+  private restoreAuthoritative(kind: HostNotice['kind'], message: string): void {
+    this.host.notify?.({ kind, message })
+    this.applySnapshotToStores(this.authoritativeSnapshot)
+  }
+
+  // fallow-ignore-next-line complexity
+  private findUnsupportedStoreMutation(): string | null {
+    const timeline = useTimelineStore.getState()
+    if (timeline.markers.length > 0) return 'Timeline markers are not supported in host mode'
+    if (timeline.transitions.length > 0) return 'Transitions are not supported in host mode'
+    if (timeline.keyframes.length > 0) return 'Keyframes are not supported in host mode'
+    if (useCompositionsStore.getState().compositions.length > 0) {
+      return 'Compositions are not supported in host mode'
+    }
+
+    const authoritativeTracks = hostSnapshotToNativeTimeline(this.authoritativeSnapshot).tracks
+    const authoritativeById = new Map(
+      authoritativeTracks.map((track) => [track.id, track] as const),
+    )
+    for (const track of timeline.tracks) {
+      const expected = authoritativeById.get(track.id)
+      if (!expected) continue
+      if (
+        track.name !== expected.name ||
+        track.kind !== expected.kind ||
+        track.locked !== expected.locked ||
+        track.muted !== expected.muted
+      ) {
+        return 'Track settings are not supported in host mode'
+      }
+    }
+
+    if (
+      authoritativeTracks.some(
+        (track) => !timeline.tracks.some((current) => current.id === track.id),
+      )
+    ) {
+      return 'Removing tracks is not supported in host mode'
+    }
+
+    const expectedOrder = authoritativeTracks
+      .map((track) => track.id)
+      .filter((id) => timeline.tracks.some((track) => track.id === id))
+    const currentOrder = timeline.tracks
+      .map((track) => track.id)
+      .filter((id) => authoritativeById.has(id))
+    if (expectedOrder.join('|') !== currentOrder.join('|')) {
+      return 'Track reordering is not supported in host mode'
+    }
+
+    return null
+  }
+}
diff --git a/src/features/editor/host/transcript-editor-context.tsx b/src/features/editor/host/transcript-editor-context.tsx
new file mode 100644
index 000000000..4fbf3bcff
--- /dev/null
+++ b/src/features/editor/host/transcript-editor-context.tsx
@@ -0,0 +1,26 @@
+/* eslint-disable react/only-export-components */
+
+import { createContext, useContext, type ReactNode } from 'react'
+
+import { EmbeddedEditorHostRuntime } from './runtime'
+
+const HostTranscriptEditorRuntimeContext = createContext<EmbeddedEditorHostRuntime | null>(null)
+
+/** Supplies the already-mounted host runtime to the Media/Transcript surface. */
+export function HostTranscriptEditorProvider({
+  runtime,
+  children,
+}: {
+  runtime: EmbeddedEditorHostRuntime
+  children: ReactNode
+}) {
+  return (
+    <HostTranscriptEditorRuntimeContext.Provider value={runtime}>
+      {children}
+    </HostTranscriptEditorRuntimeContext.Provider>
+  )
+}
+
+export function useHostTranscriptEditorRuntime(): EmbeddedEditorHostRuntime | null {
+  return useContext(HostTranscriptEditorRuntimeContext)
+}
diff --git a/src/features/editor/host/transcript-editor.test.tsx b/src/features/editor/host/transcript-editor.test.tsx
new file mode 100644
index 000000000..8ae078735
--- /dev/null
+++ b/src/features/editor/host/transcript-editor.test.tsx
@@ -0,0 +1,517 @@
+// @vitest-environment jsdom
+
+import { readFileSync } from 'node:fs'
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+// The transcript tab renders inside the real MediaSidebar; the media library
+// grid is unrelated to the tab lifecycle and stays stubbed out.
+vi.mock('@/features/editor/deps/media-library', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@/features/editor/deps/media-library')>()
+  return {
+    ...original,
+    MediaLibrary: () => <div data-testid="media-library-stub" />,
+  }
+})
+
+import {
+  controlledDocumentToFreeCutDocument,
+  createCodePressCommandAdapter,
+  freeCutDocumentToControlledDocument,
+  type EditCommandBatch,
+} from '@/features/editor/codepress'
+import { useEditorStore } from '@/shared/state/editor'
+import { MediaSidebar } from '../components/media-sidebar'
+import { EditorHostProvider } from './context-provider'
+import {
+  DEFAULT_HOST_CAPABILITIES,
+  type EditorHost,
+  type EmbeddedEditorSnapshot,
+  type HostEditResult,
+  type HostTranscriptCommandPreview,
+  type HostTranscriptCommandPreviewRequest,
+  type HostTranscriptSection,
+} from './contract'
+import { EmbeddedEditorHostRuntime } from './runtime'
+import { HostTranscriptEditor } from './transcript-editor'
+import { HostTranscriptEditorProvider } from './transcript-editor-context'
+
+function snapshot(): EmbeddedEditorSnapshot {
+  return {
+    project: {
+      id: 'host-transcript-project',
+      name: 'Host transcript project',
+      width: 1920,
+      height: 1080,
+      fps: 30,
+    },
+    timeline: {
+      timelineId: 'host-transcript-timeline',
+      revision: 0,
+      fps: 30,
+      durationInFrames: 300,
+      media: [],
+      tracks: [],
+      width: 1920,
+      height: 1080,
+    },
+    assets: [],
+  }
+}
+
+const sections: HostTranscriptSection[] = [
+  {
+    id: 'transcript-section-1',
+    transcriptId: 'transcript-1',
+    ordinal: 0,
+    startUs: 1_000_000,
+    endUs: 2_000_000,
+    text: 'First bounded caption.',
+    speaker: 'Speaker 1',
+  },
+  {
+    id: 'transcript-section-2',
+    transcriptId: 'transcript-1',
+    ordinal: 1,
+    startUs: 4_000_000,
+    endUs: 5_000_000,
+    text: 'Second bounded caption.',
+    speaker: 'Speaker 1',
+  },
+]
+
+function createHarness(
+  initial: EmbeddedEditorSnapshot,
+  transcriptStatus:
+    | 'pending'
+    | 'running'
+    | 'succeeded'
+    | 'failed'
+    | 'stale'
+    | 'purged' = 'succeeded',
+  previewStatus: 'preview' | 'replayed' = 'preview',
+  conflictOnApply = false,
+  previewTimestampCapability: 'section' | 'word' = 'section',
+) {
+  const remoteAdapter = createCodePressCommandAdapter({
+    document: freeCutDocumentToControlledDocument(initial.timeline),
+  })
+  let remoteSnapshot = initial
+  const submitEdit = vi.fn(async (batch: EditCommandBatch): Promise<HostEditResult> => {
+    if (conflictOnApply) {
+      return {
+        status: 'conflict',
+        snapshot: remoteSnapshot,
+        result: {
+          status: 'rejected',
+          timeline_id: initial.timeline.timelineId,
+          operation_id: batch.operation_id,
+          idempotency_key: batch.idempotency_key,
+          base_revision: batch.base_revision,
+          error: {
+            code: 'revision_conflict',
+            message: 'The timeline changed before this transcript edit was applied.',
+            retryable: true,
+            operation_id: batch.operation_id,
+            details: {
+              kind: 'revision_conflict',
+              base_revision: batch.base_revision,
+              current_revision: batch.base_revision + 1,
+              rebase: {
+                status: 'required',
+                automatic: false,
+                strategy: 'refresh_then_resubmit',
+                retry_with_revision: batch.base_revision + 1,
+              },
+            },
+          },
+        },
+      }
+    }
+    const result = remoteAdapter.apply(batch)
+    if (result.status === 'rejected') {
+      return {
+        status: 'rejected',
+        snapshot: remoteSnapshot,
+        result,
+      }
+    }
+    remoteSnapshot = {
+      ...remoteSnapshot,
+      timeline: controlledDocumentToFreeCutDocument(remoteAdapter.getDocument()),
+    }
+    return { status: result.status, snapshot: remoteSnapshot, result }
+  })
+
+  const previewBatch: EditCommandBatch = {
+    contract_version: 1,
+    timeline_id: initial.timeline.timelineId,
+    operation_id: 'transcript-preview-operation',
+    idempotency_key: 'transcript-preview-idempotency',
+    base_revision: 0,
+    preconditions: [],
+    commands: [
+      {
+        command_id: 'add-transcript-track',
+        type: 'add_caption_track',
+        track_id: 'host-transcript-captions',
+        name: 'Transcript captions',
+        language: 'en',
+        index: 0,
+      },
+      {
+        command_id: 'upsert-transcript-cues',
+        type: 'upsert_caption_cues',
+        track_id: 'host-transcript-captions',
+        cues: [
+          {
+            item_type: 'caption_cue',
+            cue_id: 'transcript-cue-1',
+            track_id: 'host-transcript-captions',
+            start_us: sections[0]!.startUs,
+            end_us: sections[0]!.endUs,
+            text: sections[0]!.text,
+            speaker: sections[0]!.speaker,
+          },
+        ],
+      },
+    ],
+  }
+
+  const previewCommands = vi.fn(
+    async (
+      _request: HostTranscriptCommandPreviewRequest,
+    ): Promise<HostTranscriptCommandPreview> => ({
+      status: previewStatus,
+      receiptId: 'transcript-receipt-1',
+      transcriptId: 'transcript-1',
+      assetId: 'asset-1',
+      sourceAssetHash: 'sha256:source-1',
+      timestampCapability:
+        previewTimestampCapability as HostTranscriptCommandPreview['timestampCapability'],
+      timelineId: initial.timeline.timelineId,
+      operationId: previewBatch.operation_id,
+      idempotencyKey: previewBatch.idempotency_key,
+      baseRevision: 0,
+      commandBatch: previewBatch,
+      preview: {
+        action: 'captions',
+        captionCount: 1,
+        willMutateTimeline: false,
+      },
+    }),
+  )
+
+  const host: EditorHost = {
+    capabilities: {
+      ...DEFAULT_HOST_CAPABILITIES,
+      'media.transcription': true,
+      'timeline.caption': true,
+    },
+    load: () => initial,
+    resolveMedia: () => null,
+    submitEdit,
+    transcript: {
+      getStatus: vi.fn(() =>
+        transcriptStatus === 'succeeded'
+          ? {
+              transcriptId: 'transcript-1',
+              assetId: 'asset-1',
+              sourceAssetHash: 'sha256:source-1',
+              status: 'succeeded' as const,
+              language: 'en',
+              durationUs: 10_000_000,
+              sectionCount: sections.length,
+              error: null,
+            }
+          : {
+              transcriptId: 'transcript-1',
+              assetId: 'asset-1',
+              sourceAssetHash: 'sha256:source-1',
+              status: transcriptStatus,
+              language: 'en',
+              durationUs: 10_000_000,
+              sectionCount: 0,
+              error:
+                transcriptStatus === 'pending' || transcriptStatus === 'running'
+                  ? {
+                      code: 'transcript_not_ready',
+                      message: 'The transcript is not ready for command conversion.',
+                      retryable: true,
+                    }
+                  : {
+                      code: 'transcript_content_unavailable',
+                      message: 'Transcript sections are no longer available.',
+                      retryable: false,
+                    },
+            },
+      ),
+      getSections: vi.fn(() => ({
+        transcriptId: 'transcript-1',
+        sections,
+        hasMore: false,
+        nextCursor: null,
+      })),
+      previewCommands,
+    },
+  }
+  return {
+    host,
+    runtime: new EmbeddedEditorHostRuntime(host, initial),
+    submitEdit,
+    previewCommands,
+  }
+}
+
+function renderHostEditor(harness: ReturnType<typeof createHarness>) {
+  return render(
+    <EditorHostProvider
+      value={{ mode: 'host', capabilities: harness.host.capabilities, host: harness.host }}
+    >
+      <HostTranscriptEditorProvider runtime={harness.runtime}>
+        <HostTranscriptEditor />
+      </HostTranscriptEditorProvider>
+    </EditorHostProvider>,
+  )
+}
+
+afterEach(() => cleanup())
+
+describe('host-backed transcript consumer', () => {
+  it('displays bounded sections, previews without mutation, then applies through submitEdit', async () => {
+    const harness = createHarness(snapshot())
+    renderHostEditor(harness)
+
+    expect(
+      await screen.findByTestId('host-transcript-section-transcript-section-1'),
+    ).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('host-transcript-section-transcript-section-1'))
+    expect(screen.getByTestId('host-transcript-preview-button')).not.toBeDisabled()
+
+    fireEvent.click(screen.getByTestId('host-transcript-preview-button'))
+    await waitFor(() => expect(screen.getByTestId('host-transcript-preview')).toBeInTheDocument())
+
+    expect(harness.previewCommands).toHaveBeenCalledWith(
+      expect.objectContaining({
+        transcriptId: 'transcript-1',
+        assetId: 'asset-1',
+        sourceAssetHash: 'sha256:source-1',
+        timestampCapability: 'section',
+        ranges: [
+          {
+            startUs: 1_000_000,
+            endUs: 2_000_000,
+            text: 'First bounded caption.',
+          },
+        ],
+      }),
+    )
+    expect(harness.submitEdit).not.toHaveBeenCalled()
+    expect(JSON.stringify(harness.previewCommands.mock.calls[0]?.[0])).not.toMatch(
+      /https?:|\/Users\/|Bearer|provider|upload_url|media_bytes/i,
+    )
+
+    fireEvent.click(screen.getByTestId('host-transcript-apply'))
+    await waitFor(() => expect(harness.submitEdit).toHaveBeenCalledTimes(1))
+    expect(harness.submitEdit.mock.calls[0]?.[0].commands).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: 'add_caption_track' }),
+        expect.objectContaining({ type: 'upsert_caption_cues' }),
+      ]),
+    )
+  })
+
+  it('surfaces replay receipts and clears a stale preview on apply conflict', async () => {
+    const replayed = createHarness(snapshot(), 'succeeded', 'replayed')
+    renderHostEditor(replayed)
+    expect(
+      await screen.findByTestId('host-transcript-section-transcript-section-1'),
+    ).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('host-transcript-section-transcript-section-1'))
+    fireEvent.click(screen.getByTestId('host-transcript-preview-button'))
+    await waitFor(() => expect(screen.getByText('Preview replayed safely.')).toBeInTheDocument())
+
+    cleanup()
+    const stale = createHarness(snapshot(), 'succeeded', 'preview', true)
+    renderHostEditor(stale)
+    expect(
+      await screen.findByTestId('host-transcript-section-transcript-section-1'),
+    ).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('host-transcript-section-transcript-section-1'))
+    fireEvent.click(screen.getByTestId('host-transcript-preview-button'))
+    await waitFor(() => expect(screen.getByTestId('host-transcript-preview')).toBeInTheDocument())
+    fireEvent.click(screen.getByTestId('host-transcript-apply'))
+    await waitFor(() =>
+      expect(screen.getByTestId('host-transcript-error')).toHaveTextContent(
+        'timeline changed before this transcript edit was applied',
+      ),
+    )
+    expect(screen.queryByTestId('host-transcript-preview')).not.toBeInTheDocument()
+  })
+
+  it('fails closed for unsupported timestamp previews and oversized pages', async () => {
+    const unsupported = createHarness(snapshot(), 'succeeded', 'preview', false, 'word')
+    renderHostEditor(unsupported)
+    expect(
+      await screen.findByTestId('host-transcript-section-transcript-section-1'),
+    ).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('host-transcript-section-transcript-section-1'))
+    fireEvent.click(screen.getByTestId('host-transcript-preview-button'))
+    await waitFor(() =>
+      expect(screen.getByTestId('host-transcript-error')).toHaveTextContent(
+        'could not be prepared',
+      ),
+    )
+    expect(unsupported.submitEdit).not.toHaveBeenCalled()
+
+    cleanup()
+    const oversized = createHarness(snapshot())
+    oversized.host.transcript!.getSections = vi.fn(() => ({
+      transcriptId: 'transcript-1',
+      sections: Array.from({ length: 51 }, (_, index) => ({
+        ...sections[0]!,
+        id: `oversized-section-${index}`,
+        ordinal: index,
+        startUs: index * 1_000,
+        endUs: index * 1_000 + 500,
+      })),
+      hasMore: false,
+      nextCursor: null,
+    }))
+    renderHostEditor(oversized)
+    expect(await screen.findByTestId('host-transcript-unavailable')).toHaveTextContent(
+      'could not be loaded',
+    )
+    expect(oversized.previewCommands).not.toHaveBeenCalled()
+  })
+
+  it('keeps pending and running states retryable and terminal states fail closed', async () => {
+    const states = [
+      { status: 'pending' as const, retryable: true, message: 'not ready for command conversion' },
+      { status: 'running' as const, retryable: true, message: 'not ready for command conversion' },
+      { status: 'failed' as const, retryable: false, message: 'no longer available' },
+      { status: 'stale' as const, retryable: false, message: 'no longer available' },
+      { status: 'purged' as const, retryable: false, message: 'no longer available' },
+    ]
+
+    for (const state of states) {
+      const harness = createHarness(snapshot(), state.status)
+      renderHostEditor(harness)
+      expect(await screen.findByTestId('host-transcript-unavailable')).toHaveTextContent(
+        state.message,
+      )
+      if (state.retryable) {
+        expect(screen.getByTestId('host-transcript-retry')).toBeInTheDocument()
+      } else {
+        expect(screen.queryByTestId('host-transcript-retry')).not.toBeInTheDocument()
+      }
+      expect(harness.host.transcript?.getSections).not.toHaveBeenCalled()
+      cleanup()
+    }
+  })
+
+  it('fails closed for malformed host sections and does not import local transcript services', async () => {
+    const harness = createHarness(snapshot())
+    harness.host.transcript!.getSections = vi.fn(() => ({
+      transcriptId: 'transcript-1',
+      sections: [
+        {
+          ...sections[0]!,
+          endUs: sections[0]!.startUs,
+        },
+      ],
+      hasMore: false,
+      nextCursor: null,
+    }))
+    renderHostEditor(harness)
+    expect(await screen.findByTestId('host-transcript-unavailable')).toHaveTextContent(
+      'could not be loaded',
+    )
+    expect(harness.previewCommands).not.toHaveBeenCalled()
+
+    const source = readFileSync('src/features/editor/host/transcript-editor.tsx', 'utf8')
+    expect(source).not.toMatch(
+      /mediaTranscriptionService|useTranscriptIgnoreStore|loadTimeline|saveTimeline/,
+    )
+  })
+})
+
+describe('transcript tab across authoritative snapshots (real MediaSidebar path)', () => {
+  function renderRealSidebar(harness: ReturnType<typeof createHarness>) {
+    harness.runtime.mountStores()
+    return render(
+      <EditorHostProvider
+        value={{ mode: 'host', capabilities: harness.host.capabilities, host: harness.host }}
+      >
+        <HostTranscriptEditorProvider runtime={harness.runtime}>
+          <MediaSidebar />
+        </HostTranscriptEditorProvider>
+      </EditorHostProvider>,
+    )
+  }
+
+  async function drivePreviewAndApply() {
+    act(() => {
+      useEditorStore.getState().setActiveTab('transcript')
+    })
+    expect(
+      await screen.findByTestId('host-transcript-section-transcript-section-1'),
+    ).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('host-transcript-section-transcript-section-1'))
+    fireEvent.click(screen.getByTestId('host-transcript-preview-button'))
+    await waitFor(() => expect(screen.getByTestId('host-transcript-preview')).toBeInTheDocument())
+    fireEvent.click(screen.getByTestId('host-transcript-apply'))
+  }
+
+  afterEach(() => {
+    useEditorStore.setState({ activeTab: 'media' })
+  })
+
+  it('keeps the transcript panel mounted with its applied state after apply', async () => {
+    const harness = createHarness(snapshot())
+    try {
+      renderRealSidebar(harness)
+      await drivePreviewAndApply()
+      await waitFor(() => expect(harness.submitEdit).toHaveBeenCalledTimes(1))
+      // Installing the authoritative snapshot must not unmount the panel.
+      expect(useEditorStore.getState().activeTab).toBe('transcript')
+      expect(screen.getByTestId('host-transcript-editor')).toBeInTheDocument()
+      await waitFor(() =>
+        expect(screen.getByText('Transcript captions applied.')).toBeInTheDocument(),
+      )
+    } finally {
+      harness.runtime.unmountStores()
+    }
+  })
+
+  it('keeps the transcript panel mounted with the inline revision-conflict error', async () => {
+    const harness = createHarness(snapshot(), 'succeeded', 'preview', true)
+    try {
+      renderRealSidebar(harness)
+      await drivePreviewAndApply()
+      await waitFor(() =>
+        expect(screen.getByTestId('host-transcript-error')).toHaveTextContent(
+          'timeline changed before this transcript edit was applied',
+        ),
+      )
+      expect(useEditorStore.getState().activeTab).toBe('transcript')
+      expect(screen.getByTestId('host-transcript-editor')).toBeInTheDocument()
+      expect(screen.queryByTestId('host-transcript-preview')).not.toBeInTheDocument()
+    } finally {
+      harness.runtime.unmountStores()
+    }
+  })
+
+  it('still resets a sidebar tab that host mode does not show', () => {
+    const harness = createHarness(snapshot())
+    try {
+      act(() => {
+        useEditorStore.getState().setActiveTab('effects')
+      })
+      harness.runtime.mountStores()
+      expect(useEditorStore.getState().activeTab).toBe('media')
+    } finally {
+      harness.runtime.unmountStores()
+    }
+  })
+})
diff --git a/src/features/editor/host/transcript-editor.tsx b/src/features/editor/host/transcript-editor.tsx
new file mode 100644
index 000000000..466058eae
--- /dev/null
+++ b/src/features/editor/host/transcript-editor.tsx
@@ -0,0 +1,903 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { AlertCircle, CheckCircle2, ChevronDown, Loader2, RefreshCw, Search } from 'lucide-react'
+
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import type { EditCommandBatch, EditCommand } from '@/features/editor/codepress/contract'
+import { validateCommandBatch } from '@/features/editor/codepress/contract'
+import {
+  capabilityForCommand,
+  isHostCapabilityEnabled,
+  MAX_TRANSCRIPT_COMMAND_TEXT_BYTES,
+  MAX_TRANSCRIPT_CURSOR_LENGTH,
+  MAX_TRANSCRIPT_DURATION_US,
+  MAX_TRANSCRIPT_QUERY_LENGTH,
+  MAX_TRANSCRIPT_SECTION_PAGE_SIZE,
+  MAX_TRANSCRIPT_SECTION_TEXT_BYTES,
+  MAX_TRANSCRIPT_SELECTIONS,
+  type EditorCapabilityMap,
+  type HostTranscriptCommandPreview,
+  type HostTranscriptError,
+  type HostTranscriptRange,
+  type HostTranscriptSection,
+  type HostTranscriptSectionsPage,
+  type HostTranscriptStatusReceipt,
+  type HostTranscriptStatus,
+} from './contract'
+import { useEditorHostContext } from './context'
+import { useHostTranscriptEditorRuntime } from './transcript-editor-context'
+
+const OPAQUE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u
+const SAFE_HASH_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u
+const TRANSCRIPT_STATUSES: readonly HostTranscriptStatus[] = [
+  'pending',
+  'running',
+  'succeeded',
+  'failed',
+  'stale',
+  'purged',
+]
+
+interface TranscriptUiError extends HostTranscriptError {
+  source: 'host' | 'validation' | 'submission'
+}
+
+interface NormalizedPage extends HostTranscriptSectionsPage {
+  nextCursor: string | null
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isOpaqueId(value: unknown): value is string {
+  return typeof value === 'string' && OPAQUE_ID_PATTERN.test(value)
+}
+
+function isSafeHash(value: unknown): value is string {
+  return typeof value === 'string' && SAFE_HASH_PATTERN.test(value)
+}
+
+function boundedText(value: unknown, maxBytes: number): value is string {
+  return (
+    typeof value === 'string' &&
+    value.trim().length > 0 &&
+    new TextEncoder().encode(value).byteLength <= maxBytes
+  )
+}
+
+// fallow-ignore-next-line complexity
+function errorFromHost(
+  value: unknown,
+  fallback: string,
+  source: TranscriptUiError['source'] = 'host',
+): TranscriptUiError {
+  if (isRecord(value)) {
+    const nested = isRecord(value.error) ? value.error : value
+    const code = typeof nested.code === 'string' && nested.code.length <= 128 ? nested.code : null
+    const message =
+      typeof nested.message === 'string' &&
+      nested.message.length > 0 &&
+      nested.message.length <= 512
+        ? nested.message
+        : null
+    const retryable = typeof nested.retryable === 'boolean' ? nested.retryable : false
+    if (code && message) {
+      return {
+        code,
+        message,
+        retryable,
+        ...(isRecord(nested.details) ? { details: nested.details } : {}),
+        source,
+      }
+    }
+  }
+  return { code: 'transcript_unavailable', message: fallback, retryable: false, source }
+}
+
+function unavailableError(status: HostTranscriptStatus): TranscriptUiError {
+  if (status === 'pending' || status === 'running') {
+    return {
+      code: 'transcript_not_ready',
+      message: 'The transcript is not ready yet. Retry when processing finishes.',
+      retryable: true,
+      source: 'host',
+    }
+  }
+  return {
+    code: 'transcript_content_unavailable',
+    message: 'Transcript content is no longer available.',
+    retryable: false,
+    source: 'host',
+  }
+}
+
+// fallow-ignore-next-line complexity
+function normalizeStatus(value: unknown): HostTranscriptStatusReceipt | null {
+  if (value === null) return null
+  if (!isRecord(value)) throw new Error('The host returned an invalid transcript status.')
+
+  const status = value.status
+  const transcriptId = value.transcriptId
+  const assetId = value.assetId
+  const sourceAssetHash = value.sourceAssetHash
+  const durationUs = value.durationUs
+  const sectionCount = value.sectionCount
+  const validDuration =
+    durationUs === null ||
+    (typeof durationUs === 'number' &&
+      Number.isSafeInteger(durationUs) &&
+      durationUs >= 0 &&
+      durationUs <= MAX_TRANSCRIPT_DURATION_US)
+  const validSectionCount =
+    typeof sectionCount === 'number' && Number.isSafeInteger(sectionCount) && sectionCount >= 0
+  if (
+    typeof status !== 'string' ||
+    !TRANSCRIPT_STATUSES.includes(status as HostTranscriptStatus) ||
+    !isOpaqueId(transcriptId) ||
+    (assetId !== null && !isOpaqueId(assetId)) ||
+    !isSafeHash(sourceAssetHash) ||
+    !validDuration ||
+    !validSectionCount
+  ) {
+    throw new Error('The host returned an invalid transcript status.')
+  }
+  if (status === 'succeeded' && !isOpaqueId(assetId)) {
+    throw new Error('The host returned a succeeded transcript without an asset binding.')
+  }
+
+  const rawLanguage = value.language
+  const language =
+    rawLanguage === null || rawLanguage === undefined
+      ? null
+      : typeof rawLanguage === 'string' && rawLanguage.length <= 32
+        ? rawLanguage
+        : null
+  const normalizedError =
+    value.error === null || value.error === undefined
+      ? status === 'succeeded'
+        ? null
+        : unavailableError(status as HostTranscriptStatus)
+      : errorFromHost(value.error, 'Transcript content is unavailable.')
+  const error =
+    normalizedError && status !== 'succeeded' && status !== 'pending' && status !== 'running'
+      ? { ...normalizedError, retryable: false }
+      : normalizedError
+
+  return {
+    transcriptId,
+    assetId,
+    sourceAssetHash,
+    status: status as HostTranscriptStatus,
+    language,
+    durationUs: durationUs as number | null,
+    sectionCount: sectionCount as number,
+    error,
+  }
+}
+
+// fallow-ignore-next-line complexity
+function normalizeSection(value: unknown, expectedTranscriptId: string): HostTranscriptSection {
+  if (!isRecord(value)) throw new Error('The host returned an invalid transcript section.')
+  const { id, transcriptId, ordinal, startUs, endUs, text, speaker } = value
+  const validOrdinal = typeof ordinal === 'number' && Number.isSafeInteger(ordinal) && ordinal >= 0
+  const validStartUs = typeof startUs === 'number' && Number.isSafeInteger(startUs) && startUs >= 0
+  const validEndUs = typeof endUs === 'number' && Number.isSafeInteger(endUs)
+  if (
+    !isOpaqueId(id) ||
+    transcriptId !== expectedTranscriptId ||
+    !validOrdinal ||
+    !validStartUs ||
+    !validEndUs ||
+    (validStartUs && validEndUs && endUs <= startUs) ||
+    (validEndUs && endUs > MAX_TRANSCRIPT_DURATION_US) ||
+    !boundedText(text, MAX_TRANSCRIPT_SECTION_TEXT_BYTES)
+  ) {
+    throw new Error('The host returned an invalid transcript section.')
+  }
+  if (
+    speaker !== undefined &&
+    speaker !== null &&
+    (typeof speaker !== 'string' || speaker.length > MAX_TRANSCRIPT_SECTION_TEXT_BYTES)
+  ) {
+    throw new Error('The host returned an invalid transcript speaker.')
+  }
+  return {
+    id,
+    transcriptId,
+    ordinal: ordinal as number,
+    startUs: startUs as number,
+    endUs: endUs as number,
+    text,
+    speaker: speaker ?? null,
+  }
+}
+
+// fallow-ignore-next-line complexity
+function normalizePage(value: unknown, expectedTranscriptId: string): NormalizedPage {
+  if (!isRecord(value) || value.transcriptId !== expectedTranscriptId) {
+    throw new Error('The host returned an invalid transcript section page.')
+  }
+  if (!Array.isArray(value.sections) || value.sections.length > MAX_TRANSCRIPT_SECTION_PAGE_SIZE) {
+    throw new Error('The host returned an oversized transcript section page.')
+  }
+  if (typeof value.hasMore !== 'boolean') {
+    throw new Error('The host returned an invalid transcript cursor state.')
+  }
+  const rawCursor = value.nextCursor
+  const nextCursor = rawCursor === null || rawCursor === undefined ? null : rawCursor
+  if (
+    nextCursor !== null &&
+    (typeof nextCursor !== 'string' ||
+      nextCursor.length === 0 ||
+      nextCursor.length > MAX_TRANSCRIPT_CURSOR_LENGTH)
+  ) {
+    throw new Error('The host returned an invalid transcript cursor.')
+  }
+  if (value.hasMore && nextCursor === null) {
+    throw new Error('The host returned an uncontinuable transcript cursor.')
+  }
+  const sections = value.sections.map((section) => normalizeSection(section, expectedTranscriptId))
+  const ids = new Set<string>()
+  for (const section of sections) {
+    if (ids.has(section.id)) throw new Error('The host returned duplicate transcript sections.')
+    ids.add(section.id)
+  }
+  return {
+    transcriptId: expectedTranscriptId,
+    sections,
+    hasMore: value.hasMore,
+    nextCursor,
+  }
+}
+
+// fallow-ignore-next-line complexity
+function normalizeCommandBatch(value: unknown, expectedRevision: number): EditCommandBatch {
+  if (!isRecord(value)) throw new Error('The host returned an invalid transcript command batch.')
+  if (
+    value.base_revision !== expectedRevision ||
+    !isOpaqueId(value.timeline_id) ||
+    !isOpaqueId(value.operation_id) ||
+    !isOpaqueId(value.idempotency_key)
+  ) {
+    throw new Error('The host returned an invalid transcript command batch.')
+  }
+  const validation = validateCommandBatch(value)
+  if (!validation.ok) throw new Error('The host returned an invalid transcript command batch.')
+  return validation.value
+}
+
+// fallow-ignore-next-line complexity
+function normalizePreview(
+  value: unknown,
+  expected: {
+    transcriptId: string
+    assetId: string
+    sourceAssetHash: string
+    timelineId: string
+    baseRevision: number
+  },
+): HostTranscriptCommandPreview {
+  if (!isRecord(value)) throw new Error('The host returned an invalid transcript preview.')
+  const previewValue = isRecord(value.preview) ? value.preview : null
+  const willMutateTimeline = previewValue
+    ? (previewValue.willMutateTimeline ?? previewValue.will_mutate_timeline)
+    : undefined
+  if (
+    (value.status !== 'preview' && value.status !== 'replayed') ||
+    !isOpaqueId(value.receiptId) ||
+    value.transcriptId !== expected.transcriptId ||
+    value.assetId !== expected.assetId ||
+    value.sourceAssetHash !== expected.sourceAssetHash ||
+    value.timestampCapability !== 'section' ||
+    value.timelineId !== expected.timelineId ||
+    !isOpaqueId(value.operationId) ||
+    !isOpaqueId(value.idempotencyKey) ||
+    value.baseRevision !== expected.baseRevision ||
+    previewValue === null ||
+    willMutateTimeline !== false
+  ) {
+    throw new Error('The host returned an invalid transcript preview.')
+  }
+  const commandBatch = normalizeCommandBatch(value.commandBatch, expected.baseRevision)
+  if (
+    commandBatch.timeline_id !== expected.timelineId ||
+    commandBatch.operation_id !== value.operationId ||
+    commandBatch.idempotency_key !== value.idempotencyKey
+  ) {
+    throw new Error('The host returned a transcript preview for a different operation.')
+  }
+  return {
+    status: value.status,
+    receiptId: value.receiptId,
+    transcriptId: value.transcriptId,
+    assetId: value.assetId,
+    sourceAssetHash: value.sourceAssetHash,
+    timestampCapability: 'section',
+    timelineId: value.timelineId,
+    operationId: value.operationId,
+    idempotencyKey: value.idempotencyKey,
+    baseRevision: value.baseRevision,
+    commandBatch,
+    preview: {
+      ...(previewValue as HostTranscriptCommandPreview['preview']),
+      willMutateTimeline: false,
+    },
+  }
+}
+
+function newOperationId(prefix: string): string {
+  const suffix =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : Math.random().toString(36).slice(2)
+  return `${prefix}-${suffix}`
+}
+
+function formatTimecode(microseconds: number): string {
+  const totalSeconds = Math.max(0, Math.floor(microseconds / 1_000_000))
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  return `${minutes}:${String(seconds).padStart(2, '0')}`
+}
+
+function rangesForSelection(sections: readonly HostTranscriptSection[]): HostTranscriptRange[] {
+  const ordered = [...sections].sort((left, right) => left.ordinal - right.ordinal)
+  const ranges: HostTranscriptRange[] = []
+  let totalTextBytes = 0
+  let previous: HostTranscriptSection | undefined
+  for (const section of ordered) {
+    if (section.endUs <= section.startUs || section.endUs > MAX_TRANSCRIPT_DURATION_US) {
+      throw new Error('The selected transcript range is invalid.')
+    }
+    if (previous && section.startUs < previous.endUs) {
+      throw new Error('The selected transcript ranges overlap.')
+    }
+    totalTextBytes += new TextEncoder().encode(section.text).byteLength
+    if (totalTextBytes > MAX_TRANSCRIPT_COMMAND_TEXT_BYTES) {
+      throw new Error('The selected transcript text exceeds the bounded command limit.')
+    }
+    ranges.push({ startUs: section.startUs, endUs: section.endUs, text: section.text })
+    previous = section
+  }
+  if (ranges.length === 0) throw new Error('Select at least one transcript section.')
+  if (ranges.length > MAX_TRANSCRIPT_SELECTIONS) {
+    throw new Error(`Select no more than ${MAX_TRANSCRIPT_SELECTIONS} transcript sections.`)
+  }
+  return ranges
+}
+
+function commandIsSupported(command: EditCommand, capabilities: EditorCapabilityMap): boolean {
+  const capability = capabilityForCommand(command.type)
+  return capability !== null && isHostCapabilityEnabled(capabilities, capability)
+}
+
+function UnavailableTranscript({
+  error,
+  onRetry,
+}: {
+  error: TranscriptUiError
+  onRetry?: () => void
+}) {
+  return (
+    <div
+      className="flex h-full flex-col items-center justify-center gap-3 p-4 text-center"
+      data-testid="host-transcript-unavailable"
+      role="status"
+    >
+      <AlertCircle className="h-8 w-8 text-muted-foreground/60" />
+      <div className="max-w-[34ch] space-y-1">
+        <p className="text-sm text-muted-foreground">{error.message}</p>
+        <p className="text-[11px] text-muted-foreground/75">{error.code}</p>
+      </div>
+      {error.retryable && onRetry ? (
+        <Button type="button" size="sm" onClick={onRetry} data-testid="host-transcript-retry">
+          <RefreshCw className="mr-1.5 h-3.5 w-3.5" />
+          Retry
+        </Button>
+      ) : null}
+    </div>
+  )
+}
+
+/**
+ * Host-mode transcript consumer for the real Media/Transcript sidebar path.
+ * This component intentionally has no dependency on FreeCut transcript stores,
+ * transcription services, IndexedDB, OPFS, workspace handles, or project save
+ * paths.  Preview is held locally; only Apply crosses the host edit port.
+ */
+// fallow-ignore-next-line complexity
+export function HostTranscriptEditor({ active = true }: { active?: boolean }) {
+  const { t } = useTranslation()
+  const { capabilities, host } = useEditorHostContext()
+  const runtime = useHostTranscriptEditorRuntime()
+  const port = host?.transcript
+  const canTranscribe = isHostCapabilityEnabled(capabilities, 'media.transcription')
+
+  const [status, setStatus] = useState<HostTranscriptStatusReceipt | null>(null)
+  const [sections, setSections] = useState<HostTranscriptSection[]>([])
+  const [nextCursor, setNextCursor] = useState<string | null>(null)
+  const [hasMore, setHasMore] = useState(false)
+  const [loading, setLoading] = useState(false)
+  const [loadingMore, setLoadingMore] = useState(false)
+  const [error, setError] = useState<TranscriptUiError | null>(null)
+  const [query, setQuery] = useState('')
+  const [selectedIds, setSelectedIds] = useState<Set<string>>(() => new Set())
+  const [selectionAnchor, setSelectionAnchor] = useState<number | null>(null)
+  const [preview, setPreview] = useState<HostTranscriptCommandPreview | null>(null)
+  const [previewing, setPreviewing] = useState(false)
+  const [applying, setApplying] = useState(false)
+  const [announcement, setAnnouncement] = useState('')
+  const requestGeneration = useRef(0)
+  const loadedSectionCount = useRef(0)
+
+  const loadSectionsPage = useCallback(
+    async (
+      receipt: HostTranscriptStatusReceipt,
+      cursor: string | null,
+      replace: boolean,
+    ): Promise<void> => {
+      if (!port) return
+      const page = normalizePage(
+        await port.getSections({
+          transcriptId: receipt.transcriptId,
+          cursor,
+          limit: MAX_TRANSCRIPT_SECTION_PAGE_SIZE,
+        }),
+        receipt.transcriptId,
+      )
+      const durationUs = receipt.durationUs
+      if (
+        (durationUs !== null && page.sections.some((section) => section.endUs > durationUs)) ||
+        (!replace &&
+          page.sections.length + loadedSectionCount.current >
+            MAX_TRANSCRIPT_SELECTIONS * MAX_TRANSCRIPT_SECTION_PAGE_SIZE)
+      ) {
+        throw new Error('The host returned transcript sections outside the bounded transcript.')
+      }
+      setSections((current) => {
+        const next = replace ? [] : [...current]
+        const ids = new Set(next.map((section) => section.id))
+        for (const section of page.sections) {
+          if (!ids.has(section.id)) next.push(section)
+        }
+        const sorted = next.toSorted((left, right) => left.ordinal - right.ordinal)
+        loadedSectionCount.current = sorted.length
+        return sorted
+      })
+      setNextCursor(page.nextCursor)
+      setHasMore(page.hasMore)
+    },
+    [port],
+  )
+
+  // fallow-ignore-next-line complexity
+  const refresh = useCallback(async () => {
+    if (!port || !canTranscribe) return
+    const generation = requestGeneration.current + 1
+    requestGeneration.current = generation
+    setLoading(true)
+    setError(null)
+    setPreview(null)
+    setSelectedIds(new Set())
+    setSelectionAnchor(null)
+    loadedSectionCount.current = 0
+    try {
+      const receipt = normalizeStatus(await port.getStatus())
+      if (requestGeneration.current !== generation) return
+      setStatus(receipt)
+      setSections([])
+      setNextCursor(null)
+      setHasMore(false)
+      if (!receipt) {
+        setError({
+          code: 'transcript_unavailable',
+          message: 'No application transcript is available for this project.',
+          retryable: false,
+          source: 'host',
+        })
+        return
+      }
+      if (receipt.status !== 'succeeded') {
+        setError(
+          errorFromHost(
+            receipt.error ?? unavailableError(receipt.status),
+            'Transcript content is unavailable.',
+          ),
+        )
+        return
+      }
+      await loadSectionsPage(receipt, null, true)
+    } catch (caught) {
+      if (requestGeneration.current !== generation) return
+      setStatus(null)
+      setSections([])
+      loadedSectionCount.current = 0
+      setError(errorFromHost(caught, 'The transcript could not be loaded.'))
+    } finally {
+      if (requestGeneration.current === generation) setLoading(false)
+    }
+  }, [canTranscribe, loadSectionsPage, port])
+
+  useEffect(() => {
+    if (!active || !port || !canTranscribe) return
+    void refresh()
+  }, [active, canTranscribe, port, refresh])
+
+  const loadMore = useCallback(async () => {
+    if (!status || status.status !== 'succeeded' || !nextCursor || !port || loadingMore) return
+    setLoadingMore(true)
+    try {
+      await loadSectionsPage(status, nextCursor, false)
+    } catch (caught) {
+      setError(errorFromHost(caught, 'More transcript sections could not be loaded.'))
+    } finally {
+      setLoadingMore(false)
+    }
+  }, [loadSectionsPage, loadingMore, nextCursor, port, status])
+
+  const normalizedQuery = query.trim().toLowerCase()
+  const visibleSections = useMemo(() => {
+    if (!normalizedQuery) return sections
+    return sections.filter((section) => {
+      const haystack = `${section.text} ${section.speaker ?? ''}`.toLowerCase()
+      return haystack.includes(normalizedQuery)
+    })
+  }, [normalizedQuery, sections])
+
+  const selectedSections = useMemo(
+    () => sections.filter((section) => selectedIds.has(section.id)),
+    [sections, selectedIds],
+  )
+
+  const selectSection = useCallback(
+    (index: number, shiftKey: boolean) => {
+      const section = visibleSections[index]
+      if (!section) return
+      setSelectedIds((current) => {
+        const next = new Set(current)
+        if (shiftKey && selectionAnchor !== null) {
+          const lo = Math.min(selectionAnchor, index)
+          const hi = Math.min(visibleSections.length - 1, Math.max(selectionAnchor, index))
+          for (const candidate of visibleSections.slice(lo, hi + 1)) {
+            if (next.size >= MAX_TRANSCRIPT_SELECTIONS && !next.has(candidate.id)) break
+            next.add(candidate.id)
+          }
+        } else if (next.has(section.id)) {
+          next.delete(section.id)
+        } else if (next.size < MAX_TRANSCRIPT_SELECTIONS) {
+          next.add(section.id)
+        }
+        return next
+      })
+      setSelectionAnchor(index)
+      setPreview(null)
+      setError(null)
+    },
+    [selectionAnchor, visibleSections],
+  )
+
+  // fallow-ignore-next-line complexity
+  const previewSelection = useCallback(async () => {
+    if (!port || !runtime || !status || status.status !== 'succeeded' || previewing) return
+    if (!isOpaqueId(status.assetId)) {
+      setError({
+        code: 'transcript_content_unavailable',
+        message: 'The succeeded transcript no longer has an asset binding.',
+        retryable: false,
+        source: 'validation',
+      })
+      return
+    }
+    setPreviewing(true)
+    setError(null)
+    setAnnouncement('Preparing a non-mutating transcript preview…')
+    try {
+      const ranges = rangesForSelection(selectedSections)
+      const currentSnapshot = runtime.controller.getSnapshot()
+      const request = {
+        transcriptId: status.transcriptId,
+        assetId: status.assetId,
+        sourceAssetHash: status.sourceAssetHash,
+        operationId: newOperationId('transcript-preview'),
+        idempotencyKey: newOperationId('transcript-preview-key'),
+        baseRevision: currentSnapshot.timeline.revision,
+        action: 'captions' as const,
+        timestampCapability: 'section' as const,
+        ranges,
+        captionTrackId: 'host-transcript-captions',
+        captionTrackName: 'Transcript captions',
+        captionLanguage: status.language ?? null,
+        preconditions: [],
+      }
+      const result = normalizePreview(await port.previewCommands(request), {
+        transcriptId: status.transcriptId,
+        assetId: status.assetId,
+        sourceAssetHash: status.sourceAssetHash,
+        timelineId: currentSnapshot.timeline.timelineId,
+        baseRevision: currentSnapshot.timeline.revision,
+      })
+      if (
+        result.commandBatch.commands.some((command) => !commandIsSupported(command, capabilities))
+      ) {
+        throw new Error('The transcript preview contains an unsupported timeline command.')
+      }
+      setPreview(result)
+      setAnnouncement(
+        result.status === 'replayed'
+          ? 'Transcript preview replayed safely.'
+          : 'Transcript preview ready. The timeline was not changed.',
+      )
+    } catch (caught) {
+      setPreview(null)
+      const nextError =
+        caught instanceof Error && caught.message.startsWith('Select')
+          ? errorFromHost(
+              { code: 'invalid_selection', message: caught.message, retryable: false },
+              caught.message,
+              'validation',
+            )
+          : errorFromHost(
+              caught,
+              'The transcript preview could not be prepared.',
+              caught instanceof Error ? 'validation' : 'host',
+            )
+      setError(nextError)
+      setAnnouncement(nextError.message)
+    } finally {
+      setPreviewing(false)
+    }
+  }, [capabilities, port, previewing, runtime, selectedSections, status])
+
+  // fallow-ignore-next-line complexity
+  const applyPreview = useCallback(async () => {
+    if (!runtime || !preview || applying) return
+    setApplying(true)
+    setError(null)
+    setAnnouncement('Applying transcript captions…')
+    try {
+      const result = await runtime.controller.submitEdit(preview.commandBatch)
+      if (result.status === 'applied' || result.status === 'replayed') {
+        setAnnouncement(
+          result.status === 'replayed'
+            ? 'Transcript captions replayed safely.'
+            : 'Transcript captions applied.',
+        )
+        return
+      }
+      const message =
+        result.status === 'unsupported'
+          ? result.reason
+          : result.status === 'conflict' || result.status === 'rejected'
+            ? result.result.error.message || 'The transcript caption edit was rejected.'
+            : 'The transcript caption edit was rejected.'
+      setPreview(null)
+      const nextError = errorFromHost(
+        {
+          code: result.status === 'conflict' ? 'revision_conflict' : 'transcript_apply_rejected',
+          message,
+          retryable: result.status === 'conflict',
+        },
+        message,
+        'submission',
+      )
+      setError(nextError)
+      setAnnouncement(message)
+    } catch (caught) {
+      setPreview(null)
+      const nextError = errorFromHost(
+        caught,
+        'The transcript caption edit could not be applied.',
+        'submission',
+      )
+      setError(nextError)
+      setAnnouncement(nextError.message)
+    } finally {
+      setApplying(false)
+    }
+  }, [applying, preview, runtime])
+
+  if (!port || !runtime || !canTranscribe) {
+    return (
+      <UnavailableTranscript
+        error={{
+          code: 'transcript_unavailable',
+          message: 'Transcript access is unavailable for this host.',
+          retryable: false,
+          source: 'host',
+        }}
+      />
+    )
+  }
+
+  if (loading) {
+    return (
+      <div
+        className="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground"
+        data-testid="host-transcript-loading"
+        role="status"
+      >
+        <Loader2 className="h-4 w-4 animate-spin" />
+        {t('transcript.loading', { defaultValue: 'Loading transcript…' })}
+      </div>
+    )
+  }
+
+  if (error && (!status || status.status !== 'succeeded')) {
+    return <UnavailableTranscript error={error} onRetry={error.retryable ? refresh : undefined} />
+  }
+
+  return (
+    <div
+      className="flex h-full flex-col outline-none"
+      data-testid="host-transcript-editor"
+      role="region"
+      aria-label={t('transcript.title', { defaultValue: 'Transcript' })}
+    >
+      <div className="flex items-center gap-2 border-b border-border p-2">
+        <div className="relative flex-1">
+          <Search className="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input
+            value={query}
+            onChange={(event) => {
+              const next = event.target.value
+              if (next.length <= MAX_TRANSCRIPT_QUERY_LENGTH) setQuery(next)
+            }}
+            placeholder={t('transcript.searchPlaceholder', { defaultValue: 'Search transcript' })}
+            aria-label={t('transcript.searchPlaceholder', { defaultValue: 'Search transcript' })}
+            className="h-8 pl-7 text-xs"
+          />
+        </div>
+        <Button
+          type="button"
+          variant="ghost"
+          size="icon"
+          className="h-8 w-8"
+          onClick={() => void refresh()}
+          aria-label="Refresh transcript"
+          data-testid="host-transcript-refresh"
+        >
+          <RefreshCw className="h-3.5 w-3.5" />
+        </Button>
+      </div>
+
+      <div className="flex items-center justify-between border-b border-border px-3 py-2 text-[11px] text-muted-foreground">
+        <span data-testid="host-transcript-status">{status?.status}</span>
+        <span>
+          {selectedIds.size}/{MAX_TRANSCRIPT_SELECTIONS} selected
+        </span>
+      </div>
+
+      {error ? (
+        <div
+          className="flex items-start gap-2 border-b border-border bg-destructive/5 px-3 py-2 text-xs text-destructive"
+          data-testid="host-transcript-error"
+          role="alert"
+        >
+          <AlertCircle className="mt-0.5 h-3.5 w-3.5 shrink-0" />
+          <span>{error.message}</span>
+          {error.retryable ? (
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              className="ml-auto h-6 shrink-0 px-2 text-xs"
+              onClick={() => void refresh()}
+            >
+              Retry
+            </Button>
+          ) : null}
+        </div>
+      ) : null}
+
+      <div className="min-h-0 flex-1 overflow-x-hidden overflow-y-auto px-3 py-2">
+        {visibleSections.length === 0 ? (
+          <div className="flex h-full items-center justify-center p-4 text-center text-sm text-muted-foreground">
+            {normalizedQuery
+              ? 'No transcript sections match this search.'
+              : 'No transcript sections are available.'}
+          </div>
+        ) : (
+          <div className="mx-auto max-w-[62ch] space-y-1">
+            {visibleSections.map((section, index) => {
+              const selected = selectedIds.has(section.id)
+              return (
+                <button
+                  key={section.id}
+                  type="button"
+                  data-testid={`host-transcript-section-${section.id}`}
+                  aria-pressed={selected}
+                  onClick={(event) => selectSection(index, event.shiftKey)}
+                  className={`grid w-full grid-cols-[3rem_minmax(0,1fr)] gap-x-3 rounded-md px-1 py-1.5 text-left transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary ${
+                    selected
+                      ? 'bg-primary text-primary-foreground'
+                      : 'text-foreground/85 hover:bg-secondary/60'
+                  }`}
+                >
+                  <span className="mt-px select-none text-right font-mono text-[11px] tabular-nums leading-7 opacity-70">
+                    {formatTimecode(section.startUs)}
+                  </span>
+                  <span className="min-w-0 break-words text-[13px] leading-7">
+                    {section.text}
+                    {section.speaker ? (
+                      <span className="ml-1 text-[11px] opacity-70">({section.speaker})</span>
+                    ) : null}
+                  </span>
+                </button>
+              )
+            })}
+          </div>
+        )}
+        {hasMore ? (
+          <div className="flex justify-center py-3">
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              onClick={() => void loadMore()}
+              disabled={loadingMore}
+              data-testid="host-transcript-load-more"
+            >
+              {loadingMore && <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" />}
+              Load more
+              <ChevronDown className="ml-1.5 h-3.5 w-3.5" />
+            </Button>
+          </div>
+        ) : null}
+      </div>
+
+      {preview ? (
+        <div
+          className="border-t border-border bg-secondary/30 px-3 py-2"
+          data-testid="host-transcript-preview"
+        >
+          <div className="flex items-start gap-2">
+            <CheckCircle2 className="mt-0.5 h-3.5 w-3.5 shrink-0 text-emerald-500" />
+            <div className="min-w-0 flex-1 text-xs">
+              <p className="font-medium text-foreground">
+                {preview.status === 'replayed' ? 'Preview replayed safely.' : 'Preview ready.'}
+              </p>
+              <p className="text-[11px] leading-4 text-muted-foreground">
+                {preview.preview.captionCount ?? selectedIds.size} caption(s) · timeline unchanged
+              </p>
+            </div>
+          </div>
+          <Button
+            type="button"
+            size="sm"
+            className="mt-2 w-full"
+            onClick={() => void applyPreview()}
+            disabled={applying}
+            data-testid="host-transcript-apply"
+          >
+            {applying && <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" />}
+            Apply captions
+          </Button>
+        </div>
+      ) : null}
+
+      <div className="flex flex-wrap items-center justify-between gap-2 border-t border-border p-2">
+        <span className="min-w-0 text-xs text-muted-foreground">
+          {selectedIds.size > 0
+            ? `${selectedIds.size} section${selectedIds.size === 1 ? '' : 's'} selected`
+            : 'Select sections to preview captions'}
+        </span>
+        <Button
+          type="button"
+          size="sm"
+          onClick={() => void previewSelection()}
+          disabled={selectedIds.size === 0 || previewing || applying}
+          data-testid="host-transcript-preview-button"
+        >
+          {previewing && <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" />}
+          Preview captions
+        </Button>
+      </div>
+
+      <span className="sr-only" aria-live="polite">
+        {announcement}
+      </span>
+    </div>
+  )
+}
diff --git a/src/features/media-library/components/media-card.tsx b/src/features/media-library/components/media-card.tsx
index a54b37a9d..9c60c68ad 100644
--- a/src/features/media-library/components/media-card.tsx
+++ b/src/features/media-library/components/media-card.tsx
@@ -43,6 +43,7 @@ import { importMediaLibraryService } from '../services/media-library-service-loa
 import { importMediaAnalysisService } from '../services/media-analysis-service-loader'
 import { getMediaType, formatDuration } from '../utils/validation'
 import { MediaInfoPopover } from './media-info-popover'
+import { useEditorCapability, useEditorHostMode } from '../deps/editor'
 import { getSharedProxyKey } from '../utils/proxy-key'
 import { useMediaLibraryStore } from '../stores/media-library-store'
 import { useMediaPreparationStore } from '../stores/media-preparation-store'
@@ -121,6 +122,7 @@ interface MediaCardActionMenuProps {
   onExtractEmbeddedSubtitles: (event: React.MouseEvent) => void | Promise<void>
   onAnalyzeWithAI: (event: React.MouseEvent) => void
   onDelete: (event: React.MouseEvent) => void
+  canDelete: boolean
 }
 
 type MediaCardMenuGroupProps = {
@@ -314,6 +316,7 @@ function resolveMenuVisibility(props: MediaCardActionMenuProps) {
   }
 }
 
+// fallow-ignore-next-line complexity
 function MediaCardActionMenuItems(props: MediaCardActionMenuProps) {
   const {
     onRelink,
@@ -420,7 +423,9 @@ function MediaCardActionMenuItems(props: MediaCardActionMenuProps) {
     groups.push(<AiActions key="ai" t={t} onAnalyzeWithAI={onAnalyzeWithAI} />)
   }
 
-  groups.push(<DeleteMediaAction key="destructive" t={t} onDelete={onDelete} />)
+  if (props.canDelete) {
+    groups.push(<DeleteMediaAction key="destructive" t={t} onDelete={onDelete} />)
+  }
 
   return (
     <>
@@ -669,6 +674,11 @@ const MediaCardInternal = memo(function MediaCardInternal({
   layout,
 }: MediaCardInternalProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
+  const canDeleteMedia = useEditorCapability('media.delete')
+  const canGenerateProxyCapability = useEditorCapability('media.proxy')
+  const canTranscribeCapability = useEditorCapability('media.transcription')
+  const canRelinkCapability = useEditorCapability('media.relink')
   const [thumbnailUrl, setThumbnailUrl] = useState<string | null>(null)
   const [skimProgress, setSkimProgress] = useState<number | null>(null)
   const isImporting = useMediaLibraryStore(
@@ -699,14 +709,18 @@ const MediaCardInternal = memo(function MediaCardInternal({
   const transcriptProgress = useMediaLibraryStore((s) => s.transcriptProgress.get(media.id))
 
   const mediaType = getMediaType(media.mimeType)
-  const isTranscribable = mediaType === 'video' || mediaType === 'audio'
+  const isTranscribable =
+    canTranscribeCapability && (mediaType === 'video' || mediaType === 'audio')
   const canGenerateProxy =
+    canGenerateProxyCapability &&
+    !hostMode &&
     mediaType === 'video' &&
     !isBroken &&
     !isPreparingMedia &&
     proxyService.canGenerateProxy(media.mimeType)
   const hasProxy = proxyStatus === 'ready'
   const canInterpolate =
+    !hostMode &&
     mediaType === 'video' &&
     !isBroken &&
     !isPreparingMedia &&
@@ -714,6 +728,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
   // Hidden rather than disabled when the 2x output would be too large for any encoder to take:
   // there is nothing the user could do about it from this menu.
   const canUpscaleMedia =
+    !hostMode &&
     mediaType === 'video' &&
     !isBroken &&
     !isPreparingMedia &&
@@ -721,7 +736,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
   const hasTranscript = transcriptStatus === 'ready'
   const isTranscribing = transcriptStatus === 'transcribing' || transcriptStatus === 'queued'
   const isTagging = useMediaLibraryStore((s) => s.taggingMediaIds.has(media.id))
-  const isTaggable = mediaType === 'video' || mediaType === 'image'
+  const isTaggable = !hostMode && (mediaType === 'video' || mediaType === 'image')
   const hasCaptions = (media.aiCaptions?.length ?? 0) > 0
   const thumbnailRef = useRef<HTMLImageElement>(null)
   const thumbnailContainerRef = useRef<HTMLDivElement | null>(null)
@@ -731,13 +746,17 @@ const MediaCardInternal = memo(function MediaCardInternal({
   const isTranscriptionDialogOpen = useEditorStore((s) => s.transcriptionDialogDepth > 0)
   const pauseTimelinePlayback = usePlaybackStore((s) => s.pause)
 
-  const isAudio = mediaType === 'audio' && !isBroken && !isPreparingMedia
+  const isAudio = !hostMode && mediaType === 'audio' && !isBroken && !isPreparingMedia
   const [transcribeDialogOpen, setTranscribeDialogOpen] = useState(false)
   const [transcribeErrorMessage, setTranscribeErrorMessage] = useState<string | null>(null)
   const [isExtractingEmbeddedSubtitles, setIsExtractingEmbeddedSubtitles] = useState(false)
 
   // Load thumbnail on mount and when thumbnailId changes (e.g. after regeneration)
   useEffect(() => {
+    if (hostMode) {
+      setThumbnailUrl(null)
+      return
+    }
     let mounted = true
 
     const loadThumbnail = async () => {
@@ -753,7 +772,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
     return () => {
       mounted = false
     }
-  }, [media.id, media.thumbnailId])
+  }, [hostMode, media.id, media.thumbnailId])
 
   const getTargetMediaItems = useCallback((): MediaMetadata[] => {
     const store = useMediaLibraryStore.getState()
@@ -779,12 +798,14 @@ const MediaCardInternal = memo(function MediaCardInternal({
 
   const handleDelete = (e: React.MouseEvent) => {
     e.stopPropagation()
+    if (!canDeleteMedia) return
     const targets = getTargetMediaItems()
     onDelete?.(targets.map((m) => m.id))
   }
 
   const handleGenerateProxy = (e: React.MouseEvent) => {
     e.stopPropagation()
+    if (!canGenerateProxy) return
     const store = useMediaLibraryStore.getState()
     const targets = getTargetMediaItems().filter(
       (m) =>
@@ -932,6 +953,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
 
   const handleStartTranscription = useCallback(
     (values: TranscribeDialogValues) => {
+      if (!isTranscribable) return
       const store = useMediaLibraryStore.getState()
       const targets = getTargetMediaItems()
 
@@ -1008,7 +1030,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
         }
       })()
     },
-    [getTargetMediaItems],
+    [getTargetMediaItems, isTranscribable],
   )
 
   const handleCancelTranscript = (e?: React.MouseEvent) => {
@@ -1070,6 +1092,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
 
   const handleExtractEmbeddedSubtitles = async (e: React.MouseEvent) => {
     e.stopPropagation()
+    if (hostMode || !canTranscribeCapability) return
     const targets = getTargetMediaItems().filter(canExtractEmbeddedSubtitlesFromMedia)
     const store = useMediaLibraryStore.getState()
     if (targets.length === 0) {
@@ -1175,6 +1198,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
   const handleAnalyzeWithAI = useCallback(
     async (e: React.MouseEvent) => {
       e.stopPropagation()
+      if (hostMode) return
       const store = useMediaLibraryStore.getState()
       const analyzable = getTargetMediaItems().filter((m) => {
         const type = getMediaType(m.mimeType)
@@ -1197,7 +1221,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
         }
       }
     },
-    [media, getTargetMediaItems],
+    [getTargetMediaItems, hostMode, media],
   )
 
   const removeNativeDragCleanupListenersRef = useRef<(() => void) | null>(null)
@@ -1539,7 +1563,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
   const actionMenuItems = (
     <MediaCardActionMenuItems
       isBroken={isBroken}
-      onRelink={onRelink}
+      onRelink={canRelinkCapability ? onRelink : undefined}
       canGenerateProxy={canGenerateProxy}
       hasProxy={hasProxy}
       proxyStatus={proxyStatus}
@@ -1554,7 +1578,11 @@ const MediaCardInternal = memo(function MediaCardInternal({
       isTranscribable={isTranscribable}
       isTranscribing={isTranscribing}
       hasTranscript={hasTranscript}
-      canExtractEmbeddedSubtitles={getTargetMediaItems().some(canExtractEmbeddedSubtitlesFromMedia)}
+      canExtractEmbeddedSubtitles={
+        !hostMode &&
+        canTranscribeCapability &&
+        getTargetMediaItems().some(canExtractEmbeddedSubtitlesFromMedia)
+      }
       isExtractingEmbeddedSubtitles={isExtractingEmbeddedSubtitles}
       isTaggable={isTaggable}
       isTagging={isTagging}
@@ -1565,6 +1593,7 @@ const MediaCardInternal = memo(function MediaCardInternal({
       onExtractEmbeddedSubtitles={handleExtractEmbeddedSubtitles}
       onAnalyzeWithAI={handleAnalyzeWithAI}
       onDelete={handleDelete}
+      canDelete={canDeleteMedia}
     />
   )
 
diff --git a/src/features/media-library/components/media-grid.tsx b/src/features/media-library/components/media-grid.tsx
index a82359a0b..ea85a7671 100644
--- a/src/features/media-library/components/media-grid.tsx
+++ b/src/features/media-library/components/media-grid.tsx
@@ -36,6 +36,8 @@ interface MediaGridProps {
   itemSize?: number
   /** When provided, renders these items instead of pulling from the store */
   items?: MediaMetadata[]
+  /** Disable the local file-picker empty state for host-backed surfaces. */
+  canImportMedia?: boolean
 }
 
 interface MediaGridBaseProps extends MediaGridProps {
@@ -55,6 +57,7 @@ const MediaGridBase = memo(function MediaGridBase({
   layout,
   itemSize = 3,
   items,
+  canImportMedia = true,
 }: MediaGridBaseProps) {
   const { t } = useTranslation()
   const [showDeleteDialog, setShowDeleteDialog] = useState(false)
@@ -195,12 +198,13 @@ const MediaGridBase = memo(function MediaGridBase({
 
   // Handle click on empty state to open file picker
   const handleEmptyStateClick = useCallback(async () => {
+    if (!canImportMedia) return
     try {
       await importMedia()
     } catch (error) {
       logger.error('Import failed:', error)
     }
-  }, [importMedia])
+  }, [canImportMedia, importMedia])
 
   const cardHandlersById = useMemo(
     () =>
@@ -247,6 +251,7 @@ const MediaGridBase = memo(function MediaGridBase({
             type="button"
             className="text-center max-w-md rounded-xl border border-dashed border-border/80 p-6 transition-colors hover:border-primary/60 hover:bg-secondary/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
             onClick={handleEmptyStateClick}
+            disabled={!canImportMedia}
           >
             <div className="w-20 h-20 mx-auto mb-6 rounded-full border-2 border-dashed border-border flex items-center justify-center bg-secondary transition-colors">
               <Upload className="w-10 h-10 text-muted-foreground" />
diff --git a/src/features/media-library/components/media-info-popover.tsx b/src/features/media-library/components/media-info-popover.tsx
index 9bc810e25..ba28a775f 100644
--- a/src/features/media-library/components/media-info-popover.tsx
+++ b/src/features/media-library/components/media-info-popover.tsx
@@ -22,6 +22,7 @@ import { formatBytes } from '@/shared/utils/format-utils'
 import { mediaTranscriptionService } from '../services/media-transcription-service'
 import { getMediaTranscriptionModelLabel } from '../transcription/registry'
 import { hasMediaSource, validateMediaHandle } from '@/infrastructure/storage'
+import { useEditorHostMode } from '../deps/editor'
 
 function formatTimestamp(sec: number): string {
   const m = Math.floor(sec / 60)
@@ -45,8 +46,12 @@ type SourceStatus =
   | 'needs-permission'
   | 'unavailable'
   | 'changed'
+  | 'host'
+
+// fallow-ignore-next-line complexity
+async function resolveSourceStatus(media: MediaMetadata, hostMode: boolean): Promise<SourceStatus> {
+  if (hostMode || media.storageType === 'host') return 'host'
 
-async function resolveSourceStatus(media: MediaMetadata): Promise<SourceStatus> {
   const hasWorkspaceCopy = await hasMediaSource(media.id)
 
   if (media.storageType === 'handle') {
@@ -69,6 +74,7 @@ export function MediaInfoPopover({
   onSeekToCaption,
 }: MediaInfoPopoverProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
   const [open, setOpen] = useState(false)
   const [transcript, setTranscript] = useState<MediaTranscript | null>(null)
   const [transcriptLoading, setTranscriptLoading] = useState(false)
@@ -129,7 +135,10 @@ export function MediaInfoPopover({
   rows.push({
     icon: <Link className="w-3 h-3" />,
     label: t('media.info.source'),
-    value: t(`media.info.sourceStatus.${sourceStatus}`),
+    value:
+      sourceStatus === 'host'
+        ? t('media.info.sourceStatus.host', { defaultValue: 'Host-provided media' })
+        : t(`media.info.sourceStatus.${sourceStatus}`),
   })
 
   if (mediaType === 'video' && media.fps > 0) {
@@ -141,7 +150,7 @@ export function MediaInfoPopover({
   }
 
   useEffect(() => {
-    if (!open || !isTranscribable) {
+    if (!open || hostMode || !isTranscribable) {
       return
     }
 
@@ -164,7 +173,7 @@ export function MediaInfoPopover({
     return () => {
       cancelled = true
     }
-  }, [isTranscribable, media.id, open])
+  }, [hostMode, isTranscribable, media.id, open])
 
   useEffect(() => {
     if (!open) {
@@ -172,9 +181,14 @@ export function MediaInfoPopover({
     }
 
     let cancelled = false
+    if (hostMode || media.storageType === 'host') {
+      setSourceStatus('host')
+      return
+    }
+
     setSourceStatus('checking')
 
-    void resolveSourceStatus(media)
+    void resolveSourceStatus(media, hostMode)
       .then((status) => {
         if (!cancelled) {
           setSourceStatus(status)
@@ -189,7 +203,7 @@ export function MediaInfoPopover({
     return () => {
       cancelled = true
     }
-  }, [media, open])
+  }, [hostMode, media, open])
 
   return (
     <Popover open={open} onOpenChange={setOpen}>
diff --git a/src/features/media-library/components/media-library.tsx b/src/features/media-library/components/media-library.tsx
index 7af85ecf0..4bc935d72 100644
--- a/src/features/media-library/components/media-library.tsx
+++ b/src/features/media-library/components/media-library.tsx
@@ -101,6 +101,7 @@ import { getSupportedMediaFormatLabels } from '../utils/media-file-picker'
 import { getSharedProxyKey } from '../utils/proxy-key'
 import { getMediaType } from '../utils/validation'
 import { getProjectBrokenMediaIds } from '@/features/media-library/utils/broken-media'
+import { useEditorCapability, useEditorHostMode } from '../deps/editor'
 import type { MediaMetadata } from '@/types/storage'
 import { isMarqueeJustFinished } from '@/shared/marquee/use-marquee-selection'
 import { useMediaLibraryMarquee } from './use-media-library-marquee'
@@ -234,6 +235,10 @@ function renderTaskDetailRows(
 
 export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaLibraryProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorHostMode()
+  const canImportMedia = useEditorCapability('media.import')
+  const canDeleteMedia = useEditorCapability('media.delete')
+  const canGenerateProxy = useEditorCapability('media.proxy')
   const containerRef = useRef<HTMLDivElement>(null)
   const headerToolbarRef = useRef<HTMLDivElement>(null)
   const headerToolbarWidthRef = useRef(0)
@@ -343,6 +348,10 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
   const MediaTypeGroupView = viewMode === 'grid' ? GridMediaTypeGroup : ListMediaTypeGroup
   const EmptyMediaGrid = viewMode === 'grid' ? GridMediaGrid : ListMediaGrid
 
+  useEffect(() => {
+    if (hostMode && sceneBrowserOpen) closeSceneBrowser()
+  }, [closeSceneBrowser, hostMode, sceneBrowserOpen])
+
   // Composition navigation — show banner when inside a sub-comp
   const activeCompositionId = useCompositionNavigationStore((s) => s.activeCompositionId)
   const breadcrumbs = useCompositionNavigationStore((s) => s.breadcrumbs)
@@ -356,13 +365,13 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
 
   // HMR recovery: if media store lost project context, rehydrate it from project store.
   useEffect(() => {
-    if (!currentProjectId && projectStoreProjectId) {
+    if (!hostMode && !currentProjectId && projectStoreProjectId) {
       setCurrentProject(projectStoreProjectId)
       void loadMediaItems().catch((error) => {
         logger.error('Failed to load media library during store recovery:', error)
       })
     }
-  }, [currentProjectId, loadMediaItems, projectStoreProjectId, setCurrentProject])
+  }, [currentProjectId, hostMode, loadMediaItems, projectStoreProjectId, setCurrentProject])
 
   const selectedAssetCount = selectedMediaIds.length + selectedCompositionIds.length
   const { marquee } = useMediaLibraryMarquee({
@@ -393,10 +402,12 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
     currentProjectId,
     clearSelection,
     deleteMediaBatch,
+    enabled: canDeleteMedia,
   })
 
   // Import files by copying them into the workspace-backed media store.
   const handleImport = async () => {
+    if (!canImportMedia) return
     try {
       await importMedia({ storageMode: 'copy' })
     } catch (error) {
@@ -405,6 +416,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
   }
 
   const handleLinkImport = async () => {
+    if (!canImportMedia) return
     try {
       await importMedia({ storageMode: 'link' })
     } catch (error) {
@@ -415,7 +427,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
   const handleImportUrl = useCallback(
     async (event: React.FormEvent<HTMLFormElement>) => {
       event.preventDefault()
-      if (isImportUrlSubmitting) {
+      if (isImportUrlSubmitting || !canImportMedia) {
         return
       }
 
@@ -432,24 +444,29 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
         setIsImportUrlSubmitting(false)
       }
     },
-    [importMediaFromUrl, importUrlValue, isImportUrlSubmitting],
+    [canImportMedia, importMediaFromUrl, importUrlValue, isImportUrlSubmitting],
   )
 
   // Import files from drag-drop handles - memoized to prevent MediaGrid re-renders
   const handleImportHandles = useCallback(
     async (handles: FileSystemFileHandle[]) => {
+      if (!canImportMedia) return
       try {
         await importHandles(handles)
       } catch (error) {
         logger.error('Import failed:', error)
       }
     },
-    [importHandles],
+    [canImportMedia, importHandles],
   )
 
   // Panel-level drag/drop handling so the drop zone covers the full panel height.
   const { isDragging, handleDragEnter, handleDragOver, handleDragLeave, handleDrop } =
-    useMediaLibraryDragDrop({ showNotification, importHandles: handleImportHandles })
+    useMediaLibraryDragDrop({
+      showNotification,
+      importHandles: handleImportHandles,
+      enabled: canImportMedia,
+    })
 
   // Count of items currently generating proxies
   const currentProjectBrokenMediaIds = useMemo(
@@ -485,6 +502,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
   } = useMediaTaskProgress()
 
   const handleGenerateSelectedProxies = async () => {
+    if (!canGenerateProxy) return
     const selectedItems = selectedMediaIds
       .map((id) => mediaById[id])
       .filter(
@@ -514,6 +532,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
   }
 
   const handleCancelAllProxies = () => {
+    if (!canGenerateProxy) return
     for (const [mediaId, status] of proxyStatus.entries()) {
       if (status !== 'generating') {
         continue
@@ -640,7 +659,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
               <HeaderActionTooltip label={t('media.library.importMediaFiles')}>
                 <button
                   onClick={handleImport}
-                  disabled={!currentProjectId}
+                  disabled={!currentProjectId || !canImportMedia}
                   className="flex items-center gap-1.5 h-7 px-2.5 rounded-l-md
                     bg-primary text-primary-foreground
                     hover:bg-primary/90
@@ -656,7 +675,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
               <DropdownMenu>
                 <DropdownMenuTrigger asChild>
                   <button
-                    disabled={!currentProjectId}
+                    disabled={!currentProjectId || !canImportMedia}
                     className="flex h-7 w-7 items-center justify-center rounded-r-md border-l border-primary-foreground/20
                       bg-primary text-primary-foreground
                       hover:bg-primary/90
@@ -684,7 +703,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
             <HeaderActionTooltip label={t('media.library.importMediaFromUrl')}>
               <button
                 onClick={() => setShowImportUrlDialog(true)}
-                disabled={!currentProjectId}
+                disabled={!currentProjectId || !canImportMedia}
                 className="flex items-center gap-1.5 h-7 px-2.5 rounded-md shrink-0 border
                   bg-secondary border-border text-muted-foreground
                   hover:text-primary hover:bg-primary/10 hover:border-primary/40
@@ -773,7 +792,7 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
                 </div>
 
                 {/* Generate proxies for selection */}
-                {selectedProxyEligibleCount > 0 && (
+                {canGenerateProxy && selectedProxyEligibleCount > 0 && (
                   <HeaderActionTooltip
                     label={t('media.library.generateProxiesForSelected', {
                       count: selectedProxyEligibleCount,
@@ -800,9 +819,11 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
                 <HeaderActionTooltip label={t('media.library.deleteSelectedAssets')}>
                   <button
                     onClick={handleDeleteSelected}
+                    disabled={!canDeleteMedia}
                     className="flex items-center gap-1.5 h-7 px-2.5 rounded-md shrink-0
                       bg-destructive/10 border border-destructive/25 text-destructive
                       hover:bg-destructive/20 hover:border-destructive/40
+                      disabled:opacity-40 disabled:cursor-not-allowed
                       transition-colors duration-150"
                   >
                     <Trash2 className="w-3.5 h-3.5" />
@@ -865,7 +886,10 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
               <Button
                 type="submit"
                 disabled={
-                  !currentProjectId || importUrlValue.trim().length === 0 || isImportUrlSubmitting
+                  !currentProjectId ||
+                  !canImportMedia ||
+                  importUrlValue.trim().length === 0 ||
+                  isImportUrlSubmitting
                 }
               >
                 {isImportUrlSubmitting && <Loader2 className="w-4 h-4 animate-spin" />}
@@ -1002,23 +1026,25 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
                 <span className="hidden @[280px]:inline">{t('media.library.mediaTab')}</span>
               </button>
             </HeaderActionTooltip>
-            <HeaderActionTooltip label={t('media.library.searchScenes')}>
-              <button
-                onClick={() => {
-                  if (!sceneBrowserOpen) openSceneBrowser()
-                }}
-                aria-pressed={sceneBrowserOpen}
-                className={cn(
-                  'flex items-center gap-1 h-6 px-1.5 @[280px]:px-2 rounded-[3px] text-[11px] transition-colors duration-150',
-                  sceneBrowserOpen
-                    ? 'bg-primary text-primary-foreground'
-                    : 'text-muted-foreground hover:text-foreground',
-                )}
-              >
-                <ScanSearch className="w-3 h-3" />
-                <span className="hidden @[280px]:inline">{t('media.library.scenesTab')}</span>
-              </button>
-            </HeaderActionTooltip>
+            {!hostMode && (
+              <HeaderActionTooltip label={t('media.library.searchScenes')}>
+                <button
+                  onClick={() => {
+                    if (!sceneBrowserOpen) openSceneBrowser()
+                  }}
+                  aria-pressed={sceneBrowserOpen}
+                  className={cn(
+                    'flex items-center gap-1 h-6 px-1.5 @[280px]:px-2 rounded-[3px] text-[11px] transition-colors duration-150',
+                    sceneBrowserOpen
+                      ? 'bg-primary text-primary-foreground'
+                      : 'text-muted-foreground hover:text-foreground',
+                  )}
+                >
+                  <ScanSearch className="w-3 h-3" />
+                  <span className="hidden @[280px]:inline">{t('media.library.scenesTab')}</span>
+                </button>
+              </HeaderActionTooltip>
+            )}
           </div>
         </div>
 
@@ -1229,7 +1255,11 @@ export const MediaLibrary = memo(function MediaLibrary({ onMediaSelect }: MediaL
 
           {/* Loading / empty state when no groups to show */}
           {mediaGroups.length === 0 && (
-            <EmptyMediaGrid onMediaSelect={onMediaSelect} itemSize={mediaItemSize} />
+            <EmptyMediaGrid
+              onMediaSelect={onMediaSelect}
+              itemSize={mediaItemSize}
+              canImportMedia={canImportMedia}
+            />
           )}
         </div>
 
diff --git a/src/features/media-library/components/use-media-library-deletion.ts b/src/features/media-library/components/use-media-library-deletion.ts
index d92bb43ef..bbfdf082e 100644
--- a/src/features/media-library/components/use-media-library-deletion.ts
+++ b/src/features/media-library/components/use-media-library-deletion.ts
@@ -25,6 +25,7 @@ interface UseMediaLibraryDeletionParams {
   currentProjectId: string | null
   clearSelection: () => void
   deleteMediaBatch: (mediaIds: string[]) => Promise<void>
+  enabled?: boolean
 }
 
 /**
@@ -42,6 +43,7 @@ export function useMediaLibraryDeletion({
   currentProjectId,
   clearSelection,
   deleteMediaBatch,
+  enabled = true,
 }: UseMediaLibraryDeletionParams) {
   const { t, i18n } = useTranslation()
   const isFocusedRef = useRef(false)
@@ -74,7 +76,7 @@ export function useMediaLibraryDeletion({
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {
       // Only handle Delete key
-      if (event.key !== 'Delete') return
+      if (!enabled || event.key !== 'Delete') return
 
       // Don't trigger if media library is not focused
       if (!isFocusedRef.current) return
@@ -105,7 +107,14 @@ export function useMediaLibraryDeletion({
     return () => {
       document.removeEventListener('keydown', handleKeyDown)
     }
-  }, [isFocusedRef, selectedAssetCount, selectedCompositionIds, selectedMediaIds, showDeleteDialog])
+  }, [
+    enabled,
+    isFocusedRef,
+    selectedAssetCount,
+    selectedCompositionIds,
+    selectedMediaIds,
+    showDeleteDialog,
+  ])
 
   const deleteSummary = useMemo(() => {
     const parts: string[] = []
@@ -152,7 +161,7 @@ export function useMediaLibraryDeletion({
     affectedMediaImpact.totalReferenceCount + compoundClipDeleteImpact.totalReferenceCount
 
   const handleDeleteSelected = () => {
-    if (selectedAssetCount === 0) return
+    if (!enabled || selectedAssetCount === 0) return
     // Capture the IDs BEFORE opening dialog (selection may be cleared by click outside)
     setPendingDeletion({
       mediaIds: [...selectedMediaIds],
@@ -162,6 +171,7 @@ export function useMediaLibraryDeletion({
   }
 
   const handleConfirmDelete = async () => {
+    if (!enabled) return
     setShowDeleteDialog(false)
     try {
       // First remove timeline items that reference selected library assets
diff --git a/src/features/media-library/components/use-media-library-drag-drop.ts b/src/features/media-library/components/use-media-library-drag-drop.ts
index c88365dfe..a8bed04c9 100644
--- a/src/features/media-library/components/use-media-library-drag-drop.ts
+++ b/src/features/media-library/components/use-media-library-drag-drop.ts
@@ -9,6 +9,7 @@ import type { MediaLibraryNotification } from '../types'
 interface UseMediaLibraryDragDropParams {
   showNotification: (notification: MediaLibraryNotification) => void
   importHandles: (handles: FileSystemFileHandle[]) => Promise<void>
+  enabled?: boolean
 }
 
 /**
@@ -20,25 +21,34 @@ interface UseMediaLibraryDragDropParams {
 export function useMediaLibraryDragDrop({
   showNotification,
   importHandles,
+  enabled = true,
 }: UseMediaLibraryDragDropParams) {
   const { t } = useTranslation()
   const [isDragging, setIsDragging] = useState(false)
   const dragCounterRef = useRef(0)
 
-  const handleDragEnter = useCallback((e: React.DragEvent) => {
-    e.preventDefault()
-    e.stopPropagation()
-    dragCounterRef.current++
-    if (dragCounterRef.current === 1 && !e.dataTransfer.types.includes('application/json')) {
-      setIsDragging(true)
-    }
-  }, [])
+  const handleDragEnter = useCallback(
+    (e: React.DragEvent) => {
+      e.preventDefault()
+      e.stopPropagation()
+      if (!enabled) return
+      dragCounterRef.current++
+      if (dragCounterRef.current === 1 && !e.dataTransfer.types.includes('application/json')) {
+        setIsDragging(true)
+      }
+    },
+    [enabled],
+  )
 
-  const handleDragOver = useCallback((e: React.DragEvent) => {
-    e.preventDefault()
-    e.stopPropagation()
-    e.dataTransfer.dropEffect = 'copy'
-  }, [])
+  const handleDragOver = useCallback(
+    (e: React.DragEvent) => {
+      e.preventDefault()
+      e.stopPropagation()
+      if (!enabled) return
+      e.dataTransfer.dropEffect = 'copy'
+    },
+    [enabled],
+  )
 
   const handleDragLeave = useCallback((e: React.DragEvent) => {
     e.preventDefault()
@@ -51,9 +61,11 @@ export function useMediaLibraryDragDrop({
   }, [])
 
   const handleDrop = useCallback(
+    // fallow-ignore-next-line complexity
     async (e: React.DragEvent) => {
       e.preventDefault()
       e.stopPropagation()
+      if (!enabled) return
       dragCounterRef.current = 0
       setIsDragging(false)
 
@@ -95,7 +107,7 @@ export function useMediaLibraryDragDrop({
         await importHandles(entries.map((entry) => entry.handle))
       }
     },
-    [showNotification, importHandles, t],
+    [enabled, showNotification, importHandles, t],
   )
 
   return { isDragging, handleDragEnter, handleDragOver, handleDragLeave, handleDrop }
diff --git a/src/features/media-library/deps/editor-contract.ts b/src/features/media-library/deps/editor-contract.ts
new file mode 100644
index 000000000..b65192e80
--- /dev/null
+++ b/src/features/media-library/deps/editor-contract.ts
@@ -0,0 +1,3 @@
+/** Adapter exports for the editor host capability boundary. */
+
+export { useEditorCapability, useEditorHostMode } from '@/features/editor/host/context'
diff --git a/src/features/media-library/deps/editor.ts b/src/features/media-library/deps/editor.ts
new file mode 100644
index 000000000..d28d51db1
--- /dev/null
+++ b/src/features/media-library/deps/editor.ts
@@ -0,0 +1,3 @@
+/** Compatibility adapter that re-exports through editor-contract. */
+
+export * from './editor-contract'
diff --git a/src/features/media-library/utils/media-resolver.ts b/src/features/media-library/utils/media-resolver.ts
index 779e962f2..a90c96756 100644
--- a/src/features/media-library/utils/media-resolver.ts
+++ b/src/features/media-library/utils/media-resolver.ts
@@ -14,6 +14,35 @@ const logger = createLogger('MediaResolver')
  */
 const pendingRequests = new Map<string, Promise<string>>()
 
+type RuntimeMediaResolver = (mediaId: string) => Promise<string | null> | string | null
+
+let runtimeMediaResolver: RuntimeMediaResolver | null = null
+
+/**
+ * Install a runtime-only media resolver for an embedded host.  The resolver
+ * receives an opaque media id and returns a playback locator for this session;
+ * it is never written into a timeline item or project record.
+ */
+export function installRuntimeMediaResolver(resolver: RuntimeMediaResolver): () => void {
+  const previous = runtimeMediaResolver
+  const resolvedMediaIds = new Set<string>()
+  const installedResolver: RuntimeMediaResolver = async (mediaId) => {
+    const source = await resolver(mediaId)
+    if (source) resolvedMediaIds.add(mediaId)
+    return source
+  }
+  runtimeMediaResolver = installedResolver
+  return () => {
+    if (runtimeMediaResolver === installedResolver) {
+      for (const mediaId of resolvedMediaIds) {
+        blobUrlManager.invalidate(mediaId)
+      }
+      resolvedMediaIds.clear()
+      runtimeMediaResolver = previous
+    }
+  }
+}
+
 /**
  * Resolves a mediaId to a blob URL for use in Composition Player
  *
@@ -21,6 +50,21 @@ const pendingRequests = new Map<string, Promise<string>>()
  * @returns Blob URL for the media, or empty string if not found
  */
 export async function resolveMediaUrl(mediaId: string): Promise<string> {
+  if (runtimeMediaResolver) {
+    const source = await runtimeMediaResolver(mediaId)
+    if (!source) return ''
+
+    // The preview runtime uses this manager as a freshness signal. Registering
+    // an external locator keeps that signal in memory only; unlike acquire(),
+    // it never creates or persists a Blob URL.
+    const cached = blobUrlManager.get(mediaId)
+    if (cached !== source) {
+      if (cached) blobUrlManager.invalidate(mediaId)
+      blobUrlManager.registerUrl(mediaId, source)
+    }
+    return source
+  }
+
   // Check centralized manager first - URLs persist until explicit release
   const cached = blobUrlManager.get(mediaId)
   if (cached) {
@@ -116,6 +160,8 @@ export async function resolveMediaUrl(mediaId: string): Promise<string> {
  * Returns null if no proxy exists (caller should fall back to full-res).
  */
 export function resolveProxyUrl(mediaId: string): string | null {
+  if (runtimeMediaResolver) return null
+
   const media = useMediaLibraryStore.getState().mediaById[mediaId]
   if (media) {
     const proxyKey = getSharedProxyKey(media)
diff --git a/src/features/preview/utils/scrub-proxy-fallback.ts b/src/features/preview/utils/scrub-proxy-fallback.ts
index f0439beca..c59805366 100644
--- a/src/features/preview/utils/scrub-proxy-fallback.ts
+++ b/src/features/preview/utils/scrub-proxy-fallback.ts
@@ -2,6 +2,7 @@ import { blobUrlManager } from '@/infrastructure/browser/blob-url-manager'
 import { getObjectUrlBlob } from '@/infrastructure/browser/object-url-registry'
 import { proxyService, useMediaLibraryStore } from '../deps/media-library-contract'
 import { importFilmstripCache } from '../deps/timeline-filmstrip'
+import { useEditorStore } from '@/shared/state/editor'
 import {
   cacheActivePreviewFallbackBitmap,
   getCachedActivePreviewFallbackBitmap,
@@ -19,6 +20,7 @@ function loadFilmstripModule() {
 }
 
 export function warmScrubProxyFallback(): void {
+  if (useEditorStore.getState().hostMode) return
   void loadFilmstripModule().then(({ filmstripCache }) => filmstripCache.prewarm())
 }
 
@@ -32,6 +34,7 @@ async function bitmapFromFrame(frame: { url: string; bitmap?: ImageBitmap }): Pr
 }
 
 export function scheduleScrubProxyFallback(src: string, timestamp: number): void {
+  if (useEditorStore.getState().hostMode) return
   if (getCachedActivePreviewFallbackBitmap(src, timestamp)) return
   const mediaId = blobUrlManager.getMediaIdByUrl(src) ?? proxyService.getMediaIdByProxyUrl(src)
   if (!mediaId) return
diff --git a/src/features/timeline/components/clip-filmstrip/image-filmstrip.tsx b/src/features/timeline/components/clip-filmstrip/image-filmstrip.tsx
index f23ff8850..7e0fe7bf7 100644
--- a/src/features/timeline/components/clip-filmstrip/image-filmstrip.tsx
+++ b/src/features/timeline/components/clip-filmstrip/image-filmstrip.tsx
@@ -4,6 +4,7 @@ import { useMediaBlobUrl } from '../../hooks/use-media-blob-url'
 import { resolveMediaUrl } from '@/features/timeline/deps/media-library-resolver'
 import { createLogger } from '@/shared/logging/logger'
 import { computeFilmstripRenderWindow } from './render-window'
+import { useEditorStore } from '@/shared/state/editor'
 
 const logger = createLogger('ImageFilmstrip')
 
@@ -112,6 +113,7 @@ export const ImageFilmstrip = memo(function ImageFilmstrip({
 }: ImageFilmstripProps) {
   const containerRef = useRef<HTMLDivElement>(null)
   const [height, setHeight] = useState(0)
+  const hostMode = useEditorStore((state) => state.hostMode)
 
   // Measure container height
   useEffect(() => {
@@ -133,7 +135,7 @@ export const ImageFilmstrip = memo(function ImageFilmstrip({
   const { blobUrl, setBlobUrl, hasStartedLoadingRef, blobUrlVersion } = useMediaBlobUrl(mediaId)
 
   useEffect(() => {
-    if (!isVisible || !mediaId || hasStartedLoadingRef.current) return
+    if (hostMode || !isVisible || !mediaId || hasStartedLoadingRef.current) return
     hasStartedLoadingRef.current = true
 
     let mounted = true
@@ -145,13 +147,13 @@ export const ImageFilmstrip = memo(function ImageFilmstrip({
     return () => {
       mounted = false
     }
-  }, [mediaId, isVisible, blobUrlVersion, hasStartedLoadingRef, setBlobUrl])
+  }, [blobUrlVersion, hasStartedLoadingRef, hostMode, isVisible, mediaId, setBlobUrl])
 
   const { frames, durations, totalDuration } = useGifFrames({
     mediaId,
     blobUrl,
     isVisible,
-    enabled: isAnimated && !!blobUrl,
+    enabled: !hostMode && isAnimated && !!blobUrl,
     format: animationFormat,
   })
 
diff --git a/src/features/timeline/components/clip-filmstrip/index.tsx b/src/features/timeline/components/clip-filmstrip/index.tsx
index d195f7051..e29e03dfd 100644
--- a/src/features/timeline/components/clip-filmstrip/index.tsx
+++ b/src/features/timeline/components/clip-filmstrip/index.tsx
@@ -11,6 +11,7 @@ import { useMediaLibraryStore } from '@/features/timeline/deps/media-library-sto
 import { observeParentElementHeight } from '../measure-parent-height'
 import { useTimelineViewportStore } from '../../stores/timeline-viewport-store'
 import { CLIP_VISIBILITY_PREFETCH_MARGIN_PX } from '../../hooks/use-clip-visibility'
+import { useEditorStore } from '@/shared/state/editor'
 
 const logger = createLogger('ClipFilmstrip')
 
@@ -79,6 +80,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
   const containerRef = useRef<HTMLDivElement>(null)
   const [height, setHeight] = useState(0)
   const viewportWidth = useTimelineViewportStore((state) => state.viewportWidth)
+  const hostMode = useEditorStore((state) => state.hostMode)
   const { blobUrl, setBlobUrl, hasStartedLoadingRef, blobUrlVersion } = useMediaBlobUrl(mediaId)
   const refreshingFrameIndicesRef = useRef<Set<number>>(new Set())
   const proxyStatus = useMediaLibraryStore((s) => s.proxyStatus.get(mediaId) ?? null)
@@ -189,7 +191,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
 
   // Load blob URL lazily when visible, and retry after global invalidation.
   useEffect(() => {
-    if (!isVisible || !mediaId || proxyBlobUrl || hasStartedLoadingRef.current) {
+    if (hostMode || !isVisible || !mediaId || proxyBlobUrl || hasStartedLoadingRef.current) {
       return
     }
     hasStartedLoadingRef.current = true
@@ -211,7 +213,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
     return () => {
       mounted = false
     }
-  }, [mediaId, isVisible, proxyBlobUrl, blobUrlVersion, hasStartedLoadingRef, setBlobUrl])
+  }, [blobUrlVersion, hasStartedLoadingRef, hostMode, isVisible, mediaId, proxyBlobUrl, setBlobUrl])
 
   // Use filmstrip hook. `enabled` no longer requires the source blob URL —
   // disk-cached frames can render before useMediaBlobUrl resolves. The
@@ -221,7 +223,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
     blobUrl: filmstripSourceUrl,
     duration: sourceDuration,
     isVisible,
-    enabled: sourceDuration > 0,
+    enabled: !hostMode && sourceDuration > 0,
     priorityWindow,
     targetFrameCount,
     targetFrameIndices,
@@ -252,7 +254,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
 
   const handleFrameSourceError = useCallback(
     (frameIndex: number) => {
-      if (!mediaId || refreshingFrameIndicesRef.current.has(frameIndex)) {
+      if (hostMode || !mediaId || refreshingFrameIndicesRef.current.has(frameIndex)) {
         return
       }
 
@@ -266,7 +268,7 @@ export const ClipFilmstrip = memo(function ClipFilmstrip({
           refreshingFrameIndicesRef.current.delete(frameIndex)
         })
     },
-    [mediaId],
+    [hostMode, mediaId],
   )
 
   // Share one stable fallback frame per media item. Every clip instance then
diff --git a/src/features/timeline/components/clip-waveform/index.tsx b/src/features/timeline/components/clip-waveform/index.tsx
index 76d89fd01..2d57fb071 100644
--- a/src/features/timeline/components/clip-waveform/index.tsx
+++ b/src/features/timeline/components/clip-waveform/index.tsx
@@ -18,6 +18,7 @@ import { observeParentElementHeight } from '../measure-parent-height'
 import { useTimelineViewportStore } from '../../stores/timeline-viewport-store'
 import { useZoomStore } from '../../stores/zoom-store'
 import { CLIP_VISIBILITY_PREFETCH_MARGIN_PX } from '../../hooks/use-clip-visibility'
+import { useEditorStore } from '@/shared/state/editor'
 
 const logger = createLogger('ClipWaveform')
 
@@ -85,6 +86,7 @@ export const ClipWaveform = memo(function ClipWaveform({
   const amplitudesBufferRef = useRef<Float32Array>(new Float32Array(0))
   const [height, setHeight] = useState(0)
   const viewportWidth = useTimelineViewportStore((state) => state.viewportWidth)
+  const hostMode = useEditorStore((state) => state.hostMode)
   const conformStartedRef = useRef(false)
   const { blobUrl, setBlobUrl, hasStartedLoadingRef, blobUrlVersion } = useMediaBlobUrl(mediaId)
 
@@ -169,7 +171,7 @@ export const ClipWaveform = memo(function ClipWaveform({
   // Load blob URL for the media when visible, including post-invalidation retries.
   useEffect(() => {
     // Skip if already started loading (prevents re-triggering on visibility changes)
-    if (hasStartedLoadingRef.current) {
+    if (hostMode || hasStartedLoadingRef.current) {
       return
     }
 
@@ -236,7 +238,7 @@ export const ClipWaveform = memo(function ClipWaveform({
     return () => {
       mounted = false
     }
-  }, [mediaId, isVisible, blobUrlVersion, hasStartedLoadingRef, setBlobUrl])
+  }, [blobUrlVersion, hasStartedLoadingRef, hostMode, isVisible, mediaId, setBlobUrl])
 
   // Use waveform hook. It can hydrate persisted waveforms before blobUrl is
   // available; blobUrl is only required when the cache has to generate.
@@ -245,7 +247,7 @@ export const ClipWaveform = memo(function ClipWaveform({
       mediaId,
       blobUrl,
       isVisible,
-      enabled: audioCodecSupported,
+      enabled: audioCodecSupported && !hostMode,
       deferDurationSec: sourceDuration,
       pixelsPerSecond,
       visibleSourceStartSec: visibleSourceWindow.start,
diff --git a/src/features/timeline/components/timeline-header.tsx b/src/features/timeline/components/timeline-header.tsx
index 5753a3473..586efa104 100644
--- a/src/features/timeline/components/timeline-header.tsx
+++ b/src/features/timeline/components/timeline-header.tsx
@@ -349,12 +349,7 @@ const TimelineZoomControls = memo(function TimelineZoomControls({
         finishSliderZoomInteraction()
       }
     },
-    [
-      commitSliderZoom,
-      finishSliderZoomInteraction,
-      releaseSliderZoomGesture,
-      renderSliderPreview,
-    ],
+    [commitSliderZoom, finishSliderZoomInteraction, releaseSliderZoomGesture, renderSliderPreview],
   )
 
   const controlledSliderValue = zoomToSlider(settledZoomLevel)
@@ -444,6 +439,7 @@ const TimelineZoomControls = memo(function TimelineZoomControls({
  * - In/Out points, Snap toggle
  * - Zoom controls
  */
+// fallow-ignore-next-line complexity
 export const TimelineHeader = memo(function TimelineHeader({
   onZoomChange,
   onZoomIn,
@@ -451,6 +447,7 @@ export const TimelineHeader = memo(function TimelineHeader({
   onZoomToFit,
 }: TimelineHeaderProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorStore((s) => s.hostMode)
   const hotkeys = useResolvedHotkeys()
   const snapEnabled = useTimelineStore((s) => s.snapEnabled)
   const toggleSnap = useTimelineStore((s) => s.toggleSnap)
@@ -563,25 +560,27 @@ export const TimelineHeader = memo(function TimelineHeader({
               <Scissors className="w-3.5 h-3.5 -rotate-90" />
             </Button>
 
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              className={
-                activeTool === 'rate-stretch'
-                  ? 'bg-primary text-primary-foreground hover:bg-primary/90'
-                  : ''
-              }
-              onClick={() =>
-                setActiveTool(activeTool === 'rate-stretch' ? 'select' : 'rate-stretch')
-              }
-              aria-label={t('timeline.header.rateStretchTool')}
-              data-tooltip={t('timeline.header.rateStretchToolTooltip')}
-            >
-              <Gauge className="w-3.5 h-3.5" />
-            </Button>
-
-            {SLIP_SLIDE_TOOLS_ENABLED ? (
+            {!hostMode && (
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                className={
+                  activeTool === 'rate-stretch'
+                    ? 'bg-primary text-primary-foreground hover:bg-primary/90'
+                    : ''
+                }
+                onClick={() =>
+                  setActiveTool(activeTool === 'rate-stretch' ? 'select' : 'rate-stretch')
+                }
+                aria-label={t('timeline.header.rateStretchTool')}
+                data-tooltip={t('timeline.header.rateStretchToolTooltip')}
+              >
+                <Gauge className="w-3.5 h-3.5" />
+              </Button>
+            )}
+
+            {!hostMode && SLIP_SLIDE_TOOLS_ENABLED ? (
               <DropdownMenu>
                 <DropdownMenuTrigger asChild>
                   <Button
@@ -630,140 +629,151 @@ export const TimelineHeader = memo(function TimelineHeader({
           <Separator orientation="vertical" className="h-5 mx-1.5" />
 
           {/* Undo/Redo */}
-          <div className="flex items-center gap-1">
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={handleUndo}
-              disabled={!canUndo}
-              aria-label={
-                undoLabel
-                  ? t('timeline.header.undoWithLabel', { label: undoLabel })
-                  : t('timeline.header.undo')
-              }
-              data-tooltip={
-                undoLabel
-                  ? t('timeline.header.undoWithLabelTooltip', { label: undoLabel })
-                  : t('timeline.header.undoTooltip')
-              }
-            >
-              <Undo2 className="w-3.5 h-3.5" />
-            </Button>
-
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={handleRedo}
-              disabled={!canRedo}
-              aria-label={
-                redoLabel
-                  ? t('timeline.header.redoWithLabel', { label: redoLabel })
-                  : t('timeline.header.redo')
-              }
-              data-tooltip={
-                redoLabel
-                  ? t('timeline.header.redoWithLabelTooltip', { label: redoLabel })
-                  : t('timeline.header.redoTooltip')
-              }
-            >
-              <Redo2 className="w-3.5 h-3.5" />
-            </Button>
-          </div>
+          {!hostMode && (
+            <div className="flex items-center gap-1">
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                onClick={handleUndo}
+                disabled={!canUndo}
+                aria-label={
+                  undoLabel
+                    ? t('timeline.header.undoWithLabel', { label: undoLabel })
+                    : t('timeline.header.undo')
+                }
+                data-tooltip={
+                  undoLabel
+                    ? t('timeline.header.undoWithLabelTooltip', { label: undoLabel })
+                    : t('timeline.header.undoTooltip')
+                }
+              >
+                <Undo2 className="w-3.5 h-3.5" />
+              </Button>
+
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                onClick={handleRedo}
+                disabled={!canRedo}
+                aria-label={
+                  redoLabel
+                    ? t('timeline.header.redoWithLabel', { label: redoLabel })
+                    : t('timeline.header.redo')
+                }
+                data-tooltip={
+                  redoLabel
+                    ? t('timeline.header.redoWithLabelTooltip', { label: redoLabel })
+                    : t('timeline.header.redoTooltip')
+                }
+              >
+                <Redo2 className="w-3.5 h-3.5" />
+              </Button>
+            </div>
+          )}
 
           <Separator orientation="vertical" className="h-5 mx-1.5" />
 
-          {/* In/Out Points */}
-          <div className="flex items-center gap-1">
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={() => setInPoint(usePlaybackStore.getState().currentFrame)}
-              aria-label={t('timeline.header.setInPoint')}
-              data-tooltip={t('timeline.header.setInPointTooltip')}
-            >
-              <span className="text-sm font-bold" style={{ color: 'var(--color-timeline-in)' }}>
-                [
-              </span>
-            </Button>
-
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={() => setOutPoint(usePlaybackStore.getState().currentFrame)}
-              aria-label={t('timeline.header.setOutPoint')}
-              data-tooltip={t('timeline.header.setOutPointTooltip')}
-            >
-              <span className="text-sm font-bold" style={{ color: 'var(--color-timeline-out)' }}>
-                ]
-              </span>
-            </Button>
-
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={clearInOutPoints}
-              disabled={inPoint === null && outPoint === null}
-              aria-label={t('timeline.header.clearInOutPoints')}
-              data-tooltip={t('timeline.header.clearInOutPointsTooltip')}
-            >
-              <X className="w-3.5 h-3.5" />
-            </Button>
-          </div>
-
-          <Separator orientation="vertical" className="h-5 mx-1.5" />
+          {!hostMode && (
+            <>
+              {/* In/Out Points */}
+              <div className="flex items-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  style={btnSize}
+                  onClick={() => setInPoint(usePlaybackStore.getState().currentFrame)}
+                  aria-label={t('timeline.header.setInPoint')}
+                  data-tooltip={t('timeline.header.setInPointTooltip')}
+                >
+                  <span className="text-sm font-bold" style={{ color: 'var(--color-timeline-in)' }}>
+                    [
+                  </span>
+                </Button>
+
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  style={btnSize}
+                  onClick={() => setOutPoint(usePlaybackStore.getState().currentFrame)}
+                  aria-label={t('timeline.header.setOutPoint')}
+                  data-tooltip={t('timeline.header.setOutPointTooltip')}
+                >
+                  <span
+                    className="text-sm font-bold"
+                    style={{ color: 'var(--color-timeline-out)' }}
+                  >
+                    ]
+                  </span>
+                </Button>
+
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  style={btnSize}
+                  onClick={clearInOutPoints}
+                  disabled={inPoint === null && outPoint === null}
+                  aria-label={t('timeline.header.clearInOutPoints')}
+                  data-tooltip={t('timeline.header.clearInOutPointsTooltip')}
+                >
+                  <X className="w-3.5 h-3.5" />
+                </Button>
+              </div>
+
+              <Separator orientation="vertical" className="h-5 mx-1.5" />
+            </>
+          )}
 
           {/* Markers */}
-          <div className="flex items-center gap-1">
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={() => addMarker(usePlaybackStore.getState().currentFrame)}
-              aria-label={t('timeline.header.addMarker')}
-              data-tooltip={t('timeline.header.addMarkerTooltip')}
-            >
-              <Flag className="w-3.5 h-3.5" style={{ color: 'var(--color-timeline-marker)' }} />
-            </Button>
-
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={() => {
-                if (selectedMarkerId) {
-                  removeMarker(selectedMarkerId)
-                  clearSelection()
-                }
-              }}
-              disabled={!selectedMarkerId}
-              aria-label={t('timeline.header.removeSelectedMarker')}
-              data-tooltip={t('timeline.header.removeSelectedMarkerTooltip')}
-            >
-              <FlagOff className="w-3.5 h-3.5" />
-            </Button>
-
-            <Button
-              variant="ghost"
-              size="icon"
-              style={btnSize}
-              onClick={clearAllMarkers}
-              disabled={!hasMarkers}
-              aria-label={t('timeline.header.clearAllMarkers')}
-              data-tooltip={t('timeline.header.clearAllMarkersTooltip')}
-            >
-              <X className="w-3.5 h-3.5" />
-            </Button>
-          </div>
+          {!hostMode && (
+            <div className="flex items-center gap-1">
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                onClick={() => addMarker(usePlaybackStore.getState().currentFrame)}
+                aria-label={t('timeline.header.addMarker')}
+                data-tooltip={t('timeline.header.addMarkerTooltip')}
+              >
+                <Flag className="w-3.5 h-3.5" style={{ color: 'var(--color-timeline-marker)' }} />
+              </Button>
+
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                onClick={() => {
+                  if (selectedMarkerId) {
+                    removeMarker(selectedMarkerId)
+                    clearSelection()
+                  }
+                }}
+                disabled={!selectedMarkerId}
+                aria-label={t('timeline.header.removeSelectedMarker')}
+                data-tooltip={t('timeline.header.removeSelectedMarkerTooltip')}
+              >
+                <FlagOff className="w-3.5 h-3.5" />
+              </Button>
+
+              <Button
+                variant="ghost"
+                size="icon"
+                style={btnSize}
+                onClick={clearAllMarkers}
+                disabled={!hasMarkers}
+                aria-label={t('timeline.header.clearAllMarkers')}
+                data-tooltip={t('timeline.header.clearAllMarkersTooltip')}
+              >
+                <X className="w-3.5 h-3.5" />
+              </Button>
+            </div>
+          )}
 
           <Separator orientation="vertical" className="h-5 mx-1.5" />
 
           {/* Microphone voiceover */}
-          <MicRecordControl />
+          {!hostMode && <MicRecordControl />}
 
           <Separator orientation="vertical" className="h-5 mx-1.5" />
 
@@ -811,7 +821,12 @@ export const TimelineHeader = memo(function TimelineHeader({
 
           <Separator orientation="vertical" className="h-5 mx-1.5" />
 
-          <InlineKeyframesToggle isOpen={inlineKeyframesOpen} onToggle={toggleEditKeyframePanel} />
+          {!hostMode && (
+            <InlineKeyframesToggle
+              isOpen={inlineKeyframesOpen}
+              onToggle={toggleEditKeyframePanel}
+            />
+          )}
 
           <Button
             variant="ghost"
diff --git a/src/features/timeline/components/timeline-item/item-context-menu.tsx b/src/features/timeline/components/timeline-item/item-context-menu.tsx
index b44df034d..8c087f571 100644
--- a/src/features/timeline/components/timeline-item/item-context-menu.tsx
+++ b/src/features/timeline/components/timeline-item/item-context-menu.tsx
@@ -14,6 +14,7 @@ import {
 import type { LazyContextMenuEventInit } from '../../utils/lazy-context-menu'
 import { captureContextMenuEventInit, replayContextMenuEvent } from '../../utils/lazy-context-menu'
 import { useSelectionStore } from '@/shared/state/selection'
+import { useEditorStore } from '@/shared/state/editor'
 import { useGradeClipboardStore } from '@/shared/state/grade-clipboard'
 import { useItemsStore } from '../../stores/items-store'
 import {
@@ -30,6 +31,7 @@ import {
 } from '@/features/timeline/deps/analysis'
 import { formatHotkeyBinding } from '@/config/hotkeys'
 import { useResolvedHotkeys } from '@/features/timeline/deps/settings'
+import { useEditorCapability } from '../../deps/editor'
 
 type ItemContextMenuSectionProps = {
   t: ReturnType<typeof useTranslation>['t']
@@ -108,6 +110,8 @@ type LayoutActionsProps = ItemContextMenuSectionProps & {
 
 type DestructiveActionsProps = ItemContextMenuSectionProps & {
   isSelected: boolean
+  canRippleDelete?: boolean
+  canDelete?: boolean
   onRippleDelete: () => void
   onDelete: () => void
 }
@@ -266,6 +270,8 @@ const ItemContextMenuFull = memo(function ItemContextMenuFull({
   const { t } = useTranslation()
   const triggerRef = useRef<HTMLSpanElement | null>(null)
   const hotkeys = useResolvedHotkeys()
+  const hostMode = useEditorStore((s) => s.hostMode)
+  const canDeleteItem = useEditorCapability('timeline.remove')
   const selectedCount = useSelectionStore((s) => s.selectedItemIds.length)
   // Filter to only properties that actually have keyframes
   const propertiesWithKeyframes = useMemo(() => {
@@ -295,36 +301,46 @@ const ItemContextMenuFull = memo(function ItemContextMenuFull({
         </span>
       </ContextMenuTrigger>
       <ContextMenuContent>
-        <JoinActions t={t} hotkeys={hotkeys} {...joinActions} />
-        {linkActions && <LinkActions t={t} hotkeys={hotkeys} {...linkActions} />}
-        <KeyframeActions
-          t={t}
-          hotkeys={hotkeys}
-          propertiesWithKeyframes={propertiesWithKeyframes}
-          onClearAllKeyframes={keyframeActions?.onClearAllKeyframes}
-          onClearPropertyKeyframes={keyframeActions?.onClearPropertyKeyframes}
-        />
-        <LayoutActions
+        {!hostMode && (
+          <>
+            <JoinActions t={t} hotkeys={hotkeys} {...joinActions} />
+            {linkActions && <LinkActions t={t} hotkeys={hotkeys} {...linkActions} />}
+            <KeyframeActions
+              t={t}
+              hotkeys={hotkeys}
+              propertiesWithKeyframes={propertiesWithKeyframes}
+              onClearAllKeyframes={keyframeActions?.onClearAllKeyframes}
+              onClearPropertyKeyframes={keyframeActions?.onClearPropertyKeyframes}
+            />
+            <LayoutActions
+              t={t}
+              hotkeys={hotkeys}
+              selectedCount={selectedCount}
+              onBentoLayout={layoutActions?.onBentoLayout}
+            />
+            {mediaActions && <MediaActions t={t} hotkeys={hotkeys} {...mediaActions} />}
+            {sceneDetectionActions && (
+              <SceneDetectionActions
+                t={t}
+                hotkeys={hotkeys}
+                sceneVerificationModelOptions={sceneVerificationModelOptions}
+                {...sceneDetectionActions}
+              />
+            )}
+            {captionActions && <CaptionActions t={t} hotkeys={hotkeys} {...captionActions} />}
+            <GradeActions t={t} />
+            {compositionActions && (
+              <CompositionActions t={t} hotkeys={hotkeys} {...compositionActions} />
+            )}
+          </>
+        )}
+        <DestructiveActions
           t={t}
           hotkeys={hotkeys}
-          selectedCount={selectedCount}
-          onBentoLayout={layoutActions?.onBentoLayout}
+          {...destructiveActions}
+          canRippleDelete={!hostMode}
+          canDelete={canDeleteItem}
         />
-        {mediaActions && <MediaActions t={t} hotkeys={hotkeys} {...mediaActions} />}
-        {sceneDetectionActions && (
-          <SceneDetectionActions
-            t={t}
-            hotkeys={hotkeys}
-            sceneVerificationModelOptions={sceneVerificationModelOptions}
-            {...sceneDetectionActions}
-          />
-        )}
-        {captionActions && <CaptionActions t={t} hotkeys={hotkeys} {...captionActions} />}
-        <GradeActions t={t} />
-        {compositionActions && (
-          <CompositionActions t={t} hotkeys={hotkeys} {...compositionActions} />
-        )}
-        <DestructiveActions t={t} hotkeys={hotkeys} {...destructiveActions} />
       </ContextMenuContent>
     </ContextMenu>
   )
@@ -687,25 +703,36 @@ function CompositionActions({
   )
 }
 
-function DestructiveActions({ t, isSelected, onRippleDelete, onDelete }: DestructiveActionsProps) {
+function DestructiveActions({
+  t,
+  isSelected,
+  canRippleDelete = true,
+  canDelete = true,
+  onRippleDelete,
+  onDelete,
+}: DestructiveActionsProps) {
   return (
     <>
-      <ContextMenuItem
-        onClick={onRippleDelete}
-        disabled={!isSelected}
-        className="text-destructive focus:text-destructive"
-      >
-        {t('timeline.contextMenu.rippleDelete')}
-        <ContextMenuShortcut>Ctrl+Del</ContextMenuShortcut>
-      </ContextMenuItem>
-      <ContextMenuItem
-        onClick={onDelete}
-        disabled={!isSelected}
-        className="text-destructive focus:text-destructive"
-      >
-        {t('common.delete')}
-        <ContextMenuShortcut>Del</ContextMenuShortcut>
-      </ContextMenuItem>
+      {canRippleDelete && (
+        <ContextMenuItem
+          onClick={onRippleDelete}
+          disabled={!isSelected}
+          className="text-destructive focus:text-destructive"
+        >
+          {t('timeline.contextMenu.rippleDelete')}
+          <ContextMenuShortcut>Ctrl+Del</ContextMenuShortcut>
+        </ContextMenuItem>
+      )}
+      {canDelete && (
+        <ContextMenuItem
+          onClick={onDelete}
+          disabled={!isSelected}
+          className="text-destructive focus:text-destructive"
+        >
+          {t('common.delete')}
+          <ContextMenuShortcut>Del</ContextMenuShortcut>
+        </ContextMenuItem>
+      )}
     </>
   )
 }
diff --git a/src/features/timeline/components/timeline-track.tsx b/src/features/timeline/components/timeline-track.tsx
index c326e841d..d5fb16477 100644
--- a/src/features/timeline/components/timeline-track.tsx
+++ b/src/features/timeline/components/timeline-track.tsx
@@ -98,6 +98,7 @@ import {
 import { TimelineTrackItems } from './timeline-track-items'
 import { createTimelineTrackContentLayerRef } from '../utils/timeline-live-geometry'
 import { getTimelineTrackItemRangeIndex } from '../utils/timeline-item-range-index'
+import { useEditorStore } from '@/shared/state/editor'
 
 const EMPTY_TRACK_ITEMS: TimelineItemType[] = []
 
@@ -226,6 +227,7 @@ function areTrackPropsEqual(prev: TimelineTrackProps, next: TimelineTrackProps):
 export const TimelineTrack = memo(function TimelineTrack({ track }: TimelineTrackProps) {
   perfMarkRender('TimelineTrack')
   const { t } = useTranslation()
+  const hostMode = useEditorStore((s) => s.hostMode)
   const previewOwnerId = `track:${track.id}`
   const [gapContextMenuRequest, setGapContextMenuRequest] =
     useState<TrackGapContextMenuRequest | null>(null)
@@ -910,6 +912,7 @@ export const TimelineTrack = memo(function TimelineTrack({ track }: TimelineTrac
   // Handle context menu on track (for empty space)
   const handleContextMenu = useCallback(
     (e: React.MouseEvent) => {
+      if (hostMode) return
       // Check if clicking on a clip (has data-item-id ancestor)
       const target = e.target as HTMLElement
       if (target.closest('[data-item-id], [data-item-context-anchor]')) {
@@ -942,7 +945,7 @@ export const TimelineTrack = memo(function TimelineTrack({ track }: TimelineTrac
         setGapContextMenuRequest(null)
       }
     },
-    [isFrameInGap],
+    [hostMode, isFrameInGap],
   )
 
   // Handle closing the gap
diff --git a/src/features/timeline/components/timeline.tsx b/src/features/timeline/components/timeline.tsx
index ad9045710..d6bd0b2c0 100644
--- a/src/features/timeline/components/timeline.tsx
+++ b/src/features/timeline/components/timeline.tsx
@@ -44,6 +44,7 @@ import {
   getTrackSectionLayout,
 } from '../utils/track-resize'
 import { clearMediaDragData } from '@/features/timeline/deps/media-library-resolver'
+import { useEditorCapability } from '../deps/editor'
 import { useNewTrackZonePreviewStore } from '../stores/new-track-zone-preview-store'
 import { useTrackDropPreviewStore } from '../stores/track-drop-preview-store'
 import { clearAllTimelineDropPreviewOwners } from '../utils/drop-preview-owner'
@@ -84,6 +85,8 @@ interface TimelineProps {
  */
 export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorStore((s) => s.hostMode)
+  const canAddTrack = useEditorCapability('timeline.track')
   const editorDensity = useSettingsStore((s) => s.editorDensity)
   const editorLayout = getEditorLayout(editorDensity)
   const {
@@ -676,6 +679,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
   )
 
   const addVideoTrackToTop = useCallback(() => {
+    if (!canAddTrack) return
     const newTrack = createClassicTrack({ tracks, kind: 'video', order: 0 })
 
     addTrack(newTrack)
@@ -683,9 +687,10 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
     setTimeout(() => {
       setActiveTrack(newTrack.id)
     }, 0)
-  }, [addTrack, setActiveTrack, tracks])
+  }, [addTrack, canAddTrack, setActiveTrack, tracks])
 
   const appendAudioTrackToSection = useCallback(() => {
+    if (!canAddTrack) return
     const audioAnchorTrack =
       audioTracks[audioTracks.length - 1] ??
       videoTracks[videoTracks.length - 1] ??
@@ -703,7 +708,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
     setTimeout(() => {
       setActiveTrack(newTrack.id)
     }, 0)
-  }, [audioTracks, setActiveTrack, setTimelineTracks, tracks, videoTracks])
+  }, [audioTracks, canAddTrack, setActiveTrack, setTimelineTracks, tracks, videoTracks])
 
   // Trigger reflects the persisted preset (saved as a local editor setting).
   const ActiveTrackSizeIcon =
@@ -720,6 +725,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
 
   const handleDeleteTrack = useCallback(
     (trackId: string) => {
+      if (hostMode) return
       if (tracks.length <= 1) {
         logger.warn('Cannot remove all tracks')
         return
@@ -730,11 +736,12 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
       const remainingTracks = tracks.filter((track) => track.id !== trackId)
       syncTrackSelectionAfterRemoval([trackId], remainingTracks[0]?.id ?? null)
     },
-    [removeTracks, syncTrackSelectionAfterRemoval, tracks],
+    [hostMode, removeTracks, syncTrackSelectionAfterRemoval, tracks],
   )
 
   const handleDeleteEmptyTracks = useCallback(
     (contextTrackId: string) => {
+      if (hostMode) return
       const emptyTrackIds = getEmptyTrackIdsForRemoval(
         tracks,
         useItemsStore.getState().itemsByTrackId,
@@ -748,7 +755,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
       const remainingTracks = tracks.filter((track) => !removedTrackIdsSet.has(track.id))
       syncTrackSelectionAfterRemoval(emptyTrackIds, remainingTracks[0]?.id ?? null)
     },
-    [removeTracks, syncTrackSelectionAfterRemoval, tracks],
+    [hostMode, removeTracks, syncTrackSelectionAfterRemoval, tracks],
   )
 
   /**
@@ -757,6 +764,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
    * Keeps at least one track in the timeline.
    */
   const handleRemoveTracks = useCallback(() => {
+    if (hostMode) return
     const tracksToRemove =
       selectedTrackIds.length > 0 ? [...selectedTrackIds] : activeTrackId ? [activeTrackId] : []
 
@@ -773,7 +781,14 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
 
     const remainingTrack = tracks.find((t) => !tracksToRemoveSet.has(t.id))
     syncTrackSelectionAfterRemoval(tracksToRemove, remainingTrack?.id ?? null)
-  }, [activeTrackId, removeTracks, selectedTrackIds, syncTrackSelectionAfterRemoval, tracks])
+  }, [
+    activeTrackId,
+    hostMode,
+    removeTracks,
+    selectedTrackIds,
+    syncTrackSelectionAfterRemoval,
+    tracks,
+  ])
 
   const videoDropIndicatorIndex =
     isTrackDragging && dropIndicatorIndex >= 0 && dropIndicatorIndex <= videoTracks.length
@@ -844,8 +859,9 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
                   track={track}
                   isActive={activeTrackId === track.id}
                   isSelected={selectedTrackIdsSet.has(track.id)}
-                  canDeleteTrack={tracks.length > 1}
-                  canDeleteEmptyTracks={canDeleteEmptyTracks}
+                  canAddTrack={canAddTrack}
+                  canDeleteTrack={!hostMode && tracks.length > 1}
+                  canDeleteEmptyTracks={!hostMode && canDeleteEmptyTracks}
                   onToggleLock={() => toggleTrackLock(track.id)}
                   onToggleSyncLock={() => toggleTrackSyncLock(track.id)}
                   onToggleDisabled={() => toggleTrackDisabled(track.id)}
@@ -919,10 +935,10 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
       />
 
       {/* Standalone-timeline (sequence) tabs — Main + top-level sequences */}
-      <SequenceTabs />
+      {!hostMode && <SequenceTabs />}
 
       {/* Composition Breadcrumbs - shown when inside a sub-composition */}
-      <CompositionBreadcrumbs />
+      {!hostMode && <CompositionBreadcrumbs />}
 
       {/* Timeline Content */}
       <div
@@ -976,17 +992,21 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
                     variant="ghost"
                     size="icon"
                     className="h-6 w-6"
+                    disabled={!canAddTrack}
                     title={t('timeline.addTrack.label')}
                   >
                     <Plus className="w-3 h-3" />
                   </Button>
                 </DropdownMenuTrigger>
                 <DropdownMenuContent align="end" className="min-w-[10rem]">
-                  <DropdownMenuItem onSelect={() => addVideoTrackToTop()}>
+                  <DropdownMenuItem disabled={!canAddTrack} onSelect={() => addVideoTrackToTop()}>
                     <Video className="w-4 h-4" />
                     <span className="flex-1">{t('timeline.addTrack.video')}</span>
                   </DropdownMenuItem>
-                  <DropdownMenuItem onSelect={() => appendAudioTrackToSection()}>
+                  <DropdownMenuItem
+                    disabled={!canAddTrack}
+                    onSelect={() => appendAudioTrackToSection()}
+                  >
                     <AudioLines className="w-4 h-4" />
                     <span className="flex-1">{t('timeline.addTrack.audio')}</span>
                   </DropdownMenuItem>
@@ -998,7 +1018,11 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
                 size="icon"
                 className="h-6 w-6"
                 onClick={handleRemoveTracks}
-                disabled={tracks.length === 0 || (!activeTrackId && selectedTrackIds.length === 0)}
+                disabled={
+                  hostMode ||
+                  tracks.length === 0 ||
+                  (!activeTrackId && selectedTrackIds.length === 0)
+                }
                 title={
                   tracks.length === 0
                     ? t('timeline.noTracksToRemove')
@@ -1087,7 +1111,7 @@ export const Timeline = memo(function Timeline({ duration }: TimelineProps) {
         </div>
       </div>
       <KeyframeGraphPanel
-        isOpen={keyframePanelOpen}
+        isOpen={!hostMode && keyframePanelOpen}
         placement="bottom"
         surface="edit"
         propertyColumnWidth={editorLayout.timelineSidebarWidth - 1}
diff --git a/src/features/timeline/components/track-header.tsx b/src/features/timeline/components/track-header.tsx
index a3f9fdb79..05816e3cc 100644
--- a/src/features/timeline/components/track-header.tsx
+++ b/src/features/timeline/components/track-header.tsx
@@ -16,11 +16,13 @@ import { EDITOR_LAYOUT_CSS_VALUES } from '@/config/editor-layout'
 import { useItemsStore } from '../stores/items-store'
 import { isTrackDisabled } from '@/features/timeline/utils/classic-tracks'
 import { isTrackSyncLockActive } from '../utils/track-sync-lock'
+import { useEditorStore } from '@/shared/state/editor'
 
 interface TrackHeaderProps {
   track: TimelineTrack
   isActive: boolean
   isSelected: boolean
+  canAddTrack?: boolean
   canDeleteTrack: boolean
   canDeleteEmptyTracks: boolean
   onToggleLock: () => void
@@ -43,6 +45,7 @@ function areTrackHeaderPropsEqual(prev: TrackHeaderProps, next: TrackHeaderProps
     prev.track === next.track &&
     prev.isActive === next.isActive &&
     prev.isSelected === next.isSelected &&
+    prev.canAddTrack === next.canAddTrack &&
     prev.canDeleteTrack === next.canDeleteTrack &&
     prev.canDeleteEmptyTracks === next.canDeleteEmptyTracks
   )
@@ -58,10 +61,12 @@ function areTrackHeaderPropsEqual(prev: TrackHeaderProps, next: TrackHeaderProps
  * Right-click context menu for track actions.
  * Memoized to prevent re-renders when props haven't changed.
  */
+// fallow-ignore-next-line complexity
 export const TrackHeader = memo(function TrackHeader({
   track,
   isActive,
   isSelected,
+  canAddTrack = true,
   canDeleteTrack,
   canDeleteEmptyTracks,
   onToggleLock,
@@ -76,6 +81,7 @@ export const TrackHeader = memo(function TrackHeader({
   onDeleteEmptyTracks,
 }: TrackHeaderProps) {
   const { t } = useTranslation()
+  const hostMode = useEditorStore((s) => s.hostMode)
   const itemCount = useItemsStore((s) => s.itemsByTrackId[track.id]?.length ?? 0)
   const syncLockEnabled = isTrackSyncLockActive(track)
   const trackDisabled = isTrackDisabled(track)
@@ -108,7 +114,7 @@ export const TrackHeader = memo(function TrackHeader({
             `}
             style={{ height: `${track.height}px` }}
             onClick={onSelect}
-            onMouseDown={handleDragStart}
+            onMouseDown={hostMode ? undefined : handleDragStart}
           >
             <div className="flex h-6 shrink-0 items-center gap-0.5 overflow-hidden border-b border-border/60">
               <div className="flex h-5 w-4 shrink-0 items-center justify-center">
@@ -128,6 +134,7 @@ export const TrackHeader = memo(function TrackHeader({
                   onToggleDisabled()
                 }}
                 onMouseDown={(e) => e.stopPropagation()}
+                disabled={hostMode}
                 aria-label={
                   trackDisabled
                     ? t('timeline.trackHeader.enableTrack')
@@ -160,6 +167,7 @@ export const TrackHeader = memo(function TrackHeader({
                   onToggleSolo()
                 }}
                 onMouseDown={(e) => e.stopPropagation()}
+                disabled={hostMode}
                 aria-label={
                   track.solo
                     ? t('timeline.trackHeader.unsoloTrack')
@@ -188,6 +196,7 @@ export const TrackHeader = memo(function TrackHeader({
                   onToggleLock()
                 }}
                 onMouseDown={(e) => e.stopPropagation()}
+                disabled={hostMode}
                 aria-label={
                   track.locked
                     ? t('timeline.trackHeader.unlockTrack')
@@ -215,6 +224,7 @@ export const TrackHeader = memo(function TrackHeader({
                   onToggleSyncLock()
                 }}
                 onMouseDown={(e) => e.stopPropagation()}
+                disabled={hostMode}
                 aria-label={
                   syncLockEnabled
                     ? t('timeline.trackHeader.disableSyncLock')
@@ -242,6 +252,7 @@ export const TrackHeader = memo(function TrackHeader({
                   onCloseGaps?.()
                 }}
                 onMouseDown={(e) => e.stopPropagation()}
+                disabled={hostMode}
                 aria-label={t('timeline.trackHeader.closeAllGaps')}
                 data-tooltip={t('timeline.trackHeader.closeAllGaps')}
               >
@@ -262,22 +273,22 @@ export const TrackHeader = memo(function TrackHeader({
       </ContextMenuTrigger>
 
       <ContextMenuContent className="w-52">
-        <ContextMenuItem onClick={onCloseGaps}>
+        <ContextMenuItem disabled={hostMode} onClick={onCloseGaps}>
           {t('timeline.trackHeader.closeAllGaps')}
         </ContextMenuItem>
 
         <ContextMenuSeparator />
-        <ContextMenuItem onClick={onAddVideoTrack}>
+        <ContextMenuItem disabled={!canAddTrack} onClick={onAddVideoTrack}>
           {t('timeline.trackHeader.addVideoTrack')}
         </ContextMenuItem>
-        <ContextMenuItem onClick={onAddAudioTrack}>
+        <ContextMenuItem disabled={!canAddTrack} onClick={onAddAudioTrack}>
           {t('timeline.trackHeader.addAudioTrack')}
         </ContextMenuItem>
         <ContextMenuSeparator />
-        <ContextMenuItem disabled={!canDeleteTrack} onClick={onDeleteTrack}>
+        <ContextMenuItem disabled={hostMode || !canDeleteTrack} onClick={onDeleteTrack}>
           {t('timeline.trackHeader.deleteTrack')}
         </ContextMenuItem>
-        <ContextMenuItem disabled={!canDeleteEmptyTracks} onClick={onDeleteEmptyTracks}>
+        <ContextMenuItem disabled={hostMode || !canDeleteEmptyTracks} onClick={onDeleteEmptyTracks}>
           {t('timeline.trackHeader.deleteEmptyTracks')}
         </ContextMenuItem>
       </ContextMenuContent>
diff --git a/src/features/timeline/deps/editor-contract.ts b/src/features/timeline/deps/editor-contract.ts
new file mode 100644
index 000000000..a96ca3678
--- /dev/null
+++ b/src/features/timeline/deps/editor-contract.ts
@@ -0,0 +1,3 @@
+/** Adapter exports for editor host capability state used by timeline UI. */
+
+export { useEditorCapability } from '@/features/editor/host/context'
diff --git a/src/features/timeline/deps/editor.ts b/src/features/timeline/deps/editor.ts
new file mode 100644
index 000000000..d28d51db1
--- /dev/null
+++ b/src/features/timeline/deps/editor.ts
@@ -0,0 +1,3 @@
+/** Compatibility adapter that re-exports through editor-contract. */
+
+export * from './editor-contract'
diff --git a/src/features/timeline/hooks/use-timeline-audio-skim-preview.test.tsx b/src/features/timeline/hooks/use-timeline-audio-skim-preview.test.tsx
new file mode 100644
index 000000000..894445fb7
--- /dev/null
+++ b/src/features/timeline/hooks/use-timeline-audio-skim-preview.test.tsx
@@ -0,0 +1,24 @@
+// @vitest-environment jsdom
+
+import { renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+import { useEditorStore } from '@/shared/state/editor'
+import { usePlaybackStore } from '@/shared/state/playback'
+import { useTimelineAudioSkimPreview } from './use-timeline-audio-skim-preview'
+
+describe('useTimelineAudioSkimPreview', () => {
+  afterEach(() => {
+    useEditorStore.setState({ hostMode: false })
+    vi.restoreAllMocks()
+  })
+
+  it('does not subscribe to playback audio skim in host mode', () => {
+    useEditorStore.setState({ hostMode: true })
+    const subscribe = vi.spyOn(usePlaybackStore, 'subscribe')
+
+    const { unmount } = renderHook(() => useTimelineAudioSkimPreview())
+
+    expect(subscribe).not.toHaveBeenCalled()
+    unmount()
+  })
+})
diff --git a/src/features/timeline/hooks/use-timeline-audio-skim-preview.ts b/src/features/timeline/hooks/use-timeline-audio-skim-preview.ts
index 3b956254c..bbf1bce77 100644
--- a/src/features/timeline/hooks/use-timeline-audio-skim-preview.ts
+++ b/src/features/timeline/hooks/use-timeline-audio-skim-preview.ts
@@ -7,6 +7,7 @@ import {
   publishAudioSkimMeterLevel,
 } from '@/shared/state/audio-skim-meter'
 import { usePlaybackStore } from '@/shared/state/playback'
+import { useEditorStore } from '@/shared/state/editor'
 import {
   getOrDecodeAudioSliceForPlayback,
   resolvePreviewAudioConformUrl,
@@ -24,6 +25,7 @@ import {
 
 export function useTimelineAudioSkimPreview(): void {
   const audioSkimmingEnabled = useTimelineStore((s) => s.audioSkimmingEnabled)
+  const hostMode = useEditorStore((s) => s.hostMode)
   const requestIdRef = useRef(0)
   const rafRef = useRef<number | null>(null)
   const pendingFrameRef = useRef<number | null>(null)
@@ -102,6 +104,10 @@ export function useTimelineAudioSkimPreview(): void {
 
   const skimPreviewFrame = useCallback(
     async (frame: number) => {
+      if (hostMode) {
+        stopAudioSkim()
+        return
+      }
       if (!useTimelineStore.getState().audioSkimmingEnabled) {
         stopAudioSkim()
         return
@@ -224,12 +230,13 @@ export function useTimelineAudioSkimPreview(): void {
         }
       }
     },
-    [resolveSkimUrl, stopAudioSkim],
+    [hostMode, resolveSkimUrl, stopAudioSkim],
   )
   skimPreviewFrameRef.current = skimPreviewFrame
 
   const scheduleAudioSkim = useCallback(
     (frame: number) => {
+      if (hostMode) return
       pendingFrameRef.current = frame
       if (rafRef.current !== null) return
 
@@ -241,7 +248,7 @@ export function useTimelineAudioSkimPreview(): void {
         latestAudioSkimRunnerRef.current?.schedule(nextFrame)
       })
     },
-    [],
+    [hostMode],
   )
 
   useEffect(() => {
@@ -250,6 +257,10 @@ export function useTimelineAudioSkimPreview(): void {
   }, [audioSkimmingEnabled, stopAudioSkim])
 
   useEffect(() => {
+    if (hostMode) {
+      stopAudioSkim()
+      return
+    }
     return usePlaybackStore.subscribe((state, prev) => {
       if (state.isPlaying) {
         if (!prev.isPlaying || prev.previewFrame !== null) stopAudioSkim()
@@ -262,7 +273,7 @@ export function useTimelineAudioSkimPreview(): void {
       if (state.previewFrameEpoch === prev.previewFrameEpoch) return
       scheduleAudioSkim(state.previewFrame)
     })
-  }, [scheduleAudioSkim, stopAudioSkim])
+  }, [hostMode, scheduleAudioSkim, stopAudioSkim])
 
   useEffect(() => stopAudioSkim, [stopAudioSkim])
 }
diff --git a/src/features/timeline/hooks/use-waveform-prefetch.ts b/src/features/timeline/hooks/use-waveform-prefetch.ts
index de70ea141..145b599f4 100644
--- a/src/features/timeline/hooks/use-waveform-prefetch.ts
+++ b/src/features/timeline/hooks/use-waveform-prefetch.ts
@@ -6,6 +6,7 @@ import { useItemsStore } from '../stores/items-store'
 import { useTimelineSettingsStore } from '../stores/timeline-settings-store'
 import { useTimelineViewportStore } from '../stores/timeline-viewport-store'
 import { useZoomStore } from '../stores/zoom-store'
+import { useEditorStore } from '@/shared/state/editor'
 import {
   isPreviewWorkDeferred,
   schedulePreviewWork,
@@ -46,6 +47,7 @@ function loadWaveformCache() {
  * - Defers work while drag/trim/zoom interactions are active
  */
 export function useWaveformPrefetch() {
+  const hostMode = useEditorStore((state) => state.hostMode)
   const prevScrollLeftRef = useRef(useTimelineViewportStore.getState().scrollLeft)
 
   useEffect(() => {
@@ -56,6 +58,7 @@ export function useWaveformPrefetch() {
     }
 
     const prefetchVisibleWaveforms = () => {
+      if (useEditorStore.getState().hostMode) return
       const { scrollLeft, viewportWidth } = useTimelineViewportStore.getState()
       const { pixelsPerSecond } = useZoomStore.getState()
       const { fps } = useTimelineSettingsStore.getState()
@@ -141,5 +144,5 @@ export function useWaveformPrefetch() {
         unsubscribe()
       }
     }
-  }, [])
+  }, [hostMode])
 }
diff --git a/src/shared/state/editor/store.ts b/src/shared/state/editor/store.ts
index 2d035b32a..88f552aa0 100644
--- a/src/shared/state/editor/store.ts
+++ b/src/shared/state/editor/store.ts
@@ -127,6 +127,7 @@ export const useEditorStore = create<EditorState & EditorActions>((set) => ({
   keyframeEditorShortcutScopeActive: false,
   transcriptEditorShortcutScopeActive: false,
   workspace: initialWorkspace,
+  hostMode: false,
   activeTab: initialWorkspaceLayout.activeTab,
   clipInspectorTab: initialWorkspaceLayout.clipInspectorTab,
   sidebarWidth: loadSidebarWidth('editor:sidebarWidth', EDITOR_LAYOUT.leftSidebarDefaultWidth),
diff --git a/src/shared/state/editor/types.ts b/src/shared/state/editor/types.ts
index d86d80d28..f3242391a 100644
--- a/src/shared/state/editor/types.ts
+++ b/src/shared/state/editor/types.ts
@@ -16,6 +16,8 @@ export interface EditorState {
   /** True while the transcript editor owns Delete/Backspace (pointer or focus within). */
   transcriptEditorShortcutScopeActive: boolean
   workspace: EditorWorkspaceId
+  /** True while the editor is mounted through an injected host surface. */
+  hostMode: boolean
   activeTab: EditorSidebarTab
   clipInspectorTab: ClipInspectorTab
   sidebarWidth: number
diff --git a/src/types/storage.ts b/src/types/storage.ts
index 560b9bc06..c3a03fd18 100644
--- a/src/types/storage.ts
+++ b/src/types/storage.ts
@@ -12,8 +12,11 @@
  *                imported by older builds, and the repair sweep mirrors them
  *                into the workspace folder. OPFS remains the store for
  *                regenerable caches (proxies, waveforms, decoded audio).
+ * - 'host':      Descriptive metadata supplied by an embedded host. The
+ *                source is resolved at runtime and is never represented by a
+ *                File System Access handle or an OPFS path.
  */
-export type MediaStorageType = 'handle' | 'workspace' | 'opfs'
+export type MediaStorageType = 'handle' | 'workspace' | 'opfs' | 'host'
 
 /**
  * Provenance + usage terms for media imported from a third-party provider.
diff --git a/src/types/text.ts b/src/types/text.ts
index d9cc7c251..2da3c82dc 100644
--- a/src/types/text.ts
+++ b/src/types/text.ts
@@ -39,6 +39,8 @@ export type TextStroke = {
 
 export type TextVisualStyleFields = {
   backgroundColor?: string
+  /** Opacity for a caption/text background, kept separate from the color. */
+  backgroundOpacity?: number
   backgroundRadius?: number
   textAlign?: TextHorizontalAlign
   verticalAlign?: TextVerticalAlign
diff --git a/vite.editor-package.config.ts b/vite.editor-package.config.ts
new file mode 100644
index 000000000..1c5da402b
--- /dev/null
+++ b/vite.editor-package.config.ts
@@ -0,0 +1,122 @@
+import { defineConfig, lazyPlugins } from 'vite-plus'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import {
+  copyFileSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = fileURLToPath(new URL('.', import.meta.url))
+const outDir = fileURLToPath(new URL('./packages/freecut-editor/dist', import.meta.url))
+
+const hostDisabledWorkerNames = [
+  'clip-worker-',
+  'embeddings-worker-',
+  'export-render.worker-',
+  'frame-interpolation-worker-',
+  'gemma-scene-worker-',
+  'kokoro-',
+  'lfm-scene-worker-',
+  'parakeet.worker-',
+  'ort.bundle.min-',
+  'transformers.web-',
+  'upscale-worker-',
+]
+
+function statExists(filePath: string): boolean {
+  try {
+    statSync(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// fallow-ignore-next-line complexity
+function removeHostDisabledWorkers() {
+  for (const directory of [path.join(outDir, 'assets'), path.join(outDir, 'chunks')]) {
+    if (!statExists(directory)) continue
+    for (const entry of readdirSync(directory)) {
+      if (!hostDisabledWorkerNames.some((name) => entry.startsWith(name))) continue
+      rmSync(path.join(directory, entry), { force: true })
+    }
+  }
+}
+
+function normalizeEditorPackageAssets() {
+  return {
+    name: 'freecut-editor-package-assets',
+    buildStart() {
+      rmSync(outDir, { recursive: true, force: true })
+    },
+    writeBundle() {
+      mkdirSync(outDir, { recursive: true })
+      const cssFiles: string[] = []
+      const visit = (directory: string) => {
+        for (const entry of readdirSync(directory).sort()) {
+          const absolute = path.join(directory, entry)
+          if (statSync(absolute).isDirectory()) visit(absolute)
+          else if (entry.endsWith('.css')) cssFiles.push(absolute)
+        }
+      }
+      visit(outDir)
+      if (cssFiles.length > 0) {
+        const stylePath = fileURLToPath(
+          new URL('./packages/freecut-editor/dist/style.css', import.meta.url),
+        )
+        const css = cssFiles
+          .sort((left, right) => left.localeCompare(right))
+          .map((filePath) => readFileSync(filePath, 'utf8'))
+          .join('\n')
+        writeFileSync(stylePath, css)
+        for (const filePath of cssFiles) {
+          if (filePath !== stylePath) rmSync(filePath, { force: true })
+        }
+      }
+      removeHostDisabledWorkers()
+      copyFileSync(
+        fileURLToPath(new URL('./packages/freecut-editor/src/index.d.ts', import.meta.url)),
+        fileURLToPath(new URL('./packages/freecut-editor/dist/index.d.ts', import.meta.url)),
+      )
+    },
+  }
+}
+
+export default defineConfig({
+  plugins: lazyPlugins(() => [react(), tailwindcss(), normalizeEditorPackageAssets()]),
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./src', import.meta.url)),
+    },
+    dedupe: ['react', 'react-dom'],
+  },
+  build: {
+    target: 'esnext',
+    outDir,
+    emptyOutDir: true,
+    sourcemap: false,
+    cssCodeSplit: false,
+    lib: {
+      entry: fileURLToPath(new URL('./packages/freecut-editor/src/index.ts', import.meta.url)),
+      formats: ['es'],
+      fileName: () => 'index.js',
+    },
+    rollupOptions: {
+      external: [/^react(?:\/|$)/, /^react-dom(?:\/|$)/],
+      output: {
+        assetFileNames: 'assets/[name]-[hash][extname]',
+        chunkFileNames: 'chunks/[name]-[hash].js',
+        entryFileNames: 'index.js',
+      },
+    },
+  },
+  root,
+  publicDir: false,
+})
diff --git a/vite.editor-package.test.config.ts b/vite.editor-package.test.config.ts
new file mode 100644
index 000000000..4b18aec01
--- /dev/null
+++ b/vite.editor-package.test.config.ts
@@ -0,0 +1,28 @@
+import { defineConfig, lazyPlugins } from 'vite-plus'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: lazyPlugins(() => [react()]),
+  resolve: {
+    dedupe: ['react', 'react-dom'],
+  },
+  ssr: {
+    noExternal: ['@quantfive/freecut-editor-surface'],
+  },
+  test: {
+    environment: 'jsdom',
+    environmentOptions: {
+      jsdom: {
+        url: 'http://localhost/',
+      },
+    },
+    globals: true,
+    include: ['consumer-smoke.test.tsx'],
+    setupFiles: ['consumer-smoke.setup.ts'],
+    server: {
+      deps: {
+        inline: ['@quantfive/freecut-editor-surface'],
+      },
+    },
+  },
+})