hyperframes 0.8.107 → 0.8.109

package/dist/{normalize-audio-J2PG6YXH.js → chunk-5ON5GH3X.js}

@@ -4,64 +4,21 @@ 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 {
-  resolveProject
-} from "./chunk-I73Z6OOE.js";
-import "./chunk-IHFUKJOR.js";
-import "./chunk-TPPIERG3.js";
-import "./chunk-3CYAZWF2.js";
-import "./chunk-VWG7OQKU.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
-import "./chunk-C3KEF3UA.js";
-import "./chunk-AMKC3AXA.js";
-import {
-  defineCommand
-} from "./chunk-S3S4TGEH.js";
-import "./chunk-54HJ63Q2.js";
-import {
-  failCommand
-} from "./chunk-PBN6GBJE.js";
-import "./chunk-D5EJCP26.js";
-import "./chunk-VMDEGITC.js";
-import "./chunk-UUDQD62L.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-R4IB642V.js";
 import {
   MAX_AUDIO_GAIN_DB,
-  formatAudioGain
-} from "./chunk-PMLZPNIB.js";
-import "./chunk-VC76R6W2.js";
-import "./chunk-OFQWTKPW.js";
-import "./chunk-TWWSYAKJ.js";
-import "./chunk-QM2NUN2B.js";
-import "./chunk-HBBJFK6I.js";
+  formatAudioGain,
+  isAudibleVideoElement
+} from "./chunk-YLVI7VL5.js";
 import {
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
-import "./chunk-TQFG7HTI.js";
-import "./chunk-GK4AIFIH.js";
-import "./chunk-2PSPARWP.js";
-import "./chunk-K4WIOZFP.js";
-import "./chunk-XUXGIA7H.js";
-import "./chunk-WERLJGIC.js";
-import "./chunk-ISN5GRYI.js";
-import "./chunk-OGTR33KN.js";
-import "./chunk-KNU5COPB.js";
-import "./chunk-3GXQPCJC.js";
-import "./chunk-RQVDTPGD.js";
-import "./chunk-PMRBLBUP.js";
-import "./chunk-M2WBOQ2Q.js";
 
-// src/commands/normalize-audio.ts
+// ../studio-server/dist/chunk-TEYDBVSK.js
 import { execFile } from "child_process";
-import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { isAbsolute, relative, resolve } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var FFMPEG_TIMEOUT_MS = 12e4;
-var DEFAULT_TOLERANCE_LU = 0.5;
 function authoredNumber(raw, fallback, attribute, id, strictlyPositive = false) {
   if (raw === void 0) return fallback;
   const value = Number(raw);
@@ -121,14 +78,28 @@ function commentEnd(html, start) {
   if (end < 0) throw new Error("Unterminated HTML comment");
   return end + 3;
 }
+var isSpaceAt = (html, index) => /\s/.test(html.charAt(index));
+var isWordAt = (html, index) => /\w/.test(html.charAt(index));
+function skipSpaces(html, index) {
+  let cursor = index;
+  while (cursor < html.length && isSpaceAt(html, cursor)) cursor++;
+  return cursor;
+}
 function parsedStartTag(html, start) {
-  const match = html.slice(start).match(/^<\s*(\/?)\s*([a-z][a-z\d:-]*)\b/i);
-  if (!match) return null;
+  let cursor = skipSpaces(html, start + 1);
+  const closing = html.charAt(cursor) === "/";
+  if (closing) cursor = skipSpaces(html, cursor + 1);
+  const nameStart = cursor;
+  if (!/[a-z]/i.test(html.charAt(cursor))) return null;
+  while (/[a-z\d:-]/i.test(html.charAt(cursor + 1))) cursor++;
+  let nameEnd = cursor + 1;
+  while (nameEnd > nameStart && isWordAt(html, nameEnd - 1) === isWordAt(html, nameEnd)) nameEnd--;
+  if (nameEnd === nameStart) return null;
   return {
     start,
     end: startTagEnd(html, start),
-    closing: match[1] === "/",
-    name: match[2]?.toLowerCase() ?? ""
+    closing,
+    name: html.slice(nameStart, nameEnd).toLowerCase()
   };
 }
 function rawTextElementEnd(html, lower, tag) {
@@ -139,20 +110,26 @@ function rawTextElementEnd(html, lower, tag) {
 }
 function scanMarkup(html, lower, start) {
   if (html.startsWith("<!--", start)) {
-    return { cursor: commentEnd(html, start), audioRange: null };
+    return { cursor: commentEnd(html, start), mediaRange: null };
   }
   const tag = parsedStartTag(html, start);
   if (!tag) {
     const marker = html[start + 1];
     const cursor = marker === "!" || marker === "?" ? startTagEnd(html, start) : start + 1;
-    return { cursor, audioRange: null };
+    return { cursor, mediaRange: null };
   }
   const rawTextEnd = rawTextElementEnd(html, lower, tag);
-  if (rawTextEnd !== null) return { cursor: rawTextEnd, audioRange: null };
-  const audioRange = !tag.closing && tag.name === "audio" ? { start, end: tag.end } : null;
-  return { cursor: tag.end, audioRange };
+  if (rawTextEnd !== null) return { cursor: rawTextEnd, mediaRange: null };
+  return { cursor: tag.end, mediaRange: mediaRangeOf(tag) };
 }
-function audioTagRanges(html) {
+function mediaRangeOf(tag) {
+  if (tag.closing) return null;
+  if (tag.name === "audio" || tag.name === "video") {
+    return { start: tag.start, end: tag.end, name: tag.name };
+  }
+  return null;
+}
+function mediaTagRanges(html) {
   const lower = html.toLowerCase();
   const ranges = [];
   let cursor = 0;
@@ -160,7 +137,7 @@ function audioTagRanges(html) {
     const start = html.indexOf("<", cursor);
     if (start < 0) break;
     const scanned = scanMarkup(html, lower, start);
-    if (scanned.audioRange) ranges.push(scanned.audioRange);
+    if (scanned.mediaRange) ranges.push(scanned.mediaRange);
     cursor = scanned.cursor;
   }
   return ranges;
@@ -184,11 +161,27 @@ function requiredAudioIdentity(attributes) {
   if (!src) throw new Error(`Audio #${id} has no src`);
   return { id, src };
 }
-function audioTagFromRange(html, range) {
+function hasBareAttribute(html, range, name) {
+  const unquoted = html.slice(range.start, range.end).replace(/"[^"]*"|'[^']*'/g, '""');
+  return new RegExp(`\\s${name}(?=[\\s/>=])`, "i").test(unquoted);
+}
+function isAudibleVideoTag(html, range, attributes) {
+  return isAudibleVideoElement({
+    tagName: "video",
+    hasAttribute: (name) => attributes.has(name) || hasBareAttribute(html, range, name),
+    getAttribute: (name) => attributes.get(name)?.value ?? null
+  });
+}
+function inScopeVideo(html, range, attributes) {
+  return isAudibleVideoTag(html, range, attributes) && trimmedAttribute(attributes, "id") !== "" && trimmedAttribute(attributes, "src") !== "";
+}
+function mediaTagFromRange(html, range) {
   const attributes = attributesInTag(html, range.start, range.end);
+  if (range.name === "video" && !inScopeVideo(html, range, attributes)) return null;
   const { id, src } = requiredAudioIdentity(attributes);
   const volumeAttribute = attributes.get("data-volume") ?? null;
   return {
+    tag: range.name,
     id,
     src,
     volume: authoredNumber(volumeAttribute?.value, 1, "data-volume", id),
@@ -199,6 +192,13 @@ function audioTagFromRange(html, range) {
       id
     ),
     duration: authoredDuration(attributes, id),
+    playbackRate: authoredNumber(
+      attributes.get("data-playback-rate")?.value,
+      1,
+      "data-playback-rate",
+      id,
+      true
+    ),
     start: range.start,
     end: range.end,
     volumeAttribute
@@ -207,8 +207,9 @@ function audioTagFromRange(html, range) {
 function audioTags(html) {
   const seen = /* @__PURE__ */ new Set();
   const tags = [];
-  for (const range of audioTagRanges(html)) {
-    const tag = audioTagFromRange(html, range);
+  for (const range of mediaTagRanges(html)) {
+    const tag = mediaTagFromRange(html, range);
+    if (!tag) continue;
     if (seen.has(tag.id)) throw new Error(`Duplicate audio id "${tag.id}"`);
     seen.add(tag.id);
     tags.push(tag);
@@ -305,7 +306,8 @@ function updateAudioVolume(html, id, volume) {
 function loudnessMeasureArgs(file, tag) {
   const args = ["-hide_banner", "-nostats"];
   if (tag.mediaStart > 0) args.push("-ss", String(tag.mediaStart));
-  if (tag.duration !== null && tag.duration > 0) args.push("-t", String(tag.duration));
+  const sourceSpan = tag.duration === null ? null : tag.duration * (tag.playbackRate ?? 1);
+  if (sourceSpan !== null && sourceSpan > 0) args.push("-t", String(sourceSpan));
   args.push("-i", file, "-map", "0:a:0", "-vn", "-af", "ebur128=peak=true", "-f", "null", "-");
   return args;
 }
@@ -317,162 +319,52 @@ async function measureAudio(ffmpegPath, file, tag) {
   });
   return parseEbur128Summary(result.stderr);
 }
-function fail(message, json, cause) {
-  if (json) console.log(JSON.stringify({ ok: false, error: message }, null, 2));
-  else console.error(c.error(message));
-  failCommand(1, cause);
-}
-function byId(tags, rawId, role) {
-  const id = rawId.trim().replace(/^#/, "");
-  const tag = tags.find((candidate) => candidate.id === id);
-  if (!tag) throw new Error(`${role} audio #${id} was not found`);
-  return tag;
-}
-function selectedTags(html, referenceId, targetId) {
-  const tags = audioTags(html);
-  const referenceTag = byId(tags, referenceId, "Reference");
-  const targetTag = byId(tags, targetId, "Target");
-  if (referenceTag.id === targetTag.id) {
-    throw new Error("Reference and target must be different audio elements");
-  }
-  return { referenceTag, targetTag };
-}
 function requiredFfmpeg() {
   const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
   if (!ffmpegPath) throw new Error("FFmpeg is required to measure integrated loudness");
   return ffmpegPath;
 }
-function existingAudioFile(projectDir, tag) {
-  const file = resolveLocalAudioPath(projectDir, tag.src);
-  if (!existsSync(file)) {
-    throw new Error(`Audio #${tag.id} file was not found: ${relative(projectDir, file)}`);
-  }
-  return file;
-}
-async function measuredPlan(projectDir, referenceTag, targetTag) {
-  const ffmpegPath = requiredFfmpeg();
-  const referenceFile = existingAudioFile(projectDir, referenceTag);
-  const targetFile = existingAudioFile(projectDir, targetTag);
-  const [referenceMeasurement, targetMeasurement] = await Promise.all([
-    measureAudio(ffmpegPath, referenceFile, referenceTag),
-    measureAudio(ffmpegPath, targetFile, targetTag)
-  ]);
-  return audioNormalizationPlan(
-    { id: referenceTag.id, volume: referenceTag.volume, ...referenceMeasurement },
-    { id: targetTag.id, volume: targetTag.volume, ...targetMeasurement }
-  );
-}
-function writeAtomically(path, contents) {
-  const temporary = `${path}.hf-normalize-${process.pid}.tmp`;
-  writeFileSync(temporary, contents);
-  renameSync(temporary, path);
-}
-function parsedTolerance(raw) {
-  const tolerance = Number(raw);
-  if (!Number.isFinite(tolerance) || tolerance < 0) {
-    throw new Error("--tolerance must be a non-negative number");
-  }
-  return tolerance;
-}
-async function normalizeAudio(options) {
-  const project = resolveProject(options.dir);
-  const html = readFileSync(project.indexPath, "utf8");
-  const { referenceTag, targetTag } = selectedTags(html, options.reference, options.target);
-  const tolerance = parsedTolerance(options.tolerance);
-  const plan = await measuredPlan(project.dir, referenceTag, targetTag);
-  const withinTolerance = Math.abs(plan.referenceLufs - plan.targetLufs) <= tolerance;
-  const wrote = options.write && !withinTolerance;
-  if (wrote) {
-    writeAtomically(
-      project.indexPath,
-      updateAudioVolume(readFileSync(project.indexPath, "utf8"), targetTag.id, plan.volume)
-    );
+var DEFAULT_TARGET_LUFS = -16;
+var NORMALIZE_TRUE_PEAK_CEILING_DBFS = -1.5;
+var SILENCE_LUFS = -70;
+function absoluteLoudnessPlan(track, targetLufs = DEFAULT_TARGET_LUFS) {
+  if (track.integratedLufs <= SILENCE_LUFS) {
+    throw new Error(`#${track.id} is silent in the played window; there is nothing to normalize`);
   }
-  return { ok: true, wrote, withinTolerance, tolerance, indexPath: project.indexPath, ...plan };
-}
-function printHumanResult(result) {
-  console.log(
-    `${c.bold(`#${result.referenceId}`)} ${result.referenceLufs.toFixed(1)} LUFS \u2192 ${c.bold(`#${result.targetId}`)} ${result.targetLufs.toFixed(1)} LUFS`
-  );
-  if (result.withinTolerance) {
-    console.log(
-      c.success(`Already matched within ${result.tolerance.toFixed(1)} LU; no change needed.`)
-    );
-    return;
-  }
-  console.log(
-    `Set #${result.targetId} data-volume ${result.previousVolume.toFixed(3)} \u2192 ${result.volume.toFixed(6)} (${result.changeDb >= 0 ? "+" : ""}${result.changeDb.toFixed(1)} dB).`
-  );
-  console.log(
-    result.wrote ? c.success(`Updated ${relative(process.cwd(), result.indexPath) || "index.html"}.`) : c.dim("Dry run only. Pass --write to persist this gain.")
+  const wantedGainDb = targetLufs - track.integratedLufs;
+  const peakRoomDb = NORMALIZE_TRUE_PEAK_CEILING_DBFS - track.truePeakDbfs;
+  const limits = [
+    [null, wantedGainDb],
+    ["gain-ceiling", MAX_AUDIO_GAIN_DB],
+    ["true-peak", peakRoomDb]
+  ];
+  const [limitedBy, appliedGainDb] = limits.reduce(
+    (lowest, candidate) => candidate[1] < lowest[1] - 1e-9 ? candidate : lowest
   );
+  const previousGainDb = track.volume > 0 ? gainDb(track.volume) : 0;
+  return {
+    targetId: track.id,
+    targetLufs,
+    sourceLufs: track.integratedLufs,
+    previousVolume: track.volume,
+    volume: 10 ** (appliedGainDb / 20),
+    gainDb: appliedGainDb,
+    changeDb: appliedGainDb - previousGainDb,
+    projectedLufs: track.integratedLufs + appliedGainDb,
+    projectedTruePeakDbfs: track.truePeakDbfs + appliedGainDb,
+    limitedBy
+  };
 }
-var examples = [
-  [
-    "Measure two authored clips and preview the matching gain",
-    "hyperframes normalize-audio --reference target-audio --target user-audio"
-  ],
-  [
-    "Persist the measured gain into index.html",
-    "hyperframes normalize-audio --reference target-audio --target user-audio --write"
-  ]
-];
-var normalize_audio_default = defineCommand({
-  meta: {
-    name: "normalize-audio",
-    description: "Match one local audio clip to another using integrated LUFS"
-  },
-  args: {
-    dir: { type: "positional", description: "Project directory", required: false },
-    reference: {
-      type: "string",
-      description: "Audio element id whose effective loudness should be preserved",
-      required: true
-    },
-    target: {
-      type: "string",
-      description: "Audio element id whose data-volume should be matched",
-      required: true
-    },
-    write: {
-      type: "boolean",
-      description: "Persist the measured target gain into index.html",
-      default: false
-    },
-    tolerance: {
-      type: "string",
-      description: `Skip writes within this many LU (default ${DEFAULT_TOLERANCE_LU})`,
-      default: String(DEFAULT_TOLERANCE_LU)
-    },
-    json: { type: "boolean", description: "Print machine-readable output", default: false }
-  },
-  async run({ args }) {
-    try {
-      const result = await normalizeAudio({
-        dir: args.dir,
-        reference: args.reference,
-        target: args.target,
-        tolerance: args.tolerance,
-        write: args.write
-      });
-      if (args.json) {
-        const { indexPath: _, ...jsonResult } = result;
-        console.log(JSON.stringify(jsonResult, null, 2));
-        return;
-      }
-      printHumanResult(result);
-    } catch (error) {
-      fail(error instanceof Error ? error.message : String(error), Boolean(args.json), error);
-    }
-  }
-});
+
 export {
-  audioNormalizationPlan,
   audioTags,
-  normalize_audio_default as default,
-  examples,
-  loudnessMeasureArgs,
-  parseEbur128Summary,
   resolveLocalAudioPath,
-  updateAudioVolume
+  parseEbur128Summary,
+  audioNormalizationPlan,
+  updateAudioVolume,
+  loudnessMeasureArgs,
+  measureAudio,
+  requiredFfmpeg,
+  DEFAULT_TARGET_LUFS,
+  absoluteLoudnessPlan
 };

package/dist/{chunk-NHTRUAMD.js → chunk-AWUZ3AUD.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-GMECXFAN.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-VMDEGITC.js";
+} from "./chunk-B25H4M4V.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-VMDEGITC.js → chunk-B25H4M4V.js}

@@ -17,7 +17,7 @@ import {
   parseStrictFiniteTimingNumber,
   resolveNaturalMediaTimelineDuration,
   resolveTimedImageDurationSeconds
-} from "./chunk-PMLZPNIB.js";
+} from "./chunk-YLVI7VL5.js";
 import {
   COMPOSITION_ATTRIBUTES,
   parseStartExpression

package/dist/{chunk-QM2NUN2B.js → chunk-BAVM2XBR.js}

@@ -4015,7 +4015,7 @@ function isAudibleVideoTag(tagSource) {
   if (hasAttrName(tagSource, "muted")) return false;
   if (!hasAttrName(tagSource, "data-has-audio")) return true;
   const declared = readAttr(tagSource, "data-has-audio");
-  return declared !== null && declared.trim().toLowerCase() !== "false";
+  return declared === "true";
 }
 function mediaTimeWindow(tagSource) {
   const start = Number(readAttr(tagSource, "data-start"));
@@ -5245,6 +5245,89 @@ function cssErrorOffset(source, error) {
   }
   return currentLine === line ? offset + column - 1 : void 0;
 }
+var SYNC_TOLERANCE_S = 1e-3;
+var LINKED_TIMING_FIELDS = [
+  { field: "start", attrs: ["data-start"], fallback: 0 },
+  { field: "duration", attrs: ["data-duration"], fallback: 0 },
+  { field: "media-start", attrs: ["data-playback-start", "data-media-start"], fallback: 0 },
+  { field: "playback-rate", attrs: ["data-playback-rate"], fallback: 1 }
+];
+function readTimingField(tag, attrs, fallback) {
+  for (const attr of attrs) {
+    const raw = readAttr(tag.raw, attr);
+    if (raw === null || raw.trim() === "") continue;
+    const value = Number(raw);
+    if (Number.isFinite(value)) return value;
+  }
+  return fallback;
+}
+function driftingFields(members) {
+  return LINKED_TIMING_FIELDS.filter(({ attrs, fallback }) => {
+    const values = members.map((tag) => readTimingField(tag, attrs, fallback));
+    const first = values[0] ?? fallback;
+    return values.some((value) => Math.abs(value - first) > SYNC_TOLERANCE_S);
+  }).map(({ field }) => field);
+}
+function compositionScopeOf(tag, compositions) {
+  let scope = -1;
+  for (const composition of compositions) {
+    const end = composition.endIndex ?? composition.closeIndex ?? Number.POSITIVE_INFINITY;
+    const encloses = composition.index < tag.index && tag.index < end;
+    if (composition !== tag && encloses && composition.index > scope) scope = composition.index;
+  }
+  return scope;
+}
+function groupByLink(tags) {
+  const compositions = tags.filter(
+    (tag) => ["data-composition-id", "data-composition-file"].some(
+      (name) => readAttr(tag.raw, name) !== null
+    )
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const link = readAttr(tag.raw, "data-link");
+    if (!link) continue;
+    const key = `${compositionScopeOf(tag, compositions)}\0${link}`;
+    const group = groups.get(key) ?? { link, members: [] };
+    group.members.push(tag);
+    groups.set(key, group);
+  }
+  return groups;
+}
+var memberLabel = (tag) => {
+  const id = readAttr(tag.raw, "id");
+  return id ? `#${id}` : `<${tag.name}>`;
+};
+function findLinkedClipFindings(ctx) {
+  const findings = [];
+  for (const { link, members } of groupByLink(ctx.tags).values()) {
+    const first = members[0];
+    if (!first) continue;
+    const elementId = readAttr(first.raw, "id") || void 0;
+    if (members.length === 1) {
+      findings.push({
+        code: "linked_clip_orphan",
+        severity: "warning",
+        message: `${memberLabel(first)} is the only clip with data-link="${link}"; its linked partner is gone.`,
+        elementId,
+        fixHint: `Remove data-link="${link}" from ${memberLabel(first)}, or restore the partner clip.`,
+        snippet: truncateSnippet(first.raw)
+      });
+      continue;
+    }
+    const drift = driftingFields(members);
+    if (drift.length === 0) continue;
+    findings.push({
+      code: "linked_clips_out_of_sync",
+      severity: "warning",
+      message: `Linked clips ${members.map(memberLabel).join(", ")} (data-link="${link}") differ in ${drift.join(", ")}.`,
+      elementId,
+      fixHint: "Linked clips are edited as one: give every member the same data-start, data-duration, data-media-start and data-playback-rate, or remove data-link from all of them to unlink.",
+      snippet: truncateSnippet(first.raw)
+    });
+  }
+  return findings;
+}
 function tweensVolumeInSameCall(script, id) {
   const selector = new RegExp(`#${escapeRegExp(id)}(?![\\w-])`, "g");
   for (let hit = selector.exec(script); hit; hit = selector.exec(script)) {
@@ -5943,7 +6026,8 @@ var mediaRules = [
   // audio_group_timing_attrs
   findAudioGroupTimingAttrFindings,
   // audio_group_carve_attr
-  findAudioGroupCarveAttrFindings
+  findAudioGroupCarveAttrFindings,
+  findLinkedClipFindings
 ];
 function findVolumeTweenOverridesGainFindings(ctx) {
   const boosted = ctx.tags.filter((tag) => isMediaTag(tag.name)).map((tag) => ({ tag, volume: Number(readAttr(tag.raw, "data-volume") ?? "1") })).filter((entry) => Number.isFinite(entry.volume) && entry.volume !== 1).filter((entry) => !readDecodedAttr(entry.tag.raw, "data-automation")).map((entry) => ({ ...entry, id: readAttr(entry.tag.raw, "id") })).filter((entry) => Boolean(entry.id));
@@ -6032,7 +6116,7 @@ function findCarveUngroupedSourcesFindings(ctx) {
 var AUDIO_GROUP_TIMING_ATTRS = ["data-start", "data-duration", "data-track-index"];
 function findAudioGroupNoMembersFindings(ctx) {
   const memberGroupIds = new Set(
-    ctx.tags.filter((tag) => tag.name === "audio").map((tag) => readAttr(tag.raw, "data-audio-group")).filter((id) => Boolean(id))
+    ctx.tags.filter((tag) => tag.name === "audio" || tag.name === "video" && isAudibleVideoTag(tag.raw)).map((tag) => readAttr(tag.raw, "data-audio-group")).filter((id) => Boolean(id))
   );
   if (memberGroupIds.size === 0) return [];
   const mayHaveCrossFileMembers = ctx.tags.some(

package/dist/{chunk-4W4UDPCH.js → chunk-C4TZBEHY.js}

@@ -16,7 +16,7 @@ import {
 import {
   DEFAULT_VP9_CPU_USED,
   renderProvenanceArgs
-} from "./chunk-D5EJCP26.js";
+} from "./chunk-OF3RKOPU.js";
 import {
   loadOptionalPackage
 } from "./chunk-XT5P4QMO.js";
@@ -202,7 +202,7 @@ function inferInputKind(inputPath) {
 }
 async function probeMedia(inputPath) {
   const isImage = inferInputKind(inputPath) === "image";
-  const engine = await import("./src-SV7CNZXN.js");
+  const engine = await import("./src-GD7RGV5U.js");
   const meta = await engine.extractMediaMetadata(inputPath);
   if (isImage) {
     return { width: meta.width, height: meta.height, fps: 0, frameCount: 1 };

package/dist/{chunk-FLUBCMNT.js → chunk-CFC3EEDQ.js}

@@ -19,7 +19,7 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-VMDEGITC.js";
+} from "./chunk-B25H4M4V.js";
 import {
   extractCompositionMetadata
 } from "./chunk-UUDQD62L.js";

package/dist/{chunk-3CYAZWF2.js → chunk-CPO5INJ5.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-ZTZA4UWZ.js";
 import {
   getSystemMeta
-} from "./chunk-C3KEF3UA.js";
+} from "./chunk-CQRF7VU3.js";
 import {
   getInvocationId
 } from "./chunk-54HJ63Q2.js";
@@ -23,7 +23,7 @@ import {
   evaluateCanary,
   findCanary,
   parseCanaryOverride
-} from "./chunk-VMDEGITC.js";
+} from "./chunk-B25H4M4V.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";
@@ -37,7 +37,7 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-OGTR33KN.js";
+} from "./chunk-3T4RQK6C.js";
 
 // src/telemetry/transport.ts
 import { spawn } from "child_process";

package/dist/{chunk-C3KEF3UA.js → chunk-CQRF7VU3.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-AMKC3AXA.js";
 import {
   getSystemTotalMb
-} from "./chunk-D5EJCP26.js";
+} from "./chunk-OF3RKOPU.js";
 
 // src/telemetry/system.ts
 import { cpus, freemem, platform as platform2, release as release2 } from "os";

package/dist/{chunk-6QWHIARJ.js → chunk-E4AYSXMS.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-TVCRUG2S.js";
 import {
   getFreeDiskMb
-} from "./chunk-C3KEF3UA.js";
+} from "./chunk-CQRF7VU3.js";
 import {
   ensureBrowser,
   findBrowser

package/dist/{chunk-BRTGJ73L.js → chunk-HQGJLZB6.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-NHTRUAMD.js";
+} from "./chunk-AWUZ3AUD.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-VMDEGITC.js";
+} from "./chunk-B25H4M4V.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-HJCTKNXF.js → chunk-I5WWEBDG.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-TVCRUG2S.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-3LBFLW7E.js";
+} from "./chunk-JTTAS7N6.js";
 
 // src/whisper/transcribe.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-GLTHJJIF.js → chunk-ITBEN3QD.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   getMimeType
-} from "./chunk-4DJXCVQJ.js";
+} from "./chunk-MR2LOG32.js";
 import {
   injectTagsAtHeadStart
-} from "./chunk-PMLZPNIB.js";
+} from "./chunk-YLVI7VL5.js";
 
 // src/utils/compositionServer.ts
 import { createHash } from "crypto";

package/dist/{chunk-3LBFLW7E.js → chunk-JTTAS7N6.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   setHostHandlesSigint
-} from "./chunk-D5EJCP26.js";
+} from "./chunk-OF3RKOPU.js";
 import {
   processAncestorSnapshot,
   processIdentity,