@hyperframes/producer 0.9.20 → 0.9.22

package/dist/distributed.js

@@ -351,7 +351,7 @@ function buildVirtualTimeShim(options) {
     } catch (e) {}
   }
 ` : "";
-  const seekToTimeReseedCall = seedRandomFromFrame ? "reseedRngFromTime(safeTimeMs);\n      " : "";
+  const seekToTimeReseedCall = seedRandomFromFrame ? "reseedRngFromTime(safeTimeMs);\n    " : "";
   return String.raw`(function() {
   if (window.__HF_VIRTUAL_TIME__) return;
 
@@ -430,6 +430,82 @@ ${seededRandomBlock}
     }
   };
 
+  // Timers set once rendering has started run on film time: each seek fires every timer due by then, in
+  // due order. Until a seek after the page reports ready, timers keep the wall clock: setup code waits on
+  // them while the renderer may already be seeking.
+  var rendering = false;
+  var timerQueue = [];
+  var nextTimerId = 1000000000;
+  var firingDepth = 0;
+  function addTimer(callback, delay, args, repeats) {
+    // A timer set from a firing timer waits at least 1 ms, so a zero-delay chain cannot stall a seek.
+    var ms = Math.max(firingDepth > 0 ? 1 : 0, Number(delay) || 0);
+    var entry = { id: nextTimerId++, callback: callback, args: args, due: virtualNowMs + ms, every: repeats ? Math.max(1, ms) : 0, cancelled: false };
+    timerQueue.push(entry);
+    return entry.id;
+  }
+  function cancelTimer(id) {
+    for (var i = 0; i < timerQueue.length; i++) {
+      if (timerQueue[i].id === id) {
+        timerQueue[i].cancelled = true;
+        return true;
+      }
+    }
+    return false;
+  }
+  function fireDueTimers(untilMs) {
+    // Frame times are fractional, so a timer due on a frame lands a rounding error past it; it still fires on it.
+    untilMs += 0.000001;
+    while (true) {
+      var next = null;
+      for (var i = 0; i < timerQueue.length; i++) {
+        var candidate = timerQueue[i];
+        if (!candidate.cancelled && candidate.due <= untilMs && (next === null || candidate.due < next.due)) next = candidate;
+      }
+      if (next === null) break;
+      var dueMs = next.due;
+      if (next.every) next.due += next.every;
+      else next.cancelled = true;
+      virtualNowMs = dueMs;
+      firingDepth++;
+      try {
+        next.callback.apply(window, next.args);
+      } catch (err) {
+        originalSetTimeout(function() { throw err; }, 0);
+      }
+      firingDepth--;
+    }
+    timerQueue = timerQueue.filter(function(entry) { return !entry.cancelled; });
+  }
+  window.setTimeout = function(callback, delay) {
+    if (!rendering || typeof callback !== "function") return originalSetTimeout.apply(null, arguments);
+    return addTimer(callback, delay, Array.prototype.slice.call(arguments, 2), false);
+  };
+  window.setInterval = function(callback, delay) {
+    if (!rendering || typeof callback !== "function") return originalSetInterval.apply(null, arguments);
+    return addTimer(callback, delay, Array.prototype.slice.call(arguments, 2), true);
+  };
+  window.clearTimeout = function(id) {
+    if (!cancelTimer(id)) originalClearTimeout(id);
+  };
+  window.clearInterval = function(id) {
+    if (!cancelTimer(id)) originalClearInterval(id);
+  };
+
+  function seekToTime(nextTimeMs) {
+    var safeTimeMs = Math.max(0, Number(nextTimeMs) || 0);
+    if (!rendering && window.__renderReady === true) {
+      rendering = true;
+      // A worker whose first frame is past the start plays the film's first frame first, so timers the
+      // page starts there keep the schedule a one-worker render gives them.
+      if (safeTimeMs > 0) seekToTime(0);
+    }
+    ${seekToTimeReseedCall}fireDueTimers(safeTimeMs);
+    virtualNowMs = safeTimeMs;
+    flushAnimationFrame();
+    return virtualNowMs;
+  }
+
   window.__HF_VIRTUAL_TIME__ = {
     originalSetTimeout: originalSetTimeout,
     originalClearTimeout: originalClearTimeout,
@@ -437,12 +513,7 @@ ${seededRandomBlock}
     originalClearInterval: originalClearInterval,
     originalRequestAnimationFrame: originalRequestAnimationFrame,
     originalCancelAnimationFrame: originalCancelAnimationFrame,
-    seekToTime: function(nextTimeMs) {
-      var safeTimeMs = Math.max(0, Number(nextTimeMs) || 0);
-      virtualNowMs = safeTimeMs;
-      ${seekToTimeReseedCall}flushAnimationFrame();
-      return virtualNowMs;
-    },
+    seekToTime: seekToTime,
     getTime: function() {
       return virtualNowMs;
     },
@@ -8372,13 +8443,14 @@ var RenderChunkValidationError = class extends Error {
     this.code = code;
   }
 };
+var chunkFrameInjectorDependencies = { createVideoFrameInjector: createVideoFrameInjector3 };
 function createChunkVideoFrameInjectorFactory(frameLookup, options) {
   if (!(frameLookup instanceof Promise))
-    return () => createVideoFrameInjector3(frameLookup, options);
+    return () => chunkFrameInjectorDependencies.createVideoFrameInjector(frameLookup, options);
   return () => {
     let hook;
     return async (page, time, heldVideoTime) => {
-      hook ??= createVideoFrameInjector3(await frameLookup, options);
+      hook ??= chunkFrameInjectorDependencies.createVideoFrameInjector(await frameLookup, options);
       await hook?.(page, time, heldVideoTime);
     };
   };
@@ -9939,7 +10011,7 @@ function assertPlanSizeWithinLimit(input) {
   });
   throw new PlanTooLargeError(breakdown.totalBytes, input.limitBytes, breakdown, input.observedAt);
 }
-function resolveChunkPlan(totalFrames, configChunkSize, maxParallelChunks, targetChunkFrames) {
+function resolveChunkPlan(totalFrames, configChunkSize, maxParallelChunks, targetChunkFrames, minParallelChunks = 1) {
   assertPositiveInteger("totalFrames", totalFrames);
   assertPositiveInteger("maxParallelChunks", maxParallelChunks);
   if (configChunkSize !== void 0) {
@@ -9948,7 +10020,11 @@ function resolveChunkPlan(totalFrames, configChunkSize, maxParallelChunks, targe
   if (targetChunkFrames !== void 0) {
     assertPositiveInteger("targetChunkFrames", targetChunkFrames);
   }
-  const autoSizeParallel = targetChunkFrames === void 0 ? maxParallelChunks : Math.min(maxParallelChunks, Math.max(1, Math.ceil(totalFrames / targetChunkFrames)));
+  assertPositiveInteger("minParallelChunks", minParallelChunks);
+  const autoSizeParallel = targetChunkFrames === void 0 ? maxParallelChunks : Math.min(
+    maxParallelChunks,
+    Math.max(minParallelChunks, Math.ceil(totalFrames / targetChunkFrames))
+  );
   const resolvedChunkSize = configChunkSize ?? Math.max(MIN_CHUNK_SIZE, Math.ceil(totalFrames / autoSizeParallel));
   const naiveCount = Math.ceil(totalFrames / resolvedChunkSize);
   const chunkCount = Math.min(maxParallelChunks, Math.max(1, naiveCount));
@@ -10527,7 +10603,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     totalFrames,
     config.chunkSize,
     maxParallel,
-    config.targetChunkFrames
+    config.targetChunkFrames,
+    config.minParallelChunks
   );
   const chunks = buildPlanChunkSlices(
     frameWeights,
@@ -12803,6 +12880,20 @@ function validateDistributedRenderConfig(config) {
       );
     }
   }
+  if (config.minParallelChunks !== void 0) {
+    if (!Number.isInteger(config.minParallelChunks) || config.minParallelChunks < 1) {
+      throw new InvalidConfigError(
+        "config.minParallelChunks",
+        `must be a positive integer; got ${config.minParallelChunks}`
+      );
+    }
+    if (config.minParallelChunks > MAX_PARALLEL_CHUNKS_CEILING) {
+      throw new InvalidConfigError(
+        "config.minParallelChunks",
+        `must be <= ${MAX_PARALLEL_CHUNKS_CEILING}; got ${config.minParallelChunks}`
+      );
+    }
+  }
   for (const field of ["workerTimeoutSeconds", "workerConcurrency"]) {
     const value = config[field];
     if (value !== void 0 && (!Number.isInteger(value) || value < 1)) {

package/dist/hyperframe.manifest.json

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