@hyperframes/producer 0.8.197 → 0.8.198

package/dist/index.js

@@ -14571,6 +14571,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 existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join29, relative as relative3, resolve as resolve8 } from "node:path";
@@ -15685,6 +15749,7 @@ var PLAN_PROJECT_DIR_SKIP_SEGMENTS = /* @__PURE__ */ new Set([
 ]);
 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;
@@ -15711,6 +15776,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;
@@ -15723,9 +15793,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);
@@ -15854,6 +15922,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;
@@ -16303,6 +16380,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)),
@@ -16353,7 +16438,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);
@@ -16499,7 +16593,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");
@@ -16992,6 +17085,7 @@ import crypto from "node:crypto";
 import { Hono as Hono2 } from "hono";
 import { streamSSE } from "hono/streaming";
 import { serve as serve2 } from "@hono/node-server";
+import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engine";
 
 // src/services/hyperframeLint.ts
 import {
@@ -17374,6 +17468,7 @@ function validateOutputResolutionOverride(body) {
   }
   return void 0;
 }
+var MAX_PREVIEW_HTML_BYTES = 20 * 1024 * 1024;
 function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
@@ -17394,11 +17489,7 @@ async function resolveInlineRenderHtml(body) {
   if (!previewUrl)
     return { error: "Missing render source: provide projectDir, previewUrl, or html" };
   try {
-    const response = await fetch(previewUrl, { method: "GET" });
-    if (!response.ok) {
-      return { error: `Failed to fetch previewUrl: ${response.status} ${response.statusText}` };
-    }
-    return { html: await response.text() };
+    return { html: await fetchPublicHttpsText2(previewUrl, { maxBytes: MAX_PREVIEW_HTML_BYTES }) };
   } catch (error) {
     return {
       error: `Failed to fetch previewUrl: ${error instanceof Error ? error.message : String(error)}`

package/dist/public-server.js

@@ -17,6 +17,7 @@ import crypto from "node:crypto";
 import { Hono as Hono2 } from "hono";
 import { streamSSE } from "hono/streaming";
 import { serve as serve2 } from "@hono/node-server";
+import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engine";
 
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
@@ -14233,6 +14234,9 @@ import {
 var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME3;
 var execFile = promisify2(execFileCallback);
 
+// src/services/distributed/chunkWeights.ts
+import { resolveFrameFormat } from "@hyperframes/engine";
+
 // src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
 var PLAN_ARTIFACT_LAYOUT = "plan-dir-v1";
@@ -14689,6 +14693,7 @@ function validateOutputResolutionOverride(body) {
   }
   return void 0;
 }
+var MAX_PREVIEW_HTML_BYTES = 20 * 1024 * 1024;
 function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
@@ -14709,11 +14714,7 @@ async function resolveInlineRenderHtml(body) {
   if (!previewUrl)
     return { error: "Missing render source: provide projectDir, previewUrl, or html" };
   try {
-    const response = await fetch(previewUrl, { method: "GET" });
-    if (!response.ok) {
-      return { error: `Failed to fetch previewUrl: ${response.status} ${response.statusText}` };
-    }
-    return { html: await response.text() };
+    return { html: await fetchPublicHttpsText2(previewUrl, { maxBytes: MAX_PREVIEW_HTML_BYTES }) };
   } catch (error) {
     return {
       error: `Failed to fetch previewUrl: ${error instanceof Error ? error.message : String(error)}`

package/dist/services/distributed/chunkWeights.d.ts

@@ -0,0 +1,16 @@
+import type { ChunkSliceJson } from "../render/stages/freezePlan.js";
+import type { PlanVideosJson } from "./shared.js";
+/** Estimated capture cost of every frame: page base plus each active video's pixels. */
+export declare function planFrameWeights(input: {
+    videos: PlanVideosJson["videos"];
+    extracted: PlanVideosJson["extracted"];
+    totalFrames: number;
+    fps: number;
+    width: number;
+    height: number;
+}): Float64Array;
+/**
+ * Cut `[0, weights.length)` into `chunkCount` ranges of ~equal summed weight, each within
+ * `[minFrames, maxFrames]` where the frame count allows. `null` when the cost is uniform.
+ */
+export declare function buildWeightedChunkSlices(weights: Float64Array, chunkCount: number, minFrames: number, maxFrames: number): ChunkSliceJson[] | null;

package/dist/services/distributed/plan.d.ts

@@ -271,6 +271,8 @@ export declare const DEFAULT_MAX_PARALLEL_CHUNKS = 16;
  * outweighs the parallelism gain on tiny renders.
  */
 export declare const MIN_CHUNK_SIZE = 10;
+/** Largest `chunkSize`; `validateDistributedRenderConfig` enforces it, and cost-weighted chunks stay under it. */
+export declare const MAX_CHUNK_SIZE = 3600;
 /** Most chunks one render may plan; `validateDistributedRenderConfig` enforces it on `maxParallelChunks`. */
 export declare const MAX_PARALLEL_CHUNKS_CEILING = 256;
 /** Predicted seconds for one chunk of `frames` frames at `megapixels` output pixels per frame. */
@@ -402,6 +404,11 @@ export declare function resolveChunkPlan(totalFrames: number, configChunkSize: n
  * upper bound — chunk workers iterate `i in [startFrame, endFrame)`.
  */
 export declare function buildChunkSlices(totalFrames: number, chunkCount: number, effectiveChunkSize: number): ChunkSliceJson[];
+/**
+ * The plan's chunk cut: auto-sized plans re-cut the same chunk count by estimated capture cost;
+ * explicit `chunkSize` or uniform cost keeps {@link buildChunkSlices}; `targetChunkFrames` and the time limit cap it.
+ */
+export declare function buildPlanChunkSlices(frameWeights: Float64Array, config: Pick<DistributedRenderConfig, "chunkSize" | "targetChunkFrames">, chunkCount: number, effectiveChunkSize: number, maxFramesPerChunk?: number): ChunkSliceJson[];
 /** Test-visible construction of the engine config used by distributed planning. */
 export declare function resolveDistributedEngineConfig(config: DistributedRenderConfig): EngineConfig;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.8.197",
+  "version": "0.8.198",
   "description": "HTML-to-video rendering engine using Chrome's BeginFrame API",
   "repository": {
     "type": "git",
@@ -35,11 +35,11 @@
     "postcss": "^8.4.0",
     "puppeteer": "^25.2.1",
     "puppeteer-core": "^25.2.1",
-    "@hyperframes/engine": "0.8.197",
-    "@hyperframes/lint": "0.8.197",
-    "@hyperframes/core": "0.8.197",
-    "@hyperframes/parsers": "0.8.197",
-    "@hyperframes/studio-server": "0.8.197"
+    "@hyperframes/core": "0.8.198",
+    "@hyperframes/engine": "0.8.198",
+    "@hyperframes/lint": "0.8.198",
+    "@hyperframes/parsers": "0.8.198",
+    "@hyperframes/studio-server": "0.8.198"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",
@@ -48,7 +48,7 @@
     "tsx": "^4.21.0",
     "typescript": "^5.7.2",
     "vitest": "^4.1.11",
-    "@hyperframes/aws-lambda": "0.8.197"
+    "@hyperframes/aws-lambda": "0.8.198"
   },
   "engines": {
     "node": ">=22"