@hyperframes/producer 0.8.196 → 0.8.198

package/README.md

@@ -35,7 +35,7 @@ The producer can also run as a render server, accepting render requests over HTT
 import { startServer } from "@hyperframes/producer";
 
 await startServer({ port: 8080 });
-// POST /render or /render/stream with projectDir, html, or previewUrl and render options
+// POST /render or /render/stream with projectDir, html, or previewUrl (public HTTPS only) and render options
 ```
 
 Both HTTP routes accept optional `pageMotionBlur: "off"` to disable authored page

package/dist/distributed.js

@@ -6909,6 +6909,10 @@ function readVideoMetadata(value, field) {
     hasAudio: readBoolean(record.hasAudio, `${field}.hasAudio`),
     isVFR: readBoolean(record.isVFR, `${field}.isVFR`),
     hasAlpha: readBoolean(record.hasAlpha, `${field}.hasAlpha`),
+    // Optional: plans from producers without the decode probe keep today's png for vp8/vp9.
+    ...record.alphaPlaneDecoded === void 0 ? {} : {
+      alphaPlaneDecoded: readBoolean(record.alphaPlaneDecoded, `${field}.alphaPlaneDecoded`)
+    },
     colorSpace
   };
 }
@@ -7305,6 +7309,70 @@ async function measurePlanSecondsPerFrame(input) {
   }
 }
 
+// src/services/distributed/chunkWeights.ts
+import { resolveFrameFormat } from "@hyperframes/engine";
+var PAGE_BASE_WEIGHT = 0.7;
+var PNG_WEIGHT_FACTOR = 1.5;
+function isUniformFrameCost(weights) {
+  let lightest = Infinity;
+  let heaviest = 0;
+  for (const weight of weights) {
+    lightest = Math.min(lightest, weight);
+    heaviest = Math.max(heaviest, weight);
+  }
+  return heaviest <= lightest * 1.05;
+}
+function planFrameWeights(input) {
+  const { totalFrames, fps } = input;
+  const delta = new Float64Array(totalFrames + 1);
+  const outputPixels = input.width * input.height;
+  const extractedById = new Map(input.extracted.map((entry) => [entry.videoId, entry]));
+  for (const video of input.videos) {
+    const entry = extractedById.get(video.id);
+    if (!entry || video.hidden) continue;
+    const start = Math.max(0, Math.round(video.start * fps));
+    const end = Math.min(totalFrames, Math.round(video.end * fps));
+    if (!(end > start)) continue;
+    const { width, height } = entry.metadata;
+    const factor = resolveFrameFormat(entry.metadata) === "png" ? PNG_WEIGHT_FACTOR : 1;
+    const weight = Math.min(width * height, outputPixels) / 1e6 * factor;
+    delta[start] = delta[start] + weight;
+    delta[end] = delta[end] - weight;
+  }
+  const weights = new Float64Array(totalFrames);
+  let active = 0;
+  for (let frame = 0; frame < totalFrames; frame++) {
+    active += delta[frame];
+    weights[frame] = PAGE_BASE_WEIGHT + active;
+  }
+  return weights;
+}
+function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
+  if (isUniformFrameCost(weights)) return null;
+  const totalFrames = weights.length;
+  const total = weights.reduce((sum2, weight) => sum2 + weight, 0);
+  const minSize = Math.max(1, Math.min(minFrames, Math.floor(totalFrames / chunkCount)));
+  const maxSize = Math.max(maxFrames, Math.ceil(totalFrames / chunkCount));
+  const slices = [];
+  let startFrame = 0;
+  let frame = 0;
+  let costBefore = 0;
+  for (let index = 0; index < chunkCount - 1; index++) {
+    const target = (index + 1) * total / chunkCount;
+    while (frame < totalFrames && costBefore + weights[frame] / 2 < target) {
+      costBefore += weights[frame++];
+    }
+    const remaining = chunkCount - index - 1;
+    const low = Math.max(startFrame + minSize, totalFrames - remaining * maxSize);
+    const high = Math.min(startFrame + maxSize, totalFrames - remaining * minSize);
+    const endFrame = Math.min(high, Math.max(low, frame));
+    slices.push({ index, startFrame, endFrame });
+    startFrame = endFrame;
+  }
+  slices.push({ index: chunkCount - 1, startFrame, endFrame: totalFrames });
+  return slices;
+}
+
 // src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join17, relative as relative3, resolve as resolve7 } from "node:path";
@@ -8420,6 +8488,7 @@ 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_CHUNK_SIZE = 3600;
 var MAX_PARALLEL_CHUNKS_CEILING = 256;
 var ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME = 0.11;
 var ESTIMATED_CHUNK_OVERHEAD_SECONDS = 60;
@@ -8446,6 +8515,11 @@ var ChunkExceedsWorkerTimeoutError = class extends Error {
     this.name = "ChunkExceedsWorkerTimeoutError";
   }
 };
+function framesWithinWorkerTimeout(workerTimeoutSeconds, secondsPerFrame) {
+  return Math.floor(
+    (workerTimeoutSeconds * WORKER_TIMEOUT_MARGIN - ESTIMATED_CHUNK_OVERHEAD_SECONDS) / secondsPerFrame
+  );
+}
 function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger, measuredSecondsPerFrame) {
   if (config.maxParallelChunks !== void 0) return config.maxParallelChunks;
   const { workerTimeoutSeconds, workerConcurrency } = config;
@@ -8458,9 +8532,7 @@ function resolveMaxParallelChunks(config, totalFrames, megapixels, log = default
   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 maxFramesPerChunk = framesWithinWorkerTimeout(workerTimeoutSeconds, 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);
@@ -8592,6 +8664,15 @@ function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
   }
   return slices;
 }
+function buildPlanChunkSlices(frameWeights, config, chunkCount, effectiveChunkSize, maxFramesPerChunk = Infinity) {
+  const weighted = config.chunkSize === void 0 ? buildWeightedChunkSlices(
+    frameWeights,
+    chunkCount,
+    MIN_CHUNK_SIZE,
+    Math.min(config.targetChunkFrames ?? MAX_CHUNK_SIZE, MAX_CHUNK_SIZE, maxFramesPerChunk)
+  ) : null;
+  return weighted ?? buildChunkSlices(frameWeights.length, chunkCount, effectiveChunkSize);
+}
 async function readFontSnapshotSha() {
   const module = await import("@hyperframes/core/fonts/embedded-data");
   const data = module.EMBEDDED_FONT_DATA;
@@ -9041,6 +9122,14 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const digests = options.digests ?? /* @__PURE__ */ new Map();
   const separateAudio = plansSeparateAudio(config, options);
   const chunksCarryAudio = !separateAudio && carriesChunkAudio(config, options);
+  const frameWeights = planFrameWeights({
+    videos: planVideosJson.videos,
+    extracted: planVideosJson.extracted,
+    totalFrames,
+    fps: config.fps,
+    width,
+    height
+  });
   stageStarted = Date.now();
   const [audioOutcome, overlapOutcome, frameCostOutcome] = await Promise.allSettled([
     separateAudio ? null : mixPlanAudio(c, finalCompiledDir).finally(() => logPlanStage(log, "audio", stageStarted)),
@@ -9091,7 +9180,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     maxParallel,
     config.targetChunkFrames
   );
-  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
+  const chunks = buildPlanChunkSlices(
+    frameWeights,
+    config,
+    chunkCount,
+    effectiveChunkSize,
+    chunkSizingUsesFrameCost(config) && config.workerTimeoutSeconds !== void 0 ? framesWithinWorkerTimeout(
+      config.workerTimeoutSeconds,
+      estimateFrameSeconds(megapixels, frameCostOutcome.value)
+    ) : void 0
+  );
   const audioResult = audioOutcome.value;
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
@@ -11143,7 +11241,6 @@ var ALLOWED_RUNTIME_CAPS = ["lambda", "temporal", "cloud-run-job", "k8s-job", "n
 var ALLOWED_HDR_MODES = ["auto", "force-sdr"];
 var MAX_DIMENSION = 7680;
 var MIN_DIMENSION = 16;
-var MAX_CHUNK_SIZE = 3600;
 function validateDistributedRenderConfig(config) {
   if (config === null || typeof config !== "object") {
     throw new InvalidConfigError("config", "must be an object");

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "76ecb9a94777082e1cb85f468f089ade395649a08149ad8a6795fa3ff6062cc8",
+  "sha256": "34e66a8b6f8a0c9e7cb0895fc3e22c3a21b0a6240b0b47fb3fcf1621087b919b",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"