hyperframes 0.8.190 → 0.8.192

package/dist/{chunk-TMBUBLZB.js → chunk-4HCJOFMB.js}

@@ -21,9 +21,9 @@ import {
   mkdirWithinProject
 } from "./chunk-OFQWTKPW.js";
 
-// ../studio-server/dist/chunk-YIMSBQIO.js
+// ../studio-server/dist/chunk-B4NDV4NM.js
 import { randomUUID as randomUUID7 } from "crypto";
-import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, stat as stat2, writeFile } from "fs/promises";
 import {
   existsSync as existsSync3,
   lstatSync as lstatSync4,
@@ -58,6 +58,7 @@ import { constants, createReadStream, createWriteStream, renameSync as renameSyn
 import { copyFile, mkdir, readdir, readFile, rename, rm, stat } from "fs/promises";
 import { dirname, join as join2 } from "path";
 import { pipeline } from "stream/promises";
+import { extname as extname2 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
 import { lstat, readdir as readdir2, rm as rm2 } from "fs/promises";
@@ -97,6 +98,9 @@ import {
 import { dirname as dirname3, join as join6, relative as relative4, resolve as resolve5, sep as sep4 } from "path";
 import { closeSync as closeSync3, constants as constants4, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync9, writeSync as writeSync2 } from "fs";
 import { dirname as dirname4 } from "path";
+import { readdirSync as readdirSync5 } from "fs";
+import { rm as rm4, stat as stat3 } from "fs/promises";
+import { join as join9 } from "path";
 var RECEIPT_TTL_MS = 1e4;
 var receipts = /* @__PURE__ */ new Map();
 var overwriteListeners = /* @__PURE__ */ new Set();
@@ -110,9 +114,9 @@ function hashVersion(hex) {
 function hashOfVersion(version) {
   return /^"sha256:([0-9a-f]{64})"$/.exec(version)?.[1];
 }
-function settledFileTag(stat2, now = Date.now()) {
-  if (now - stat2.ctimeMs < 3e3) return null;
-  return [stat2.ino, stat2.ctimeMs, stat2.size].map((n) => n.toString(36)).join("-");
+function settledFileTag(stat4, now = Date.now()) {
+  if (now - stat4.ctimeMs < 3e3) return null;
+  return [stat4.ino, stat4.ctimeMs, stat4.size].map((n) => n.toString(36)).join("-");
 }
 function createWriteToken(requestToken) {
   const token = requestToken?.trim();
@@ -391,8 +395,8 @@ function signatureEntryStat(projectDir, entry, file, outputs) {
   if (isSkippedEntry(entry) || !isPathWithin(projectDir, file)) return null;
   if (isRenderOutput(projectDir, file, outputs)) return null;
   try {
-    const stat2 = lstatSync(file);
-    return stat2.isSymbolicLink() ? null : stat2;
+    const stat4 = lstatSync(file);
+    return stat4.isSymbolicLink() ? null : stat4;
   } catch {
     return null;
   }
@@ -406,17 +410,17 @@ function collectProjectSignatureFiles(projectDir, dir, files, outputs = readRend
   }
   for (const entry of entries) {
     const file = resolve2(dir, entry);
-    const stat2 = signatureEntryStat(projectDir, entry, file, outputs);
-    if (!stat2) continue;
-    if (stat2.isDirectory()) {
+    const stat4 = signatureEntryStat(projectDir, entry, file, outputs);
+    if (!stat4) continue;
+    if (stat4.isDirectory()) {
       collectProjectSignatureFiles(projectDir, file, files, outputs);
-    } else if (stat2.isFile()) {
+    } else if (stat4.isFile()) {
       files.push({
         file,
-        mtimeMs: stat2.mtimeMs,
-        ctimeMs: stat2.ctimeMs,
-        size: stat2.size,
-        textContentEligible: isTextContentEligible(file, stat2.size)
+        mtimeMs: stat4.mtimeMs,
+        ctimeMs: stat4.ctimeMs,
+        size: stat4.size,
+        textContentEligible: isTextContentEligible(file, stat4.size)
       });
     }
   }
@@ -426,19 +430,19 @@ function collectProjectSignatureManifestFiles(projectDir, files) {
   for (const manifestPath of STUDIO_SIGNATURE_MANIFEST_PATHS) {
     const file = resolve2(projectDir, manifestPath);
     if (seen.has(file) || !isPathWithin(projectDir, file)) continue;
-    let stat2;
+    let stat4;
     try {
-      stat2 = lstatSync(file);
+      stat4 = lstatSync(file);
     } catch {
       continue;
     }
-    if (stat2.isSymbolicLink() || !stat2.isFile()) continue;
+    if (stat4.isSymbolicLink() || !stat4.isFile()) continue;
     files.push({
       file,
-      mtimeMs: stat2.mtimeMs,
-      ctimeMs: stat2.ctimeMs,
-      size: stat2.size,
-      textContentEligible: isTextContentEligible(file, stat2.size)
+      mtimeMs: stat4.mtimeMs,
+      ctimeMs: stat4.ctimeMs,
+      size: stat4.size,
+      textContentEligible: isTextContentEligible(file, stat4.size)
     });
     seen.add(file);
   }
@@ -578,11 +582,21 @@ async function openBlobStore(dir) {
       total += size;
       return hash;
     },
+    reference: (absPath) => hashFile(absPath),
     has: (hash) => sizes.has(hash),
     read: async (hash) => readBlob(dir, hash),
     writeTo: async (hash, absPath, beforeReplace) => cloneOrCopy(pathOf(hash), absPath, beforeReplace),
     bytes: () => total,
     size: (hash) => sizes.get(hash) ?? 0,
+    async drop(hashes) {
+      for (const hash of hashes) {
+        const size = sizes.get(hash);
+        if (size === void 0) continue;
+        await rm(pathOf(hash), { force: true });
+        sizes.delete(hash);
+        total -= size;
+      }
+    },
     async prune(keep) {
       for (const [hash, size] of sizes) {
         if (keep.has(hash)) continue;
@@ -593,6 +607,39 @@ async function openBlobStore(dir) {
     }
   };
 }
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".mov",
+  ".m4v",
+  ".webm",
+  ".mkv",
+  ".avi",
+  ".mxf",
+  ".m2ts",
+  ".mp3",
+  ".wav",
+  ".aac",
+  ".m4a",
+  ".flac",
+  ".ogg",
+  ".opus"
+]);
+var COPY_NOTHING_ABOVE_BYTES = 64 * 1024 ** 2;
+var isUncopied = (path, size) => size > COPY_NOTHING_ABOVE_BYTES || MEDIA_EXTENSIONS.has(extname2(path).toLowerCase());
+function uncopiedOnlyHashes(log, sizeOf) {
+  const copied = /* @__PURE__ */ new Set();
+  const uncopied = /* @__PURE__ */ new Set();
+  const note = (path, hash) => {
+    if (hash) (isUncopied(path, sizeOf(hash)) ? uncopied : copied).add(hash);
+  };
+  for (const [path, hash] of log.baseline) note(path, hash);
+  for (const entry of log.entries)
+    for (const file of entry.files) {
+      note(file.path, file.before);
+      note(file.path, file.after);
+    }
+  return [...uncopied].filter((hash) => !copied.has(hash));
+}
 var ID_PATH = join3(".hyperframes", "history-id");
 var ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var isHistoryId = (name) => ID_SHAPE.test(name);
@@ -763,13 +810,13 @@ function projectGone(dir, id, dev, tempDir) {
 }
 function diskStillHere(dir, dev, tempDir) {
   let at = dir;
-  let stat2 = statSync3(at, { throwIfNoEntry: false });
-  while (!stat2) {
+  let stat4 = statSync3(at, { throwIfNoEntry: false });
+  while (!stat4) {
     if (dirname2(at) === at) return false;
     at = dirname2(at);
-    stat2 = statSync3(at, { throwIfNoEntry: false });
+    stat4 = statSync3(at, { throwIfNoEntry: false });
   }
-  if (typeof dev === "number") return stat2.dev === dev;
+  if (typeof dev === "number") return stat4.dev === dev;
   return at === dir || isSafePath(tempDir, at);
 }
 function lastUsed(home) {
@@ -870,12 +917,12 @@ function stillPendingAfterUnlink(item) {
   let descriptor;
   try {
     descriptor = openSync(item.path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
-    const stat2 = fstatSync(descriptor);
-    if (!stat2.isFile() || stat2.isSymbolicLink()) return false;
+    const stat4 = fstatSync(descriptor);
+    if (!stat4.isFile() || stat4.isSymbolicLink()) return false;
     const hash = createHash4("sha256").update(readFileSync6(descriptor)).digest("hex");
     if (hash !== item.hash) return false;
     const current = lstatSync2(item.path);
-    if (current.dev !== stat2.dev || current.ino !== stat2.ino) return false;
+    if (current.dev !== stat4.dev || current.ino !== stat4.ino) return false;
     unlinkSync(item.path);
     return false;
   } catch (error) {
@@ -975,8 +1022,8 @@ function ownerPid(owner) {
   const pid = owner.pid;
   return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : null;
 }
-function ordinaryOwner(stat2) {
-  return stat2.isFile() && stat2.nlink === 1;
+function ordinaryOwner(stat4) {
+  return stat4.isFile() && stat4.nlink === 1;
 }
 function sameOwnerFile(before, current) {
   return current.dev === before.dev && current.ino === before.ino;
@@ -1050,8 +1097,8 @@ function runsOnDisk(root) {
   return entries.filter((entry) => entry.isDirectory() && UUID.test(entry.name)).flatMap((entry) => {
     const path = join6(root, entry.name);
     try {
-      const stat2 = lstatSync3(path);
-      return [{ path, stat: stat2 }];
+      const stat4 = lstatSync3(path);
+      return [{ path, stat: stat4 }];
     } catch {
       return [];
     }
@@ -1065,10 +1112,10 @@ function planSnapshotCleanup(project, state, now = Date.now()) {
   const runs = runsOnDisk(root);
   for (const run of runs.slice(0, SNAPSHOT_RUNS_TO_KEEP)) keep.add(run.path);
   const pending = [];
-  for (const { path, stat: stat2 } of runs) {
-    if (keep.has(path) || now - stat2.mtimeMs < SNAPSHOT_GRACE_MS || liveOwner(path)) continue;
+  for (const { path, stat: stat4 } of runs) {
+    if (keep.has(path) || now - stat4.mtimeMs < SNAPSHOT_GRACE_MS || liveOwner(path)) continue;
     try {
-      const run = { path, dev: stat2.dev, ino: stat2.ino, mtimeMs: stat2.mtimeMs };
+      const run = { path, dev: stat4.dev, ino: stat4.ino, mtimeMs: stat4.mtimeMs };
       if (!unchangedRun(project, run)) continue;
       pending.push(run);
       retireReferences(records2, root, path);
@@ -1704,6 +1751,7 @@ var Engine = class {
     );
     if (!log) return this.firstOpen();
     this.log = withoutHiddenPaths(log);
+    await this.reclaimUncopied();
     if (!this.log.keepsLedger) await this.takeInUnnamedLedger();
     const cache = this.readStatCache();
     const last = this.log.entries.at(-1)?.id ?? START;
@@ -1717,6 +1765,10 @@ var Engine = class {
     this.reopenClosedWindow();
     await this.settleAll();
   }
+  /** Copies an older version took of files that are no longer copied; text and small files are never touched. */
+  async reclaimUncopied() {
+    await this.blobs.drop(uncopiedOnlyHashes(this.log, (hash) => this.blobs.size(hash)));
+  }
   hearWrites() {
     const realDir = realFilePath(this.dir);
     this.stopHearing = onFileOverwritten((absPath, version, bytes) => {
@@ -1731,7 +1783,8 @@ var Engine = class {
         chainBackFrom(this.overwritten.get(path), replaced).set(after, replaced)
       );
       this.queue(async () => {
-        if (!this.blobs.has(replaced)) await this.storeBytes(bytes);
+        if (!this.blobs.has(replaced) && !isUncopied(path, bytes.length))
+          await this.storeBytes(bytes);
       }).catch((error) => this.options.onError?.(error));
     });
   }
@@ -1810,7 +1863,8 @@ var Engine = class {
   }
   async recordAdopted(file, sweptAt, stored) {
     if (stored === null || this.whereFolder() !== "here") return;
-    const hash = this.blobs.has(stored) ? stored : await this.storeIfPresent(file.path);
+    const kept = this.blobs.has(stored) || isUncopied(file.path, file.size);
+    const hash = kept ? stored : await this.storeIfPresent(file.path);
     if (hash === null) return;
     const change = { path: file.path, before: null, after: hash };
     const found = this.overwrittenBy(change, void 0, /* @__PURE__ */ new Set());
@@ -1886,22 +1940,24 @@ var Engine = class {
   /** The file's hash once copied in; null when it was removed before the copy (the next sweep records that). */
   async storeIfPresent(path) {
     try {
-      return await this.blobs.put(join8(this.dir, path));
+      const abs = join8(this.dir, path);
+      const { size } = await stat2(abs);
+      return await (isUncopied(path, size) ? this.blobs.reference(abs) : this.blobs.put(abs));
     } catch (error) {
       if (error.code === "ENOENT") return null;
       throw error;
     }
   }
-  async observe(path, stat2, at) {
+  async observe(path, stat4, at) {
     const known = this.tracked.get(path) ?? { hash: null, stat: null };
-    if (stat2 && known.stat === stat2) return false;
+    if (stat4 && known.stat === stat4) return false;
     const heard = this.overwritten.get(path);
     const hash = await this.storeIfPresent(path);
     if (hash === null || this.whereFolder() !== "here") return false;
-    this.tracked.set(path, { hash, stat: stat2 });
+    this.tracked.set(path, { hash, stat: stat4 });
     this.forgetWritesBefore(path, hash, heard);
     if (known.hash !== hash) await this.record(path, known.hash, hash, at);
-    return known.hash !== hash || known.stat !== stat2;
+    return known.hash !== hash || known.stat !== stat4;
   }
   async record(path, before, after, at) {
     const endedBeforeThisWrite = this.windows.filter((open) => !takesWrite(open, at));
@@ -2199,9 +2255,9 @@ var Engine = class {
     const parts = path.split("/");
     for (let depth = 1; depth <= parts.length; depth += 1) {
       const at = parts.slice(0, depth).join("/");
-      const stat2 = lstatSync4(join8(this.dir, at), { throwIfNoEntry: false });
-      if (!stat2) return void 0;
-      if (at === path || !stat2.isDirectory()) return { at, stat: stat2 };
+      const stat4 = lstatSync4(join8(this.dir, at), { throwIfNoEntry: false });
+      if (!stat4) return void 0;
+      if (at === path || !stat4.isDirectory()) return { at, stat: stat4 };
     }
     return void 0;
   }
@@ -2220,6 +2276,11 @@ var Engine = class {
   async writeAs(who, label, target, extra) {
     this.assertWritable();
     const changes = [...target].filter(([path, hash]) => (this.tracked.get(path)?.hash ?? null) !== hash).sort(([, a], [, b]) => Number(a !== null) - Number(b !== null));
+    const gone = changes.find(([, hash]) => hash !== null && !this.blobs.has(hash));
+    if (gone)
+      throw new Error(
+        `An earlier version of ${gone[0]} is not kept, so this cannot be brought back.`
+      );
     const deleted = new Set(changes.filter(([, hash]) => hash === null).map(([path]) => path));
     const blocked = changes.filter(([, hash]) => hash !== null).map(([path]) => this.inTheWay(path, deleted)).find(Boolean);
     if (blocked) throw new Error(`${blocked} is in the way; move or delete it, then try again.`);
@@ -2386,6 +2447,9 @@ var Engine = class {
         if ((await readdir3(dest).catch(missingIsEmpty)).length > 0)
           throw new Error(`Checkout writes into an empty folder only: ${dest}`);
         const files = manifestAround(this.log, entryId, side);
+        for (const [path, hash] of files)
+          if (!this.blobs.has(hash))
+            throw new Error(`The version of ${path} from then is not kept.`);
         try {
           for (const [path, hash] of files) await this.blobs.writeTo(hash, join8(dest, path));
         } catch (error) {
@@ -2490,6 +2554,61 @@ function readProjectHistory(options) {
     }
   };
 }
+function historyIds(historyRoot) {
+  try {
+    return readdirSync5(historyRoot).filter(isHistoryId);
+  } catch {
+    return [];
+  }
+}
+function namedHashes(log) {
+  const hashes = new Set(log.baseline.values());
+  for (const entry of log.entries) {
+    for (const file of entry.files) {
+      if (file.before) hashes.add(file.before);
+      if (file.after) hashes.add(file.after);
+    }
+  }
+  return hashes;
+}
+async function blobSizes(blobs, hashes) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const hash of hashes)
+    sizes.set(hash, (await stat3(blobPath(blobs, hash)).catch(() => null))?.size ?? 0);
+  return sizes;
+}
+async function reclaimOne(home, dryRun) {
+  const log = readLog(join9(home, "log.jsonl"), () => {
+  });
+  if (!log) return 0;
+  const blobs = join9(home, "blobs");
+  const sizes = await blobSizes(blobs, namedHashes(log));
+  let bytes = 0;
+  for (const hash of uncopiedOnlyHashes(log, (known) => sizes.get(known) ?? 0)) {
+    const size = sizes.get(hash) ?? 0;
+    if (size === 0) continue;
+    bytes += size;
+    if (!dryRun) await rm4(blobPath(blobs, hash), { force: true });
+  }
+  return bytes;
+}
+async function reclaimUncopiedBlobs(historyRoot, { dryRun = false, onError } = {}) {
+  const reclaimed = [];
+  for (const id of historyIds(historyRoot)) {
+    const home = join9(historyRoot, id);
+    let release;
+    try {
+      release = await takeHistoryOwnership(home, 0);
+      const bytes = await reclaimOne(home, dryRun);
+      if (bytes > 0) reclaimed.push({ id, bytes });
+    } catch (error) {
+      if (!(error instanceof HistoryBusyError)) onError?.(error);
+    } finally {
+      release?.();
+    }
+  }
+  return reclaimed;
+}
 function historyCache(open) {
   const histories = /* @__PURE__ */ new Map();
   const get = async (projectDir) => {
@@ -2547,5 +2666,6 @@ export {
   HistoryClosedError,
   openProjectHistory,
   readProjectHistory,
+  reclaimUncopiedBlobs,
   historyCache
 };

package/dist/{chunk-UZ7RJDEC.js → chunk-5IPKQHOL.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-HVW7ABXD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-AYFF3GX6.js";
+} from "./chunk-32NB4VMH.js";
 
 // src/utils/projectConfig.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -43,7 +43,10 @@ function readProjectConfigWithStatus(projectDir) {
     return { status: isFileNotFound(error) ? "missing" : "unreadable" };
   }
   try {
-    return { status: "ok", config: normalizeConfig(JSON.parse(text)) };
+    return {
+      status: "ok",
+      config: normalizeConfig(JSON.parse(text.replace(/^\uFEFF/, "")))
+    };
   } catch {
     return { status: "unreadable" };
   }
@@ -118,12 +121,16 @@ function seedProjectAuthoringSkill(projectDir, rawSkill) {
     return;
   }
   try {
-    const parsed = JSON.parse(text);
+    const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
     if (!isJsonObject(parsed)) return;
     if (normalizeSkillSlug(parsed.authoringSkill)) return;
     parsed.authoringSkill = skill;
     const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
-    writeFileSync(path, JSON.stringify(parsed, null, indent) + "\n", "utf-8");
+    writeFileSync(
+      path,
+      (text.startsWith("\uFEFF") ? "\uFEFF" : "") + JSON.stringify(parsed, null, indent) + "\n",
+      "utf-8"
+    );
   } catch {
   }
 }
@@ -137,7 +144,7 @@ function recordProjectRegistryItems(projectDir, items) {
     return;
   }
   try {
-    const parsed = JSON.parse(text);
+    const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
     if (!isJsonObject(parsed)) return;
     const existing = normalizeRegistryItems(parsed.registryItems) ?? [];
     const byName = new Map(existing.map((item) => [item.name, item]));
@@ -150,7 +157,11 @@ function recordProjectRegistryItems(projectDir, items) {
     if (unchanged) return;
     parsed.registryItems = merged;
     const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
-    writeFileSync(path, JSON.stringify(parsed, null, indent) + "\n", "utf-8");
+    writeFileSync(
+      path,
+      (text.startsWith("\uFEFF") ? "\uFEFF" : "") + JSON.stringify(parsed, null, indent) + "\n",
+      "utf-8"
+    );
   } catch {
   }
 }

package/dist/{chunk-WBUO6WH6.js → chunk-5TRFLZ5Z.js}

@@ -19,10 +19,10 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-56IOFIYB.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   extractCompositionMetadata
-} from "./chunk-B2A56S5C.js";
+} from "./chunk-2MCXIY4B.js";
 
 // src/utils/variables.ts
 import { readFileSync } from "fs";

package/dist/{chunk-HRPWRZGF.js → chunk-6N65ZMC5.js}

@@ -9,7 +9,7 @@ import {
   buildAuthHeaders,
   refreshTokens,
   resolveCredential
-} from "./chunk-7KVVNF7B.js";
+} from "./chunk-ELP5QZWL.js";
 
 // src/cloud/auth.ts
 async function resolveCloudAuthHeaders() {

package/dist/{chunk-XUXGIA7H.js → chunk-6NLPPKBO.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   normalizeErrorMessage
-} from "./chunk-KNU5COPB.js";
+} from "./chunk-T2EUWCJE.js";
 
 // src/telemetry/posthogKey.ts
 var POSTHOG_API_KEY = "phc_zjjbX0PnWxERXrMHhkEJWj9A9BhGVLRReICgsfTMmpx";
@@ -305,7 +305,6 @@ function passthroughFields(parsed) {
     skillsUpdateAvailable: parsed.skillsUpdateAvailable,
     skillsOutdatedCount: parsed.skillsOutdatedCount,
     skillsMissingCount: parsed.skillsMissingCount,
-    skillsRemovedCount: parsed.skillsRemovedCount,
     localEmbeddingEnabled: consentFrom(parsed.localEmbeddingEnabled)
   };
 }

package/dist/{chunk-3QLT727N.js → chunk-6WNLQI63.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-OOAVKK2W.js";
+} from "./chunk-BV6YE455.js";
 import {
   shouldTrack
-} from "./chunk-TTZTGXKG.js";
+} from "./chunk-GANST5K3.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -20,7 +20,7 @@ import {
 import {
   readConfig,
   writeConfig
-} from "./chunk-XUXGIA7H.js";
+} from "./chunk-6NLPPKBO.js";
 
 // src/telemetry/feedback.ts
 import * as readline from "readline";
@@ -84,7 +84,7 @@ async function getDoctorSummary() {
   try {
     const [{ getSystemMeta }, { findFFmpeg }] = await Promise.all([
       import("./system-7F3UEHQT.js"),
-      import("./ffmpeg-KU7RNT3U.js")
+      import("./ffmpeg-3VHY7GO3.js")
     ]);
     const sys = getSystemMeta();
     const parts = [

package/dist/{chunk-XNLYMHX2.js → chunk-6XVKMBUA.js}

@@ -10,7 +10,7 @@ import {
 import {
   DISTRIBUTED_FPS,
   isDistributedFps
-} from "./chunk-56IOFIYB.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";
@@ -18,6 +18,9 @@ import {
 // src/utils/compositionFps.ts
 import { readFileSync } from "fs";
 import { join } from "path";
+function getHtmlAttribute(element, name) {
+  return Array.from(element.attributes).find((attribute) => attribute.name.toLowerCase() === name)?.value ?? null;
+}
 function readCompositionFps(html) {
   let doc;
   try {
@@ -25,11 +28,11 @@ function readCompositionFps(html) {
   } catch {
     return null;
   }
-  const explicitRoot = doc.querySelector('[data-composition-id][data-root="true"]');
-  const root = explicitRoot ?? Array.from(doc.querySelectorAll("[data-composition-id]")).find(
-    (el) => !el.parentElement?.closest("[data-composition-id]")
-  ) ?? null;
-  const raw = root?.getAttribute("data-fps")?.trim();
+  const compositions = Array.from(doc.querySelectorAll("*")).filter(
+    (element) => getHtmlAttribute(element, "data-composition-id") !== null
+  );
+  const root = compositions.find((element) => getHtmlAttribute(element, "data-root") === "true") ?? compositions[0];
+  const raw = root ? getHtmlAttribute(root, "data-fps")?.trim() : void 0;
   return raw ? raw : null;
 }
 var DEFAULT_CLOUD_FPS = 30;

package/dist/{chunk-JLSXXMRU.js → chunk-7JJMT6LN.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   sherpaParakeetInstalled,
   sherpaUnsupportedReason
-} from "./chunk-FUHI34T4.js";
+} from "./chunk-VOM2HLUI.js";
 import {
   findParakeet
 } from "./chunk-JZIEZCQM.js";

package/dist/{chunk-7JHTNUF2.js → chunk-7LLRMYP6.js}

@@ -6,14 +6,14 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveProject
-} from "./chunk-OTQXYTQZ.js";
+} from "./chunk-4E75LHAL.js";
 import {
   DEFAULT_HISTORY_ROOT,
   HistoryBusyError,
   MAX_WINDOW_IDLE_MS,
   openProjectHistory,
   readProjectHistory
-} from "./chunk-TMBUBLZB.js";
+} from "./chunk-4HCJOFMB.js";
 import {
   findPreviewServerForProject,
   studioApiUrl

package/dist/{chunk-BT64TTSE.js → chunk-7RSY7SZN.js}

@@ -13,11 +13,11 @@ import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-56IOFIYB.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   decodeAuthoredAttribute,
   scanHtmlOpeningTags
-} from "./chunk-B2A56S5C.js";
+} from "./chunk-2MCXIY4B.js";
 import {
   mkdirWithinProject,
   realProjectRoot,

package/dist/{chunk-DX7VEUBO.js → chunk-7UZC4N62.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-W6Y5ZYRQ.js");
+  return await import("./src-DCD3YMXX.js");
 }
 
 export {

package/dist/{chunk-YT5VLUHM.js → chunk-A4OI5ZNX.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-PV3CDO4A.js");
+        const { trackCommandFailure } = await import("./events-V2VU4J3B.js");
         trackCommandFailure(
           command,
           err,