@hyperframes/producer 0.8.225 → 0.8.227

package/dist/distributed.js

@@ -68,7 +68,6 @@ import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframe
 import {
   existsSync as existsSync10,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync6,
   readdirSync as readdirSync3,
   rmSync as rmSync5,
   statSync as statSync5,
@@ -88,6 +87,7 @@ import {
 import { HF_AUDIO_GROUP_TAG } from "@hyperframes/core/audio-groups";
 import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
 import { HTML_BODY_CSS_HEIGHT_FIRST_RE, HTML_BODY_CSS_WIDTH_FIRST_RE } from "@hyperframes/parsers";
+import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
 import {
   extractMediaMetadata as extractMediaMetadata4,
   resolveConfig as resolveConfig2,
@@ -1893,7 +1893,7 @@ import { suggestMatchingPreset } from "@hyperframes/core";
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash4 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
 import { join as join6, dirname as dirname5, resolve as resolve6, basename as basename3, relative as relative2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
@@ -1946,7 +1946,8 @@ import {
 } from "@hyperframes/parsers/sub-composition-validity";
 import {
   isUnresolvedAssetPlaceholder,
-  readProjectFile
+  readProjectFile,
+  readTextFile
 } from "@hyperframes/parsers/asset-resolution";
 
 // src/services/renderMediaCollector.ts
@@ -4035,11 +4036,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
   return document2.toString();
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
-  const entryHtml = rebaseDirectEntryAssetPaths(
-    readFileSync4(htmlPath, "utf-8"),
-    projectDir,
-    htmlPath
-  );
+  const entryHtml = rebaseDirectEntryAssetPaths(readTextFile(htmlPath), projectDir, htmlPath);
   const rawHtml = rewriteUnresolvableGsapToCdn(entryHtml, projectDir);
   assertSubCompositionsUsable(rawHtml, projectDir);
   const probes = /* @__PURE__ */ new Map();
@@ -4890,7 +4887,7 @@ async function runProbeStage(input) {
   );
   const hasVariableMedia = hasVariableBoundMedia(compiled.html, job.config.variables);
   const hasInsertedMedia = hasRuntimeMediaChanges(compiled.html);
-  const needsBrowser = probeRequiresBrowser({
+  const needsBrowser = cfg.videoLayerPassthrough || probeRequiresBrowser({
     durationSeconds: composition.duration,
     unresolvedCompositionCount: compiled.unresolvedCompositions.length,
     hasAutoStart,
@@ -5522,17 +5519,23 @@ function resolveVideoExtractionPolicy(env = process.env) {
   const maxTransientRetries = failureMode !== "off" && env.HF_VIDEO_EXTRACTION_MAX_RETRIES?.trim() === "1" ? 1 : 0;
   return { failureMode, maxTransientRetries };
 }
+var MAX_NAMED_SOURCES = 5;
 var VideoExtractionStageError = class extends Error {
   constructor(code, retryable, failures, extractionFailure = buildExtractionFailureMetadata(
     failures.map((failure) => ({
       kind: failure.kind,
       affectedElementCount: failure.count
     }))
-  ), ffmpegReason) {
+  ), ffmpegReason, sources = []) {
     const total = failures.reduce((sum2, failure) => sum2 + failure.count, 0);
     const breakdown = failures.map((failure) => `${failure.kind}=${failure.count}`).join(",");
     const reason = ffmpegReason ? `: ffmpeg said: ${ffmpegReason}` : "";
-    super(`Video extraction failed for ${total} source(s) [${code}; ${breakdown}]${reason}`);
+    const shown = sources.slice(0, MAX_NAMED_SOURCES).join(", ");
+    const more = sources.length > MAX_NAMED_SOURCES ? ` and ${sources.length - MAX_NAMED_SOURCES} more` : "";
+    const files = sources.length > 0 ? ` (${shown}${more})` : "";
+    super(
+      `Video extraction failed for ${total} source(s) [${code}; ${breakdown}]${files}${reason}`
+    );
     this.code = code;
     this.retryable = retryable;
     this.failures = failures;
@@ -5580,7 +5583,10 @@ function buildVideoExtractionStageError(result) {
     retryable,
     failures,
     extractionFailureMetadataFromResult(result),
-    result.errors.find((failure) => failure.ffmpegReason)?.ffmpegReason
+    result.errors.find((failure) => failure.ffmpegReason)?.ffmpegReason,
+    [
+      ...new Set(result.errors.flatMap((failure) => failure.source ? [failure.source] : []))
+    ].sort()
   );
 }
 function buildHdrProbeStageError(failures) {
@@ -5659,7 +5665,8 @@ async function runExtractVideosStage(input) {
     assertNotAborted,
     materializeSymlinks,
     deferRangeExtraction,
-    urlByAbsentLocalPath
+    urlByAbsentLocalPath,
+    skipFrameExtractionIds = []
   } = input;
   const stage2Start = Date.now();
   const extractionPolicy = resolveVideoExtractionPolicy();
@@ -5730,7 +5737,10 @@ async function runExtractVideosStage(input) {
     );
     imageColorSpaces.push(...probed);
   }
-  if (composition.videos.length > 0) {
+  if (skipFrameExtractionIds.length > 0) {
+    await appendVideoAudioFromProbe({ projectDir, compiledDir, composition, urlByAbsentLocalPath });
+    videoReadinessSkipIds = [...skipFrameExtractionIds];
+  } else if (composition.videos.length > 0) {
     const totalVideos = composition.videos.length;
     for (let i = 0; i < totalVideos; i++) {
       const v = composition.videos[i];
@@ -5854,6 +5864,14 @@ async function appendVideoAudioFromProbe(input) {
   );
 }
 
+// src/services/render/videoLayerPassthroughPlan.ts
+import {
+  buildVideoLayerInput,
+  isHttpUrl as isHttpUrl3,
+  qualifyVideoLayer,
+  resolveProjectRelativeSrc as resolveProjectRelativeSrc4
+} from "@hyperframes/engine";
+
 // src/services/render/stages/audioStage.ts
 import { join as join11 } from "node:path";
 import {
@@ -6856,7 +6874,7 @@ import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync4,
   rmSync as rmSync4,
   statSync as statSync4,
   writeFileSync as writeFileSync3
@@ -6950,7 +6968,7 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = formatFfmpegError(result.exitCode, result.stderr);
     return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
   }
-  const gif = readFileSync5(outputPath);
+  const gif = readFileSync4(outputPath);
   if (!clearGifFramesBeforeNext(gif)) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
@@ -6983,7 +7001,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
         return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
     }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync5(outputPath)) !== false) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync4(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
@@ -7654,7 +7672,7 @@ import {
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
 import { dirname as dirname9, join as join15 } from "node:path";
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync5 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -7933,7 +7951,7 @@ function readProducerVersion() {
     const candidate = join15(current, "package.json");
     if (existsSync11(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
           cachedProducerVersion = pkg.version;
           return pkg.version;
@@ -8263,7 +8281,7 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync6, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join18, relative as relative3, resolve as resolve8 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
@@ -8503,7 +8521,7 @@ function collectPlanAssetShas(planDir, digests) {
   const assets = [];
   for (const file of files) {
     if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync8(file.absolutePath);
+      compositionHtml = readFileSync6(file.absolutePath);
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
@@ -8527,7 +8545,7 @@ function writePlanRemoteFiles(planDir, files) {
 }
 function readPlanRemoteFiles(planDir) {
   const path = join18(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync13(path) ? JSON.parse(readFileSync8(path, "utf-8")) : [];
+  return existsSync13(path) ? JSON.parse(readFileSync6(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join18(planDir, "plan.json");
@@ -8538,8 +8556,8 @@ function recomputePlanHashFromPlanDir(planDir, digests) {
   if (!existsSync13(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
-  const planJson = JSON.parse(readFileSync8(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync8(encoderJsonPath, "utf-8");
+  const planJson = JSON.parse(readFileSync6(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync6(encoderJsonPath, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   return computePlanHash({
     compositionHtml,
@@ -8645,7 +8663,7 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync4, existsSync as existsSync14, ftruncateSync, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync9 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync14, ftruncateSync, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync7 } from "node:fs";
 import { writeFileSync as writeFileSync6, writeSync } from "node:fs";
 import { join as join20 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
@@ -9118,7 +9136,7 @@ async function writeChunkAudioSlices(input) {
       offset += track.sizes[offsets.length - 1];
     }
   });
-  const bytes = readFileSync9(input.audioPath);
+  const bytes = readFileSync7(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
   mkdirSync9(join20(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
@@ -9137,8 +9155,8 @@ async function writeChunkAudioSlices(input) {
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
   const layoutPath = join20(planDir, SLICE_LAYOUT);
   if (!existsSync14(layoutPath)) return resolvePlanAudioPath(planDir);
-  const layout = JSON.parse(readFileSync9(layoutPath, "utf-8"));
-  const frame = readFileSync9(join20(planDir, SLICE_FRAME));
+  const layout = JSON.parse(readFileSync7(layoutPath, "utf-8"));
+  const frame = readFileSync7(join20(planDir, SLICE_FRAME));
   const fd = openSync4(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -9151,7 +9169,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync9(join20(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync7(join20(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -10242,7 +10260,7 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync4,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync7,
   rmSync as rmSync9,
   statSync as statSync7,
@@ -10391,7 +10409,7 @@ function isNonNegativeIntegerArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0);
 }
 function readJsonFile(path, label) {
-  const contents = readFileSync10(path, "utf-8");
+  const contents = readFileSync8(path, "utf-8");
   try {
     const parsed = JSON.parse(contents);
     return parsed;
@@ -11132,7 +11150,7 @@ import {
   existsSync as existsSync18,
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync8,
   rmSync as rmSync10,
   statSync as statSync8,
@@ -11236,13 +11254,13 @@ function readAssemblePlan(planDir, chunkPaths) {
   if (!existsSync18(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync11(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
   if (!existsSync18(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync9(chunksJsonPath, "utf-8"));
   if (chunkPaths.length !== chunks.length) {
     throw new Error(
       `[assemble] chunkPaths length (${chunkPaths.length}) does not match chunks.json length (${chunks.length}). Adapters must pass one path per chunk, ordered by index.`
@@ -11388,13 +11406,13 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync11(join26(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync9(join26(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join26(planDir, "meta", "encoder.json");
   if (!existsSync18(encoderJsonPath)) return {};
-  return JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
+  return JSON.parse(readFileSync9(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -11406,7 +11424,7 @@ function readCfrEncoder(planDir, format) {
   if (!existsSync18(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
-  const encoderJson = JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
+  const encoderJson = JSON.parse(readFileSync9(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".`
@@ -11460,7 +11478,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync12, readdirSync as readdirSync9, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync10, readdirSync as readdirSync9, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
 import { cpus } from "node:os";
 import { join as join27 } from "node:path";
 import {
@@ -11583,10 +11601,10 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function hashChunkOutput(outputPath, kind) {
-  if (kind === "file") return sha256Hex(readFileSync12(outputPath));
+  if (kind === "file") return sha256Hex(readFileSync10(outputPath));
   const entries = readdirSync9(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync12(join27(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync10(join27(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -11612,7 +11630,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
     );
   }
-  const plan2 = JSON.parse(readFileSync12(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
@@ -11629,13 +11647,13 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       );
     }
   }
-  const encoder = JSON.parse(readFileSync12(encoderJsonPath, "utf-8"));
-  const chunks = JSON.parse(readFileSync12(chunksJsonPath, "utf-8"));
+  const encoder = JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync10(chunksJsonPath, "utf-8"));
   const videosJsonPath = join27(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync19(videosJsonPath)) {
     try {
-      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync12(videosJsonPath, "utf-8")));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync10(videosJsonPath, "utf-8")));
     } catch (err) {
       if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
@@ -11746,7 +11764,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync12(join27(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync10(join27(compiledDir, "index.html"), "utf-8"),
       // The plan ships a deferred source only to chunks that show it; don't wait on the rest.
       skipReadinessVideoIds: deferredVideos.filter(
         (video) => !shownFrames.get(video.videoId)?.size || remoteVideoIds.has(video.videoId)

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "1503dd37b026878d624c777b74f45676d66598b0f1f927fb419e904de6b54031",
+  "sha256": "675f38c16c7cbd061ea636f5437c51e18a54e9d89b9da49b105cb34ac9f865a4",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"