hyperframes 0.8.169 → 0.8.171

package/dist/{chunk-UCNQE52B.js → chunk-4RXJG3SY.js}

@@ -17,12 +17,12 @@ import {
   iterateFontFamilyDeclarations,
   normalizeSystemFontPrimaryFamilies,
   resolveFontFamilyDeclarationFamilies
-} from "./chunk-M4N6IHCQ.js";
+} from "./chunk-XRQBHOBT.js";
 import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-GVX2443P.js";
+} from "./chunk-PH3RS5X4.js";
 import {
   BROWSER_GPU_NOT_SOFTWARE,
   CaptureFailure,
@@ -151,7 +151,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-7FHFPHEM.js";
+} from "./chunk-VKFYI7AQ.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -164,7 +164,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-P24X6CGY.js";
+} from "./chunk-FAORS3UR.js";
 import {
   LOW_MEMORY_TOTAL_MB_THRESHOLD,
   getCgroupMemoryLimitMb,
@@ -190,7 +190,7 @@ import {
   resolveAbsoluteMediaStartSeconds,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-O3J7BHBU.js";
+} from "./chunk-QZUVPWC4.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -218,7 +218,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-BIV5HVTQ.js";
+} from "./chunk-6M3IPJS6.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-UJKQWGFF.js";
@@ -6574,7 +6574,7 @@ async function readLocalFont(absPath) {
   return { kind: "inline", buffer: Buffer.concat(chunks, totalBytes) };
 }
 async function embedLocalFontFaces(html, projectDir) {
-  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-KXVO7QEL.js");
+  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-RWGQPEZU.js");
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const fontFaceRe = /@font-face\s*\{([^}]*)\}/gi;
   let result = html;
@@ -13533,6 +13533,13 @@ var PLAN_AUDIO_LEGACY_RELATIVE_PATH = "audio.aac";
 function isPlanAudioArtifactPath(path) {
   return path === PLAN_AUDIO_RELATIVE_PATH || path === PLAN_AUDIO_LEGACY_RELATIVE_PATH;
 }
+function resolvePlanAudioPath(planDir) {
+  for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
+    const candidate = join27(planDir, name);
+    if (existsSync17(candidate)) return candidate;
+  }
+  return null;
+}
 var INVALID_VIDEO_METADATA = "INVALID_VIDEO_METADATA";
 var PlanVideosMetadataError = class extends Error {
   // Read by cloud adapters across the package boundary to classify retries.
@@ -14185,9 +14192,28 @@ function buildLockedRenderConfig(input) {
     chunkSize: input.effectiveChunkSize,
     chunkCount: input.chunkCount,
     runtimeEnv: input.runtimeEnv,
-    variables: config.variables
+    variables: config.variables,
+    ...input.chunksCarryAudio ? { chunksCarryAudio: true } : {}
   };
 }
+function carriesChunkAudio(config, options) {
+  return options.chunksCarryAudio === true && config.format === "mp4" && config.cfr !== true;
+}
+async function fitPlanAudioToFrames(audioPath, workDir, totalFrames, fps, run) {
+  const fittedPath = join29(workDir, "audio-fitted.m4a");
+  const result = await padOrTrimAudioToVideoFrameCount({
+    videoPath: audioPath,
+    probeVideoFrameInfo: async () => ({ frameCount: totalFrames, fpsNum: fps, fpsDen: 1 }),
+    audioPath,
+    outputPath: fittedPath,
+    signal: run.signal,
+    timeoutMs: run.timeoutMs
+  });
+  if (!result.success) {
+    throw encoderFailureError("[plan] audio pad/trim failed", result);
+  }
+  renameSync4(fittedPath, audioPath);
+}
 function resolveEncoderTriple(config) {
   if (config.format === "mp4") {
     return resolveMp4EncoderTriple(config.codec);
@@ -14241,6 +14267,13 @@ function pathInside(root, path) {
   const rel = relative5(root, path);
   return rel === "" || rel.startsWith("..") || isAbsolute2(rel) ? null : rel;
 }
+function stableSourcePath(roots, srcPath) {
+  for (const [root, prefix] of roots) {
+    const rel = pathInside(root, srcPath);
+    if (rel !== null) return [prefix, ...rel.split(sep2)].filter(Boolean).join("/");
+  }
+  return srcPath;
+}
 function createVideoSourceShipper(input) {
   const shipped = /* @__PURE__ */ new Map();
   return (srcPath) => {
@@ -14390,7 +14423,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-ZGMLMQ3B.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-VFTQPSQD.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -14453,12 +14486,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     workCompiledDir: compiledDir,
     workVideoFramesDir: stagedVideoFrames
   });
+  const sourceRoots = [
+    [stagedVideoFrames, "video-frames"],
+    [compiledDir, "compiled"],
+    [projectDir, ""]
+  ];
   const planVideosJson = buildPlanVideosJson({
     videos: composition.videos,
     compositionEnd: job.duration ?? Number.NaN,
     extracted: (extractResult.extractionResult?.extracted ?? []).map((ext) => ({
       videoId: ext.videoId,
-      srcPath: ext.srcPath,
+      srcPath: stableSourcePath(sourceRoots, ext.srcPath),
       framePattern: ext.framePattern,
       fps: ext.fps,
       totalFrames: ext.totalFrames,
@@ -14509,6 +14547,13 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult.hasAudio && existsSync18(audioResult.audioOutputPath)) {
     renameSync4(audioResult.audioOutputPath, planAudioPath);
   }
+  const chunksCarryAudio2 = carriesChunkAudio(config, options);
+  if (chunksCarryAudio2 && existsSync18(planAudioPath)) {
+    await fitPlanAudioToFrames(planAudioPath, workDir, totalFrames, config.fps, {
+      signal: abortSignal,
+      timeoutMs: cfg.ffmpegProcessTimeout
+    });
+  }
   const ffmpegVersion = await readFfmpegVersion();
   const producerVersion = readProducerVersion();
   const fontSnapshotSha = await readFontSnapshotSha();
@@ -14521,7 +14566,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     engineConfig: cfg,
     effectiveChunkSize,
     chunkCount,
-    runtimeEnv
+    runtimeEnv,
+    chunksCarryAudio: chunksCarryAudio2
   });
   const compositionJson = {
     durationSeconds: job.duration ?? 0,
@@ -15917,7 +15963,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-ZGMLMQ3B.js");
+    const { drainBrowserPool } = await import("./src-VFTQPSQD.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -16177,8 +16223,10 @@ function resolveExtractedVideoOutputDir(planDir, videoId) {
   }
   return outputDir;
 }
-function artifactTargets(path, videoDependencies) {
-  if (isPlanAudioArtifactPath(path)) return { chunks: [], assembler: true };
+function artifactTargets(path, videoDependencies, chunksCarryAudio2) {
+  if (isPlanAudioArtifactPath(path)) {
+    return { chunks: chunksCarryAudio2 ? "all" : [], assembler: true };
+  }
   if (path === "plan.json" || path === "meta/chunks.json" || path === "meta/encoder.json") {
     return { chunks: "all", assembler: true };
   }
@@ -16400,9 +16448,11 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
+  const encoder = readJsonFile(join35(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const chunksCarryAudio2 = isRecord3(encoder) && encoder.chunksCarryAudio === true;
   for (const file of listFiles(executionPlanDir)) {
     if (isExtractionCacheCompleteSentinelPath(file.path)) continue;
-    const targets = artifactTargets(file.path, videoDependencyPlan.dependencies);
+    const targets = artifactTargets(file.path, videoDependencyPlan.dependencies, chunksCarryAudio2);
     if ((file.path.startsWith("video-frames/") || file.path.startsWith("video-sources/")) && targets.chunks !== "all" && targets.chunks.length === 0 && !targets.assembler) {
       continue;
     }
@@ -16505,7 +16555,8 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
         listFiles(join35(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
-      )
+      ),
+      chunksCarryAudio: options.chunksCarryAudio
     });
     return await publishExecutionPlan(stagingRoot, publisher, { digests, log: config.logger });
   } catch (error) {
@@ -16818,6 +16869,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     format,
     fps,
     fpsArg: fpsToFfmpegArg(fps),
+    chunkSeconds: chunksCarryAudio(planDir) ? plan2.chunks.map((chunk) => (chunk.endFrame - chunk.startFrame) * fps.den / fps.num) : null,
     signal: options?.abortSignal,
     timeout: resolveConfig().ffmpegProcessTimeout,
     log,
@@ -16880,10 +16932,10 @@ function readAssemblePlan(planDir, chunkPaths) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
-  return plan2;
+  return { ...plan2, chunks };
 }
 function videoInputArgs(ctx, videoSources) {
-  return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
+  return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg, ctx.chunkSeconds);
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
   const cfrOutputPath = join36(ctx.workDir, `cfr.${ctx.format}`);
@@ -16963,10 +17015,15 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     throw encoderFailureError("[assemble] audio mux failed", muxResult);
   }
 }
-function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
+function concatDemuxerInput(chunkPaths, workDir, fpsArg, chunkSeconds) {
   const listPath = join36(workDir, "concat-list.txt");
-  const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync11(listPath, `${body}
+  const head = chunkSeconds ? ["stream", "exact_stream_id 1"] : [];
+  const body = chunkPaths.map((path, i) => {
+    const line = `file '${path.replace(/'/g, "'\\''")}'`;
+    return chunkSeconds ? `${line}
+duration ${chunkSeconds[i].toFixed(6)}` : line;
+  });
+  writeFileSync11(listPath, `${[...head, ...body].join("\n")}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -16989,6 +17046,11 @@ async function runAssembleFfmpeg(args, step, signal, timeout) {
     });
   }
 }
+function chunksCarryAudio(planDir) {
+  const encoderJsonPath = join36(planDir, "meta", "encoder.json");
+  if (!existsSync24(encoderJsonPath)) return false;
+  return JSON.parse(readFileSync12(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
+}
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
     throw new Error(
@@ -17055,6 +17117,103 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 import { randomBytes } from "crypto";
 import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync13, readdirSync as readdirSync10, rmSync as rmSync14, writeFileSync as writeFileSync12 } from "fs";
 import { extname as extname6, join as join37 } from "path";
+
+// ../producer/src/services/distributed/chunkAudio.ts
+function audioCutForChunk(grid, chunks, index, fps) {
+  const firstPacketAt = (frame) => Math.min(
+    grid.packetCount,
+    Math.max(
+      0,
+      Math.ceil(
+        (frame * fps.den * grid.sampleRate - grid.firstStart * fps.num) / (grid.packetSamples * fps.num)
+      )
+    )
+  );
+  const first = index === 0 ? 0 : firstPacketAt(chunks[index].startFrame);
+  const end = index === chunks.length - 1 ? grid.packetCount : firstPacketAt(chunks[index + 1].startFrame);
+  if (end <= first) return null;
+  const cutSeconds = (packet) => (grid.firstStart + packet * grid.packetSamples - grid.packetSamples / 2) / grid.sampleRate;
+  const seekSeconds = index === 0 ? null : cutSeconds(first);
+  const durationSeconds = end === grid.packetCount ? null : cutSeconds(end) - (seekSeconds ?? 0);
+  return { seekSeconds, durationSeconds, firstPacket: first, packetCount: end - first };
+}
+async function probeAacPacketGrid(audioPath) {
+  const probe = await runFfprobeJson([
+    "-v",
+    "error",
+    "-select_streams",
+    "a:0",
+    "-show_entries",
+    "stream=sample_rate,time_base,nb_frames:packet=pts,duration",
+    "-read_intervals",
+    "%+#1",
+    "-of",
+    "json",
+    "--",
+    audioPath
+  ]);
+  const stream = probe.streams?.[0] ?? {};
+  const packet = probe.packets?.[0] ?? {};
+  const sampleRate = Number(stream.sample_rate);
+  const [tbNum = NaN, tbDen = NaN] = String(stream.time_base).split("/").map(Number);
+  const toSamples = (ticks) => Number(ticks) * sampleRate * tbNum / tbDen;
+  const grid = {
+    sampleRate,
+    firstStart: toSamples(packet.pts),
+    packetSamples: toSamples(packet.duration),
+    packetCount: Number(stream.nb_frames)
+  };
+  const counts = [grid.sampleRate, grid.packetSamples, grid.packetCount];
+  if (!Number.isFinite(grid.firstStart) || !counts.every((n) => Number.isFinite(n) && n > 0)) {
+    throw new Error(`[chunkAudio] could not read the AAC packet grid: ${JSON.stringify(probe)}`);
+  }
+  return grid;
+}
+function chunkMuxArgs(input, cut) {
+  if (!cut) return ["-i", input.videoPath, "-map", "0:v:0"];
+  const seek = cut.seekSeconds === null ? [] : ["-ss", cut.seekSeconds.toFixed(6)];
+  const length = cut.durationSeconds === null ? [] : ["-t", cut.durationSeconds.toFixed(6)];
+  const exact = seek.length ? ["-copypriorss", "0"] : [];
+  return [
+    ...["-i", input.videoPath, ...seek, ...length, "-i", input.audioPath],
+    ...["-map", "0:v:0", "-map", "1:a:0", ...exact]
+  ];
+}
+async function muxChunkWithAudio(input) {
+  const grid = input.audioPath ? await probeAacPacketGrid(input.audioPath) : null;
+  const cut = grid ? audioCutForChunk(grid, input.chunks, input.chunkIndex, input.fps) : null;
+  const args = [...chunkMuxArgs(input, cut), "-c", "copy"];
+  appendRenderProvenanceArgs(args, input.outputPath);
+  args.push("-y", input.outputPath);
+  const result = await runFfmpeg(args, { signal: input.signal, timeout: input.timeoutMs });
+  if (!result.success) {
+    throw new Error(
+      `[chunkAudio] chunk mux failed: ${describeFfmpegFailure(result, input.timeoutMs)}`
+    );
+  }
+  const slice = input.chunks[input.chunkIndex];
+  const expected = { video: slice.endFrame - slice.startFrame };
+  if (cut) expected.audio = cut.packetCount;
+  const probe = await runFfprobeJson([
+    "-v",
+    "error",
+    "-count_packets",
+    "-show_entries",
+    "stream=codec_type,nb_read_packets",
+    "-of",
+    "json",
+    "--",
+    input.outputPath
+  ]);
+  for (const [type, count] of Object.entries(expected)) {
+    const packets = Number(probe.streams?.find((s) => s.codec_type === type)?.nb_read_packets ?? 0);
+    if (packets !== count) {
+      throw new Error(`[chunkAudio] ${type} packets in chunk ${packets}, expected ${count}`);
+    }
+  }
+}
+
+// ../producer/src/services/distributed/renderChunk.ts
 var FFMPEG_VERSION_MISMATCH = "FFMPEG_VERSION_MISMATCH";
 var PLAN_HASH_MISMATCH = "PLAN_HASH_MISMATCH";
 var MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
@@ -17603,7 +17762,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       const preset = resolvePresetForLockedEncoder(basePreset, encoder.encoder);
       const effectiveQuality = encoder.crf ?? preset.quality;
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
-      const videoOnlyPath = outputChunkPath;
+      const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
         if (!existsSync25(outputChunkPath)) mkdirSync15(outputChunkPath, { recursive: true });
       } else {
@@ -17614,16 +17773,16 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       await runEncodeStage({
         job,
         log,
-        outputPath: outputChunkPath,
+        outputPath: videoOnlyPath,
         framesDir,
         videoOnlyPath,
         width: Math.round(plan2.dimensions.width * encoder.deviceScaleFactor),
         height: Math.round(plan2.dimensions.height * encoder.deviceScaleFactor),
         needsAlpha: plan2.dimensions.format !== "mp4",
         captureImageFormat: captureOptions.format ?? "jpeg",
-        // Each chunk produces video only — audio is muxed once at assemble
-        // time. Suppressing `hasAudio` skips the png-sequence audio sidecar
-        // AND the mp4 audio mux.
+        // The encoder writes video only; audio joins at assemble time or in the
+        // chunk that carries audio. Suppressing `hasAudio` skips the png-sequence audio
+        // sidecar AND the mp4 audio mux.
         hasAudio: false,
         isPngSequence,
         // `DistributedFormat` has no "gif" member — distributed chunks are
@@ -17650,6 +17809,18 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         lockGopForChunkConcat: !isPngSequence,
         gopSize: framesInChunk
       });
+      if (encoder.chunksCarryAudio) {
+        await muxChunkWithAudio({
+          videoPath: videoOnlyPath,
+          audioPath: resolvePlanAudioPath(planDir),
+          outputPath: outputChunkPath,
+          chunks,
+          chunkIndex,
+          fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
+          timeoutMs: cfg.ffmpegProcessTimeout
+        });
+        rmSync14(videoOnlyPath, { force: true });
+      }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
       if (session) {

package/dist/{chunk-JPN7SVWC.js → chunk-5GQB63WX.js}

@@ -7,29 +7,29 @@ var __dirname = __hf_dirname(__filename);
 import {
   RegistryCompatibilityError,
   gateRegistryItemsCompatibility
-} from "./chunk-YZRS3COO.js";
+} from "./chunk-4QIJFIR5.js";
 import {
   DEFAULT_PROJECT_CONFIG,
   createProjectConfig,
   loadProjectConfig,
   projectConfigPath,
   recordProjectRegistryItems
-} from "./chunk-J5Z56PU3.js";
+} from "./chunk-EDGJ2OMH.js";
 import {
   resolveItemWithDependencies,
   resolveItemsByTag
-} from "./chunk-5SQHHBAR.js";
+} from "./chunk-JMJTXBVF.js";
 import {
   InvalidVariableValuesError,
   prepareItem,
   publishItem
-} from "./chunk-5FWVFCQM.js";
+} from "./chunk-XGFYN53T.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-EELTMBCC.js";
+} from "./chunk-RTW6WSC7.js";
 import {
   trackRegistryItemAdded
-} from "./chunk-FQJDV2RI.js";
+} from "./chunk-6I24ZSCR.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -41,7 +41,7 @@ import {
 } from "./chunk-ZTZA4UWZ.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-O3J7BHBU.js";
+} from "./chunk-QZUVPWC4.js";
 import {
   isProjectRootMissing,
   realpath

package/dist/{chunk-FSX7GTBB.js → chunk-5HLJ4JMB.js}

@@ -29,7 +29,7 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-BNEKKUPG.js";
+} from "./chunk-BYFG74OA.js";
 import {
   CANARIES,
   canaryEnvVar,

package/dist/{chunk-FQJDV2RI.js → chunk-6I24ZSCR.js}

@@ -8,7 +8,7 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-FSX7GTBB.js";
+} from "./chunk-5HLJ4JMB.js";
 import {
   getPowerState
 } from "./chunk-QWQ6GQTI.js";