hyperframes 0.8.113 → 0.8.115

package/dist/chunk-P73WQPSB.js

@@ -0,0 +1,93 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  resolveCaptureBrowserGpuMode
+} from "./chunk-WZYHTXZY.js";
+import {
+  requestCliExit
+} from "./chunk-PBN6GBJE.js";
+
+// src/browser/launch.ts
+var browsers = /* @__PURE__ */ new Set();
+var pending = /* @__PURE__ */ new Map();
+var CLOSE_GRACE_MS = 1e3;
+var listening = false;
+var shutdown;
+function stopForSignal(signal) {
+  if (shutdown) return;
+  shutdown = closeManagedBrowsers();
+  void shutdown.then(
+    () => requestCliExit(signal === "SIGINT" ? 130 : 143),
+    (error) => {
+      console.error("Browser shutdown failed:", error);
+      requestCliExit(1);
+    }
+  );
+}
+function ownSignals() {
+  if (listening) return;
+  listening = true;
+  process.on("SIGINT", () => stopForSignal("SIGINT"));
+  process.on("SIGTERM", () => stopForSignal("SIGTERM"));
+}
+async function resolveManagedGpuMode(requestedMode, chromePath) {
+  ownSignals();
+  return resolveCaptureBrowserGpuMode(requestedMode, chromePath);
+}
+async function launchManagedBrowser(puppeteer, options) {
+  if (shutdown) throw new Error("The CLI is stopping; no browser can start.");
+  ownSignals();
+  const abort = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
+  const launch = puppeteer.launch({
+    ...options,
+    signal,
+    handleSIGINT: false,
+    handleSIGTERM: false
+  });
+  pending.set(launch, abort);
+  try {
+    const browser = await launch;
+    const child = browser.process();
+    if (!child) throw new Error("A launched browser has no owned process.");
+    browsers.add(browser);
+    child.once("exit", () => browsers.delete(browser));
+    return browser;
+  } finally {
+    pending.delete(launch);
+  }
+}
+async function closeManagedBrowsers() {
+  for (const abort of pending.values()) abort.abort();
+  await Promise.allSettled(pending.keys());
+  await Promise.all([...browsers].map(closeBrowser));
+}
+async function closeBrowser(browser) {
+  const child = browser.process();
+  if (!child) throw new Error("A managed browser lost its owned process.");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+  let timer;
+  const grace = new Promise((resolve) => {
+    timer = setTimeout(resolve, CLOSE_GRACE_MS);
+  });
+  try {
+    await Promise.race([
+      browser.close().catch((error) => console.warn("Browser close failed:", error)),
+      grace
+    ]);
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    await exited;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export {
+  resolveManagedGpuMode,
+  launchManagedBrowser
+};

package/dist/{chunk-VTP4VSRP.js → chunk-PLP4K6WZ.js}

@@ -12,13 +12,15 @@ import {
   parseSourceDocument,
   patchElementInHtml,
   probeElementInSource,
+  probeElementsInSource,
   relinkSplitHalves,
   relinkSplitHalvesInHtml,
   removeElementFromHtml,
+  removeElementsFromHtml,
   splitElementInHtml,
   unwrapElementsFromHtml,
   wrapElementsInHtml
-} from "./chunk-XFJXFNJF.js";
+} from "./chunk-TWJT2RGZ.js";
 import {
   atomicTempPath,
   createFileAtomically,
@@ -31,7 +33,7 @@ import {
   measureAudio,
   requiredFfmpeg,
   resolveLocalAudioPath
-} from "./chunk-GDJ74GHW.js";
+} from "./chunk-MPB7BQT7.js";
 import {
   PROXY_PARAMS_VERSION,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
@@ -57,7 +59,7 @@ import {
   shouldPrewarmProxy,
   waitForProxy,
   walkDir
-} from "./chunk-LMC46FK5.js";
+} from "./chunk-QMFCL2ZN.js";
 import {
   findTimelineScript,
   parseGsapScriptAcorn
@@ -76,7 +78,7 @@ import {
   formatRenderOutputTimestamp,
   parseFps,
   sameInstant
-} from "./chunk-FCEFKWPM.js";
+} from "./chunk-IEE7GIVX.js";
 import {
   MagicString,
   VALID_CANVAS_RESOLUTIONS,
@@ -85,7 +87,7 @@ import {
 import {
   addScenePartsManifest,
   ensureHfIds
-} from "./chunk-OCNCK5FQ.js";
+} from "./chunk-M7XTMZF5.js";
 import {
   findStartTags,
   injectScriptsIntoHtml,
@@ -95,7 +97,7 @@ import {
   resolveRateSpec,
   sourceTimeAt,
   stripEmbeddedRuntimeScripts
-} from "./chunk-C6AIZOQN.js";
+} from "./chunk-RRPJEHHW.js";
 import {
   ProjectRootMissingError,
   folderGone,
@@ -213,7 +215,7 @@ function stampFileHfIds(filePath) {
   }
 }
 
-// ../studio-server/dist/chunk-EPL4YKGI.js
+// ../studio-server/dist/chunk-E3HLZKPI.js
 import { randomUUID as randomUUID6 } from "crypto";
 import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, writeFile } from "fs/promises";
 import {
@@ -1015,6 +1017,7 @@ function ignoresCase(dir) {
   return self !== void 0 && other?.ino === self.ino && other.dev === self.dev;
 }
 var blocks = (removed, added) => added.startsWith(`${removed}/`) || removed.startsWith(`${added}/`);
+var MAX_TIMER_MS = 2 ** 31 - 1;
 var takesWrite = (window2, at) => window2.idleMs === void 0 || at - (window2.lastWriteAt ?? at) <= window2.idleMs;
 function chainBackFrom(byAfter, hash) {
   const chain = /* @__PURE__ */ new Map();
@@ -1170,7 +1173,7 @@ var Engine = class {
     this.windows.push({ id, who, label, startedAt, lastWriteAt, idleMs, changes: /* @__PURE__ */ new Map() });
   }
   async firstOpen() {
-    const sweptAt = Date.now();
+    const sweptAt = this.now();
     for (const file of listProjectFiles(this.dir)) {
       const hash = await this.storeIfPresent(file.path);
       if (this.whereFolder() !== "here") throw this.replaced();
@@ -1202,7 +1205,7 @@ var Engine = class {
    */
   async sweep() {
     if (this.whereFolder() !== "here") return;
-    const sweptAt = Date.now();
+    const sweptAt = this.now();
     const changedAt = (file) => Math.min(sweptAt, Math.max(file.mtimeMs, file.ctimeMs));
     const seen = listProjectFiles(this.dir);
     const heard = new Map(this.overwritten);
@@ -1477,7 +1480,7 @@ var Engine = class {
       await this.settle();
       const window2 = { ...this.newGroup(who, label), idleMs };
       this.windows.push(window2);
-      this.touch(window2, Date.now());
+      this.touch(window2, this.now());
       const close = () => this.queue(() => this.sweepAndEnd(window2));
       return { id: window2.id, startedAt: window2.startedAt, close };
     });
@@ -1485,11 +1488,19 @@ var Engine = class {
   /** A window with no write for its idleMs ends, so a close that never comes cannot hold every later write. */
   touch(window2, at) {
     window2.lastWriteAt = Math.max(window2.lastWriteAt ?? at, at);
+    this.endWhenIdle(window2, window2.idleMs);
+  }
+  endWhenIdle(window2, delay) {
     clearTimeout(window2.idleTimer);
-    if (window2.idleMs === void 0 || !Number.isFinite(window2.idleMs)) return;
+    if (window2.idleMs === void 0 || !Number.isFinite(window2.idleMs) || delay === void 0)
+      return;
     window2.idleTimer = setTimeout(
-      () => this.background(() => this.sweepAndEnd(window2)),
-      window2.idleMs
+      () => {
+        const left = window2.idleMs - (this.now() - (window2.lastWriteAt ?? this.now()));
+        if (left > 0) this.endWhenIdle(window2, left);
+        else this.background(() => this.sweepAndEnd(window2));
+      },
+      Math.min(delay, MAX_TIMER_MS)
     );
     window2.idleTimer.unref?.();
   }
@@ -1799,7 +1810,7 @@ function historyCache(open2) {
   };
 }
 
-// ../studio-server/dist/chunk-W2SBTCO2.js
+// ../studio-server/dist/chunk-IMG2GSY6.js
 function getElementScreenshotClip(selector, selectorIndex) {
   let matches;
   try {
@@ -1812,6 +1823,16 @@ function getElementScreenshotClip(selector, selectorIndex) {
   const safeIndex = Math.max(0, Math.min(matches.length - 1, Math.floor(selectorIndex ?? 0)));
   const el = matches[safeIndex] ?? null;
   if (!(el instanceof HTMLElement)) return void 0;
+  const page = window;
+  const faded = page.__hfThumbnailFaded ??= [];
+  for (let node = el; node.parentElement; node = node.parentElement) {
+    for (const sibling of Array.from(node.parentElement.children)) {
+      const style = sibling.style;
+      if (sibling === node || !style) continue;
+      faded.push([style, style.getPropertyValue("opacity"), style.getPropertyPriority("opacity")]);
+      style.setProperty("opacity", "0", "important");
+    }
+  }
   const rect = el.getBoundingClientRect();
   if (rect.width < 4 || rect.height < 4) return void 0;
   const pad = 8;
@@ -1826,6 +1847,14 @@ function getElementScreenshotClip(selector, selectorIndex) {
     height: Math.max(1, Math.min(rect.height + pad * 2, maxHeight))
   };
 }
+function clearElementScreenshotIsolation() {
+  const page = window;
+  for (const [style, value, priority] of (page.__hfThumbnailFaded ?? []).reverse()) {
+    if (value) style.setProperty("opacity", value, priority);
+    else style.removeProperty("opacity");
+  }
+  page.__hfThumbnailFaded = [];
+}
 
 // ../studio-server/dist/chunk-WK3ZL3SN.js
 import { resolve as resolve4 } from "path";
@@ -2101,7 +2130,8 @@ import {
   statSync as statSync32,
   fstatSync as fstatSync2,
   renameSync as renameSync22,
-  readdirSync as readdirSync22
+  readdirSync as readdirSync22,
+  realpathSync as realpathSync2
 } from "fs";
 import { resolve as resolve22, dirname as dirname32, join as join52 } from "path";
 import { spawn } from "child_process";
@@ -5121,14 +5151,15 @@ import {
   writeFileSync as writeFileSync42
 } from "fs";
 import { join as join11 } from "path";
-import { createHash as createHash32, randomUUID as randomUUID22 } from "crypto";
+import { createHash as createHash42, randomUUID as randomUUID22 } from "crypto";
 import { readFileSync as readFileSync8 } from "fs";
+import { createHash as createHash32 } from "crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
 import { join as join12, resolve as resolve52 } from "path";
 import { execFile } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
 import { dirname as dirname52, join as join13, relative as relative4, sep as sep22 } from "path";
-import { createHash as createHash42, randomBytes } from "crypto";
+import { createHash as createHash5, randomBytes } from "crypto";
 import { existsSync as existsSync9 } from "fs";
 import { existsSync as existsSync10, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
 import { join as join14, resolve as resolve6 } from "path";
@@ -5141,7 +5172,7 @@ import { basename as basename22, dirname as dirname6, extname as extname2, join
 import { existsSync as existsSync12, readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join16 } from "path";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { readFileSync as readFileSync14, readdirSync as readdirSync5, rmSync as rmSync5 } from "fs";
 import { join as join17 } from "path";
 async function filterCompositionFiles(projectDir, files) {
@@ -6103,18 +6134,83 @@ function readableText(file) {
     throw error;
   }
 }
-function updateReferences(projectDir, oldPath, newPath) {
+var escapeRegExp = (text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var SEPARATOR = String.raw`\\{0,2}[\\/]`;
+var REFERENCE_START = String.raw`(?<![\w./\\+-])`;
+var FILE_END = String.raw`(?![\w-]|\.\w)`;
+function referencePattern(oldPath, isDirectory) {
+  const name = oldPath.split("/").map(escapeRegExp).join(SEPARATOR);
+  const end = isDirectory ? `(?=${SEPARATOR})` : FILE_END;
+  return new RegExp(
+    String.raw`${REFERENCE_START}(?<lead>(?:\.{1,2}${SEPARATOR}|${SEPARATOR}){0,4})${name}${end}`,
+    "g"
+  );
+}
+function referenceRewriter(oldPath, newPath, isDirectory, existing = []) {
+  const pattern = referencePattern(oldPath, isDirectory);
+  const around = /* @__PURE__ */ new Map();
+  const afterLengths = /* @__PURE__ */ new Set();
+  let window2 = 0;
+  for (const path of existing) {
+    if (path.length <= oldPath.length) continue;
+    for (const start of occurrences(path, oldPath)) {
+      const [before, after] = [path.slice(0, start), path.slice(start + oldPath.length)];
+      const befores = around.get(after) ?? around.set(after, /* @__PURE__ */ new Map()).get(after);
+      (befores.get(before.length) ?? befores.set(before.length, /* @__PURE__ */ new Set()).get(before.length)).add(
+        before
+      );
+      afterLengths.add(after.length);
+      window2 = Math.max(window2, path.length * 3);
+    }
+  }
+  const normalized = (text2) => text2.replace(/\\{0,2}[\\/]/g, "/");
+  return (text2) => text2.replace(pattern, (...args) => {
+    const [match, offset] = [args[0], args.at(-3)];
+    const { lead } = args.at(-1);
+    const at = offset + lead.length;
+    const head = normalized(text2.slice(Math.max(0, at - window2), at));
+    const tail = normalized(text2.slice(offset + match.length, offset + match.length + window2));
+    const inLonger = [...afterLengths].some((after) => {
+      const befores = tail.length >= after && around.get(tail.slice(0, after));
+      return befores && [...befores].some(
+        ([length, set]) => head.length >= length && set.has(head.slice(head.length - length))
+      );
+    });
+    return inLonger ? match : `${lead}${newPath}`;
+  });
+}
+function occurrences(text2, part) {
+  const at = [];
+  for (let i = text2.indexOf(part); i >= 0; i = text2.indexOf(part, i + 1)) at.push(i);
+  return at;
+}
+function projectPaths(root, dir = root, prefix = "", ancestors = /* @__PURE__ */ new Set()) {
+  return readableEntries(dir).flatMap((entry) => {
+    const [path, full2] = [`${prefix}${entry.name}`, join52(dir, entry.name)];
+    const real = entry.name === "node_modules" ? null : directoryReal(entry, full2);
+    if (real === null || ancestors.has(real) || !isSafePath(root, full2)) return [path];
+    return [path, ...projectPaths(root, full2, `${path}/`, /* @__PURE__ */ new Set([...ancestors, real]))];
+  });
+}
+function directoryReal(entry, full2) {
+  try {
+    return entry.isDirectory() || entry.isSymbolicLink() && statSync32(full2).isDirectory() ? realpathSync2(full2) : null;
+  } catch {
+    return null;
+  }
+}
+function updateReferences(projectDir, oldPath, newPath, isDirectory) {
   const textFiles = walkFiles(
     projectDir,
     (name) => /\.(html|css|js|jsx|ts|tsx|json|mjs|cjs|md|mdx)$/i.test(name)
   );
+  const rewrite = referenceRewriter(oldPath, newPath, isDirectory, projectPaths(projectDir));
   let updatedCount = 0;
   for (const file of textFiles) {
     if (!isSafePath(projectDir, file)) continue;
     const content = readableText(file);
     if (content === null) continue;
-    if (!content.includes(oldPath)) continue;
-    const updated = content.split(oldPath).join(newPath);
+    const updated = rewrite(content);
     if (updated !== content) {
       replaceFileAtomically(file, updated, statSync32(file).mode);
       updatedCount++;
@@ -6388,7 +6484,7 @@ async function prepareGsapMutationScript(c, res, firstMutation) {
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
     const compId = html.match(/data-composition-id="([^"]+)"/)?.[1] ?? "main";
-    const { GSAP_CDN } = await import("./dist-OKRUIHYU.js");
+    const { GSAP_CDN } = await import("./dist-KNGSQALD.js");
     const bootstrap = [
       `<script src="${GSAP_CDN}"></script>`,
       "<script>",
@@ -6436,7 +6532,9 @@ async function applyGsapMutations(c, res, mutations) {
   } catch (error) {
     return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
   }
+  const mutationChanges = [];
   for (const mutation of mutations) {
+    const previousScript = block.scriptText;
     const result = await executeGsapMutation(mutation, block, respond, writer);
     if (result instanceof Response) return result;
     let newScript = typeof result === "string" ? result : result.script;
@@ -6446,6 +6544,7 @@ async function applyGsapMutations(c, res, mutations) {
     if (HOLD_SYNC_MUTATION_TYPES.has(mutation.type)) {
       newScript = writer === "acorn" ? syncPositionHoldsBeforeKeyframes(newScript) : (await loadGsapParser()).syncPositionHoldsBeforeKeyframes(newScript);
     }
+    mutationChanges.push(newScript !== previousScript);
     block.scriptText = newScript;
   }
   const changed = block.scriptText !== initialScript;
@@ -6470,6 +6569,7 @@ async function applyGsapMutations(c, res, mutations) {
     ok: true,
     changed,
     mutated: changed,
+    mutationChanges,
     parsed: parseGsapScriptAcorn(block.scriptText),
     before: beforeHtml,
     after: newHtml,
@@ -7529,11 +7629,14 @@ function registerFileRoutes(api, adapter) {
       return c.json({ error: "targets required" }, 400);
     }
     const originalContent = readFileSync32(ctx.absPath, "utf-8");
-    let next = originalContent;
-    for (const target of targets) {
-      next = removeElementFromHtml(next, target);
-    }
-    return writeIfChanged(c, ctx.project.dir, ctx.filePath, ctx.absPath, originalContent, next);
+    return writeIfChanged(
+      c,
+      ctx.project.dir,
+      ctx.filePath,
+      ctx.absPath,
+      originalContent,
+      removeElementsFromHtml(originalContent, targets)
+    );
   });
   api.post("/projects/:id/file-mutations/split-batch", async (c) => {
     const body = await c.req.json().catch(() => null);
@@ -7937,6 +8040,19 @@ function registerFileRoutes(api, adapter) {
     const exists = probeElementInSource(content, parsed.target);
     return c.json({ exists });
   });
+  api.post("/projects/:id/file-mutations/probe-elements/*", async (c) => {
+    const ctx = await resolveFileMutationContext(c, adapter, "probe-elements");
+    if ("error" in ctx) return ctx.error;
+    const body = await c.req.json().catch(() => null);
+    if (!Array.isArray(body?.targets)) return c.json({ error: "targets required" }, 400);
+    let content;
+    try {
+      content = readFileSync32(ctx.absPath, "utf-8");
+    } catch {
+      return c.json({ exists: body.targets.map(() => false) });
+    }
+    return c.json({ exists: probeElementsInSource(content, body.targets) });
+  });
   api.patch("/projects/:id/files/*", async (c) => {
     const res = await resolveProjectFile(c, adapter, { mustExist: true });
     if ("error" in res) return res.error;
@@ -7951,9 +8067,10 @@ function registerFileRoutes(api, adapter) {
     if (existsSync3(newAbs)) {
       return c.json({ error: "already exists" }, 409);
     }
+    const isDirectory = statSync32(res.absPath, { throwIfNoEntry: false })?.isDirectory() ?? false;
     ensureDir(res.project.dir, newAbs);
     renameSync22(res.absPath, newAbs);
-    const updatedFiles = updateReferences(res.project.dir, res.filePath, body.newPath);
+    const updatedFiles = updateReferences(res.project.dir, res.filePath, body.newPath, isDirectory);
     return c.json({ ok: true, path: body.newPath, updatedReferences: updatedFiles });
   });
   api.post("/projects/:id/duplicate-file", async (c) => {
@@ -8019,17 +8136,18 @@ function registerFileRoutes(api, adapter) {
     });
     if ("error" in res) return res.error;
     const html = readFileSync32(res.absPath, "utf-8");
+    const etag = `${fileContentVersion(html).slice(0, -1)}:gsap-animations:v1"`;
+    const headers = { ETag: etag, "Cache-Control": "no-cache" };
+    if (c.req.header("If-None-Match") === etag) return new Response(null, { status: 304, headers });
     const block = extractGsapScriptBlock(html);
     if (!block) {
-      return c.json({
-        animations: [],
-        timelineVar: "tl",
-        preamble: "",
-        postamble: ""
-      });
+      return c.json(
+        { animations: [], timelineVar: "tl", preamble: "", postamble: "" },
+        200,
+        headers
+      );
     }
-    const parsed = parseGsapScriptAcorn(block.scriptText);
-    return c.json(parsed);
+    return c.json(parseGsapScriptAcorn(block.scriptText), 200, headers);
   });
   api.get("/projects/:id/gsap-mutation-capabilities", async (c) => {
     const project = await adapter.resolveProject(c.req.param("id"));
@@ -8179,6 +8297,9 @@ function tagRootCompositionFile(bodyHtml, compPath) {
   if (bodyHtml.slice(match.index, tagEnd).includes("data-composition-file")) return bodyHtml;
   return bodyHtml.slice(0, tagEnd) + ` data-composition-file="${compPath}"` + bodyHtml.slice(tagEnd);
 }
+function rootHeadContent(rootHtml) {
+  return rootHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i)?.[1] ?? "";
+}
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
   const compFile = join62(projectDir, compPath);
   if (!existsSync42(compFile)) return null;
@@ -8214,11 +8335,7 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, raw
   rewrittenContent = tagRootCompositionFile(rewrittenContent, compPath);
   const indexPath = join62(projectDir, "index.html");
   let headContent = "";
-  if (existsSync42(indexPath)) {
-    const indexHtml = readFileSync42(indexPath, "utf-8");
-    const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
-    headContent = headMatch?.[1] ?? "";
-  }
+  if (existsSync42(indexPath)) headContent = rootHeadContent(readFileSync42(indexPath, "utf-8"));
   if (baseHref && !hasBaseElement(headContent)) {
     headContent = `<base href="${baseHref}">
 ${headContent}`;
@@ -9357,25 +9474,49 @@ function closureOf(read, compPath) {
   return closure;
 }
 var inputSignatures = /* @__PURE__ */ new Map();
+var rootMemos = /* @__PURE__ */ new Map();
+var sha1 = (text2) => createHash32("sha1").update(text2).digest("hex");
+function rootHashes(read) {
+  const source = read(ROOT_COMPOSITION) ?? "";
+  return { root: sha1(source), head: sha1(rootHeadContent(source)) };
+}
 function compositionInputSignature(projectDir, compPath, projectSignature) {
   const key = `${projectDir}\0${compPath}`;
   const known = inputSignatures.get(key);
   if (known?.projectSignature === projectSignature) return known.inputSignature;
   const read = projectReader(projectDir);
-  const inputs = closureOf(read, normalizeSource(compPath) ?? compPath).add(ROOT_COMPOSITION);
-  const siblings = [...closureOf(read, ROOT_COMPOSITION)].filter((path) => !inputs.has(path));
-  const inputSignature = createProjectSignature(projectDir, new Set(siblings));
+  const comp = normalizeSource(compPath) ?? compPath;
+  const inputs = closureOf(read, comp).add(ROOT_COMPOSITION);
+  const excluded = new Set(
+    [...closureOf(read, ROOT_COMPOSITION)].filter((path) => !inputs.has(path))
+  );
+  let inputSignature;
+  if (comp === ROOT_COMPOSITION) {
+    inputSignature = createProjectSignature(projectDir, excluded);
+  } else {
+    const hashes = rootHashes(read);
+    if (!rootMemos.has(projectDir)) rootMemos.set(projectDir, { ...hashes, affected: null });
+    inputSignature = `${createProjectSignature(projectDir, excluded.add(ROOT_COMPOSITION))}:${hashes.head}`;
+  }
   inputSignatures.set(key, { projectSignature, inputSignature });
   return inputSignature;
 }
 function compositionsAffectedBy(projectDir, changedPath) {
   const changed = changedPath.replace(/\\/g, "/");
   const read = projectReader(projectDir);
+  if (changed === ROOT_COMPOSITION) {
+    const now = rootHashes(read);
+    const memo = rootMemos.get(projectDir);
+    if (memo?.root === now.root) return memo.affected;
+    const affected = memo?.head === now.head ? [ROOT_COMPOSITION] : null;
+    rootMemos.set(projectDir, { ...now, affected });
+    return affected;
+  }
   const mounted = closureOf(read, ROOT_COMPOSITION);
-  if (changed === ROOT_COMPOSITION || !mounted.has(changed)) return null;
+  if (!mounted.has(changed)) return null;
   return [...mounted].filter((path) => closureOf(read, path).has(changed));
 }
-var THUMBNAIL_CACHE_VERSION = "v4";
+var THUMBNAIL_CACHE_VERSION = "v5";
 var THUMBNAIL_MAX_OUTPUT_WIDTH = 240;
 var THUMBNAIL_MAX_OUTPUT_HEIGHT = 135;
 var THUMBNAIL_CACHE_MAX_BYTES = 512 * 1024 * 1024;
@@ -9448,7 +9589,7 @@ function readFileOnce(file) {
 function manifestKey(file) {
   const manifest = readFileOnce(file);
   if (typeof manifest === "string") return { key: "", mtimeMs: -Infinity };
-  const hash = createHash32("sha1").update(manifest.data).digest("hex").slice(0, 16);
+  const hash = createHash42("sha1").update(manifest.data).digest("hex").slice(0, 16);
   return { key: `_${hash}`, mtimeMs: Math.round(manifest.mtimeMs) };
 }
 function registerThumbnailRoutes(api, adapter) {
@@ -9485,7 +9626,7 @@ function registerThumbnailRoutes(api, adapter) {
     let sourceKey = "";
     if (source !== "missing") {
       const html = source.data.toString("utf-8");
-      sourceKey = `_${createHash32("sha1").update(html).digest("hex").slice(0, 16)}`;
+      sourceKey = `_${createHash42("sha1").update(html).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.round(source.mtimeMs);
       if (!vpWidth) {
         const wMatch = html.match(/data-width=["'](\d+)["']/);
@@ -9501,9 +9642,9 @@ function registerThumbnailRoutes(api, adapter) {
     const previewPath = compPath === "index.html" ? `${projectUrl}/preview` : `${projectUrl}/preview/comp/${compPath.split("/").map(encodeURIComponent).join("/")}`;
     const previewUrl = `${previewPath}?${PREVIEW_CAPTURE_PARAM}=1`;
     const cacheDir = join11(project.dir, ".thumbnails");
-    const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}_${selectorIndex ?? 0}` : "";
+    const selectorKey = selector ? `_${createHash42("sha1").update(selector).digest("hex").slice(0, 16)}_${selectorIndex ?? 0}` : "";
     const urlVersionKey = urlVersion ? `_${urlVersion.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 32)}` : "";
-    const inputSignatureKey = `_${createHash32("sha1").update(inputSignature).digest("hex").slice(0, 16)}`;
+    const inputSignatureKey = `_${createHash42("sha1").update(inputSignature).digest("hex").slice(0, 16)}`;
     const outputScale = outputMode === "source" ? 1 : Math.min(1, THUMBNAIL_MAX_OUTPUT_WIDTH / compW, THUMBNAIL_MAX_OUTPUT_HEIGHT / compH);
     const outputWidth = Math.max(1, Math.round(compW * outputScale));
     const outputHeight = Math.max(1, Math.round(compH * outputScale));
@@ -9631,7 +9772,7 @@ function freezeExtractArgs(src, mediaTime, output) {
 var randomStillToken = () => randomBytes(4).toString("hex");
 function freezeStillFileName(clipId, playhead, token = randomStillToken()) {
   const stem = clipId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 48) || "clip";
-  const idHash = createHash42("sha256").update(clipId).digest("hex").slice(0, 10);
+  const idHash = createHash5("sha256").update(clipId).digest("hex").slice(0, 10);
   return `${stem}-${idHash}-${Math.round(playhead * 1e3)}-${token}.png`;
 }
 function readFreezeSource(html, target, playhead) {
@@ -10790,7 +10931,7 @@ function numericAttribute(element, name) {
 }
 function createPreviewDocumentStore(projectDir, salt) {
   const dir = join17(projectDir, ".hyperframes", "preview");
-  const fileFor = (key) => join17(dir, `${createHash5("sha256").update(`${salt}
+  const fileFor = (key) => join17(dir, `${createHash6("sha256").update(`${salt}
 ${key}`).digest("hex").slice(0, 32)}.html`);
   return {
     read(key) {
@@ -10899,6 +11040,7 @@ export {
   openProjectHistory,
   historyCache,
   getElementScreenshotClip,
+  clearElementScreenshotIsolation,
   injectMediaCodecMapIntoHtml,
   STUDIO_MOTION_PATH,
   createStudioMotionRenderBodyScript,

package/dist/{chunk-LMC46FK5.js → chunk-QMFCL2ZN.js}

@@ -8,7 +8,7 @@ import {
   firstFrameColourArgs,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-FCEFKWPM.js";
+} from "./chunk-IEE7GIVX.js";
 import {
   mkdirWithinProject,
   realProjectRoot,

package/dist/{chunk-DR7QW6C5.js → chunk-QXNRRMBQ.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-IP3XINRB.js";
+} from "./chunk-BDNCUMZM.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-FCEFKWPM.js";
+} from "./chunk-IEE7GIVX.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";