hyperframes 0.8.56 → 0.8.58

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.8.56" : "0.0.0-dev";
+    VERSION = true ? "0.8.58" : "0.0.0-dev";
   }
 });
 
@@ -4887,7 +4887,7 @@ var require_util = __commonJS({
       return path;
     }
     exports.normalize = normalize3;
-    function join156(aRoot, aPath) {
+    function join157(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -4919,7 +4919,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join156;
+    exports.join = join157;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -5092,7 +5092,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join156(urlGenerate(parsed), sourceURL);
+        sourceURL = join157(urlGenerate(parsed), sourceURL);
       }
       return normalize3(sourceURL);
     }
@@ -13450,8 +13450,8 @@ var require_lines = __commonJS({
             if (isOnlyWhitespace(sliced)) {
               continue;
             }
-            var diff = Math.abs(info.indent - lastIndent);
-            counts[diff] = ~~counts[diff] + 1;
+            var diff2 = Math.abs(info.indent - lastIndent);
+            counts[diff2] = ~~counts[diff2] + 1;
             lastIndent = info.indent;
           }
           var maxCount = -1;
@@ -13477,12 +13477,12 @@ var require_lines = __commonJS({
         Lines2.prototype.isPrecededOnlyByWhitespace = function(pos) {
           var info = this.infos[pos.line - 1];
           var indent = Math.max(info.indent, 0);
-          var diff = pos.column - indent;
-          if (diff <= 0) {
+          var diff2 = pos.column - indent;
+          if (diff2 <= 0) {
             return true;
           }
           var start = info.sliceStart;
-          var end = Math.min(start + diff, info.sliceEnd);
+          var end = Math.min(start + diff2, info.sliceEnd);
           var prefix = info.line.slice(start, end);
           return isOnlyWhitespace(prefix);
         };
@@ -67717,9 +67717,9 @@ function motionBlurWindowIsStatic(plan2, frameIndex, staticFrames) {
   }
   return true;
 }
-function adaptiveSampleCount(diff) {
+function adaptiveSampleCount(diff2) {
   for (const step of ADAPTIVE_SAMPLE_STEPS) {
-    if (diff <= step.maxDiff) return step.samples;
+    if (diff2 <= step.maxDiff) return step.samples;
   }
   return MAX_SAMPLES_PER_FRAME;
 }
@@ -93681,10 +93681,10 @@ function simplifyVolumeKeyframes(keyframes) {
   return sampled;
 }
 function buildVolumeExpression(track, ignoreKeyframes = false) {
-  const trimDuration = track.end - track.start;
+  const trimDuration2 = track.end - track.start;
   const staticVolume = clampVolume(track.volume);
   const keyframes = (ignoreKeyframes ? [] : track.volumeKeyframes ?? []).filter((keyframe) => Number.isFinite(keyframe.time) && Number.isFinite(keyframe.volume)).map((keyframe) => ({
-    time: Math.max(0, Math.min(trimDuration, keyframe.time - track.start)),
+    time: Math.max(0, Math.min(trimDuration2, keyframe.time - track.start)),
     volume: clampVolume(keyframe.volume)
   })).sort((a, b2) => a.time - b2.time);
   if (keyframes.length === 0) return `volume=${formatFilterNumber(staticVolume)}`;
@@ -94044,10 +94044,10 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     const filterParts = [];
     tracks.forEach((track, i) => {
       const delayMs = Math.round(track.start * 1e3);
-      const trimDuration = track.end - track.start + (track.tailSeconds ?? 0);
+      const trimDuration2 = track.end - track.start + (track.tailSeconds ?? 0);
       const volumeFilter = buildVolumeExpression(track, ignoreAutomation);
       filterParts.push(
-        `[${i}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${i}]`
+        `[${i}:a]atrim=0:${formatFilterNumber(trimDuration2)},${volumeFilter},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${i}]`
       );
     });
     const mixInputs = tracks.map((_, i) => `[a${i}]`).join("");
@@ -94150,9 +94150,9 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
   if (!existsSync16(outputDir)) mkdirSync8(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes) => memberTracks.map((track, i) => {
     const delayMs = Math.round(track.start * 1e3);
-    const trimDuration = track.end - track.start + (track.tailSeconds ?? 0);
+    const trimDuration2 = track.end - track.start + (track.tailSeconds ?? 0);
     const volumeFilter = buildVolumeExpression(track, ignoreKeyframes);
-    return `[${i}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${i}]`;
+    return `[${i}:a]atrim=0:${formatFilterNumber(trimDuration2)},${volumeFilter},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${i}]`;
   });
   const mixInputs = memberTracks.map((_, i) => `[a${i}]`).join("");
   const runOnce = async (useNormalize2, ignoreKeyframes = false) => {
@@ -95579,27 +95579,27 @@ function diffGpuParityPngs(pngA, pngB, options = {}) {
   return diffGpuParityFrames(a, b2, options);
 }
 function verifyGpuParity(a, b2, options = {}) {
-  const diff = diffGpuParityFrames(a, b2, options);
+  const diff2 = diffGpuParityFrames(a, b2, options);
   const threshold = options.blackOnlyFractionThreshold ?? DEFAULT_BLACK_ONLY_FRACTION_THRESHOLD;
-  if (diff.blackOnlyInA.fraction > threshold) {
-    const bb = diff.blackOnlyInA.boundingBox;
+  if (diff2.blackOnlyInA.fraction > threshold) {
+    const bb = diff2.blackOnlyInA.boundingBox;
     const region = bb ? ` (bbox ${bb.x},${bb.y} ${bb.width}x${bb.height})` : "";
     return {
       ok: false,
-      reason: `hardware-GPU frame has ${diff.blackOnlyInA.pixels} pixel(s) (${(diff.blackOnlyInA.fraction * 100).toFixed(3)}%) that are solid-black while software-GPU frame has content there${region} \u2014 likely shape-dependent hardware-GPU capture bug`,
-      diff
+      reason: `hardware-GPU frame has ${diff2.blackOnlyInA.pixels} pixel(s) (${(diff2.blackOnlyInA.fraction * 100).toFixed(3)}%) that are solid-black while software-GPU frame has content there${region} \u2014 likely shape-dependent hardware-GPU capture bug`,
+      diff: diff2
     };
   }
-  if (diff.blackOnlyInB.fraction > threshold) {
-    const bb = diff.blackOnlyInB.boundingBox;
+  if (diff2.blackOnlyInB.fraction > threshold) {
+    const bb = diff2.blackOnlyInB.boundingBox;
     const region = bb ? ` (bbox ${bb.x},${bb.y} ${bb.width}x${bb.height})` : "";
     return {
       ok: false,
-      reason: `software-GPU frame has ${diff.blackOnlyInB.pixels} pixel(s) (${(diff.blackOnlyInB.fraction * 100).toFixed(3)}%) that are solid-black while hardware-GPU frame has content there${region} \u2014 unexpected inverse pattern, worth investigating`,
-      diff
+      reason: `software-GPU frame has ${diff2.blackOnlyInB.pixels} pixel(s) (${(diff2.blackOnlyInB.fraction * 100).toFixed(3)}%) that are solid-black while hardware-GPU frame has content there${region} \u2014 unexpected inverse pattern, worth investigating`,
+      diff: diff2
     };
   }
-  return { ok: true, reason: "", diff };
+  return { ok: true, reason: "", diff: diff2 };
 }
 var DEFAULT_PIXEL_CHANNEL_TOLERANCE, DEFAULT_BLACK_SUM_THRESHOLD, DEFAULT_CONTENT_SUM_THRESHOLD, DEFAULT_BLACK_ONLY_FRACTION_THRESHOLD;
 var init_gpuParityDiff = __esm({
@@ -103585,7 +103585,7 @@ var require_compile = __commonJS({
       }
     }
     exports.compileSchema = compileSchema;
-    function resolveRef(root, baseId, ref2) {
+    function resolveRef2(root, baseId, ref2) {
       var _a3;
       ref2 = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref2);
       const schOrFunc = root.refs[ref2];
@@ -103602,7 +103602,7 @@ var require_compile = __commonJS({
         return;
       return root.refs[ref2] = inlineOrCompile.call(this, _sch);
     }
-    exports.resolveRef = resolveRef;
+    exports.resolveRef = resolveRef2;
     function inlineOrCompile(sch) {
       if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
         return sch.schema;
@@ -111061,7 +111061,7 @@ async function checkSkills(opts = {}) {
   const skillNames = Object.keys(latest.skills);
   const root = locateInstall(skillNames, { dir: opts.dir, cwd: opts.cwd, home: opts.home });
   const installed = root ? hashInstalled(root, skillNames) : {};
-  const diff = diffSkills(installed, latest);
+  const diff2 = diffSkills(installed, latest);
   const removedResult = root ? detectRemoved(root, latest, { cwd: opts.cwd, home: opts.home }) : { removed: [], lockMissing: false };
   const { removed, lockMissing } = removedResult;
   return {
@@ -111070,9 +111070,9 @@ async function checkSkills(opts = {}) {
     scope: root?.scope ?? null,
     // Removed skills also mean the install isn't reconciled with the manifest —
     // `skills update` now prunes them, so they count toward "update available".
-    updateAvailable: diff.updateAvailable || removed.length > 0,
-    summary: { ...diff.summary, removed: removed.length },
-    skills: [...diff.skills, ...removed],
+    updateAvailable: diff2.updateAvailable || removed.length > 0,
+    summary: { ...diff2.summary, removed: removed.length },
+    skills: [...diff2.skills, ...removed],
     lockMissing
   };
 }
@@ -121471,8 +121471,8 @@ import {
   existsSync as existsSync37,
   ftruncateSync as ftruncateSync2,
   openSync as openSync8,
-  readFileSync as readFileSync42,
-  writeFileSync as writeFileSync42,
+  readFileSync as readFileSync52,
+  writeFileSync as writeFileSync52,
   writeSync as writeSync2,
   mkdirSync as mkdirSync32,
   unlinkSync as unlinkSync23,
@@ -121502,14 +121502,15 @@ import { mkdirSync as mkdirSync22, readdirSync as readdirSync32, readFileSync as
 import { Buffer as Buffer2 } from "buffer";
 import { join as join52, relative as relative22 } from "path";
 import { createHash as createHash22, randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync211, readFileSync as readFileSync32, realpathSync as realpathSync8 } from "fs";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync42 } from "fs";
+import { existsSync as existsSync211, readFileSync as readFileSync42, realpathSync as realpathSync8 } from "fs";
 import { randomUUID as randomUUID22 } from "crypto";
 import { dirname as dirname22, relative as relative32, resolve as resolve24, sep as sep22 } from "path";
-import { createReadStream as createReadStream3, existsSync as existsSync52, readFileSync as readFileSync72, statSync as statSync32 } from "fs";
+import { createReadStream as createReadStream3, existsSync as existsSync52, readFileSync as readFileSync82, statSync as statSync32 } from "fs";
 import { Readable as Readable2 } from "stream";
 import { join as join82, resolve as resolve42 } from "path";
 import { createHash as createHash32 } from "crypto";
-import { existsSync as existsSync42, readFileSync as readFileSync52 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync62 } from "fs";
 import { join as join72 } from "path";
 import {
   closeSync as closeSync22,
@@ -121517,35 +121518,35 @@ import {
   fstatSync as fstatSync4,
   ftruncateSync as ftruncateSync22,
   openSync as openSync22,
-  readFileSync as readFileSync62,
-  writeFileSync as writeFileSync52,
+  readFileSync as readFileSync72,
+  writeFileSync as writeFileSync62,
   writeSync as writeSync22
 } from "fs";
-import { readFileSync as readFileSync82 } from "fs";
+import { readFileSync as readFileSync92 } from "fs";
 import { join as join92 } from "path";
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync62, readFileSync as readFileSync92, mkdirSync as mkdirSync42, unlinkSync as unlinkSync32, readdirSync as readdirSync52, statSync as statSync42 } from "fs";
+import { existsSync as existsSync62, readFileSync as readFileSync102, mkdirSync as mkdirSync42, unlinkSync as unlinkSync32, readdirSync as readdirSync52, statSync as statSync42 } from "fs";
 import { join as join102 } from "path";
 import {
   existsSync as existsSync72,
   mkdirSync as mkdirSync52,
-  readFileSync as readFileSync102,
+  readFileSync as readFileSync112,
   readdirSync as readdirSync62,
   renameSync as renameSync32,
   rmSync as rmSync42,
   statSync as statSync52,
   unlinkSync as unlinkSync42,
-  writeFileSync as writeFileSync62
+  writeFileSync as writeFileSync72
 } from "fs";
 import { join as join112 } from "path";
 import { createHash as createHash42, randomUUID as randomUUID32 } from "crypto";
-import { existsSync as existsSync82, readFileSync as readFileSync112, statSync as statSync62 } from "fs";
+import { existsSync as existsSync82, readFileSync as readFileSync122, statSync as statSync62 } from "fs";
 import { join as join122 } from "path";
 import { closeSync as closeSync32, constants as constants22, fstatSync as fstatSync22, openSync as openSync32, readSync as readSync2 } from "fs";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 import { existsSync as existsSync92, mkdirSync as mkdirSync62 } from "fs";
 import { basename as basename22, dirname as dirname42, extname as extname22, join as join132 } from "path";
-import { existsSync as existsSync102, readFileSync as readFileSync122 } from "fs";
+import { existsSync as existsSync102, readFileSync as readFileSync132 } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join142 } from "path";
 function shouldIgnoreDir(rel) {
@@ -121956,6 +121957,13 @@ function recordFileWriteReceipt(absPath, receipt) {
   current2.push({ ...receipt, recordedAt: now });
   receipts.set(absPath, current2);
 }
+function clearFileWriteReceipt(absPath, version2, writeToken) {
+  const current2 = (receipts.get(absPath) ?? []).filter(
+    (entry) => entry.version !== version2 || entry.writeToken !== writeToken
+  );
+  if (current2.length > 0) receipts.set(absPath, current2);
+  else receipts.delete(absPath);
+}
 function identifyFileWrite(absPath, expectedVersion) {
   const now = Date.now();
   const current2 = (receipts.get(absPath) ?? []).filter(
@@ -121971,6 +121979,76 @@ function identifyFileWrite(absPath, expectedVersion) {
   const { path, version: version2, writeToken } = receipt;
   return { path, version: version2, writeToken };
 }
+function applyFileMutations(projectDir, mutations, requestToken, writeFile3 = writeFileSync42) {
+  const prepared = mutations.map((mutation) => ({
+    ...mutation,
+    before: mutation.before ?? readFileSync32(mutation.absPath, "utf-8")
+  }));
+  const results = [];
+  const attempted = [];
+  try {
+    for (const mutation of prepared) {
+      results.push(applyOneMutation(projectDir, mutation, requestToken, writeFile3, attempted));
+    }
+    return results;
+  } catch (error) {
+    const rollbackErrors = [];
+    for (const mutation of attempted.reverse()) {
+      try {
+        writeFile3(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, writeFile3, attempted) {
+  const current2 = readFileSync32(mutation.absPath, "utf-8");
+  assertExpectedVersion(mutation.expectedVersion, current2);
+  if (mutation.after === mutation.before) {
+    return {
+      ...mutation,
+      before: current2,
+      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}`);
+  const before3 = current2;
+  const version2 = fileContentVersion(mutation.after);
+  const writeToken = createWriteToken(requestToken);
+  attempted.push({ ...mutation, before: before3, version: version2, writeToken });
+  writeFile3(mutation.absPath, mutation.after, "utf-8");
+  recordFileWriteReceipt(mutation.absPath, {
+    path: mutation.sourceFile,
+    version: version2,
+    writeToken
+  });
+  return {
+    ...mutation,
+    before: before3,
+    changed: true,
+    backupPath: backupPathForResponse(projectDir, backup.backupPath),
+    version: version2,
+    writeToken
+  };
+}
+function assertExpectedVersion(expectedVersion, current2) {
+  if (expectedVersion !== void 0 && fileContentVersion(current2) !== expectedVersion) {
+    throw new Error("file changed since the timeline was read");
+  }
+}
 function descendants(root, selector) {
   const found = Array.from(root.querySelectorAll(selector));
   for (const template of root.querySelectorAll("template")) {
@@ -122032,7 +122110,7 @@ function validateDependencyGraph(projectDir, targetAbs, sourceAbs) {
     }
     if (visited.has(file)) return;
     visiting.add(file);
-    const source = readFileSync32(file, "utf-8");
+    const source = readFileSync42(file, "utf-8");
     const { document: document2 } = compositionRoot(source);
     for (const host of descendants(document2, "[data-composition-src]")) {
       const dependency = host.getAttribute("data-composition-src");
@@ -122096,7 +122174,7 @@ function insertCompositionIntoSource(input2) {
   const targetAbs = canonicalProjectFile(input2.projectDir, input2.targetPath);
   const sourceAbs = canonicalProjectFile(input2.projectDir, input2.sourcePath);
   validateDependencyGraph(input2.projectDir, targetAbs, sourceAbs);
-  const source = readFileSync32(sourceAbs, "utf-8");
+  const source = readFileSync42(sourceAbs, "utf-8");
   const sourceComposition = compositionRoot(source).root;
   const duration = positiveAttribute(
     sourceComposition,
@@ -122224,7 +122302,7 @@ function foldElementPatches(originalContent, patches) {
   }
   return { content, matched };
 }
-function commitElementPatchBatches(projectDir, batches, writeFile3 = writeFileSync42) {
+function commitElementPatchBatches(projectDir, batches, writeFile3 = writeFileSync52, requestToken) {
   const resolvedPaths = /* @__PURE__ */ new Set();
   const prepared = [];
   for (const batch of batches) {
@@ -122234,7 +122312,7 @@ function commitElementPatchBatches(projectDir, batches, writeFile3 = writeFileSy
     resolvedPaths.add(absPath);
     let before3;
     try {
-      before3 = readFileSync42(absPath, "utf-8");
+      before3 = readFileSync52(absPath, "utf-8");
     } catch {
       return { error: "not-found", sourceFile: batch.sourceFile };
     }
@@ -122260,64 +122338,34 @@ function commitElementPatchBatches(projectDir, batches, writeFile3 = writeFileSy
       }))
     };
   }
-  const files = [];
-  const attemptedWrites = [];
-  try {
-    for (const file of prepared) {
-      if (file.after === file.before) {
-        files.push({
-          sourceFile: file.sourceFile,
-          changed: false,
-          matched: file.matched,
-          before: file.before,
-          after: file.before
-        });
-        continue;
-      }
-      const backup = snapshotBeforeWrite(projectDir, file.absPath);
-      if (backup.error) {
-        throw new Error(`Failed to create backup for ${file.sourceFile}: ${backup.error}`);
-      }
-      attemptedWrites.push(file);
-      writeFile3(file.absPath, file.after, "utf-8");
-      files.push({
-        sourceFile: file.sourceFile,
-        changed: true,
-        matched: file.matched,
-        before: file.before,
-        after: file.after,
-        backupPath: backupPathForResponse(projectDir, backup.backupPath)
-      });
-    }
-  } catch (error) {
-    const rollbackErrors = [];
-    for (const file of attemptedWrites.reverse()) {
-      try {
-        writeFile3(file.absPath, file.before, "utf-8");
-      } catch (rollbackError) {
-        rollbackErrors.push(rollbackError);
-      }
-    }
-    if (rollbackErrors.length > 0) {
-      throw new AggregateError(
-        [error, ...rollbackErrors],
-        "Element patch batch failed and rollback did not complete"
-      );
-    }
-    throw error;
-  }
+  const applied = applyFileMutations(
+    projectDir,
+    prepared.map(({ sourceFile, absPath, before: before3, after: after2 }) => ({
+      sourceFile,
+      absPath,
+      before: before3,
+      after: after2
+    })),
+    requestToken,
+    writeFile3
+  );
+  const files = applied.map((file, index) => ({
+    sourceFile: file.sourceFile,
+    changed: file.changed,
+    matched: prepared[index]?.matched ?? [],
+    before: file.before,
+    after: file.after,
+    backupPath: file.backupPath ?? void 0
+  }));
   return { durable: true, files };
 }
 function commitElementPatchBatchesWithReceipts(c3, projectDir, batches) {
-  const result = commitElementPatchBatches(projectDir, batches);
-  if ("error" in result || !result.durable) return result;
-  for (const file of result.files) {
-    if (!file.changed) continue;
-    const absPath = resolveWithinProject(projectDir, file.sourceFile);
-    if (!absPath) throw new Error(`Committed element patch escaped project: ${file.sourceFile}`);
-    recordMutationReceipt(c3, file.sourceFile, absPath, file.after);
-  }
-  return result;
+  return commitElementPatchBatches(
+    projectDir,
+    batches,
+    writeFileSync52,
+    c3.req.header("X-Hyperframes-Write-Token")
+  );
 }
 function recordMutationReceipt(c3, filePath, absPath, html) {
   const version2 = fileContentVersion(html);
@@ -122326,7 +122374,7 @@ function recordMutationReceipt(c3, filePath, absPath, html) {
   return { version: version2, writeToken };
 }
 function writeFileWithReceipt(c3, filePath, absPath, html) {
-  writeFileSync42(absPath, html, "utf-8");
+  writeFileSync52(absPath, html, "utf-8");
   return recordMutationReceipt(c3, filePath, absPath, html);
 }
 function writeMutationResult(c3, projectDir, filePath, absPath, html) {
@@ -122339,9 +122387,9 @@ function writeIfChanged(c3, projectDir, filePath, absPath, original, next) {
   if (next === original) {
     return c3.json({ ok: true, changed: false, content: original, path: filePath });
   }
-  const mutationResult = writeMutationResult(c3, projectDir, filePath, absPath, next);
-  if (mutationResult instanceof Response) return mutationResult;
-  const { backupPath } = mutationResult;
+  const mutationResult2 = writeMutationResult(c3, projectDir, filePath, absPath, next);
+  if (mutationResult2 instanceof Response) return mutationResult2;
+  const { backupPath } = mutationResult2;
   return c3.json({
     ok: true,
     changed: true,
@@ -122411,11 +122459,11 @@ function updateReferences(projectDir, oldPath, newPath) {
   let updatedCount = 0;
   for (const file of textFiles) {
     if (!isSafePath(projectDir, file)) continue;
-    const content = readFileSync42(file, "utf-8");
+    const content = readFileSync52(file, "utf-8");
     if (!content.includes(oldPath)) continue;
     const updated = content.split(oldPath).join(newPath);
     if (updated !== content) {
-      writeFileSync42(file, updated, "utf-8");
+      writeFileSync52(file, updated, "utf-8");
       updatedCount++;
     }
   }
@@ -122654,7 +122702,7 @@ function containsRawGsapExpression(value) {
   return Object.values(value).some(containsRawGsapExpression);
 }
 async function prepareGsapMutationScript(c3, res, firstMutation) {
-  const beforeHtml = readFileSync42(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")) {
@@ -122721,19 +122769,19 @@ async function applyGsapMutations(c3, res, mutations) {
   const changed = block.scriptText !== initialScript;
   const newHtml = changed ? block.replaceScript(block.scriptText) : html;
   let backupPath = null;
-  if (readFileSync42(res.absPath, "utf-8") !== beforeHtml) {
+  if (readFileSync52(res.absPath, "utf-8") !== beforeHtml) {
     return c3.json({ error: "file changed during GSAP mutation", conflict: true }, 409);
   }
   if (changed) {
-    const mutationResult = writeMutationResult(
+    const mutationResult2 = writeMutationResult(
       c3,
       res.project.dir,
       res.filePath,
       res.absPath,
       newHtml
     );
-    if (mutationResult instanceof Response) return mutationResult;
-    backupPath = mutationResult.backupPath;
+    if (mutationResult2 instanceof Response) return mutationResult2;
+    backupPath = mutationResult2.backupPath;
   }
   const responsePayload = {
     ok: true,
@@ -123504,7 +123552,7 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
       try {
         const fd = openSync8(finalPath, "wx");
         try {
-          writeFileSync42(fd, buffer);
+          writeFileSync52(fd, buffer);
         } finally {
           closeSync8(fd);
         }
@@ -123542,7 +123590,7 @@ function registerFileRoutes(api, adapter2) {
       }
       return c3.json({ error: "not found" }, 404);
     }
-    const content = readFileSync42(res.absPath);
+    const content = readFileSync52(res.absPath);
     const version2 = fileContentVersion(content);
     c3.header("ETag", version2);
     return c3.json({ filename: res.filePath, content: content.toString("utf-8"), version: version2 });
@@ -123556,7 +123604,7 @@ function registerFileRoutes(api, adapter2) {
     if (expectedVersion === null && !createOnly) {
       let currentContent = null;
       try {
-        currentContent = readFileSync42(res.absPath);
+        currentContent = readFileSync52(res.absPath);
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
           throw error;
@@ -123582,7 +123630,7 @@ function registerFileRoutes(api, adapter2) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
           throw error;
         }
-        const currentContent = readFileSync42(res.absPath);
+        const currentContent = readFileSync52(res.absPath);
         return c3.json(
           {
             error: "file conflict",
@@ -123617,7 +123665,7 @@ function registerFileRoutes(api, adapter2) {
         );
       }
       try {
-        const currentContent = readFileSync42(fd);
+        const currentContent = readFileSync52(fd);
         const currentVersion = fileContentVersion(currentContent);
         if (expectedVersion !== currentVersion) {
           return c3.json(
@@ -123656,7 +123704,7 @@ function registerFileRoutes(api, adapter2) {
     ensureDir(res.absPath);
     const body = Buffer.from(await c3.req.arrayBuffer());
     try {
-      writeFileSync42(res.absPath, body, { flag: "wx" });
+      writeFileSync52(res.absPath, body, { flag: "wx" });
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
         throw error;
@@ -123690,7 +123738,7 @@ function registerFileRoutes(api, adapter2) {
     }
     let before3;
     try {
-      before3 = readFileSync42(ctx.absPath, "utf-8");
+      before3 = readFileSync52(ctx.absPath, "utf-8");
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
         throw error;
@@ -123747,7 +123795,7 @@ function registerFileRoutes(api, adapter2) {
     }
     const parsed = await parseMutationBody(c3);
     if ("error" in parsed) return parsed.error;
-    const originalContent = readFileSync42(ctx.absPath, "utf-8");
+    const originalContent = readFileSync52(ctx.absPath, "utf-8");
     return writeIfChanged(
       c3,
       ctx.project.dir,
@@ -123768,7 +123816,7 @@ function registerFileRoutes(api, adapter2) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return c3.json({ error: "targets required" }, 400);
     }
-    const originalContent = readFileSync42(ctx.absPath, "utf-8");
+    const originalContent = readFileSync52(ctx.absPath, "utf-8");
     let next = originalContent;
     for (const target of targets) {
       next = removeElementFromHtml2(next, target);
@@ -123801,7 +123849,7 @@ function registerFileRoutes(api, adapter2) {
         seen.add(absPath);
         let before3;
         try {
-          before3 = readFileSync42(absPath, "utf-8");
+          before3 = readFileSync52(absPath, "utf-8");
         } catch {
           return c3.json({ error: `not found: ${file.path}` }, 404);
         }
@@ -123828,7 +123876,7 @@ function registerFileRoutes(api, adapter2) {
         prepared.push(folded);
       }
       for (const file of prepared) {
-        const current2 = readFileSync42(file.absPath, "utf-8");
+        const current2 = readFileSync52(file.absPath, "utf-8");
         if (current2 !== file.before) {
           return c3.json(
             {
@@ -123858,7 +123906,7 @@ function registerFileRoutes(api, adapter2) {
       const written = [];
       try {
         for (const file of prepared) {
-          writeFileSync42(file.absPath, file.after, "utf-8");
+          writeFileSync52(file.absPath, file.after, "utf-8");
           written.push(file);
           recordFileWriteReceipt(file.absPath, {
             path: file.path,
@@ -123870,12 +123918,12 @@ function registerFileRoutes(api, adapter2) {
         const conflicts = [];
         for (const file of written.reverse()) {
           try {
-            const current2 = readFileSync42(file.absPath, "utf-8");
+            const current2 = readFileSync52(file.absPath, "utf-8");
             if (current2 !== file.after) {
               conflicts.push(file.path);
               continue;
             }
-            writeFileSync42(file.absPath, file.before, "utf-8");
+            writeFileSync52(file.absPath, file.before, "utf-8");
             recordFileWriteReceipt(file.absPath, {
               path: file.path,
               version: fileContentVersion(file.before),
@@ -123918,7 +123966,7 @@ function registerFileRoutes(api, adapter2) {
     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 = readFileSync42(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c3.json({ error: "not found" }, 404);
     }
@@ -123940,15 +123988,15 @@ function registerFileRoutes(api, adapter2) {
         version: version22
       });
     }
-    const mutationResult = writeMutationResult(
+    const mutationResult2 = writeMutationResult(
       c3,
       ctx.project.dir,
       ctx.filePath,
       ctx.absPath,
       result.html
     );
-    if (mutationResult instanceof Response) return mutationResult;
-    const { version: version2, backupPath } = mutationResult;
+    if (mutationResult2 instanceof Response) return mutationResult2;
+    const { version: version2, backupPath } = mutationResult2;
     c3.header("ETag", version2);
     return c3.json({
       ok: true,
@@ -123974,7 +124022,7 @@ function registerFileRoutes(api, adapter2) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync42(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c3.json({ error: "not found" }, 404);
     }
@@ -123995,15 +124043,15 @@ function registerFileRoutes(api, adapter2) {
         version: version22
       });
     }
-    const mutationResult = writeMutationResult(
+    const mutationResult2 = writeMutationResult(
       c3,
       ctx.project.dir,
       ctx.filePath,
       ctx.absPath,
       patched
     );
-    if (mutationResult instanceof Response) return mutationResult;
-    const { backupPath, version: version2 } = mutationResult;
+    if (mutationResult2 instanceof Response) return mutationResult2;
+    const { backupPath, version: version2 } = mutationResult2;
     c3.header("ETag", version2);
     return c3.json({
       ok: true,
@@ -124075,7 +124123,7 @@ function registerFileRoutes(api, adapter2) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync42(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c3.json({ error: "not found" }, 404);
     }
@@ -124098,15 +124146,15 @@ function registerFileRoutes(api, adapter2) {
         result.error === "grouped elements must share a single parent" ? 422 : 400
       );
     }
-    const mutationResult = writeMutationResult(
+    const mutationResult2 = writeMutationResult(
       c3,
       ctx.project.dir,
       ctx.filePath,
       ctx.absPath,
       result.html
     );
-    if (mutationResult instanceof Response) return mutationResult;
-    const { backupPath } = mutationResult;
+    if (mutationResult2 instanceof Response) return mutationResult2;
+    const { backupPath } = mutationResult2;
     return c3.json({
       ok: true,
       changed: true,
@@ -124130,7 +124178,7 @@ function registerFileRoutes(api, adapter2) {
     ).map((entry) => ({ target: entry.target, track: entry.track }));
     let originalContent;
     try {
-      originalContent = readFileSync42(ctx.absPath, "utf-8");
+      originalContent = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c3.json({ error: "not found" }, 404);
     }
@@ -124159,7 +124207,7 @@ function registerFileRoutes(api, adapter2) {
     if ("error" in parsed) return parsed.error;
     let content;
     try {
-      content = readFileSync42(ctx.absPath, "utf-8");
+      content = readFileSync52(ctx.absPath, "utf-8");
     } catch {
       return c3.json({ exists: false });
     }
@@ -124202,7 +124250,7 @@ function registerFileRoutes(api, adapter2) {
       return c3.json({ error: "forbidden" }, 403);
     }
     ensureDir(destAbs);
-    writeFileSync42(destAbs, readFileSync42(srcAbs));
+    writeFileSync52(destAbs, readFileSync52(srcAbs));
     return c3.json({ ok: true, path: copyPath }, 201);
   });
   const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
@@ -124232,7 +124280,7 @@ function registerFileRoutes(api, adapter2) {
       mustExist: true
     });
     if ("error" in res) return res.error;
-    const html = readFileSync42(res.absPath, "utf-8");
+    const html = readFileSync52(res.absPath, "utf-8");
     const block = extractGsapScriptBlock(html);
     if (!block) {
       return c3.json({
@@ -124291,11 +124339,11 @@ function registerFileRoutes(api, adapter2) {
     if (!body || typeof body.expected !== "string" || typeof body.restore !== "string") {
       return c3.json({ error: "expected and restore contents required" }, 400);
     }
-    const current2 = readFileSync42(res.absPath, "utf-8");
+    const current2 = readFileSync52(res.absPath, "utf-8");
     if (current2 !== body.expected) {
       return c3.json({ ok: true, restored: false, conflict: true });
     }
-    writeFileSync42(res.absPath, body.restore, "utf-8");
+    writeFileSync52(res.absPath, body.restore, "utf-8");
     return c3.json({ ok: true, restored: true, conflict: false });
   });
 }
@@ -124400,7 +124448,7 @@ function tagRootCompositionFile(bodyHtml, compPath) {
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
   const compFile = join72(projectDir, compPath);
   if (!existsSync42(compFile)) return null;
-  const rawComp = rawOverride ?? readFileSync52(compFile, "utf-8");
+  const rawComp = rawOverride ?? readFileSync62(compFile, "utf-8");
   let compHeadContent = "";
   let rewrittenContent;
   let htmlAttrs = "";
@@ -124433,7 +124481,7 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, raw
   const indexPath2 = join72(projectDir, "index.html");
   let headContent = "";
   if (existsSync42(indexPath2)) {
-    const indexHtml = readFileSync52(indexPath2, "utf-8");
+    const indexHtml = readFileSync62(indexPath2, "utf-8");
     const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     headContent = headMatch?.[1] ?? "";
   }
@@ -124471,9 +124519,9 @@ function persistHfIdsIfNeeded(filePath, html) {
   const idsAfter = (normalized2.match(/\bdata-hf-id=/g) ?? []).length;
   if (idsAfter > idsBefore) {
     try {
-      const current2 = readFileSync62(filePath, "utf-8");
+      const current2 = readFileSync72(filePath, "utf-8");
       if (current2 === html) {
-        writeFileSync52(filePath, normalized2, "utf-8");
+        writeFileSync62(filePath, normalized2, "utf-8");
       }
     } catch (err) {
       console.warn("[hyperframes] persistHfIdsIfNeeded: failed to write ids to disk:", err);
@@ -124499,7 +124547,7 @@ function stampFileHfIds(filePath) {
   if (fd === null) return null;
   try {
     if (!fstatSync4(fd).isFile()) return null;
-    const html = readFileSync62(fd, "utf-8");
+    const html = readFileSync72(fd, "utf-8");
     const normalized2 = ensureHfIds(html);
     const idsBefore = (html.match(/\bdata-hf-id=/g) ?? []).length;
     const idsAfter = (normalized2.match(/\bdata-hf-id=/g) ?? []).length;
@@ -124549,7 +124597,7 @@ function readStudioMotionManifestContent(projectDir) {
   const manifestPath3 = join82(projectDir, STUDIO_MOTION_PATH);
   if (!existsSync52(manifestPath3)) return "";
   try {
-    return readFileSync72(manifestPath3, "utf-8");
+    return readFileSync82(manifestPath3, "utf-8");
   } catch {
     return "";
   }
@@ -124675,14 +124723,14 @@ function resolveProjectMainHtml(projectDir, projectId) {
   const indexPath2 = join82(projectDir, "index.html");
   if (existsSync52(indexPath2)) {
     return {
-      html: readFileSync72(indexPath2, "utf-8"),
+      html: readFileSync82(indexPath2, "utf-8"),
       compositionPath: "index.html"
     };
   }
   const blockHtmlPath = join82(projectDir, `${projectId}.html`);
   if (existsSync52(blockHtmlPath)) {
     return {
-      html: readFileSync72(blockHtmlPath, "utf-8"),
+      html: readFileSync82(blockHtmlPath, "utf-8"),
       compositionPath: `${projectId}.html`
     };
   }
@@ -124876,7 +124924,7 @@ ${runtimeTag}`;
       }
       servedContentType = PROXY_VARIANT_CONFIG[proxyVariant].contentType;
     }
-    const textBuffer = isText2 ? Buffer.from(readFileSync72(file, "utf-8"), "utf-8") : null;
+    const textBuffer = isText2 ? Buffer.from(readFileSync82(file, "utf-8"), "utf-8") : null;
     const totalSize2 = textBuffer ? textBuffer.length : statSync32(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
@@ -124935,7 +124983,7 @@ async function lintUncoveredHtml(adapter2, projectDir, htmlFiles, coveredFiles)
   const findings = [];
   for (const file of htmlFiles) {
     if (coveredFiles.has(file)) continue;
-    const content = readFileSync82(join92(projectDir, file), "utf-8");
+    const content = readFileSync92(join92(projectDir, file), "utf-8");
     const result = await adapter2.lint(content, { filePath: file, isSubComposition: true });
     for (const finding of result?.findings ?? []) {
       findings.push({ ...finding, file });
@@ -125098,7 +125146,7 @@ function registerRenderRoutes(api, adapter2) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync92(job.outputPath);
+    const content = readFileSync102(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -125116,7 +125164,7 @@ function registerRenderRoutes(api, adapter2) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync92(job.outputPath);
+    const content = readFileSync102(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -125149,7 +125197,7 @@ function registerRenderRoutes(api, adapter2) {
     if (!fp) return c3.json({ error: "forbidden" }, 403);
     if (!existsSync62(fp)) return c3.json({ error: "not found" }, 404);
     const contentType = renderContentType(fp);
-    const content = readFileSync92(fp);
+    const content = readFileSync102(fp);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -125173,7 +125221,7 @@ function registerRenderRoutes(api, adapter2) {
       let durationMs;
       if (existsSync62(metaPath)) {
         try {
-          const meta = JSON.parse(readFileSync92(metaPath, "utf-8"));
+          const meta = JSON.parse(readFileSync102(metaPath, "utf-8"));
           if (meta.status === "failed" && !existsSync62(fp)) status = "failed";
           if (meta.durationMs) durationMs = meta.durationMs;
         } catch {
@@ -125236,7 +125284,7 @@ function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
 function writeThumbnailAtomically(path, buffer) {
   const temporaryPath = `${path}.${process.pid}.${randomUUID32()}.tmp`;
   try {
-    writeFileSync62(temporaryPath, buffer, { flag: "wx" });
+    writeFileSync72(temporaryPath, buffer, { flag: "wx" });
     renameSync32(temporaryPath, path);
   } finally {
     rmSync42(temporaryPath, { force: true });
@@ -125274,7 +125322,7 @@ function registerThumbnailRoutes(api, adapter2) {
     let sourceKey = "";
     const htmlFile = join112(project.dir, compPath);
     if (existsSync72(htmlFile)) {
-      const html = readFileSync102(htmlFile, "utf-8");
+      const html = readFileSync112(htmlFile, "utf-8");
       sourceKey = `_${createHash42("sha1").update(html).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.round(statSync52(htmlFile).mtimeMs);
       if (!vpWidth) {
@@ -125287,14 +125335,14 @@ function registerThumbnailRoutes(api, adapter2) {
     const manualEditsFile = join112(project.dir, STUDIO_MANUAL_EDITS_PATH);
     let manualEditsKey = "";
     if (existsSync72(manualEditsFile)) {
-      const manualEditsContent = readFileSync102(manualEditsFile, "utf-8");
+      const manualEditsContent = readFileSync112(manualEditsFile, "utf-8");
       manualEditsKey = `_${createHash42("sha1").update(manualEditsContent).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.max(sourceMtime, Math.round(statSync52(manualEditsFile).mtimeMs));
     }
     const motionFile = join112(project.dir, STUDIO_MOTION_PATH);
     let motionKey = "";
     if (existsSync72(motionFile)) {
-      const motionContent = readFileSync102(motionFile, "utf-8");
+      const motionContent = readFileSync112(motionFile, "utf-8");
       motionKey = `_${createHash42("sha1").update(motionContent).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.max(sourceMtime, Math.round(statSync52(motionFile).mtimeMs));
     }
@@ -125316,7 +125364,7 @@ function registerThumbnailRoutes(api, adapter2) {
       );
     }
     if (existsSync72(cachePath2)) {
-      return new Response(new Uint8Array(readFileSync102(cachePath2)), {
+      return new Response(new Uint8Array(readFileSync112(cachePath2)), {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
       });
     }
@@ -125383,7 +125431,7 @@ function registerWaveformRoutes(api, adapter2) {
     const cachePath2 = join122(cacheDir, buildWaveformCacheKey(assetPath, stats));
     try {
       if (isWaveformCacheDirectory(cacheDir) && existsSync82(cachePath2)) {
-        const peaks2 = JSON.parse(readFileSync112(cachePath2, "utf-8"));
+        const peaks2 = JSON.parse(readFileSync122(cachePath2, "utf-8"));
         return c3.json({ peaks: peaks2 });
       }
     } catch {
@@ -125809,7 +125857,7 @@ function readGlobalAssets(home = homedir10()) {
   const manifestPath3 = join142(home, ".media", "manifest.jsonl");
   if (!existsSync102(manifestPath3)) return [];
   const out = [];
-  for (const line3 of readFileSync122(manifestPath3, "utf8").split("\n")) {
+  for (const line3 of readFileSync132(manifestPath3, "utf8").split("\n")) {
     if (!line3.trim()) continue;
     try {
       const rec = JSON.parse(line3);
@@ -155540,6 +155588,7 @@ __export(studio_api_exports, {
   STUDIO_MANUAL_EDITS_PATH: () => STUDIO_MANUAL_EDITS_PATH,
   STUDIO_MOTION_PATH: () => STUDIO_MOTION_PATH,
   affectsProjectSignature: () => affectsProjectSignature,
+  applyFileMutations: () => applyFileMutations,
   buildSubCompositionHtml: () => buildSubCompositionHtml,
   consumeFileWriteReceipt: () => consumeFileWriteReceipt,
   createBackgroundRemovalJob: () => createBackgroundRemovalJob,
@@ -155553,6 +155602,9 @@ __export(studio_api_exports, {
   getMimeType: () => getMimeType,
   identifyFileWrite: () => identifyFileWrite,
   isSafePath: () => isSafePath,
+  patchElementInHtml: () => patchElementInHtml,
+  removeElementFromHtml: () => removeElementFromHtml2,
+  splitElementInHtml: () => splitElementInHtml,
   thumbnailDeviceScaleFactor: () => thumbnailDeviceScaleFactor,
   walkDir: () => walkDir
 });
@@ -170293,27 +170345,32 @@ function mainTimelineStart(scope, el, start) {
     ordinaryStart
   });
 }
-async function describeRow(scope, node, depth) {
+async function resolveRowTiming(scope, node, depth) {
   const { el } = node;
-  const { doc, startCache } = scope;
-  const start = resolveReferencedStart(doc, el, startCache, /* @__PURE__ */ new Set());
-  const authored = resolveReferencedDuration(doc, el, startCache, /* @__PURE__ */ new Set());
+  const start = resolveReferencedStart(scope.doc, el, scope.startCache, /* @__PURE__ */ new Set());
+  const authored = resolveReferencedDuration(scope.doc, el, scope.startCache, /* @__PURE__ */ new Set());
   const host = el.getAttribute("data-composition-src");
   const absStart = mainTimelineStart(scope, el, start);
   const children = host && depth === 0 ? await readSubComposition(host, scope, absStart) : [];
   const kind = el.tagName.toLowerCase();
-  const { duration, durationSource, pendingReason: pendingReason2 } = MEDIA_TAG.test(kind) ? await resolveMediaRowDuration(scope, el, kind, authored) : resolveContainerDuration(authored, children);
+  const duration = MEDIA_TAG.test(kind) ? await resolveMediaRowDuration(scope, el, kind, authored) : resolveContainerDuration(authored, children);
+  return { start, authored, absStart, children, duration };
+}
+function describeRowFields(scope, node, timing2) {
+  const { el } = node;
+  const kind = el.tagName.toLowerCase();
+  const host = el.getAttribute("data-composition-src");
   const rate = parseNumeric2(el.getAttribute("data-playback-rate"));
   return {
     id: el.id || el.getAttribute("data-composition-id") || kind,
     label: null,
     kind,
     trackKind: trackKindOf(node).kind,
-    start,
-    duration,
-    end: start + duration,
-    absStart: roundMs(absStart),
-    absEnd: roundMs(absStart + duration),
+    start: timing2.start,
+    duration: timing2.duration.duration,
+    end: timing2.start + timing2.duration.duration,
+    absStart: roundMs(timing2.absStart),
+    absEnd: roundMs(timing2.absStart + timing2.duration.duration),
     file: scope.file,
     trackIndex: parseNumeric2(el.getAttribute("data-track-index")) ?? 0,
     src: el.getAttribute("src") ?? host,
@@ -170323,17 +170380,26 @@ async function describeRow(scope, node, depth) {
     playbackRate: rate === 1 ? null : rate,
     audioGroup: el.getAttribute(HF_AUDIO_GROUP_ATTR),
     role: null,
-    durationAuthored: authored !== null,
-    durationSource,
-    pendingReason: pendingReason2,
-    children
+    durationAuthored: timing2.authored !== null,
+    durationSource: timing2.duration.durationSource,
+    pendingReason: timing2.duration.pendingReason,
+    children: timing2.children,
+    ref: "",
+    warnings: [],
+    elementId: el.id || null,
+    hfId: el.getAttribute("data-hf-id")
   };
 }
+async function describeRow(scope, node, depth) {
+  return describeRowFields(scope, node, await resolveRowTiming(scope, node, depth));
+}
 async function readSubComposition(src, parent, origin) {
   const authored = resolve64(parent.dir, src);
   const file = realFileInside(parent.projectDir, authored);
   if (!file) return [];
-  const doc = new DOMParser().parseFromString(readFileSync76(file, "utf-8"), "text/html");
+  const relativeFile = relative30(parent.projectDir, authored).split(sep17).join("/");
+  const source = parent.sourceOverrides.get(relativeFile) ?? readFileSync76(file, "utf-8");
+  const doc = new DOMParser().parseFromString(source, "text/html");
   const template = doc.querySelector("template");
   const root = (template?.content ?? doc).querySelector("[data-composition-id]");
   if (!root) return [];
@@ -170345,7 +170411,8 @@ async function readSubComposition(src, parent, origin) {
     origin,
     file: relative30(parent.projectDir, authored).split(sep17).join("/"),
     withProbeSlot: parent.withProbeSlot,
-    measure: parent.measure
+    measure: parent.measure,
+    sourceOverrides: parent.sourceOverrides
   };
   const rows = await Promise.all(
     topLevelElements(toNode2(root)).map((node) => describeRow(scope, node, 1))
@@ -170375,22 +170442,42 @@ function flatten(top) {
     byKind.flatMap((t) => t.entries.map((e2, index) => [e2.clip, { kind: t.kind, index }]))
   );
   const at4 = (clip) => pointers.get(clip);
+  const fileIds = /* @__PURE__ */ new Map();
+  for (const { entries: entries3 } of byKind) {
+    for (const { clip } of entries3) {
+      if (!clip.elementId) continue;
+      const ids = fileIds.get(clip.file) ?? /* @__PURE__ */ new Map();
+      ids.set(clip.elementId, (ids.get(clip.elementId) ?? 0) + 1);
+      fileIds.set(clip.file, ids);
+    }
+  }
   return byKind.map(({ kind, entries: kindEntries }) => ({
     kind,
-    rows: kindEntries.map(({ clip, host }, index) => ({
-      ...clip,
-      index,
-      nested: host !== null,
-      host: host && host.id,
-      hostRow: host && at4(host),
-      children: clip.children.map(at4)
-    }))
+    rows: kindEntries.map(({ clip, host }, index) => {
+      const uniqueId = clip.elementId && fileIds.get(clip.file)?.get(clip.elementId) === 1;
+      const ref2 = uniqueId ? `#${clip.elementId}` : clip.hfId ? `hf:${clip.hfId}` : `${kind}/${index}`;
+      const warnings = uniqueId || clip.hfId ? [] : [
+        'row has no stable name; add id="<name>" to the element in this file, then retry with #<name>'
+      ];
+      return {
+        ...clip,
+        index,
+        ref: ref2,
+        warnings,
+        nested: host !== null,
+        host: host && host.id,
+        hostRow: host && at4(host),
+        children: clip.children.map(at4)
+      };
+    })
   }));
 }
-async function describeProject(indexPath2, measure = measureWithFfprobe) {
-  const doc = new DOMParser().parseFromString(readFileSync76(indexPath2, "utf-8"), "text/html");
+async function describeProject(indexPath2, measure = measureWithFfprobe, sourceOverrides = /* @__PURE__ */ new Map()) {
+  const projectDir = dirname55(indexPath2);
+  const source = sourceOverrides.get(basename24(indexPath2)) ?? readFileSync76(indexPath2, "utf-8");
+  const doc = new DOMParser().parseFromString(source, "text/html");
   const root = doc.querySelector("[data-composition-id]") ?? doc.body;
-  const dir = dirname55(indexPath2);
+  const dir = projectDir;
   const scope = {
     doc,
     dir,
@@ -170399,7 +170486,8 @@ async function describeProject(indexPath2, measure = measureWithFfprobe) {
     origin: 0,
     file: basename24(indexPath2),
     withProbeSlot: createProbeGate(PROBE_CONCURRENCY3),
-    measure
+    measure,
+    sourceOverrides
   };
   const rows = (await Promise.all(topLevelElements(toNode2(root)).map((node) => describeRow(scope, node, 0)))).sort(byStart);
   const declared = parseNumeric2(root.getAttribute("data-duration"));
@@ -170470,7 +170558,7 @@ function details(row) {
 }
 function line2(row, total) {
   const times = row.host ? `${span(row.absStart, row.absEnd)} (local ${span(row.start, row.end)}) nested in ${row.host} ${row.file}` : span(row.start, row.end);
-  return `  |${bar(row, total)}| ${row.id} ${times} ${details(row)}`.trimEnd();
+  return `  |${bar(row, total)}| ${row.ref} ${row.id} ${times} ${details(row)}`.trimEnd();
 }
 function header({ kind, rows }) {
   const nested = rows.filter((r) => r.nested).length;
@@ -170495,36 +170583,554 @@ var init_formatTimeline = __esm({
   }
 });
 
+// src/timeline/resolveRef.ts
+function targetFor(row) {
+  if (row.ref.startsWith("#")) return { id: row.ref.slice(1) };
+  if (row.ref.startsWith("hf:")) return { hfId: row.ref.slice(3) };
+  return row.id && row.id !== row.kind ? { id: row.id } : null;
+}
+function resolveRef(timeline, ref2) {
+  const rows = timeline.tracks.flatMap((track) => track.rows);
+  const matches2 = ref2.startsWith("#") ? rows.filter((row2) => row2.ref === ref2 || row2.id === ref2.slice(1)) : ref2.startsWith("hf:") ? rows.filter((row2) => row2.ref === ref2) : (() => {
+    const match = /^(video|graphics|captions|audio)\/(\d+)$/.exec(ref2);
+    if (!match) return [];
+    const row2 = timeline.tracks.find((track) => track.kind === match[1])?.rows.find((candidate) => candidate.index === Number(match[2]));
+    return row2 ? [row2] : [];
+  })();
+  if (matches2.length !== 1) {
+    return {
+      ok: false,
+      reason: matches2.length === 0 ? `${ref2} was not found` : `${ref2} matches ${matches2.length} rows`,
+      fix: 'add id="<name>" to the element in its source file, then retry with #<name>'
+    };
+  }
+  const row = matches2[0];
+  const target = targetFor(row);
+  if (!target) {
+    return {
+      ok: false,
+      reason: `${ref2} has no stable element id in ${row.file}`,
+      fix: `add id="<name>" to the element in ${row.file}, then retry with #<name>`
+    };
+  }
+  return { ok: true, row, target };
+}
+var init_resolveRef = __esm({
+  "src/timeline/resolveRef.ts"() {
+    "use strict";
+  }
+});
+
+// src/timeline/timeExpr.ts
+function parseTimeExpression(expression, context) {
+  const raw = expression.trim();
+  if (raw === "end") return { ok: true, seconds: context.duration };
+  const frames = /^(-?\d+(?:\.\d+)?)f$/.exec(raw);
+  if (frames) return { ok: true, seconds: Number(frames[1]) / context.fps };
+  const absolute = /^\d+(?:\.\d+)?$/.test(raw);
+  const relative38 = /^[+-]\d+(?:\.\d+)?$/.test(raw);
+  if (absolute) return { ok: true, seconds: Number(raw) };
+  if (relative38) return { ok: true, seconds: context.row.start + Number(raw) };
+  const anchor = /^(after|before|start-of|end-of):(.+)$/.exec(raw);
+  if (!anchor) return { ok: false, reason: `invalid time expression: ${expression}` };
+  const row = context.resolveAnchor(anchor[2]);
+  if (!row) return { ok: false, reason: `anchor ref not found: ${anchor[2]}` };
+  switch (anchor[1]) {
+    case "after":
+    case "end-of":
+      return { ok: true, seconds: row.end };
+    case "before":
+    case "start-of":
+      return { ok: true, seconds: row.start };
+  }
+  return { ok: false, reason: `invalid time anchor: ${anchor[1]}` };
+}
+var init_timeExpr = __esm({
+  "src/timeline/timeExpr.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/timeline.ts
 var timeline_exports = {};
 __export(timeline_exports, {
   default: () => timeline_default,
   examples: () => examples19
 });
-var examples19, timeline_default;
+import { readFileSync as readFileSync77 } from "fs";
+import { join as join116 } from "path";
+function refusal(reason, fix, json) {
+  setCommandExitCode(2);
+  const payload = { ok: false, reason, fix };
+  console.error(json ? JSON.stringify(payload, null, 2) : `${reason}; ${fix}.`);
+}
+function fpsFor(indexPath2) {
+  const parsed = parseFpsWithDefault(
+    readCompositionFps(readFileSync77(indexPath2, "utf-8")) ?? void 0
+  );
+  return fpsToNumber(parsed.ok ? parsed.value : { num: 30, den: 1 });
+}
+function declaredFps(source) {
+  const raw = readCompositionFps(source);
+  if (raw === null) return null;
+  const parsed = parseFpsWithDefault(raw);
+  return parsed.ok ? fpsToNumber(parsed.value) : null;
+}
+function splitBaseId(row) {
+  return row.ref.startsWith("hf:") ? row.ref.slice(3) : row.id;
+}
+function nextFreeSplitId(source, base2) {
+  const document2 = new DOMParser().parseFromString(source, "text/html");
+  const existing = new Set(Array.from(document2.querySelectorAll("[id]"), (element) => element.id));
+  const match = /^(.*)-(\d+)$/.exec(base2);
+  const prefix = match && existing.has(match[1]) ? match[1] : base2;
+  let suffix = 2;
+  while (existing.has(`${prefix}-${suffix}`)) suffix += 1;
+  return `${prefix}-${suffix}`;
+}
+function parseMutationTime(context, expression, fix) {
+  const value = context.parseTime(expression);
+  if (!value.ok) return { ok: false, reason: value.reason, fix };
+  if (value.seconds < 0 || value.seconds > context.duration) {
+    return {
+      ok: false,
+      reason: `time ${value.seconds} is outside the composition duration`,
+      fix: "pass a time between 0 and the composition duration"
+    };
+  }
+  return { ok: true, seconds: value.seconds };
+}
+function diff(before3, after2) {
+  if (before3 === after2) return "";
+  const beforeLines = before3.split("\n");
+  const afterLines = after2.split("\n");
+  let prefix = 0;
+  while (prefix < beforeLines.length && prefix < afterLines.length && beforeLines[prefix] === afterLines[prefix]) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (suffix < beforeLines.length - prefix && suffix < afterLines.length - prefix && beforeLines[beforeLines.length - suffix - 1] === afterLines[afterLines.length - suffix - 1]) {
+    suffix += 1;
+  }
+  const changedBefore = beforeLines.slice(prefix, beforeLines.length - suffix);
+  const changedAfter = afterLines.slice(prefix, afterLines.length - suffix);
+  const lines = [
+    "--- before",
+    "+++ after",
+    ...changedBefore.map((line3) => `-${line3}`),
+    ...changedAfter.map((line3) => `+${line3}`)
+  ];
+  const output = lines.join("\n");
+  return output.length <= 8e3 ? output : `${output.slice(0, 7997)}...`;
+}
+function overlap(row, timeline, start, end) {
+  return allRows(timeline).find(
+    (candidate) => candidate !== row && candidate.file === row.file && candidate.trackIndex === row.trackIndex && Math.max(start, candidate.start) < Math.min(end, candidate.end)
+  );
+}
+function moveMutation(context, args) {
+  const expression = typeof args.time === "string" ? args.time : "";
+  const time = parseMutationTime(context, expression, "pass a valid time expression");
+  if (!time.ok) return time;
+  const end = time.seconds + context.row.duration;
+  if (end > context.duration) {
+    return {
+      ok: false,
+      reason: `move would end at ${end}, beyond composition duration ${context.duration}`,
+      fix: `choose a start at or before the latest valid start ${context.duration - context.row.duration}`
+    };
+  }
+  const patched = patchElementInHtml(context.before, context.resolved.target, [
+    { type: "html-attribute", property: "data-start", value: String(time.seconds) }
+  ]);
+  if (!patched.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: patched.html,
+    nextStart: time.seconds,
+    nextDuration: context.row.duration
+  };
+}
+function splitMutation(context, args) {
+  const expression = typeof args.time === "string" ? args.time : "";
+  const time = parseMutationTime(context, expression, "pass a valid time expression");
+  if (!time.ok) return time;
+  const split = splitElementInHtml(
+    context.before,
+    context.resolved.target,
+    time.seconds,
+    nextFreeSplitId(context.before, splitBaseId(context.row)),
+    {
+      start: context.row.start,
+      duration: context.row.duration,
+      track: context.row.trackIndex
+    }
+  );
+  if (!split.matched || !split.newId) {
+    return {
+      ok: false,
+      reason: `${context.ref} cannot be split at ${time.seconds}`,
+      fix: "choose a time inside the clip"
+    };
+  }
+  return {
+    ok: true,
+    after: split.html,
+    nextStart: context.row.start,
+    nextDuration: context.row.duration
+  };
+}
+function trimMutation(context, args) {
+  const bounds = trimBounds(context, args);
+  if (!bounds.ok) return bounds;
+  const patched = patchElementInHtml(context.before, context.resolved.target, [
+    { type: "html-attribute", property: "data-start", value: String(bounds.nextStart) },
+    { type: "html-attribute", property: "data-duration", value: String(bounds.nextDuration) }
+  ]);
+  if (!patched.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: patched.html,
+    nextStart: bounds.nextStart,
+    nextDuration: bounds.nextDuration
+  };
+}
+function trimBounds(context, args) {
+  const input2 = trimInput(args);
+  if (!input2.ok) return input2;
+  const start = trimStart(context, input2.start);
+  if (!start.ok) return start;
+  return finishTrim(
+    context,
+    start.seconds,
+    trimEnd(context, input2.end),
+    trimDuration(context, input2.duration)
+  );
+}
+function trimInput(args) {
+  const input2 = {
+    start: typeof args.start === "string" ? args.start : void 0,
+    end: typeof args.end === "string" ? args.end : void 0,
+    duration: typeof args.duration === "string" ? args.duration : void 0
+  };
+  if (input2.start || input2.end || input2.duration) return { ok: true, ...input2 };
+  return {
+    ok: false,
+    reason: "trim requires --start, --end, or --duration",
+    fix: "pass one trim option"
+  };
+}
+function finishTrim(context, nextStart, end, duration) {
+  if (end && !end.ok) return end;
+  if (duration && !duration.ok) return duration;
+  const nextDuration = duration?.seconds ?? (end ? end.seconds - nextStart : context.row.duration);
+  if (nextDuration <= 0) {
+    return {
+      ok: false,
+      reason: "trim duration must be positive",
+      fix: "choose a later end or positive duration"
+    };
+  }
+  return { ok: true, nextStart, nextDuration };
+}
+function trimStart(context, expression) {
+  if (!expression) return { ok: true, seconds: context.row.start };
+  return parseMutationTime(context, expression, "pass a valid time expression");
+}
+function trimEnd(context, expression) {
+  if (!expression) return void 0;
+  return parseMutationTime(context, expression, "pass a valid time expression");
+}
+function trimDuration(context, expression) {
+  if (!expression) return void 0;
+  return parseMutationTime(context, expression, "pass a valid duration");
+}
+function deleteMutation(context) {
+  return {
+    ok: true,
+    after: removeElementFromHtml2(context.before, context.resolved.target),
+    nextStart: context.row.start,
+    nextDuration: context.row.duration
+  };
+}
+function decideMutation(verb, context, args) {
+  switch (verb) {
+    case "move":
+      return moveMutation(context, args);
+    case "trim":
+      return trimMutation(context, args);
+    case "split":
+      return splitMutation(context, args);
+    case "delete":
+      return deleteMutation(context);
+  }
+}
+async function runMutation(verb, args) {
+  const setup = await prepareMutation(args);
+  if (!setup.ok) return refusal(setup.reason, setup.fix, setup.json);
+  const decision = decideMutation(verb, setup.context, args);
+  if (!decision.ok) return refusal(decision.reason, decision.fix, setup.json);
+  await finishMutation(setup, verb, decision);
+}
+async function prepareMutation(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
+  const ref2 = typeof args.ref === "string" ? args.ref : "";
+  const json = args.json === true;
+  const plan2 = args.plan === true;
+  const overwrite = args.overwrite === true;
+  const snap = args.snap === true;
+  ensureDOMParser();
+  const indexSource = readFileSync77(project.indexPath, "utf-8");
+  const initialTimeline = await describeProject(
+    project.indexPath,
+    void 0,
+    /* @__PURE__ */ new Map([["index.html", indexSource]])
+  );
+  const projectFps = declaredFps(indexSource);
+  if (snap && projectFps === null) {
+    return {
+      ok: false,
+      reason: "project fps is unknown",
+      fix: "set data-fps on the project, then rerun with --snap",
+      json
+    };
+  }
+  const initialResolved = resolveRef(initialTimeline, ref2);
+  if (!initialResolved.ok)
+    return { ok: false, reason: initialResolved.reason, fix: initialResolved.fix, json };
+  const initialRow = initialResolved.row;
+  const filePath = join116(project.dir, initialRow.file);
+  const before3 = readFileSync77(filePath, "utf-8");
+  const expectedVersion = fileContentVersion(before3);
+  const sources = /* @__PURE__ */ new Map([
+    ["index.html", indexSource],
+    [initialRow.file, before3]
+  ]);
+  const timeline = await describeProject(project.indexPath, void 0, sources);
+  const resolved2 = resolveRef(timeline, ref2);
+  if (!resolved2.ok) return { ok: false, reason: resolved2.reason, fix: resolved2.fix, json };
+  const row = resolved2.row;
+  const anchor = (anchorRef) => {
+    const found = resolveRef(timeline, anchorRef);
+    return found.ok ? found.row : void 0;
+  };
+  const parseTime = (expression) => {
+    const parsed = parseTimeExpression(expression, {
+      row,
+      duration: timeline.duration,
+      fps: fpsFor(project.indexPath),
+      resolveAnchor: anchor
+    });
+    if (!parsed.ok || !snap) return parsed;
+    return { ok: true, seconds: Math.round(parsed.seconds * projectFps) / projectFps };
+  };
+  return {
+    ok: true,
+    project,
+    ref: ref2,
+    json,
+    plan: plan2,
+    overwrite,
+    timeline,
+    indexSource,
+    row,
+    resolved: resolved2,
+    filePath,
+    before: before3,
+    expectedVersion,
+    context: {
+      ref: ref2,
+      row,
+      before: before3,
+      resolved: resolved2,
+      parseTime,
+      // Nested rows use the visible host clip duration as their composition bound.
+      duration: row.nested && row.hostRow ? rowAt(timeline, row.hostRow).duration : timeline.duration
+    }
+  };
+}
+async function finishMutation(setup, verb, decision) {
+  const { after: after2, nextStart, nextDuration } = decision;
+  const { ref: ref2, row, timeline, json, overwrite, project, before: before3 } = setup;
+  const refusalMessage = mutationRefusal(verb, after2, before3, ref2);
+  if (refusalMessage) return refusal(refusalMessage.reason, refusalMessage.fix, json);
+  const conflict = mutationConflict(verb, overwrite, row, timeline, nextStart, nextDuration);
+  if (conflict) return refusal(conflict.reason, conflict.fix, json);
+  const describeSource2 = (source) => describeProject(
+    project.indexPath,
+    void 0,
+    /* @__PURE__ */ new Map([
+      ["index.html", setup.indexSource],
+      [row.file, source]
+    ])
+  );
+  const describedBefore = await describeSource2(before3);
+  const result = mutationResult(row, describedBefore, setup.plan);
+  if (setup.plan) return printPlan(result, json, timeline, describeSource2, after2, before3);
+  return applyAndPrint({
+    setup,
+    verb,
+    json,
+    row,
+    nextStart,
+    nextDuration,
+    after: after2,
+    before: before3,
+    result,
+    describeSource: describeSource2
+  });
+}
+async function applyAndPrint(args) {
+  const receipt = applyMutation(args.setup, args.after);
+  if (receipt && "error" in receipt)
+    return refusal(receipt.error, "re-run hyperframes timeline", args.json);
+  if (!receipt && args.after !== args.before) {
+    return refusal("mutation produced no receipt", "re-run hyperframes timeline", args.json);
+  }
+  args.result.after = rowsForFile(await args.describeSource(args.after), args.row.file);
+  args.result.receipt = receipt ? {
+    file: receipt.sourceFile,
+    version: receipt.version,
+    writeToken: receipt.writeToken,
+    changed: receipt.changed,
+    backupPath: receipt.backupPath
+  } : null;
+  if (args.json) {
+    console.log(JSON.stringify(withMeta(args.result), null, 2));
+    return;
+  }
+  console.log(
+    `${args.verb} ${args.row.ref}: ${args.row.start}-${args.row.end}s -> ${args.nextStart}-${args.nextStart + args.nextDuration}s
+receipt: ${receipt?.version ?? "unchanged"}`
+  );
+}
+function rowsForFile(timeline, file) {
+  return allRows(timeline).filter((candidate) => candidate.file === file);
+}
+function rowAt(timeline, pointer) {
+  const track = timeline.tracks.find((candidate) => candidate.kind === pointer.kind);
+  if (!track) throw new Error(`missing track ${pointer.kind}`);
+  const row = track.rows[pointer.index];
+  if (!row) throw new Error(`missing row ${pointer.kind}/${pointer.index}`);
+  return row;
+}
+function mutationResult(row, before3, planned) {
+  return {
+    ok: true,
+    receipt: null,
+    file: row.file,
+    before: rowsForFile(before3, row.file),
+    after: [],
+    warnings: row.warnings,
+    planned
+  };
+}
+async function printPlan(result, json, timeline, describeSource2, after2, before3) {
+  const plannedTimeline = await describeSource2(after2);
+  result.after = rowsForFile(plannedTimeline, result.file);
+  if (json) console.log(JSON.stringify(withMeta(result), null, 2));
+  else
+    console.log(
+      `${formatTimeline(timeline)}
+
+planned:
+${formatTimeline(plannedTimeline)}
+
+diff:
+${diff(before3, after2)}`
+    );
+}
+function applyMutation(setup, after2) {
+  try {
+    return applyFileMutations(setup.project.dir, [
+      {
+        sourceFile: setup.row.file,
+        absPath: setup.filePath,
+        before: setup.before,
+        after: after2,
+        expectedVersion: setup.expectedVersion
+      }
+    ])[0];
+  } catch (error) {
+    if (error instanceof Error && error.message === "file changed since the timeline was read") {
+      return { error: error.message };
+    }
+    throw error;
+  }
+}
+function mutationRefusal(verb, after2, before3, ref2) {
+  if (verb !== "delete" || after2 !== before3) return null;
+  return { reason: `${ref2} was not found`, fix: "choose an existing clip" };
+}
+function mutationConflict(verb, overwrite, row, timeline, nextStart, nextDuration) {
+  if (verb !== "move" && verb !== "trim" || overwrite) return null;
+  const conflict = overlap(row, timeline, nextStart, nextStart + nextDuration);
+  if (!conflict) return null;
+  return {
+    reason: `${row.ref} would overlap ${conflict.ref} at ${nextStart}-${nextStart + nextDuration}`,
+    fix: "pass --overwrite or move the named neighbour"
+  };
+}
+function mutationCommand(verb) {
+  return defineCommand({
+    meta: { name: verb, description: `${verb} a timeline clip` },
+    args: {
+      ref: { type: "positional", required: true },
+      time: { type: "positional", required: verb === "move" || verb === "split" },
+      dir: { type: "string" },
+      start: { type: "string" },
+      end: { type: "string" },
+      duration: { type: "string" },
+      plan: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      overwrite: { type: "boolean", default: false },
+      snap: { type: "boolean", default: false }
+    },
+    async run({ args }) {
+      await runMutation(verb, args);
+    }
+  });
+}
+var examples19, allRows, timeline_default;
 var init_timeline = __esm({
   "src/commands/timeline.ts"() {
     "use strict";
+    init_dist9();
+    init_dist3();
+    init_compositionFps();
     init_dist();
     init_describeProject();
     init_formatTimeline();
+    init_resolveRef();
+    init_timeExpr();
     init_dom();
+    init_commandResult();
     init_project();
     init_updateCheck();
     examples19 = [
       ["Show every track and clip of the project in the current directory", "hyperframes timeline"],
-      ["Same, as JSON for an agent", "hyperframes timeline ./my-video --json"]
+      ["Move a clip without writing", "hyperframes timeline move '#hero' +2 --plan"],
+      ["Delete a clip and return a receipt", "hyperframes timeline delete '#hero' --json"]
     ];
+    allRows = (timeline) => timeline.tracks.flatMap((track) => track.rows);
     timeline_default = defineCommand({
-      meta: {
-        name: "timeline",
-        description: "Print the project's tracks and clips (start, duration, source, volume, rate)"
-      },
+      meta: { name: "timeline", description: "Print and edit the project's tracks and clips" },
       args: {
         dir: { type: "positional", description: "Project directory", required: false },
         json: { type: "boolean", description: "Output as JSON", default: false }
       },
+      subCommands: {
+        move: () => mutationCommand("move"),
+        trim: () => mutationCommand("trim"),
+        split: () => mutationCommand("split"),
+        delete: () => mutationCommand("delete")
+      },
       async run({ args }) {
+        if (args._?.[0]) return;
         const project = resolveProject(args.dir);
         ensureDOMParser();
         const timeline = await describeProject(project.indexPath);
@@ -170543,7 +171149,7 @@ __export(benchmark_exports, {
   examples: () => examples20
 });
 import { existsSync as existsSync99, statSync as statSync41 } from "fs";
-import { resolve as resolve65, join as join116 } from "path";
+import { resolve as resolve65, join as join117 } from "path";
 var examples20, FPS_30, FPS_60, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -170622,7 +171228,7 @@ var init_benchmark = __esm({
           s?.start(`Benchmarking ${config.label}...`);
           for (let i = 0; i < runsPerConfig; i++) {
             s?.message(`${config.label} \u2014 run ${i + 1}/${runsPerConfig}`);
-            const outputPath = join116(
+            const outputPath = join117(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i}.mp4`
             );
@@ -171124,9 +171730,9 @@ var init_remove_background = __esm({
 
 // src/whisper/parakeet.ts
 import { execFileSync as execFileSync13 } from "child_process";
-import { existsSync as existsSync101, mkdtempSync as mkdtempSync23, readFileSync as readFileSync77, rmSync as rmSync36, writeFileSync as writeFileSync44 } from "fs";
+import { existsSync as existsSync101, mkdtempSync as mkdtempSync23, readFileSync as readFileSync78, rmSync as rmSync36, writeFileSync as writeFileSync44 } from "fs";
 import { homedir as homedir21, tmpdir as tmpdir15 } from "os";
-import { basename as basename25, extname as extname16, join as join117 } from "path";
+import { basename as basename25, extname as extname16, join as join118 } from "path";
 function isRunnable(bin) {
   try {
     execFileSync13(bin, ["--help"], { stdio: ["ignore", "ignore", "ignore"], timeout: 1e4 });
@@ -171138,7 +171744,7 @@ function isRunnable(bin) {
 function findParakeet() {
   const candidates = [
     process.env.HYPERFRAMES_PARAKEET,
-    join117(homedir21(), ".venvs", "parakeet", "bin", "parakeet-mlx")
+    join118(homedir21(), ".venvs", "parakeet", "bin", "parakeet-mlx")
   ].filter((p2) => Boolean(p2));
   for (const path of candidates) {
     if (existsSync101(path) && isRunnable(path)) return path;
@@ -171189,20 +171795,20 @@ function transcribeWithParakeet(inputPath, dir, options) {
   }
   const model = options?.model ?? DEFAULT_MODEL3;
   const cached3 = existsSync101(
-    join117(homedir21(), ".cache", "huggingface", "hub", `models--${model.replace(/\//g, "--")}`)
+    join118(homedir21(), ".cache", "huggingface", "hub", `models--${model.replace(/\//g, "--")}`)
   );
   options?.onProgress?.(
     cached3 ? "Transcribing with Parakeet..." : "Downloading Parakeet model (first run, ~600MB)..."
   );
-  const workDir = mkdtempSync23(join117(tmpdir15(), "hyperframes-parakeet-"));
+  const workDir = mkdtempSync23(join118(tmpdir15(), "hyperframes-parakeet-"));
   try {
     const argv2 = [inputPath, "--model", model, "--output-format", "json", "--output-dir", workDir];
     if (options?.language) argv2.push("--language", options.language);
     execFileSync13(runner, argv2, { stdio: ["ignore", "pipe", "pipe"], timeout: 18e5 });
-    const produced = join117(workDir, `${basename25(inputPath, extname16(inputPath))}.json`);
+    const produced = join118(workDir, `${basename25(inputPath, extname16(inputPath))}.json`);
     if (!existsSync101(produced)) throw new Error("Parakeet did not produce output.");
-    const words = mergeTokensToWords(JSON.parse(readFileSync77(produced, "utf-8")));
-    const transcriptPath = join117(dir, "transcript.json");
+    const words = mergeTokensToWords(JSON.parse(readFileSync78(produced, "utf-8")));
+    const transcriptPath = join118(dir, "transcript.json");
     writeFileSync44(transcriptPath, JSON.stringify(words, null, 2));
     const durationSeconds = words.length > 0 ? words[words.length - 1].end : 0;
     return { transcriptPath, wordCount: words.length, durationSeconds, speechOnsetSeconds: null };
@@ -171226,7 +171832,7 @@ __export(transcribe_exports2, {
   examples: () => examples23
 });
 import { existsSync as existsSync103, writeFileSync as writeFileSync45 } from "fs";
-import { resolve as resolve67, join as join118, extname as extname17, dirname as dirname56 } from "path";
+import { resolve as resolve67, join as join119, extname as extname17, dirname as dirname56 } from "path";
 function parseTimeoutMs(raw, json) {
   const source = raw ?? process.env["HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS"];
   if (source == null || source === "") return void 0;
@@ -171262,7 +171868,7 @@ async function importTranscript(inputPath, dir, json) {
   const { loadTranscript: loadTranscript2, patchCaptionHtml: patchCaptionHtml2 } = await Promise.resolve().then(() => (init_normalize(), normalize_exports));
   const { words, format } = loadTranscript2(inputPath);
   if (words.length === 0) exitNoWords(json);
-  const outPath = join118(dir, "transcript.json");
+  const outPath = join119(dir, "transcript.json");
   writeFileSync45(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
@@ -171280,7 +171886,7 @@ async function exportTranscript(inputPath, dir, to, output, json, preserveCues)
   const { words, format } = loadTranscript2(inputPath);
   if (words.length === 0) exitNoWords(json);
   const preGrouped = preserveCues || format === "srt" || format === "vtt" || void 0;
-  const outPath = resolve67(output ?? join118(dir, `transcript.${to}`));
+  const outPath = resolve67(output ?? join119(dir, `transcript.${to}`));
   const content = to === "srt" ? formatSrt2(words, { preGrouped }) : formatVtt2(words, { preGrouped });
   writeFileSync45(outPath, content);
   if (json) {
@@ -171503,7 +172109,7 @@ var init_transcribe2 = __esm({
 // src/tts/manager.ts
 import { existsSync as existsSync104, mkdirSync as mkdirSync54 } from "fs";
 import { homedir as homedir22 } from "os";
-import { join as join119 } from "path";
+import { join as join120 } from "path";
 function inferLangFromVoiceId(voiceId) {
   const first = voiceId.charAt(0).toLowerCase();
   return VOICE_PREFIX_LANG[first] ?? "en-us";
@@ -171512,7 +172118,7 @@ function isSupportedLang(value) {
   return SUPPORTED_LANGS.includes(value);
 }
 async function ensureModel3(model = DEFAULT_MODEL4, options) {
-  const modelPath2 = join119(MODELS_DIR4, `${model}.onnx`);
+  const modelPath2 = join120(MODELS_DIR4, `${model}.onnx`);
   if (existsSync104(modelPath2)) return modelPath2;
   const url = MODEL_URLS2[model];
   if (!url) {
@@ -171529,7 +172135,7 @@ async function ensureModel3(model = DEFAULT_MODEL4, options) {
   return modelPath2;
 }
 async function ensureVoices(options) {
-  const voicesPath = join119(VOICES_DIR, "voices-v1.0.bin");
+  const voicesPath = join120(VOICES_DIR, "voices-v1.0.bin");
   if (existsSync104(voicesPath)) return voicesPath;
   mkdirSync54(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
@@ -171544,9 +172150,9 @@ var init_manager4 = __esm({
   "src/tts/manager.ts"() {
     "use strict";
     init_download();
-    CACHE_DIR4 = join119(homedir22(), ".cache", "hyperframes", "tts");
-    MODELS_DIR4 = join119(CACHE_DIR4, "models");
-    VOICES_DIR = join119(CACHE_DIR4, "voices");
+    CACHE_DIR4 = join120(homedir22(), ".cache", "hyperframes", "tts");
+    MODELS_DIR4 = join120(CACHE_DIR4, "models");
+    VOICES_DIR = join120(CACHE_DIR4, "voices");
     DEFAULT_MODEL4 = "kokoro-v1.0";
     MODEL_URLS2 = {
       "kokoro-v1.0": "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx"
@@ -171689,7 +172295,7 @@ __export(synthesize_exports, {
 });
 import { execFileSync as execFileSync15 } from "child_process";
 import { existsSync as existsSync105, mkdirSync as mkdirSync55, readdirSync as readdirSync37, unlinkSync as unlinkSync9 } from "fs";
-import { join as join120, dirname as dirname57, basename as basename26 } from "path";
+import { join as join121, dirname as dirname57, basename as basename26 } from "path";
 import { homedir as homedir23 } from "os";
 function ensureSynthScript() {
   if (!existsSync105(SCRIPT_PATH)) {
@@ -171700,7 +172306,7 @@ function ensureSynthScript() {
       for (const entry of readdirSync37(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync9(join120(SCRIPT_DIR, entry));
+            unlinkSync9(join121(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -171848,8 +172454,8 @@ print(json.dumps({
     ESPEAK_LANG_OVERRIDES = {
       zh: "cmn"
     };
-    SCRIPT_DIR = join120(homedir23(), ".cache", "hyperframes", "tts");
-    SCRIPT_PATH = join120(SCRIPT_DIR, "synth-v3.py");
+    SCRIPT_DIR = join121(homedir23(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join121(SCRIPT_DIR, "synth-v3.py");
   }
 });
 
@@ -171859,7 +172465,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples24
 });
-import { existsSync as existsSync106, readFileSync as readFileSync78 } from "fs";
+import { existsSync as existsSync106, readFileSync as readFileSync79 } from "fs";
 import { resolve as resolve68, extname as extname18 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v2) => ({ ...v2, defaultLang: inferLangFromVoiceId(v2.id) }));
@@ -171977,7 +172583,7 @@ var init_tts = __esm({
         let text2;
         const maybeFile = resolve68(input2);
         if (existsSync106(maybeFile) && extname18(maybeFile).toLowerCase() === ".txt") {
-          text2 = readFileSync78(maybeFile, "utf-8").trim();
+          text2 = readFileSync79(maybeFile, "utf-8").trim();
           if (!text2) {
             console.error(c.error("File is empty."));
             failCommand();
@@ -172069,8 +172675,8 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples25
 });
-import { readFileSync as readFileSync79, existsSync as existsSync107 } from "fs";
-import { resolve as resolve69, dirname as dirname58, join as join121 } from "path";
+import { readFileSync as readFileSync80, existsSync as existsSync107 } from "fs";
+import { resolve as resolve69, dirname as dirname58, join as join123 } from "path";
 import { fileURLToPath as fileURLToPath15 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath15(import.meta.url);
@@ -172175,12 +172781,12 @@ var init_docs = __esm({
           }
           failCommand();
         }
-        const filePath = join121(docsDir(), entry.file);
+        const filePath = join123(docsDir(), entry.file);
         if (!existsSync107(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           failCommand();
         }
-        const content = readFileSync79(filePath, "utf-8");
+        const content = readFileSync80(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -172594,7 +173200,7 @@ __export(upgrade_exports, {
   upgradeProjectPins: () => upgradeProjectPins
 });
 import { execFileSync as execFileSync17 } from "child_process";
-import { existsSync as existsSync109, readFileSync as readFileSync80, writeFileSync as writeFileSync46, renameSync as renameSync20, readdirSync as readdirSync38 } from "fs";
+import { existsSync as existsSync109, readFileSync as readFileSync81, writeFileSync as writeFileSync46, renameSync as renameSync20, readdirSync as readdirSync38 } from "fs";
 import { resolve as resolve70 } from "path";
 async function confirmUpgrade() {
   const shouldUpgrade = await ue({ message: "Upgrade now?" });
@@ -172657,14 +173263,14 @@ async function upgradeProjectPins(dir, opts) {
   if (!existsSync109(pkgPath)) {
     return { changed: false, from: [], to: "", path: pkgPath };
   }
-  const raw = JSON.parse(readFileSync80(pkgPath, "utf-8"));
+  const raw = JSON.parse(readFileSync81(pkgPath, "utf-8"));
   const scripts = raw.scripts ?? {};
   const { latest } = await checkForUpdate(true);
   if (!isSafeVersion(latest)) return { changed: false, from: [], to: latest, path: pkgPath };
   const rewrite = rewriteProjectPinnedScripts(scripts, latest);
   const wrapperRewrites = readdirSync38(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".sh")).map((entry) => {
     const path = resolve70(dir, entry.name);
-    return { path, rewrite: rewritePinnedHyperframesText(readFileSync80(path, "utf-8"), latest) };
+    return { path, rewrite: rewritePinnedHyperframesText(readFileSync81(path, "utf-8"), latest) };
   });
   if (rewrite.changed && !opts.check) {
     raw.scripts = rewrite.scripts;
@@ -173378,8 +173984,8 @@ __export(contactSheet_exports, {
   createSvgContactSheet: () => createSvgContactSheet
 });
 import sharp from "sharp";
-import { readdirSync as readdirSync39, readFileSync as readFileSync81, writeFileSync as writeFileSync47, unlinkSync as unlinkSync10, existsSync as existsSync110 } from "fs";
-import { join as join123, extname as extname19, basename as basename27, dirname as dirname60 } from "path";
+import { readdirSync as readdirSync39, readFileSync as readFileSync83, writeFileSync as writeFileSync47, unlinkSync as unlinkSync10, existsSync as existsSync110 } from "fs";
+import { join as join124, extname as extname19, basename as basename27, dirname as dirname60 } from "path";
 async function createContactSheet(imagePaths, outputPath, opts = {}) {
   const {
     cols = 3,
@@ -173468,7 +174074,7 @@ async function createScrollContactSheet(screenshotsDir, outputPath, budget = {})
   if (!existsSync110(screenshotsDir)) return [];
   const scrollFiles = readdirSync39(screenshotsDir).filter((f) => f.startsWith("scroll-") && f.endsWith(".png")).sort();
   if (scrollFiles.length === 0) return [];
-  const paths = scrollFiles.map((f) => join123(screenshotsDir, f));
+  const paths = scrollFiles.map((f) => join124(screenshotsDir, f));
   const labels = scrollFiles.map((f) => {
     const m = f.match(/scroll-(\d+)\.png/);
     return m ? `${m[1]}% scroll` : f;
@@ -173485,7 +174091,7 @@ async function createSnapshotContactSheet(snapshotsDir, outputPath, budget = {})
   if (!existsSync110(snapshotsDir)) return [];
   const snapshotFiles = readdirSync39(snapshotsDir).filter((f) => f.startsWith("frame-") && f.endsWith(".png")).sort();
   if (snapshotFiles.length === 0) return [];
-  const paths = snapshotFiles.map((f) => join123(snapshotsDir, f));
+  const paths = snapshotFiles.map((f) => join124(snapshotsDir, f));
   const labels = snapshotFiles.map((f) => {
     const m = f.match(/at-([\d.]+)s/);
     return m ? `${m[1]}s` : f;
@@ -173503,7 +174109,7 @@ async function createAssetContactSheet(assetsDir, outputPath, budget = {}) {
   const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
   const assetFiles = readdirSync39(assetsDir).filter((f) => imageExts.has(extname19(f).toLowerCase()) && !f.includes("contact-sheet")).sort();
   if (assetFiles.length === 0) return [];
-  const paths = assetFiles.map((f) => join123(assetsDir, f));
+  const paths = assetFiles.map((f) => join124(assetsDir, f));
   return createContactSheetPages(paths, outputPath, {
     cols: 4,
     cellWidth: 480,
@@ -173523,7 +174129,7 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget
     for (const f of readdirSync39(dir).filter((f2) => f2.endsWith(".svg")).sort()) {
       if (!seen.has(f)) {
         seen.add(f);
-        svgPaths.push(join123(dir, f));
+        svgPaths.push(join124(dir, f));
       }
     }
   }
@@ -173536,9 +174142,9 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget
   for (let i = 0; i < svgPaths.length; i++) {
     if ((budget.remainingMs?.() ?? 1) <= 0) break;
     const svgPath = svgPaths[i];
-    const tmpPath = join123(tmpDir, `.thumb-${i}.png`);
+    const tmpPath = join124(tmpDir, `.thumb-${i}.png`);
     try {
-      const svgBuf = readFileSync81(svgPath);
+      const svgBuf = readFileSync83(svgPath);
       const thumb = await sharp(svgBuf).resize(thumbSize, thumbSize, {
         fit: "contain",
         background: { r: 245, g: 245, b: 245, alpha: 1 }
@@ -173591,12 +174197,12 @@ __export(snapshot_exports, {
   requireSnapshotFfmpeg: () => requireSnapshotFfmpeg,
   resolveSnapshotVideoClipStart: () => resolveSnapshotVideoClipStart,
   resolveSnapshotVideoFrameTime: () => resolveSnapshotVideoFrameTime,
-  resolveSnapshotVideoPlaybackRate: () => resolveSnapshotVideoPlaybackRate,
+  resolveSnapshotVideoRateSpec: () => resolveSnapshotVideoRateSpec,
   tailFrameTime: () => tailFrameTime
 });
-import { existsSync as existsSync111, mkdtempSync as mkdtempSync24, readFileSync as readFileSync83, mkdirSync as mkdirSync56, rmSync as rmSync37, writeFileSync as writeFileSync48 } from "fs";
+import { existsSync as existsSync111, mkdtempSync as mkdtempSync24, readFileSync as readFileSync84, mkdirSync as mkdirSync56, rmSync as rmSync37, writeFileSync as writeFileSync48 } from "fs";
 import { tmpdir as tmpdir16 } from "os";
-import { resolve as resolve72, join as join124, relative as relative31, isAbsolute as isAbsolute19, basename as basename28, posix as posix6 } from "path";
+import { resolve as resolve72, join as join125, relative as relative31, isAbsolute as isAbsolute19, basename as basename28, posix as posix6 } from "path";
 function orbitStageSource() {
   return `function(cam) {
     var root = document.querySelector("[data-composition-id]")
@@ -173635,10 +174241,13 @@ function resolveSnapshotVideoFrameTime(input2) {
 function resolveSnapshotVideoClipStart(input2) {
   return input2.runtimeResolvedStart ?? input2.authoredStart;
 }
-function resolveSnapshotVideoPlaybackRate(input2) {
+function resolveSnapshotVideoRateSpec(input2) {
   const authoredRate = Number.parseFloat(input2.authoredRate ?? "");
-  const rawRate = Number.isFinite(authoredRate) && authoredRate > 0 ? authoredRate : input2.defaultRate;
-  return Number.isFinite(rawRate) && rawRate > 0 ? Math.max(0.1, Math.min(5, rawRate)) : 1;
+  const attrs2 = {
+    "data-playback-rate": Number.isFinite(authoredRate) && authoredRate > 0 ? input2.authoredRate : String(input2.defaultRate),
+    "data-automation": input2.authoredAutomation
+  };
+  return readElementRateSpec({ getAttribute: (name) => attrs2[name] ?? null });
 }
 function requireSnapshotFfmpeg(ffmpegPath) {
   if (ffmpegPath) return ffmpegPath;
@@ -173647,8 +174256,8 @@ function requireSnapshotFfmpeg(ffmpegPath) {
   );
 }
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false, accurateSeek = false) {
-  const tmp = mkdtempSync24(join124(tmpdir16(), "hf-snapshot-frame-"));
-  const outPath = join124(tmp, "frame.png");
+  const tmp = mkdtempSync24(join125(tmpdir16(), "hf-snapshot-frame-"));
+  const outPath = join125(tmp, "frame.png");
   try {
     const ffmpegPath = requireSnapshotFfmpeg(findFFmpeg());
     const args = ["-hide_banner", "-loglevel", "error"];
@@ -173667,7 +174276,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
     );
     const result = await runFfmpegOnce(ffmpegPath, args, FFMPEG_EXTRACT_TIMEOUT_MS);
     if (result.code !== 0 || result.timedOut || !existsSync111(outPath)) return null;
-    return readFileSync83(outPath);
+    return readFileSync84(outPath);
   } finally {
     try {
       rmSync37(tmp, { recursive: true, force: true });
@@ -173759,13 +174368,13 @@ async function captureSnapshots(projectDir, opts) {
         );
       }
       const cameraExpr = opts.angle && (opts.angle.yaw !== 0 || opts.angle.pitch !== 0) ? `(${orbitStageSource()})(${JSON.stringify(opts.angle)})` : null;
-      const snapshotDir = opts.outputDir ?? join124(projectDir, "snapshots");
+      const snapshotDir = opts.outputDir ?? join125(projectDir, "snapshots");
       mkdirSync56(snapshotDir, { recursive: true });
       try {
         const { readdirSync: readdirSync46 } = await import("fs");
         for (const file of readdirSync46(snapshotDir)) {
           if (/\.(png|jpg|jpeg)$/i.test(file)) {
-            rmSync37(join124(snapshotDir, file), { force: true });
+            rmSync37(join125(snapshotDir, file), { force: true });
           }
         }
       } catch {
@@ -173815,6 +174424,7 @@ async function captureSnapshots(projectDir, opts) {
                 src: v2.currentSrc || v2.src,
                 authoredStart,
                 authoredRate: v2.dataset.playbackRate,
+                authoredAutomation: v2.dataset.automation,
                 defaultRate: v2.defaultPlaybackRate,
                 runtimeResolvedStart: runtimeResolvedStart !== void 0 && Number.isFinite(runtimeResolvedStart) ? runtimeResolvedStart : null,
                 authoredDuration: Number.isFinite(rawDuration) && rawDuration > 0 ? rawDuration : null,
@@ -173826,9 +174436,12 @@ async function captureSnapshots(projectDir, opts) {
           });
           const active = candidates.flatMap((candidate) => {
             const start = resolveSnapshotVideoClipStart(candidate);
-            const playbackRate = resolveSnapshotVideoPlaybackRate(candidate);
-            const duration2 = candidate.authoredDuration ?? (candidate.srcDuration > 0 ? Math.max(0, (candidate.srcDuration - candidate.mediaStart) / playbackRate) : Number.POSITIVE_INFINITY);
-            let relTime = (time - start) * playbackRate + candidate.mediaStart;
+            const playbackRate = resolveSnapshotVideoRateSpec(candidate);
+            const duration2 = candidate.authoredDuration ?? (candidate.srcDuration > 0 ? Math.max(
+              0,
+              timeAtSourceTime(playbackRate, candidate.srcDuration - candidate.mediaStart)
+            ) : Number.POSITIVE_INFINITY);
+            let relTime = sourceTimeAt(playbackRate, time - start) + candidate.mediaStart;
             if (candidate.loop && candidate.srcDuration > candidate.mediaStart && relTime >= candidate.srcDuration) {
               relTime = candidate.mediaStart + (relTime - candidate.mediaStart) % (candidate.srcDuration - candidate.mediaStart);
             }
@@ -173895,7 +174508,7 @@ async function captureSnapshots(projectDir, opts) {
         const timeLabel = formatSnapshotTimestamp(time);
         const index = String(i).padStart(2, "0");
         const filename = `frame-${index}-at-${timeLabel}.png`;
-        const framePath = join124(snapshotDir, filename);
+        const framePath = join125(snapshotDir, filename);
         if (opts.zoom) {
           const canvas = await page.evaluate(() => ({
             width: window.innerWidth,
@@ -173924,9 +174537,9 @@ async function captureSnapshots(projectDir, opts) {
               `   ${c.warn("\u26A0")} --against has no frame at ${timeLabel} \u2014 reference pair skipped`
             );
           } else {
-            const refPath = join124(snapshotDir, `ref-${index}-at-${timeLabel}.png`);
+            const refPath = join125(snapshotDir, `ref-${index}-at-${timeLabel}.png`);
             writeFileSync48(refPath, refPng);
-            const pairPath = join124(snapshotDir, `pair-${index}-at-${timeLabel}.jpg`);
+            const pairPath = join125(snapshotDir, `pair-${index}-at-${timeLabel}.jpg`);
             const { createContactSheet: createContactSheet2 } = await Promise.resolve().then(() => (init_contactSheet(), contactSheet_exports));
             await createContactSheet2([framePath, refPath], pairPath, {
               cols: 2,
@@ -173955,6 +174568,7 @@ var init_snapshot = __esm({
     init_commandResult();
     init_dist();
     init_captureCompositionFrame();
+    init_dist3();
     init_project();
     init_lintProject();
     init_lintFormat();
@@ -174092,7 +174706,7 @@ var init_snapshot = __esm({
         const angleLabel = camera && (camera.yaw !== 0 || camera.pitch !== 0) ? ` ${c.dim(`(angle yaw ${camera.yaw}\xB0 pitch ${camera.pitch}\xB0)`)}` : "";
         console.log(`${c.accent("\u25C6")}  Capturing ${label2} from ${c.accent(project.name)}${angleLabel}`);
         try {
-          const snapshotDir = args.output ? resolve72(String(args.output)) : join124(project.dir, "snapshots");
+          const snapshotDir = args.output ? resolve72(String(args.output)) : join125(project.dir, "snapshots");
           const paths = await captureSnapshots(project.dir, {
             frames,
             timeout,
@@ -174129,7 +174743,7 @@ ${c.success("\u25C7")}  ${paths.length} snapshots saved to ${args.output ? snaps
             const { createSnapshotContactSheet: createSnapshotContactSheet2 } = await Promise.resolve().then(() => (init_contactSheet(), contactSheet_exports));
             const sheets = await createSnapshotContactSheet2(
               snapshotDir,
-              join124(snapshotDir, "contact-sheet.jpg")
+              join125(snapshotDir, "contact-sheet.jpg")
             );
             if (sheets.length > 0) {
               const label3 = sheets.length === 1 ? "contact-sheet.jpg" : `contact-sheet-1..${sheets.length}.jpg`;
@@ -174165,9 +174779,9 @@ ${c.success("\u25C7")}  ${paths.length} snapshots saved to ${args.output ? snaps
                 const results = await Promise.allSettled(
                   paths.map(async (p2) => {
                     const filename = basename28(p2);
-                    const filePath = join124(snapshotDir, filename);
+                    const filePath = join125(snapshotDir, filename);
                     if (!existsSync111(filePath)) return { filename, desc: "file not found" };
-                    const raw = readFileSync83(filePath);
+                    const raw = readFileSync84(filePath);
                     let imageData;
                     let mimeType = "image/png";
                     if (sharpFn) {
@@ -174203,7 +174817,7 @@ ${c.success("\u25C7")}  ${paths.length} snapshots saved to ${args.output ? snaps
                     descriptions.push(`## (error)`, `Gemini call failed: ${errMsg.slice(0, 120)}`, ``);
                   }
                 }
-                const descPath = join124(snapshotDir, "descriptions.md");
+                const descPath = join125(snapshotDir, "descriptions.md");
                 writeFileSync48(descPath, descriptions.join("\n"));
                 console.log(`   ${c.dim("descriptions.md")} (Gemini frame analysis)`);
               }
@@ -174536,8 +175150,8 @@ __export(media_treatment_exports, {
   mediaTreatmentCommand: () => mediaTreatmentCommand,
   resolveMediaTreatmentSource: () => resolveMediaTreatmentSource
 });
-import { existsSync as existsSync112, readFileSync as readFileSync84, writeFileSync as writeFileSync49 } from "fs";
-import { join as join125, relative as relative34, resolve as resolve74 } from "path";
+import { existsSync as existsSync112, readFileSync as readFileSync85, writeFileSync as writeFileSync49 } from "fs";
+import { join as join126, relative as relative34, resolve as resolve74 } from "path";
 function getMediaTreatmentCapabilityOverview() {
   const capabilities = getHfColorGradingCapabilities();
   const family = (id, label2, description) => ({
@@ -174915,7 +175529,7 @@ function resolveMediaTreatmentSource(projectDir, compositionFile, source) {
   }
   const cleanSource = cleanAssetUrl(sourceUrl);
   if (!cleanSource) throw new Error("Selected media has no analyzable local src");
-  const projectRelative = cleanSource.startsWith("/") ? cleanSource : rewriteAssetPath(compositionFile, cleanSource, (path) => existsSync112(join125(projectDir, path)));
+  const projectRelative = cleanSource.startsWith("/") ? cleanSource : rewriteAssetPath(compositionFile, cleanSource, (path) => existsSync112(join126(projectDir, path)));
   const asset = resolveExistingLocalAsset(projectDir, projectRelative);
   if (!asset) throw new Error(`Media file not found: ${source}`);
   return asset.resolved;
@@ -174980,7 +175594,7 @@ function analyzeTarget(args) {
   }
   const selectorIndex = parseSelectorIndex(readOptionalString(args["selector-index"]));
   const { element, tag } = selectMediaElement(
-    readFileSync84(filePath, "utf8"),
+    readFileSync85(filePath, "utf8"),
     selector,
     selectorIndex
   );
@@ -174998,14 +175612,14 @@ function analyzeTarget(args) {
     ...analyzeMediaTreatment(mediaPath)
   };
 }
-function prepareMutation(args) {
+function prepareMutation2(args) {
   const { project, filePath } = resolveMutationFile(args);
   const selector = readOptionalString(args.selector);
   if (!selector) throw new Error("--selector is required");
   const clear = args.clear === true;
   const apply = args.apply === true;
   const selectorIndex = parseSelectorIndex(readOptionalString(args["selector-index"]));
-  const result = applyMediaTreatmentToHtml(readFileSync84(filePath, "utf8"), {
+  const result = applyMediaTreatmentToHtml(readFileSync85(filePath, "utf8"), {
     selector,
     selectorIndex,
     grading: parseGrading(readOptionalString(args.grading), apply, clear),
@@ -175047,7 +175661,7 @@ function printAnalysis(args) {
   console.log(`   suggested patch: ${JSON.stringify(result.suggestedPatch)}`);
 }
 function printMutation(args) {
-  const { action, result, selector, payload } = prepareMutation(args);
+  const { action, result, selector, payload } = prepareMutation2(args);
   if (args.json === true) {
     console.log(JSON.stringify(withMeta(payload), null, 2));
     return;
@@ -175194,12 +175808,12 @@ import {
   existsSync as existsSync113,
   mkdirSync as mkdirSync57,
   mkdtempSync as mkdtempSync25,
-  readFileSync as readFileSync85,
+  readFileSync as readFileSync86,
   rmSync as rmSync38,
   writeFileSync as writeFileSync50
 } from "fs";
 import { tmpdir as tmpdir17 } from "os";
-import { basename as basename30, dirname as dirname61, extname as extname21, join as join126, resolve as resolve75 } from "path";
+import { basename as basename30, dirname as dirname61, extname as extname21, join as join127, resolve as resolve75 } from "path";
 import sharp2 from "sharp";
 function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -175290,7 +175904,7 @@ function parseGradesFile(filePath) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync85(filePath, "utf-8"));
+    parsed = JSON.parse(readFileSync86(filePath, "utf-8"));
   } catch (err) {
     throw new Error(`Could not parse grades JSON: ${normalizeErrorMessage(err)}`);
   }
@@ -175455,10 +176069,10 @@ function frameFileNameForPath(framePath) {
   return "frame.png";
 }
 async function prepareGradeCompareTempProject(opts) {
-  const tempDir = mkdtempSync25(join126(tmpdir17(), "hf-grade-compare-"));
+  const tempDir = mkdtempSync25(join127(tmpdir17(), "hf-grade-compare-"));
   try {
     const frameFileName2 = opts.frameFileName ?? frameFileNameForPath(opts.framePath);
-    writeFileSync50(join126(tempDir, frameFileName2), opts.frameBuffer);
+    writeFileSync50(join127(tempDir, frameFileName2), opts.frameBuffer);
     let lutIndex = 0;
     const stagedCells = opts.cells.map((cell) => {
       const lutSrc = lutSrcFromGrading(cell.grading);
@@ -175467,7 +176081,7 @@ async function prepareGradeCompareTempProject(opts) {
       if (!existsSync113(sourcePath)) {
         throw new Error(`LUT file not found for "${cell.label}": ${sourcePath}`);
       }
-      const lutText = readFileSync85(sourcePath, "utf-8");
+      const lutText = readFileSync86(sourcePath, "utf-8");
       try {
         parseCubeLut(lutText, { maxSize: 64 });
       } catch (err) {
@@ -175478,7 +176092,7 @@ async function prepareGradeCompareTempProject(opts) {
       const lutExt = extname21(sourcePath) || ".cube";
       const stagedName = `lut-${lutIndex}${lutExt}`;
       lutIndex += 1;
-      copyFileSync10(sourcePath, join126(tempDir, stagedName));
+      copyFileSync10(sourcePath, join127(tempDir, stagedName));
       return {
         label: cell.label,
         grading: rewriteGradingLutSrc(cell.grading, stagedName)
@@ -175490,7 +176104,7 @@ async function prepareGradeCompareTempProject(opts) {
       frameWidth: opts.frameWidth,
       frameHeight: opts.frameHeight
     });
-    writeFileSync50(join126(tempDir, "index.html"), html);
+    writeFileSync50(join127(tempDir, "index.html"), html);
     return { tempDir, html, cells: stagedCells };
   } catch (err) {
     rmSync38(tempDir, { recursive: true, force: true });
@@ -175502,8 +176116,8 @@ function isVideoPath2(filePath) {
   return [".mp4", ".mov", ".m4v", ".webm", ".mkv", ".avi", ".mpeg", ".mpg", ".ogv"].includes(ext);
 }
 async function extractVideoFrameToBuffer2(videoPath) {
-  const tmp = mkdtempSync25(join126(tmpdir17(), "hf-grade-compare-frame-"));
-  const outPath = join126(tmp, "frame.png");
+  const tmp = mkdtempSync25(join127(tmpdir17(), "hf-grade-compare-frame-"));
+  const outPath = join127(tmp, "frame.png");
   try {
     const ffmpegPath = findFFmpeg();
     if (!ffmpegPath) return null;
@@ -175530,7 +176144,7 @@ async function extractVideoFrameToBuffer2(videoPath) {
       const detail = result.stderr.trim() ? `: ${result.stderr.trim()}` : "";
       throw new Error(`ffmpeg could not extract first frame from ${videoPath}${detail}`);
     }
-    return readFileSync85(outPath);
+    return readFileSync86(outPath);
   } finally {
     rmSync38(tmp, { recursive: true, force: true });
   }
@@ -175539,7 +176153,7 @@ async function loadReferenceFrame(framePath) {
   if (!existsSync113(framePath)) {
     throw new Error(`Reference frame not found: ${framePath}`);
   }
-  const buffer = isVideoPath2(framePath) ? await extractVideoFrameToBuffer2(framePath) : readFileSync85(framePath);
+  const buffer = isVideoPath2(framePath) ? await extractVideoFrameToBuffer2(framePath) : readFileSync86(framePath);
   if (!buffer) {
     throw new Error(`Could not extract a frame from video: ${framePath}`);
   }
@@ -175558,7 +176172,7 @@ async function captureGradeCompareSheet(projectDir, timeoutMs) {
   const { bundleToSingleHtml: bundleToSingleHtml2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
   const html = await bundleToSingleHtml2(projectDir);
   const server = await serveStaticProjectHtml(projectDir, html);
-  const sheetPath = join126(projectDir, "grade-compare.png");
+  const sheetPath = join127(projectDir, "grade-compare.png");
   try {
     const {
       browser: chromeBrowser,
@@ -175746,7 +176360,7 @@ __export(compare_exports, {
 });
 import { cpSync as cpSync6, existsSync as existsSync114, mkdirSync as mkdirSync58, mkdtempSync as mkdtempSync26, renameSync as renameSync21, rmSync as rmSync39, statSync as statSync43 } from "fs";
 import { tmpdir as tmpdir18 } from "os";
-import { basename as basename31, dirname as dirname62, extname as extname23, join as join127 } from "path";
+import { basename as basename31, dirname as dirname62, extname as extname23, join as join128 } from "path";
 function defaultLabelForPath(input2) {
   const name = basename31(input2);
   return extname23(name).toLowerCase() === ".html" ? basename31(name, extname23(name)) : name;
@@ -175845,7 +176459,7 @@ function inputError(variant) {
   );
 }
 function stageHtmlVariant(variant) {
-  const stagedDir = mkdtempSync26(join127(tmpdir18(), "hf-compare-variant-"));
+  const stagedDir = mkdtempSync26(join128(tmpdir18(), "hf-compare-variant-"));
   try {
     cpSync6(dirname62(variant.inputPath), stagedDir, {
       recursive: true,
@@ -175856,7 +176470,7 @@ function stageHtmlVariant(variant) {
     });
     const sourceName = basename31(variant.inputPath);
     if (sourceName !== "index.html") {
-      renameSync21(join127(stagedDir, sourceName), join127(stagedDir, "index.html"));
+      renameSync21(join128(stagedDir, sourceName), join128(stagedDir, "index.html"));
     }
     return {
       ...variant,
@@ -175876,7 +176490,7 @@ function prepareCompareVariantProjects(variants) {
         throw inputError(variant);
       }
       const stat = statSync43(variant.inputPath);
-      if (stat.isDirectory() && existsSync114(join127(variant.inputPath, "index.html"))) {
+      if (stat.isDirectory() && existsSync114(join128(variant.inputPath, "index.html"))) {
         prepared.push({
           ...variant,
           projectDir: variant.inputPath
@@ -175942,13 +176556,13 @@ async function renderCompareSheet(parsed) {
   const capResult = capCompareVariants(parsed.variants);
   const variants = capResult.variants;
   const prepared = prepareCompareVariantProjects(variants);
-  const frameDir = mkdtempSync26(join127(tmpdir18(), "hf-compare-frames-"));
+  const frameDir = mkdtempSync26(join128(tmpdir18(), "hf-compare-frames-"));
   const framePaths = [];
   try {
     let renderReadyTimedOut = false;
     for (let i = 0; i < prepared.length; i++) {
       const variant = prepared[i];
-      const framePath = join127(frameDir, `variant-${String(i + 1).padStart(2, "0")}.png`);
+      const framePath = join128(frameDir, `variant-${String(i + 1).padStart(2, "0")}.png`);
       const rendered = await renderCompareVariant(variant, {
         atSeconds: parsed.atSeconds,
         framePath,
@@ -176459,7 +177073,7 @@ var init_captureImageValidation = __esm({
 
 // src/capture/assetDownloader.ts
 import { writeFileSync as writeFileSync51, mkdirSync as mkdirSync59 } from "fs";
-import { join as join128, extname as extname24 } from "path";
+import { join as join129, extname as extname24 } from "path";
 import { createHash as createHash27 } from "crypto";
 function noDrops() {
   return { "size-floor": 0, "budget-exhausted": 0, "cap-reached": 0, unavailable: 0 };
@@ -176521,7 +177135,7 @@ async function fetchAndInspectIcon(icon, rank, stem, outputDir, timeoutMs, byteB
   const ext = await captureImageExtension(buffer);
   if (!ext) return null;
   const file = `assets/${stem}${ext}`;
-  writeFileSync51(join128(outputDir, file), buffer);
+  writeFileSync51(join129(outputDir, file), buffer);
   const verdict = await classifyIcon(buffer, ext);
   return {
     buffer,
@@ -176543,7 +177157,7 @@ function promoteHeadline(manifest, bytesByFile, outputDir) {
   )[0];
   if (!chosen) return null;
   const file = `assets/favicon${extname24(chosen.file)}`;
-  writeFileSync51(join128(outputDir, file), bytesByFile.get(chosen.file));
+  writeFileSync51(join129(outputDir, file), bytesByFile.get(chosen.file));
   manifest.headline = {
     file,
     source: chosen.file,
@@ -176598,13 +177212,13 @@ async function downloadDeclaredIcons(faviconLinks, outputDir, drops, options) {
 }
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks, options = {}) {
   options = { ...options, byteBudget: options.byteBudget ?? createCaptureDownloadBudget() };
-  const assetsDir = join128(outputDir, "assets");
+  const assetsDir = join129(outputDir, "assets");
   mkdirSync59(assetsDir, { recursive: true });
   const assets = [];
   const drops = noDrops();
   const downloadedUrls = /* @__PURE__ */ new Set();
   let icons = emptyIconManifest();
-  mkdirSync59(join128(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync59(join129(outputDir, "assets", "svgs"), { recursive: true });
   const usedSvgNames = /* @__PURE__ */ new Set();
   const MAX_INLINE_SVGS = 30;
   drops["cap-reached"] += Math.max(0, tokens.svgs.length - MAX_INLINE_SVGS);
@@ -176626,7 +177240,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks,
     const name = `${finalSlug}.svg`;
     const localPath = `assets/svgs/${name}`;
     try {
-      writeFileSync51(join128(outputDir, localPath), svgFile, "utf-8");
+      writeFileSync51(join129(outputDir, localPath), svgFile, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
       drops.unavailable++;
@@ -176716,7 +177330,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks,
         const name = `${slug}${ext}`;
         usedNames.add(slug);
         const localPath = `assets/${name}`;
-        writeFileSync51(join128(outputDir, localPath), buffer);
+        writeFileSync51(join129(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -176743,7 +177357,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks,
           drops["size-floor"]++;
         } else {
           const localPath = `assets/og-image${ext}`;
-          writeFileSync51(join128(outputDir, localPath), buffer);
+          writeFileSync51(join129(outputDir, localPath), buffer);
           assets.push({ url: tokens.ogImage, localPath, type: "image" });
         }
       }
@@ -176769,7 +177383,7 @@ function normalizeUrl(u) {
 }
 async function downloadAndRewriteFonts(css, outputDir, options = {}) {
   options = { ...options, byteBudget: options.byteBudget ?? createCaptureDownloadBudget() };
-  const assetsDir = join128(outputDir, "assets", "fonts");
+  const assetsDir = join129(outputDir, "assets", "fonts");
   mkdirSync59(assetsDir, { recursive: true });
   const drops = noDrops();
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
@@ -176827,7 +177441,7 @@ async function downloadAndRewriteFonts(css, outputDir, options = {}) {
       const extension = buffer && captureFontExtension(buffer);
       if (buffer && extension) {
         const filename = captureFontFilename(fontUrl, extension, usedFontNames);
-        const localPath = join128(assetsDir, filename);
+        const localPath = join129(assetsDir, filename);
         const relativePath = `assets/fonts/${filename}`;
         writeFileSync51(localPath, buffer);
         rewritten = rewritten.split(fontUrl).join(relativePath);
@@ -176949,8 +177563,8 @@ __export(video_exports, {
   runVideoMode: () => runVideoMode,
   safeFilename: () => safeFilename
 });
-import { createWriteStream as createWriteStream3, existsSync as existsSync115, mkdirSync as mkdirSync60, readFileSync as readFileSync86, unlinkSync as unlinkSync11 } from "fs";
-import { resolve as resolve76, join as join129, basename as basename32 } from "path";
+import { createWriteStream as createWriteStream3, existsSync as existsSync115, mkdirSync as mkdirSync60, readFileSync as readFileSync87, unlinkSync as unlinkSync11 } from "fs";
+import { resolve as resolve76, join as join130, basename as basename32 } from "path";
 async function streamToFile(url, destPath) {
   const r = await safeFetch(url, {
     signal: AbortSignal.timeout(12e4),
@@ -177069,8 +177683,8 @@ function pickManifestEntry(manifest, args) {
 }
 async function runVideoMode(args) {
   const projectDir = resolve76(args.project);
-  const directPath = join129(projectDir, "extracted", "video-manifest.json");
-  const w2hPath = join129(projectDir, "capture", "extracted", "video-manifest.json");
+  const directPath = join130(projectDir, "extracted", "video-manifest.json");
+  const w2hPath = join130(projectDir, "capture", "extracted", "video-manifest.json");
   const manifestPath3 = existsSync115(directPath) ? directPath : w2hPath;
   const isW2hLayout = manifestPath3 === w2hPath;
   if (!existsSync115(manifestPath3)) {
@@ -177083,7 +177697,7 @@ async function runVideoMode(args) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync86(manifestPath3, "utf-8"));
+    manifest = JSON.parse(readFileSync87(manifestPath3, "utf-8"));
   } catch (e2) {
     console.error(`${c.error("\u2717")} video-manifest.json is malformed: ${e2.message}`);
     setCommandExitCode(1);
@@ -177124,10 +177738,10 @@ async function runVideoMode(args) {
     setCommandExitCode(1);
     return;
   }
-  const outDir = isW2hLayout ? join129(projectDir, "capture", "assets", "videos") : join129(projectDir, "assets", "videos");
+  const outDir = isW2hLayout ? join130(projectDir, "capture", "assets", "videos") : join130(projectDir, "assets", "videos");
   mkdirSync60(outDir, { recursive: true });
   const fname = safeFilename(entry.filename || basename32(entry.url));
-  const outPath = join129(outDir, fname);
+  const outPath = join130(outDir, fname);
   const relPath = isW2hLayout ? `capture/assets/videos/${fname}` : `assets/videos/${fname}`;
   console.log(
     `${c.accent("\u25B8")} downloading [${entry.index}] ${entry.filename} (${entry.sourceWidth || entry.width}\xD7${entry.sourceHeight || entry.height})`
@@ -178624,8 +179238,8 @@ var init_designStyleExtractor = __esm({
 });
 
 // src/capture/fontMetadataExtractor.ts
-import { readdirSync as readdirSync40, readFileSync as readFileSync87, writeFileSync as writeFileSync53, existsSync as existsSync116 } from "fs";
-import { join as join130 } from "path";
+import { readdirSync as readdirSync40, readFileSync as readFileSync88, writeFileSync as writeFileSync53, existsSync as existsSync116 } from "fs";
+import { join as join131 } from "path";
 import * as fontkit from "fontkit";
 function isFontCollection(value) {
   return value.type === "TTC" || value.type === "DFont";
@@ -178636,7 +179250,7 @@ function extractFontMetadata(fontsDir, outputPath) {
   if (existsSync116(fontsDir)) {
     const fontFiles = readdirSync40(fontsDir).filter((f) => /\.(woff2?|ttf|otf)$/i.test(f));
     for (const filename of fontFiles) {
-      const fullPath = join130(fontsDir, filename);
+      const fullPath = join131(fontsDir, filename);
       const meta = readSingleFont(fullPath, filename);
       if (meta.identified) {
         files.push(meta);
@@ -178675,7 +179289,7 @@ function readSingleFont(fullPath, filename) {
     isIcon: false
   };
   try {
-    const buf = readFileSync87(fullPath);
+    const buf = readFileSync88(fullPath);
     const created = fontkit.create(buf);
     const font = isFontCollection(created) ? created.fonts[0] : created;
     if (!font) return empty2;
@@ -179191,8 +179805,8 @@ var init_lottiePreviewRequests = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync61, writeFileSync as writeFileSync54, readdirSync as readdirSync41, readFileSync as readFileSync88, statSync as statSync44 } from "fs";
-import { join as join131, extname as extname25 } from "path";
+import { mkdirSync as mkdirSync61, writeFileSync as writeFileSync54, readdirSync as readdirSync41, readFileSync as readFileSync89, statSync as statSync44 } from "fs";
+import { join as join133, extname as extname25 } from "path";
 function liveRemainingMs(budget, fallbackMs) {
   return budget.remainingMs?.() ?? fallbackMs;
 }
@@ -179230,7 +179844,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir, budget = {}) {
         if (savedHashes.has(hash2)) continue;
         savedHashes.add(hash2);
         if (!validLottieJson(jsonData)) continue;
-        writeFileSync54(join131(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync54(join133(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -179240,18 +179854,18 @@ async function saveLottieAnimations(discoveredLotties, lottieDir, budget = {}) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget = {}) {
   const manifest = [];
-  const previewDir = join131(lottieDir, "previews");
+  const previewDir = join133(lottieDir, "previews");
   mkdirSync61(previewDir, { recursive: true });
   for (const file of readdirSync41(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     if (liveRemainingMs(budget, 1) <= 0) break;
     try {
-      const raw = JSON.parse(readFileSync88(join131(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync89(join133(lottieDir, file), "utf-8"));
       const fr = raw.fr || 30;
       const dur = ((raw.op || 0) - (raw.ip || 0)) / fr;
       const previewName = file.replace(".json", "-preview.png");
       let preview;
-      const fileSize = statSync44(join131(lottieDir, file)).size;
+      const fileSize = statSync44(join133(lottieDir, file)).size;
       if (fileSize > 2e6) continue;
       let previewPage;
       try {
@@ -179260,7 +179874,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
         if (liveRemainingMs(budget, 1) <= 0) break;
         await guardLottiePreviewRequests(previewPage);
         await previewPage.setViewport({ width: 400, height: 400 });
-        const animData = JSON.parse(readFileSync88(join131(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync89(join133(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -179291,7 +179905,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
         });
         if (liveRemainingMs(budget, 1) > 0) {
           await previewPage.screenshot({
-            path: join131(previewDir, previewName),
+            path: join133(previewDir, previewName),
             type: "png",
             omitBackground: true
           });
@@ -179317,7 +179931,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
   }
   if (manifest.length > 0) {
     writeFileSync54(
-      join131(outputDir, "extracted", "lottie-manifest.json"),
+      join133(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -179355,7 +179969,7 @@ async function downloadVideoBody(srcUrl, filename, videosDir, timeoutMs) {
     }
     if (total < 1024) return null;
     const safe = /\.[a-z0-9]+$/i.test(filename) ? filename.replace(/[^\w.-]/g, "_") : `video${ext}`;
-    writeFileSync54(join131(videosDir, safe), Buffer.concat(chunks));
+    writeFileSync54(join133(videosDir, safe), Buffer.concat(chunks));
     return `assets/videos/${safe}`;
   } catch {
     return null;
@@ -179422,9 +180036,9 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
   }
   const merged = [...byKey.values()];
   if (merged.length === 0) return;
-  const videoManifestDir = join131(outputDir, "assets", "videos");
+  const videoManifestDir = join133(outputDir, "assets", "videos");
   mkdirSync61(videoManifestDir, { recursive: true });
-  const previewDir = join131(videoManifestDir, "previews");
+  const previewDir = join133(videoManifestDir, "previews");
   mkdirSync61(previewDir, { recursive: true });
   const videoManifest = [];
   const dlStart = Date.now();
@@ -179453,7 +180067,7 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
           await new Promise((r) => setTimeout(r, 200));
           if (liveRemainingMs(opts ?? {}, 1) > 0) {
             await page.screenshot({
-              path: join131(previewDir, previewName),
+              path: join133(previewDir, previewName),
               clip: {
                 x: Math.max(0, rect.x),
                 y: Math.max(0, rect.y),
@@ -179490,7 +180104,7 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
   }
   if (videoManifest.length > 0) {
     writeFileSync54(
-      join131(outputDir, "extracted", "video-manifest.json"),
+      join133(outputDir, "extracted", "video-manifest.json"),
       JSON.stringify(videoManifest, null, 2),
       "utf-8"
     );
@@ -179567,12 +180181,12 @@ import {
   existsSync as existsSync117,
   readdirSync as readdirSync43,
   statSync as statSync45,
-  readFileSync as readFileSync89,
+  readFileSync as readFileSync90,
   openSync as openSync14,
   fstatSync as fstatSync9,
   closeSync as closeSync15
 } from "fs";
-import { basename as basename33, join as join133 } from "path";
+import { basename as basename33, join as join134 } from "path";
 function resolveVisionPhaseCompletion(outcome, remainingMs) {
   if (outcome.budgetExhausted || remainingMs <= 0) {
     return { status: "degraded", reason: "budget-exhausted" };
@@ -179853,7 +180467,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
         return response.text?.trim() || "";
       };
     }
-    const imageFiles = readdirSync43(join133(outputDir, "assets")).filter(
+    const imageFiles = readdirSync43(join134(outputDir, "assets")).filter(
       (f) => /\.(png|jpg|jpeg|webp|gif)$/i.test(f)
     );
     const BATCH_SIZE = 20;
@@ -179881,13 +180495,13 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
       const batch = imageFiles.slice(i, i + BATCH_SIZE);
       const results = await Promise.allSettled(
         batch.map(async (file) => {
-          const filePath = join133(outputDir, "assets", file);
+          const filePath = join134(outputDir, "assets", file);
           const fd = openSync14(filePath, "r");
           let buffer;
           try {
             const stat = fstatSync9(fd);
             if (stat.size > 4e6) return { file, caption: "" };
-            buffer = readFileSync89(fd);
+            buffer = readFileSync90(fd);
           } finally {
             closeSync15(fd);
           }
@@ -179920,11 +180534,11 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
       `${Object.keys(geminiCaptions).length} images captioned with ${providerName}`
     );
     const svgFiles = [];
-    const assetsDir = join133(outputDir, "assets");
+    const assetsDir = join134(outputDir, "assets");
     for (const f of readdirSync43(assetsDir)) {
       if (/\.svg$/i.test(f)) svgFiles.push({ file: f, relPath: f });
     }
-    const svgsSubdir = join133(assetsDir, "svgs");
+    const svgsSubdir = join134(assetsDir, "svgs");
     if (existsSync117(svgsSubdir)) {
       for (const f of readdirSync43(svgsSubdir)) {
         if (/\.svg$/i.test(f)) svgFiles.push({ file: f, relPath: `svgs/${f}` });
@@ -179958,9 +180572,9 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
         sharp5.concurrency(1);
         try {
           for (const { relPath } of batch) {
-            const filePath = join133(assetsDir, relPath);
+            const filePath = join134(assetsDir, relPath);
             try {
-              const svgSource = readFileSync89(filePath, "utf-8");
+              const svgSource = readFileSync90(filePath, "utf-8");
               const lightFillHits = (svgSource.match(/fill\s*=\s*["'](#fff(fff)?|white|#[ef][ef][ef]|#[ef]{6})["']/gi) || []).length;
               const darkFillHits = (svgSource.match(/fill\s*=\s*["'](#000(000)?|black|#[0-3]{6}|#[0-3]{3})["']/gi) || []).length;
               const bg = lightFillHits > darkFillHits ? { r: 32, g: 32, b: 32 } : { r: 255, g: 255, b: 255 };
@@ -180033,11 +180647,11 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join133(outputDir, "assets");
+  const assetsPath = join134(outputDir, "assets");
   try {
     for (const file of readdirSync43(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join133(assetsPath, file);
+      const filePath = join134(assetsPath, file);
       const stat = statSync45(filePath);
       if (!stat.isFile()) continue;
       const sizeKb = Math.round(stat.size / 1024);
@@ -180066,7 +180680,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join133(assetsPath, "svgs");
+    const svgsPath = join134(assetsPath, "svgs");
     for (const file of readdirSync43(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
@@ -180085,7 +180699,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join133(assetsPath, "fonts");
+    const fontsPath = join134(assetsPath, "fonts");
     for (const file of readdirSync43(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
@@ -180094,7 +180708,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const videoLines = [];
   try {
     const manifest = JSON.parse(
-      readFileSync89(join133(outputDir, "extracted", "video-manifest.json"), "utf-8")
+      readFileSync90(join134(outputDir, "extracted", "video-manifest.json"), "utf-8")
     );
     for (const v2 of manifest) {
       if (!v2.localPath) continue;
@@ -180131,7 +180745,7 @@ __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
 import { writeFileSync as writeFileSync55, readdirSync as readdirSync44, existsSync as existsSync118 } from "fs";
-import { join as join134 } from "path";
+import { join as join135 } from "path";
 function inferColorRole(hex) {
   const r = parseInt(hex.slice(1, 3), 16) / 255;
   const g = parseInt(hex.slice(3, 5), 16) / 255;
@@ -180150,9 +180764,9 @@ function inferColorRole(hex) {
 }
 function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, _detectedLibraries) {
   const prompt = buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShaders);
-  writeFileSync55(join134(outputDir, "AGENTS.md"), prompt, "utf-8");
-  writeFileSync55(join134(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync55(join134(outputDir, ".cursorrules"), prompt, "utf-8");
+  writeFileSync55(join135(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync55(join135(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync55(join135(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShaders) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -180161,7 +180775,7 @@ function buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShader
     (f) => f.family + (f.variable && f.weightRange ? ` (${f.weightRange[0]}-${f.weightRange[1]} variable)` : f.weights.length > 0 ? ` (${f.weights.join(",")})` : "")
   ).join(", ") || "none detected";
   function contactSheetRows(dir, baseFile, label2) {
-    const fullDir = join134(outputDir, dir);
+    const fullDir = join135(outputDir, dir);
     if (!existsSync118(fullDir)) return [];
     const baseName = baseFile.replace(/\.jpg$/, "");
     const escapedBase = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -180194,7 +180808,7 @@ function buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShader
   tableRows.push(
     `| \`extracted/tokens.json\` | Design tokens: ${tokens.colors.length} colors, ${tokens.fonts.length} fonts, ${tokens.headings?.length ?? 0} headings, ${tokens.ctas?.length ?? 0} CTAs |`
   );
-  if (existsSync118(join134(outputDir, "extracted", "design-styles.json"))) {
+  if (existsSync118(join135(outputDir, "extracted", "design-styles.json"))) {
     tableRows.push(
       "| `extracted/design-styles.json` | Computed styles from live DOM: typography hierarchy, button/card/nav styles, spacing scale, border-radius, box shadows. Primary data source for DESIGN.md. |"
     );
@@ -180265,15 +180879,15 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync119, readFileSync as readFileSync90 } from "fs";
-import { join as join135, resolve as resolve77 } from "path";
+import { existsSync as existsSync119, readFileSync as readFileSync91 } from "fs";
+import { join as join136, resolve as resolve77 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve77(startDir);
     for (let i = 0; i < 5; i++) {
       const envPath = resolve77(dir, ".env");
       try {
-        const envContent = readFileSync90(envPath, "utf-8");
+        const envContent = readFileSync91(envPath, "utf-8");
         for (const line3 of envContent.split("\n")) {
           const trimmed = line3.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -180292,7 +180906,7 @@ function loadEnvFile(startDir) {
   }
 }
 async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
-  const metaPath = join135(outputDir, "meta.json");
+  const metaPath = join136(outputDir, "meta.json");
   if (!existsSync119(metaPath)) {
     const hostname2 = new URL(url).hostname.replace(/^www\./, "");
     writeNewFileSync(
@@ -180346,10 +180960,10 @@ var init_pageBlockDetection = __esm({
 
 // src/capture/responseRecord.ts
 import { writeFileSync as writeFileSync56 } from "fs";
-import { join as join136 } from "path";
+import { join as join137 } from "path";
 function writeResponseRecord(extractedDir, record2) {
   writeFileSync56(
-    join136(extractedDir, RESPONSE_RECORD_FILENAME),
+    join137(extractedDir, RESPONSE_RECORD_FILENAME),
     JSON.stringify(record2, null, 2),
     "utf-8"
   );
@@ -180414,7 +181028,7 @@ __export(screenshotCapture_exports, {
   pngHeight: () => pngHeight
 });
 import { writeFileSync as writeFileSync57, mkdirSync as mkdirSync63 } from "fs";
-import { join as join137 } from "path";
+import { join as join138 } from "path";
 function pngHeight(buf) {
   if (buf.length < 24) return null;
   if (buf[12] !== 73 || buf[13] !== 72 || buf[14] !== 68 || buf[15] !== 82) return null;
@@ -180439,7 +181053,7 @@ async function captureFullPagePlate(page, screenshotsDir, budget = {}) {
     const buffer = await page.screenshot({ type: "png", fullPage: true });
     const produced = pngHeight(buffer);
     if (produced != null && produced > MAX_PLATE_HEIGHT_PX) return null;
-    writeFileSync57(join137(screenshotsDir, "full-page.png"), buffer);
+    writeFileSync57(join138(screenshotsDir, "full-page.png"), buffer);
     return "screenshots/full-page.png";
   } finally {
     try {
@@ -180454,7 +181068,7 @@ async function captureFullPagePlate(page, screenshotsDir, budget = {}) {
   }
 }
 async function captureScrollScreenshots(page, outputDir, budget = {}) {
-  const screenshotsDir = join137(outputDir, "screenshots");
+  const screenshotsDir = join138(outputDir, "screenshots");
   mkdirSync63(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
@@ -180551,7 +181165,7 @@ async function captureScrollScreenshots(page, outputDir, budget = {}) {
         finalPositions[i] / Math.max(1, scrollHeight - viewportHeight) * 100
       );
       const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
-      const filePath = join137(screenshotsDir, filename);
+      const filePath = join138(screenshotsDir, filename);
       if ((budget.remainingMs?.() ?? 1) <= 0) break;
       const buffer = await page.screenshot({ type: "png" });
       writeFileSync57(filePath, buffer);
@@ -180912,7 +181526,7 @@ __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
 import { mkdirSync as mkdirSync64, writeFileSync as writeFileSync58, existsSync as existsSync120 } from "fs";
-import { join as join138 } from "path";
+import { join as join139 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -180954,9 +181568,9 @@ async function captureWebsite(opts, onProgress) {
   };
   phase("browser", "started");
   loadEnvFile(outputDir);
-  mkdirSync64(join138(outputDir, "extracted"), { recursive: true });
-  mkdirSync64(join138(outputDir, "screenshots"), { recursive: true });
-  mkdirSync64(join138(outputDir, "assets"), { recursive: true });
+  mkdirSync64(join139(outputDir, "extracted"), { recursive: true });
+  mkdirSync64(join139(outputDir, "screenshots"), { recursive: true });
+  mkdirSync64(join139(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -181067,7 +181681,7 @@ async function captureWebsite(opts, onProgress) {
       progress("warn", message);
     }
     const httpStatus = navigationResponse?.status() ?? null;
-    writeResponseRecord(join138(outputDir, "extracted"), { status: httpStatus });
+    writeResponseRecord(join139(outputDir, "extracted"), { status: httpStatus });
     const blockedReason = detectBlockedPage({
       httpStatus,
       ...contentCheckTimedOut ? {
@@ -181131,7 +181745,7 @@ async function captureWebsite(opts, onProgress) {
       else discoveredLotties[existing] = found;
     }
     if (discoveredLotties.length > 0 && remainingMs() > 0) {
-      const lottieDir = join138(outputDir, "assets", "lottie");
+      const lottieDir = join139(outputDir, "assets", "lottie");
       mkdirSync64(lottieDir, { recursive: true });
       const lottieBudget = { remainingMs, byteBudget: downloadByteBudget };
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir, lottieBudget);
@@ -181152,7 +181766,7 @@ async function captureWebsite(opts, onProgress) {
         });
         capturedShaders = unique;
         writeFileSync58(
-          join138(outputDir, "extracted", "shaders.json"),
+          join139(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -181167,7 +181781,7 @@ async function captureWebsite(opts, onProgress) {
       svgs: tokens.svgs.map(({ outerHTML: _, ...rest }) => rest)
     };
     writeFileSync58(
-      join138(outputDir, "extracted", "tokens.json"),
+      join139(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokensForDisk, null, 2),
       "utf-8"
     );
@@ -181175,7 +181789,7 @@ async function captureWebsite(opts, onProgress) {
     try {
       const designStyles = await extractDesignStyles(page1);
       writeFileSync58(
-        join138(outputDir, "extracted", "design-styles.json"),
+        join139(outputDir, "extracted", "design-styles.json"),
         JSON.stringify(designStyles, null, 2),
         "utf-8"
       );
@@ -181309,8 +181923,8 @@ ${err.stack}` : normalizeErrorMessage(err);
     );
     try {
       const fontsManifest = extractFontMetadata(
-        join138(outputDir, "assets", "fonts"),
-        join138(outputDir, "extracted", "fonts-manifest.json")
+        join139(outputDir, "assets", "fonts"),
+        join139(outputDir, "extracted", "fonts-manifest.json")
       );
       if (fontsManifest.families.length > 0) {
         const summary = fontsManifest.families.map((f) => `${f.family}${f.variable ? " (variable)" : ""} \xD7 ${f.fileCount}`).join(", ");
@@ -181337,7 +181951,7 @@ ${err.stack}` : normalizeErrorMessage(err);
         representativeAnimations: representativeAnims
       };
       writeFileSync58(
-        join138(outputDir, "extracted", "animations.json"),
+        join139(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -181354,7 +181968,7 @@ ${err.stack}` : normalizeErrorMessage(err);
       assets = assetPass.assets;
       assetDrops = assetPass.drops;
       writeFileSync58(
-        join138(outputDir, "extracted", "icons-manifest.json"),
+        join139(outputDir, "extracted", "icons-manifest.json"),
         JSON.stringify(assetPass.icons, null, 2),
         "utf-8"
       );
@@ -181395,7 +182009,7 @@ ${err.stack}` : normalizeErrorMessage(err);
         svgs: tokens.svgs.map(({ outerHTML: _, ...rest }) => rest)
       };
       writeFileSync58(
-        join138(outputDir, "extracted", "tokens.json"),
+        join139(outputDir, "extracted", "tokens.json"),
         JSON.stringify(tokensForDisk2, null, 2),
         "utf-8"
       );
@@ -181411,12 +182025,12 @@ ${extracted.bodyHtml}
 </body>
 </html>
 `;
-      writeFileSync58(join138(outputDir, "extracted", "page.html"), pageHtml, "utf-8");
+      writeFileSync58(join139(outputDir, "extracted", "page.html"), pageHtml, "utf-8");
     } catch (err) {
       warnings.push(`page.html write failed: ${err}`);
     }
     if (visibleTextContent) {
-      writeFileSync58(join138(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync58(join139(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     let geminiCaptions = {};
     if (skipVision) {
@@ -181453,7 +182067,7 @@ ${extracted.bodyHtml}
         const hasVisionKey = !!(!skipVision && (process.env.OPENROUTER_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || process.env.HYPERFRAMES_VERTEX_PROJECT_ID && process.env.HYPERFRAMES_VERTEX_SERVICE_ACCOUNT));
         const header2 = hasVisionKey ? "# Asset Descriptions\n\nOne line per file. Read this instead of opening every image individually.\n\nTo find a specific brand or icon, **grep this file for the brand name in the description text** (e.g. `grep -i 'autodesk' asset-descriptions.md`). The Gemini Vision captions identify what's actually in each file \u2014 that's the agent's selector.\n\nThe `logo-<hash>.svg` filename prefix is a cheap structural hint (DOM said this SVG was inside a `<header>`, home-link `<a>`, or had an aria-label matching the page brand). It is NOT a content claim \u2014 many `logo-*` files are nav icons or decorative shapes. Trust the captions, not the filename prefix.\n\n" : "# Asset Descriptions\n\n\u26A0\uFE0F  No vision credentials \u2014 descriptions below are catalog-derived (alt text, headings, section context, filename) instead of Vision-generated. To get richer Vision descriptions on the next capture, set GEMINI_API_KEY (or GOOGLE_API_KEY), or HYPERFRAMES_VERTEX_PROJECT_ID plus HYPERFRAMES_VERTEX_SERVICE_ACCOUNT for Vertex service-account auth, and re-run.\n\nThe `logo-<hash>.svg` filename prefix is a structural hint (DOM said this SVG was inside a `<header>`, home-link `<a>`, or had an aria-label matching the page brand). To pick the actual brand logo without Vision, open the `logo-*` candidates in a previewer or rasterize them with `sharp` before referencing \u2014 composing a fake logo ships off-brand in the final video.\n\n";
         writeFileSync58(
-          join138(outputDir, "extracted", "asset-descriptions.md"),
+          join139(outputDir, "extracted", "asset-descriptions.md"),
           header2 + lines.map((l) => "- " + l).join("\n") + "\n",
           "utf-8"
         );
@@ -181471,8 +182085,8 @@ ${extracted.bodyHtml}
         const { createScrollContactSheet: createScrollContactSheet2, createAssetContactSheet: createAssetContactSheet2, createSvgContactSheet: createSvgContactSheet2 } = await Promise.resolve().then(() => (init_contactSheet(), contactSheet_exports));
         const contactSheetBudget = { remainingMs };
         const scrollSheets = await createScrollContactSheet2(
-          join138(outputDir, "screenshots"),
-          join138(outputDir, "screenshots", "contact-sheet.jpg"),
+          join139(outputDir, "screenshots"),
+          join139(outputDir, "screenshots", "contact-sheet.jpg"),
           contactSheetBudget
         );
         if (scrollSheets.length > 0)
@@ -181480,11 +182094,11 @@ ${extracted.bodyHtml}
             "design",
             `Screenshot contact sheet generated (${scrollSheets.length} page${scrollSheets.length > 1 ? "s" : ""})`
           );
-        const assetsImgDir = join138(outputDir, "assets");
+        const assetsImgDir = join139(outputDir, "assets");
         if (existsSync120(assetsImgDir)) {
           const assetSheets = await createAssetContactSheet2(
             assetsImgDir,
-            join138(outputDir, "assets", "contact-sheet.jpg"),
+            join139(outputDir, "assets", "contact-sheet.jpg"),
             contactSheetBudget
           );
           if (assetSheets.length > 0)
@@ -181493,9 +182107,9 @@ ${extracted.bodyHtml}
               `Asset contact sheet generated (${assetSheets.length} page${assetSheets.length > 1 ? "s" : ""})`
             );
         }
-        const svgsDir = join138(outputDir, "assets", "svgs");
-        const assetsRootDir = join138(outputDir, "assets");
-        const svgOutputPath = existsSync120(svgsDir) ? join138(outputDir, "assets", "svgs", "contact-sheet.jpg") : join138(outputDir, "assets", "contact-sheet-svgs.jpg");
+        const svgsDir = join139(outputDir, "assets", "svgs");
+        const assetsRootDir = join139(outputDir, "assets");
+        const svgOutputPath = existsSync120(svgsDir) ? join139(outputDir, "assets", "svgs", "contact-sheet.jpg") : join139(outputDir, "assets", "contact-sheet-svgs.jpg");
         const svgSheets = await createSvgContactSheet2(
           svgsDir,
           svgOutputPath,
@@ -181528,7 +182142,7 @@ ${extracted.bodyHtml}
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync120(join138(outputDir, "extracted", "shaders.json")),
+      existsSync120(join139(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
       warnings,
@@ -181892,10 +182506,10 @@ __export(state_exports, {
   stateFilePath: () => stateFilePath,
   writeStackOutputs: () => writeStackOutputs
 });
-import { existsSync as existsSync121, mkdirSync as mkdirSync65, readdirSync as readdirSync45, readFileSync as readFileSync91, rmSync as rmSync40, writeFileSync as writeFileSync59 } from "fs";
-import { dirname as dirname63, join as join139 } from "path";
+import { existsSync as existsSync121, mkdirSync as mkdirSync65, readdirSync as readdirSync45, readFileSync as readFileSync93, rmSync as rmSync40, writeFileSync as writeFileSync59 } from "fs";
+import { dirname as dirname63, join as join140 } from "path";
 function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
-  return join139(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
+  return join140(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
 }
 function writeStackOutputs(outputs, cwd = process.cwd()) {
   const path = stateFilePath(outputs.stackName, cwd);
@@ -181907,7 +182521,7 @@ function readStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   const path = stateFilePath(stackName, cwd);
   if (!existsSync121(path)) return null;
   try {
-    return JSON.parse(readFileSync91(path, "utf-8"));
+    return JSON.parse(readFileSync93(path, "utf-8"));
   } catch {
     return null;
   }
@@ -181917,7 +182531,7 @@ function deleteStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd())
   if (existsSync121(path)) rmSync40(path);
 }
 function listStackNames(cwd = process.cwd()) {
-  const dir = join139(cwd, STATE_DIR_NAME);
+  const dir = join140(cwd, STATE_DIR_NAME);
   if (!existsSync121(dir)) return [];
   return readdirSync45(dir).filter((f) => f.startsWith(STATE_FILE_PREFIX) && f.endsWith(".json")).map((f) => f.slice(STATE_FILE_PREFIX.length, -".json".length));
 }
@@ -181950,7 +182564,7 @@ var init_state = __esm({
 // src/commands/lambda/sam.ts
 import { execFileSync as execFileSync19, spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync122 } from "fs";
-import { join as join140 } from "path";
+import { join as join141 } from "path";
 function assertSamAvailable() {
   try {
     execFileSync19("sam", ["--version"], { stdio: "ignore" });
@@ -181970,7 +182584,7 @@ function assertAwsCliAvailable() {
   }
 }
 function locateSamTemplate(repoRoot2) {
-  const candidate = join140(repoRoot2, "examples", "aws-lambda", "template.yaml");
+  const candidate = join141(repoRoot2, "examples", "aws-lambda", "template.yaml");
   if (!existsSync122(candidate)) {
     throw new Error(
       `[lambda] SAM template not found at ${candidate}. If you're running from an installed package, point --sam-template at your local copy of examples/aws-lambda/template.yaml.`
@@ -182004,7 +182618,7 @@ function samDeploy(opts) {
   if (opts.awsProfile) {
     args.push("--profile", opts.awsProfile);
   }
-  const samDir = join140(opts.repoRoot, "examples", "aws-lambda");
+  const samDir = join141(opts.repoRoot, "examples", "aws-lambda");
   const result = spawnSync4("sam", args, { cwd: samDir, stdio: opts.stdio ?? "inherit" });
   if (result.status !== 0) {
     throw new Error(
@@ -182022,7 +182636,7 @@ function samDelete(opts) {
   if (opts.awsProfile) {
     args.push("--profile", opts.awsProfile);
   }
-  const samDir = join140(opts.repoRoot, "examples", "aws-lambda");
+  const samDir = join141(opts.repoRoot, "examples", "aws-lambda");
   const result = spawnSync4("sam", args, { cwd: samDir, stdio: opts.stdio ?? "inherit" });
   if (result.status !== 0) {
     throw new Error(`[lambda] sam delete exited with code ${result.status ?? "unknown"}`);
@@ -182106,7 +182720,7 @@ __export(deploy_exports, {
 });
 import { spawnSync as spawnSync5 } from "child_process";
 import { existsSync as existsSync124 } from "fs";
-import { join as join141, resolve as resolve80 } from "path";
+import { join as join143, resolve as resolve80 } from "path";
 async function runDeploy(args = {}) {
   const resolved2 = {
     stackName: args.stackName ?? DEFAULT_STACK_NAME,
@@ -182123,7 +182737,7 @@ async function runDeploy(args = {}) {
     console.log(c.dim("\u2192 Building handler ZIP"));
     buildHandlerZip(root);
   } else {
-    const zip = join141(root, "packages", "aws-lambda", "dist", "handler.zip");
+    const zip = join143(root, "packages", "aws-lambda", "dist", "handler.zip");
     if (!existsSync124(zip)) {
       throw new Error(
         `--skip-build set but ${zip} does not exist. Run \`bun run --cwd packages/aws-lambda build:zip\` first or drop --skip-build.`
@@ -182167,7 +182781,7 @@ async function runDeploy(args = {}) {
 function buildHandlerZip(root) {
   const result = spawnSync5(
     "bun",
-    ["run", "--cwd", join141(root, "packages", "aws-lambda"), "build:zip"],
+    ["run", "--cwd", join143(root, "packages", "aws-lambda"), "build:zip"],
     { stdio: "inherit" }
   );
   if (result.status !== 0) {
@@ -182236,14 +182850,14 @@ var init_sites = __esm({
 });
 
 // src/commands/lambda/_dimensions.ts
-import { readFileSync as readFileSync93 } from "fs";
-import { join as join143 } from "path";
+import { readFileSync as readFileSync94 } from "fs";
+import { join as join144 } from "path";
 function warnOnDimensionMismatch(args) {
   if (args.quiet) return;
   if (args.outputResolution) return;
   let html;
   try {
-    html = readFileSync93(join143(args.projectDir, "index.html"), "utf-8");
+    html = readFileSync94(join144(args.projectDir, "index.html"), "utf-8");
   } catch {
     return;
   }
@@ -182273,7 +182887,7 @@ __export(render_exports2, {
   runRender: () => runRender
 });
 import { existsSync as existsSync125 } from "fs";
-import { join as join144, resolve as resolvePath2 } from "path";
+import { join as join145, resolve as resolvePath2 } from "path";
 async function loadSDK2() {
   return import("@hyperframes/aws-lambda/sdk");
 }
@@ -182289,7 +182903,7 @@ async function runRender(args) {
   });
   const variables = resolveVariablesArg(args.variables, args.variablesFile);
   if (variables && Object.keys(variables).length > 0) {
-    const indexPath2 = join144(projectDir, "index.html");
+    const indexPath2 = join145(projectDir, "index.html");
     if (existsSync125(indexPath2)) {
       const issues = validateVariablesAgainstProject(indexPath2, variables);
       reportVariableIssues(issues, { strict: args.strictVariables ?? false, quiet: args.json });
@@ -182423,8 +183037,8 @@ __export(render_batch_exports, {
   runRenderBatch: () => runRenderBatch,
   runWithConcurrencyLimit: () => runWithConcurrencyLimit
 });
-import { existsSync as existsSync126, readFileSync as readFileSync94 } from "fs";
-import { join as join145, resolve as resolvePath3 } from "path";
+import { existsSync as existsSync126, readFileSync as readFileSync95 } from "fs";
+import { join as join146, resolve as resolvePath3 } from "path";
 async function loadSDK3() {
   return import("@hyperframes/aws-lambda/sdk");
 }
@@ -182448,7 +183062,7 @@ async function runRenderBatch(args) {
     outputResolution: args.outputResolution,
     quiet: args.json
   });
-  const schema = loadProjectVariableSchema(join145(projectDir, "index.html"));
+  const schema = loadProjectVariableSchema(join146(projectDir, "index.html"));
   const strict = args.strictVariables ?? false;
   let hadStrictIssue = false;
   for (const { entry, lineNumber } of entries2) {
@@ -182583,7 +183197,7 @@ function buildLambdaBatchRenderConfig(args) {
   return config;
 }
 function parseBatchFile(path) {
-  const raw = readFileSync94(path, "utf8");
+  const raw = readFileSync95(path, "utf8");
   const lines = raw.split(/\r?\n/);
   const out = [];
   for (let i = 0; i < lines.length; i++) {
@@ -182777,7 +183391,7 @@ __export(policies_exports, {
   runPolicies: () => runPolicies,
   validatePolicy: () => validatePolicy
 });
-import { readFileSync as readFileSync95 } from "fs";
+import { readFileSync as readFileSync96 } from "fs";
 function allRequiredActions() {
   const set = /* @__PURE__ */ new Set();
   for (const group of Object.values(REQUIRED_ACTIONS)) {
@@ -182883,7 +183497,7 @@ async function runPolicies(args) {
   }
 }
 function validatePolicy(policyPath) {
-  const raw = readFileSync95(policyPath, "utf-8");
+  const raw = readFileSync96(policyPath, "utf-8");
   const parsed = JSON.parse(raw);
   const statements = Array.isArray(parsed.Statement) ? parsed.Statement : parsed.Statement ? [
     parsed.Statement
@@ -183494,9 +184108,9 @@ __export(cloudrun_exports, {
   missingCloudRunAdapterMessage: () => missingCloudRunAdapterMessage
 });
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync127, mkdirSync as mkdirSync66, readFileSync as readFileSync96, writeFileSync as writeFileSync60 } from "fs";
+import { existsSync as existsSync127, mkdirSync as mkdirSync66, readFileSync as readFileSync97, writeFileSync as writeFileSync60 } from "fs";
 import { homedir as homedir24 } from "os";
-import { join as join146, resolve as resolve81 } from "path";
+import { join as join147, resolve as resolve81 } from "path";
 function loadCloudRunAdapter() {
   cloudRunAdapterPromise ??= Promise.all([
     import("@hyperframes/gcp-cloud-run/sdk"),
@@ -183515,10 +184129,10 @@ Or, for an opt-in project setup:
   ${c.accent("npm install @hyperframes/gcp-cloud-run")}`;
 }
 function stateDir() {
-  return join146(homedir24(), ".hyperframes");
+  return join147(homedir24(), ".hyperframes");
 }
 function statePath() {
-  return join146(stateDir(), "cloudrun-state.json");
+  return join147(stateDir(), "cloudrun-state.json");
 }
 function writeState2(state) {
   mkdirSync66(stateDir(), { recursive: true });
@@ -183532,7 +184146,7 @@ function readState2(args) {
   let base2 = {};
   if (existsSync127(statePath())) {
     try {
-      base2 = JSON.parse(readFileSync96(statePath(), "utf8"));
+      base2 = JSON.parse(readFileSync97(statePath(), "utf8"));
     } catch {
     }
   }
@@ -183675,11 +184289,11 @@ function machineVars(args, project, region, image) {
 }
 function findRepoRoot(tfDir) {
   const candidate = resolve81(tfDir, "..", "..", "..");
-  if (existsSync127(join146(candidate, "packages", "gcp-cloud-run", "Dockerfile"))) return candidate;
+  if (existsSync127(join147(candidate, "packages", "gcp-cloud-run", "Dockerfile"))) return candidate;
   return null;
 }
 function writeCloudBuildConfig(image) {
-  const cfgPath = join146(stateDir(), "cloudrun-cloudbuild.yaml");
+  const cfgPath = join147(stateDir(), "cloudrun-cloudbuild.yaml");
   mkdirSync66(stateDir(), { recursive: true });
   writeFileSync60(
     cfgPath,
@@ -183891,7 +184505,7 @@ async function runRenderBatch2(args) {
   if (failed.length > 0) failCommand();
 }
 function parseBatchFile2(path) {
-  const lines = readFileSync96(path, "utf8").split(/\r?\n/);
+  const lines = readFileSync97(path, "utf8").split(/\r?\n/);
   const entries2 = [];
   lines.forEach((line3, idx) => {
     const trimmed = line3.trim();
@@ -183916,7 +184530,7 @@ function parseBatchFile2(path) {
 async function runDestroy2(args) {
   const { getTerraformModuleDir } = await loadCloudRunAdapter();
   const tfDir = getTerraformModuleDir();
-  const state = existsSync127(statePath()) ? JSON.parse(readFileSync96(statePath(), "utf8")) : {};
+  const state = existsSync127(statePath()) ? JSON.parse(readFileSync97(statePath(), "utf8")) : {};
   const project = args.project ?? state.projectId;
   const region = args.region ?? state.region ?? "us-central1";
   const image = args.image ?? "unused:latest";
@@ -183971,7 +184585,7 @@ function resolveAndValidateVariables(args, projectDir) {
     args["variables-file"]
   );
   if (variables && Object.keys(variables).length > 0) {
-    const indexPath2 = join146(projectDir, "index.html");
+    const indexPath2 = join147(projectDir, "index.html");
     if (existsSync127(indexPath2)) {
       const issues = validateVariablesAgainstProject(indexPath2, variables);
       reportVariableIssues(issues, {
@@ -184218,7 +184832,7 @@ ${HELP2}`);
 });
 
 // src/cloud/detectAspectRatio.ts
-import { readFileSync as readFileSync97 } from "fs";
+import { readFileSync as readFileSync98 } from "fs";
 function extractAttributeNumber(tag, re2) {
   const match = tag.match(re2);
   if (!match) return null;
@@ -184230,7 +184844,7 @@ function extractAttributeNumber(tag, re2) {
 function detectAspectRatioFromHtml(entryHtmlPath) {
   let html;
   try {
-    html = readFileSync97(entryHtmlPath, "utf-8");
+    html = readFileSync98(entryHtmlPath, "utf-8");
   } catch (err) {
     return { kind: "read-error", error: normalizeErrorMessage(err) };
   }
@@ -184344,7 +184958,7 @@ import {
   rmSync as rmSync41,
   statSync as statSync46
 } from "fs";
-import { dirname as dirname65, join as join147, resolve as resolve82 } from "path";
+import { dirname as dirname65, join as join148, resolve as resolve82 } from "path";
 import { pipeline as pipeline3 } from "stream/promises";
 async function downloadToFile(url, destPath, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -184361,8 +184975,8 @@ async function downloadToFile(url, destPath, options = {}) {
   const totalOpt = total !== void 0 && Number.isFinite(total) ? total : void 0;
   const destination = resolveDownloadDestination(destPath);
   const previous = statSync46(destination, { throwIfNoEntry: false });
-  const stage = mkdtempSync27(join147(dirname65(destination), ".hf-download-"));
-  const stagedFile = join147(stage, "download");
+  const stage = mkdtempSync27(join148(dirname65(destination), ".hf-download-"));
+  const stagedFile = join148(stage, "download");
   let bytes = 0;
   try {
     await pipeline3(
@@ -187028,12 +187642,12 @@ var init_freeze = __esm({
 });
 
 // ../core/dist/figma/jsonl.js
-import { existsSync as existsSync129, readFileSync as readFileSync98 } from "fs";
+import { existsSync as existsSync129, readFileSync as readFileSync99 } from "fs";
 function readJsonlValues(path) {
   if (!existsSync129(path))
     return [];
   const out = [];
-  for (const line3 of readFileSync98(path, "utf8").split(/\r?\n/)) {
+  for (const line3 of readFileSync99(path, "utf8").split(/\r?\n/)) {
     const trimmed = line3.trim();
     if (trimmed.length === 0)
       continue;
@@ -187052,16 +187666,16 @@ var init_jsonl = __esm({
 });
 
 // ../core/dist/figma/manifest.js
-import { appendFileSync as appendFileSync2, existsSync as existsSync130, mkdirSync as mkdirSync69, readFileSync as readFileSync99, writeFileSync as writeFileSync63 } from "fs";
-import { join as join148 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync130, mkdirSync as mkdirSync69, readFileSync as readFileSync100, writeFileSync as writeFileSync63 } from "fs";
+import { join as join149 } from "path";
 function mediaDir(projectDir) {
-  return join148(projectDir, ".media");
+  return join149(projectDir, ".media");
 }
 function manifestPath2(projectDir) {
-  return join148(mediaDir(projectDir), MANIFEST_FILE2);
+  return join149(mediaDir(projectDir), MANIFEST_FILE2);
 }
 function typeDirPath(projectDir, type) {
-  return join148(mediaDir(projectDir), TYPE_DIRS[type]);
+  return join149(mediaDir(projectDir), TYPE_DIRS[type]);
 }
 function isFigmaManifestRecord(value) {
   if (typeof value !== "object" || value === null)
@@ -187093,7 +187707,7 @@ function findAllByFigmaNode(projectDir, fileKey2, nodeId) {
 }
 function updateRecord(projectDir, record2) {
   const p2 = manifestPath2(projectDir);
-  const lines = readFileSync99(p2, "utf8").split(/\r?\n/);
+  const lines = readFileSync100(p2, "utf8").split(/\r?\n/);
   const out = lines.map((line3) => {
     const trimmed = line3.trim();
     if (trimmed.length === 0)
@@ -187114,7 +187728,7 @@ function nextId(projectDir, type) {
   const p2 = manifestPath2(projectDir);
   if (!existsSync130(p2))
     return `${type}_001`;
-  for (const line3 of readFileSync99(p2, "utf8").split(/\r?\n/)) {
+  for (const line3 of readFileSync100(p2, "utf8").split(/\r?\n/)) {
     const trimmed = line3.trim();
     if (trimmed.length === 0)
       continue;
@@ -187148,12 +187762,12 @@ var init_manifest = __esm({
 
 // ../core/dist/figma/mediaIndex.js
 import { mkdirSync as mkdirSync70, writeFileSync as writeFileSync64 } from "fs";
-import { dirname as dirname67, join as join149 } from "path";
+import { dirname as dirname67, join as join150 } from "path";
 function isRow(value) {
   return typeof value === "object" && value !== null;
 }
 function indexPath(projectDir) {
-  return join149(mediaDir(projectDir), "index.md");
+  return join150(mediaDir(projectDir), "index.md");
 }
 function pad(str, len2) {
   return String(str ?? "").padEnd(len2);
@@ -187265,9 +187879,9 @@ var init_sanitizeSvg = __esm({
 
 // ../core/dist/figma/bindings.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync71, writeFileSync as writeFileSync65 } from "fs";
-import { join as join150 } from "path";
+import { join as join151 } from "path";
 function bindingsPath(projectDir) {
-  return join150(mediaDir(projectDir), BINDINGS_FILE);
+  return join151(mediaDir(projectDir), BINDINGS_FILE);
 }
 function isRecord16(value) {
   return typeof value === "object" && value !== null;
@@ -187868,7 +188482,7 @@ __export(asset_exports, {
   runAssetImportMany: () => runAssetImportMany
 });
 import { existsSync as existsSync131 } from "fs";
-import { join as join151, relative as relative36 } from "path";
+import { join as join152, relative as relative36 } from "path";
 function gatherAssetRefs(positionals) {
   return positionals.flatMap((r) => /^https?:/i.test(r.trim()) ? [r] : r.split(",")).map((r) => r.trim()).filter((r) => r.length > 0);
 }
@@ -187882,7 +188496,7 @@ function requireNodeRef(refInput) {
 }
 function reuseExisting(fileKey2, nodeId, opts, version2, deps, description, entity) {
   const existing = findAllByFigmaNode(deps.projectDir, fileKey2, nodeId).find(
-    (r) => r.provenance.format === opts.format && (r.provenance.scale ?? 1) === (opts.scale ?? 1) && r.provenance.version === version2 && existsSync131(join151(deps.projectDir, r.path))
+    (r) => r.provenance.format === opts.format && (r.provenance.scale ?? 1) === (opts.scale ?? 1) && r.provenance.version === version2 && existsSync131(join152(deps.projectDir, r.path))
   );
   if (!existing) return null;
   let record2 = existing;
@@ -187905,7 +188519,7 @@ async function freezeAndRecord(fileKey2, nodeId, url, ext, opts, version2, deps,
     bytes = new TextEncoder().encode(sanitizeSvg(new TextDecoder().decode(bytes)));
   }
   const id = nextId(deps.projectDir, "image");
-  const destAbs = join151(typeDirPath(deps.projectDir, "image"), `${id}.${ext}`);
+  const destAbs = join152(typeDirPath(deps.projectDir, "image"), `${id}.${ext}`);
   freezeBytes(bytes, destAbs);
   const record2 = {
     id,
@@ -188075,11 +188689,11 @@ __export(tokens_exports, {
   runTokensImport: () => runTokensImport
 });
 import { writeFileSync as writeFileSync66 } from "fs";
-import { join as join152 } from "path";
+import { join as join153 } from "path";
 async function runTokensImport(refInput, deps) {
   const { fileKey: fileKey2 } = parseFigmaRef(refInput);
   const { version: version2 } = await deps.client.fileVersion(fileKey2);
-  const sidecarPath = join152(deps.projectDir, "figma-tokens.json");
+  const sidecarPath = join153(deps.projectDir, "figma-tokens.json");
   let vars = null;
   try {
     vars = await deps.client.variables(fileKey2);
@@ -188154,7 +188768,7 @@ __export(component_exports, {
   runComponentImport: () => runComponentImport
 });
 import { existsSync as existsSync132, mkdirSync as mkdirSync72, writeFileSync as writeFileSync67 } from "fs";
-import { join as join153, relative as relative37 } from "path";
+import { join as join154, relative as relative37 } from "path";
 function escapeAttr2(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -188165,7 +188779,7 @@ async function runComponentImport(refInput, deps) {
   const bindings = resolveBindings(tree, readBindings(deps.projectDir));
   const mapped = nodeToHtml(tree, bindings, { rootName: deps.name });
   const name = slugify(deps.name ?? tree.name);
-  const componentDir = join153(deps.projectDir, "compositions", "components", name);
+  const componentDir = join154(deps.projectDir, "compositions", "components", name);
   if (existsSync132(componentDir))
     console.warn(
       `component dir compositions/components/${name} already exists \u2014 overwriting (rename the figma frame for a separate import)`
@@ -188177,7 +188791,7 @@ async function runComponentImport(refInput, deps) {
     componentDir,
     deps
   );
-  const htmlFile = join153(componentDir, `${name}.html`);
+  const htmlFile = join154(componentDir, `${name}.html`);
   writeFileSync67(htmlFile, html + "\n");
   const registryItem = {
     name,
@@ -188199,7 +188813,7 @@ async function runComponentImport(refInput, deps) {
     ]
   };
   writeFileSync67(
-    join153(componentDir, "registry-item.json"),
+    join154(componentDir, "registry-item.json"),
     JSON.stringify(registryItem, null, 2) + "\n"
   );
   return {
@@ -188224,7 +188838,7 @@ async function rasterizeFallback(mapped, fileKey2, componentDir, deps) {
       continue;
     }
     frozenAssets.push(asset.record.path);
-    const srcRel = relative37(componentDir, join153(deps.projectDir, asset.record.path)).replaceAll(
+    const srcRel = relative37(componentDir, join154(deps.projectDir, asset.record.path)).replaceAll(
       "\\",
       "/"
     );
@@ -188373,7 +188987,7 @@ __export(autoUpdate_exports, {
 import { spawn as spawn19 } from "child_process";
 import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync73, openSync as openSync15 } from "fs";
 import { homedir as homedir25 } from "os";
-import { join as join154 } from "path";
+import { join as join155 } from "path";
 import { compareVersions as compareVersions3 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -188396,7 +189010,7 @@ function log(line3) {
 }
 function launchDetachedInstall(invocation, displayCommand, version2) {
   mkdirSync73(CONFIG_DIR3, { recursive: true, mode: 448 });
-  const configFile = join154(CONFIG_DIR3, "config.json");
+  const configFile = join155(CONFIG_DIR3, "config.json");
   const nodeScript = `
     const { execFile } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -188517,8 +189131,8 @@ var init_autoUpdate = __esm({
     init_config();
     init_env();
     init_installerDetection();
-    CONFIG_DIR3 = join154(homedir25(), ".hyperframes");
-    LOG_FILE = join154(CONFIG_DIR3, "auto-update.log");
+    CONFIG_DIR3 = join155(homedir25(), ".hyperframes");
+    LOG_FILE = join155(CONFIG_DIR3, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });
@@ -188714,7 +189328,7 @@ var init_help = __esm({
 init_version();
 init_dist();
 init_runId();
-import { dirname as dirname68, join as join155, resolve as resolve83 } from "path";
+import { dirname as dirname68, join as join156, resolve as resolve83 } from "path";
 import { fileURLToPath as fileURLToPath17 } from "url";
 import { existsSync as existsSync133 } from "fs";
 
@@ -188834,7 +189448,7 @@ for (const stream of [process.stdout, process.stderr]) {
 }
 (() => {
   const here = dirname68(fileURLToPath17(import.meta.url));
-  const shader = join155(here, "shaderTransitionWorker.js");
+  const shader = join156(here, "shaderTransitionWorker.js");
   if (!process.env.HF_SHADER_WORKER_ENTRY && existsSync133(shader)) {
     process.env.HF_SHADER_WORKER_ENTRY = shader;
   }
@@ -188847,10 +189461,10 @@ if (rootVersionRequested) {
   process.exit(0);
 }
 try {
-  const { readFileSync: readFileSync100 } = await import("fs");
+  const { readFileSync: readFileSync101 } = await import("fs");
   const { resolve: resolve84 } = await import("path");
   const envPath = resolve84(process.cwd(), ".env");
-  const envContent = readFileSync100(envPath, "utf-8");
+  const envContent = readFileSync101(envPath, "utf-8");
   for (const rawLine of envContent.split("\n")) {
     let line3 = rawLine.trim();
     if (!line3 || line3.startsWith("#")) continue;