@hyperframes/producer 0.8.189 → 0.8.191

package/dist/distributed.d.ts

@@ -39,6 +39,7 @@ export { muxChunkWithAudio } from "./services/distributed/chunkAudio.js";
 export { buildStitchedHeader, readMp4Layout, type Mp4Layout, type ReadRange, } from "./services/distributed/mp4Stitch.js";
 export { InvalidConfigError, type SerializableDistributedRenderConfig, validateDistributedRenderConfig, validateVariablesPayload, } from "./services/distributed/renderConfigValidation.js";
 export { hashProjectDir, listSiteFiles } from "./services/distributed/projectHash.js";
+export { AUDIO_SIDECAR_MIN_BYTES, buildAudioSidecar, wantsAudioSidecar, type AudioSidecarOutcome, } from "./services/distributed/audioSidecar.js";
 export { CURRENT_PLAN_PROTOCOL, DISTRIBUTED_RENDER_CAPABILITIES, getDistributedRenderCapabilities, PLAN_ARTIFACT_LAYOUT, PLAN_HASH_SCHEMA, PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2, PLAN_PROTOCOL_UNSUPPORTED, PLAN_SCHEMA_VERSION, PLAN_V2_ARTIFACT_LAYOUT, PLAN_V2_HASH_SCHEMA, PLAN_V2_SCHEMA_VERSION, PlanProtocolUnsupportedError, readPlanProtocol, readPlanProtocolV1, type DistributedRenderCapabilities, type PlanProtocolConsumerCapabilities, type PlanProtocolDescriptor, type PlanProtocolV1Descriptor, type PlanProtocolV2Descriptor, type SupportedPlanProtocolDescriptor, } from "./services/distributed/planProtocol.js";
 export { PlanVideosMetadataError, type DistributedFormat } from "./services/distributed/shared.js";
 export { isPlanAudioArtifactPath, PLAN_AUDIO_LEGACY_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, resolvePlanAudioPath, } from "./services/distributed/shared.js";

package/dist/distributed.js

@@ -1097,6 +1097,14 @@ function materializeExtractedFramesForCompiledDir(extracted, compiledDir, option
   }
 }
 
+// src/services/render/frameCacheBudget.ts
+function frameCacheOptions(cfg, workers) {
+  return {
+    frameDataUriCacheLimit: cfg.frameDataUriCacheLimit,
+    frameDataUriCacheBytesLimitMb: Math.floor(cfg.frameDataUriCacheBytesLimitMb / (workers || 1))
+  };
+}
+
 // src/utils/errorMessage.ts
 function normalizeErrorMessage(error) {
   if (error instanceof Error) return error.message;
@@ -3387,7 +3395,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
       );
       if (analysis.isProblematic) {
         defaultLogger.warn(
-          `[Compiler] WARNING: Video "${video.id}" has sparse keyframes (max interval: ${analysis.maxIntervalSeconds}s). This causes seek failures and frame freezing. Re-encode with: ${reencode}`
+          `[Compiler] WARNING: Video "${video.id}" has sparse keyframes (max interval: ${analysis.maxIntervalSeconds}s). Long GOPs can make preview seeking slower; rendering is unaffected. If preview seeking is slow, re-encode with: ${reencode}`
         );
       }
       if (metadata.isVFR) {
@@ -5438,6 +5446,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     audios,
     masterFxChain,
     urlByAbsentLocalPath,
+    audioSidecarUrlByLocalPath,
     abortSignal,
     assertNotAborted,
     log
@@ -5461,6 +5470,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
           audioGain,
           masterFxChain,
           urlByAbsentLocalPath,
+          audioSidecarUrlByLocalPath,
           keepEncoderInputAt: pcmSourcePath
         },
         compiledDir
@@ -6847,12 +6857,13 @@ var RenderChunkValidationError = class extends Error {
     this.code = code;
   }
 };
-function createChunkVideoFrameInjectorFactory(frameLookup) {
-  if (!(frameLookup instanceof Promise)) return () => createVideoFrameInjector2(frameLookup);
+function createChunkVideoFrameInjectorFactory(frameLookup, options) {
+  if (!(frameLookup instanceof Promise))
+    return () => createVideoFrameInjector2(frameLookup, options);
   return () => {
     let hook;
     return async (page, time, heldVideoTime) => {
-      hook ??= createVideoFrameInjector2(await frameLookup);
+      hook ??= createVideoFrameInjector2(await frameLookup, options);
       await hook?.(page, time, heldVideoTime);
     };
   };
@@ -8574,6 +8585,11 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   const localPathByUrl = new Map(
     remoteFiles.map(([rel, file]) => [file.url, remoteLocalPath(rel)])
   );
+  const audioSidecarUrlByLocalPath = new Map(
+    remoteFiles.flatMap(
+      ([rel, file]) => file.audioSidecarUrl ? [[remoteLocalPath(rel), file.audioSidecarUrl]] : []
+    )
+  );
   stageStarted = Date.now();
   const compileResult = await runCompileStage({
     urlByAbsentLocalPath,
@@ -8658,6 +8674,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     finalCompiledDir,
     remoteFiles,
     urlByAbsentLocalPath,
+    audioSidecarUrlByLocalPath,
     localPathByUrl,
     compileResult,
     compiled,
@@ -8675,6 +8692,7 @@ function mixPlanAudio(c, compiledDir) {
     workDir: c.workDir,
     compiledDir,
     urlByAbsentLocalPath: c.urlByAbsentLocalPath,
+    audioSidecarUrlByLocalPath: c.audioSidecarUrlByLocalPath,
     totalFrames: c.totalFrames,
     fps: c.job.config.fps,
     ffmpegProcessTimeout: c.cfg.ffmpegProcessTimeout,
@@ -10283,6 +10301,22 @@ async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, cap
 function isCaptureMode(value) {
   return value === "beginframe" || value === "screenshot" || value === "drawelement";
 }
+var MixedCaptureModesError = class extends Error {
+  constructor(modes) {
+    super(`[renderChunk] capture workers reported inconsistent modes: ${modes.join(",")}`);
+    this.modes = modes;
+    this.name = "MixedCaptureModesError";
+  }
+};
+function observedChunkCaptureMode(perfs) {
+  const modes = [...new Set(perfs.map((perf) => perf.captureMode))];
+  if (modes.length > 1) throw new MixedCaptureModesError(modes);
+  const [mode] = modes;
+  if (!mode || !isCaptureMode(mode)) {
+    throw new Error(`[renderChunk] capture workers reported an invalid mode: ${mode ?? "<none>"}`);
+  }
+  return mode;
+}
 function shouldRetryChunkCaptureWithScreenshot(error) {
   const failure = classifyCaptureFailure4(error);
   if (failure.kind === "cancelled" || failure.kind === "memory_exhaustion") return false;
@@ -10580,7 +10614,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       ) : null;
       videoFrameLookup?.catch(() => {
       });
-      const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
+      const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(
+        videoFrameLookup,
+        frameCacheOptions(cfg, chunkWorkerCount)
+      );
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
         forceScreenshot: forceScreenshotForChunk,
@@ -10634,17 +10671,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             },
             frameRange: range
           });
-          const observedModes = new Set(capturePerfs.map((perf) => perf.captureMode));
-          if (observedModes.size !== 1 || ![...observedModes].every(isCaptureMode)) {
-            throw new Error(
-              `[renderChunk] capture workers reported invalid or inconsistent modes: ${[...observedModes].join(",") || "<none>"}`
-            );
-          }
-          const [observedMode] = observedModes;
-          if (!observedMode || !isCaptureMode(observedMode)) {
-            throw new Error("[renderChunk] capture completed without an observed mode");
-          }
-          return observedMode;
+          return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
           rmSync13(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
@@ -11146,7 +11173,36 @@ function hashProjectDir(projectDir, files = listSiteFiles(projectDir)) {
   }
   return hash.digest("hex").slice(0, 16);
 }
+
+// src/services/distributed/audioSidecar.ts
+import { extractAudioMetadata as extractAudioMetadata4, runFfmpeg as runFfmpeg8 } from "@hyperframes/engine";
+import { extname as extname5 } from "node:path";
+var AUDIO_SIDECAR_MIN_BYTES = 32 * 1024 * 1024;
+var AUDIO_SIDECAR_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".m4v"]);
+function wantsAudioSidecar(path, sizeBytes) {
+  return sizeBytes >= AUDIO_SIDECAR_MIN_BYTES && AUDIO_SIDECAR_SOURCE_EXTENSIONS.has(extname5(path).toLowerCase());
+}
+async function buildAudioSidecar(inputPath, outputPath, signal) {
+  const audio = await extractAudioMetadata4(inputPath, { signal }).catch(() => null);
+  if (!audio) return await ffmpegIsMissing(signal) ? "unavailable" : "none";
+  if (audio.audioStreamCount !== 1 || (audio.audioStreamLeadSeconds ?? 0) > 0) return "none";
+  const result = await runFfmpeg8(
+    ["-v", "error", "-y", "-i", inputPath, "-map", "0:a:0", "-vn", "-c:a", "copy"].concat([
+      "-movflags",
+      "+faststart",
+      "-f",
+      "mp4",
+      outputPath
+    ]),
+    { signal }
+  );
+  if (result.success) return "built";
+  return isMissing(result) ? "unavailable" : "none";
+}
+var isMissing = (result) => result.error?.code === "ENOENT";
+var ffmpegIsMissing = async (signal) => isMissing(await runFfmpeg8(["-version"], { signal }));
 export {
+  AUDIO_SIDECAR_MIN_BYTES,
   CHUNK_EXCEEDS_WORKER_TIMEOUT,
   CHUNK_FRAME_RANGE_INVALID,
   CURRENT_PLAN_PROTOCOL,
@@ -11189,6 +11245,7 @@ export {
   applyRuntimeEnvSnapshot,
   assemble,
   assembleV2,
+  buildAudioSidecar,
   buildChunkSlices,
   buildPlanAudio,
   buildStitchedHeader,
@@ -11224,5 +11281,6 @@ export {
   stitchesSeparateAudio,
   validateDistributedRenderConfig,
   validatePlanV2MaterializedTarget,
-  validateVariablesPayload
+  validateVariablesPayload,
+  wantsAudioSidecar
 };

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "eee27ae31219b3ee97526ca8d8716b921e7f5bce461e1d62f1ff2a49eb26ea67",
+  "sha256": "cd5f930c1b25aea193005449687af10c1b706fc870e51d1ff160dd46751d1581",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"