hyperframes 0.6.14 → 0.6.15

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.6.14" : "0.0.0-dev";
+    VERSION = true ? "0.6.15" : "0.0.0-dev";
   }
 });
 
@@ -34012,18 +34012,19 @@ function calculateOptimalWorkers(totalFrames, requested, config) {
   }
   return finalWorkers;
 }
-function distributeFrames(totalFrames, workerCount, workDir) {
+function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
   const tasks = [];
   const framesPerWorker = Math.ceil(totalFrames / workerCount);
   for (let i2 = 0; i2 < workerCount; i2++) {
-    const startFrame = i2 * framesPerWorker;
-    const endFrame = Math.min((i2 + 1) * framesPerWorker, totalFrames);
-    if (startFrame >= totalFrames) break;
+    const startFrame = rangeStart + i2 * framesPerWorker;
+    const endFrame = Math.min(rangeStart + (i2 + 1) * framesPerWorker, rangeStart + totalFrames);
+    if (startFrame >= rangeStart + totalFrames) break;
     tasks.push({
       workerId: i2,
       startFrame,
       endFrame,
-      outputDir: join30(workDir, `worker-${i2}`)
+      outputDir: join30(workDir, `worker-${i2}`),
+      outputFrameOffset: rangeStart
     });
   }
   return tasks;
@@ -34043,16 +34044,18 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
       config
     );
     await initializeSession(session);
+    const outputOffset = task.outputFrameOffset ?? 0;
     for (let i2 = task.startFrame; i2 < task.endFrame; i2++) {
       if (signal?.aborted) {
         throw new Error("Parallel worker cancelled");
       }
       const time = i2 * captureOptions.fps.den / captureOptions.fps.num;
+      const fileFrameIdx = i2 - outputOffset;
       if (onFrameBuffer) {
-        const { buffer } = await captureFrameToBuffer(session, i2, time);
+        const { buffer } = await captureFrameToBuffer(session, fileFrameIdx, time);
         await onFrameBuffer(i2, buffer);
       } else {
-        await captureFrame(session, i2, time);
+        await captureFrame(session, fileFrameIdx, time);
       }
       framesCaptured++;
       if (onFrameCaptured) onFrameCaptured(task.workerId, i2);
@@ -39073,17 +39076,18 @@ async function runCaptureStage(input) {
   let { workerCount, probeSession } = input;
   let lastBrowserConsole = [];
   const captureCfg = cfg.forceScreenshot === forceScreenshot ? cfg : { ...cfg, forceScreenshot };
-  if (frameRange !== void 0 && workerCount > 1) {
-    throw new Error(
-      `[captureStage] frameRange capture requires workerCount === 1 (received workerCount=${workerCount}). Distributed chunk workers fan out at the activity layer; reduce workerCount to 1 when passing frameRange.`
-    );
-  }
   if (frameRange !== void 0) {
     if (!Number.isFinite(frameRange.startFrame) || !Number.isFinite(frameRange.endFrame) || frameRange.startFrame < 0 || frameRange.endFrame <= frameRange.startFrame) {
       throw new Error(
         `[captureStage] invalid frameRange: ${JSON.stringify(frameRange)}. Expected non-negative startFrame strictly less than endFrame.`
       );
     }
+    const rangeFrames = frameRange.endFrame - frameRange.startFrame;
+    if (rangeFrames !== totalFrames) {
+      throw new Error(
+        `[captureStage] frameRange size (${rangeFrames}) must equal totalFrames (${totalFrames}). Received frameRange=${JSON.stringify(frameRange)}.`
+      );
+    }
   }
   if (workerCount > 1) {
     const attempts = await executeDiskCaptureWithAdaptiveRetry({
@@ -39097,6 +39101,7 @@ async function runCaptureStage(input) {
       captureOptions: buildCaptureOptions(),
       createBeforeCaptureHook: createRenderVideoFrameInjector,
       abortSignal,
+      frameRangeStart: frameRange?.startFrame,
       onProgress: (progress) => {
         job.framesRendered = progress.capturedFrames;
         const frameProgress = progress.capturedFrames / progress.totalFrames;
@@ -40986,16 +40991,17 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   }
   return ranges;
 }
-function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt) {
+function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
   for (let i2 = 0; i2 < ranges.length; i2 += workersPerBatch) {
     const batchIndex = batches.length;
     const batch = ranges.slice(i2, i2 + workersPerBatch).map((range, workerId) => ({
       workerId,
-      startFrame: range.startFrame,
-      endFrame: range.endFrame,
-      outputDir: join49(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`)
+      startFrame: rangeStart + range.startFrame,
+      endFrame: rangeStart + range.endFrame,
+      outputDir: join49(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputFrameOffset: rangeStart
     }));
     batches.push(batch);
   }
@@ -41026,6 +41032,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
   let currentWorkers = options.initialWorkerCount;
   let missingRanges = null;
   let attempt = 0;
+  const rangeStart = options.frameRangeStart ?? 0;
   while (true) {
     const frameCount = missingRanges ? countFrameRanges(missingRanges) : options.totalFrames;
     attempts.push({
@@ -41035,7 +41042,13 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : "retry"
     });
     const attemptWorkDir = join49(options.workDir, `capture-attempt-${attempt}`);
-    const batches = missingRanges ? buildMissingFrameRetryBatches(missingRanges, currentWorkers, attemptWorkDir, attempt) : [distributeFrames(options.totalFrames, currentWorkers, attemptWorkDir)];
+    const batches = missingRanges ? buildMissingFrameRetryBatches(
+      missingRanges,
+      currentWorkers,
+      attemptWorkDir,
+      attempt,
+      rangeStart
+    ) : [distributeFrames(options.totalFrames, currentWorkers, attemptWorkDir, rangeStart)];
     try {
       for (const tasks of batches) {
         const capturedBeforeBatch = countCapturedFrames(
@@ -43467,6 +43480,14 @@ async function plan(projectDir, config, planDir) {
     height,
     format: config.format
   };
+  try {
+    rmSync11(workDir, { recursive: true, force: true });
+  } catch (err) {
+    log2.warn("[plan] failed to remove temp work dir", {
+      workDir,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
   const freezeResult = await freezePlan({
     planDir,
     composition: compositionJson,
@@ -43480,14 +43501,6 @@ async function plan(projectDir, config, planDir) {
     hasAudio: audioResult.hasAudio
   });
   const planHash = freezeResult.planHash;
-  try {
-    rmSync11(workDir, { recursive: true, force: true });
-  } catch (err) {
-    log2.warn("[plan] failed to remove temp work dir", {
-      workDir,
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
   const sizeLimitBytes = config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const planDirBytes = measurePlanDirBytes(planDir);
   if (planDirBytes > sizeLimitBytes) {
@@ -43775,6 +43788,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       session = await createCaptureSession(fileServer.url, framesDir, captureOptions, null, cfg);
       await assertSwiftShader(session.page, readWebGlVendorInfoFromCanvas);
       await initializeSession(session);
+      const chunkWorkerCount = calculateOptimalWorkers(framesInChunk, void 0, cfg);
       await runCaptureStage({
         fileServer,
         workDir,
@@ -43784,11 +43798,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         cfg,
         forceScreenshot: encoder.forceScreenshot,
         log: log2,
-        workerCount: 1,
-        // Pass the pre-warmed session through as `probeSession` so captureStage
-        // reuses it via `prepareCaptureSessionForReuse` instead of spinning up
-        // a fresh browser. The stage closes the session in its `finally`,
-        // so we MUST clear our own reference here to avoid a double-close.
+        workerCount: chunkWorkerCount,
+        // The parallel branch closes this session and spins up its own
+        // worker sessions, wasting the ~3-5s of pre-warmed setup. Worth a
+        // follow-up to skip pre-warmup when the resolved workerCount > 1.
         probeSession: session,
         needsAlpha: plan2.dimensions.format !== "mp4",
         captureAttempts: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperframes",
-  "version": "0.6.14",
+  "version": "0.6.15",
   "description": "HyperFrames CLI — create, preview, and render HTML video compositions",
   "repository": {
     "type": "git",