@hyperframes/producer 0.8.166 → 0.8.168

package/dist/distributed.js

@@ -876,7 +876,7 @@ function resolveDeviceScaleFactor(input) {
   });
   if (!compat.ok) throw new Error(compat.message);
   const target = CANVAS_DIMENSIONS[input.outputResolution];
-  return target.width / input.compositionWidth;
+  return Math.max(target.width / input.compositionWidth, target.height / input.compositionHeight);
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
   const compileDir = join3(workDir, "compiled");
@@ -3766,10 +3766,10 @@ async function runCompileStage(input) {
     hdrRequested: job.config.hdrMode === "force-hdr",
     alphaRequested: needsAlpha
   });
-  const outputWidth = width * deviceScaleFactor;
-  const outputHeight = height * deviceScaleFactor;
-  if (deviceScaleFactor > 1) {
-    log.info("Supersampling composition via deviceScaleFactor", {
+  const outputWidth = Math.round(width * deviceScaleFactor);
+  const outputHeight = Math.round(height * deviceScaleFactor);
+  if (deviceScaleFactor !== 1) {
+    log.info("Scaling composition via deviceScaleFactor", {
       compositionWidth: width,
       compositionHeight: height,
       outputResolution: effectiveResolution,
@@ -6450,6 +6450,7 @@ function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILI
 
 // src/services/render/stages/planHash.ts
 import { createHash as createHash4 } from "node:crypto";
+import { closeSync as closeSync3, createReadStream as createReadStream3, openSync as openSync3, readSync } from "node:fs";
 var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
 var FIELD_DELIMITER = Buffer.from([0]);
 function computePlanHash(input) {
@@ -6504,6 +6505,28 @@ function sha256Hex(bytes) {
   h.update(bytes);
   return h.digest("hex");
 }
+function sha256File(path) {
+  const hash = createHash4("sha256");
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  const fd = openSync3(path, "r");
+  try {
+    let bytesRead = 0;
+    do {
+      bytesRead = readSync(fd, buffer, 0, buffer.byteLength, null);
+      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
+    } while (bytesRead > 0);
+  } finally {
+    closeSync3(fd);
+  }
+  return hash.digest("hex");
+}
+async function sha256FileAsync(path) {
+  const hash = createHash4("sha256");
+  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
 
 // src/services/render/stages/freezePlan.ts
 var COMPILED_INDEX_RELATIVE_PATH = "compiled/index.html";
@@ -6512,6 +6535,20 @@ var HASH_EXCLUDED_PLAN_FILES = /* @__PURE__ */ new Set([
   "meta/encoder.json",
   COMPILED_INDEX_RELATIVE_PATH
 ]);
+function planFileSha256(absolutePath, digests) {
+  let sha256 = digests?.get(absolutePath);
+  if (sha256 === void 0) {
+    sha256 = sha256File(absolutePath);
+    digests?.set(absolutePath, sha256);
+  }
+  return sha256;
+}
+async function prehashPlanFiles(dir, digests) {
+  if (!existsSync11(dir)) return;
+  for (const { absolutePath } of listPlanFiles(dir)) {
+    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
+  }
+}
 function stripUndefined(value) {
   if (Array.isArray(value)) return value.map(stripUndefined);
   if (value !== null && typeof value === "object") {
@@ -6547,7 +6584,7 @@ function listPlanFiles(planDir) {
   results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
   return results;
 }
-function collectPlanAssetShas(planDir) {
+function collectPlanAssetShas(planDir, digests) {
   const files = listPlanFiles(planDir);
   let compositionHtml = null;
   const assets = [];
@@ -6557,8 +6594,10 @@ function collectPlanAssetShas(planDir) {
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
-    const bytes = readFileSync7(file.absolutePath);
-    assets.push({ path: file.planRelativePath, sha256: sha256Hex(bytes) });
+    assets.push({
+      path: file.planRelativePath,
+      sha256: planFileSha256(file.absolutePath, digests)
+    });
   }
   if (compositionHtml === null) {
     throw new Error(
@@ -6567,7 +6606,7 @@ function collectPlanAssetShas(planDir) {
   }
   return { compositionHtml, assets };
 }
-function recomputePlanHashFromPlanDir(planDir) {
+function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join15(planDir, "plan.json");
   const encoderJsonPath = join15(planDir, "meta", "encoder.json");
   if (!existsSync11(planJsonPath)) {
@@ -6578,7 +6617,7 @@ function recomputePlanHashFromPlanDir(planDir) {
   }
   const planJson = JSON.parse(readFileSync7(planJsonPath, "utf-8"));
   const encoderConfigCanonicalJson = readFileSync7(encoderJsonPath, "utf-8");
-  const { compositionHtml, assets } = collectPlanAssetShas(planDir);
+  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   return computePlanHash({
     compositionHtml,
     assets,
@@ -6600,7 +6639,8 @@ async function freezePlan(input) {
     fontSnapshotSha,
     durationSeconds,
     totalFrames,
-    hasAudio
+    hasAudio,
+    digests
   } = input;
   if (!existsSync11(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
@@ -6618,7 +6658,7 @@ async function freezePlan(input) {
   writeFileSync4(join15(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
   writeFileSync4(join15(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
-  const { compositionHtml, assets } = collectPlanAssetShas(planDir);
+  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
     compositionHtml,
     assets,
@@ -7108,6 +7148,9 @@ function measurePlanSizeBreakdown(rootDir, rootKind = "plan") {
 }
 
 // src/services/distributed/plan.ts
+function logPlanStage(log, stage, startedAt) {
+  log.info("[plan] stage", { stage, ms: Date.now() - startedAt });
+}
 function applyDistributedAudioWarningPolicy(job, audioError, audioFailures = [], log = defaultLogger) {
   const failureOwner = audioFailures.length === 0 ? void 0 : audioFailures.some((failure) => failure.owner === "system") ? "system" : "user";
   const retryable = audioFailures.length === 0 ? void 0 : audioFailures.every((failure) => failure.retryable);
@@ -7143,6 +7186,58 @@ var PLAN_PROJECT_DIR_SKIP_SEGMENTS = /* @__PURE__ */ new Set([
 var DEFAULT_CHUNK_SIZE = 240;
 var DEFAULT_MAX_PARALLEL_CHUNKS = 16;
 var MIN_CHUNK_SIZE = 10;
+var MAX_PARALLEL_CHUNKS_CEILING = 256;
+var ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME = 0.11;
+var ESTIMATED_CHUNK_OVERHEAD_SECONDS = 60;
+var WORKER_TIMEOUT_MARGIN = 0.75;
+function estimateChunkSeconds(frames, megapixels) {
+  return ESTIMATED_CHUNK_OVERHEAD_SECONDS + frames * ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
+}
+var CHUNK_EXCEEDS_WORKER_TIMEOUT = "CHUNK_EXCEEDS_WORKER_TIMEOUT";
+var ChunkExceedsWorkerTimeoutError = class extends Error {
+  // fallow-ignore-next-line unused-class-member
+  code = CHUNK_EXCEEDS_WORKER_TIMEOUT;
+  constructor(predictedChunkSeconds, workerTimeoutSeconds) {
+    super(
+      `[plan] each chunk is predicted to take about ${predictedChunkSeconds} s even split ${MAX_PARALLEL_CHUNKS_CEILING} ways, over the ${workerTimeoutSeconds * WORKER_TIMEOUT_MARGIN} s budget (${WORKER_TIMEOUT_MARGIN * 100}% of the ${workerTimeoutSeconds} s worker time limit) (${CHUNK_EXCEEDS_WORKER_TIMEOUT}). Shorten the video or lower its resolution, raise the worker time limit, or pass an explicit chunkSize or maxParallelChunks to override the estimate.`
+    );
+    this.name = "ChunkExceedsWorkerTimeoutError";
+  }
+};
+function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger) {
+  if (config.maxParallelChunks !== void 0) return config.maxParallelChunks;
+  const { workerTimeoutSeconds, workerConcurrency } = config;
+  const pinsChunking = config.chunkSize !== void 0 || config.targetChunkFrames !== void 0;
+  if (pinsChunking || workerTimeoutSeconds === void 0 && workerConcurrency === void 0) {
+    return DEFAULT_MAX_PARALLEL_CHUNKS;
+  }
+  const secondsPerFrame = ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
+  const wave = Math.min(
+    workerConcurrency ?? DEFAULT_MAX_PARALLEL_CHUNKS,
+    MAX_PARALLEL_CHUNKS_CEILING
+  );
+  const minFramesPerChunk = Math.ceil(ESTIMATED_CHUNK_OVERHEAD_SECONDS / secondsPerFrame);
+  const wide = Math.max(1, Math.min(wave, Math.floor(totalFrames / minFramesPerChunk)));
+  if (workerTimeoutSeconds === void 0) return wide;
+  const maxFramesPerChunk = Math.floor(
+    (workerTimeoutSeconds * WORKER_TIMEOUT_MARGIN - ESTIMATED_CHUNK_OVERHEAD_SECONDS) / secondsPerFrame
+  );
+  const needed = maxFramesPerChunk < 1 ? Infinity : Math.ceil(totalFrames / maxFramesPerChunk);
+  if (needed > MAX_PARALLEL_CHUNKS_CEILING) {
+    const framesAtCeiling = Math.ceil(totalFrames / MAX_PARALLEL_CHUNKS_CEILING);
+    throw new ChunkExceedsWorkerTimeoutError(
+      Math.ceil(estimateChunkSeconds(framesAtCeiling, megapixels)),
+      workerTimeoutSeconds
+    );
+  }
+  if (needed > wave) {
+    log.warn(
+      `[plan] ${needed} chunks are needed to keep each under the ${workerTimeoutSeconds} s worker time limit, but the plan assumes ${wave} workers at once, so the render runs in ${Math.ceil(needed / wave)} waves. Raise --concurrency to ${needed} to render in one wave (Lambda: hyperframes lambda deploy --concurrency ${needed}).`,
+      { needed, workerConcurrency: wave, workerTimeoutSeconds }
+    );
+  }
+  return Math.max(wide, needed);
+}
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var PLAN_TOO_LARGE = "PLAN_TOO_LARGE";
 var PlanTooLargeError = class extends Error {
@@ -7435,6 +7530,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   mkdirSync8(workDir, { recursive: true });
   const compiledDir = join18(workDir, "compiled");
   mkdirSync8(compiledDir, { recursive: true });
+  let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
     recursive: true,
     dereference: true,
@@ -7445,8 +7541,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       return firstSegment === void 0 || !PLAN_PROJECT_DIR_SKIP_SEGMENTS.has(firstSegment);
     }
   });
+  logPlanStage(log, "copy", stageStarted);
   const finalCompiledDir = join18(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
+  stageStarted = Date.now();
   const compileResult = await runCompileStage({
     projectDir,
     workDir,
@@ -7466,6 +7564,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     allowSystemFontCapture: false,
     variables: config.variables
   });
+  logPlanStage(log, "compile", stageStarted);
   let compiled = compileResult.compiled;
   const composition = compileResult.composition;
   const { deviceScaleFactor } = compileResult;
@@ -7475,6 +7574,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (config.rejectOnSystemFonts !== false) {
     validateNoSystemFonts(compiled.html);
   }
+  stageStarted = Date.now();
   const probeResult = await runProbeStage({
     projectDir,
     workDir,
@@ -7492,6 +7592,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     deviceScaleFactor,
     subTimelineWaitMemo: {}
   });
+  logPlanStage(log, "probe", stageStarted);
   compiled = probeResult.compiled;
   job.duration = probeResult.duration;
   job.totalFrames = probeResult.totalFrames;
@@ -7512,6 +7613,19 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       });
     }
   }
+  const maxParallel = resolveMaxParallelChunks(
+    config,
+    totalFrames,
+    compileResult.outputWidth * compileResult.outputHeight / 1e6,
+    log
+  );
+  const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
+    totalFrames,
+    config.chunkSize,
+    maxParallel,
+    config.targetChunkFrames
+  );
+  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
   assertPlanSizeWithinLimit({
     rootDir: compiledDir,
     rootKind: "compiled",
@@ -7519,6 +7633,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     observedAt: "pre-extract",
     log
   });
+  stageStarted = Date.now();
   const extractResult = await runExtractVideosStage({
     projectDir,
     compiledDir,
@@ -7530,29 +7645,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     materializeSymlinks: true,
     deferRangeExtraction: options.deferVideoExtraction
   });
+  logPlanStage(log, "extract", stageStarted);
   if (extractResult.failureToEnforce) throw extractResult.failureToEnforce;
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
   }
-  const audioResult = await runAudioStage({
-    projectDir,
-    workDir,
-    compiledDir,
-    duration: job.duration,
-    ffmpegProcessTimeout: cfg.ffmpegProcessTimeout,
-    audioGain: cfg.audioGain,
-    audios: composition.audios,
-    masterFxChain: composition.masterFxChain,
-    abortSignal,
-    assertNotAborted
-  });
-  if (audioResult.audioError) {
-    applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
-  }
   const stagedVideoFrames = join18(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join18(planDir, "video-frames");
   if (existsSync13(videoFramesDst)) rmSync7(videoFramesDst, { recursive: true, force: true });
-  rmSync7(join18(planDir, "video-sources"), { recursive: true, force: true });
+  const videoSourcesDir = join18(planDir, "video-sources");
+  rmSync7(videoSourcesDir, { recursive: true, force: true });
   if (existsSync13(stagedVideoFrames)) {
     renameSync3(stagedVideoFrames, videoFramesDst);
   } else {
@@ -7585,18 +7687,43 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
+  const digests = options.digests ?? /* @__PURE__ */ new Map();
+  stageStarted = Date.now();
+  const [audioOutcome, overlapOutcome] = await Promise.allSettled([
+    runAudioStage({
+      projectDir,
+      workDir,
+      compiledDir: finalCompiledDir,
+      duration: probeResult.duration,
+      ffmpegProcessTimeout: cfg.ffmpegProcessTimeout,
+      audioGain: cfg.audioGain,
+      audios: composition.audios,
+      masterFxChain: composition.masterFxChain,
+      abortSignal,
+      assertNotAborted
+    }).finally(() => logPlanStage(log, "audio", stageStarted)),
+    (async () => {
+      for (const dir of [finalCompiledDir, videoFramesDst, videoSourcesDir]) {
+        await prehashPlanFiles(dir, digests);
+      }
+      logPlanStage(log, "prehash", stageStarted);
+      if (options.whileAudioMixes) {
+        const prepublishStarted = Date.now();
+        await options.whileAudioMixes();
+        logPlanStage(log, "prepublish", prepublishStarted);
+      }
+    })()
+  ]);
+  if (audioOutcome.status === "rejected") throw audioOutcome.reason;
+  if (overlapOutcome.status === "rejected") throw overlapOutcome.reason;
+  const audioResult = audioOutcome.value;
+  if (audioResult.audioError) {
+    applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
+  }
   const planAudioPath = join18(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult.hasAudio && existsSync13(audioResult.audioOutputPath)) {
     renameSync3(audioResult.audioOutputPath, planAudioPath);
   }
-  const maxParallel = config.maxParallelChunks ?? DEFAULT_MAX_PARALLEL_CHUNKS;
-  const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
-    totalFrames,
-    config.chunkSize,
-    maxParallel,
-    config.targetChunkFrames
-  );
-  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
   const ffmpegVersion = await readFfmpegVersion();
   const producerVersion = readProducerVersion();
   const fontSnapshotSha = await readFontSnapshotSha();
@@ -7643,6 +7770,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     observedAt: "pre-freeze",
     log
   });
+  stageStarted = Date.now();
   const freezeResult = await freezePlan({
     planDir,
     composition: compositionJson,
@@ -7653,8 +7781,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     fontSnapshotSha,
     durationSeconds: job.duration ?? 0,
     totalFrames,
-    hasAudio: audioResult.hasAudio
+    hasAudio: audioResult.hasAudio,
+    digests
   });
+  logPlanStage(log, "freeze", stageStarted);
   const planHash = freezeResult.planHash;
   assertPlanSizeWithinLimit({
     rootDir: planDir,
@@ -7695,24 +7825,21 @@ async function plan(projectDir, config, planDir) {
 
 // src/services/distributed/planV2.ts
 import {
-  closeSync as closeSync3,
   copyFileSync as copyFileSync7,
   existsSync as existsSync15,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync4,
-  openSync as openSync3,
   readFileSync as readFileSync9,
-  readSync,
   readdirSync as readdirSync6,
   renameSync as renameSync5,
   rmSync as rmSync9,
   statSync as statSync6,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { createHash as createHash6 } from "node:crypto";
 import { tmpdir } from "node:os";
 import { dirname as dirname10, isAbsolute as isAbsolute4, join as join21, relative as relative6, resolve as resolve8, sep as sep3 } from "node:path";
+import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
 import { createFrameLookupTable as createFrameLookupTable2 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
@@ -7891,21 +8018,6 @@ function listFiles(root) {
   walk(rootResolved);
   return files.sort((a, b) => a.path.localeCompare(b.path));
 }
-function sha256File(path) {
-  const hash = createHash6("sha256");
-  const buffer = Buffer.allocUnsafe(1024 * 1024);
-  const fd = openSync3(path, "r");
-  try {
-    let bytesRead = 0;
-    do {
-      bytesRead = readSync(fd, buffer, 0, buffer.byteLength, null);
-      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
-    } while (bytesRead > 0);
-  } finally {
-    closeSync3(fd);
-  }
-  return hash.digest("hex");
-}
 function assertValidExtractionCacheCompleteSentinel(path) {
   const sentinel = lstatSync2(path);
   if (!sentinel.isFile() || sentinel.size !== 0) {
@@ -8108,7 +8220,31 @@ function writeBlob(sourcePath, destinationPath) {
     rmSync9(temporaryDir, { recursive: true, force: true });
   }
 }
-function buildPlanV2Publication(executionPlanDir) {
+function publishBlobFor(absolutePath, digests) {
+  return {
+    sourcePath: absolutePath,
+    sha256: planFileSha256(absolutePath, digests),
+    sizeBytes: statSync6(absolutePath).size
+  };
+}
+async function putBlobs(publisher, blobs) {
+  const uploadSlots = 32;
+  let next = 0;
+  let failure;
+  const upload = async () => {
+    while (!failure && next < blobs.length) {
+      const blob = blobs[next++];
+      try {
+        await publisher.putBlob(blob);
+      } catch (reason) {
+        failure ??= { reason };
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: uploadSlots }, upload));
+  if (failure) throw failure.reason;
+}
+function buildPlanV2Publication(executionPlanDir, digests) {
   const executionPlanPath = join21(executionPlanDir, "plan.json");
   if (!existsSync15(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
@@ -8123,7 +8259,7 @@ function buildPlanV2Publication(executionPlanDir) {
   if (!isSha256(executionPlanHash)) {
     throw new PlanV2IntegrityError("execution plan.json.planHash must be a sha256 digest");
   }
-  const recomputedExecutionPlanHash = recomputePlanHashFromPlanDir(executionPlanDir);
+  const recomputedExecutionPlanHash = recomputePlanHashFromPlanDir(executionPlanDir, digests);
   if (recomputedExecutionPlanHash !== executionPlanHash) {
     throw new PlanV2IntegrityError(
       `execution plan content fingerprint does not match plan.json.planHash: expected ${executionPlanHash}, recomputed ${recomputedExecutionPlanHash}`
@@ -8143,15 +8279,12 @@ function buildPlanV2Publication(executionPlanDir) {
     if ((file.path.startsWith("video-frames/") || file.path.startsWith("video-sources/")) && targets.chunks !== "all" && targets.chunks.length === 0 && !targets.assembler) {
       continue;
     }
-    const sha256 = sha256File(file.absolutePath);
-    const sizeBytes = statSync6(file.absolutePath).size;
-    if (!blobs.has(sha256)) {
-      blobs.set(sha256, { sourcePath: file.absolutePath, sha256, sizeBytes });
-    }
+    const blob = publishBlobFor(file.absolutePath, digests);
+    if (!blobs.has(blob.sha256)) blobs.set(blob.sha256, blob);
     artifacts.push({
       path: file.path,
-      sha256,
-      sizeBytes,
+      sha256: blob.sha256,
+      sizeBytes: blob.sizeBytes,
       ...targets
     });
   }
@@ -8206,24 +8339,19 @@ function createPlanV2FromV1(executionPlanDir, planV2Dir) {
   return createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir);
 }
 async function publishPlanV2FromExecutionPlan(executionPlanDir, publisher) {
+  return publishExecutionPlan(executionPlanDir, publisher, {});
+}
+async function publishExecutionPlan(executionPlanDir, publisher, { digests, log = defaultLogger }) {
   try {
-    const publication = buildPlanV2Publication(executionPlanDir);
-    const uploadSlots = 32;
-    let next = 0;
-    let failure;
-    const upload = async () => {
-      while (!failure && next < publication.blobs.length) {
-        const blob = publication.blobs[next++];
-        try {
-          await publisher.putBlob(blob);
-        } catch (reason) {
-          failure ??= { reason };
-        }
-      }
-    };
-    await Promise.all(Array.from({ length: uploadSlots }, upload));
-    if (failure) throw failure.reason;
+    let stageStarted = Date.now();
+    const publication = buildPlanV2Publication(executionPlanDir, digests);
+    logPlanStage(log, "publication", stageStarted);
+    stageStarted = Date.now();
+    await putBlobs(publisher, publication.blobs);
+    logPlanStage(log, "upload", stageStarted);
+    stageStarted = Date.now();
     await publisher.commitManifest(canonicalJsonStringify(publication.manifest));
+    logPlanStage(log, "manifest", stageStarted);
     return publication.manifest;
   } catch (error) {
     try {
@@ -8238,12 +8366,21 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
   const stagingRoot = mkdtempSync4(join21(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
+  const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
       executionPlanSizeLimitBytes: Number.MAX_SAFE_INTEGER,
-      deferVideoExtraction: true
+      deferVideoExtraction: true,
+      digests,
+      // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
+      whileAudioMixes: () => putBlobs(
+        publisher,
+        listFiles(join21(stagingRoot, "compiled")).map(
+          (file) => publishBlobFor(file.absolutePath, digests)
+        )
+      )
     });
-    return await publishPlanV2FromExecutionPlan(stagingRoot, publisher);
+    return await publishExecutionPlan(stagingRoot, publisher, { digests, log: config.logger });
   } catch (error) {
     try {
       await publisher.abort();
@@ -8304,8 +8441,10 @@ function readNonNegativeInteger2(value, field) {
   return value;
 }
 function readSupportedFps(value) {
-  if (value !== 24 && value !== 30 && value !== 60) {
-    throw new PlanV2IntegrityError("dimensions.fpsNum must be 24, 30, or 60");
+  if (!isDistributedFps(value)) {
+    throw new PlanV2IntegrityError(
+      `dimensions.fpsNum must be one of ${DISTRIBUTED_FPS.join(", ")}`
+    );
   }
   return value;
 }
@@ -8518,6 +8657,7 @@ import {
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync10,
   readdirSync as readdirSync7,
+  renameSync as renameSync6,
   rmSync as rmSync10,
   statSync as statSync7,
   writeFileSync as writeFileSync8
@@ -8525,7 +8665,6 @@ import {
 import { dirname as dirname11, join as join22 } from "node:path";
 import {
   appendRenderProvenanceArgs,
-  applyFaststart as applyFaststart2,
   describeFfmpegFailure as describeFfmpegFailure2,
   getEncoderPreset as getEncoderPreset5,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
@@ -8544,9 +8683,64 @@ function cfrRateControlArgs(locked) {
 async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   const start = Date.now();
   const log = options?.logger ?? defaultLogger;
-  const abortSignal = options?.abortSignal;
   const cfr = options?.cfr === true;
-  const { ffmpegProcessTimeout } = resolveConfig4();
+  const plan2 = readAssemblePlan(planDir, chunkPaths);
+  if (plan2.dimensions.format === "png-sequence") {
+    return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
+  }
+  const format = plan2.dimensions.format;
+  const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
+  if (!existsSync16(dirname11(outputPath))) {
+    mkdirSync11(dirname11(outputPath), { recursive: true });
+  }
+  const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
+  const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
+  const stageMs = {};
+  const ctx = {
+    workDir,
+    format,
+    fps,
+    fpsArg: fpsToFfmpegArg3(fps),
+    signal: options?.abortSignal,
+    timeout: resolveConfig4().ffmpegProcessTimeout,
+    log,
+    timed: async (stage, run) => {
+      const stageStart = Date.now();
+      const result = await run();
+      stageMs[stage] = Date.now() - stageStart;
+      return result;
+    }
+  };
+  try {
+    const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
+    const finalPath = join22(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync16(audioPath) ? audioPath : null;
+    await writeJoined(ctx, videoSources, audio, finalPath);
+    renameSync6(finalPath, outputPath);
+    log.info("[assemble] stage timings", {
+      ...stageMs,
+      chunks: chunkPaths.length,
+      totalMs: Date.now() - start
+    });
+  } finally {
+    try {
+      rmSync10(workDir, { recursive: true, force: true });
+    } catch (err) {
+      log.warn("[assemble] failed to remove work dir", {
+        workDir,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const fileSize = existsSync16(outputPath) ? statSync7(outputPath).size : 0;
+  return {
+    outputPath,
+    durationMs: Date.now() - start,
+    framesEncoded: plan2.totalFrames,
+    fileSize
+  };
+}
+function readAssemblePlan(planDir, chunkPaths) {
   const planJsonPath = join22(planDir, "plan.json");
   const chunksJsonPath = join22(planDir, "meta", "chunks.json");
   if (!existsSync16(planJsonPath)) {
@@ -8569,180 +8763,133 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
-  if (plan2.dimensions.format === "png-sequence") {
-    return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
+  return plan2;
+}
+function videoInputArgs(ctx, videoSources) {
+  return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
+}
+async function reencodeCfr(ctx, chunkPaths, encoder) {
+  const cfrOutputPath = join22(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrArgs = [
+    ...videoInputArgs(ctx, chunkPaths),
+    "-c:v",
+    "libx264",
+    ...cfrRateControlArgs(encoder),
+    "-pix_fmt",
+    "yuv420p",
+    "-fps_mode",
+    "cfr",
+    "-r",
+    ctx.fpsArg
+  ];
+  appendRenderProvenanceArgs(cfrArgs, cfrOutputPath);
+  cfrArgs.push("-y", cfrOutputPath);
+  await ctx.timed(
+    "cfrMs",
+    () => runAssembleFfmpeg(cfrArgs, "cfr re-encode", ctx.signal, ctx.timeout)
+  );
+  ctx.log.info("[assemble] cfr re-encode applied", {
+    format: ctx.format,
+    fpsNum: ctx.fps.num,
+    fpsDen: ctx.fps.den
+  });
+  return cfrOutputPath;
+}
+async function writeJoined(ctx, videoSources, audioPath, finalPath) {
+  if (audioPath === null) {
+    const joinArgs = [...videoInputArgs(ctx, videoSources), "-c", "copy"];
+    if (ctx.format === "mp4") joinArgs.push("-movflags", "+faststart");
+    appendRenderProvenanceArgs(joinArgs, finalPath);
+    joinArgs.push("-r", ctx.fpsArg, "-y", finalPath);
+    await ctx.timed(
+      "joinMs",
+      () => runAssembleFfmpeg(joinArgs, "concat-copy", ctx.signal, ctx.timeout)
+    );
+    return;
   }
-  if (!existsSync16(dirname11(outputPath))) {
-    mkdirSync11(dirname11(outputPath), { recursive: true });
+  const paddedAudioPath = join22(ctx.workDir, "audio-padded.m4a");
+  const padTrimResult = await ctx.timed(
+    "audioMs",
+    () => padOrTrimAudioToVideoFrameCount({
+      videoPath: videoSources[0],
+      probeVideoFrameInfo: () => probeJoinedFrameInfo(videoSources, ctx.fps, ctx.signal),
+      audioPath,
+      outputPath: paddedAudioPath,
+      signal: ctx.signal,
+      timeoutMs: ctx.timeout
+    })
+  );
+  if (!padTrimResult.success) {
+    throw encoderFailureError("[assemble] audio pad/trim failed", padTrimResult);
   }
-  const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
-  try {
-    const concatOutputPath = join22(workDir, `concat.${plan2.dimensions.format}`);
-    const fpsArg = fpsToFfmpegArg3({
-      num: plan2.dimensions.fpsNum,
-      den: plan2.dimensions.fpsDen
-    });
-    if (chunkPaths.length === 1) {
-      const remuxArgs = ["-i", chunkPaths[0], "-c", "copy", "-r", fpsArg];
-      appendRenderProvenanceArgs(remuxArgs, concatOutputPath);
-      remuxArgs.push("-y", concatOutputPath);
-      const remuxResult = await runFfmpeg5(remuxArgs, {
-        signal: abortSignal,
-        timeout: ffmpegProcessTimeout
-      });
-      if (!remuxResult.success) {
-        throw encoderFailureError("[assemble] ffmpeg single-chunk remux failed", {
-          error: describeFfmpegFailure2(remuxResult, ffmpegProcessTimeout),
-          failureReason: remuxResult.failureReason
-        });
-      }
-    } else {
-      const concatListPath = join22(workDir, "concat-list.txt");
-      const concatBody = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-      writeFileSync8(concatListPath, `${concatBody}
-`, "utf-8");
-      const concatArgs = [
-        "-r",
-        fpsArg,
-        "-f",
-        "concat",
-        "-safe",
-        "0",
-        "-i",
-        concatListPath,
-        "-c",
-        "copy"
-      ];
-      appendRenderProvenanceArgs(concatArgs, concatOutputPath);
-      concatArgs.push("-y", concatOutputPath);
-      const concatResult = await runFfmpeg5(concatArgs, {
-        signal: abortSignal,
-        timeout: ffmpegProcessTimeout
-      });
-      if (!concatResult.success) {
-        throw encoderFailureError("[assemble] ffmpeg concat-copy failed", {
-          error: describeFfmpegFailure2(concatResult, ffmpegProcessTimeout),
-          failureReason: concatResult.failureReason
-        });
-      }
-    }
-    let postConcatPath = concatOutputPath;
-    if (cfr) {
-      if (plan2.dimensions.format !== "mp4") {
-        throw new Error(
-          `[assemble] cfr=true is only supported for format="mp4" (got "${plan2.dimensions.format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
-        );
-      }
-      const encoderJsonPath = join22(planDir, "meta", "encoder.json");
-      if (!existsSync16(encoderJsonPath)) {
-        throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
-      }
-      const encoderJson = JSON.parse(
-        readFileSync10(encoderJsonPath, "utf-8")
-      );
-      if (encoderJson.encoder === "libx265-software") {
-        throw new Error(
-          `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`
-        );
-      }
-      const cfrOutputPath = join22(workDir, `cfr.${plan2.dimensions.format}`);
-      const cfrArgs = [
-        "-i",
-        concatOutputPath,
-        "-c:v",
-        "libx264",
-        ...cfrRateControlArgs(encoderJson),
-        "-pix_fmt",
-        "yuv420p",
-        "-fps_mode",
-        "cfr",
-        "-r",
-        fpsArg
-      ];
-      appendRenderProvenanceArgs(cfrArgs, cfrOutputPath);
-      cfrArgs.push("-y", cfrOutputPath);
-      const cfrResult = await runFfmpeg5(cfrArgs, {
-        signal: abortSignal,
-        timeout: ffmpegProcessTimeout
-      });
-      if (!cfrResult.success) {
-        throw encoderFailureError("[assemble] ffmpeg cfr re-encode failed", {
-          error: describeFfmpegFailure2(cfrResult, ffmpegProcessTimeout),
-          failureReason: cfrResult.failureReason
-        });
-      }
-      postConcatPath = cfrOutputPath;
-      log.info("[assemble] cfr re-encode applied", {
-        format: plan2.dimensions.format,
-        fpsNum: plan2.dimensions.fpsNum,
-        fpsDen: plan2.dimensions.fpsDen
-      });
-    }
-    let normalizedAudioPath = null;
-    if (audioPath !== null && existsSync16(audioPath)) {
-      const paddedAudioPath = join22(workDir, "audio-padded.m4a");
-      const padTrimResult = await padOrTrimAudioToVideoFrameCount({
-        videoPath: postConcatPath,
-        audioPath,
-        outputPath: paddedAudioPath,
-        signal: abortSignal,
-        timeoutMs: ffmpegProcessTimeout
-      });
-      if (!padTrimResult.success) {
-        throw encoderFailureError("[assemble] audio pad/trim failed", padTrimResult);
-      }
-      normalizedAudioPath = paddedAudioPath;
-      log.info("[assemble] audio normalized for mux", {
-        operation: padTrimResult.operation,
-        targetDurationSeconds: padTrimResult.targetDurationSeconds,
-        sourceDurationSeconds: padTrimResult.sourceDurationSeconds
-      });
-    }
-    const muxOutputPath = normalizedAudioPath !== null ? join22(workDir, `mux.${plan2.dimensions.format}`) : postConcatPath;
-    if (normalizedAudioPath !== null) {
-      const muxResult = await muxVideoWithAudio2(
-        postConcatPath,
-        normalizedAudioPath,
-        muxOutputPath,
-        abortSignal,
-        { audioCodec: "aac", ffmpegProcessTimeout },
-        { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen }
-      );
-      if (!muxResult.success) {
-        throw encoderFailureError("[assemble] audio mux failed", muxResult);
-      }
-    }
-    const faststartResult = await applyFaststart2(
-      muxOutputPath,
-      outputPath,
-      abortSignal,
-      { ffmpegProcessTimeout },
+  ctx.log.info("[assemble] audio normalized for mux", {
+    operation: padTrimResult.operation,
+    targetDurationSeconds: padTrimResult.targetDurationSeconds,
+    sourceDurationSeconds: padTrimResult.sourceDurationSeconds
+  });
+  const muxResult = await ctx.timed(
+    "joinMs",
+    () => muxVideoWithAudio2(
+      videoSources[0],
+      paddedAudioPath,
+      finalPath,
+      ctx.signal,
       {
-        num: plan2.dimensions.fpsNum,
-        den: plan2.dimensions.fpsDen
-      }
-    );
-    if (!faststartResult.success) {
-      throw encoderFailureError("[assemble] faststart failed", faststartResult);
-    }
-  } finally {
-    try {
-      rmSync10(workDir, { recursive: true, force: true });
-    } catch (err) {
-      log.warn("[assemble] failed to remove work dir", {
-        workDir,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
+        audioCodec: "aac",
+        ffmpegProcessTimeout: ctx.timeout,
+        videoInputArgs: videoInputArgs(ctx, videoSources)
+      },
+      ctx.fps
+    )
+  );
+  if (!muxResult.success) {
+    throw encoderFailureError("[assemble] audio mux failed", muxResult);
   }
-  const fileSize = existsSync16(outputPath) ? statSync7(outputPath).size : 0;
+}
+function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
+  const listPath = join22(workDir, "concat-list.txt");
+  const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
+  writeFileSync8(listPath, `${body}
+`, "utf-8");
+  return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
+}
+async function probeJoinedFrameInfo(videoPaths, fps, signal) {
+  const infos = await Promise.all(
+    videoPaths.map((path) => defaultProbeVideoFrameInfo(path, signal))
+  );
   return {
-    outputPath,
-    durationMs: Date.now() - start,
-    framesEncoded: plan2.totalFrames,
-    fileSize
+    frameCount: infos.reduce((sum, info) => sum + info.frameCount, 0),
+    fpsNum: fps.num,
+    fpsDen: fps.den
   };
 }
+async function runAssembleFfmpeg(args, step, signal, timeout) {
+  const result = await runFfmpeg5(args, { signal, timeout });
+  if (!result.success) {
+    throw encoderFailureError(`[assemble] ffmpeg ${step} failed`, {
+      error: describeFfmpegFailure2(result, timeout),
+      failureReason: result.failureReason
+    });
+  }
+}
+function readCfrEncoder(planDir, format) {
+  if (format !== "mp4") {
+    throw new Error(
+      `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
+    );
+  }
+  const encoderJsonPath = join22(planDir, "meta", "encoder.json");
+  if (!existsSync16(encoderJsonPath)) {
+    throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
+  }
+  const encoderJson = JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
+  if (encoderJson.encoder === "libx265-software") {
+    throw new Error(
+      `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`
+    );
+  }
+  return encoderJson;
+}
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
   if (existsSync16(outputPath)) rmSync10(outputPath, { recursive: true, force: true });
   mkdirSync11(outputPath, { recursive: true });
@@ -9372,8 +9519,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         outputPath: outputChunkPath,
         framesDir,
         videoOnlyPath,
-        width: plan2.dimensions.width * encoder.deviceScaleFactor,
-        height: plan2.dimensions.height * encoder.deviceScaleFactor,
+        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
@@ -9510,6 +9657,7 @@ import {
   isVideoFrameFormat,
   validateEngineConfigSnapshot
 } from "@hyperframes/engine";
+import { DISTRIBUTED_FPS as DISTRIBUTED_FPS2, isDistributedFps as isDistributedFps2 } from "@hyperframes/core";
 var InvalidConfigError = class extends Error {
   // Read via Error.prototype.toString; fallow can't see it.
   // fallow-ignore-next-line unused-class-member
@@ -9521,7 +9669,6 @@ var InvalidConfigError = class extends Error {
     this.field = field;
   }
 };
-var ALLOWED_FPS = [24, 30, 60];
 var ALLOWED_FORMATS = [
   "mp4",
   "mov",
@@ -9535,15 +9682,14 @@ var ALLOWED_HDR_MODES = ["auto", "force-sdr"];
 var MAX_DIMENSION = 7680;
 var MIN_DIMENSION = 16;
 var MAX_CHUNK_SIZE = 3600;
-var MAX_PARALLEL_CHUNKS_CEILING = 256;
 function validateDistributedRenderConfig(config) {
   if (config === null || typeof config !== "object") {
     throw new InvalidConfigError("config", "must be an object");
   }
-  if (!ALLOWED_FPS.includes(config.fps)) {
+  if (!isDistributedFps2(config.fps)) {
     throw new InvalidConfigError(
       "config.fps",
-      `must be one of ${ALLOWED_FPS.join(", ")}; got ${String(config.fps)}`
+      `must be one of ${DISTRIBUTED_FPS2.join(", ")}; got ${String(config.fps)}`
     );
   }
   validateIntDimension("config.width", config.width);
@@ -9634,6 +9780,12 @@ function validateDistributedRenderConfig(config) {
       );
     }
   }
+  for (const field of ["workerTimeoutSeconds", "workerConcurrency"]) {
+    const value = config[field];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 1)) {
+      throw new InvalidConfigError(`config.${field}`, `must be a positive integer; got ${value}`);
+    }
+  }
   if (config.runtimeCap !== void 0 && !ALLOWED_RUNTIME_CAPS.includes(config.runtimeCap)) {
     throw new InvalidConfigError(
       "config.runtimeCap",
@@ -9743,10 +9895,10 @@ function validateIntDimension(field, value) {
 
 // src/services/distributed/projectHash.ts
 import { readdirSync as readdirSync9, readFileSync as readFileSync12 } from "node:fs";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { join as join25, relative as relative7 } from "node:path";
 function hashProjectDir(projectDir) {
-  const hash = createHash7("sha256");
+  const hash = createHash6("sha256");
   const files = [];
   function walk(dir, isRoot) {
     for (const entry of readdirSync9(dir, { withFileTypes: true }).sort(
@@ -9768,7 +9920,9 @@ function hashProjectDir(projectDir) {
   return hash.digest("hex").slice(0, 16);
 }
 export {
+  CHUNK_EXCEEDS_WORKER_TIMEOUT,
   CURRENT_PLAN_PROTOCOL,
+  ChunkExceedsWorkerTimeoutError,
   DEFAULT_CHUNK_SIZE,
   DEFAULT_MAX_PARALLEL_CHUNKS,
   DISTRIBUTED_DURATION_OUT_OF_RANGE,