@hyperframes/engine 0.5.5 → 0.6.0-alpha.1

package/src/services/browserManager.ts

@@ -136,119 +136,6 @@ async function probeBeginFrameSupport(browser: Browser): Promise<boolean> {
   }
 }
 
-/**
- * Cached *in-flight or resolved* probe Promise for `resolveBrowserGpuMode("auto", ...)`.
- *
- * Caching the Promise (rather than the resolved value) deduplicates concurrent
- * callers — the parallel coordinator runs N workers via `Promise.all`, so a
- * `--workers 4` render against a no-GPU host would otherwise fire 4
- * simultaneous probe Chromes. The first call assigns the Promise and every
- * other concurrent caller awaits the same one, paying the ~240 ms probe cost
- * exactly once per process lifetime.
- *
- * Exported for tests; production callers go through `resolveBrowserGpuMode`.
- */
-export let _autoBrowserGpuModeCache: Promise<"software" | "hardware"> | undefined;
-
-/** Test-only: reset the cached probe result. */
-export function _resetAutoBrowserGpuModeCacheForTests(): void {
-  _autoBrowserGpuModeCache = undefined;
-}
-
-/**
- * Resolve `browserGpuMode` to a concrete `"software" | "hardware"` answer.
- *
- * For `"software"` / `"hardware"` this is a pure pass-through. For `"auto"`
- * it launches a tiny Chrome with the platform's hardware GPU args, runs a
- * one-shot WebGL availability probe, and falls back to `"software"` if
- * hardware-mode WebGL is unavailable. The Promise is cached for the process
- * lifetime, so concurrent callers (parallel workers) share the same probe.
- *
- * Any failure (Chrome launch error, navigation timeout, missing canvas API,
- * etc.) is treated as a `"software"` fallback. The render path with
- * SwiftShader always works, so a misclassification toward software is the
- * safe failure mode; misclassifying toward hardware would error on the real
- * render.
- */
-export function resolveBrowserGpuMode(
-  mode: EngineConfig["browserGpuMode"],
-  options: {
-    chromePath?: string;
-    browserTimeout?: number;
-    platform?: NodeJS.Platform;
-  } = {},
-): Promise<"software" | "hardware"> {
-  if (mode !== "auto") return Promise.resolve(mode);
-  if (_autoBrowserGpuModeCache) return _autoBrowserGpuModeCache;
-
-  _autoBrowserGpuModeCache = (async () => {
-    const platform = options.platform ?? process.platform;
-    const browserTimeout = options.browserTimeout ?? DEFAULT_CONFIG.browserTimeout;
-    const executablePath = options.chromePath ?? resolveHeadlessShellPath({});
-
-    const probeArgs = [
-      "--no-sandbox",
-      "--disable-setuid-sandbox",
-      "--disable-dev-shm-usage",
-      "--enable-webgl",
-      "--ignore-gpu-blocklist",
-      ...getBrowserGpuArgs("hardware", platform),
-    ];
-
-    const ppt = await getPuppeteer().catch(() => null);
-    if (!ppt) {
-      logResolvedBrowserGpuMode("software", "puppeteer unavailable");
-      return "software" as const;
-    }
-
-    let probeBrowser: Browser | undefined;
-    try {
-      probeBrowser = await ppt.launch({
-        headless: true,
-        args: probeArgs,
-        defaultViewport: { width: 64, height: 64 },
-        executablePath,
-        timeout: browserTimeout,
-      });
-      const page = await probeBrowser.newPage();
-      const hasWebGL = await page.evaluate(() => {
-        try {
-          const c = document.createElement("canvas");
-          const gl =
-            c.getContext("webgl") ||
-            (c.getContext("experimental-webgl") as RenderingContext | null);
-          return gl !== null;
-        } catch {
-          return false;
-        }
-      });
-      const resolved = hasWebGL ? ("hardware" as const) : ("software" as const);
-      logResolvedBrowserGpuMode(resolved, hasWebGL ? "WebGL probe succeeded" : "WebGL unavailable");
-      return resolved;
-    } catch (err) {
-      logResolvedBrowserGpuMode(
-        "software",
-        `probe failed (${err instanceof Error ? err.message : String(err)})`,
-      );
-      return "software" as const;
-    } finally {
-      await probeBrowser?.close().catch(() => {});
-    }
-  })();
-
-  return _autoBrowserGpuModeCache;
-}
-
-/**
- * Single observability surface for the auto-detect outcome. Logged exactly
- * once per process (the probe runs once); without this line, a regression
- * to "always software even with a GPU present" would be invisible in
- * production. Goes to stderr to stay out of stdout pipelines.
- */
-function logResolvedBrowserGpuMode(resolved: "hardware" | "software", reason: string): void {
-  console.error(`[hyperframes] browserGpuMode auto → ${resolved} (${reason})`);
-}
-
 export async function acquireBrowser(
   chromeArgs: string[],
   config?: Partial<
@@ -378,8 +265,6 @@ export interface BuildChromeArgsOptions {
   platform?: NodeJS.Platform;
 }
 
-const CANVAS_DRAW_ELEMENT_FEATURE_FLAG = "--enable-features=CanvasDrawElement";
-
 export function buildChromeArgs(
   options: BuildChromeArgsOptions,
   config?: Partial<Pick<EngineConfig, "browserGpuMode" | "disableGpu" | "chromePath">>,
@@ -397,7 +282,6 @@ export function buildChromeArgs(
     "--no-sandbox",
     "--disable-setuid-sandbox",
     "--disable-dev-shm-usage",
-    CANVAS_DRAW_ELEMENT_FEATURE_FLAG,
     "--enable-webgl",
     "--ignore-gpu-blocklist",
     ...getBrowserGpuArgs(browserGpuMode, platform),
@@ -457,20 +341,7 @@ function getBrowserGpuArgs(
   platform: NodeJS.Platform,
 ): string[] {
   if (mode === "software") {
-    // Chrome 120+ deprecated implicit SwiftShader fallback; the explicit
-    // path (--use-angle=swiftshader) keeps working but Chrome emits a
-    // deprecation warning unless --enable-unsafe-swiftshader is also set.
-    // Despite the name, this is exactly the behaviour Chrome had before;
-    // the flag exists to make CPU rasterisation an explicit opt-in rather
-    // than an implicit fallback for end users on the open web.
-    return ["--use-gl=angle", "--use-angle=swiftshader", "--enable-unsafe-swiftshader"];
-  }
-
-  if (mode === "auto") {
-    // Should not reach here — `resolveBrowserGpuMode` collapses "auto" to
-    // "software" or "hardware" before args are built. Be defensive: software
-    // is the always-safe fallback.
-    return ["--use-gl=angle", "--use-angle=swiftshader", "--enable-unsafe-swiftshader"];
+    return ["--use-gl=angle", "--use-angle=swiftshader"];
   }
 
   switch (platform) {

package/src/services/chunkEncoder.ts

@@ -139,43 +139,12 @@ export function buildEncoderArgs(
           else args.push("-global_quality", String(quality));
           break;
       }
-
-      // Same B-frame story as the SW branch below — nvenc emits B-frames
-      // by default (qsv via b_strategy, vaapi too), and the negative-DTS
-      // freeze hits the same downstream players. The unconditional
-      // `-avoid_negative_ts make_zero` near the bottom of this function
-      // covers the mux level, but we belt-and-suspenders the encoder too
-      // so even tools that consume the chunk file directly (without going
-      // through our mux step) play correctly. videotoolbox doesn't accept
-      // `-bf` so it's skipped — videotoolbox h264 also doesn't emit
-      // negative DTS in practice on macOS Sonoma+.
-      if (
-        codec === "h264" &&
-        (gpuEncoder === "nvenc" || gpuEncoder === "qsv" || gpuEncoder === "vaapi")
-      ) {
-        args.push("-bf", "0");
-        if (gpuEncoder === "qsv") {
-          args.push("-b_strategy", "0");
-        }
-      }
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
 
-      // Disable B-frames. Standard h264 with B-frames produces negative DTS
-      // at the start of the stream (the first B-frame's decode order is
-      // "before" the first I-frame's presentation time). VS Code's video
-      // preview, several browser <video> pipelines, and some HW decoders
-      // freeze on the first frame when DTS is negative, so audio plays alone.
-      // -bf 0 makes PTS == DTS at every frame, eliminating the issue at the
-      // source. Quality cost is ~5–10% larger files at the same CRF — a
-      // worthwhile trade for "the file plays everywhere".
-      if (codec === "h264") {
-        args.push("-bf", "0");
-      }
-
       // Encoder-specific params: anti-banding + color space tagging.
       // aq-mode=3 redistributes bits to dark flat areas (gradients).
       // For HDR x265 paths we additionally embed BT.2020 + transfer + HDR static
@@ -270,8 +239,6 @@ export function buildEncoderArgs(
     args.push("-pix_fmt", pixelFormat);
   }
 
-  args.push("-avoid_negative_ts", "make_zero");
-
   args.push("-y", outputPath);
   return args;
 }
@@ -543,9 +510,6 @@ export async function muxVideoWithAudio(
   } else {
     args.push("-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart");
   }
-  // PTS bases can diverge during mux and reintroduce negative DTS. See
-  // buildEncoderArgs for the full reasoning on why that breaks playback.
-  args.push("-avoid_negative_ts", "make_zero");
   args.push("-shortest", "-y", outputPath);
 
   const processTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;

package/src/services/frameCapture.ts

@@ -18,7 +18,6 @@ import {
   releaseBrowser,
   forceReleaseBrowser,
   buildChromeArgs,
-  resolveBrowserGpuMode,
   resolveHeadlessShellPath,
   type CaptureMode,
 } from "./browserManager.js";
@@ -114,22 +113,11 @@ export async function createCaptureSession(
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG.forceScreenshot;
-  // BeginFrame's screenshot does not honor a viewport `deviceScaleFactor`
-  // (the captured surface is sized by the OS window in CSS pixels regardless
-  // of `Emulation.setDeviceMetricsOverride`'s DPR). When supersampling we
-  // need explicit clip+scale on `Page.captureScreenshot`, so fall back to
-  // the screenshot path for any DPR > 1.
-  const supersampling = (options.deviceScaleFactor ?? 1) > 1;
   const preMode: CaptureMode =
-    headlessShell && isLinux && !forceScreenshot && !supersampling ? "beginframe" : "screenshot";
-  const requestedGpuMode = config?.browserGpuMode ?? DEFAULT_CONFIG.browserGpuMode;
-  const resolvedGpuMode = await resolveBrowserGpuMode(requestedGpuMode, {
-    chromePath: headlessShell ?? undefined,
-    browserTimeout: config?.browserTimeout,
-  });
+    headlessShell && isLinux && !forceScreenshot ? "beginframe" : "screenshot";
   const chromeArgs = buildChromeArgs(
     { width: options.width, height: options.height, captureMode: preMode },
-    { ...config, browserGpuMode: resolvedGpuMode },
+    config,
   );
 
   const { browser, captureMode } = await acquireBrowser(chromeArgs, config);
@@ -400,14 +388,8 @@ export async function initializeSession(session: CaptureSession): Promise<void>
 
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
 
-    // Wait for all video elements to have decoded their CURRENT frame, not
-    // just metadata. readyState >= 2 (HAVE_CURRENT_DATA) means a frame is
-    // actually rasterized and ready to paint — at >= 1 (HAVE_METADATA) we
-    // only know the dimensions, and the first <video> screenshot can come
-    // back as a black/blank rectangle. This bites compositions with two
-    // <video> elements of different codecs (h264 mp4 + VP9 webm) where the
-    // faster decoder lets the readiness check pass while the slower one
-    // hasn't painted, producing a black "first frame" for the slower clip.
+    // Wait for all video elements to have loaded metadata (dimensions + duration)
+    // Without this, frame 0 captures videos at their 300x150 default size.
     // skipReadinessVideoIds excludes natively-extracted videos (e.g. HDR HEVC
     // sources) whose frames come from ffmpeg out-of-band. videoMetadataHints
     // supply intrinsic dimensions for skipped videos whose layout depends on
@@ -415,12 +397,12 @@ export async function initializeSession(session: CaptureSession): Promise<void>
     const skipIdsLiteral = JSON.stringify(session.options.skipReadinessVideoIds ?? []);
     const videosReady = await pollPageExpression(
       page,
-      `(() => { const skip = new Set(${skipIdsLiteral}); const vids = Array.from(document.querySelectorAll("video")).filter(v => !skip.has(v.id)); return vids.length === 0 || vids.every(v => v.readyState >= 2); })()`,
+      `(() => { const skip = new Set(${skipIdsLiteral}); const vids = Array.from(document.querySelectorAll("video")).filter(v => !skip.has(v.id)); return vids.length === 0 || vids.every(v => v.readyState >= 1); })()`,
       pageReadyTimeout,
     );
     if (!videosReady) {
       throw new Error(
-        `[FrameCapture] video first frame not decoded after ${pageReadyTimeout}ms. Video elements must reach readyState >= 2 (HAVE_CURRENT_DATA) before capture starts.`,
+        `[FrameCapture] video metadata not ready after ${pageReadyTimeout}ms. Video elements must load metadata before capture starts.`,
       );
     }
 
@@ -502,13 +484,16 @@ export async function initializeSession(session: CaptureSession): Promise<void>
 
   await applyVideoMetadataHints(page, session.options.videoMetadataHints);
 
-  // Same readyState contract as the screenshot path above (>= 2 / HAVE_CURRENT_DATA).
+  // Wait for all video elements to have loaded metadata (dimensions + duration).
+  // Without this, frame 0 captures videos at their 300x150 default size.
+  // See screenshot-mode comment above for why skipReadinessVideoIds and
+  // videoMetadataHints are paired.
   const beginframeSkipIdsLiteral = JSON.stringify(session.options.skipReadinessVideoIds ?? []);
   const videoDeadline =
     Date.now() + (session.config?.playerReadyTimeout ?? DEFAULT_CONFIG.playerReadyTimeout);
   while (Date.now() < videoDeadline) {
     const videosReady = await page.evaluate(
-      `(() => { const skip = new Set(${beginframeSkipIdsLiteral}); const vids = Array.from(document.querySelectorAll("video")).filter(v => !skip.has(v.id)); return vids.length === 0 || vids.every(v => v.readyState >= 2); })()`,
+      `(() => { const skip = new Set(${beginframeSkipIdsLiteral}); const vids = Array.from(document.querySelectorAll("video")).filter(v => !skip.has(v.id)); return vids.length === 0 || vids.every(v => v.readyState >= 1); })()`,
     );
     if (videosReady) break;
     await new Promise((r) => setTimeout(r, 100));

package/src/services/screenshotService.ts

@@ -129,20 +129,12 @@ export async function beginFrameCapture(
 export async function pageScreenshotCapture(page: Page, options: CaptureOptions): Promise<Buffer> {
   const client = await getCdpSession(page);
   const isPng = options.format === "png";
-  const dpr = options.deviceScaleFactor ?? 1;
-  // When supersampling, pass an explicit clip with `scale` so Chrome emits a
-  // screenshot at device-pixel dimensions (`width × height × dpr`). Without
-  // this, `Page.captureScreenshot` returns at CSS dimensions regardless of
-  // the viewport's deviceScaleFactor.
-  const clip =
-    dpr > 1 ? { x: 0, y: 0, width: options.width, height: options.height, scale: dpr } : undefined;
   const result = await client.send("Page.captureScreenshot", {
     format: isPng ? "png" : "jpeg",
     quality: isPng ? undefined : (options.quality ?? 80),
     fromSurface: true,
     captureBeyondViewport: false,
     optimizeForSpeed: !isPng,
-    ...(clip ? { clip } : {}),
   });
   return Buffer.from(result.data, "base64");
 }

package/src/services/streamingEncoder.ts

@@ -221,33 +221,12 @@ export function buildStreamingArgs(
           else args.push("-global_quality", String(quality));
           break;
       }
-
-      // Mirror SW branch: GPU h264 paths emit B-frames by default (nvenc, qsv,
-      // vaapi) and produce the same negative-DTS freeze for downstream players.
-      // See chunkEncoder.buildEncoderArgs for the full explanation.
-      if (
-        codec === "h264" &&
-        (gpuEncoder === "nvenc" || gpuEncoder === "qsv" || gpuEncoder === "vaapi")
-      ) {
-        args.push("-bf", "0");
-        if (gpuEncoder === "qsv") {
-          args.push("-b_strategy", "0");
-        }
-      }
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
 
-      // Mirrors chunkEncoder: disable B-frames for h264 so PTS == DTS, no
-      // negative DTS at stream start. Without this, files freeze on the
-      // first frame in VS Code preview, several browsers, and some HW
-      // decoders. See chunkEncoder.buildEncoderArgs for the full reasoning.
-      if (codec === "h264") {
-        args.push("-bf", "0");
-      }
-
       // Encoder-specific params: anti-banding + color space tagging.
       // For HDR, getHdrEncoderColorParams also emits the SMPTE ST 2086
       // mastering-display and CTA-861.3 MaxCLL/MaxFALL SEI messages —
@@ -334,10 +313,6 @@ export function buildStreamingArgs(
     args.push("-pix_fmt", pixelFormat);
   }
 
-  // Belt-and-suspenders against negative DTS at stream start. See chunkEncoder
-  // for the full explanation; same playback compatibility class.
-  args.push("-avoid_negative_ts", "make_zero");
-
   args.push("-y", outputPath);
   return args;
 }

package/src/services/videoFrameExtractor.test.ts

@@ -1,13 +1,5 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -17,9 +9,6 @@ import {
   parseImageElements,
   extractAllVideoFrames,
   createFrameLookupTable,
-  resolveProjectRelativeSrc,
-  codecMayHaveAlpha,
-  decoderForCodec,
   type VideoElement,
   type ExtractedFrames,
 } from "./videoFrameExtractor.js";
@@ -34,111 +23,6 @@ import { runFfmpeg } from "../utils/runFfmpeg.js";
 // synthesized VFR fixture.
 const HAS_FFMPEG = spawnSync("ffmpeg", ["-version"]).status === 0;
 
-// Codec-based alpha defaulting replaces tag-based detection (the
-// alpha_mode/ALPHA_MODE case bug — see ffprobe.test.ts for the regression
-// pin on that). The extractor uses these helpers for two decisions:
-//   1. whether to force the alpha-aware decoder (libvpx-vp9 for VP9, libvpx
-//      for VP8)
-//   2. whether to default the cached frame format to PNG (with alpha) vs JPG
-// The "default to capable" trade is small file-size growth on opaque VP9
-// content for correctness on alpha-having content even when the sidecar tag
-// is missing or muxed with the wrong case.
-describe("codec alpha capability", () => {
-  it("flags VP9, VP8, and ProRes as alpha-capable", () => {
-    expect(codecMayHaveAlpha("vp9")).toBe(true);
-    expect(codecMayHaveAlpha("VP9")).toBe(true);
-    expect(codecMayHaveAlpha("vp8")).toBe(true);
-    expect(codecMayHaveAlpha("prores")).toBe(true);
-  });
-
-  it("does not flag h264 / h265 / mpeg4 (no alpha in their bitstreams)", () => {
-    expect(codecMayHaveAlpha("h264")).toBe(false);
-    expect(codecMayHaveAlpha("h265")).toBe(false);
-    expect(codecMayHaveAlpha("hevc")).toBe(false);
-    expect(codecMayHaveAlpha("mpeg4")).toBe(false);
-  });
-
-  it("treats undefined / empty input as non-alpha", () => {
-    expect(codecMayHaveAlpha(undefined)).toBe(false);
-    expect(codecMayHaveAlpha("")).toBe(false);
-  });
-
-  it("returns the alpha-aware decoder name for VP9 and VP8", () => {
-    expect(decoderForCodec("vp9")).toBe("libvpx-vp9");
-    expect(decoderForCodec("VP9")).toBe("libvpx-vp9");
-    expect(decoderForCodec("vp8")).toBe("libvpx");
-  });
-});
-
-// Regression: a long-standing footgun where `<video src="../assets/foo">`
-// inside a sub-composition silently dropped the video from extraction. The
-// browser's URL resolver clamps `..` at the served origin's root (so the
-// page renders fine in the studio), but `path.join(projectDir, "../assets/foo")`
-// normalizes to <parentOfProjectDir>/assets/foo, which doesn't exist —
-// extraction skipped, no frame injection, rendered output shows the video's
-// first decoded frame for the whole clip duration. The resolver now mirrors
-// browser semantics by clamping any traversal that escapes the project root.
-describe("resolveProjectRelativeSrc — sub-composition path clamping", () => {
-  let tmp: string;
-
-  beforeAll(() => {
-    tmp = mkdtempSync(join(tmpdir(), "hf-resolver-"));
-    mkdirSync(join(tmp, "project", "assets"), { recursive: true });
-    writeFileSync(join(tmp, "project", "assets", "foo.mp4"), "");
-  });
-  afterAll(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("returns the literal join when the file exists at projectDir/src", () => {
-    const projectDir = join(tmp, "project");
-    expect(resolveProjectRelativeSrc("assets/foo.mp4", projectDir)).toBe(
-      join(projectDir, "assets/foo.mp4"),
-    );
-  });
-
-  it("clamps a leading `../` so `../assets/foo.mp4` resolves to assets/foo.mp4", () => {
-    const projectDir = join(tmp, "project");
-    expect(resolveProjectRelativeSrc("../assets/foo.mp4", projectDir)).toBe(
-      join(projectDir, "assets/foo.mp4"),
-    );
-  });
-
-  it("clamps multiple leading `../../../` segments", () => {
-    const projectDir = join(tmp, "project");
-    expect(resolveProjectRelativeSrc("../../../assets/foo.mp4", projectDir)).toBe(
-      join(projectDir, "assets/foo.mp4"),
-    );
-  });
-
-  it("clamps mid-path traversal that escapes baseDir (not just leading `..`)", () => {
-    // `assets/../../foo.mp4` collapses past projectDir via path.join — this
-    // case used to silently escape; the resolver now strips embedded `..`
-    // segments and re-anchors at the project root.
-    const projectDir = join(tmp, "project");
-    expect(resolveProjectRelativeSrc("assets/../../assets/foo.mp4", projectDir)).toBe(
-      join(projectDir, "assets/foo.mp4"),
-    );
-  });
-
-  it("returns the (non-existent) base-dir path on miss so callers get a stable error message", () => {
-    const projectDir = join(tmp, "project");
-    expect(resolveProjectRelativeSrc("../assets/missing.mp4", projectDir)).toBe(
-      join(projectDir, "../assets/missing.mp4"),
-    );
-  });
-
-  it("prefers compiled-dir over base-dir when the file exists in both", () => {
-    const projectDir = join(tmp, "project");
-    const compiledDir = join(tmp, "compiled");
-    mkdirSync(join(compiledDir, "assets"), { recursive: true });
-    writeFileSync(join(compiledDir, "assets", "foo.mp4"), "");
-    expect(resolveProjectRelativeSrc("assets/foo.mp4", projectDir, compiledDir)).toBe(
-      join(compiledDir, "assets/foo.mp4"),
-    );
-  });
-});
-
 describe("parseVideoElements", () => {
   it("parses videos without an id or data-start attribute", () => {
     const videos = parseVideoElements('<video src="clip.mp4"></video>');

package/src/services/videoFrameExtractor.ts

@@ -7,7 +7,7 @@
 
 import { spawn } from "child_process";
 import { existsSync, mkdirSync, readdirSync, rmSync } from "fs";
-import { isAbsolute, join, posix, resolve, sep } from "path";
+import { isAbsolute, join } from "path";
 import { parseHTML } from "linkedom";
 import { extractMediaMetadata, type VideoMetadata } from "../utils/ffprobe.js";
 import {
@@ -230,17 +230,8 @@ export async function extractVideoFramesRange(
   if (isHdr && isMacOS) {
     args.push("-hwaccel", "videotoolbox");
   }
-  // Always force the alpha-aware decoder on codecs that can carry alpha. The
-  // alternative — gating on `metadata.hasAlpha` — relies on tag detection that
-  // has at least three known failure modes: case-sensitivity across ffmpeg
-  // versions (`alpha_mode` vs `ALPHA_MODE`), missing tags from older muxers,
-  // and mp4-as-webm rewraps that drop the sidecar. A wrong negative there
-  // silently strips alpha during decode and the bug doesn't surface until
-  // the rendered video is missing layers. Codec-based default has no such
-  // ambiguity: libvpx-vp9 reads the alpha sidecar when present and decodes
-  // normally when it isn't.
-  if (codecMayHaveAlpha(metadata.videoCodec)) {
-    args.push("-c:v", decoderForCodec(metadata.videoCodec));
+  if (metadata.hasAlpha && metadata.videoCodec === "vp9") {
+    args.push("-c:v", "libvpx-vp9");
   }
   args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
 
@@ -407,31 +398,9 @@ function resolveSegmentDuration(
   return sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
 }
 
-/**
- * Codecs whose bitstream is allowed to carry an alpha channel. Default the
- * extraction path to PNG output for these regardless of `metadata.hasAlpha`
- * so a missed sidecar tag doesn't silently strip transparency. Opaque content
- * encoded in one of these codecs pays a small file-size cost on the cached
- * frames but stays correct on the rare case where alpha IS present and the
- * tag was missed.
- */
-const ALPHA_CAPABLE_CODECS = new Set(["vp9", "vp8", "prores"]);
-
-export function codecMayHaveAlpha(codec: string | undefined): boolean {
-  return ALPHA_CAPABLE_CODECS.has((codec ?? "").toLowerCase());
-}
-
-export function decoderForCodec(codec: string | undefined): string {
-  const c = (codec ?? "").toLowerCase();
-  if (c === "vp9") return "libvpx-vp9";
-  if (c === "vp8") return "libvpx";
-  return c;
-}
-
 function resolveFrameFormat(metadata: VideoMetadata, requested?: "jpg" | "png"): CacheFrameFormat {
   if (requested) return requested;
-  if (metadata.hasAlpha || codecMayHaveAlpha(metadata.videoCodec)) return "png";
-  return "jpg";
+  return metadata.hasAlpha ? "png" : "jpg";
 }
 
 /**
@@ -490,54 +459,6 @@ async function convertVfrToCfr(
   }
 }
 
-/**
- * Resolve a relative `<video src>` to a filesystem path the way the browser
- * resolves it as a URL. Browsers clamp `..` segments at the served origin's
- * root; `path.join(projectDir, "../assets/foo")` does not. So a sub-comp
- * `<video src="../assets/foo">` loads in the page (browser clamps to
- * `<projectDir>/assets/foo`) but the filesystem-side resolver lands at
- * `<parentOfProjectDir>/assets/foo` — file missing, extraction skipped,
- * the rendered output shows the video's first frame for the whole clip.
- *
- * The clamp covers two escape patterns: leading `..` (`../assets/foo`) AND
- * mid-path escapes (`assets/../../foo`) that `path.join` collapses past the
- * project root silently. Both fall back to a project-rooted candidate that
- * strips traversal from the resolved path.
- *
- * Returns the first existing candidate, or the base-dir join on miss so
- * the caller's `existsSync` check produces a stable error path.
- */
-export function resolveProjectRelativeSrc(
-  src: string,
-  baseDir: string,
-  compiledDir?: string,
-): string {
-  const fromCompiled = compiledDir ? join(compiledDir, src) : null;
-  const fromBase = join(baseDir, src);
-  const candidates: string[] = [];
-  if (fromCompiled) candidates.push(fromCompiled);
-  candidates.push(fromBase);
-  // If the joined result escapes the project root (either via leading `..`
-  // or mid-path traversal that path.join collapsed past baseDir), retry
-  // with the basename re-anchored at the project root. This mirrors the
-  // browser URL clamp without relying on a particular `..` shape.
-  const baseAbs = resolve(baseDir);
-  const fromBaseAbs = resolve(fromBase);
-  if (!fromBaseAbs.startsWith(baseAbs + sep) && fromBaseAbs !== baseAbs) {
-    // Normalize first (`assets/../../assets/foo.mp4` → `../assets/foo.mp4`)
-    // then strip any remaining leading `..` segments. Stripping `..` from the
-    // raw input would leave dangling siblings (`assets/../../assets/foo`
-    // would become `assets/assets/foo` instead of `assets/foo`).
-    const normalized = posix.normalize(src.replace(/\\/g, "/"));
-    const stripped = normalized.replace(/^(\.\.\/)+/, "");
-    if (stripped && stripped !== src && !stripped.startsWith("..")) {
-      if (compiledDir) candidates.push(join(compiledDir, stripped));
-      candidates.push(join(baseDir, stripped));
-    }
-  }
-  return candidates.find(existsSync) ?? fromBase;
-}
-
 export async function extractAllVideoFrames(
   videos: VideoElement[],
   baseDir: string,
@@ -566,9 +487,6 @@ export async function extractAllVideoFrames(
   // Phase 1: Resolve paths and download remote videos
   const phase1Start = Date.now();
   const resolvedVideos: Array<{ video: VideoElement; videoPath: string }> = [];
-  // Dedupe missing-src warnings: a composition with N <video> elements all
-  // pointing at the same broken src should only print one warning, not N.
-  const warnedSrcs = new Set<string>();
   for (const video of videos) {
     if (signal?.aborted) break;
     try {
@@ -578,7 +496,9 @@ export async function extractAllVideoFrames(
       // baseDir and produce duplicated, nonexistent paths
       // (e.g. C:\tmp\hf-vfr-test-X\C:\tmp\hf-vfr-test-X\vfr_screen.mp4).
       if (!isAbsolute(videoPath) && !isHttpUrl(videoPath)) {
-        videoPath = resolveProjectRelativeSrc(video.src, baseDir, compiledDir);
+        const fromCompiled = compiledDir ? join(compiledDir, videoPath) : null;
+        videoPath =
+          fromCompiled && existsSync(fromCompiled) ? fromCompiled : join(baseDir, videoPath);
       }
 
       if (isHttpUrl(videoPath)) {
@@ -588,19 +508,6 @@ export async function extractAllVideoFrames(
       }
 
       if (!existsSync(videoPath)) {
-        // Loud: silent miss leaves the rendered video frozen at frame 0 with
-        // no error in stdout — extremely confusing for authors. Dedupe by
-        // src so 50 broken videos pointing at the same path don't spam.
-        if (!warnedSrcs.has(video.src)) {
-          warnedSrcs.add(video.src);
-          process.stderr.write(
-            `[hyperframes:render] WARNING: video src="${video.src}" ` +
-              `could not be resolved on disk (looked for ${videoPath}). ` +
-              `The rendered output will show this video's first frame for the entire clip duration. ` +
-              `If your <video> lives inside a sub-composition, prefer project-root-relative paths ` +
-              `(e.g. src="assets/foo.mp4") over "../assets/foo.mp4".\n`,
-          );
-        }
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }