hyperframes 0.8.106 → 0.8.108

package/dist/{normalize-audio-H3SI5V63.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-FTXU3TQ4.js";
-import "./chunk-IHFUKJOR.js";
-import "./chunk-2LCIQS3K.js";
-import "./chunk-LAHK4P7Q.js";
-import "./chunk-VWG7OQKU.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
-import "./chunk-PUB5XZYL.js";
-import "./chunk-AMKC3AXA.js";
-import {
-  defineCommand
-} from "./chunk-S3S4TGEH.js";
-import "./chunk-54HJ63Q2.js";
-import {
-  failCommand
-} from "./chunk-PBN6GBJE.js";
-import "./chunk-VW5OMJNG.js";
-import "./chunk-TEXPOC5V.js";
-import "./chunk-TLYU5625.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-TH4APNRP.js";
 import {
   MAX_AUDIO_GAIN_DB,
-  formatAudioGain
-} from "./chunk-FOKUJKBN.js";
-import "./chunk-VC76R6W2.js";
-import "./chunk-OFQWTKPW.js";
-import "./chunk-TWWSYAKJ.js";
-import "./chunk-UVUAU3CH.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-6LPWMCPY.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-NRMYDPFQ.js → chunk-5R5UHSXN.js}

@@ -8,13 +8,13 @@ import {
   installPageFunctionGuard,
   resolveCliChromeGpuMode,
   seekCompositionTimeline
-} from "./chunk-XZSH5GS7.js";
+} from "./chunk-RSL3XFMO.js";
 import {
   resolveCompositionViewportFromHtml
 } from "./chunk-5Z63TBTX.js";
 import {
   resolveProject
-} from "./chunk-FTXU3TQ4.js";
+} from "./chunk-US7SWKGC.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -28,7 +28,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-4NJZZHYT.js";
+} from "./chunk-RPMXMOFU.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -217,7 +217,7 @@ function extractCompositionErrorsFromLint(lintResult) {
 async function localizeRemoteAssets(html) {
   let dir;
   try {
-    const { loadProducer } = await import("./producer-LGG3TOUI.js");
+    const { loadProducer } = await import("./producer-RS7CB3XJ.js");
     const { localizeRemoteMediaSources, localizeRemoteImageSources, localizeRemoteFontFaces } = await loadProducer();
     dir = mkdtempSync(join(tmpdir(), "hf-validate-assets-"));
     const assetDir = dir;
@@ -238,10 +238,10 @@ async function localizeRemoteAssets(html) {
 }
 async function validateInBrowser(project, opts) {
   const projectDir = project.dir;
-  const { bundleToSingleHtml } = await import("./compiler-QMEZK6CU.js");
+  const { bundleToSingleHtml } = await import("./compiler-YYOV2BJ7.js");
   const { ensureBrowser } = await import("./manager-NEVLEZK3.js");
-  const { serveStaticProjectHtml } = await import("./staticProjectServer-WBXW2CA4.js");
-  const { lintProject } = await import("./lintProject-4P4C6AN2.js");
+  const { serveStaticProjectHtml } = await import("./staticProjectServer-RXAFGDK7.js");
+  const { lintProject } = await import("./lintProject-F2OTN2IR.js");
   const lintResult = await lintProject(projectDir);
   const compositionErrors = extractCompositionErrorsFromLint(lintResult);
   const html = await bundleToSingleHtml(projectDir);
@@ -262,13 +262,13 @@ async function validateInBrowser(project, opts) {
   try {
     const browser = await ensureBrowser();
     const puppeteer = await import("puppeteer-core");
-    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-QX5PPANW.js");
+    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-6R4DC2YI.js");
     const requestedGpuMode = resolveCliChromeGpuMode();
     const {
       assertWebGpuAdapterAvailable,
       compositionRequiresWebGpu,
       resolveCaptureBrowserGpuMode
-    } = await import("./gpuPolicy-BQFPO7UA.js");
+    } = await import("./gpuPolicy-KSWTVU5C.js");
     const resolvedGpuMode = await resolveCaptureBrowserGpuMode(
       requestedGpuMode,
       browser.executablePath

package/dist/{chunk-OSZJCBZX.js → chunk-AFGDOKRI.js}

@@ -7,29 +7,29 @@ var __dirname = __hf_dirname(__filename);
 import {
   RegistryCompatibilityError,
   gateRegistryItemsCompatibility
-} from "./chunk-JYRPUDVZ.js";
+} from "./chunk-5N4KKGSZ.js";
 import {
   DEFAULT_PROJECT_CONFIG,
   createProjectConfig,
   loadProjectConfig,
   projectConfigPath,
   recordProjectRegistryItems
-} from "./chunk-HUHJYNST.js";
+} from "./chunk-LAQEZHOH.js";
 import {
   resolveItemWithDependencies,
   resolveItemsByTag
-} from "./chunk-USWOTTSP.js";
+} from "./chunk-XYVFPDNU.js";
 import {
   InvalidVariableValuesError,
   prepareItem,
   publishItem
-} from "./chunk-TYA65W4U.js";
+} from "./chunk-HQGJLZB6.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-6CN2QLB5.js";
+} from "./chunk-AWUZ3AUD.js";
 import {
   trackRegistryItemAdded
-} from "./chunk-2LCIQS3K.js";
+} from "./chunk-VBXJSCHR.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -41,7 +41,7 @@ import {
 } from "./chunk-PBN6GBJE.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-TEXPOC5V.js";
+} from "./chunk-B25H4M4V.js";
 import {
   isProjectRootMissing,
   realpath

package/dist/{chunk-6CN2QLB5.js → chunk-AWUZ3AUD.js}

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

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

@@ -11,13 +11,13 @@ import {
   isTextElement,
   keyframesToGsapAnimations,
   serializeGsapAnimations
-} from "./chunk-TLYU5625.js";
+} from "./chunk-UUDQD62L.js";
 import {
   isMediaElement as isMediaElement2,
   parseStrictFiniteTimingNumber,
   resolveNaturalMediaTimelineDuration,
   resolveTimedImageDurationSeconds
-} from "./chunk-FOKUJKBN.js";
+} from "./chunk-YLVI7VL5.js";
 import {
   COMPOSITION_ATTRIBUTES,
   parseStartExpression