@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-LTGTN2TH.js

@@ -0,0 +1,195 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  runRenderSetupWorker
+} from "./chunk-BL4U6U52.js";
+import {
+  HYPERFRAMES_BROWSER_MARKER_ARG
+} from "./chunk-K4MJX7SR.js";
+import {
+  terminateProcessTree
+} from "./chunk-KGPLIH7B.js";
+
+// src/utils/orphanCleanup.ts
+import { execFileSync } from "child_process";
+import { readFileSync } from "fs";
+function killOrphanedProcesses() {
+  if (process.env.HYPERFRAMES_NO_ORPHAN_CLEANUP === "1" || process.platform === "win32") return 0;
+  return killOrphansMatching(HYPERFRAMES_BROWSER_MARKER_ARG);
+}
+async function killOrphanedProcessesForRender(signal) {
+  return runRenderSetupWorker("orphan-cleanup", {}, { signal, timeoutMs: 15e3 });
+}
+function killProcessTree(pid, signal = "SIGTERM") {
+  void terminateProcessTree(pid, { signal }).catch(() => void 0);
+}
+function processIdentity(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  try {
+    if (process.platform === "win32") {
+      const created = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$p = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' -ErrorAction SilentlyContinue; if ($p) { $p.CreationDate.ToFileTimeUtc() }`
+        ],
+        {
+          encoding: "utf8",
+          timeout: 2e3,
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true
+        }
+      ).trim();
+      return created ? `windows:${created}` : null;
+    }
+    if (process.platform === "linux") {
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const fields = stat.slice(stat.lastIndexOf(") ") + 2).trim().split(/\s+/);
+      const startTicks = fields[19];
+      return startTicks ? `linux:${startTicks}` : null;
+    }
+    const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 2e3
+    }).trim();
+    return started ? `posix:${started}` : null;
+  } catch {
+    return null;
+  }
+}
+var holdsReusedPid = (parent, child) => parent.startedAt !== void 0 && child?.startedAt !== void 0 && parent.startedAt > child.startedAt;
+function recordsToAncestors(pid, records) {
+  const byPid = new Map(records.map((record) => [record.pid, record]));
+  const ancestors = [];
+  const visited = /* @__PURE__ */ new Set([pid]);
+  let current = pid;
+  for (let depth = 0; depth < 64; depth++) {
+    const child = byPid.get(current);
+    const parent = child?.parentPid;
+    if (parent === void 0 || parent <= 1 || visited.has(parent)) break;
+    visited.add(parent);
+    const ancestor = byPid.get(parent);
+    if (!ancestor || holdsReusedPid(ancestor, child)) break;
+    ancestors.push({ pid: ancestor.pid, identity: ancestor.identity });
+    current = parent;
+  }
+  return ancestors;
+}
+function processAncestorSnapshot(pid) {
+  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "linux") return [];
+  try {
+    if (process.platform === "win32") {
+      const output2 = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CreationDate.ToFileTimeUtc())" }'
+        ],
+        { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "ignore"], windowsHide: true }
+      );
+      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(
+        ([processId, parentProcessId, creationDate]) => ({
+          pid: Number(processId),
+          parentPid: Number(parentProcessId),
+          identity: creationDate ? `windows:${creationDate}` : "",
+          startedAt: creationDate && /^\d+$/.test(creationDate) ? BigInt(creationDate) : void 0
+        })
+      ).filter(
+        (record) => Number.isInteger(record.pid) && record.pid > 0 && Number.isInteger(record.parentPid) && record.parentPid > 0 && record.identity !== ""
+      );
+      return recordsToAncestors(pid, records2);
+    }
+    const output = execFileSync("ps", ["-axo", "pid=,ppid=,lstart="], {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    const records = output.split(/\r?\n/).map((line) => line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/)).filter((match) => match !== null).map(([, processId, parentProcessId, started]) => ({
+      pid: Number(processId),
+      parentPid: Number(parentProcessId),
+      identity: `posix:${started?.trim() ?? ""}`
+    }));
+    return recordsToAncestors(pid, records);
+  } catch {
+    return [];
+  }
+}
+function processParentPid(pid) {
+  try {
+    const output = process.platform === "win32" ? execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `$p = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' -ErrorAction SilentlyContinue; if ($p) { $p.ParentProcessId }`
+      ],
+      {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }
+    ) : execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    const parentPid = Number(output.trim());
+    return Number.isInteger(parentPid) && parentPid > 0 ? parentPid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessDescendant(childPid, ancestorPid, parentPid = processParentPid) {
+  if (childPid <= 0 || ancestorPid <= 0 || childPid === ancestorPid) return false;
+  const visited = /* @__PURE__ */ new Set();
+  let current = childPid;
+  for (let depth = 0; depth < 64; depth++) {
+    if (visited.has(current)) return false;
+    visited.add(current);
+    const parent = parentPid(current);
+    if (parent === ancestorPid) return true;
+    if (parent === null || parent <= 1) return false;
+    current = parent;
+  }
+  return false;
+}
+function killOrphansMatching(marker) {
+  const uid = process.getuid?.();
+  const owner = uid === void 0 ? ["-A"] : ["-U", String(uid)];
+  let table;
+  try {
+    table = execFileSync("ps", [...owner, "-ww", "-o", "pid=,ppid=,args="], {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+  } catch {
+    return 0;
+  }
+  let killed = 0;
+  for (const line of table.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+    if (!match || match[2] !== "1") continue;
+    if (!match[3].split(/\s+/).includes(marker)) continue;
+    killProcessTree(Number(match[1]));
+    killed++;
+  }
+  return killed;
+}
+
+export {
+  killOrphanedProcesses,
+  killOrphanedProcessesForRender,
+  killProcessTree,
+  processIdentity,
+  processAncestorSnapshot,
+  processParentPid,
+  isProcessDescendant
+};

package/vendor/framey/dist/chunk-M2WBOQ2Q.js

@@ -0,0 +1,54 @@
+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);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};

package/vendor/framey/dist/chunk-MI5FTLYK.js

@@ -0,0 +1,399 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  resolveWithinProject
+} from "./chunk-7JQFJ6JJ.js";
+import {
+  MAX_AUDIO_GAIN_DB,
+  formatAudioGain,
+  isAudibleVideoElement
+} from "./chunk-X7HBSTCZ.js";
+import {
+  decodeAuthoredAttribute
+} from "./chunk-B7RJV74O.js";
+import {
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
+import {
+  decodeWellFormedEscapes,
+  decodedUrlPath,
+  readMediaOffsetSeconds
+} from "./chunk-BSQ7XANM.js";
+
+// ../studio-server/dist/chunk-75IWAUSY.js
+import { execFile } from "child_process";
+import { isAbsolute, relative, resolve } from "path";
+import { promisify } from "util";
+import { existsSync } from "fs";
+function requestSubPath(url, route) {
+  const routeSegments = route.split("/");
+  const segments = new URL(url).pathname.split("/");
+  const start = segments.indexOf(routeSegments[0] ?? "");
+  return decodeWellFormedEscapes(segments.slice(start + routeSegments.length).join("/"));
+}
+function requestedProjectPath(projectDir, field) {
+  const trimmed = field.trim().replace(/^[.]\//, "");
+  const named = resolveWithinProject(projectDir, trimmed);
+  return named && existsSync(named) ? trimmed : decodedUrlPath(trimmed);
+}
+var execFileAsync = promisify(execFile);
+var FFMPEG_TIMEOUT_MS = 12e4;
+function authoredNumber(raw, fallback, attribute, id, strictlyPositive = false) {
+  if (raw === void 0) return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || (strictlyPositive ? value <= 0 : value < 0)) {
+    throw new Error(`Audio #${id} has an invalid ${attribute}: ${raw}`);
+  }
+  return value;
+}
+function attributeFromMatch(match, absoluteOffset) {
+  if (match.index === void 0) return null;
+  const name = match[1]?.toLowerCase();
+  const value = matchedAttributeValue(match);
+  if (!name || value === void 0) return null;
+  const whole = match[0];
+  const localValueStart = attributeValueStart(whole);
+  const valueStart = absoluteOffset + match.index + localValueStart;
+  return [
+    name,
+    {
+      value: decodeAuthoredAttribute(value),
+      valueStart,
+      valueEnd: valueStart + value.length
+    }
+  ];
+}
+function matchedAttributeValue(match) {
+  return match[2] ?? match[3] ?? match[4];
+}
+function attributeValueStart(attribute) {
+  let cursor = attribute.indexOf("=") + 1;
+  while (/\s/.test(attribute[cursor] ?? "")) cursor += 1;
+  const quote = attribute[cursor];
+  return quote === '"' || quote === "'" ? cursor + 1 : cursor;
+}
+function attributesInTag(html, from, to) {
+  const tag = html.slice(from, to);
+  const nameEnd = tag.search(/\s|\/?\s*>/);
+  const attributes = /* @__PURE__ */ new Map();
+  if (nameEnd < 0) return attributes;
+  const pattern = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
+  for (const match of tag.slice(nameEnd).matchAll(pattern)) {
+    const attribute = attributeFromMatch(match, from + nameEnd);
+    if (attribute) attributes.set(...attribute);
+  }
+  return attributes;
+}
+function startTagEnd(html, start) {
+  let quote = "";
+  let end = start + 1;
+  for (; end < html.length; end += 1) {
+    const char = html[end];
+    if (quote) {
+      if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === ">") {
+      return end + 1;
+    }
+  }
+  throw new Error("Unterminated HTML start tag");
+}
+function commentEnd(html, start) {
+  const end = html.indexOf("-->", start + 4);
+  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) {
+  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,
+    name: html.slice(nameStart, nameEnd).toLowerCase()
+  };
+}
+function rawTextElementEnd(html, lower, tag) {
+  if (tag.closing || tag.name !== "script" && tag.name !== "style") return null;
+  const closeStart = lower.indexOf(`</${tag.name}`, tag.end);
+  if (closeStart < 0) throw new Error(`Unterminated <${tag.name}> element`);
+  return startTagEnd(html, closeStart);
+}
+function scanMarkup(html, lower, start) {
+  if (html.startsWith("<!--", start)) {
+    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, mediaRange: null };
+  }
+  const rawTextEnd = rawTextElementEnd(html, lower, tag);
+  if (rawTextEnd !== null) return { cursor: rawTextEnd, mediaRange: null };
+  return { cursor: tag.end, mediaRange: mediaRangeOf(tag) };
+}
+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;
+  while (cursor < html.length) {
+    const start = html.indexOf("<", cursor);
+    if (start < 0) break;
+    const scanned = scanMarkup(html, lower, start);
+    if (scanned.mediaRange) ranges.push(scanned.mediaRange);
+    cursor = scanned.cursor;
+  }
+  return ranges;
+}
+function trimmedAttribute(attributes, name) {
+  return attributes.get(name)?.value.trim() ?? "";
+}
+function authoredDuration(attributes, id) {
+  const raw = attributes.get("data-duration")?.value;
+  if (raw !== void 0) return authoredNumber(raw, 0, "data-duration", id, true);
+  const rawEnd = attributes.get("data-end")?.value;
+  if (rawEnd === void 0) return null;
+  const end = authoredNumber(rawEnd, 0, "data-end", id, true);
+  const start = authoredNumber(attributes.get("data-start")?.value, 0, "data-start", id);
+  return end > start ? end - start : null;
+}
+function requiredAudioIdentity(attributes) {
+  const id = trimmedAttribute(attributes, "id");
+  const src = trimmedAttribute(attributes, "src");
+  if (!id) throw new Error("Every normalized <audio> element needs an id");
+  if (!src) throw new Error(`Audio #${id} has no src`);
+  return { id, src };
+}
+function authoredMediaStart(attributes, id) {
+  return readMediaOffsetSeconds((name) => {
+    const raw = attributes.get(name)?.value;
+    if (name === "data-media-start") authoredNumber(raw, 0, name, id);
+    return raw;
+  });
+}
+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),
+    mediaStart: authoredMediaStart(attributes, 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
+  };
+}
+function audioTags(html) {
+  const seen = /* @__PURE__ */ new Set();
+  const tags = [];
+  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);
+  }
+  return tags;
+}
+function resolveLocalAudioPath(projectDir, src) {
+  const decoded = requestedProjectPath(projectDir, src);
+  if (!decoded || isAbsolute(decoded) || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(decoded)) {
+    throw new Error(`Audio source must be a local project file: ${src}`);
+  }
+  const root = resolve(projectDir);
+  const file = resolve(root, decoded);
+  const rel = relative(root, file);
+  if (!rel || rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+    throw new Error(`Audio source must be a local project file: ${src}`);
+  }
+  return file;
+}
+function parseEbur128Summary(stderr) {
+  const summaryAt = stderr.lastIndexOf("Summary:");
+  const summary = summaryAt >= 0 ? stderr.slice(summaryAt) : "";
+  const integrated = summary.match(/\bI:\s*(-?\d+(?:\.\d+)?)\s+LUFS\b/);
+  const peak = summary.match(/\bPeak:\s*(-?\d+(?:\.\d+)?)\s+dBFS\b/);
+  const integratedLufs = Number(integrated?.[1]);
+  const truePeakDbfs = Number(peak?.[1]);
+  if (!Number.isFinite(integratedLufs)) {
+    throw new Error("FFmpeg did not report integrated loudness for this audio stream");
+  }
+  if (!Number.isFinite(truePeakDbfs)) {
+    throw new Error("FFmpeg did not report true peak for this audio stream");
+  }
+  return { integratedLufs, truePeakDbfs };
+}
+function gainDb(volume) {
+  return volume > 0 ? 20 * Math.log10(volume) : Number.NEGATIVE_INFINITY;
+}
+function audioNormalizationPlan(referenceTrack, targetTrack) {
+  if (!(referenceTrack.volume > 0) || !(targetTrack.volume > 0)) {
+    throw new Error("Muted audio cannot be used for loudness matching");
+  }
+  const referenceLufs = referenceTrack.integratedLufs + gainDb(referenceTrack.volume);
+  const targetLufs = targetTrack.integratedLufs + gainDb(targetTrack.volume);
+  const wantedGainDb = referenceLufs - targetTrack.integratedLufs;
+  if (wantedGainDb > MAX_AUDIO_GAIN_DB + 1e-9) {
+    throw new Error(
+      `Matching #${targetTrack.id} needs ${wantedGainDb.toFixed(1)} dB, beyond the +${MAX_AUDIO_GAIN_DB} dB authoring ceiling. A gap this large belongs in the source file, not the mixer: mixer gain raises the noise floor with the signal. Normalize ${targetTrack.id}'s asset offline (e.g. ffmpeg loudnorm), or lower #${referenceTrack.id} instead.`
+    );
+  }
+  const volume = 10 ** (wantedGainDb / 20);
+  const projectedTruePeakDbfs = targetTrack.truePeakDbfs + wantedGainDb;
+  if (projectedTruePeakDbfs > 0) {
+    throw new Error(
+      `Matching #${targetTrack.id} would clip at +${projectedTruePeakDbfs.toFixed(1)} dBFS; limit or preprocess the source first`
+    );
+  }
+  return {
+    referenceId: referenceTrack.id,
+    targetId: targetTrack.id,
+    referenceLufs,
+    targetLufs,
+    previousVolume: targetTrack.volume,
+    volume,
+    gainDb: wantedGainDb,
+    changeDb: wantedGainDb - gainDb(targetTrack.volume),
+    projectedLufs: targetTrack.integratedLufs + wantedGainDb,
+    projectedTruePeakDbfs
+  };
+}
+function updateAudioVolume(html, id, volume) {
+  const tag = audioTags(html).find((candidate) => candidate.id === id);
+  if (!tag) throw new Error(`Audio #${id} was not found`);
+  const value = formatAudioGain(volume);
+  if (tag.volumeAttribute) {
+    return html.slice(0, tag.volumeAttribute.valueStart) + value + html.slice(tag.volumeAttribute.valueEnd);
+  }
+  let insertion = tag.end - 1;
+  let tail = insertion - 1;
+  while (tail >= tag.start && /\s/.test(html[tail] ?? "")) tail -= 1;
+  if (html[tail] === "/") {
+    insertion = tail;
+    while (insertion > tag.start && /\s/.test(html[insertion - 1] ?? "")) insertion -= 1;
+  } else {
+    while (insertion > tag.start && /\s/.test(html[insertion - 1] ?? "")) insertion -= 1;
+  }
+  return html.slice(0, insertion) + ` data-volume="${value}"` + html.slice(insertion);
+}
+function loudnessMeasureArgs(file, tag) {
+  const args = ["-hide_banner", "-nostats"];
+  if (tag.mediaStart > 0) args.push("-ss", String(tag.mediaStart));
+  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;
+}
+async function measureAudio(ffmpegPath, file, tag) {
+  const result = await execFileAsync(ffmpegPath, loudnessMeasureArgs(file, tag), {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: FFMPEG_TIMEOUT_MS,
+    windowsHide: true
+  });
+  return parseEbur128Summary(result.stderr);
+}
+function requiredFfmpeg() {
+  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
+  if (!ffmpegPath) throw new Error("FFmpeg is required to measure integrated loudness");
+  return ffmpegPath;
+}
+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`);
+  }
+  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
+  };
+}
+
+export {
+  requestSubPath,
+  requestedProjectPath,
+  audioTags,
+  resolveLocalAudioPath,
+  parseEbur128Summary,
+  audioNormalizationPlan,
+  updateAudioVolume,
+  loudnessMeasureArgs,
+  measureAudio,
+  requiredFfmpeg,
+  DEFAULT_TARGET_LUFS,
+  absoluteLoudnessPlan
+};