@hyperframes/studio-server 0.7.61 → 0.7.63

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   splitElementInHtml,
   unwrapElementsFromHtml,
   wrapElementsInHtml
-} from "./chunk-XVQX2JHE.js";
+} from "./chunk-VPA335OG.js";
 import {
   getElementScreenshotClip
 } from "./chunk-W2SBTCO2.js";
@@ -19,12 +19,12 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-ZUW4PULZ.js";
+} from "./chunk-OK7FKBKI.js";
 import {
   ProxyCapacityError,
   ProxyTranscodeError,
   resolveProxy
-} from "./chunk-YBR7MXIO.js";
+} from "./chunk-IVOJZ24X.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,
@@ -32,7 +32,7 @@ import {
   probeAssetCodec,
   probeMediaMetadata,
   resolveProxyVariantRequest
-} from "./chunk-LVXVG4V6.js";
+} from "./chunk-7Q5AFHU6.js";
 import {
   STUDIO_MANUAL_EDITS_PATH,
   createStudioManualEditsRenderBodyScript,
@@ -334,10 +334,10 @@ function registerStoryboardRoutes(api, adapter) {
 import { bodyLimit } from "hono/body-limit";
 import {
   closeSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   ftruncateSync,
   openSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync4,
   writeSync,
   mkdirSync as mkdirSync3,
@@ -347,7 +347,7 @@ import {
   renameSync,
   readdirSync as readdirSync4
 } from "fs";
-import { resolve as resolve2, dirname, join as join6 } from "path";
+import { resolve as resolve3, dirname as dirname2, join as join6 } from "path";
 
 // src/helpers/mime.ts
 var MIME_TYPES = {
@@ -654,7 +654,196 @@ import {
   scalePositionsInScript,
   dedupePositionWritesInScript
 } from "@hyperframes/parsers/gsap-writer-acorn";
+import { parseHTML as parseHTML2 } from "linkedom";
+
+// src/helpers/compositionInsertion.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname, relative as relative3, resolve as resolve2, sep } from "path";
 import { parseHTML } from "linkedom";
+var CompositionInsertionError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function descendants(root, selector) {
+  const found = Array.from(root.querySelectorAll(selector));
+  for (const template of root.querySelectorAll("template")) {
+    found.push(...descendants(template, selector));
+  }
+  return [...new Set(found)];
+}
+function compositionRoot(source) {
+  const document = parseHTML(source).document;
+  const root = descendants(document, "[data-composition-id]")[0];
+  if (!root) throw new CompositionInsertionError("Composition source has no root", 400);
+  return { document, root };
+}
+function positiveAttribute(root, ...names) {
+  for (const name of names) {
+    const value = Number.parseFloat(root.getAttribute(name) ?? "");
+    if (Number.isFinite(value) && value > 0) return value;
+  }
+  throw new CompositionInsertionError(`Composition source has no valid ${names[0]}`, 400);
+}
+function canonicalProjectPath(projectDir, candidate) {
+  if (!candidate) {
+    throw new CompositionInsertionError("Composition source escapes the project", 400);
+  }
+  if (!existsSync3(candidate)) {
+    throw new CompositionInsertionError("Composition source was not found", 404);
+  }
+  const canonical = realpathSync(candidate);
+  if (!isSafePath(realpathSync(projectDir), canonical)) {
+    throw new CompositionInsertionError("Composition source escapes the project", 400);
+  }
+  return canonical;
+}
+function validateSourcePath(sourcePath) {
+  if (!sourcePath.trim() || sourcePath.includes("\0") || /^[a-z]+:/i.test(sourcePath)) {
+    throw new CompositionInsertionError("Invalid composition source path", 400);
+  }
+}
+function canonicalProjectFile(projectDir, sourcePath) {
+  validateSourcePath(sourcePath);
+  return canonicalProjectPath(projectDir, resolveWithinProject(projectDir, sourcePath));
+}
+function canonicalDependency(projectDir, ownerAbs, sourcePath) {
+  validateSourcePath(sourcePath);
+  return canonicalProjectPath(
+    projectDir,
+    resolveWithinProject(projectDir, relative3(projectDir, resolve2(dirname(ownerAbs), sourcePath)))
+  );
+}
+function validateDependencyGraph(projectDir, targetAbs, sourceAbs) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (file) => {
+    if (file === targetAbs) {
+      throw new CompositionInsertionError("Composition insertion would create a cycle", 400);
+    }
+    if (visiting.has(file)) {
+      throw new CompositionInsertionError("Composition dependency cycle detected", 400);
+    }
+    if (visited.has(file)) return;
+    visiting.add(file);
+    const source = readFileSync4(file, "utf-8");
+    const { document } = compositionRoot(source);
+    for (const host of descendants(document, "[data-composition-src]")) {
+      const dependency = host.getAttribute("data-composition-src");
+      if (dependency) {
+        visit(canonicalDependency(projectDir, file, dependency));
+      }
+    }
+    visiting.delete(file);
+    visited.add(file);
+  };
+  visit(sourceAbs);
+}
+function numberAttribute(element, name, fallback = 0) {
+  const value = Number.parseFloat(element.getAttribute(name) ?? "");
+  return Number.isFinite(value) ? value : fallback;
+}
+function rangesOverlap(start, duration, other) {
+  const otherStart = numberAttribute(other, "data-start");
+  const otherDuration = numberAttribute(other, "data-duration");
+  return start < otherStart + otherDuration && otherStart < start + duration;
+}
+function resolveTrack(root, desiredTrack, start, duration) {
+  const clips = descendants(root, "[data-start][data-duration]").filter(
+    (element) => element !== root && element.parentElement?.closest("[data-composition-id]") === root
+  );
+  const tracks = [...new Set(clips.map((clip) => numberAttribute(clip, "data-track-index")))].sort(
+    (a, b) => a - b
+  );
+  const isFree = (track) => !clips.some(
+    (clip) => numberAttribute(clip, "data-track-index") === track && rangesOverlap(start, duration, clip)
+  );
+  if (isFree(desiredTrack)) return desiredTrack;
+  const row = tracks.indexOf(desiredTrack);
+  for (let index = row - 1; index >= 0; index--) {
+    const track = tracks[index];
+    if (track !== void 0 && isFree(track)) return track;
+  }
+  for (let index = Math.max(0, row + 1); index < tracks.length; index++) {
+    const track = tracks[index];
+    if (track !== void 0 && isFree(track)) return track;
+  }
+  return Math.max(desiredTrack, ...tracks, -1) + 1;
+}
+function uniqueHostId(root, base) {
+  const ids = /* @__PURE__ */ new Set([
+    ...descendants(root, "[id]").map((element) => element.id),
+    ...descendants(root, "[data-composition-id]").flatMap((element) => {
+      const id = element.getAttribute("data-composition-id");
+      return id ? [id] : [];
+    })
+  ]);
+  if (!ids.has(base)) return base;
+  let suffix = 2;
+  while (ids.has(`${base}_${suffix}`)) suffix += 1;
+  return `${base}_${suffix}`;
+}
+function relativeSourcePath(targetAbs, sourceAbs) {
+  return relative3(dirname(targetAbs), sourceAbs).split(sep).join("/");
+}
+function insertCompositionIntoSource(input) {
+  const targetAbs = canonicalProjectFile(input.projectDir, input.targetPath);
+  const sourceAbs = canonicalProjectFile(input.projectDir, input.sourcePath);
+  validateDependencyGraph(input.projectDir, targetAbs, sourceAbs);
+  const source = readFileSync4(sourceAbs, "utf-8");
+  const sourceComposition = compositionRoot(source).root;
+  const duration = positiveAttribute(
+    sourceComposition,
+    "data-composition-duration",
+    "data-duration"
+  );
+  const width = positiveAttribute(sourceComposition, "data-width");
+  const height = positiveAttribute(sourceComposition, "data-height");
+  const { document, root } = compositionRoot(input.parentSource);
+  const parentDuration = positiveAttribute(root, "data-duration", "data-composition-duration");
+  const base = (sourceComposition.getAttribute("data-composition-id") ?? "composition").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "composition";
+  const hostId = uniqueHostId(root, base);
+  const track = resolveTrack(
+    root,
+    Math.max(0, Math.round(input.desiredTrack)),
+    input.start,
+    duration
+  );
+  const zIndex = Math.max(
+    0,
+    ...descendants(root, "[style]").map((element) => {
+      const match = /(?:^|;)\s*z-index\s*:\s*(-?\d+)/i.exec(element.getAttribute("style") ?? "");
+      return match?.[1] ? Number.parseInt(match[1], 10) : 0;
+    })
+  ) + 1;
+  const host = document.createElement("div");
+  host.id = hostId;
+  host.className = "clip";
+  host.setAttribute("data-hf-id", `hf-${randomUUID2()}`);
+  host.setAttribute("data-composition-id", hostId);
+  host.setAttribute("data-composition-src", relativeSourcePath(targetAbs, sourceAbs));
+  host.setAttribute("data-start", String(Math.round(input.start * 100) / 100));
+  host.setAttribute("data-duration", String(duration));
+  host.setAttribute("data-playback-start", "0");
+  host.setAttribute("data-track-index", String(track));
+  host.setAttribute("data-width", String(width));
+  host.setAttribute("data-height", String(height));
+  host.setAttribute(
+    "style",
+    `position: absolute; left: 0px; top: 0px; width: ${width}px; height: ${height}px; z-index: ${zIndex}`
+  );
+  root.appendChild(host);
+  if (input.start + duration > parentDuration) {
+    const name = root.hasAttribute("data-duration") ? "data-duration" : "data-composition-duration";
+    root.setAttribute(name, String(Math.round((input.start + duration) * 100) / 100));
+  }
+  return { html: document.toString(), hostId, track, duration };
+}
+
+// src/routes/files.ts
 function isAcornGsapWriterEnabled() {
   const val = process.env["STUDIO_SDK_CUTOVER_ENABLED"];
   return val === "true" || val === "1";
@@ -676,7 +865,7 @@ async function resolveProjectPath(c, adapter, pathPrefix, opts) {
   if (!absPath) {
     return { error: c.json({ error: "forbidden" }, 403) };
   }
-  if (opts?.mustExist && !existsSync3(absPath)) {
+  if (opts?.mustExist && !existsSync4(absPath)) {
     return { error: c.json({ error: "not found" }, 404) };
   }
   return { project, filePath, absPath };
@@ -687,6 +876,25 @@ function resolveProjectFile(c, adapter, opts) {
 function resolveFileMutationContext(c, adapter, operation) {
   return resolveProjectPath(c, adapter, (id) => `/projects/${id}/file-mutations/${operation}/`);
 }
+function isAtomicCutTarget(value) {
+  if (!value || typeof value !== "object") return false;
+  const target = value;
+  return !!target.target && typeof target.target === "object" && Number.isFinite(target.splitTime) && Number.isFinite(target.elementStart) && Number.isFinite(target.elementDuration) && Number(target.elementDuration) > 0;
+}
+function isAtomicCutFileRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const file = value;
+  return typeof file.path === "string" && file.path.length > 0 && typeof file.expectedVersion === "string" && Array.isArray(file.targets) && file.targets.length > 0 && file.targets.every(isAtomicCutTarget);
+}
+var atomicCutTail = Promise.resolve();
+function serializeAtomicCut(task) {
+  const next = atomicCutTail.then(task, task);
+  atomicCutTail = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
 function isElementPatchRequest(value) {
   if (typeof value !== "object" || value === null) return false;
   if (!("target" in value) || typeof value.target !== "object" || value.target === null) {
@@ -722,7 +930,7 @@ function commitElementPatchBatches(projectDir, batches, writeFile = writeFileSyn
     resolvedPaths.add(absPath);
     let before;
     try {
-      before = readFileSync4(absPath, "utf-8");
+      before = readFileSync5(absPath, "utf-8");
     } catch {
       return { error: "not-found", sourceFile: batch.sourceFile };
     }
@@ -834,8 +1042,8 @@ async function parseMutationBody(c) {
   return { target: body.target, body };
 }
 function ensureDir(filePath) {
-  const dir = dirname(filePath);
-  if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = dirname2(filePath);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
 }
 function generateCopyPath(projectDir, originalPath) {
   const ext = originalPath.includes(".") ? "." + originalPath.split(".").pop() : "";
@@ -844,7 +1052,7 @@ function generateCopyPath(projectDir, originalPath) {
   const cleanBase = copyMatch ? base.slice(0, -copyMatch[0].length) : base;
   let num = copyMatch ? copyMatch[1] ? parseInt(copyMatch[1]) + 1 : 2 : 1;
   let candidate = num === 1 ? `${cleanBase} (copy)${ext}` : `${cleanBase} (copy ${num})${ext}`;
-  while (existsSync3(resolve2(projectDir, candidate))) {
+  while (existsSync4(resolve3(projectDir, candidate))) {
     num++;
     candidate = `${cleanBase} (copy ${num})${ext}`;
   }
@@ -871,7 +1079,7 @@ function updateReferences(projectDir, oldPath, newPath) {
   );
   let updatedCount = 0;
   for (const file of textFiles) {
-    const content = readFileSync4(file, "utf-8");
+    const content = readFileSync5(file, "utf-8");
     if (!content.includes(oldPath)) continue;
     const updated = content.split(oldPath).join(newPath);
     if (updated !== content) {
@@ -882,7 +1090,7 @@ function updateReferences(projectDir, oldPath, newPath) {
   return updatedCount;
 }
 function extractGsapScriptBlock(html) {
-  const { document } = parseHTML(html);
+  const { document } = parseHTML2(html);
   const scripts = [
     ...document.querySelectorAll("script:not([src])"),
     ...Array.from(document.querySelectorAll("template")).flatMap(
@@ -1128,7 +1336,7 @@ function validateGsapMutationRequest(c, body) {
   return null;
 }
 async function prepareGsapMutationScript(c, res, firstMutation) {
-  const beforeHtml = readFileSync4(res.absPath, "utf-8");
+  const beforeHtml = readFileSync5(res.absPath, "utf-8");
   let html = beforeHtml;
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
@@ -1188,7 +1396,7 @@ async function applyGsapMutations(c, res, mutations) {
   const changed = block.scriptText !== initialScript;
   const newHtml = changed ? block.replaceScript(block.scriptText) : html;
   let backupPath = null;
-  if (readFileSync4(res.absPath, "utf-8") !== beforeHtml) {
+  if (readFileSync5(res.absPath, "utf-8") !== beforeHtml) {
     return c.json({ error: "file changed during GSAP mutation", conflict: true }, 409);
   }
   if (changed) {
@@ -1811,6 +2019,74 @@ async function executeGsapMutationRecast(body, block, respond) {
       return respond({ error: `unknown mutation type: ${body.type}` }, 400);
   }
 }
+async function foldAtomicCutFile(c, file, absPath, before) {
+  let after = before;
+  let splitCount = 0;
+  const skippedSelectors = /* @__PURE__ */ new Set();
+  const respond = (data, status) => status ? c.json(data, status) : c.json(data);
+  const orderedTargets = file.targets.map((cut, index) => ({ cut, index })).sort((left, right) => {
+    const locatorKey = (entry) => !entry.target.id && !entry.target.hfId && entry.target.selector ? entry.target.selector : null;
+    const leftKey = locatorKey(left.cut);
+    const rightKey = locatorKey(right.cut);
+    if (leftKey && rightKey) {
+      return leftKey.localeCompare(rightKey) || (right.cut.target.selectorIndex ?? 0) - (left.cut.target.selectorIndex ?? 0);
+    }
+    if (leftKey) return -1;
+    if (rightKey) return 1;
+    return left.index - right.index;
+  }).map(({ cut }) => cut);
+  for (const cut of orderedTargets) {
+    const baseId = cut.originalId || cut.target.id || "clip";
+    const split = splitElementInHtml(after, cut.target, cut.splitTime, `${baseId}-split`, {
+      start: cut.elementStart,
+      duration: cut.elementDuration,
+      playbackStart: cut.playbackStart,
+      playbackRate: cut.playbackRate,
+      stampPlaybackStart: cut.isComposition
+    });
+    if (!split.matched || !split.newId) {
+      return c.json(
+        { error: `Cut target was not found or was outside its authored bounds in ${file.path}` },
+        400
+      );
+    }
+    after = split.html;
+    splitCount++;
+    if (!cut.originalId) continue;
+    const block = extractGsapScriptBlock(after);
+    if (!block) continue;
+    const result = await executeGsapMutation(
+      {
+        type: "split-animations",
+        originalId: cut.originalId,
+        newId: split.newId,
+        splitTime: cut.splitTime,
+        elementStart: cut.elementStart,
+        elementDuration: cut.elementDuration
+      },
+      block,
+      respond
+    );
+    if (result instanceof Response) return result;
+    let script = typeof result === "string" ? result : result.script;
+    if (typeof result !== "string") {
+      for (const selector of result.skippedSelectors) skippedSelectors.add(selector);
+    }
+    if (script !== block.scriptText) {
+      const parser = await loadGsapParser();
+      script = parser.syncPositionHoldsBeforeKeyframes(script);
+      after = block.replaceScript(script);
+    }
+  }
+  return {
+    path: file.path,
+    absPath,
+    before,
+    after,
+    splitCount,
+    skippedSelectors: [...skippedSelectors]
+  };
+}
 async function processUploadedFiles(formData, targetDir, projectDir) {
   const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
   const uploaded = [];
@@ -1826,23 +2102,23 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
       skipped.push(name);
       continue;
     }
-    const destPath = resolve2(targetDir, name);
+    const destPath = resolve3(targetDir, name);
     if (!isSafePath(projectDir, destPath)) continue;
     let finalPath = destPath;
     let finalName = name;
-    if (existsSync3(finalPath)) {
+    if (existsSync4(finalPath)) {
       const dotIdx = name.indexOf(".", name.startsWith(".") ? 1 : 0);
       const ext = dotIdx > 0 ? name.slice(dotIdx) : "";
       const base = dotIdx > 0 ? name.slice(0, dotIdx) : name;
       let n = 2;
       const MAX_COPY_INDEX = 1e4;
-      while (n < MAX_COPY_INDEX && existsSync3(resolve2(targetDir, `${base} (${n})${ext}`))) n++;
+      while (n < MAX_COPY_INDEX && existsSync4(resolve3(targetDir, `${base} (${n})${ext}`))) n++;
       if (n >= MAX_COPY_INDEX) {
         skipped.push(name);
         continue;
       }
       finalName = `${base} (${n})${ext}`;
-      finalPath = resolve2(targetDir, finalName);
+      finalPath = resolve3(targetDir, finalName);
     }
     const buffer = Buffer.from(await value.arrayBuffer());
     const validation = validateUploadedMediaBuffer(finalName, buffer);
@@ -1864,13 +2140,13 @@ function registerFileRoutes(api, adapter) {
   api.get("/projects/:id/files/*", async (c) => {
     const res = await resolveProjectFile(c, adapter);
     if ("error" in res) return res.error;
-    if (!existsSync3(res.absPath)) {
+    if (!existsSync4(res.absPath)) {
       if (c.req.query("optional") === "1") {
         return c.json({ filename: res.filePath, content: "" });
       }
       return c.json({ error: "not found" }, 404);
     }
-    const content = readFileSync4(res.absPath, "utf-8");
+    const content = readFileSync5(res.absPath, "utf-8");
     const version = fileContentVersion(content);
     c.header("ETag", version);
     return c.json({ filename: res.filePath, content, version });
@@ -1884,7 +2160,7 @@ function registerFileRoutes(api, adapter) {
     if (expectedVersion === null && !createOnly) {
       let currentContent = null;
       try {
-        currentContent = readFileSync4(res.absPath, "utf-8");
+        currentContent = readFileSync5(res.absPath, "utf-8");
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
           throw error;
@@ -1910,7 +2186,7 @@ function registerFileRoutes(api, adapter) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
           throw error;
         }
-        const currentContent = readFileSync4(res.absPath, "utf-8");
+        const currentContent = readFileSync5(res.absPath, "utf-8");
         return c.json(
           {
             error: "file conflict",
@@ -1945,7 +2221,7 @@ function registerFileRoutes(api, adapter) {
         );
       }
       try {
-        const currentContent = readFileSync4(fd, "utf-8");
+        const currentContent = readFileSync5(fd, "utf-8");
         const currentVersion = fileContentVersion(currentContent);
         if (expectedVersion !== currentVersion) {
           return c.json(
@@ -1982,7 +2258,7 @@ function registerFileRoutes(api, adapter) {
   api.post("/projects/:id/files/*", async (c) => {
     const res = await resolveProjectFile(c, adapter);
     if ("error" in res) return res.error;
-    if (existsSync3(res.absPath)) {
+    if (existsSync4(res.absPath)) {
       return c.json({ error: "already exists" }, 409);
     }
     ensureDir(res.absPath);
@@ -2006,15 +2282,71 @@ function registerFileRoutes(api, adapter) {
       backupPath: backupPathForResponse(res.project.dir, backup.backupPath)
     });
   });
+  api.post("/projects/:id/file-mutations/insert-composition/*", async (c) => {
+    const ctx = await resolveFileMutationContext(c, adapter, "insert-composition");
+    if ("error" in ctx) return ctx.error;
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.sourcePath !== "string" || typeof body.start !== "number" || !Number.isFinite(body.start) || body.start < 0 || typeof body.track !== "number" || !Number.isFinite(body.track) || typeof body.expectedVersion !== "string") {
+      return c.json({ error: "sourcePath, finite placement, and expectedVersion required" }, 400);
+    }
+    let before;
+    try {
+      before = readFileSync5(ctx.absPath, "utf-8");
+    } catch (error) {
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+        throw error;
+      }
+      return c.json({ error: "not found" }, 404);
+    }
+    const currentVersion = fileContentVersion(before);
+    if (body.expectedVersion !== currentVersion) {
+      return c.json({ error: "file conflict", currentVersion, currentContent: before }, 409);
+    }
+    let insertion;
+    try {
+      insertion = insertCompositionIntoSource({
+        projectDir: ctx.project.dir,
+        targetPath: ctx.filePath,
+        sourcePath: body.sourcePath,
+        parentSource: before,
+        start: body.start,
+        desiredTrack: body.track
+      });
+    } catch (error) {
+      if (error instanceof CompositionInsertionError) {
+        return c.json({ error: error.message }, error.status);
+      }
+      throw error;
+    }
+    const backup = snapshotBeforeWrite(ctx.project.dir, ctx.absPath);
+    if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
+    writeFileSync4(ctx.absPath, insertion.html, "utf-8");
+    const version = fileContentVersion(insertion.html);
+    const writeToken = createWriteToken(c.req.header("X-Hyperframes-Write-Token"));
+    recordFileWriteReceipt(ctx.absPath, { path: ctx.filePath, version, writeToken });
+    c.header("ETag", version);
+    return c.json({
+      ok: true,
+      path: ctx.filePath,
+      hostId: insertion.hostId,
+      track: insertion.track,
+      duration: insertion.duration,
+      before,
+      after: insertion.html,
+      version,
+      writeToken,
+      backupPath: backupPathForResponse(ctx.project.dir, backup.backupPath)
+    });
+  });
   api.post("/projects/:id/file-mutations/remove-element/*", async (c) => {
     const ctx = await resolveFileMutationContext(c, adapter, "remove-element");
     if ("error" in ctx) return ctx.error;
-    if (!existsSync3(ctx.absPath)) {
+    if (!existsSync4(ctx.absPath)) {
       return c.json({ error: "not found" }, 404);
     }
     const parsed = await parseMutationBody(c);
     if ("error" in parsed) return parsed.error;
-    const originalContent = readFileSync4(ctx.absPath, "utf-8");
+    const originalContent = readFileSync5(ctx.absPath, "utf-8");
     return writeIfChanged(
       c,
       ctx.project.dir,
@@ -2024,6 +2356,130 @@ function registerFileRoutes(api, adapter) {
       removeElementFromHtml(originalContent, parsed.target)
     );
   });
+  api.post("/projects/:id/file-mutations/split-batch", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!Array.isArray(body?.files) || body.files.length === 0 || !body.files.every(isAtomicCutFileRequest)) {
+      return c.json({ error: "files with path, expectedVersion, and cut targets required" }, 400);
+    }
+    const files = body.files;
+    const project = await adapter.resolveProject(c.req.param("id"));
+    if (!project) return c.json({ error: "not found" }, 404);
+    return serializeAtomicCut(async () => {
+      const seen = /* @__PURE__ */ new Set();
+      const prepared = [];
+      for (const file of files) {
+        const absPath = resolveWithinProject(project.dir, file.path);
+        if (!absPath) return c.json({ error: `forbidden path: ${file.path}` }, 403);
+        if (seen.has(absPath)) return c.json({ error: `duplicate path: ${file.path}` }, 400);
+        seen.add(absPath);
+        let before;
+        try {
+          before = readFileSync5(absPath, "utf-8");
+        } catch {
+          return c.json({ error: `not found: ${file.path}` }, 404);
+        }
+        const currentVersion = fileContentVersion(before);
+        if (currentVersion !== file.expectedVersion) {
+          return c.json(
+            {
+              error: `file conflict: ${file.path}`,
+              path: file.path,
+              currentVersion,
+              currentContent: before
+            },
+            409
+          );
+        }
+        let folded;
+        try {
+          folded = await foldAtomicCutFile(c, file, absPath, before);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Cut transform failed";
+          return c.json({ error: message }, 400);
+        }
+        if (folded instanceof Response) return folded;
+        prepared.push(folded);
+      }
+      for (const file of prepared) {
+        const current = readFileSync5(file.absPath, "utf-8");
+        if (current !== file.before) {
+          return c.json(
+            {
+              error: `file conflict: ${file.path}`,
+              path: file.path,
+              currentVersion: fileContentVersion(current),
+              currentContent: current
+            },
+            409
+          );
+        }
+      }
+      const backups = /* @__PURE__ */ new Map();
+      for (const file of prepared) {
+        const backup = snapshotBeforeWrite(project.dir, file.absPath);
+        if (backup.error) {
+          return c.json(
+            { error: `Failed to create backup for ${file.path}: ${backup.error}` },
+            500
+          );
+        }
+        backups.set(file.path, backupPathForResponse(project.dir, backup.backupPath));
+      }
+      const writeToken = createWriteToken(
+        typeof body.transactionToken === "string" ? body.transactionToken : c.req.header("X-Hyperframes-Write-Token")
+      );
+      const written = [];
+      try {
+        for (const file of prepared) {
+          writeFileSync4(file.absPath, file.after, "utf-8");
+          written.push(file);
+          recordFileWriteReceipt(file.absPath, {
+            path: file.path,
+            version: fileContentVersion(file.after),
+            writeToken
+          });
+        }
+      } catch (error) {
+        const conflicts = [];
+        for (const file of written.reverse()) {
+          try {
+            const current = readFileSync5(file.absPath, "utf-8");
+            if (current !== file.after) {
+              conflicts.push(file.path);
+              continue;
+            }
+            writeFileSync4(file.absPath, file.before, "utf-8");
+            recordFileWriteReceipt(file.absPath, {
+              path: file.path,
+              version: fileContentVersion(file.before),
+              writeToken
+            });
+          } catch {
+            conflicts.push(file.path);
+          }
+        }
+        return c.json(
+          {
+            error: error instanceof Error ? error.message : "Cut write failed",
+            outcome: conflicts.length ? "aborted-with-conflicts" : "aborted-restored",
+            conflicts
+          },
+          conflicts.length ? 409 : 500
+        );
+      }
+      const result = prepared.map((file) => ({
+        path: file.path,
+        before: file.before,
+        after: file.after,
+        version: fileContentVersion(file.after),
+        writeToken,
+        backupPath: backups.get(file.path) ?? null,
+        splitCount: file.splitCount,
+        skippedSelectors: file.skippedSelectors
+      }));
+      return c.json({ ok: true, outcome: "committed", files: result });
+    });
+  });
   api.post("/projects/:id/file-mutations/split-element/*", async (c) => {
     const ctx = await resolveFileMutationContext(c, adapter, "split-element");
     if ("error" in ctx) return ctx.error;
@@ -2035,7 +2491,7 @@ function registerFileRoutes(api, adapter) {
     const fallbackTiming = typeof parsed.body.elementStart === "number" && typeof parsed.body.elementDuration === "number" ? { start: parsed.body.elementStart, duration: parsed.body.elementDuration } : void 0;
     let originalContent;
     try {
-      originalContent = readFileSync4(ctx.absPath, "utf-8");
+      originalContent = readFileSync5(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -2086,7 +2542,7 @@ function registerFileRoutes(api, adapter) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync4(ctx.absPath, "utf-8");
+      originalContent = readFileSync5(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -2176,7 +2632,7 @@ function registerFileRoutes(api, adapter) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync4(ctx.absPath, "utf-8");
+      originalContent = readFileSync5(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -2218,7 +2674,7 @@ function registerFileRoutes(api, adapter) {
     if ("error" in parsed) return parsed.error;
     let originalContent;
     try {
-      originalContent = readFileSync4(ctx.absPath, "utf-8");
+      originalContent = readFileSync5(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -2247,7 +2703,7 @@ function registerFileRoutes(api, adapter) {
     if ("error" in parsed) return parsed.error;
     let content;
     try {
-      content = readFileSync4(ctx.absPath, "utf-8");
+      content = readFileSync5(ctx.absPath, "utf-8");
     } catch {
       return c.json({ exists: false });
     }
@@ -2265,7 +2721,7 @@ function registerFileRoutes(api, adapter) {
     if (!newAbs) {
       return c.json({ error: "forbidden" }, 403);
     }
-    if (existsSync3(newAbs)) {
+    if (existsSync4(newAbs)) {
       return c.json({ error: "already exists" }, 409);
     }
     ensureDir(newAbs);
@@ -2281,7 +2737,7 @@ function registerFileRoutes(api, adapter) {
       return c.json({ error: "path required" }, 400);
     }
     const srcAbs = resolveWithinProject(project.dir, body.path);
-    if (!srcAbs || !existsSync3(srcAbs)) {
+    if (!srcAbs || !existsSync4(srcAbs)) {
       return c.json({ error: "not found" }, 404);
     }
     const copyPath = generateCopyPath(project.dir, body.path);
@@ -2290,7 +2746,7 @@ function registerFileRoutes(api, adapter) {
       return c.json({ error: "forbidden" }, 403);
     }
     ensureDir(destAbs);
-    writeFileSync4(destAbs, readFileSync4(srcAbs));
+    writeFileSync4(destAbs, readFileSync5(srcAbs));
     return c.json({ ok: true, path: copyPath }, 201);
   });
   const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
@@ -2306,7 +2762,7 @@ function registerFileRoutes(api, adapter) {
       const subDir = c.req.query("dir") ?? "";
       const targetDir = subDir ? resolveWithinProject(project.dir, subDir) : project.dir;
       if (!targetDir) return c.json({ error: "forbidden" }, 403);
-      if (subDir && !existsSync3(targetDir)) mkdirSync3(targetDir, { recursive: true });
+      if (subDir && !existsSync4(targetDir)) mkdirSync3(targetDir, { recursive: true });
       const formData = await c.req.formData();
       const result = await processUploadedFiles(formData, targetDir, project.dir);
       return c.json(
@@ -2320,7 +2776,7 @@ function registerFileRoutes(api, adapter) {
       mustExist: true
     });
     if ("error" in res) return res.error;
-    const html = readFileSync4(res.absPath, "utf-8");
+    const html = readFileSync5(res.absPath, "utf-8");
     const block = extractGsapScriptBlock(html);
     if (!block) {
       return c.json({
@@ -2379,7 +2835,7 @@ function registerFileRoutes(api, adapter) {
     if (!body || typeof body.expected !== "string" || typeof body.restore !== "string") {
       return c.json({ error: "expected and restore contents required" }, 400);
     }
-    const current = readFileSync4(res.absPath, "utf-8");
+    const current = readFileSync5(res.absPath, "utf-8");
     if (current !== body.expected) {
       return c.json({ ok: true, restored: false, conflict: true });
     }
@@ -2389,15 +2845,15 @@ function registerFileRoutes(api, adapter) {
 }
 
 // src/routes/preview.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
 import { join as join8 } from "path";
 import { createHash as createHash3 } from "crypto";
 import { injectScriptsIntoHtml, stripEmbeddedRuntimeScripts as stripEmbeddedRuntimeScripts2 } from "@hyperframes/core/compiler";
 
 // src/helpers/subComposition.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
-import { parseHTML as parseHTML2 } from "linkedom";
+import { parseHTML as parseHTML3 } from "linkedom";
 import {
   rewriteAssetPaths,
   rewriteCssAssetUrls,
@@ -2445,7 +2901,7 @@ function fixDigitLeadingIdSelectors(root) {
   }
 }
 function extractFullDocumentParts(rawHtml, compPath) {
-  const { document: doc } = parseHTML2(rawHtml);
+  const { document: doc } = parseHTML3(rawHtml);
   const rewriteTargets = [doc.head, doc.body].filter(Boolean);
   for (const target of rewriteTargets) {
     rewriteRelativePaths(target, compPath);
@@ -2459,7 +2915,7 @@ function extractFullDocumentParts(rawHtml, compPath) {
   return { headContent, bodyContent, htmlAttrs, bodyAttrs };
 }
 function extractTemplateInnerHtml(rawComp) {
-  const { document: doc } = parseHTML2(rawComp);
+  const { document: doc } = parseHTML3(rawComp);
   const template = doc.querySelector("template");
   return template ? template.innerHTML : null;
 }
@@ -2503,15 +2959,15 @@ function tagRootCompositionFile(bodyHtml, compPath) {
 }
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
   const compFile = join7(projectDir, compPath);
-  if (!existsSync4(compFile)) return null;
-  const rawComp = rawOverride ?? readFileSync5(compFile, "utf-8");
+  if (!existsSync5(compFile)) return null;
+  const rawComp = rawOverride ?? readFileSync6(compFile, "utf-8");
   let compHeadContent = "";
   let rewrittenContent;
   let htmlAttrs = "";
   let bodyAttrs = "";
   const templateInner = extractTemplateInnerHtml(rawComp);
   if (templateInner != null) {
-    const { document: contentDoc } = parseHTML2(
+    const { document: contentDoc } = parseHTML3(
       `<!DOCTYPE html><html><head></head><body>${templateInner}</body></html>`
     );
     rewriteRelativePaths(contentDoc, compPath);
@@ -2525,7 +2981,7 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, raw
     htmlAttrs = parts.htmlAttrs;
     bodyAttrs = parts.bodyAttrs;
   } else {
-    const { document: contentDoc } = parseHTML2(
+    const { document: contentDoc } = parseHTML3(
       `<!DOCTYPE html><html><head></head><body>${rawComp}</body></html>`
     );
     rewriteRelativePaths(contentDoc, compPath);
@@ -2536,8 +2992,8 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, raw
   rewrittenContent = tagRootCompositionFile(rewrittenContent, compPath);
   const indexPath = join7(projectDir, "index.html");
   let headContent = "";
-  if (existsSync4(indexPath)) {
-    const indexHtml = readFileSync5(indexPath, "utf-8");
+  if (existsSync5(indexPath)) {
+    const indexHtml = readFileSync6(indexPath, "utf-8");
     const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     headContent = headMatch?.[1] ?? "";
   }
@@ -2581,7 +3037,7 @@ import {
   fstatSync,
   ftruncateSync as ftruncateSync2,
   openSync as openSync2,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync5,
   writeSync as writeSync2
 } from "fs";
@@ -2591,7 +3047,7 @@ function persistHfIdsIfNeeded(filePath, html) {
   const idsAfter = (normalized.match(/\bdata-hf-id=/g) ?? []).length;
   if (idsAfter > idsBefore) {
     try {
-      const current = readFileSync6(filePath, "utf-8");
+      const current = readFileSync7(filePath, "utf-8");
       if (current === html) {
         writeFileSync5(filePath, normalized, "utf-8");
       }
@@ -2619,7 +3075,7 @@ function stampFileHfIds(filePath) {
   if (fd === null) return null;
   try {
     if (!fstatSync(fd).isFile()) return null;
-    const html = readFileSync6(fd, "utf-8");
+    const html = readFileSync7(fd, "utf-8");
     const normalized = ensureHfIds(html);
     const idsBefore = (html.match(/\bdata-hf-id=/g) ?? []).length;
     const idsAfter = (normalized.match(/\bdata-hf-id=/g) ?? []).length;
@@ -2663,9 +3119,9 @@ ${html}`;
 }
 function readStudioMotionManifestContent(projectDir) {
   const manifestPath = join8(projectDir, STUDIO_MOTION_PATH);
-  if (!existsSync5(manifestPath)) return "";
+  if (!existsSync6(manifestPath)) return "";
   try {
-    return readFileSync7(manifestPath, "utf-8");
+    return readFileSync8(manifestPath, "utf-8");
   } catch {
     return "";
   }
@@ -2821,16 +3277,16 @@ async function transformPreviewHtml(html, adapter, project, activeCompositionPat
 }
 function resolveProjectMainHtml(projectDir, projectId) {
   const indexPath = join8(projectDir, "index.html");
-  if (existsSync5(indexPath)) {
+  if (existsSync6(indexPath)) {
     return {
-      html: readFileSync7(indexPath, "utf-8"),
+      html: readFileSync8(indexPath, "utf-8"),
       compositionPath: "index.html"
     };
   }
   const blockHtmlPath = join8(projectDir, `${projectId}.html`);
-  if (existsSync5(blockHtmlPath)) {
+  if (existsSync6(blockHtmlPath)) {
     return {
-      html: readFileSync7(blockHtmlPath, "utf-8"),
+      html: readFileSync8(blockHtmlPath, "utf-8"),
       compositionPath: `${projectId}.html`
     };
   }
@@ -2935,7 +3391,7 @@ ${runtimeTag}`;
       c.req.path.replace(`/projects/${project.id}/preview/comp/`, "").split("?")[0] ?? ""
     );
     const compFile = resolveWithinProject(project.dir, compPath);
-    if (!compFile || !existsSync5(compFile) || !statSync2(compFile).isFile()) {
+    if (!compFile || !existsSync6(compFile) || !statSync2(compFile).isFile()) {
       return c.text("not found", 404);
     }
     const etag = `"comp:v2:${compPath}:${signature}${variablesEtagSalt(vars.raw)}"`;
@@ -2973,7 +3429,7 @@ ${runtimeTag}`;
     if (!file) {
       return c.text("not found", 404);
     }
-    const stat = existsSync5(file) ? statSync2(file) : null;
+    const stat = existsSync6(file) ? statSync2(file) : null;
     if (!stat?.isFile()) {
       return c.text("not found", 404);
     }
@@ -3021,7 +3477,7 @@ ${runtimeTag}`;
       }
       servedContentType = PROXY_VARIANT_CONFIG[proxyVariant].contentType;
     }
-    const buffer = isText ? Buffer.from(readFileSync7(file, "utf-8"), "utf-8") : readFileSync7(servedPath);
+    const buffer = isText ? Buffer.from(readFileSync8(file, "utf-8"), "utf-8") : readFileSync8(servedPath);
     const totalSize = buffer.length;
     const rangeHeader = c.req.header("Range");
     if (rangeHeader) {
@@ -3055,7 +3511,7 @@ ${runtimeTag}`;
 }
 
 // src/routes/lint.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { join as join9 } from "path";
 function registerLintRoutes(api, adapter) {
   api.get("/projects/:id/lint", async (c) => {
@@ -3067,7 +3523,7 @@ function registerLintRoutes(api, adapter) {
       );
       const allFindings = [];
       for (const file of htmlFiles) {
-        const content = readFileSync8(join9(project.dir, file), "utf-8");
+        const content = readFileSync9(join9(project.dir, file), "utf-8");
         const result = await adapter.lint(content, { filePath: file });
         if (result?.findings) {
           for (const f of result.findings) {
@@ -3085,7 +3541,7 @@ function registerLintRoutes(api, adapter) {
 
 // src/routes/render.ts
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync6, readFileSync as readFileSync9, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
 import { join as join10 } from "path";
 import { VALID_CANVAS_RESOLUTIONS } from "@hyperframes/parsers";
 import { formatRenderOutputTimestamp, parseFps } from "@hyperframes/core";
@@ -3144,7 +3600,7 @@ function registerRenderRoutes(api, adapter) {
     const now = /* @__PURE__ */ new Date();
     const jobId = `${project.id}_${formatRenderOutputTimestamp(now)}`;
     const rendersDir = adapter.rendersDir(project);
-    if (!existsSync6(rendersDir)) mkdirSync4(rendersDir, { recursive: true });
+    if (!existsSync7(rendersDir)) mkdirSync4(rendersDir, { recursive: true });
     const ext = FORMAT_EXT[format] ?? ".mp4";
     const outputPath = join10(rendersDir, `${jobId}${ext}`);
     const jobState = adapter.startRender({
@@ -3209,12 +3665,12 @@ function registerRenderRoutes(api, adapter) {
   api.get("/render/:jobId/view", (c) => {
     const { jobId } = c.req.param();
     const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync6(job.outputPath)) {
+    if (!job?.outputPath || !existsSync7(job.outputPath)) {
       return c.json({ error: "not found" }, 404);
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync9(job.outputPath);
+    const content = readFileSync10(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -3227,12 +3683,12 @@ function registerRenderRoutes(api, adapter) {
   api.get("/render/:jobId/download", (c) => {
     const { jobId } = c.req.param();
     const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync6(job.outputPath)) {
+    if (!job?.outputPath || !existsSync7(job.outputPath)) {
       return c.json({ error: "not found" }, 404);
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync9(job.outputPath);
+    const content = readFileSync10(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -3247,7 +3703,7 @@ function registerRenderRoutes(api, adapter) {
         const dir = state.outputPath.replace(/\/[^/]+$/, "");
         for (const ext of [".mp4", ".webm", ".mov", ".meta.json"]) {
           const fp = join10(dir, `${jobId}${ext}`);
-          if (existsSync6(fp)) unlinkSync3(fp);
+          if (existsSync7(fp)) unlinkSync3(fp);
         }
         break;
       }
@@ -3263,9 +3719,9 @@ function registerRenderRoutes(api, adapter) {
     const rendersDir = adapter.rendersDir(project);
     const fp = resolveWithinProject(rendersDir, filename);
     if (!fp) return c.json({ error: "forbidden" }, 403);
-    if (!existsSync6(fp)) return c.json({ error: "not found" }, 404);
+    if (!existsSync7(fp)) return c.json({ error: "not found" }, 404);
     const contentType = renderContentType(fp);
-    const content = readFileSync9(fp);
+    const content = readFileSync10(fp);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -3279,7 +3735,7 @@ function registerRenderRoutes(api, adapter) {
     const project = await adapter.resolveProject(c.req.param("id"));
     if (!project) return c.json({ error: "not found" }, 404);
     const rendersDir = adapter.rendersDir(project);
-    if (!existsSync6(rendersDir)) return c.json({ renders: [] });
+    if (!existsSync7(rendersDir)) return c.json({ renders: [] });
     const files = readdirSync5(rendersDir).filter((f) => f.endsWith(".mp4") || f.endsWith(".webm") || f.endsWith(".mov")).map((f) => {
       const fp = join10(rendersDir, f);
       const stat = statSync3(fp);
@@ -3287,10 +3743,10 @@ function registerRenderRoutes(api, adapter) {
       const metaPath = join10(rendersDir, `${rid}.meta.json`);
       let status = "complete";
       let durationMs;
-      if (existsSync6(metaPath)) {
+      if (existsSync7(metaPath)) {
         try {
-          const meta = JSON.parse(readFileSync9(metaPath, "utf-8"));
-          if (meta.status === "failed") status = "failed";
+          const meta = JSON.parse(readFileSync10(metaPath, "utf-8"));
+          if (meta.status === "failed" && !existsSync7(fp)) status = "failed";
           if (meta.durationMs) durationMs = meta.durationMs;
         } catch {
         }
@@ -3320,7 +3776,7 @@ function registerRenderRoutes(api, adapter) {
 }
 
 // src/routes/thumbnail.ts
-import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
 import { join as join11 } from "path";
 import { createHash as createHash4 } from "crypto";
 var THUMBNAIL_CACHE_VERSION = "v4";
@@ -3352,8 +3808,8 @@ function registerThumbnailRoutes(api, adapter) {
     let sourceMtime = 0;
     let sourceKey = "";
     const htmlFile = join11(project.dir, compPath);
-    if (existsSync7(htmlFile)) {
-      const html = readFileSync10(htmlFile, "utf-8");
+    if (existsSync8(htmlFile)) {
+      const html = readFileSync11(htmlFile, "utf-8");
       sourceKey = `_${createHash4("sha1").update(html).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.round(statSync4(htmlFile).mtimeMs);
       if (!vpWidth) {
@@ -3365,15 +3821,15 @@ function registerThumbnailRoutes(api, adapter) {
     }
     const manualEditsFile = join11(project.dir, STUDIO_MANUAL_EDITS_PATH);
     let manualEditsKey = "";
-    if (existsSync7(manualEditsFile)) {
-      const manualEditsContent = readFileSync10(manualEditsFile, "utf-8");
+    if (existsSync8(manualEditsFile)) {
+      const manualEditsContent = readFileSync11(manualEditsFile, "utf-8");
       manualEditsKey = `_${createHash4("sha1").update(manualEditsContent).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.max(sourceMtime, Math.round(statSync4(manualEditsFile).mtimeMs));
     }
     const motionFile = join11(project.dir, STUDIO_MOTION_PATH);
     let motionKey = "";
-    if (existsSync7(motionFile)) {
-      const motionContent = readFileSync10(motionFile, "utf-8");
+    if (existsSync8(motionFile)) {
+      const motionContent = readFileSync11(motionFile, "utf-8");
       motionKey = `_${createHash4("sha1").update(motionContent).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.max(sourceMtime, Math.round(statSync4(motionFile).mtimeMs));
     }
@@ -3383,8 +3839,8 @@ function registerThumbnailRoutes(api, adapter) {
     const urlVersionKey = urlVersion ? `_${urlVersion.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 32)}` : "";
     const cacheKey = `${THUMBNAIL_CACHE_VERSION}${urlVersionKey}${manualEditsKey}${motionKey}${sourceKey}_${format}_${compPath.replace(/\//g, "_")}_${compW}x${compH}_${sourceMtime}_${seekTime.toFixed(2)}${selectorKey}.${format === "png" ? "png" : "jpg"}`;
     const cachePath = join11(cacheDir, cacheKey);
-    if (existsSync7(cachePath)) {
-      return new Response(new Uint8Array(readFileSync10(cachePath)), {
+    if (existsSync8(cachePath)) {
+      return new Response(new Uint8Array(readFileSync11(cachePath)), {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
       });
     }
@@ -3406,7 +3862,7 @@ function registerThumbnailRoutes(api, adapter) {
           500
         );
       }
-      if (!existsSync7(cacheDir)) mkdirSync5(cacheDir, { recursive: true });
+      if (!existsSync8(cacheDir)) mkdirSync5(cacheDir, { recursive: true });
       writeFileSync6(cachePath, buffer);
       return new Response(new Uint8Array(buffer), {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
@@ -3419,7 +3875,7 @@ function registerThumbnailRoutes(api, adapter) {
 }
 
 // src/routes/waveform.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
 import { join as join12 } from "path";
 function registerWaveformRoutes(api, adapter) {
   api.get("/projects/:id/waveform/*", async (c) => {
@@ -3429,12 +3885,12 @@ function registerWaveformRoutes(api, adapter) {
       c.req.path.replace(`/projects/${project.id}/waveform/`, "").split("?")[0] ?? ""
     );
     const audioPath = join12(project.dir, assetPath);
-    if (!existsSync8(audioPath)) return c.json({ error: "file not found" }, 404);
+    if (!existsSync9(audioPath)) return c.json({ error: "file not found" }, 404);
     const cacheDir = join12(project.dir, ".waveform-cache");
     const cachePath = join12(cacheDir, buildWaveformCacheKey(assetPath));
-    if (existsSync8(cachePath)) {
+    if (existsSync9(cachePath)) {
       try {
-        const peaks2 = JSON.parse(readFileSync11(cachePath, "utf-8"));
+        const peaks2 = JSON.parse(readFileSync12(cachePath, "utf-8"));
         return c.json({ peaks: peaks2 });
       } catch {
       }
@@ -3718,8 +4174,8 @@ function registerSelectionRoutes(api, adapter) {
 
 // src/routes/media.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync9, mkdirSync as mkdirSync7 } from "fs";
-import { basename as basename2, dirname as dirname2, extname as extname2, join as join13 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join13 } from "path";
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
   ".mp4",
   ".mov",
@@ -3756,7 +4212,7 @@ function uniqueAssetPath(projectDir, assetPath) {
   const ext = extname2(assetPath);
   const withoutExt = assetPath.slice(0, -ext.length);
   let candidate = assetPath;
-  for (let index = 2; existsSync9(join13(projectDir, candidate)); index++) {
+  for (let index = 2; existsSync10(join13(projectDir, candidate)); index++) {
     candidate = `${withoutExt}-${index}${ext}`;
   }
   return candidate;
@@ -3807,7 +4263,7 @@ function registerMediaRoutes(api, adapter, options = {}) {
     }
     const filePath = resolveWithinProject(project.dir, assetPath);
     if (!filePath) return c.json({ error: "forbidden" }, 403);
-    if (!existsSync9(filePath)) return c.json({ error: "media not found" }, 404);
+    if (!existsSync10(filePath)) return c.json({ error: "media not found" }, 404);
     return c.json({ path: assetPath, metadata: await readMediaMetadata(filePath) });
   });
   api.post(
@@ -3829,7 +4285,7 @@ function registerMediaRoutes(api, adapter, options = {}) {
       }
       const inputPath = resolveWithinProject(project.dir, inputAssetPath);
       if (!inputPath) return c.json({ error: "forbidden" }, 403);
-      if (!existsSync9(inputPath)) return c.json({ error: "input media not found" }, 404);
+      if (!existsSync10(inputPath)) return c.json({ error: "input media not found" }, 404);
       const inputIsVideo = isVideoPath(inputAssetPath);
       const inputIsImage = isImagePath(inputAssetPath);
       if (!inputIsVideo && !inputIsImage) {
@@ -3863,8 +4319,8 @@ function registerMediaRoutes(api, adapter, options = {}) {
           return c.json({ error: "forbidden" }, 403);
         }
       }
-      mkdirSync7(dirname2(outputPath), { recursive: true });
-      if (backgroundOutputPath) mkdirSync7(dirname2(backgroundOutputPath), { recursive: true });
+      mkdirSync7(dirname3(outputPath), { recursive: true });
+      if (backgroundOutputPath) mkdirSync7(dirname3(backgroundOutputPath), { recursive: true });
       const jobId = makeJobId(project.id, mediaJobs);
       const state = adapter.startBackgroundRemoval({
         project,
@@ -3921,14 +4377,14 @@ function registerMediaRoutes(api, adapter, options = {}) {
 }
 
 // src/routes/globalAssets.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
 import { homedir } from "os";
 import { join as join14 } from "path";
 function readGlobalAssets(home = homedir()) {
   const manifestPath = join14(home, ".media", "manifest.jsonl");
-  if (!existsSync10(manifestPath)) return [];
+  if (!existsSync11(manifestPath)) return [];
   const out = [];
-  for (const line of readFileSync12(manifestPath, "utf8").split("\n")) {
+  for (const line of readFileSync13(manifestPath, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       const rec = JSON.parse(line);