@hyperframes/producer 0.8.193 → 0.8.195

package/dist/public-server.js

@@ -1583,8 +1583,11 @@ function assertDurationWithinTolerance(expectedSeconds, probedSeconds, tolerance
     `Render artifact is truncated: expected ${expectedSeconds.toFixed(3)}s, probed ${probedSeconds.toFixed(3)}s (deficit ${deficit.toFixed(3)}s exceeds tolerance ${toleranceSeconds.toFixed(3)}s). Artifact: ${stagingPath}`
   );
 }
+function hasUsableFrameCount(frames) {
+  return frames !== void 0 && Number.isFinite(frames) && frames > 0;
+}
 function assertFrameCountWithinTolerance(expectedFrames, probedFrames, stagingPath, toleranceFrames = 1) {
-  if (probedFrames === void 0 || !Number.isFinite(probedFrames) || probedFrames <= 0) {
+  if (!hasUsableFrameCount(probedFrames)) {
     return;
   }
   const shortfall = expectedFrames - probedFrames;
@@ -1604,9 +1607,10 @@ function assertSizeMatches(expected, probed, stagingPath) {
   );
 }
 var ArtifactTransaction = class {
-  constructor(destinationPath, kind, fileSystem = defaultFileSystem, durationProbe = defaultArtifactDurationProbe) {
+  constructor(destinationPath, kind, fileSystem = defaultFileSystem, durationProbe = defaultArtifactDurationProbe, logger = defaultLogger) {
     this.kind = kind;
     this.fileSystem = fileSystem;
+    this.logger = logger;
     this.destinationPath = resolve4(destinationPath);
     this.transactionDirectory = createSiblingTransactionDirectory(this.destinationPath);
     this.stagingPath = join5(this.transactionDirectory, basename3(this.destinationPath));
@@ -1689,6 +1693,19 @@ var ArtifactTransaction = class {
       probePath
     );
     if (expected.expectedFrames !== void 0) {
+      if (!hasUsableFrameCount(probed.frames)) {
+        try {
+          this.logger.debug(
+            "[Render] Frame-count validation skipped: no usable frame count was reported.",
+            {
+              event: "artifact_frame_count_unavailable",
+              artifact: this.destinationPath,
+              expectedFrames: expected.expectedFrames
+            }
+          );
+        } catch {
+        }
+      }
       assertFrameCountWithinTolerance(expected.expectedFrames, probed.frames, probePath);
     }
     assertSizeMatches(expected, probed, probePath);
@@ -5271,12 +5288,15 @@ import {
   readMediaStart,
   redactTelemetryString as redactTelemetryString2,
   resolveNaturalMediaTimelineDurationFromValues,
+  rewriteAssetPath,
   rewriteAssetPaths,
   rewriteCssAssetUrls,
   rewriteInlineStyleAssetUrls
 } from "@hyperframes/core";
 import { MAX_AUDIO_GAIN } from "@hyperframes/core/audio-gain";
-import { gsapCdnDist } from "@hyperframes/core/gsap-cdn";
+import { readPlaybackRate } from "@hyperframes/parsers/media-duration";
+import { resolveRateSpec } from "@hyperframes/core/speed-ramp";
+import { gsapCdnDist, normalizeGsapBaseUrl } from "@hyperframes/core/gsap-cdn";
 import {
   assignBundledRuntimeCompositionIds,
   assignMediaRenderIds,
@@ -6309,7 +6329,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
   const results = await Promise.all(
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
-        item.rawSubHtml,
+        rewriteUnresolvableGsapToCdn(item.rawSubHtml, projectDir, item.srcPath),
         dirname6(item.filePath),
         downloadDir,
         void 0,
@@ -6483,7 +6503,9 @@ function inlineSubCompositions(html, subCompositions, projectDir, variableOverri
         let compHtml = subCompositions.get(srcPath) || null;
         if (!compHtml) {
           const read = readProjectFile(resolve6(projectDir, srcPath));
-          if (read.kind === "file") compHtml = read.text;
+          if (read.kind === "file") {
+            compHtml = rewriteUnresolvableGsapToCdn(read.text, projectDir, srcPath);
+          }
         }
         return compHtml;
       },
@@ -7026,18 +7048,27 @@ async function embedLocalFontFaces(html, projectDir) {
   }
   return result;
 }
-var GSAP_CDN_BASE = gsapCdnDist();
-function rewriteUnresolvableGsapToCdn(html, projectDir) {
+function renderGsapDist() {
+  try {
+    return gsapCdnDist(void 0, normalizeGsapBaseUrl(process.env.HYPERFRAMES_GSAP_BASE_URL));
+  } catch (cause) {
+    throw new Error(
+      "Invalid HYPERFRAMES_GSAP_BASE_URL: use an absolute HTTPS npm mirror root (plain HTTP only for localhost) without credentials, query, or fragment",
+      { cause }
+    );
+  }
+}
+function rewriteUnresolvableGsapToCdn(html, projectDir, compSrcPath) {
+  let gsapDist;
+  const exists = (path) => existsSync10(resolve6(projectDir, path));
   return html.replace(
     /(<script\b[^>]*\bsrc=["'])([^"']*gsap[^"']*\/dist\/([^"']+))(["'][^>]*>)/gi,
     (full, prefix, src, file, suffix) => {
       if (/^https?:\/\//i.test(src)) return full;
-      const absPath = resolve6(projectDir, src);
-      if (existsSync10(absPath)) return full;
-      defaultLogger.info(
-        `[Compiler] Rewriting missing gsap script to CDN: ${src} \u2192 ${GSAP_CDN_BASE}${file}`
-      );
-      return `${prefix}${GSAP_CDN_BASE}${file}${suffix}`;
+      if (exists(compSrcPath ? rewriteAssetPath(compSrcPath, src, exists) : src)) return full;
+      gsapDist ??= renderGsapDist();
+      defaultLogger.info(`[Compiler] Rewriting missing gsap script: ${src} \u2192 ${gsapDist}${file}`);
+      return `${prefix}${gsapDist}${file}${suffix}`;
     }
   );
 }
@@ -7251,6 +7282,9 @@ async function discoverMediaFromBrowser(page) {
       const intrinsicDuration = isImage ? 0 : htmlEl.duration;
       const playbackStartRaw = htmlEl.getAttribute("data-playback-start");
       const mediaStartRaw = htmlEl.getAttribute("data-media-start");
+      const playbackRateRaw = htmlEl.getAttribute("data-playback-rate");
+      const automationRaw = htmlEl.getAttribute("data-automation");
+      const defaultPlaybackRate = isImage ? 1 : htmlEl.defaultPlaybackRate;
       const loop = htmlEl.hasAttribute("loop");
       const hasAudio = htmlEl.getAttribute("data-has-audio") === "true";
       const volume = parseFloat(htmlEl.getAttribute("data-volume") || "1");
@@ -7266,6 +7300,9 @@ async function discoverMediaFromBrowser(page) {
         durationInferred,
         playbackStartRaw,
         mediaStartRaw,
+        playbackRateRaw,
+        automationRaw,
+        defaultPlaybackRate,
         loop,
         hasAudio,
         volume,
@@ -7275,7 +7312,17 @@ async function discoverMediaFromBrowser(page) {
     return results;
   });
   return elements.map(
-    ({ endRaw, durationRaw, intrinsicDuration, playbackStartRaw, mediaStartRaw, ...element }) => ({
+    ({
+      endRaw,
+      durationRaw,
+      intrinsicDuration,
+      playbackStartRaw,
+      mediaStartRaw,
+      playbackRateRaw,
+      automationRaw,
+      defaultPlaybackRate,
+      ...element
+    }) => ({
       ...element,
       end: parseStrictFiniteTimingNumber(endRaw) ?? 0,
       duration: element.durationInferred && Number.isFinite(intrinsicDuration) && intrinsicDuration > 0 ? intrinsicDuration : parseStrictFiniteTimingNumber(durationRaw) ?? 0,
@@ -7285,7 +7332,14 @@ async function discoverMediaFromBrowser(page) {
           if (name === "data-media-start") return mediaStartRaw;
           return null;
         }
-      })
+      }),
+      playbackRate: resolveRateSpec(
+        automationRaw,
+        readPlaybackRate(
+          (name) => name === "data-playback-rate" ? playbackRateRaw : null,
+          defaultPlaybackRate
+        )
+      )
     })
   );
 }
@@ -7705,9 +7759,18 @@ import {
   getCompositionDuration,
   initializeSession as initializeSession4,
   isTransientBrowserError,
-  probeBeginFrameLiveness
+  probeBeginFrameLiveness,
+  videoAudioId
 } from "@hyperframes/engine";
-import { MEDIA_RENDER_ID_ATTR as MEDIA_RENDER_ID_ATTR2, fpsToNumber as fpsToNumber7, readMediaStart as readMediaStart2 } from "@hyperframes/core";
+import {
+  MEDIA_RENDER_ID_ATTR as MEDIA_RENDER_ID_ATTR2,
+  fpsToNumber as fpsToNumber7,
+  normalizeRateSpec as normalizeRateSpec3,
+  readMediaStart as readMediaStart2,
+  shiftRateLane as shiftRateLane2,
+  sourceTimeAt as sourceTimeAt3,
+  timeAtSourceTime
+} from "@hyperframes/core";
 import { extractMediaSrcMutations } from "@hyperframes/parsers";
 
 // src/services/render/stages/probeFailures.ts
@@ -7766,16 +7829,28 @@ function authoredMediaStarts(html) {
   }
   return starts;
 }
-function adoptRuntimeMediaStart(composition, el, authored) {
+function isVideoAudio(audio, videoId) {
+  return audio.type === "video" && audio.id === videoAudioId(videoId);
+}
+function adoptRuntimeMediaTiming(composition, el, authored) {
   const shift = el.mediaStart - authored;
-  if (el.mediaStart <= 0 || Math.abs(shift) <= BROWSER_MEDIA_EPSILON) return;
   const entries = el.tagName === "video" ? [
     ...composition.videos.filter((video) => video.id === el.id),
-    ...composition.audios.filter(
-      (audio) => audio.type === "video" && audio.id === `${el.id}-audio`
-    )
+    ...composition.audios.filter((audio) => isVideoAudio(audio, el.id))
   ] : composition.audios.filter((audio) => audio.type !== "video" && audio.id === el.id);
-  for (const entry of entries) entry.mediaStart += shift;
+  for (const entry of entries) {
+    if (typeof entry.playbackRate !== "object") {
+      if (typeof el.playbackRate === "object") {
+        const consumed = Math.max(0, entry.mediaStart - authored);
+        const head = timeAtSourceTime(normalizeRateSpec3(entry.playbackRate), consumed);
+        entry.mediaStart += sourceTimeAt3(el.playbackRate, head) - consumed;
+        entry.playbackRate = shiftRateLane2(el.playbackRate, head);
+      } else {
+        entry.playbackRate = el.playbackRate;
+      }
+    }
+    if (el.mediaStart > 0 && Math.abs(shift) > BROWSER_MEDIA_EPSILON) entry.mediaStart += shift;
+  }
 }
 function reconcileBrowserMediaEnd(existingEnd, projectedEnd, sourceChanged, durationInferred) {
   if (projectedEnd <= 0) return existingEnd;
@@ -8059,7 +8134,7 @@ async function runProbeStage(input) {
                   sourceChanged,
                   el.durationInferred
                 );
-                adoptRuntimeMediaStart(
+                adoptRuntimeMediaTiming(
                   composition,
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart
@@ -8082,6 +8157,7 @@ async function runProbeStage(input) {
                 start: el.start,
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
+                playbackRate: el.playbackRate,
                 loop: el.loop,
                 hasAudio: el.hasAudio && !el.muted
               });
@@ -8106,7 +8182,7 @@ async function runProbeStage(input) {
                   sourceChanged,
                   el.durationInferred
                 );
-                adoptRuntimeMediaStart(
+                adoptRuntimeMediaTiming(
                   composition,
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart
@@ -8124,6 +8200,7 @@ async function runProbeStage(input) {
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
                 loop: el.loop,
+                playbackRate: el.playbackRate,
                 layer: 0,
                 volume: el.volume,
                 type: "audio"
@@ -8353,7 +8430,8 @@ import {
   isHttpUrl as isHttpUrl2,
   resolveProjectRelativeSrc as resolveProjectRelativeSrc3,
   runVideoExtractionWithRetry,
-  safeVideoExtractionSourceIdentity
+  safeVideoExtractionSourceIdentity,
+  videoAudioId as videoAudioId2
 } from "@hyperframes/engine";
 
 // src/services/render/extractionFailureMetadata.ts
@@ -8706,7 +8784,7 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
     const video = composition.videos.find((v) => v.id === ext.videoId);
     if (!video || !video.hasAudio || video.hidden || existingAudioSrcs.has(video.src)) continue;
     composition.audios.push({
-      id: `${video.id}-audio`,
+      id: videoAudioId2(video.id),
       src: video.src,
       start: video.start,
       end: video.end,
@@ -11732,13 +11810,36 @@ function colorGradingValueHasLut(rawAttributeValue) {
     return false;
   }
 }
-async function resolveCompositionElementCount(probeSession, html) {
+var PROBE_READ_TIMEOUT_MS = 5e3;
+async function evaluateWithinBound(page, fn, what, log) {
+  let timer;
+  const timedOut = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`no answer within ${PROBE_READ_TIMEOUT_MS} ms (page busy)`)),
+      PROBE_READ_TIMEOUT_MS
+    );
+  });
+  try {
+    return await Promise.race([page.evaluate(fn), timedOut]);
+  } catch (err) {
+    log.warn(`[Render] live ${what} read skipped; using the static answer`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function resolveCompositionElementCount(probeSession, html, log = defaultLogger) {
   if (probeSession?.isInitialized) {
     try {
-      const liveCount = await probeSession.page.evaluate(
+      const liveCount = await evaluateWithinBound(
+        probeSession.page,
         // Live HTMLCollection length — avoids materializing a static NodeList
         // on the large-DOM comps this gate exists to catch (review nit).
-        () => document.getElementsByTagName("*").length
+        () => document.getElementsByTagName("*").length,
+        "element count",
+        log
       );
       if (typeof liveCount === "number" && Number.isFinite(liveCount)) {
         return { count: liveCount, source: "live" };
@@ -11826,11 +11927,11 @@ function probeAdaptersUsed() {
   }
   return used;
 }
-async function resolveAdaptersUsed(probeSession, html) {
+async function resolveAdaptersUsed(probeSession, html, log = defaultLogger) {
   const staticAdapters = detectAdaptersStatic(html);
   if (!probeSession?.isInitialized) return staticAdapters;
   try {
-    const live = await probeSession.page.evaluate(probeAdaptersUsed);
+    const live = await evaluateWithinBound(probeSession.page, probeAdaptersUsed, "adapters", log);
     if (!Array.isArray(live)) return staticAdapters;
     const detected = /* @__PURE__ */ new Set([...staticAdapters, ...live]);
     return KNOWN_RUNTIME_ADAPTERS.filter((name) => detected.has(name));
@@ -12088,7 +12189,10 @@ async function executeRenderPipeline(input) {
   );
   const artifactTransaction = new ArtifactTransaction(
     outputPath,
-    isPngSequence || isHls ? "directory" : "file"
+    isPngSequence || isHls ? "directory" : "file",
+    void 0,
+    void 0,
+    log
   );
   const stagedOutputPath = artifactTransaction.stagingPath;
   const needsAlpha = outputNeedsAlpha(outputFormat);
@@ -12587,8 +12691,8 @@ async function executeRenderPipeline(input) {
       vfxHostCount,
       vfxCapture,
       vfxTypes
-    } = await resolveCompositionElementCount(probeSession, compiled.html);
-    const adaptersUsed = await resolveAdaptersUsed(probeSession, compiled.html);
+    } = await resolveCompositionElementCount(probeSession, compiled.html, log);
+    const adaptersUsed = await resolveAdaptersUsed(probeSession, compiled.html, log);
     const deShortBandEnabled = deShortBandMaxElements > 0;
     const deShortBandOpen = deShortBandEnabled && deShortBandMinFrames > 0 && compositionElementCountSource === "live" && compositionElementCount <= deShortBandMaxElements;
     const deShortBandRoute = process.env.HF_DE_SHORT_BAND_ROUTE === "true";

package/dist/services/htmlCompiler.d.ts

@@ -1,4 +1,4 @@
-import { type ResolvedDuration, type UnresolvedElement } from "@hyperframes/core";
+import { type RateSpec, type ResolvedDuration, type UnresolvedElement } from "@hyperframes/core";
 import { type VideoElement, type ImageElement, type AudioElement, type AudioVolumeKeyframe } from "@hyperframes/engine";
 import type { Page } from "puppeteer-core";
 import { type ProducerLogger } from "../logger.js";
@@ -216,6 +216,7 @@ export interface BrowserMediaElement {
     /** True when compilation inferred duration from the fallback source. */
     durationInferred: boolean;
     mediaStart: number;
+    playbackRate: RateSpec;
     loop: boolean;
     hasAudio: boolean;
     volume: number;

package/dist/services/render/artifactTransaction.d.ts

@@ -1,3 +1,4 @@
+import { type ProducerLogger } from "../../logger.js";
 import type { RenderOutputFormat } from "./renderFormat.js";
 export type ArtifactKind = "file" | "directory";
 export interface ArtifactTransactionFileSystem {
@@ -113,13 +114,14 @@ export declare function buildArtifactExpectation(input: {
 export declare class ArtifactTransaction {
     private readonly kind;
     private readonly fileSystem;
+    private readonly logger;
     readonly destinationPath: string;
     readonly stagingPath: string;
     private readonly transactionDirectory;
     private readonly backupPath;
     private state;
     private readonly durationProbe;
-    constructor(destinationPath: string, kind: ArtifactKind, fileSystem?: ArtifactTransactionFileSystem, durationProbe?: ArtifactDurationProbe);
+    constructor(destinationPath: string, kind: ArtifactKind, fileSystem?: ArtifactTransactionFileSystem, durationProbe?: ArtifactDurationProbe, logger?: Pick<ProducerLogger, "debug">);
     validate(expected?: ArtifactValidationExpectation): Promise<void>;
     private assertReadableNonEmptyDirectory;
     /**

package/dist/services/renderOrchestrator.d.ts

@@ -706,6 +706,8 @@ export interface ElementTagScan {
  * live count and uses this only when no such session exists.
  */
 export declare function scanElementTags(html: string): ElementTagScan;
+/** Longest a live probe-page read may hold the render; a busy page otherwise waits out the CDP timeout. */
+export declare const PROBE_READ_TIMEOUT_MS = 5000;
 /**
  * Element count for the short-comp band's gate, WITH PROVENANCE.
  *
@@ -728,7 +730,7 @@ export declare function scanElementTags(html: string): ElementTagScan;
  * the fleet distribution recorded by the baseline release must be measured
  * by the same resolver that later gates routing, or the baseline is invalid.
  */
-export declare function resolveCompositionElementCount(probeSession: Pick<CaptureSession, "isInitialized" | "page"> | null, html: string): Promise<{
+export declare function resolveCompositionElementCount(probeSession: Pick<CaptureSession, "isInitialized" | "page"> | null, html: string, log?: Pick<ProducerLogger, "warn">): Promise<{
     count: number;
     source: "live" | "static";
     byTag?: Readonly<Record<string, number>>;
@@ -761,7 +763,7 @@ export declare function detectAdaptersStatic(html: string): RuntimeAdapterName[]
  * Runtime adapters a composition exercises. Unlike `resolveCompositionElementCount`
  * (one source of truth, for gating), this is observational: unions live + static every render.
  */
-export declare function resolveAdaptersUsed(probeSession: Pick<CaptureSession, "isInitialized" | "page"> | null, html: string): Promise<readonly RuntimeAdapterName[]>;
+export declare function resolveAdaptersUsed(probeSession: Pick<CaptureSession, "isInitialized" | "page"> | null, html: string, log?: Pick<ProducerLogger, "warn">): Promise<readonly RuntimeAdapterName[]>;
 /**
  * Max-merge init telemetry across per-worker capture perf summaries — the
  * success-path channel for PARALLEL renders, whose worker console buffers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.8.193",
+  "version": "0.8.195",
   "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.193",
-    "@hyperframes/core": "0.8.193",
-    "@hyperframes/parsers": "0.8.193",
-    "@hyperframes/lint": "0.8.193",
-    "@hyperframes/studio-server": "0.8.193"
+    "@hyperframes/core": "0.8.195",
+    "@hyperframes/lint": "0.8.195",
+    "@hyperframes/studio-server": "0.8.195",
+    "@hyperframes/parsers": "0.8.195",
+    "@hyperframes/engine": "0.8.195"
   },
   "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.193"
+    "@hyperframes/aws-lambda": "0.8.195"
   },
   "engines": {
     "node": ">=22"