hyperframes 0.8.132 → 0.8.134

package/dist/{chunk-S7NPLFWV.js → chunk-SIU7QCPK.js}

@@ -2227,10 +2227,10 @@ import { join as join6 } from "path";
 import { bodyLimit } from "hono/body-limit";
 import {
   closeSync as closeSync3,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   lstatSync as lstatSync22,
   openSync as openSync3,
-  readFileSync as readFileSync32,
+  readFileSync as readFileSync52,
   readlinkSync,
   unlinkSync as unlinkSync2,
   rmSync as rmSync3,
@@ -2240,10 +2240,17 @@ import {
   readdirSync as readdirSync22,
   realpathSync as realpathSync2
 } from "fs";
-import { resolve as resolve22, dirname as dirname32, join as join52 } from "path";
+import { resolve as resolve22, dirname as dirname32, join as join62 } from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+import { join as join23 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { randomUUID as randomUUID7 } from "crypto";
+import { dirname as dirname5, relative as relative3, resolve as resolve5, sep as sep3 } from "path";
 import { spawn } from "child_process";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync32,
   writeFileSync as writeFileSync4,
   mkdirSync as mkdirSync5,
   lstatSync as lstatSync3,
@@ -2252,15 +2259,15 @@ import {
   rmSync as rmSync4,
   statSync as statSync4
 } from "fs";
-import { dirname as dirname5, join as join23 } from "path";
+import { dirname as dirname23, join as join32 } from "path";
 import { spawnSync } from "child_process";
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync22, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, join as join32 } from "path";
-import { readdirSync as readdirSync4, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync32 } from "fs";
+import { basename as basename2, join as join42 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync32, unlinkSync, writeFileSync as writeFileSync32 } from "fs";
 import { Buffer as Buffer2 } from "buffer";
-import { join as join42, relative as relative3 } from "path";
-import { readFileSync as readFileSync23, statSync as statSync22 } from "fs";
+import { join as join52, relative as relative22 } from "path";
+import { readFileSync as readFileSync42, statSync as statSync22 } from "fs";
 
 // ../parsers/dist/gsapConstants.js
 var PROPERTY_GROUPS = {
@@ -2335,23 +2342,43 @@ function knownStart(animation) {
   if (animation.resolvedStart !== void 0) return animation.resolvedStart;
   return typeof animation.position === "number" ? animation.position : void 0;
 }
-function positionHoldForAnimation(animation, animations) {
+var tweenSignature = (a) => JSON.stringify([a.targetSelector, a.method, a.position, a.duration, a.properties, a.keyframes]);
+function holdScope(before, previous) {
+  const kept = new Set(previous?.map(tweenSignature));
+  const held = /* @__PURE__ */ new Map();
+  for (const a of before.filter((b) => b.method === "set" && b.properties?.data === "hf-hold")) {
+    const props = held.get(a.targetSelector) ?? /* @__PURE__ */ new Map();
+    for (const [property, value] of Object.entries(a.properties)) props.set(property, value);
+    held.set(a.targetSelector, props);
+  }
+  return {
+    touched: (a) => previous !== null && !kept.has(tweenSignature(a)),
+    held: (selector) => held.get(selector) ?? /* @__PURE__ */ new Map()
+  };
+}
+function keyframeHoldForAnimation(animation, animations, scope) {
   if (!animation.keyframes) return null;
-  const start = knownStart(animation) ?? 0;
-  if (!(start > 1e-3)) return null;
+  const start = knownStart(animation);
+  const lone = animation.keyframes.keyframes.length === 1;
+  if (start === void 0 || !(start > 1e-3) && !lone) return null;
   const atStart = animation.keyframes.keyframes.find((keyframe) => keyframe.percentage === 0);
   if (!atStart) return null;
   const earlier = animations.filter((other) => {
     const otherStart = knownStart(other);
     return other !== animation && !other.global && other.targetSelector === animation.targetSelector && otherStart !== void 0 && otherStart < start - 1e-3;
   });
-  const position = {};
+  const touched = scope.touched(animation);
+  const pinned = scope.held(animation.targetSelector);
+  const kept = (property, value) => touched ? pinned.has(property) : pinned.get(property) === value;
+  const pins = (group, property, value) => group === "position" && start > 1e-3 || (group === "position" || group === "size") && (lone && touched || kept(property, value));
+  const hold = {};
   for (const [property, value] of Object.entries(atStart.properties)) {
-    if (classifyPropertyGroup2(property) !== "position" || typeof value !== "number") continue;
+    if (!pins(classifyPropertyGroup2(property), property, value) || typeof value !== "number")
+      continue;
     if (earlier.some((other) => writesProperty(other, property))) continue;
-    position[property] = value;
+    hold[property] = value;
   }
-  return Object.keys(position).length > 0 ? position : null;
+  return Object.keys(hold).length > 0 ? hold : null;
 }
 function authorsKeyframes(anim) {
   return anim.keyframes !== void 0 || anim.hasUnresolvedKeyframes === true;
@@ -5021,15 +5048,20 @@ function removeStudioHoldSets(script, parsed) {
   for (const hold of staleHolds) removeCallFromMagicString(ms, hold.call, script);
   return ms.toString();
 }
-function syncPositionHoldsBeforeKeyframes(script) {
+function syncPositionHoldsBeforeKeyframes(script, previous) {
   const parsed = parseGsapScriptAcornForWrite(script);
   if (!parsed) return script;
+  const tweensOf = (text2) => parseGsapScriptAcornForWrite(text2)?.located.map((entry) => entry.animation) ?? null;
+  const scope = holdScope(
+    parsed.located.map((entry) => entry.animation),
+    previous === void 0 ? null : tweensOf(previous)
+  );
   let result = removeStudioHoldSets(script, parsed);
   const current = parseGsapScriptAcornForWrite(result);
   if (!current) return result;
   const animations = current.located.map((entry) => entry.animation);
   for (const animation of animations) {
-    const position = positionHoldForAnimation(animation, animations);
+    const position = keyframeHoldForAnimation(animation, animations, scope);
     if (!position) continue;
     result = insertInheritedStateSetInScript(result, animation.targetSelector, 0, {
       ...position,
@@ -5038,6 +5070,62 @@ function syncPositionHoldsBeforeKeyframes(script) {
   }
   return result;
 }
+var roundPct = (pct) => Math.round(pct * 1e3) / 1e3;
+var LINEAR_RUN = /* @__PURE__ */ new Set(["none", "linear"]);
+var PLACED_BY_TIMELINE = /\.(?:add|addLabel|addPause|call|repeat|yoyo|duration|timeScale)\s*\(|\b(?:repeat|yoyo)\s*:/;
+function linearPercentageKeys(animation) {
+  const data = animation.keyframes;
+  if (data?.format !== "percentage" || data.fromMotionPath || animation.arcPath) return null;
+  if (animation.durationUnresolved || !LINEAR_RUN.has(animation.ease || "none")) return null;
+  return data.keyframes;
+}
+var loops = (animation) => Boolean(animation.extras?.repeat || animation.extras?.yoyo);
+function trimmableKeyframes(animation) {
+  const keyframes = loops(animation) ? null : linearPercentageKeys(animation);
+  const { duration, position } = animation;
+  if (!keyframes || typeof position !== "number" || typeof duration !== "number") return null;
+  return duration > 0 ? { keyframes, duration, position } : null;
+}
+function trailingSpanTrim(animation) {
+  const tween = trimmableKeyframes(animation);
+  if (!tween) return null;
+  const last = Math.max(...tween.keyframes.map((keyframe) => keyframe.percentage));
+  if (tween.keyframes.length < 2 || !(last > 0) || last >= 99.999) return null;
+  return {
+    position: tween.position,
+    duration: Math.round(tween.duration * last * 10) / 1e3,
+    pctRemap: tween.keyframes.map(({ percentage: from }) => ({
+      from,
+      to: roundPct(from / last * 100)
+    }))
+  };
+}
+function trimTrailingKeyframeSpans(previous, script) {
+  if (script === previous) return script;
+  const located = parseGsapScriptAcornForWrite(script)?.located ?? [];
+  const placedAfter = ({ animation: a }) => !a.global && (a.implicitPosition || typeof a.position !== "number");
+  if (PLACED_BY_TIMELINE.test(script) || located.some(placedAfter)) return script;
+  const trims = located.flatMap((entry) => {
+    const trim = trailingSpanTrim(entry.animation);
+    return trim ? [{ entry, trim }] : [];
+  });
+  if (!trims.length) return script;
+  const source = (text2, { call }) => `${call.method}${text2.slice(call.node.arguments[0]?.start, call.node.end)}`;
+  const previousTweens = parseGsapScriptAcornForWrite(previous)?.located ?? [];
+  const untouched = new Set(previousTweens.map((entry) => source(previous, entry)));
+  let result = script;
+  for (const { entry, trim } of trims) {
+    if (untouched.has(source(script, entry))) continue;
+    result = resizeKeyframedTweenInScript(
+      result,
+      entry.id,
+      trim.position,
+      trim.duration,
+      trim.pctRemap
+    );
+  }
+  return result;
+}
 function computeForwardBaselines(matching, splitTime) {
   const before = [];
   const acc = {};
@@ -5330,31 +5418,26 @@ function unrollDynamicAnimations(script, animationId, elements) {
 }
 
 // ../studio-server/dist/index.js
-import { existsSync as existsSync22 } from "fs";
-import { randomUUID as randomUUID7 } from "crypto";
-import { dirname as dirname23, relative as relative22, resolve as resolve5, sep as sep3 } from "path";
-import { createReadStream as createReadStream2, existsSync as existsSync5, readFileSync as readFileSync52, statSync as statSync42 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync5, readFileSync as readFileSync62, statSync as statSync42 } from "fs";
 import { Readable } from "stream";
 import { join as join8, resolve as resolve42 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 
 // ../core/dist/studioPreviewMark.js
 var STUDIO_PREVIEW_MARK_META = "hyperframes-studio-preview";
 var STUDIO_PREVIEW_LAZY_ATTR = "data-hf-preview-lazy";
 
 // ../studio-server/dist/index.js
-import { existsSync as existsSync42, readFileSync as readFileSync42 } from "fs";
-import { join as join62 } from "path";
 import { readlinkSync as readlinkSync2 } from "fs";
 import { dirname as dirname42, join as join7, parse as parse2, relative as relative32, resolve as resolve32 } from "path";
-import { readFileSync as readFileSync62 } from "fs";
+import { readFileSync as readFileSync72 } from "fs";
 import { join as join9 } from "path";
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync6, readFileSync as readFileSync72, unlinkSync as unlinkSync3, readdirSync as readdirSync32, statSync as statSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync8, unlinkSync as unlinkSync3, readdirSync as readdirSync32, statSync as statSync5 } from "fs";
 import { join as join10 } from "path";
 import { HTTPException } from "hono/http-exception";
 import { open, stat as stat2 } from "fs/promises";
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash32 } from "crypto";
 import {
   closeSync as closeSync22,
   fstatSync as fstatSync22,
@@ -5369,8 +5452,6 @@ import {
 } from "fs";
 import { join as join11 } from "path";
 import { createHash as createHash42, randomUUID as randomUUID22 } from "crypto";
-import { readFileSync as readFileSync8 } from "fs";
-import { createHash as createHash32 } from "crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
 import { join as join12, resolve as resolve52 } from "path";
 import { execFile } from "child_process";
@@ -5477,339 +5558,175 @@ function getMimeType(path) {
 function isAudioFile(name) {
   return (getMimeType(name) ?? "").startsWith("audio/");
 }
-var SAMPLE_RATE = 4e3;
-var PEAK_COUNT = 4e3;
-var WAVEFORM_CACHE_VERSION = "v2";
-function buildWaveformCacheKey(assetPath, fingerprint) {
-  const name = assetPath.replace(/[/\\]/g, "_");
-  if (!fingerprint) return `${WAVEFORM_CACHE_VERSION}_${name}.json`;
-  const stamp = `${fingerprint.size}-${Math.round(fingerprint.mtimeMs)}`;
-  return `${WAVEFORM_CACHE_VERSION}_${name}_${stamp}.json`;
-}
-function computePeaks(floats, count) {
-  const step = floats.length / count;
-  const peaks = [];
-  for (let i = 0; i < count; i++) {
-    const start = Math.floor(i * step);
-    const end = Math.min(Math.floor((i + 1) * step), floats.length);
-    let max = 0;
-    for (let j = start; j < end; j++) {
-      const abs = Math.abs(floats[j] ?? 0);
-      if (abs > max) max = abs;
-    }
-    peaks.push(max);
+function rewriteRelativePaths(root, compPath, projectDir) {
+  const assetExists = (path) => existsSync3(join23(projectDir, path));
+  rewriteAssetPaths(
+    root.querySelectorAll("[src], [href]"),
+    compPath,
+    (el, attr) => el.getAttribute(attr),
+    (el, attr, value) => el.setAttribute(attr, value),
+    assetExists
+  );
+  rewriteInlineStyleAssetUrls(
+    root.querySelectorAll("[style]"),
+    compPath,
+    (el) => el.getAttribute("style"),
+    (el, value) => el.setAttribute("style", value),
+    assetExists
+  );
+  for (const styleEl of root.querySelectorAll("style")) {
+    styleEl.textContent = rewriteCssAssetUrls(styleEl.textContent || "", compPath, assetExists);
   }
-  const maxPeak = Math.max(...peaks, 1e-3);
-  return peaks.map((p) => p / maxPeak);
-}
-function decodeAudioPeaks(audioPath) {
-  return new Promise((resolvePromise, reject) => {
-    const proc = spawn(
-      findFfBinary("ffmpeg") ?? "ffmpeg",
-      [
-        "-i",
-        audioPath,
-        "-af",
-        "atrim=start_sample=1152",
-        "-f",
-        "f32le",
-        "-ac",
-        "1",
-        "-ar",
-        String(SAMPLE_RATE),
-        "-vn",
-        "pipe:1"
-      ],
-      { stdio: ["ignore", "pipe", "ignore"], windowsHide: true }
-    );
-    const chunks = [];
-    proc.stdout?.on("data", (chunk) => chunks.push(chunk));
-    proc.on("close", (code) => {
-      if (code !== 0 && chunks.length === 0) {
-        reject(new Error(`ffmpeg exited with code ${code}`));
-        return;
-      }
-      const buf = Buffer.concat(chunks);
-      const numSamples = Math.floor(buf.length / 4);
-      if (numSamples === 0) {
-        reject(new Error("ffmpeg produced no audio samples"));
-        return;
-      }
-      const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + numSamples * 4);
-      resolvePromise(computePeaks(new Float32Array(ab), PEAK_COUNT));
-    });
-    proc.on("error", reject);
-  });
-}
-async function generateWaveformCache(projectDir, assetPath) {
-  const audioPath = join23(projectDir, assetPath);
-  if (!existsSync4(audioPath)) return;
-  const stats = statSync4(audioPath);
-  const cacheDir = join23(projectDir, ".waveform-cache");
-  const cachePath = join23(cacheDir, buildWaveformCacheKey(assetPath, stats));
-  if (isWaveformCacheDirectory(cacheDir) && existsSync4(cachePath)) return;
-  const peaks = await decodeAudioPeaks(audioPath);
-  writeWaveformCache(cachePath, peaks);
 }
-function isWaveformCacheDirectory(cacheDir) {
-  return lstatSync3(cacheDir, { throwIfNoEntry: false })?.isDirectory() ?? false;
+function escapeLeadingDigitIdent(id) {
+  return `\\${id.charCodeAt(0).toString(16)} ${id.slice(1)}`;
 }
-function writeWaveformCache(cachePath, peaks) {
-  const cacheDir = dirname5(cachePath);
-  try {
-    mkdirSync5(cacheDir, { mode: 448 });
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
-  }
-  if (!isWaveformCacheDirectory(cacheDir)) {
-    throw new Error("Waveform cache must be a directory, not a symlink");
+var REGEXP_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+function fixDigitLeadingIdSelectors(root) {
+  const digitIds = /* @__PURE__ */ new Set();
+  for (const el of root.querySelectorAll("[id]")) {
+    const id = el.getAttribute("id");
+    if (id && /^\d/.test(id)) digitIds.add(id);
   }
-  const stagingDir = mkdtempSync(join23(cacheDir, ".waveform-"));
-  try {
-    const stagingPath = join23(stagingDir, "peaks.json");
-    writeFileSync4(stagingPath, JSON.stringify(peaks), { flag: "wx" });
-    renameSync3(stagingPath, cachePath);
-  } finally {
-    try {
-      rmSync4(stagingDir, { recursive: true, force: true });
-    } catch {
+  if (digitIds.size === 0) return;
+  for (const styleEl of root.querySelectorAll("style")) {
+    let css = styleEl.textContent || "";
+    for (const id of digitIds) {
+      const pattern = new RegExp(`#${id.replace(REGEXP_SPECIALS, "\\$&")}(?![\\w-])`, "g");
+      css = css.replace(pattern, `#${escapeLeadingDigitIdent(id)}`);
     }
+    styleEl.textContent = css;
   }
 }
-var VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi|m4v|mxf|mts|m2ts|ts)$/i;
-var AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac|flac)$/i;
-var defaultRunner = spawnSync;
-var FFPROBE_MISSING = "not checked: ffprobe was not found. Install FFmpeg or set HYPERFRAMES_FFPROBE_PATH.";
-function validateUploadedMedia(filePath, runner = defaultRunner) {
-  const isVideo = VIDEO_EXT.test(filePath);
-  const isAudio = AUDIO_EXT.test(filePath);
-  if (!isVideo && !isAudio) {
-    return { ok: true };
-  }
-  const ffprobe = findFfBinary("ffprobe") ?? (runner === defaultRunner ? void 0 : "ffprobe");
-  if (!ffprobe) return { ok: true, unchecked: FFPROBE_MISSING };
-  const result = runner(
-    ffprobe,
-    ["-v", "error", "-show_entries", "stream=codec_type", "-of", "json", "--", filePath],
-    { windowsHide: true }
-  );
-  if (result.error && process.env[FFPROBE_PATH_ENV]?.trim()) {
-    return {
-      ok: false,
-      reason: `${FFPROBE_PATH_ENV} names "${ffprobe}", which cannot run: fix it or unset it`
-    };
-  }
-  if (result.error?.code === "ENOENT") {
-    return { ok: true, unchecked: FFPROBE_MISSING };
-  }
-  if (result.status !== 0) {
-    return { ok: false, reason: "ffprobe failed to read the media file" };
+function extractFullDocumentParts(rawHtml, compPath, projectDir) {
+  const { document: doc } = parseHTML(rawHtml);
+  const rewriteTargets = [doc.head, doc.body].filter(Boolean);
+  for (const target of rewriteTargets) {
+    rewriteRelativePaths(target, compPath, projectDir);
   }
-  return checkStreams(String(result.stdout || "{}"), isVideo, isAudio);
+  fixDigitLeadingIdSelectors(doc);
+  const headContent = doc.head?.innerHTML ?? "";
+  const bodyContent = doc.body?.innerHTML ?? "";
+  const htmlEl = doc.documentElement;
+  const htmlAttrs = extractElementAttrs(htmlEl);
+  const bodyAttrs = doc.body ? extractElementAttrs(doc.body) : "";
+  return { headContent, bodyContent, htmlAttrs, bodyAttrs };
 }
-function checkStreams(stdout, isVideo, isAudio) {
-  try {
-    const parsed = JSON.parse(stdout);
-    const streams = parsed.streams ?? [];
-    const hasVideo = streams.some((stream) => stream.codec_type === "video");
-    const hasAudio = streams.some((stream) => stream.codec_type === "audio");
-    if (isVideo && !hasVideo) {
-      return { ok: false, reason: "no supported video stream found" };
-    }
-    if (isAudio && !hasAudio) {
-      return { ok: false, reason: "no supported audio stream found" };
+function extractTemplateInnerHtml(rawComp) {
+  const { document: doc } = parseHTML(rawComp);
+  const template = doc.querySelector("template");
+  return template ? template.innerHTML : null;
+}
+function escapeAttrValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function extractElementAttrs(el) {
+  const parts = [];
+  for (let i = 0; i < el.attributes.length; i++) {
+    const attr = el.attributes[i];
+    if (attr.value === "") {
+      parts.push(attr.name);
+    } else {
+      parts.push(`${attr.name}="${escapeAttrValue(attr.value)}"`);
     }
-    return { ok: true };
-  } catch {
-    return { ok: false, reason: "ffprobe returned unreadable media metadata" };
   }
+  return parts.join(" ");
 }
-function validateUploadedMediaBuffer(fileName, buffer, runner = defaultRunner) {
-  const tempDir = mkdtempSync2(join32(tmpdir2(), "hyperframes-upload-"));
-  const tempPath = join32(tempDir, basename2(fileName));
-  try {
-    writeFileSync23(tempPath, buffer);
-    return validateUploadedMedia(tempPath, runner);
-  } finally {
-    rmSync22(tempDir, { recursive: true, force: true });
+var NON_RENDERED_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "LINK", "META", "TEMPLATE", "NOSCRIPT"]);
+function promoteTemplateCompositionId(rawComp, body) {
+  let templateCompositionId;
+  for (const tag of rawComp.matchAll(/<template\b[^>]*/gi)) {
+    const id = /\bdata-composition-id\s*=\s*["']([^"']+)["']/i.exec(tag[0] ?? "")?.[1];
+    if (id) {
+      templateCompositionId = id;
+      break;
+    }
   }
+  if (!templateCompositionId) return;
+  if (body.querySelector("[data-composition-id]")) return;
+  const root = Array.from(body.children).find((el) => !NON_RENDERED_TAGS.has(el.tagName));
+  root?.setAttribute("data-composition-id", templateCompositionId);
 }
-var DEFAULT_KEEP_PER_FILE = 10;
-function backupKeyForPath(path) {
-  return Buffer2.from(path, "utf-8").toString("base64url");
-}
-function timestampPrefix() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+function tagRootCompositionFile(bodyHtml, compPath) {
+  const match = bodyHtml.match(/<[a-zA-Z][^>]*\bdata-composition-id=/);
+  if (match?.index == null) return bodyHtml;
+  const tagEnd = bodyHtml.indexOf(">", match.index);
+  if (tagEnd === -1) return bodyHtml;
+  if (bodyHtml.slice(match.index, tagEnd).includes("data-composition-file")) return bodyHtml;
+  return bodyHtml.slice(0, tagEnd) + ` data-composition-file="${compPath}"` + bodyHtml.slice(tagEnd);
 }
-function backupPathForResponse(projectDir, backupPath) {
-  if (!backupPath) return null;
-  const rel = relative3(projectDir, backupPath);
-  if (!rel || rel.startsWith("..")) return null;
-  return rel.split("\\").join("/");
+function rootHeadContent(rootHtml) {
+  return rootHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i)?.[1] ?? "";
 }
-function snapshotBeforeWrite(projectDir, absPath, options = {}) {
-  if (!isSafePath(projectDir, absPath)) return { backupPath: null };
-  try {
-    const content = readFileSync7(absPath);
-    const relativePath = relative3(projectDir, absPath);
-    const backupDir = join42(projectDir, ".hyperframes", "backup");
-    mkdirWithinProject(projectDir, backupDir);
-    const backupKey = backupKeyForPath(relativePath);
-    const backupPath = nextBackupPath(backupDir, backupKey);
-    writeFileSync32(backupPath, content);
-    pruneBackups(backupDir, backupKey, options.keepPerFile ?? DEFAULT_KEEP_PER_FILE);
-    return { backupPath };
-  } catch (error) {
-    if (isProjectRootMissing(error)) throw error;
-    if (error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) {
-      return { backupPath: null };
-    }
-    return { backupPath: null, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-function nextBackupPath(backupDir, backupKey) {
-  const base = `${timestampPrefix()}-${backupKey}`;
-  let candidate = join42(backupDir, base);
-  let counter = 2;
-  while (true) {
-    try {
-      readFileSync7(candidate);
-    } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-        return candidate;
-      }
-      throw error;
-    }
-    candidate = join42(backupDir, `${base}-${counter}`);
-    counter += 1;
-  }
-}
-function pruneBackups(backupDir, backupKey, keepPerFile) {
-  const keep = Math.max(1, Math.floor(keepPerFile));
-  const suffix = `-${backupKey}`;
-  const numberedSuffix = new RegExp(`-${backupKey}-\\d+$`);
-  const matches = readdirSync4(backupDir).filter((name) => name.endsWith(suffix) || numberedSuffix.test(name)).map((name) => join42(backupDir, name)).sort((a, b) => {
-    return b.localeCompare(a);
-  });
-  for (const file of matches.slice(keep)) {
-    try {
-      unlinkSync(file);
-    } catch {
-    }
-  }
-}
-var PROJECT_DIR_MISSING = { error: "not found", why: "project_dir_missing" };
-var projectDirMissing = (c) => c.json(PROJECT_DIR_MISSING, 404);
-function replaceWithProjectDirMissing(c, hostHeaders) {
-  hostHeaders.delete("content-type");
-  c.res = void 0;
-  c.res = Response.json(PROJECT_DIR_MISSING, { status: 404, headers: hostHeaders });
-}
-function applyFileMutations(projectDir, mutations, requestToken, writeFile2 = (path, content) => replaceFileAtomically(path, content, statSync22(path).mode)) {
-  const prepared = mutations.map((mutation) => ({
-    ...mutation,
-    before: mutation.before ?? readFileSync23(mutation.absPath, "utf-8")
-  }));
-  const results = [];
-  const attempted = [];
-  for (const mutation of prepared)
-    assertExpectedVersion(mutation, readFileSync23(mutation.absPath, "utf-8"));
-  try {
-    for (const mutation of prepared) {
-      results.push(applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted));
-    }
-    return results;
-  } catch (error) {
-    const rollbackErrors = [];
-    for (const mutation of attempted.reverse()) {
-      try {
-        if (!mutation.written || readFileSync23(mutation.absPath, "utf-8") === mutation.after)
-          writeFile2(mutation.absPath, mutation.before, "utf-8");
-        clearFileWriteReceipt(mutation.absPath, mutation.version, mutation.writeToken);
-      } catch (rollbackError) {
-        rollbackErrors.push(rollbackError);
-      }
-    }
-    if (rollbackErrors.length > 0) {
-      throw new AggregateError(
-        [error, ...rollbackErrors],
-        "File mutation failed and rollback did not complete"
-      );
-    }
-    throw error;
+function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
+  const compFile = join23(projectDir, compPath);
+  if (!existsSync3(compFile)) return null;
+  const rawComp = rawOverride ?? readFileSync7(compFile, "utf-8");
+  let compHeadContent = "";
+  let rewrittenContent;
+  let htmlAttrs = "";
+  let bodyAttrs = "";
+  const templateInner = extractTemplateInnerHtml(rawComp);
+  if (templateInner != null) {
+    const { document: contentDoc } = parseHTML(
+      `<!DOCTYPE html><html><head></head><body>${templateInner}</body></html>`
+    );
+    rewriteRelativePaths(contentDoc, compPath, projectDir);
+    fixDigitLeadingIdSelectors(contentDoc);
+    promoteTemplateCompositionId(rawComp, contentDoc.body);
+    rewrittenContent = contentDoc.body.innerHTML || templateInner;
+  } else if (isFullHtmlDocument(rawComp)) {
+    const parts = extractFullDocumentParts(rawComp, compPath, projectDir);
+    compHeadContent = parts.headContent;
+    rewrittenContent = parts.bodyContent;
+    htmlAttrs = parts.htmlAttrs;
+    bodyAttrs = parts.bodyAttrs;
+  } else {
+    const { document: contentDoc } = parseHTML(
+      `<!DOCTYPE html><html><head></head><body>${rawComp}</body></html>`
+    );
+    rewriteRelativePaths(contentDoc, compPath, projectDir);
+    fixDigitLeadingIdSelectors(contentDoc);
+    rewrittenContent = contentDoc.body.innerHTML || rawComp;
   }
-}
-function applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted) {
-  const current = readFileSync23(mutation.absPath, "utf-8");
-  assertExpectedVersion(mutation, current);
-  if (mutation.after === mutation.before) {
-    return {
-      ...mutation,
-      before: current,
-      changed: false,
-      backupPath: null,
-      version: fileContentVersion(mutation.before),
-      writeToken: null
-    };
+  rewrittenContent = stripEmbeddedRuntimeScripts(rewrittenContent);
+  const { document: scriptsDoc } = parseHTML(
+    `<!DOCTYPE html><html><head></head><body>${rewrittenContent}</body></html>`
+  );
+  deferScriptsUntilFonts(scriptsDoc);
+  rewrittenContent = scriptsDoc.body.innerHTML;
+  rewrittenContent = tagRootCompositionFile(rewrittenContent, compPath);
+  const indexPath = join23(projectDir, "index.html");
+  let headContent = "";
+  if (existsSync3(indexPath)) headContent = rootHeadContent(readFileSync7(indexPath, "utf-8"));
+  if (baseHref && !hasBaseElement(headContent)) {
+    headContent = `<base href="${baseHref}">
+${headContent}`;
   }
-  const backup = snapshotBeforeWrite(projectDir, mutation.absPath);
-  if (backup.error) throw new Error(`backup failed: ${backup.error}`);
-  assertExpectedVersion(mutation, readFileSync23(mutation.absPath, "utf-8"));
-  const before = current;
-  const version = fileContentVersion(mutation.after);
-  const writeToken = createWriteToken(requestToken);
-  const attempt = { ...mutation, before, version, writeToken, written: false };
-  attempted.push(attempt);
-  writeFile2(mutation.absPath, mutation.after, "utf-8");
-  attempt.written = true;
-  recordFileWriteReceipt(mutation.absPath, {
-    path: mutation.sourceFile,
-    version,
-    writeToken,
-    overwrote: before
-  });
-  return {
-    ...mutation,
-    before,
-    changed: true,
-    backupPath: backupPathForResponse(projectDir, backup.backupPath),
-    version,
-    writeToken
-  };
-}
-var FileChangedError = class extends Error {
-  constructor(sourceFile) {
-    super("file changed since the timeline was read");
-    this.sourceFile = sourceFile;
+  if (compHeadContent) headContent += `
+${compHeadContent}`;
+  headContent = stripEmbeddedRuntimeScripts(headContent);
+  headContent += `
+<script ${RUNTIME_BOOTSTRAP_ATTR}="1" src="${runtimeUrl}"></script>`;
+  if (!headContent.includes("gsap")) {
+    headContent += `
+<script src="${gsapCdnDist()}gsap.min.js"></script>`;
   }
-  sourceFile;
-};
-function assertExpectedVersion(mutation, current) {
-  const stale = mutation.expectedVersion === void 0 ? current !== mutation.before : fileContentVersion(current) !== mutation.expectedVersion;
-  if (stale) throw new FileChangedError(mutation.sourceFile);
-}
-var FONT_STYLE_RE = /<style\b[^>]*data-hf-studio-fonts=(["'])true\1[^>]*>([\s\S]*?)<\/style>/i;
-var ONE_FONT_FACE_RULE = /^@font-face \{(?:[^{}<"'\\]|"(?:[^"\\<\n\r\f]|\\[^<\n\r\f])*"|'(?:[^'\\<\n\r\f]|\\[^<\n\r\f])*')*\}$/;
-function isStudioFontFaceCss(css) {
-  return typeof css === "string" && ONE_FONT_FACE_RULE.test(css);
+  const htmlOpen = htmlAttrs ? `<html ${htmlAttrs}>` : "<html>";
+  const bodyOpen = bodyAttrs ? `<body ${bodyAttrs}>` : "<body>";
+  return `<!DOCTYPE html>
+${htmlOpen}
+<head>
+${headContent}
+</head>
+${bodyOpen}
+<script>window.__timelines=window.__timelines||{};</script>
+${rewrittenContent}
+</body>
+</html>`;
 }
-function ensureStudioFontFaceCss(html, css) {
-  if (html.includes(css)) return html;
-  const block = FONT_STYLE_RE.exec(html);
-  if (block) {
-    const next = `${(block[2] ?? "").trim()}
-${css}`.trim();
-    return html.replace(block[0], () => `<style data-hf-studio-fonts="true">
-${next}
-</style>`);
-  }
-  const styleTag = `<style data-hf-studio-fonts="true">
-${css}
-</style>`;
-  if (/<\/head>/i.test(html)) return html.replace(/<\/head>/i, () => `  ${styleTag}
-  </head>`);
-  return `${styleTag}
-${html}`;
+function hasBaseElement(html) {
+  return parseHTML(html).document.querySelector("base") !== null;
 }
 var CompositionInsertionError = class extends Error {
   constructor(message, status) {
@@ -5875,7 +5792,7 @@ function canonicalDependency(projectDir, ownerAbs, sourcePath) {
   validateSourcePath(sourcePath);
   return canonicalProjectPath(
     projectDir,
-    resolveWithinProject(projectDir, relative22(projectDir, resolve5(dirname23(ownerAbs), sourcePath)))
+    resolveWithinProject(projectDir, relative3(projectDir, resolve5(dirname5(ownerAbs), sourcePath)))
   );
 }
 function validateDependencyGraph(projectDir, targetAbs, sourceAbs) {
@@ -5948,7 +5865,7 @@ function uniqueHostId(root, base) {
   return `${base}_${suffix}`;
 }
 function relativeSourcePath(targetAbs, sourceAbs) {
-  return relative22(dirname23(targetAbs), sourceAbs).split(sep3).join("/");
+  return relative3(dirname5(targetAbs), sourceAbs).split(sep3).join("/");
 }
 function insertCompositionIntoSource(input) {
   const targetAbs = canonicalProjectFile(input.projectDir, input.targetPath);
@@ -6001,7 +5918,443 @@ function insertCompositionIntoSource(input) {
     const name = root.hasAttribute("data-duration") ? "data-duration" : "data-composition-duration";
     root.setAttribute(name, String(Math.round((input.start + duration) * 100) / 100));
   }
-  return { html: document2.toString(), hostId, track, duration };
+  return { html: document2.toString(), hostId, track, duration };
+}
+var ROOT_COMPOSITION = "index.html";
+var COMPOSITION_SRC = /\bdata-composition-src\s*=\s*(["'])(.*?)\1/g;
+function projectReader(projectDir) {
+  const sources = /* @__PURE__ */ new Map();
+  return (compPath) => {
+    if (!sources.has(compPath)) {
+      const file = resolveWithinProject(projectDir, compPath);
+      let source = null;
+      try {
+        source = file ? readFileSync23(file, "utf-8") : null;
+      } catch {
+      }
+      sources.set(compPath, source);
+    }
+    return sources.get(compPath) ?? null;
+  };
+}
+function normalizeSource(src) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) return null;
+  const path = src.split(/[?#]/)[0]?.replace(/^\.?\//, "") ?? "";
+  return path || null;
+}
+function closureOf(read, compPath) {
+  const closure = /* @__PURE__ */ new Set();
+  const visit = (path) => {
+    if (closure.has(path)) return;
+    closure.add(path);
+    for (const match of (read(path) ?? "").matchAll(COMPOSITION_SRC)) {
+      const mounted = normalizeSource(match[2] ?? "");
+      if (mounted) visit(mounted);
+    }
+  };
+  visit(compPath);
+  return closure;
+}
+function lengthIsTimeline(projectDir, compPath) {
+  const read = projectReader(projectDir);
+  const documents = /* @__PURE__ */ new Map();
+  const elements = (path, selector) => {
+    let document2 = documents.get(path);
+    if (!document2) documents.set(path, document2 = parseHTML(read(path) ?? "").document);
+    return descendants(document2, selector);
+  };
+  const comp = normalizeSource(compPath) ?? compPath;
+  const unsized = (path) => {
+    const [root] = elements(path, "[data-composition-id]");
+    return Boolean(root && !root.hasAttribute("data-duration"));
+  };
+  if (unsized(ROOT_COMPOSITION)) return true;
+  const hosts = [...closureOf(read, ROOT_COMPOSITION)].flatMap(
+    (path) => elements(path, "[data-composition-src]").filter(
+      (host) => normalizeSource(host.getAttribute("data-composition-src") ?? "") === comp
+    )
+  );
+  if (comp === ROOT_COMPOSITION || hosts.length === 0) return unsized(comp);
+  return hosts.some(
+    (host) => !host.hasAttribute("data-duration") && !host.hasAttribute("data-end")
+  );
+}
+var inputSignatures = /* @__PURE__ */ new Map();
+var rootMemos = /* @__PURE__ */ new Map();
+var sha1 = (text2) => createHash4("sha1").update(text2).digest("hex");
+function rootHashes(read) {
+  const source = read(ROOT_COMPOSITION) ?? "";
+  return { root: sha1(source), head: sha1(rootHeadContent(source)) };
+}
+function compositionInputSignature(projectDir, compPath, projectSignature) {
+  const key = `${projectDir}\0${compPath}`;
+  const known = inputSignatures.get(key);
+  if (known?.projectSignature === projectSignature) return known.inputSignature;
+  const read = projectReader(projectDir);
+  const comp = normalizeSource(compPath) ?? compPath;
+  const inputs = closureOf(read, comp).add(ROOT_COMPOSITION);
+  const excluded = new Set(
+    [...closureOf(read, ROOT_COMPOSITION)].filter((path) => !inputs.has(path))
+  );
+  let inputSignature;
+  if (comp === ROOT_COMPOSITION) {
+    inputSignature = createProjectSignature(projectDir, excluded);
+  } else {
+    const hashes = rootHashes(read);
+    if (!rootMemos.has(projectDir)) rootMemos.set(projectDir, { ...hashes, affected: null });
+    inputSignature = `${createProjectSignature(projectDir, excluded.add(ROOT_COMPOSITION))}:${hashes.head}`;
+  }
+  inputSignatures.set(key, { projectSignature, inputSignature });
+  return inputSignature;
+}
+function compositionsAffectedBy(projectDir, changedPath) {
+  const changed = changedPath.replace(/\\/g, "/");
+  const read = projectReader(projectDir);
+  if (changed === ROOT_COMPOSITION) {
+    const now = rootHashes(read);
+    const memo = rootMemos.get(projectDir);
+    if (memo?.root === now.root) return memo.affected;
+    const affected = memo?.head === now.head ? [ROOT_COMPOSITION] : null;
+    rootMemos.set(projectDir, { ...now, affected });
+    return affected;
+  }
+  const mounted = closureOf(read, ROOT_COMPOSITION);
+  if (!mounted.has(changed)) return null;
+  return [...mounted].filter((path) => closureOf(read, path).has(changed));
+}
+var SAMPLE_RATE = 4e3;
+var PEAK_COUNT = 4e3;
+var WAVEFORM_CACHE_VERSION = "v2";
+function buildWaveformCacheKey(assetPath, fingerprint) {
+  const name = assetPath.replace(/[/\\]/g, "_");
+  if (!fingerprint) return `${WAVEFORM_CACHE_VERSION}_${name}.json`;
+  const stamp = `${fingerprint.size}-${Math.round(fingerprint.mtimeMs)}`;
+  return `${WAVEFORM_CACHE_VERSION}_${name}_${stamp}.json`;
+}
+function computePeaks(floats, count) {
+  const step = floats.length / count;
+  const peaks = [];
+  for (let i = 0; i < count; i++) {
+    const start = Math.floor(i * step);
+    const end = Math.min(Math.floor((i + 1) * step), floats.length);
+    let max = 0;
+    for (let j = start; j < end; j++) {
+      const abs = Math.abs(floats[j] ?? 0);
+      if (abs > max) max = abs;
+    }
+    peaks.push(max);
+  }
+  const maxPeak = Math.max(...peaks, 1e-3);
+  return peaks.map((p) => p / maxPeak);
+}
+function decodeAudioPeaks(audioPath) {
+  return new Promise((resolvePromise, reject) => {
+    const proc = spawn(
+      findFfBinary("ffmpeg") ?? "ffmpeg",
+      [
+        "-i",
+        audioPath,
+        "-af",
+        "atrim=start_sample=1152",
+        "-f",
+        "f32le",
+        "-ac",
+        "1",
+        "-ar",
+        String(SAMPLE_RATE),
+        "-vn",
+        "pipe:1"
+      ],
+      { stdio: ["ignore", "pipe", "ignore"], windowsHide: true }
+    );
+    const chunks = [];
+    proc.stdout?.on("data", (chunk) => chunks.push(chunk));
+    proc.on("close", (code) => {
+      if (code !== 0 && chunks.length === 0) {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+        return;
+      }
+      const buf = Buffer.concat(chunks);
+      const numSamples = Math.floor(buf.length / 4);
+      if (numSamples === 0) {
+        reject(new Error("ffmpeg produced no audio samples"));
+        return;
+      }
+      const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + numSamples * 4);
+      resolvePromise(computePeaks(new Float32Array(ab), PEAK_COUNT));
+    });
+    proc.on("error", reject);
+  });
+}
+async function generateWaveformCache(projectDir, assetPath) {
+  const audioPath = join32(projectDir, assetPath);
+  if (!existsSync32(audioPath)) return;
+  const stats = statSync4(audioPath);
+  const cacheDir = join32(projectDir, ".waveform-cache");
+  const cachePath = join32(cacheDir, buildWaveformCacheKey(assetPath, stats));
+  if (isWaveformCacheDirectory(cacheDir) && existsSync32(cachePath)) return;
+  const peaks = await decodeAudioPeaks(audioPath);
+  writeWaveformCache(cachePath, peaks);
+}
+function isWaveformCacheDirectory(cacheDir) {
+  return lstatSync3(cacheDir, { throwIfNoEntry: false })?.isDirectory() ?? false;
+}
+function writeWaveformCache(cachePath, peaks) {
+  const cacheDir = dirname23(cachePath);
+  try {
+    mkdirSync5(cacheDir, { mode: 448 });
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+  }
+  if (!isWaveformCacheDirectory(cacheDir)) {
+    throw new Error("Waveform cache must be a directory, not a symlink");
+  }
+  const stagingDir = mkdtempSync(join32(cacheDir, ".waveform-"));
+  try {
+    const stagingPath = join32(stagingDir, "peaks.json");
+    writeFileSync4(stagingPath, JSON.stringify(peaks), { flag: "wx" });
+    renameSync3(stagingPath, cachePath);
+  } finally {
+    try {
+      rmSync4(stagingDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+var VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi|m4v|mxf|mts|m2ts|ts)$/i;
+var AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac|flac)$/i;
+var defaultRunner = spawnSync;
+var FFPROBE_MISSING = "not checked: ffprobe was not found. Install FFmpeg or set HYPERFRAMES_FFPROBE_PATH.";
+function validateUploadedMedia(filePath, runner = defaultRunner) {
+  const isVideo = VIDEO_EXT.test(filePath);
+  const isAudio = AUDIO_EXT.test(filePath);
+  if (!isVideo && !isAudio) {
+    return { ok: true };
+  }
+  const ffprobe = findFfBinary("ffprobe") ?? (runner === defaultRunner ? void 0 : "ffprobe");
+  if (!ffprobe) return { ok: true, unchecked: FFPROBE_MISSING };
+  const result = runner(
+    ffprobe,
+    ["-v", "error", "-show_entries", "stream=codec_type", "-of", "json", "--", filePath],
+    { windowsHide: true }
+  );
+  if (result.error && process.env[FFPROBE_PATH_ENV]?.trim()) {
+    return {
+      ok: false,
+      reason: `${FFPROBE_PATH_ENV} names "${ffprobe}", which cannot run: fix it or unset it`
+    };
+  }
+  if (result.error?.code === "ENOENT") {
+    return { ok: true, unchecked: FFPROBE_MISSING };
+  }
+  if (result.status !== 0) {
+    return { ok: false, reason: "ffprobe failed to read the media file" };
+  }
+  return checkStreams(String(result.stdout || "{}"), isVideo, isAudio);
+}
+function checkStreams(stdout, isVideo, isAudio) {
+  try {
+    const parsed = JSON.parse(stdout);
+    const streams = parsed.streams ?? [];
+    const hasVideo = streams.some((stream) => stream.codec_type === "video");
+    const hasAudio = streams.some((stream) => stream.codec_type === "audio");
+    if (isVideo && !hasVideo) {
+      return { ok: false, reason: "no supported video stream found" };
+    }
+    if (isAudio && !hasAudio) {
+      return { ok: false, reason: "no supported audio stream found" };
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, reason: "ffprobe returned unreadable media metadata" };
+  }
+}
+function validateUploadedMediaBuffer(fileName, buffer, runner = defaultRunner) {
+  const tempDir = mkdtempSync2(join42(tmpdir2(), "hyperframes-upload-"));
+  const tempPath = join42(tempDir, basename2(fileName));
+  try {
+    writeFileSync23(tempPath, buffer);
+    return validateUploadedMedia(tempPath, runner);
+  } finally {
+    rmSync22(tempDir, { recursive: true, force: true });
+  }
+}
+var DEFAULT_KEEP_PER_FILE = 10;
+function backupKeyForPath(path) {
+  return Buffer2.from(path, "utf-8").toString("base64url");
+}
+function timestampPrefix() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function backupPathForResponse(projectDir, backupPath) {
+  if (!backupPath) return null;
+  const rel = relative22(projectDir, backupPath);
+  if (!rel || rel.startsWith("..")) return null;
+  return rel.split("\\").join("/");
+}
+function snapshotBeforeWrite(projectDir, absPath, options = {}) {
+  if (!isSafePath(projectDir, absPath)) return { backupPath: null };
+  try {
+    const content = readFileSync32(absPath);
+    const relativePath = relative22(projectDir, absPath);
+    const backupDir = join52(projectDir, ".hyperframes", "backup");
+    mkdirWithinProject(projectDir, backupDir);
+    const backupKey = backupKeyForPath(relativePath);
+    const backupPath = nextBackupPath(backupDir, backupKey);
+    writeFileSync32(backupPath, content);
+    pruneBackups(backupDir, backupKey, options.keepPerFile ?? DEFAULT_KEEP_PER_FILE);
+    return { backupPath };
+  } catch (error) {
+    if (isProjectRootMissing(error)) throw error;
+    if (error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) {
+      return { backupPath: null };
+    }
+    return { backupPath: null, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function nextBackupPath(backupDir, backupKey) {
+  const base = `${timestampPrefix()}-${backupKey}`;
+  let candidate = join52(backupDir, base);
+  let counter = 2;
+  while (true) {
+    try {
+      readFileSync32(candidate);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return candidate;
+      }
+      throw error;
+    }
+    candidate = join52(backupDir, `${base}-${counter}`);
+    counter += 1;
+  }
+}
+function pruneBackups(backupDir, backupKey, keepPerFile) {
+  const keep = Math.max(1, Math.floor(keepPerFile));
+  const suffix = `-${backupKey}`;
+  const numberedSuffix = new RegExp(`-${backupKey}-\\d+$`);
+  const matches = readdirSync4(backupDir).filter((name) => name.endsWith(suffix) || numberedSuffix.test(name)).map((name) => join52(backupDir, name)).sort((a, b) => {
+    return b.localeCompare(a);
+  });
+  for (const file of matches.slice(keep)) {
+    try {
+      unlinkSync(file);
+    } catch {
+    }
+  }
+}
+var PROJECT_DIR_MISSING = { error: "not found", why: "project_dir_missing" };
+var projectDirMissing = (c) => c.json(PROJECT_DIR_MISSING, 404);
+function replaceWithProjectDirMissing(c, hostHeaders) {
+  hostHeaders.delete("content-type");
+  c.res = void 0;
+  c.res = Response.json(PROJECT_DIR_MISSING, { status: 404, headers: hostHeaders });
+}
+function applyFileMutations(projectDir, mutations, requestToken, writeFile2 = (path, content) => replaceFileAtomically(path, content, statSync22(path).mode)) {
+  const prepared = mutations.map((mutation) => ({
+    ...mutation,
+    before: mutation.before ?? readFileSync42(mutation.absPath, "utf-8")
+  }));
+  const results = [];
+  const attempted = [];
+  for (const mutation of prepared)
+    assertExpectedVersion(mutation, readFileSync42(mutation.absPath, "utf-8"));
+  try {
+    for (const mutation of prepared) {
+      results.push(applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted));
+    }
+    return results;
+  } catch (error) {
+    const rollbackErrors = [];
+    for (const mutation of attempted.reverse()) {
+      try {
+        if (!mutation.written || readFileSync42(mutation.absPath, "utf-8") === mutation.after)
+          writeFile2(mutation.absPath, mutation.before, "utf-8");
+        clearFileWriteReceipt(mutation.absPath, mutation.version, mutation.writeToken);
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (rollbackErrors.length > 0) {
+      throw new AggregateError(
+        [error, ...rollbackErrors],
+        "File mutation failed and rollback did not complete"
+      );
+    }
+    throw error;
+  }
+}
+function applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted) {
+  const current = readFileSync42(mutation.absPath, "utf-8");
+  assertExpectedVersion(mutation, current);
+  if (mutation.after === mutation.before) {
+    return {
+      ...mutation,
+      before: current,
+      changed: false,
+      backupPath: null,
+      version: fileContentVersion(mutation.before),
+      writeToken: null
+    };
+  }
+  const backup = snapshotBeforeWrite(projectDir, mutation.absPath);
+  if (backup.error) throw new Error(`backup failed: ${backup.error}`);
+  assertExpectedVersion(mutation, readFileSync42(mutation.absPath, "utf-8"));
+  const before = current;
+  const version = fileContentVersion(mutation.after);
+  const writeToken = createWriteToken(requestToken);
+  const attempt = { ...mutation, before, version, writeToken, written: false };
+  attempted.push(attempt);
+  writeFile2(mutation.absPath, mutation.after, "utf-8");
+  attempt.written = true;
+  recordFileWriteReceipt(mutation.absPath, {
+    path: mutation.sourceFile,
+    version,
+    writeToken,
+    overwrote: before
+  });
+  return {
+    ...mutation,
+    before,
+    changed: true,
+    backupPath: backupPathForResponse(projectDir, backup.backupPath),
+    version,
+    writeToken
+  };
+}
+var FileChangedError = class extends Error {
+  constructor(sourceFile) {
+    super("file changed since the timeline was read");
+    this.sourceFile = sourceFile;
+  }
+  sourceFile;
+};
+function assertExpectedVersion(mutation, current) {
+  const stale = mutation.expectedVersion === void 0 ? current !== mutation.before : fileContentVersion(current) !== mutation.expectedVersion;
+  if (stale) throw new FileChangedError(mutation.sourceFile);
+}
+var FONT_STYLE_RE = /<style\b[^>]*data-hf-studio-fonts=(["'])true\1[^>]*>([\s\S]*?)<\/style>/i;
+var ONE_FONT_FACE_RULE = /^@font-face \{(?:[^{}<"'\\]|"(?:[^"\\<\n\r\f]|\\[^<\n\r\f])*"|'(?:[^'\\<\n\r\f]|\\[^<\n\r\f])*')*\}$/;
+function isStudioFontFaceCss(css) {
+  return typeof css === "string" && ONE_FONT_FACE_RULE.test(css);
+}
+function ensureStudioFontFaceCss(html, css) {
+  if (html.includes(css)) return html;
+  const block = FONT_STYLE_RE.exec(html);
+  if (block) {
+    const next = `${(block[2] ?? "").trim()}
+${css}`.trim();
+    return html.replace(block[0], () => `<style data-hf-studio-fonts="true">
+${next}
+</style>`);
+  }
+  const styleTag = `<style data-hf-studio-fonts="true">
+${css}
+</style>`;
+  if (/<\/head>/i.test(html)) return html.replace(/<\/head>/i, () => `  ${styleTag}
+  </head>`);
+  return `${styleTag}
+${html}`;
 }
 var differential = (family) => ({
   family,
@@ -6070,7 +6423,7 @@ function requestSubPath(url, route) {
   return decodeURIComponent(segments.slice(start + routeSegments.length).join("/"));
 }
 async function loadGsapParser() {
-  return import("./gsapParser-DIYYX6JT.js");
+  return import("./gsapParser-GHMVJQLH.js");
 }
 function isDanglingSymlinkInProject(projectDir, lexicalPath) {
   if (!isSafePath(projectDir, dirname32(lexicalPath))) return false;
@@ -6110,7 +6463,7 @@ async function resolveProjectPath(c, adapter, route, opts) {
     }
     return { error: c.json({ error: "forbidden", why: "outside_project" }, 403) };
   }
-  if (opts?.mustExist && !existsSync3(absPath)) {
+  if (opts?.mustExist && !existsSync4(absPath)) {
     return { error: c.json({ error: "not found" }, 404) };
   }
   return { project, filePath, absPath };
@@ -6176,7 +6529,7 @@ function projectHtmlIds(projectDir) {
     if (!rel.endsWith(".html") || isInHiddenOrVendorDir(rel)) continue;
     let html;
     try {
-      html = readFileSync32(join52(projectDir, rel), "utf-8");
+      html = readFileSync52(join62(projectDir, rel), "utf-8");
     } catch {
       continue;
     }
@@ -6205,7 +6558,7 @@ function foldAndCommitElementPatchBatches(projectDir, batches, writeFile2, reque
     resolvedPaths.add(absPath);
     let before;
     try {
-      before = readFileSync32(absPath, "utf-8");
+      before = readFileSync52(absPath, "utf-8");
     } catch {
       return { error: "not-found", sourceFile: batch.sourceFile };
     }
@@ -6261,7 +6614,7 @@ function commitElementPatchBatchesWithReceipts(c, projectDir, batches) {
   );
 }
 function writeFileWithReceipt(c, filePath, absPath, html) {
-  const overwrote = readFileSync32(absPath);
+  const overwrote = readFileSync52(absPath);
   replaceFileAtomically(absPath, html, statSync32(absPath).mode);
   const version = fileContentVersion(html);
   const writeToken = createWriteToken(c.req.header("X-Hyperframes-Write-Token"));
@@ -6271,7 +6624,7 @@ function writeFileWithReceipt(c, filePath, absPath, html) {
 function writeMutationResult(c, projectDir, filePath, absPath, html, original) {
   const backup = snapshotBeforeWrite(projectDir, absPath);
   if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-  if (readFileSync32(absPath, "utf-8") !== original) {
+  if (readFileSync52(absPath, "utf-8") !== original) {
     return c.json({ error: "file changed", conflict: true, path: filePath }, 409);
   }
   const { version } = writeFileWithReceipt(c, filePath, absPath, html);
@@ -6326,7 +6679,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(resolve22(projectDir, candidate))) {
+  while (existsSync4(resolve22(projectDir, candidate))) {
     num++;
     candidate = `${cleanBase} (copy ${num})${ext}`;
   }
@@ -6335,7 +6688,7 @@ function generateCopyPath(projectDir, originalPath) {
 function walkFiles(dir, filter) {
   const results = [];
   for (const entry of readableEntries(dir)) {
-    const full2 = join52(dir, entry.name);
+    const full2 = join62(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".thumbnails" || entry.name === "renders" || entry.name === ".transcode-cache")
         continue;
@@ -6360,7 +6713,7 @@ function readableEntries(dir) {
 }
 function readableText(file) {
   try {
-    return readFileSync32(file, "utf-8");
+    return readFileSync52(file, "utf-8");
   } catch (error) {
     if (skippable(error)) return null;
     throw error;
@@ -6418,7 +6771,7 @@ function occurrences(text2, part) {
 }
 function projectPaths(root, dir = root, prefix = "", ancestors = /* @__PURE__ */ new Set()) {
   return readableEntries(dir).flatMap((entry) => {
-    const [path, full2] = [`${prefix}${entry.name}`, join52(dir, entry.name)];
+    const [path, full2] = [`${prefix}${entry.name}`, join62(dir, entry.name)];
     const real = entry.name === "node_modules" ? null : directoryReal(entry, full2);
     if (real === null || ancestors.has(real) || !isSafePath(root, full2)) return [path];
     return [path, ...projectPaths(root, full2, `${path}/`, /* @__PURE__ */ new Set([...ancestors, real]))];
@@ -6726,7 +7079,7 @@ function containsRawGsapExpression(value) {
   return Object.values(value).some(containsRawGsapExpression);
 }
 async function prepareGsapMutationScript(c, res, firstMutation) {
-  const beforeHtml = readFileSync32(res.absPath, "utf-8");
+  const beforeHtml = readFileSync52(res.absPath, "utf-8");
   let html = beforeHtml;
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
@@ -6801,6 +7154,7 @@ async function applyGsapMutations(c, res, mutations) {
   const prepared = await prepareGsapMutationScript(c, res, firstMutation);
   if (prepared instanceof Response) return prepared;
   const { html, beforeHtml, block } = prepared;
+  let lengthIsAuthored;
   const initialScript = block.scriptText;
   const skippedSelectors = /* @__PURE__ */ new Set();
   const respond = (data, status) => status ? c.json(data, status) : c.json(data);
@@ -6832,7 +7186,9 @@ async function applyGsapMutations(c, res, mutations) {
       for (const selector of result.skippedSelectors) skippedSelectors.add(selector);
     }
     if (HOLD_SYNC_MUTATION_TYPES.has(mutation.type)) {
-      newScript = writer === "acorn" ? syncPositionHoldsBeforeKeyframes(newScript) : (await loadGsapParser()).syncPositionHoldsBeforeKeyframes(newScript);
+      lengthIsAuthored ??= !lengthIsTimeline(res.project.dir, res.filePath);
+      if (lengthIsAuthored) newScript = trimTrailingKeyframeSpans(previousScript, newScript);
+      newScript = writer === "acorn" ? syncPositionHoldsBeforeKeyframes(newScript, previousScript) : (await loadGsapParser()).syncPositionHoldsBeforeKeyframes(newScript, previousScript);
     }
     mutationChanges.push(newScript !== previousScript);
     block.scriptText = newScript;
@@ -6840,7 +7196,7 @@ async function applyGsapMutations(c, res, mutations) {
   const changed = block.scriptText !== initialScript;
   const newHtml = changed ? block.replaceScript(block.scriptText) : html;
   let backupPath = null;
-  if (readFileSync32(res.absPath, "utf-8") !== beforeHtml) {
+  if (readFileSync52(res.absPath, "utf-8") !== beforeHtml) {
     return c.json({ error: "file changed during GSAP mutation", conflict: true }, 409);
   }
   if (changed) {
@@ -7531,7 +7887,7 @@ async function foldAtomicCutFile(c, file, absPath, before, writer) {
       for (const selector of result.skippedSelectors) skippedSelectors.add(selector);
     }
     if (script !== block.scriptText) {
-      script = writer === "acorn" ? syncPositionHoldsBeforeKeyframes(script) : (await loadGsapParser()).syncPositionHoldsBeforeKeyframes(script);
+      script = writer === "acorn" ? syncPositionHoldsBeforeKeyframes(script, block.scriptText) : (await loadGsapParser()).syncPositionHoldsBeforeKeyframes(script, block.scriptText);
       after = block.replaceScript(script);
     }
   }
@@ -7570,9 +7926,9 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
     const base = dotIdx > 0 ? name.slice(0, dotIdx) : name;
     const MAX_COPY_INDEX = 1e4;
     let n = 1;
-    if (existsSync3(finalPath)) {
+    if (existsSync4(finalPath)) {
       n = 2;
-      while (n < MAX_COPY_INDEX && existsSync3(resolve22(targetDir, `${base} (${n})${ext}`))) n++;
+      while (n < MAX_COPY_INDEX && existsSync4(resolve22(targetDir, `${base} (${n})${ext}`))) n++;
       if (n >= MAX_COPY_INDEX) {
         skipped.push(name);
         continue;
@@ -7606,7 +7962,7 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
       if (n >= MAX_COPY_INDEX) skipped.push(name);
       continue;
     }
-    const relativePath = subDir ? join52(subDir, finalName) : finalName;
+    const relativePath = subDir ? join62(subDir, finalName) : finalName;
     uploaded.push(relativePath);
     if (validation.unchecked) unchecked.push({ name: finalName, reason: validation.unchecked });
     if (isAudioFile(finalName)) {
@@ -7639,7 +7995,7 @@ function registerFileRoutes(api, adapter) {
       if (stat22.size > MAX_TEXT_READ_BYTES) {
         return c.json({ error: "too large to read as text", why: "too_large" }, 413);
       }
-      const content = readFileSync32(fd);
+      const content = readFileSync52(fd);
       const version = fileContentVersion(content);
       c.header("ETag", version);
       if (content.subarray(0, GIT_BINARY_SNIFF_BYTES).includes(0)) {
@@ -7664,7 +8020,7 @@ function registerFileRoutes(api, adapter) {
     if (expectedVersion === null && !createOnly) {
       let currentContent = null;
       try {
-        currentContent = readFileSync32(res.absPath);
+        currentContent = readFileSync52(res.absPath);
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
           throw error;
@@ -7690,7 +8046,7 @@ function registerFileRoutes(api, adapter) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
           throw error;
         }
-        const currentContent = readFileSync32(res.absPath);
+        const currentContent = readFileSync52(res.absPath);
         return c.json(
           {
             error: "file conflict",
@@ -7720,7 +8076,7 @@ function registerFileRoutes(api, adapter) {
         );
       }
       try {
-        const currentContent = readFileSync32(fd);
+        const currentContent = readFileSync52(fd);
         overwrote = currentContent;
         const currentVersion = fileContentVersion(currentContent);
         if (expectedVersion !== currentVersion) {
@@ -7796,7 +8152,7 @@ function registerFileRoutes(api, adapter) {
     }
     let before;
     try {
-      before = readFileSync32(ctx.absPath, "utf-8");
+      before = readFileSync52(ctx.absPath, "utf-8");
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
         throw error;
@@ -7825,7 +8181,7 @@ function registerFileRoutes(api, adapter) {
     }
     const backup = snapshotBeforeWrite(ctx.project.dir, ctx.absPath);
     if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-    const current = readFileSync32(ctx.absPath, "utf-8");
+    const current = readFileSync52(ctx.absPath, "utf-8");
     if (current !== before) {
       const currentVersion2 = fileContentVersion(current);
       return c.json({ error: "file conflict", currentVersion: currentVersion2, currentContent: current }, 409);
@@ -7853,12 +8209,12 @@ function registerFileRoutes(api, adapter) {
   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 = readFileSync32(ctx.absPath, "utf-8");
+    const originalContent = readFileSync52(ctx.absPath, "utf-8");
     return writeIfChanged(
       c,
       ctx.project.dir,
@@ -7871,7 +8227,7 @@ function registerFileRoutes(api, adapter) {
   api.post("/projects/:id/file-mutations/remove-elements/*", async (c) => {
     const ctx = await resolveFileMutationContext(c, adapter, "remove-elements");
     if ("error" in ctx) return ctx.error;
-    if (!existsSync3(ctx.absPath)) {
+    if (!existsSync4(ctx.absPath)) {
       return c.json({ error: "not found" }, 404);
     }
     const body = await c.req.json().catch(() => null);
@@ -7879,7 +8235,7 @@ function registerFileRoutes(api, adapter) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return c.json({ error: "targets required" }, 400);
     }
-    const originalContent = readFileSync32(ctx.absPath, "utf-8");
+    const originalContent = readFileSync52(ctx.absPath, "utf-8");
     return writeIfChanged(
       c,
       ctx.project.dir,
@@ -7915,7 +8271,7 @@ function registerFileRoutes(api, adapter) {
         seen.add(absPath);
         let before;
         try {
-          before = readFileSync32(absPath, "utf-8");
+          before = readFileSync52(absPath, "utf-8");
         } catch {
           return c.json({ error: `not found: ${file.path}` }, 404);
         }
@@ -7942,7 +8298,7 @@ function registerFileRoutes(api, adapter) {
         prepared.push(folded);
       }
       for (const file of prepared) {
-        const current = readFileSync32(file.absPath, "utf-8");
+        const current = readFileSync52(file.absPath, "utf-8");
         if (current !== file.before) {
           return c.json(
             {
@@ -7985,7 +8341,7 @@ function registerFileRoutes(api, adapter) {
         const conflicts = [];
         for (const file of written.reverse()) {
           try {
-            const current = readFileSync32(file.absPath, "utf-8");
+            const current = readFileSync52(file.absPath, "utf-8");
             if (current !== file.after) {
               conflicts.push(file.path);
               continue;
@@ -8033,7 +8389,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 = readFileSync32(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -8095,7 +8451,7 @@ function registerFileRoutes(api, adapter) {
     for (let attempt = 1; ; attempt += 1) {
       let originalContent;
       try {
-        originalContent = readFileSync32(ctx.absPath, "utf-8");
+        originalContent = readFileSync52(ctx.absPath, "utf-8");
       } catch {
         return c.json({ error: "not found" }, 404);
       }
@@ -8207,7 +8563,7 @@ function registerFileRoutes(api, adapter) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync32(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -8263,7 +8619,7 @@ function registerFileRoutes(api, adapter) {
     ).map((entry) => ({ target: entry.target, track: entry.track }));
     let originalContent;
     try {
-      originalContent = readFileSync32(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -8292,7 +8648,7 @@ function registerFileRoutes(api, adapter) {
     if ("error" in parsed) return parsed.error;
     let content;
     try {
-      content = readFileSync32(ctx.absPath, "utf-8");
+      content = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c.json({ exists: false });
     }
@@ -8306,7 +8662,7 @@ function registerFileRoutes(api, adapter) {
     if (!Array.isArray(body?.targets)) return c.json({ error: "targets required" }, 400);
     let content;
     try {
-      content = readFileSync32(ctx.absPath, "utf-8");
+      content = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c.json({ exists: body.targets.map(() => false) });
     }
@@ -8323,7 +8679,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);
     }
     const isDirectory = statSync32(res.absPath, { throwIfNoEntry: false })?.isDirectory() ?? false;
@@ -8340,7 +8696,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);
@@ -8350,7 +8706,7 @@ function registerFileRoutes(api, adapter) {
     }
     ensureDir(project.dir, destAbs);
     try {
-      createFileAtomically(destAbs, readFileSync32(srcAbs));
+      createFileAtomically(destAbs, readFileSync52(srcAbs));
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
         throw error;
@@ -8394,7 +8750,7 @@ function registerFileRoutes(api, adapter) {
       mustExist: true
     });
     if ("error" in res) return res.error;
-    const html = readFileSync32(res.absPath, "utf-8");
+    const html = readFileSync52(res.absPath, "utf-8");
     const etag = `${fileContentVersion(html).slice(0, -1)}:gsap-animations:v1"`;
     const headers = { ETag: etag, "Cache-Control": "no-cache" };
     if (c.req.header("If-None-Match") === etag) return new Response(null, { status: 304, headers });
@@ -8451,7 +8807,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 = readFileSync32(res.absPath, "utf-8");
+    const current = readFileSync52(res.absPath, "utf-8");
     if (current !== body.expected) {
       return c.json({ ok: true, restored: false, conflict: true });
     }
@@ -8459,176 +8815,6 @@ function registerFileRoutes(api, adapter) {
     return c.json({ ok: true, restored: true, conflict: false });
   });
 }
-function rewriteRelativePaths(root, compPath, projectDir) {
-  const assetExists = (path) => existsSync42(join62(projectDir, path));
-  rewriteAssetPaths(
-    root.querySelectorAll("[src], [href]"),
-    compPath,
-    (el, attr) => el.getAttribute(attr),
-    (el, attr, value) => el.setAttribute(attr, value),
-    assetExists
-  );
-  rewriteInlineStyleAssetUrls(
-    root.querySelectorAll("[style]"),
-    compPath,
-    (el) => el.getAttribute("style"),
-    (el, value) => el.setAttribute("style", value),
-    assetExists
-  );
-  for (const styleEl of root.querySelectorAll("style")) {
-    styleEl.textContent = rewriteCssAssetUrls(styleEl.textContent || "", compPath, assetExists);
-  }
-}
-function escapeLeadingDigitIdent(id) {
-  return `\\${id.charCodeAt(0).toString(16)} ${id.slice(1)}`;
-}
-var REGEXP_SPECIALS = /[.*+?^${}()|[\]\\]/g;
-function fixDigitLeadingIdSelectors(root) {
-  const digitIds = /* @__PURE__ */ new Set();
-  for (const el of root.querySelectorAll("[id]")) {
-    const id = el.getAttribute("id");
-    if (id && /^\d/.test(id)) digitIds.add(id);
-  }
-  if (digitIds.size === 0) return;
-  for (const styleEl of root.querySelectorAll("style")) {
-    let css = styleEl.textContent || "";
-    for (const id of digitIds) {
-      const pattern = new RegExp(`#${id.replace(REGEXP_SPECIALS, "\\$&")}(?![\\w-])`, "g");
-      css = css.replace(pattern, `#${escapeLeadingDigitIdent(id)}`);
-    }
-    styleEl.textContent = css;
-  }
-}
-function extractFullDocumentParts(rawHtml, compPath, projectDir) {
-  const { document: doc } = parseHTML(rawHtml);
-  const rewriteTargets = [doc.head, doc.body].filter(Boolean);
-  for (const target of rewriteTargets) {
-    rewriteRelativePaths(target, compPath, projectDir);
-  }
-  fixDigitLeadingIdSelectors(doc);
-  const headContent = doc.head?.innerHTML ?? "";
-  const bodyContent = doc.body?.innerHTML ?? "";
-  const htmlEl = doc.documentElement;
-  const htmlAttrs = extractElementAttrs(htmlEl);
-  const bodyAttrs = doc.body ? extractElementAttrs(doc.body) : "";
-  return { headContent, bodyContent, htmlAttrs, bodyAttrs };
-}
-function extractTemplateInnerHtml(rawComp) {
-  const { document: doc } = parseHTML(rawComp);
-  const template = doc.querySelector("template");
-  return template ? template.innerHTML : null;
-}
-function escapeAttrValue(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function extractElementAttrs(el) {
-  const parts = [];
-  for (let i = 0; i < el.attributes.length; i++) {
-    const attr = el.attributes[i];
-    if (attr.value === "") {
-      parts.push(attr.name);
-    } else {
-      parts.push(`${attr.name}="${escapeAttrValue(attr.value)}"`);
-    }
-  }
-  return parts.join(" ");
-}
-var NON_RENDERED_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "LINK", "META", "TEMPLATE", "NOSCRIPT"]);
-function promoteTemplateCompositionId(rawComp, body) {
-  let templateCompositionId;
-  for (const tag of rawComp.matchAll(/<template\b[^>]*/gi)) {
-    const id = /\bdata-composition-id\s*=\s*["']([^"']+)["']/i.exec(tag[0] ?? "")?.[1];
-    if (id) {
-      templateCompositionId = id;
-      break;
-    }
-  }
-  if (!templateCompositionId) return;
-  if (body.querySelector("[data-composition-id]")) return;
-  const root = Array.from(body.children).find((el) => !NON_RENDERED_TAGS.has(el.tagName));
-  root?.setAttribute("data-composition-id", templateCompositionId);
-}
-function tagRootCompositionFile(bodyHtml, compPath) {
-  const match = bodyHtml.match(/<[a-zA-Z][^>]*\bdata-composition-id=/);
-  if (match?.index == null) return bodyHtml;
-  const tagEnd = bodyHtml.indexOf(">", match.index);
-  if (tagEnd === -1) return bodyHtml;
-  if (bodyHtml.slice(match.index, tagEnd).includes("data-composition-file")) return bodyHtml;
-  return bodyHtml.slice(0, tagEnd) + ` data-composition-file="${compPath}"` + bodyHtml.slice(tagEnd);
-}
-function rootHeadContent(rootHtml) {
-  return rootHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i)?.[1] ?? "";
-}
-function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
-  const compFile = join62(projectDir, compPath);
-  if (!existsSync42(compFile)) return null;
-  const rawComp = rawOverride ?? readFileSync42(compFile, "utf-8");
-  let compHeadContent = "";
-  let rewrittenContent;
-  let htmlAttrs = "";
-  let bodyAttrs = "";
-  const templateInner = extractTemplateInnerHtml(rawComp);
-  if (templateInner != null) {
-    const { document: contentDoc } = parseHTML(
-      `<!DOCTYPE html><html><head></head><body>${templateInner}</body></html>`
-    );
-    rewriteRelativePaths(contentDoc, compPath, projectDir);
-    fixDigitLeadingIdSelectors(contentDoc);
-    promoteTemplateCompositionId(rawComp, contentDoc.body);
-    rewrittenContent = contentDoc.body.innerHTML || templateInner;
-  } else if (isFullHtmlDocument(rawComp)) {
-    const parts = extractFullDocumentParts(rawComp, compPath, projectDir);
-    compHeadContent = parts.headContent;
-    rewrittenContent = parts.bodyContent;
-    htmlAttrs = parts.htmlAttrs;
-    bodyAttrs = parts.bodyAttrs;
-  } else {
-    const { document: contentDoc } = parseHTML(
-      `<!DOCTYPE html><html><head></head><body>${rawComp}</body></html>`
-    );
-    rewriteRelativePaths(contentDoc, compPath, projectDir);
-    fixDigitLeadingIdSelectors(contentDoc);
-    rewrittenContent = contentDoc.body.innerHTML || rawComp;
-  }
-  rewrittenContent = stripEmbeddedRuntimeScripts(rewrittenContent);
-  const { document: scriptsDoc } = parseHTML(
-    `<!DOCTYPE html><html><head></head><body>${rewrittenContent}</body></html>`
-  );
-  deferScriptsUntilFonts(scriptsDoc);
-  rewrittenContent = scriptsDoc.body.innerHTML;
-  rewrittenContent = tagRootCompositionFile(rewrittenContent, compPath);
-  const indexPath = join62(projectDir, "index.html");
-  let headContent = "";
-  if (existsSync42(indexPath)) headContent = rootHeadContent(readFileSync42(indexPath, "utf-8"));
-  if (baseHref && !hasBaseElement(headContent)) {
-    headContent = `<base href="${baseHref}">
-${headContent}`;
-  }
-  if (compHeadContent) headContent += `
-${compHeadContent}`;
-  headContent = stripEmbeddedRuntimeScripts(headContent);
-  headContent += `
-<script ${RUNTIME_BOOTSTRAP_ATTR}="1" src="${runtimeUrl}"></script>`;
-  if (!headContent.includes("gsap")) {
-    headContent += `
-<script src="${gsapCdnDist()}gsap.min.js"></script>`;
-  }
-  const htmlOpen = htmlAttrs ? `<html ${htmlAttrs}>` : "<html>";
-  const bodyOpen = bodyAttrs ? `<body ${bodyAttrs}>` : "<body>";
-  return `<!DOCTYPE html>
-${htmlOpen}
-<head>
-${headContent}
-</head>
-${bodyOpen}
-<script>window.__timelines=window.__timelines||{};</script>
-${rewrittenContent}
-</body>
-</html>`;
-}
-function hasBaseElement(html) {
-  return parseHTML(html).document.querySelector("base") !== null;
-}
 var ALWAYS_AFFECTS = ["hyperframes.json", ...STUDIO_SIGNATURE_MANIFEST_PATHS];
 var REFERENCE = /\b(?:src|href|poster|data-composition-src)\s*=\s*(?:"([^"\n]*)"|'([^'\n]*)')|url\(\s*(?:"([^"\n]*)"|'([^'\n]*)'|([^"'\s)]+))/gi;
 var pathKey = process.platform === "darwin" || process.platform === "win32" ? (path) => resolve32(path).toLowerCase() : (path) => resolve32(path);
@@ -8763,7 +8949,7 @@ function readStudioMotionManifestContent(projectDir) {
   const manifestPath = join8(projectDir, STUDIO_MOTION_PATH);
   if (!existsSync5(manifestPath)) return "";
   try {
-    return readFileSync52(manifestPath, "utf-8");
+    return readFileSync62(manifestPath, "utf-8");
   } catch {
     return "";
   }
@@ -8905,7 +9091,7 @@ function parsePreviewVariablesParam(raw) {
 }
 function variablesEtagSalt(raw) {
   if (!raw) return "";
-  return `:vars:${createHash4("sha1").update(raw).digest("hex").slice(0, 12)}`;
+  return `:vars:${createHash23("sha1").update(raw).digest("hex").slice(0, 12)}`;
 }
 function previewVariablesFromRequest(rawVariables) {
   const parse22 = parsePreviewVariablesParam(rawVariables);
@@ -8945,13 +9131,13 @@ function resolveProjectMainHtml(projectDir, projectId) {
   recordPreviewRead(projectDir, blockHtmlPath);
   if (existsSync5(indexPath)) {
     return {
-      html: readFileSync52(indexPath, "utf-8"),
+      html: readFileSync62(indexPath, "utf-8"),
       compositionPath: "index.html"
     };
   }
   if (existsSync5(blockHtmlPath)) {
     return {
-      html: readFileSync52(blockHtmlPath, "utf-8"),
+      html: readFileSync62(blockHtmlPath, "utf-8"),
       compositionPath: `${projectId}.html`
     };
   }
@@ -9082,7 +9268,7 @@ ${etag}`;
   function pinSubCompHfIds(compFile, compPath) {
     if (!/\.html?$/i.test(compPath)) return void 0;
     try {
-      return ensureHfIds(readFileSync52(compFile, "utf-8"));
+      return ensureHfIds(readFileSync62(compFile, "utf-8"));
     } catch {
       return null;
     }
@@ -9101,7 +9287,7 @@ ${etag}`;
     if (!compFile || !existsSync5(compFile) || !statSync42(compFile).isFile()) {
       return c.text("not found", 404);
     }
-    const compPathHash = createHash4("sha1").update(compPath).digest("hex");
+    const compPathHash = createHash23("sha1").update(compPath).digest("hex");
     const capture = c.req.query(PREVIEW_CAPTURE_PARAM) !== void 0;
     const etag = `"comp:v2:${compPathHash}:${signature}${variablesEtagSalt(vars.raw)}${capture ? ":capture" : ""}"`;
     const ifNoneMatch = c.req.header("If-None-Match");
@@ -9193,7 +9379,7 @@ ${etag}`;
       recordProxyRequest();
       servedContentType = PROXY_VARIANT_CONFIG[proxyVariant].contentType;
     }
-    const textBuffer = isText ? Buffer.from(readFileSync52(file, "utf-8"), "utf-8") : null;
+    const textBuffer = isText ? Buffer.from(readFileSync62(file, "utf-8"), "utf-8") : null;
     const totalSize = textBuffer ? textBuffer.length : statSync42(servedPath).size;
     const bodyFor = (start, end) => textBuffer ? new Uint8Array(textBuffer.subarray(start, end + 1)) : (
       // Node's web stream type and the DOM one do not overlap for tsc on
@@ -9252,7 +9438,7 @@ async function lintUncoveredHtml(adapter, projectDir, htmlFiles, coveredFiles) {
   const findings = [];
   for (const file of htmlFiles) {
     if (coveredFiles.has(file)) continue;
-    const content = readFileSync62(join9(projectDir, file), "utf-8");
+    const content = readFileSync72(join9(projectDir, file), "utf-8");
     const result = await adapter.lint(content, { filePath: file, isSubComposition: true });
     for (const finding of result?.findings ?? []) {
       findings.push({ ...finding, file });
@@ -9418,7 +9604,7 @@ function registerRenderRoutes(api, adapter) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync72(job.outputPath);
+    const content = readFileSync8(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -9436,7 +9622,7 @@ function registerRenderRoutes(api, adapter) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync72(job.outputPath);
+    const content = readFileSync8(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -9469,7 +9655,7 @@ function registerRenderRoutes(api, adapter) {
     if (!fp) return c.json({ error: "forbidden" }, 403);
     if (!existsSync6(fp)) return c.json({ error: "not found" }, 404);
     const contentType = renderContentType(fp);
-    const content = readFileSync72(fp);
+    const content = readFileSync8(fp);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -9494,7 +9680,7 @@ function registerRenderRoutes(api, adapter) {
       let audioLoweredDb;
       if (existsSync6(metaPath)) {
         try {
-          const meta = JSON.parse(readFileSync72(metaPath, "utf-8"));
+          const meta = JSON.parse(readFileSync8(metaPath, "utf-8"));
           if (meta.status === "failed" && !existsSync6(fp)) status = "failed";
           if (meta.durationMs) durationMs = meta.durationMs;
           if (typeof meta.audioLoweredDb === "number") audioLoweredDb = meta.audioLoweredDb;
@@ -9702,7 +9888,7 @@ function registerImageThumbnailRoutes(api, adapter) {
   api.get("/projects/:id/image-thumbnail/*", async (c) => {
     try {
       const { path, info } = await resolveSource(adapter, c.req.param("id"), c.req.url);
-      const key = createHash23("sha256").update(JSON.stringify([path, info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs])).digest("hex");
+      const key = createHash32("sha256").update(JSON.stringify([path, info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs])).digest("hex");
       const etag = `"${key}"`;
       c.header("ETag", etag);
       c.header("Cache-Control", "private, no-cache");
@@ -9727,84 +9913,6 @@ function registerImageThumbnailRoutes(api, adapter) {
     }
   });
 }
-var ROOT_COMPOSITION = "index.html";
-var COMPOSITION_SRC = /\bdata-composition-src\s*=\s*(["'])(.*?)\1/g;
-function projectReader(projectDir) {
-  const sources = /* @__PURE__ */ new Map();
-  return (compPath) => {
-    if (!sources.has(compPath)) {
-      const file = resolveWithinProject(projectDir, compPath);
-      let source = null;
-      try {
-        source = file ? readFileSync8(file, "utf-8") : null;
-      } catch {
-      }
-      sources.set(compPath, source);
-    }
-    return sources.get(compPath) ?? null;
-  };
-}
-function normalizeSource(src) {
-  if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) return null;
-  const path = src.split(/[?#]/)[0]?.replace(/^\.?\//, "") ?? "";
-  return path || null;
-}
-function closureOf(read, compPath) {
-  const closure = /* @__PURE__ */ new Set();
-  const visit = (path) => {
-    if (closure.has(path)) return;
-    closure.add(path);
-    for (const match of (read(path) ?? "").matchAll(COMPOSITION_SRC)) {
-      const mounted = normalizeSource(match[2] ?? "");
-      if (mounted) visit(mounted);
-    }
-  };
-  visit(compPath);
-  return closure;
-}
-var inputSignatures = /* @__PURE__ */ new Map();
-var rootMemos = /* @__PURE__ */ new Map();
-var sha1 = (text2) => createHash32("sha1").update(text2).digest("hex");
-function rootHashes(read) {
-  const source = read(ROOT_COMPOSITION) ?? "";
-  return { root: sha1(source), head: sha1(rootHeadContent(source)) };
-}
-function compositionInputSignature(projectDir, compPath, projectSignature) {
-  const key = `${projectDir}\0${compPath}`;
-  const known = inputSignatures.get(key);
-  if (known?.projectSignature === projectSignature) return known.inputSignature;
-  const read = projectReader(projectDir);
-  const comp = normalizeSource(compPath) ?? compPath;
-  const inputs = closureOf(read, comp).add(ROOT_COMPOSITION);
-  const excluded = new Set(
-    [...closureOf(read, ROOT_COMPOSITION)].filter((path) => !inputs.has(path))
-  );
-  let inputSignature;
-  if (comp === ROOT_COMPOSITION) {
-    inputSignature = createProjectSignature(projectDir, excluded);
-  } else {
-    const hashes = rootHashes(read);
-    if (!rootMemos.has(projectDir)) rootMemos.set(projectDir, { ...hashes, affected: null });
-    inputSignature = `${createProjectSignature(projectDir, excluded.add(ROOT_COMPOSITION))}:${hashes.head}`;
-  }
-  inputSignatures.set(key, { projectSignature, inputSignature });
-  return inputSignature;
-}
-function compositionsAffectedBy(projectDir, changedPath) {
-  const changed = changedPath.replace(/\\/g, "/");
-  const read = projectReader(projectDir);
-  if (changed === ROOT_COMPOSITION) {
-    const now = rootHashes(read);
-    const memo = rootMemos.get(projectDir);
-    if (memo?.root === now.root) return memo.affected;
-    const affected = memo?.head === now.head ? [ROOT_COMPOSITION] : null;
-    rootMemos.set(projectDir, { ...now, affected });
-    return affected;
-  }
-  const mounted = closureOf(read, ROOT_COMPOSITION);
-  if (!mounted.has(changed)) return null;
-  return [...mounted].filter((path) => closureOf(read, path).has(changed));
-}
 var THUMBNAIL_CACHE_VERSION = "v5";
 var THUMBNAIL_MAX_OUTPUT_WIDTH = 240;
 var THUMBNAIL_MAX_OUTPUT_HEIGHT = 135;
@@ -11381,12 +11489,12 @@ export {
   createStudioMotionRenderBodyScript,
   MIME_TYPES,
   getMimeType,
+  buildSubCompositionHtml,
+  compositionsAffectedBy,
   applyFileMutations,
   requestSubPath,
-  buildSubCompositionHtml,
   affectsPreview,
   PREVIEW_BUNDLE_OPTIONS,
-  compositionsAffectedBy,
   createStudioApi,
   duplicateElementInHtml,
   createPreviewDocumentStore,