@1agh/maude 0.39.0 → 0.40.0

package/apps/studio/api.ts

@@ -8,12 +8,23 @@ import path from 'node:path';
 
 import { renderBriefBoard, validateCanvasName } from './canvas-create.ts';
 import {
+  type AssembleClip,
+  assembleCompSource,
   CanvasEditError,
+  type ClipInfo,
+  editArrayElementString,
   editAttribute,
+  enumerateClips,
+  insertClip,
   type MovePosition,
   moveElement,
   removeAttribute,
+  removeClip,
+  reorderClip,
+  retimeSequence,
+  retimeSequenceByClip,
   editText as runEditText,
+  toggleClipHidden,
 } from './canvas-edit.ts';
 import type { Context } from './context.ts';
 import { createHistory } from './history.ts';
@@ -180,7 +191,7 @@ export type DeleteCanvasResult =
 
 /** Phase 12 — result of an in-canvas direct edit (`editCss` / `editText`). */
 export type EditOpResult =
-  | { ok: true; delta: number }
+  | { ok: true; delta: number; seq?: number }
   | { ok: false; status: number; error: string };
 
 /**
@@ -230,6 +241,10 @@ export interface Api {
   saveCanvasState(file: string, state: Record<string, unknown>): Promise<void>;
   // Canvas meta sidecar (Phase 4 T5 — .design/ui/<slug>.meta.json)
   loadCanvasMeta(file: string): Promise<Record<string, unknown> | null>;
+  /** DDR-148 — raw .tsx source for the Timeline sequence/keyframe parser. */
+  loadCanvasSource(
+    file: unknown
+  ): Promise<{ ok: true; source: string } | { ok: false; status: number; error: string }>;
   patchCanvasMeta(
     file: string,
     patch: Record<string, unknown>
@@ -239,17 +254,25 @@ export interface Api {
   saveAnnotations(file: string, svg: string): Promise<boolean>;
   // Phase 23 — content-addressed binary image write (drag-drop / paste / picker)
   saveAsset(bytes: Uint8Array): Promise<SaveAssetResult>;
+  /** DDR-148 — streaming variant for the HTTP route (100 MB video without a
+   *  full in-RAM buffer). Sniffs + caps + content-addresses like saveAsset. */
+  saveAssetFromStream(stream: ReadableStream<Uint8Array>): Promise<SaveAssetResult>;
   // Persist a clipboard-pasted ACP composer image → runtime `_chat/attachments/`,
   // returns an absolute path (Phase 31 follow-up — POST /_api/acp/attachment).
   saveChatAttachment(bytes: Uint8Array): Promise<SaveAssetResult>;
   // Resolve a content-addressed attachment name (`<sha8>.<ext>`) to its absolute
   // path, or null (GET /_api/acp/attachment — the read side of the pair above).
   resolveChatAttachment(name: unknown): Promise<string | null>;
-  // Create a blank brief board from the browser (Phase 22 — POST /_api/canvas)
+  // Create a blank brief board OR an assembled video-comp from the browser
+  // (Phase 22 — POST /_api/canvas; DDR-150 P4 Task 12 adds kind "video-comp").
   createCanvas(input: {
     name?: unknown;
     kind?: unknown;
     group?: unknown;
+    clips?: unknown;
+    fps?: unknown;
+    width?: unknown;
+    height?: unknown;
   }): Promise<CreateCanvasResult>;
   // Soft-delete a canvas from the browser (Phase 22 — DELETE /_api/canvas)
   deleteCanvas(input: { file?: unknown }): Promise<DeleteCanvasResult>;
@@ -281,6 +304,85 @@ export interface Api {
     refId?: unknown;
     position?: unknown;
   }): Promise<ReorderOpResult>;
+  /** DDR-148 — Timeline drag-to-retime a sequence's durationInFrames / from. */
+  retimeSequenceOp(input: {
+    canvas?: unknown;
+    // DDR-150 P2 — prefer stableId (comp-scoped, multi-comp-safe) over index.
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+    index?: unknown;
+    durationInFrames?: unknown;
+    from?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }>;
+  // DDR-150 P3 — remove a clip addressed by stableId (fingerprint + semantic
+  // gate; refuses the only clip; drops an adjacent transition in a series).
+  removeSequenceOp(input: {
+    canvas?: unknown;
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }>;
+  // DDR-150 P4 — insert a new <Sequence> (optionally with media) after a comp's
+  // last clip. Returns the new clip's stableId.
+  insertSequenceOp(input: {
+    canvas?: unknown;
+    artboardId?: unknown;
+    from?: unknown;
+    durationInFrames?: unknown;
+    mediaTag?: unknown;
+    src?: unknown;
+  }): Promise<
+    | { ok: true; stableId: string | null; seq?: number }
+    | { ok: false; status: number; error: string }
+  >;
+  // DDR-150 P5 — z-order reorder: move a standalone <Sequence> before/after a
+  // sibling (render stacking), reusing moveElement + the semantic gate. Both
+  // clips are fingerprint-checked. Returns the moved clip's (re-settled) stableId.
+  reorderSequenceOp(input: {
+    canvas?: unknown;
+    artboardId?: unknown;
+    stableId?: unknown;
+    contentHash?: unknown;
+    refStableId?: unknown;
+    refContentHash?: unknown;
+    position?: unknown;
+  }): Promise<
+    | { ok: true; stableId: string | null; seq?: number }
+    | { ok: false; status: number; error: string }
+  >;
+  // DDR-150 dogfood — replace a media src that lives in an array literal
+  // (the showreel `CLIPS[i].src` pattern), addressed by mediaArrayRef.
+  editArraySrcOp(input: {
+    canvas?: unknown;
+    arrayName?: unknown;
+    index?: unknown;
+    field?: unknown;
+    value?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }>;
+  // DDR-150 dogfood — hide/show a clip (gates its body behind {false && …}).
+  toggleHideOp(input: {
+    canvas?: unknown;
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+  }): Promise<
+    { ok: true; hidden: boolean; seq?: number } | { ok: false; status: number; error: string }
+  >;
+  // DDR-150 P2 — the single authoritative clip enumerator for a video-comp.
+  // Read-only; the Timeline addresses every op by the returned `stableId`
+  // (never a regex document-order index — the multi-comp mis-hit defect).
+  compClips(input: { canvas?: unknown; artboardId?: unknown }): Promise<
+    | {
+        ok: true;
+        compName: string | null;
+        artboardId: string | null;
+        fps: number | null;
+        durationInFrames: number | null;
+        clips: Array<Omit<ClipInfo, 'start' | 'end'>>;
+      }
+    | { ok: false; status: number; error: string }
+  >;
   // Undo/redo a prior reorder by seq (Cmd+Z from the canvas undo stack). Whole-
   // file content swap from the in-memory revert log — immune to the positional
   // data-cd-id churn a reorder causes (inverse-descriptor undo would go stale).
@@ -327,7 +429,10 @@ export const ASSET_MAX_BYTES = 10 * 1024 * 1024;
  */
 export const ASSET_SESSION_BUDGET = (() => {
   const env = Number(process.env.MAUDE_ASSET_SESSION_BUDGET);
-  return Number.isFinite(env) && env > 0 ? env : 256 * 1024 * 1024;
+  // DDR-148 — raised 256 MB → 1 GB now that the route accepts video/audio (one
+  // 100 MB clip would blow a 256 MB budget after a couple of drops). Still an
+  // aggregate per-server-instance disk-fill bound; env-overridable.
+  return Number.isFinite(env) && env > 0 ? env : 1024 * 1024 * 1024;
 })();
 
 /**
@@ -392,6 +497,110 @@ export interface SaveAssetResult {
   path?: string;
 }
 
+/** DDR-148 — media category, decides which per-file cap applies. */
+export type AssetCategory = 'image' | 'video' | 'audio';
+
+export interface AssetTypeInfo {
+  /** Stored file extension (bytes decide it, never the upload name). */
+  ext: string;
+  category: AssetCategory;
+}
+
+/**
+ * DDR-148 — per-file ceiling for time-based media (video + audio). Images keep
+ * the tighter {@link ASSET_MAX_BYTES} 10 MB cap. Overridable via
+ * `MAUDE_ASSET_MAX_VIDEO_BYTES` (bytes) for power users. The route lives on the
+ * (untrusted) canvas origin, so this cap + the session budget + the streamed
+ * write are the trust mitigation, exactly like the image caps (DDR-088).
+ */
+export const ASSET_MAX_VIDEO_BYTES = (() => {
+  const env = Number(process.env.MAUDE_ASSET_MAX_VIDEO_BYTES);
+  return Number.isFinite(env) && env > 0 ? env : 100 * 1024 * 1024;
+})();
+
+/** The byte cap for a category. */
+export function assetCapForCategory(category: AssetCategory): number {
+  return category === 'image' ? ASSET_MAX_BYTES : ASSET_MAX_VIDEO_BYTES;
+}
+
+const UNSUPPORTED_ASSET_MSG =
+  'unsupported media type — png/jpeg/gif/webp images or mp4/mov/webm/mp3/wav/m4a media only (SVG/script rejected)';
+
+function capError(category?: AssetCategory): string {
+  if (category === 'image') return 'image exceeds the 10 MB cap';
+  const mb = Math.round(ASSET_MAX_VIDEO_BYTES / (1024 * 1024));
+  return `media exceeds the ${mb} MB cap`;
+}
+
+/** Concatenate a small list of chunks (used only for the ≤ few-KB sniff head). */
+function concatBytes(chunks: readonly Uint8Array[]): Uint8Array {
+  let len = 0;
+  for (const c of chunks) len += c.length;
+  const out = new Uint8Array(len);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+
+/**
+ * DDR-148 — magic-byte type sniff for the WIDENED asset route: images (via
+ * {@link sniffImageType}) PLUS time-based media. The declared name / extension
+ * / Content-Type is NEVER trusted — the bytes decide the stored extension AND
+ * the category (→ which cap applies). The server only sniffs; it never PARSES a
+ * container (parsing happens in the sandboxed capture browser). Anything that
+ * isn't a recognised raster/video/audio magic number (SVG, HTML, arbitrary
+ * script) → null → rejected (415). Needs ≥ 12 bytes for the ISO-BMFF brands.
+ */
+export function sniffAssetType(bytes: Uint8Array): AssetTypeInfo | null {
+  const img = sniffImageType(bytes);
+  if (img) return { ext: img, category: 'image' };
+  const b = bytes;
+  // ISO-BMFF (mp4 / mov / m4a): "ftyp" box at offset 4, brand at offset 8.
+  if (
+    b.length >= 12 &&
+    b[4] === 0x66 && // f
+    b[5] === 0x74 && // t
+    b[6] === 0x79 && // y
+    b[7] === 0x70 // p
+  ) {
+    const brand = String.fromCharCode(b[8] ?? 0, b[9] ?? 0, b[10] ?? 0, b[11] ?? 0);
+    if (brand === 'qt  ') return { ext: 'mov', category: 'video' };
+    if (brand.startsWith('M4A')) return { ext: 'm4a', category: 'audio' };
+    if (brand.startsWith('M4V')) return { ext: 'm4v', category: 'video' };
+    // isom / mp41 / mp42 / avc1 / iso2 / iso5 / dash / mp4v / … → treat as mp4.
+    return { ext: 'mp4', category: 'video' };
+  }
+  // Matroska / WebM — EBML header 1A 45 DF A3.
+  if (b.length >= 4 && b[0] === 0x1a && b[1] === 0x45 && b[2] === 0xdf && b[3] === 0xa3) {
+    return { ext: 'webm', category: 'video' };
+  }
+  // MP3 — "ID3" tag OR a frame-sync (0xFF followed by 0b111xxxxx).
+  if (b.length >= 3 && b[0] === 0x49 && b[1] === 0x44 && b[2] === 0x33) {
+    return { ext: 'mp3', category: 'audio' };
+  }
+  if (b.length >= 2 && b[0] === 0xff && ((b[1] ?? 0) & 0xe0) === 0xe0) {
+    return { ext: 'mp3', category: 'audio' };
+  }
+  // WAV — "RIFF"????"WAVE".
+  if (
+    b.length >= 12 &&
+    b[0] === 0x52 &&
+    b[1] === 0x49 &&
+    b[2] === 0x46 &&
+    b[3] === 0x46 &&
+    b[8] === 0x57 &&
+    b[9] === 0x41 &&
+    b[10] === 0x56 &&
+    b[11] === 0x45
+  ) {
+    return { ext: 'wav', category: 'audio' };
+  }
+  return null;
+}
+
 export function createApi(ctx: Context, hooks: ApiHooks): Api {
   const onCommentsChanged = hooks.onCommentsChanged;
   const onAnnotationsChanged = hooks.onAnnotationsChanged;
@@ -405,6 +614,22 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
   const reorderLog = new Map<number, { abs: string; before: string; after: string }>();
   let reorderSeq = 0;
 
+  // DDR-150 dogfood #1 — the SAME whole-file log backs the Timeline clip ops
+  // (retime / remove / insert / z-reorder / replace-src): every successful op
+  // registers its {before, after} and returns the seq; the shell keeps a
+  // per-canvas undo/redo stack of seqs and replays them through
+  // /_api/reorder-revert (guarded whole-file swap, 409 on divergence).
+  function logUndo(abs: string, before: string, after: string): number {
+    const seq = ++reorderSeq;
+    reorderLog.set(seq, { abs, before, after });
+    while (reorderLog.size > REORDER_LOG_CAP) {
+      const oldest = reorderLog.keys().next().value;
+      if (oldest === undefined) break;
+      reorderLog.delete(oldest);
+    }
+    return seq;
+  }
+
   function fileSlug(file: string): string {
     return canvasSlugFromRel(file, paths.designRel);
   }
@@ -987,51 +1212,153 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
   //     user input, but a poisoned designRoot must still not escape).
   // Running total of bytes this server instance has actually written (post-dedupe).
   let assetBytesWritten = 0;
-  async function saveAsset(bytes: Uint8Array): Promise<SaveAssetResult> {
-    if (!bytes || bytes.length === 0) return { ok: false, status: 400, error: 'empty body' };
-    if (bytes.length > ASSET_MAX_BYTES) {
-      return { ok: false, status: 413, error: 'asset exceeds the 10 MB cap' };
-    }
-    const kind = sniffImageType(bytes);
-    if (!kind) {
-      return {
-        ok: false,
-        status: 415,
-        error: 'unsupported image type — png/jpeg/gif/webp only (SVG rejected)',
-      };
-    }
-    const sha8 = crypto.createHash('sha256').update(bytes).digest('hex').slice(0, 8);
-    const name = `${sha8}.${kind}`;
+
+  /**
+   * DDR-148 — the streaming write path behind `POST /_api/asset`. Reads the
+   * request body chunk-by-chunk so a 100 MB video never lands as a single
+   * ArrayBuffer in RAM (the memory-amplification vector DDR-088 §review flagged
+   * for the untrusted canvas origin — worse now that the per-file cap is 100 MB,
+   * not 10 MB). Sniffs the type from the head, applies the CATEGORY cap while
+   * streaming (image 10 MB · video/audio {@link ASSET_MAX_VIDEO_BYTES}), writes
+   * to a temp file, then content-addresses (sha8) → dedupe-rename. Nothing is
+   * ever parsed — only magic bytes are read. `saveAsset(bytes)` wraps this so
+   * both the route and any programmatic caller share ONE tested path.
+   */
+  async function saveAssetFromStream(stream: ReadableStream<Uint8Array>): Promise<SaveAssetResult> {
     const assetsDir = path.join(paths.designRoot, 'assets');
-    const fileAbs = path.join(assetsDir, name);
-    // Containment backstop — the name is content-addressed (sha8 hex + sniffed
-    // ext), so there is no user-controlled path segment, but assert anyway.
-    const resolved = path.resolve(fileAbs);
-    const assetsResolved = path.resolve(assetsDir);
-    if (resolved !== path.join(assetsResolved, name)) {
-      return { ok: false, status: 400, error: 'resolved asset path escapes assets dir' };
-    }
+    const tmpName = `.tmp-${crypto.randomBytes(8).toString('hex')}`;
+    const tmpAbs = path.join(assetsDir, tmpName);
+    const hash = crypto.createHash('sha256');
+    let sink: Bun.FileSink | null = null;
+    let typeInfo: AssetTypeInfo | null = null;
+    let cap = ASSET_MAX_VIDEO_BYTES; // provisional max until the head is sniffed
+    let total = 0;
+    const headChunks: Uint8Array[] = [];
+    let headLen = 0;
+
+    const cleanup = async () => {
+      try {
+        if (sink) await sink.end();
+      } catch {
+        /* sink already closed */
+      }
+      try {
+        await rm(tmpAbs, { force: true });
+      } catch {
+        /* temp already gone */
+      }
+    };
+    const flushHead = () => {
+      for (const c of headChunks) {
+        hash.update(c);
+        sink?.write(c);
+      }
+      headChunks.length = 0;
+      headLen = 0;
+    };
+
+    // Explicit reader (NOT `for await` — Bun's HTTP `req.body` ReadableStream
+    // does not implement Symbol.asyncIterator, so async-iteration throws
+    // "undefined is not a function"; getReader().read() works for every stream).
+    const reader = stream.getReader();
     try {
-      // Dedupe — identical bytes hash to the same name; skip the write if present.
-      if (!(await Bun.file(fileAbs).exists())) {
-        // Aggregate write budget (DDR-088 follow-up) — bounds a scripted
-        // one-byte-mutation disk-fill loop from the untrusted canvas origin.
-        // Only a genuinely NEW file counts (a dedupe hit is free).
-        if (assetBytesWritten + bytes.length > ASSET_SESSION_BUDGET) {
-          return {
-            ok: false,
-            status: 429,
-            error: 'asset write budget exceeded for this server session',
-          };
+      await mkdir(assetsDir, { recursive: true });
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = value;
+        if (!chunk || chunk.length === 0) continue;
+        total += chunk.length;
+        if (total > cap) {
+          await cleanup();
+          return { ok: false, status: 413, error: capError(typeInfo?.category) };
+        }
+        if (!typeInfo) {
+          headChunks.push(chunk);
+          headLen += chunk.length;
+          if (headLen >= 12) {
+            typeInfo = sniffAssetType(concatBytes(headChunks));
+            if (!typeInfo) {
+              await cleanup(); // nothing written yet — no temp file to remove
+              return { ok: false, status: 415, error: UNSUPPORTED_ASSET_MSG };
+            }
+            cap = assetCapForCategory(typeInfo.category);
+            if (total > cap) {
+              await cleanup();
+              return { ok: false, status: 413, error: capError(typeInfo.category) };
+            }
+            sink = Bun.file(tmpAbs).writer();
+            flushHead();
+          }
+        } else {
+          hash.update(chunk);
+          sink?.write(chunk);
         }
-        await mkdir(assetsDir, { recursive: true });
-        await Bun.write(fileAbs, bytes);
-        assetBytesWritten += bytes.length;
       }
+
+      if (total === 0) {
+        await cleanup();
+        return { ok: false, status: 400, error: 'empty body' };
+      }
+      // A body shorter than 12 bytes never triggered the mid-stream sniff.
+      if (!typeInfo) {
+        typeInfo = sniffAssetType(concatBytes(headChunks));
+        if (!typeInfo) {
+          await cleanup();
+          return { ok: false, status: 415, error: UNSUPPORTED_ASSET_MSG };
+        }
+        cap = assetCapForCategory(typeInfo.category);
+        if (total > cap) {
+          await cleanup();
+          return { ok: false, status: 413, error: capError(typeInfo.category) };
+        }
+        sink = Bun.file(tmpAbs).writer();
+        flushHead();
+      }
+      if (sink) await sink.end();
+
+      const sha8 = hash.digest('hex').slice(0, 8);
+      const name = `${sha8}.${typeInfo.ext}`;
+      const fileAbs = path.join(assetsDir, name);
+      // Containment backstop — the name is content-addressed (sha8 hex + sniffed
+      // ext), no user-controlled segment, but assert anyway (poisoned designRoot).
+      if (path.resolve(fileAbs) !== path.join(path.resolve(assetsDir), name)) {
+        await rm(tmpAbs, { force: true });
+        return { ok: false, status: 400, error: 'resolved asset path escapes assets dir' };
+      }
+      // Dedupe — identical bytes hash to the same name; drop the temp copy.
+      if (await Bun.file(fileAbs).exists()) {
+        await rm(tmpAbs, { force: true });
+        return { ok: true, path: `assets/${name}` };
+      }
+      // Aggregate write budget — bounds a scripted disk-fill loop from the
+      // untrusted canvas origin. Only a genuinely NEW file counts.
+      if (assetBytesWritten + total > ASSET_SESSION_BUDGET) {
+        await rm(tmpAbs, { force: true });
+        return {
+          ok: false,
+          status: 429,
+          error: 'asset write budget exceeded for this server session',
+        };
+      }
+      await rename(tmpAbs, fileAbs);
+      assetBytesWritten += total;
+      return { ok: true, path: `assets/${name}` };
     } catch (err) {
+      await cleanup();
       return { ok: false, status: 500, error: err instanceof Error ? err.message : 'write failed' };
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+        /* already released */
+      }
     }
-    return { ok: true, path: `assets/${name}` };
+  }
+
+  async function saveAsset(bytes: Uint8Array): Promise<SaveAssetResult> {
+    if (!bytes || bytes.length === 0) return { ok: false, status: 400, error: 'empty body' };
+    return saveAssetFromStream(new Response(bytes).body as ReadableStream<Uint8Array>);
   }
 
   // Phase 31 follow-up — persist an image pasted straight from the clipboard into
@@ -1112,11 +1439,37 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     name?: unknown;
     kind?: unknown;
     group?: unknown;
+    // DDR-150 P4 Task 12 — video-comp assemble payload (kind === 'video-comp').
+    clips?: unknown;
+    fps?: unknown;
+    width?: unknown;
+    height?: unknown;
   }): Promise<CreateCanvasResult> {
-    // v1 only stamps blank boards — generation stays with `/design:new` (Claude).
+    // v1 stamps blank brief-boards + assembled video-comps — richer generation
+    // stays with `/design:new` (Claude).
     const kind = input.kind == null || input.kind === '' ? 'brief-board' : input.kind;
-    if (kind !== 'brief-board') {
-      return { ok: false, status: 400, error: 'only kind "brief-board" is supported' };
+    if (kind !== 'brief-board' && kind !== 'video-comp') {
+      return { ok: false, status: 400, error: 'kind must be "brief-board" or "video-comp"' };
+    }
+    // Parse + validate the assemble clip list up front (video-comp only).
+    const assembleClips: AssembleClip[] = [];
+    if (kind === 'video-comp') {
+      if (!Array.isArray(input.clips) || input.clips.length === 0) {
+        return { ok: false, status: 400, error: 'video-comp needs a non-empty clips[]' };
+      }
+      if (input.clips.length > 60) {
+        return { ok: false, status: 400, error: 'too many clips (max 60)' };
+      }
+      for (const raw of input.clips) {
+        const c = raw as { src?: unknown; mediaKind?: unknown; durationInFrames?: unknown };
+        const src = typeof c?.src === 'string' ? c.src : '';
+        if (!src) return { ok: false, status: 400, error: 'each clip needs a src' };
+        const mediaKind = c?.mediaKind === 'audio' ? 'audio' : 'video';
+        const durationInFrames = Number.isFinite(Number(c?.durationInFrames))
+          ? Math.max(1, Math.min(100000, Math.round(Number(c.durationInFrames))))
+          : null;
+        assembleClips.push({ src, mediaKind, durationInFrames });
+      }
     }
     const v = validateCanvasName(input.name);
     if (!v.ok || !v.name || !v.componentName) {
@@ -1169,25 +1522,55 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     const slug = fileSlug(rel);
     const dsName = cfg.defaultDesignSystem || 'project';
     const platform = 'desktop';
-    const tsx = renderBriefBoard({
-      name: v.name,
-      componentName: v.componentName,
-      dsName,
-      platform,
-      seedHint: 'Empty brief board — annotate me',
-      historyDir: path.posix.join(paths.designRel, '_history', slug),
-    });
+    let tsx: string;
+    if (kind === 'video-comp') {
+      try {
+        tsx = assembleCompSource(v.componentName, assembleClips, {
+          fps: Number.isFinite(Number(input.fps)) ? Number(input.fps) : undefined,
+          width: Number.isFinite(Number(input.width)) ? Number(input.width) : undefined,
+          height: Number.isFinite(Number(input.height)) ? Number(input.height) : undefined,
+        });
+      } catch (err) {
+        return {
+          ok: false,
+          status: 400,
+          error: err instanceof Error ? err.message : 'assemble failed',
+        };
+      }
+    } else {
+      tsx = renderBriefBoard({
+        name: v.name,
+        componentName: v.componentName,
+        dsName,
+        platform,
+        seedHint: 'Empty brief board — annotate me',
+        historyDir: path.posix.join(paths.designRel, '_history', slug),
+      });
+    }
     const now = new Date().toISOString();
-    const meta = {
-      kind: 'brief-board',
-      title: v.name,
-      subtitle: 'brief board',
-      brief: v.name,
-      designSystem: dsName,
-      platform,
-      created: now,
-      last_modified: now,
-    };
+    const meta =
+      kind === 'video-comp'
+        ? {
+            kind: 'video-comp',
+            title: v.name,
+            subtitle: 'assembled reel',
+            brief: v.name,
+            tags: ['video'],
+            designSystem: dsName,
+            platform,
+            created: now,
+            last_modified: now,
+          }
+        : {
+            kind: 'brief-board',
+            title: v.name,
+            subtitle: 'brief board',
+            brief: v.name,
+            designSystem: dsName,
+            platform,
+            created: now,
+            last_modified: now,
+          };
     await Bun.write(fileAbs, tsx);
     await Bun.write(
       path.join(groupAbs, `${v.name}.meta.json`),
@@ -1356,6 +1739,27 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     return { ok: true, abs };
   }
 
+  /**
+   * DDR-148 — read a canvas's RAW .tsx source (containment via resolveCanvasAbs).
+   * The Timeline panel parses `<Sequence>`/`<TransitionSeries.Sequence>` blocks
+   * + `interpolate` windows from it to draw the sequence/keyframe rows. Read-only,
+   * MAIN-ORIGIN ONLY at the route layer (never the untrusted canvas iframe).
+   */
+  async function loadCanvasSource(
+    file: unknown
+  ): Promise<{ ok: true; source: string } | { ok: false; status: number; error: string }> {
+    const r = resolveCanvasAbs(file);
+    if (!r.ok) return r;
+    const f = Bun.file(r.abs);
+    if (!(await f.exists())) return { ok: false, status: 404, error: 'canvas not found' };
+    const source = await f.text();
+    // A comp is small; never stream a huge blob into the panel.
+    if (source.length > 512 * 1024) {
+      return { ok: false, status: 413, error: 'canvas source too large for the timeline parser' };
+    }
+    return { ok: true, source };
+  }
+
   // 8-hex lowercase, the shape `computeId` (canvas-edit.ts) stamps on data-cd-id.
   const CD_ID_RE = /^[0-9a-f]{8}$/;
 
@@ -1374,11 +1778,20 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     const rel = path.relative(paths.designRoot, abs);
     ctx.bus.emit('activity:suppress', rel);
     try {
+      // DDR-150 dogfood #1 — capture before/after so the edit registers in the
+      // whole-file undo log (the Timeline replace-src path rides this; other
+      // inspector edits get an undoable seq for free).
+      const before = await Bun.file(abs).text();
       const res = await run();
       // `changed === false` = the op collapsed to a no-op and nothing hit disk —
       // NOT `delta === 0`, which an equal-length replacement also produces.
-      if (res.changed === false) ctx.bus.emit('activity:unsuppress', rel);
-      return { ok: true, delta: res.delta };
+      if (res.changed === false) {
+        ctx.bus.emit('activity:unsuppress', rel);
+        return { ok: true, delta: res.delta };
+      }
+      const after = await Bun.file(abs).text();
+      const seq = after !== before ? logUndo(abs, before, after) : undefined;
+      return { ok: true, delta: res.delta, seq };
     } catch (err) {
       ctx.bus.emit('activity:unsuppress', rel);
       return {
@@ -1478,6 +1891,18 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     const value = typeof input.value === 'string' ? input.value : '';
     if (!value.trim()) return { ok: false, status: 400, error: 'value required' };
     if (value.length > 256) return { ok: false, status: 413, error: 'value too long' };
+    // DDR-150 P3 — a media/image `src` edit (the clip-replace path) must stay a
+    // contained asset reference: no path traversal, no script/file/data schemes.
+    if (
+      attr === 'src' &&
+      (/\.\./.test(value) || /^\s*(javascript|vbscript|file|data):/i.test(value))
+    ) {
+      return {
+        ok: false,
+        status: 400,
+        error: 'src must be a contained asset path (no ../ or javascript:/file:/data: schemes)',
+      };
+    }
     // Non-`style.` attr name → editAttribute writes a plain quoted JSX attribute.
     // Pass the value RAW: editStringAttr quotes/escapes it itself (JSON.stringify
     // on replace, escapeAttr on insert) — pre-stringifying here double-encoded
@@ -1566,6 +1991,320 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     }
   }
 
+  /**
+   * DDR-148 — Timeline drag-to-retime. Rewrites the `durationInFrames` / `from`
+   * of the `index`-th sequence (document order). MAIN-ORIGIN ONLY at the route
+   * layer. Snapshots pre-retime for /design:rollback; suppresses the agent-rim.
+   */
+  async function retimeSequenceOp(input: {
+    canvas?: unknown;
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+    index?: unknown;
+    durationInFrames?: unknown;
+    from?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }> {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    // DDR-150 P2 — prefer the comp-scoped stableId (multi-comp-safe) over the
+    // legacy whole-file index. The index path stays for back-compat.
+    const stableId = typeof input.stableId === 'string' ? input.stableId : null;
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    const contentHash = typeof input.contentHash === 'string' ? input.contentHash : undefined;
+    const index = Number.isInteger(input.index) ? (input.index as number) : -1;
+    if (!stableId && (index < 0 || index > 500))
+      return { ok: false, status: 400, error: 'invalid sequence index' };
+    const frames = (v: unknown, lo: number): number | undefined => {
+      const n = Math.round(Number(v));
+      return Number.isFinite(n) ? Math.max(lo, Math.min(100000, n)) : undefined;
+    };
+    const patch: { durationInFrames?: number; from?: number } = {};
+    if (input.durationInFrames != null) patch.durationInFrames = frames(input.durationInFrames, 1);
+    if (input.from != null) patch.from = frames(input.from, 0);
+    if (patch.durationInFrames == null && patch.from == null) {
+      return { ok: false, status: 400, error: 'nothing to retime' };
+    }
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      if (stableId) await retimeSequenceByClip(r.abs, artboardId, stableId, contentHash, patch);
+      else await retimeSequence(r.abs, index, patch);
+      const after = await Bun.file(r.abs).text();
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+        return { ok: true };
+      }
+      try {
+        await history.writeSnapshot(rel, before, 'pre-retime');
+      } catch {
+        /* snapshot best-effort */
+      }
+      return { ok: true, seq: logUndo(r.abs, before, after) };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'retime failed',
+      };
+    }
+  }
+
+  async function removeSequenceOp(input: {
+    canvas?: unknown;
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }> {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const stableId = typeof input.stableId === 'string' ? input.stableId : null;
+    if (!stableId) return { ok: false, status: 400, error: 'stableId required' };
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    const contentHash = typeof input.contentHash === 'string' ? input.contentHash : undefined;
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      await removeClip(r.abs, artboardId, stableId, contentHash);
+      const after = await Bun.file(r.abs).text();
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+        return { ok: true };
+      }
+      try {
+        await history.writeSnapshot(rel, before, 'pre-remove-clip');
+      } catch {
+        /* snapshot best-effort */
+      }
+      return { ok: true, seq: logUndo(r.abs, before, after) };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'remove failed',
+      };
+    }
+  }
+
+  async function insertSequenceOp(input: {
+    canvas?: unknown;
+    artboardId?: unknown;
+    from?: unknown;
+    durationInFrames?: unknown;
+    mediaTag?: unknown;
+    src?: unknown;
+  }): Promise<
+    | { ok: true; stableId: string | null; seq?: number }
+    | { ok: false; status: number; error: string }
+  > {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    const from = Number.isFinite(Number(input.from))
+      ? Math.max(0, Math.round(Number(input.from)))
+      : 0;
+    const durationInFrames = Number.isFinite(Number(input.durationInFrames))
+      ? Math.max(1, Math.min(100000, Math.round(Number(input.durationInFrames))))
+      : 90;
+    const mediaTag = typeof input.mediaTag === 'string' ? input.mediaTag : null;
+    const src = typeof input.src === 'string' ? input.src : null;
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      const res = await insertClip(r.abs, artboardId, { from, durationInFrames, mediaTag, src });
+      const after = await Bun.file(r.abs).text();
+      let seq: number | undefined;
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+      } else {
+        try {
+          await history.writeSnapshot(rel, before, 'pre-insert-clip');
+        } catch {
+          /* snapshot best-effort */
+        }
+        seq = logUndo(r.abs, before, after);
+      }
+      return { ok: true, stableId: res.stableId, seq };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'insert failed',
+      };
+    }
+  }
+
+  async function toggleHideOp(input: {
+    canvas?: unknown;
+    stableId?: unknown;
+    artboardId?: unknown;
+    contentHash?: unknown;
+  }): Promise<
+    { ok: true; hidden: boolean; seq?: number } | { ok: false; status: number; error: string }
+  > {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const stableId = typeof input.stableId === 'string' ? input.stableId : null;
+    if (!stableId) return { ok: false, status: 400, error: 'stableId required' };
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    const contentHash = typeof input.contentHash === 'string' ? input.contentHash : undefined;
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      const res = await toggleClipHidden(r.abs, artboardId, stableId, contentHash);
+      const after = await Bun.file(r.abs).text();
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+        return { ok: true, hidden: res.hidden };
+      }
+      return { ok: true, hidden: res.hidden, seq: logUndo(r.abs, before, after) };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'hide failed',
+      };
+    }
+  }
+
+  async function editArraySrcOp(input: {
+    canvas?: unknown;
+    arrayName?: unknown;
+    index?: unknown;
+    field?: unknown;
+    value?: unknown;
+  }): Promise<{ ok: true; seq?: number } | { ok: false; status: number; error: string }> {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const arrayName = typeof input.arrayName === 'string' ? input.arrayName : '';
+    const field = typeof input.field === 'string' ? input.field : 'src';
+    const index = Number.isInteger(input.index) ? (input.index as number) : -1;
+    const value = typeof input.value === 'string' ? input.value : '';
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(arrayName)) {
+      return { ok: false, status: 400, error: 'invalid array name' };
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(field)) {
+      return { ok: false, status: 400, error: 'invalid field' };
+    }
+    if (index < 0 || index > 500) return { ok: false, status: 400, error: 'invalid index' };
+    if (!value.trim()) return { ok: false, status: 400, error: 'value required' };
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      await editArrayElementString(r.abs, arrayName, index, field, value);
+      const after = await Bun.file(r.abs).text();
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+        return { ok: true };
+      }
+      return { ok: true, seq: logUndo(r.abs, before, after) };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'edit failed',
+      };
+    }
+  }
+
+  async function reorderSequenceOp(input: {
+    canvas?: unknown;
+    artboardId?: unknown;
+    stableId?: unknown;
+    contentHash?: unknown;
+    refStableId?: unknown;
+    refContentHash?: unknown;
+    position?: unknown;
+  }): Promise<
+    | { ok: true; stableId: string | null; seq?: number }
+    | { ok: false; status: number; error: string }
+  > {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const stableId = typeof input.stableId === 'string' ? input.stableId : null;
+    const refStableId = typeof input.refStableId === 'string' ? input.refStableId : null;
+    if (!stableId || !refStableId) {
+      return { ok: false, status: 400, error: 'stableId and refStableId required' };
+    }
+    const position: MovePosition = input.position === 'before' ? 'before' : 'after';
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    const contentHash = typeof input.contentHash === 'string' ? input.contentHash : undefined;
+    const refContentHash =
+      typeof input.refContentHash === 'string' ? input.refContentHash : undefined;
+    const rel = path.relative(paths.designRoot, r.abs);
+    ctx.bus.emit('activity:suppress', rel);
+    try {
+      const before = await Bun.file(r.abs).text();
+      const res = await reorderClip(
+        r.abs,
+        artboardId,
+        stableId,
+        contentHash,
+        refStableId,
+        refContentHash,
+        position
+      );
+      const after = await Bun.file(r.abs).text();
+      let seq: number | undefined;
+      if (after === before) {
+        ctx.bus.emit('activity:unsuppress', rel);
+      } else {
+        try {
+          await history.writeSnapshot(rel, before, 'pre-reorder-clip');
+        } catch {
+          /* snapshot best-effort */
+        }
+        seq = logUndo(r.abs, before, after);
+      }
+      return { ok: true, stableId: res.stableId, seq };
+    } catch (err) {
+      ctx.bus.emit('activity:unsuppress', rel);
+      return {
+        ok: false,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'reorder failed',
+      };
+    }
+  }
+
+  async function compClips(input: { canvas?: unknown; artboardId?: unknown }) {
+    const r = resolveCanvasAbs(input.canvas);
+    if (!r.ok) return r;
+    const artboardId = typeof input.artboardId === 'string' ? input.artboardId : undefined;
+    try {
+      const source = await Bun.file(r.abs).text();
+      const result = enumerateClips(r.abs, source, artboardId);
+      // Strip the internal source offsets — the client addresses by stableId.
+      const clips = result.clips.map(({ start: _s, end: _e, ...c }) => c);
+      return {
+        ok: true as const,
+        compName: result.compName,
+        artboardId: result.artboardId,
+        fps: result.fps,
+        durationInFrames: result.durationInFrames,
+        clips,
+        // DDR-150 dogfood #5 — loose media beds (audio/bg video) for replace.
+        media: result.media,
+      };
+    } catch (err) {
+      return {
+        ok: false as const,
+        status: err instanceof CanvasEditError ? 422 : 500,
+        error: err instanceof Error ? err.message : 'enumerate failed',
+      };
+    }
+  }
+
   async function reorderRevert(input: {
     canvas?: unknown;
     seq?: unknown;
@@ -2009,10 +2748,12 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     loadCanvasState,
     saveCanvasState,
     loadCanvasMeta,
+    loadCanvasSource,
     patchCanvasMeta,
     loadAnnotations,
     saveAnnotations,
     saveAsset,
+    saveAssetFromStream,
     saveChatAttachment,
     resolveChatAttachment,
     createCanvas,
@@ -2020,7 +2761,14 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     editCss,
     editText,
     editAttr,
+    removeSequenceOp,
+    insertSequenceOp,
+    reorderSequenceOp,
+    editArraySrcOp,
+    toggleHideOp,
+    compClips,
     reorder,
+    retimeSequenceOp,
     reorderRevert,
     buildIndexData,
     buildSystemData,