hyperframes 0.8.191 → 0.8.193

package/dist/{chunk-TMBUBLZB.js → chunk-C4Y3ZREE.js}

@@ -21,9 +21,9 @@ import {
   mkdirWithinProject
 } from "./chunk-OFQWTKPW.js";
 
-// ../studio-server/dist/chunk-YIMSBQIO.js
+// ../studio-server/dist/chunk-JPKAFJIJ.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.`);
@@ -2327,6 +2388,18 @@ var Engine = class {
       [...this.tracked.keys()].map((path) => [path, null])
     );
     for (const [path, hash] of files) target.set(path, hash);
+    if (point === START && this.adopting.size > 0) {
+      throw new HistoryRefusedError(
+        "The project's starting copy is still being saved; try again in a moment. Nothing was changed."
+      );
+    }
+    const isProjectFile = (path) => !KEPT_HIDDEN_PATHS.has(path);
+    const keepsAny = [...target].some(([path, hash]) => hash !== null && isProjectFile(path));
+    if ([...this.tracked.keys()].some(isProjectFile) && !keepsAny) {
+      throw new HistoryRefusedError(
+        "Restoring this point would remove every file in this project, so nothing was changed."
+      );
+    }
     return this.writeAs(who, label, target, { restoredTo: point });
   }
   /** Settles, then runs `task` with its writes labelled `writeToken`. */
@@ -2386,6 +2459,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) {
@@ -2443,6 +2519,12 @@ var HistoryClosedError = class extends Error {
     this.name = "HistoryClosedError";
   }
 };
+var HistoryRefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryRefusedError";
+  }
+};
 async function openProjectHistory(options) {
   if (!existsSync3(options.projectDir))
     throw new HistoryClosedError(`${options.projectDir} is gone or now another project.`);
@@ -2490,6 +2572,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) => {
@@ -2545,7 +2682,9 @@ export {
   MAX_WINDOW_IDLE_MS,
   UNDO_MODES,
   HistoryClosedError,
+  HistoryRefusedError,
   openProjectHistory,
   readProjectHistory,
+  reclaimUncopiedBlobs,
   historyCache
 };

package/dist/{chunk-JQYJXUJW.js → chunk-C6KE4AFW.js}

@@ -10,7 +10,7 @@ import {
   hasPreservedUnknownData,
   readStore,
   writeStore
-} from "./chunk-7KVVNF7B.js";
+} from "./chunk-ELP5QZWL.js";
 
 // src/auth/user.ts
 function isUserInfoEmpty(u) {

package/dist/{chunk-TMK4Q7JA.js → chunk-CFUCHO4T.js}

@@ -11,6 +11,7 @@ import {
 // src/whisper/normalize.ts
 import { readFileSync, readdirSync, writeFileSync } from "fs";
 import { extname, join } from "path";
+import { parseExpressionAt, tokenizer } from "acorn";
 function detectFormat(filePath) {
   const ext = extname(filePath).toLowerCase();
   if (ext === ".srt") return "srt";
@@ -306,6 +307,20 @@ function loadTranscript(filePath) {
   }))).map((w, i) => ({ ...w, id: w.id || `w${i}` }));
   return { words, format };
 }
+function findCaptionArray(source, name) {
+  const prefix = `const ${name} = `;
+  const start = source.indexOf(`${prefix}[`);
+  if (start < 0) return void 0;
+  try {
+    const array = parseExpressionAt(source, start + prefix.length, { ecmaVersion: "latest" });
+    if (array.type !== "ArrayExpression") return void 0;
+    const terminator = tokenizer(source.slice(array.end), { ecmaVersion: "latest" }).getToken();
+    if (terminator.type.label !== ";") return void 0;
+    return source.slice(start, array.end + terminator.end);
+  } catch {
+    return void 0;
+  }
+}
 function patchCaptionHtml(dir, words) {
   if (words.length === 0) return;
   const wordsJson = JSON.stringify(words, null, 2).replace(/</g, "\\u003c").replace(/\n/g, "\n          ");
@@ -318,16 +333,16 @@ function patchCaptionHtml(dir, words) {
   for (const file of htmlFiles) {
     let content = readFileSync(file, "utf-8");
     const scriptBlocks = content.match(/<script>[\s\S]*?<\/script>/g) ?? [];
-    let scriptMatch = null;
-    let transcriptMatch = null;
+    let scriptMatch;
+    let transcriptMatch;
     for (const block of scriptBlocks) {
-      scriptMatch = scriptMatch ?? block.match(/const script = \[[\s\S]*?\];/);
-      transcriptMatch = transcriptMatch ?? block.match(/const TRANSCRIPT = \[[\s\S]*?\];/);
+      scriptMatch = scriptMatch ?? findCaptionArray(block, "script");
+      transcriptMatch = transcriptMatch ?? findCaptionArray(block, "TRANSCRIPT");
     }
     const match = scriptMatch ?? transcriptMatch;
     if (match) {
       const varName = scriptMatch ? "script" : "TRANSCRIPT";
-      content = content.replace(match[0], () => `const ${varName} = ${wordsJson};`);
+      content = content.replace(match, () => `const ${varName} = ${wordsJson};`);
       writeFileSync(file, content, "utf-8");
     }
   }

package/dist/{chunk-JGTRVG32.js → chunk-CGTZOY53.js}

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

package/dist/chunk-CZGHFATT.js

@@ -0,0 +1,31 @@
+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);
+
+// ../parsers/dist/compositionDuration.js
+var TIMING_TOLERANCE_SECONDS = 0.05;
+var isPositiveFinite = (value) => value !== null && Number.isFinite(value) && value > 0;
+function resolveCompositionDuration(input) {
+  const pendingClips = input.clipEndsSeconds.filter((end) => end === null).length;
+  if (isPositiveFinite(input.authoredDurationSeconds)) {
+    return { seconds: input.authoredDurationSeconds, source: "authored", pendingClips };
+  }
+  const known = input.clipEndsSeconds.filter(isPositiveFinite);
+  if (known.length > 0) {
+    return { seconds: Math.max(...known), source: "derived", pendingClips };
+  }
+  return {
+    seconds: null,
+    source: "unresolved",
+    pendingClips,
+    reason: pendingClips > 0 ? "every clip's length is still pending" : "no authored duration and no clip with a length"
+  };
+}
+
+export {
+  TIMING_TOLERANCE_SECONDS,
+  resolveCompositionDuration
+};

package/dist/{chunk-NJGTNWQY.js → chunk-D625D4TV.js}

@@ -14,33 +14,33 @@ import {
 } from "./chunk-6JR2XUEE.js";
 import {
   readCompositionFps
-} from "./chunk-7FF36MAD.js";
+} from "./chunk-VW63MHQU.js";
 import {
   HF_AUDIO_GROUP_ATTR,
   extractAudioMetadata,
   extractMediaMetadata
-} from "./chunk-NMDUSCCE.js";
+} from "./chunk-L4JB7LI4.js";
 import {
   byStart,
   fpsToNumber,
   parseFpsWithDefault
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-7HTH5PFK.js";
 import {
   HF_AUDIO_AUTOMATION_ATTR,
   HF_AUDIO_FX_ATTR,
   parseAudioFxChain,
   parseAutomation,
   resolveAutomation
-} from "./chunk-LM265QNK.js";
+} from "./chunk-USWPZXEA.js";
 import {
   isSubCompositionHost,
   topLevelElements,
   trackKindOf
-} from "./chunk-B2A56S5C.js";
+} from "./chunk-2MCXIY4B.js";
 import {
   resolveReferencedDuration,
   resolveReferencedStart
-} from "./chunk-3NRB7YXW.js";
+} from "./chunk-2VXY3PEF.js";
 import {
   resolveAuthoredAssetFile
 } from "./chunk-6BNTGNGD.js";

package/dist/{chunk-CYBXXSC4.js → chunk-DIKAPMMF.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   runCancellableProcess,
   runRenderSetupWorker
-} from "./chunk-DYAPHNV6.js";
+} from "./chunk-RWGASWT7.js";
 import {
   getFreeDiskMb
 } from "./chunk-T6AGUTZJ.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-4UMPIPCQ.js";
 import {
   normalizeErrorMessage
-} from "./chunk-KNU5COPB.js";
+} from "./chunk-T2EUWCJE.js";
 
 // src/browser/manager.ts
 import { execSync, spawnSync } from "child_process";

package/dist/{chunk-CXMXJEVY.js → chunk-DSQ72G5I.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   findCompositionDimensions
-} from "./chunk-COWQITWP.js";
+} from "./chunk-4TKJWWPL.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";

package/dist/{chunk-GLG5JWLI.js → chunk-DYNHVCBF.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   detectGpuEncoder
-} from "./chunk-NMDUSCCE.js";
+} from "./chunk-L4JB7LI4.js";
 import {
   runCancellableProcess
-} from "./chunk-DYAPHNV6.js";
+} from "./chunk-RWGASWT7.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";