hyperframes 0.8.142 → 0.8.144

package/dist/{chunk-LCSMOLGX.js → chunk-BYSBRF24.js}

@@ -4,6 +4,9 @@ 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 {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
 
 // src/utils/processTree.ts
 import { execFileSync, spawn } from "child_process";
@@ -121,6 +124,57 @@ async function terminateProcessTree(pid, options = {}) {
   return options.processGroup ? terminateProcessGroup(pid, signal) : terminatePidTree(pid, signal);
 }
 
+// src/renderSetupWorkerLifecycle.ts
+var RENDER_SETUP_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var RENDER_SETUP_RESULT_PREFIX = "HYPERFRAMES_RENDER_SETUP_RESULT:";
+var RENDER_SETUP_ERROR_PREFIX = "HYPERFRAMES_RENDER_SETUP_ERROR:";
+function installRenderSetupSignalHandlers(signalTarget, releaseLock, resendSignal, handleHangup = true) {
+  const handlers = /* @__PURE__ */ new Map();
+  const handledSignals = handleHangup ? RENDER_SETUP_SIGNALS : RENDER_SETUP_SIGNALS.filter((signal) => signal !== "SIGHUP");
+  for (const signal of handledSignals) {
+    const handler = () => {
+      releaseLock();
+      signalTarget.off(signal, handler);
+      resendSignal(signal);
+    };
+    handlers.set(signal, handler);
+    signalTarget.on(signal, handler);
+  }
+  return () => {
+    for (const [signal, handler] of handlers) signalTarget.off(signal, handler);
+  };
+}
+function prefixedLine(prefix, value) {
+  return prefix + JSON.stringify(value) + "\n";
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function prefixedValue(output, prefix) {
+  const line = output.split(/\r?\n/).find((text) => text.startsWith(prefix));
+  return line === void 0 ? void 0 : parseJson(line.slice(prefix.length));
+}
+function renderSetupResultLine(result) {
+  return prefixedLine(RENDER_SETUP_RESULT_PREFIX, result);
+}
+function renderSetupResultFrom(stdout) {
+  return prefixedValue(stdout, RENDER_SETUP_RESULT_PREFIX);
+}
+function renderSetupErrorLine(error) {
+  return "\n" + prefixedLine(RENDER_SETUP_ERROR_PREFIX, normalizeErrorMessage(error));
+}
+function renderSetupFailureFrom(stderr) {
+  const lines = stderr.split(/\r?\n/);
+  const at = lines.findIndex((text) => text.startsWith(RENDER_SETUP_ERROR_PREFIX));
+  const reason = at === -1 ? void 0 : parseJson(lines[at].slice(RENDER_SETUP_ERROR_PREFIX.length));
+  if (typeof reason !== "string" || reason === "") return void 0;
+  return { reason, earlierOutput: lines.slice(0, at).join("\n") };
+}
+
 // src/utils/cancellableProcess.ts
 import { spawn as spawn2 } from "child_process";
 import { fileURLToPath } from "url";
@@ -269,7 +323,14 @@ function runCancellableProcess(command, args, options = {}) {
     }
   });
 }
-var SETUP_RESULT_PREFIX = "HYPERFRAMES_RENDER_SETUP_RESULT:";
+function renderSetupError(error) {
+  if (!(error instanceof CancellableProcessError)) return error;
+  const failure = renderSetupFailureFrom(error.stderr);
+  if (failure?.earlierOutput.trim()) process.stderr.write(`${failure.earlierOutput.trimEnd()}
+`);
+  const reason = failure?.reason ?? error.stderr.trim();
+  return reason ? new Error(reason, { cause: error }) : error;
+}
 async function runRenderSetupWorker(mode, input, options) {
   const sourceMode = import.meta.url.endsWith(".ts");
   const workerUrl = new URL(
@@ -293,20 +354,20 @@ async function runRenderSetupWorker(mode, input, options) {
     );
   } catch (error) {
     if (options.signal?.aborted) options.signal.throwIfAborted();
-    if (error instanceof CancellableProcessError && error.stderr.trim()) {
-      throw new Error(error.stderr.trim(), { cause: error });
-    }
-    throw error;
+    throw renderSetupError(error);
   }
   if (result.stderr) process.stderr.write(result.stderr);
-  const encoded = result.stdout.split(/\r?\n/).find((line) => line.startsWith(SETUP_RESULT_PREFIX))?.slice(SETUP_RESULT_PREFIX.length);
-  if (!encoded) throw new Error(`${mode} setup process exited without a result`);
-  return JSON.parse(encoded);
+  const value = renderSetupResultFrom(result.stdout);
+  if (value === void 0) throw new Error(`${mode} setup process exited without a result`);
+  return value;
 }
 
 export {
   processIsAlive,
   terminateProcessTree,
+  installRenderSetupSignalHandlers,
+  renderSetupResultLine,
+  renderSetupErrorLine,
   runCancellableProcess,
   runRenderSetupWorker
 };

package/dist/{chunk-U7E736AJ.js → chunk-DDIVWXN7.js}

@@ -4,6 +4,9 @@ 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-G75ENCEZ.js";
 import {
   MAX_AUDIO_GAIN_DB,
   formatAudioGain,
@@ -12,11 +15,28 @@ import {
 import {
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
+import {
+  decodeWellFormedEscapes,
+  decodedUrlPath,
+  readMediaOffsetSeconds
+} from "./chunk-BSQ7XANM.js";
 
-// ../studio-server/dist/chunk-DSVQ2U7J.js
+// ../studio-server/dist/chunk-32IH7WBY.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) {
@@ -161,6 +181,13 @@ function requiredAudioIdentity(attributes) {
   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);
@@ -185,12 +212,7 @@ function mediaTagFromRange(html, range) {
     id,
     src,
     volume: authoredNumber(volumeAttribute?.value, 1, "data-volume", id),
-    mediaStart: authoredNumber(
-      attributes.get("data-media-start")?.value,
-      0,
-      "data-media-start",
-      id
-    ),
+    mediaStart: authoredMediaStart(attributes, id),
     duration: authoredDuration(attributes, id),
     playbackRate: authoredNumber(
       attributes.get("data-playback-rate")?.value,
@@ -217,13 +239,7 @@ function audioTags(html) {
   return tags;
 }
 function resolveLocalAudioPath(projectDir, src) {
-  const withoutSuffix = src.split(/[?#]/, 1)[0] ?? "";
-  let decoded = "";
-  try {
-    decoded = decodeURIComponent(withoutSuffix);
-  } catch {
-    throw new Error(`Audio source must be a local project file: ${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}`);
   }
@@ -358,6 +374,8 @@ function absoluteLoudnessPlan(track, targetLufs = DEFAULT_TARGET_LUFS) {
 }
 
 export {
+  requestSubPath,
+  requestedProjectPath,
   audioTags,
   resolveLocalAudioPath,
   parseEbur128Summary,

package/dist/{chunk-KOEWEFHK.js → chunk-DIRJ322I.js}

@@ -10,22 +10,25 @@ import {
   distroLabel,
   getFFmpegInstallHint,
   parseLddMissingLibs
-} from "./chunk-TVCRUG2S.js";
+} from "./chunk-ZEUONDQG.js";
 import {
   getFreeDiskMb
 } from "./chunk-GQJZORQP.js";
 import {
   ensureBrowser,
   findBrowser
-} from "./chunk-4PFZPP2N.js";
+} from "./chunk-A6S35NYA.js";
 import {
   runCancellableProcess
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
 
 // src/browser/preflight.ts
 import { existsSync } from "fs";
@@ -254,11 +257,13 @@ async function checkChrome(browserPath, signal) {
     };
   }
   let info;
+  let failure;
   try {
     info = signal ? await ensureBrowser({ preferManagedChrome: true, signal }) : await findBrowser();
-  } catch {
+  } catch (error) {
     if (signal?.aborted) signal.throwIfAborted();
     info = void 0;
+    failure = normalizeErrorMessage(error);
   }
   if (info) {
     return chromeLaunchOutcome(
@@ -278,7 +283,7 @@ async function checkChrome(browserPath, signal) {
     ok: false,
     level: "error",
     title: "Chrome not found",
-    detail: "Chrome Headless Shell is required for local rendering.",
+    detail: failure ?? "Chrome Headless Shell is required for local rendering.",
     hint: "Run: npx hyperframes browser ensure"
   };
 }

package/dist/{chunk-HMUF7FEO.js → chunk-EX6C672Y.js}

@@ -14,11 +14,11 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-IDX52YJN.js";
+} from "./chunk-5VMR4WBS.js";
 import {
   DOMParser,
   parseHTML
-} from "./chunk-GK4AIFIH.js";
+} from "./chunk-SDYDNHEE.js";
 
 // src/capture/userAgent.ts
 var CAPTURE_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";