hyperframes 0.8.163 → 0.8.164

package/dist/{capture-TKWJBFGC.js → capture-KSXWVLT7.js}

@@ -19,9 +19,10 @@ import {
   isPrivateUrl,
   mergeDrops,
   noDrops,
+  resolvePublicAddress,
   safeFetch,
   totalDrops
-} from "./chunk-OFD2XWIQ.js";
+} from "./chunk-SYOB5Y35.js";
 import {
   CaptureDirRefusedError,
   NavigationDeadlineError,
@@ -35,8 +36,10 @@ import {
   withRemainingBudget
 } from "./chunk-AWNBM3MZ.js";
 import {
-  launchManagedBrowser
-} from "./chunk-2ALJMIFW.js";
+  closeManagedBrowser,
+  launchManagedBrowser,
+  registerBrowserSessionCleanup
+} from "./chunk-57SASPYR.js";
 import "./chunk-Z6VBXCYN.js";
 import {
   writeNewFileSync
@@ -49,8 +52,9 @@ import {
   diag
 } from "./chunk-VWG7OQKU.js";
 import {
+  CAPTURE_ENV_KEYS,
   applyDotEnv
-} from "./chunk-NGKM64BP.js";
+} from "./chunk-5CTORVUM.js";
 import "./chunk-IGLEPPTN.js";
 import "./chunk-PBN6GBJE.js";
 import {
@@ -177,6 +181,220 @@ function writePartialCaptureBundle(opts, state, lastPhase) {
   };
 }
 
+// src/capture/launchCaptureBrowser.ts
+import { mkdtemp, mkdir, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
+// src/capture/browserLaunchArgs.ts
+function captureBrowserArgs(disableWebgl, viewportWidth, viewportHeight, platform = process.platform) {
+  const needsLinuxSandboxException = platform === "linux";
+  return [
+    ...needsLinuxSandboxException ? ["--no-sandbox"] : [],
+    "--disable-dev-shm-usage",
+    ...disableWebgl ? ["--disable-gpu"] : ["--enable-webgl", "--ignore-gpu-blocklist", "--use-gl=angle", "--use-angle=swiftshader"],
+    "--disable-blink-features=AutomationControlled",
+    "--disable-background-timer-throttling",
+    "--disable-renderer-backgrounding",
+    `--window-size=${viewportWidth},${viewportHeight}`
+  ];
+}
+
+// src/capture/captureProxy.ts
+import { createServer, request } from "http";
+import { connect } from "net";
+var CONNECTION_TIMEOUT_MS = 15e3;
+var HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "proxy-connection",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "keep-alive",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function forwardHeaders(message) {
+  const headers = { ...message.headers };
+  const connection = String(headers.connection ?? "").split(",");
+  for (const name of [...HOP_HEADERS, ...connection]) delete headers[name.trim().toLowerCase()];
+  return headers;
+}
+function destination(raw, tunnel) {
+  const url = new URL(tunnel ? `https://${raw}` : raw);
+  if (url.username || url.password || url.hash || (tunnel ? url.protocol !== "https:" || url.pathname !== "/" || !!url.search : url.protocol !== "http:")) {
+    throw new Error("Unsupported capture destination");
+  }
+  return url;
+}
+function refuse(response) {
+  if (!response.headersSent) response.writeHead(403, { Connection: "close" });
+  response.end();
+}
+async function forwardHttp(incoming, response, sockets) {
+  try {
+    const url = destination(incoming.url ?? "", false);
+    const address = await resolvePublicAddress(url.hostname);
+    if (incoming.destroyed || response.destroyed) return;
+    const headers = forwardHeaders(incoming);
+    headers.host = url.host;
+    const upstream = request(
+      {
+        hostname: address,
+        family: 4,
+        port: url.port || 80,
+        method: incoming.method,
+        path: url.pathname + url.search,
+        headers,
+        agent: false,
+        signal: AbortSignal.timeout(3e4)
+      },
+      (received) => {
+        response.writeHead(received.statusCode ?? 502, forwardHeaders(received));
+        received.on("error", () => response.destroy());
+        received.pipe(response);
+      }
+    );
+    upstream.on("socket", (socket) => trackSocket(socket, sockets));
+    upstream.setTimeout(
+      CONNECTION_TIMEOUT_MS,
+      () => upstream.destroy(new Error("Capture request timed out"))
+    );
+    upstream.on("error", () => {
+      if (!response.headersSent) response.writeHead(502, { Connection: "close" });
+      response.end();
+    });
+    response.on("close", () => upstream.destroy());
+    incoming.on("error", () => upstream.destroy());
+    incoming.pipe(upstream);
+  } catch {
+    refuse(response);
+  }
+}
+function trackSocket(socket, sockets) {
+  sockets.add(socket);
+  socket.once("close", () => sockets.delete(socket));
+  socket.on("error", () => socket.destroy());
+}
+async function forwardTunnel(incoming, client, head, sockets) {
+  try {
+    const url = destination(incoming.url ?? "", true);
+    const address = await resolvePublicAddress(url.hostname);
+    if (client.destroyed) return;
+    const upstream = connect({ host: address, family: 4, port: Number(url.port || 443) });
+    trackSocket(upstream, sockets);
+    const connectDeadline = setTimeout(() => upstream.destroy(), CONNECTION_TIMEOUT_MS);
+    connectDeadline.unref();
+    upstream.once("close", () => clearTimeout(connectDeadline));
+    upstream.setTimeout(CONNECTION_TIMEOUT_MS, () => upstream.destroy());
+    upstream.once("connect", () => {
+      clearTimeout(connectDeadline);
+      if (client.destroyed) return upstream.destroy();
+      client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      if (head.length) upstream.write(head);
+      upstream.pipe(client);
+      client.pipe(upstream);
+    });
+    upstream.once("close", () => client.destroy());
+    client.once("close", () => upstream.destroy());
+  } catch {
+    client.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+  }
+}
+async function startCaptureProxy() {
+  const sockets = /* @__PURE__ */ new Set();
+  const server = createServer(
+    (incoming, response) => void forwardHttp(incoming, response, sockets)
+  );
+  server.on("connection", (socket) => trackSocket(socket, sockets));
+  server.on(
+    "connect",
+    (incoming, socket, head) => void forwardTunnel(incoming, socket, head, sockets)
+  );
+  server.on("upgrade", (_incoming, socket) => socket.destroy());
+  server.maxConnections = 128;
+  server.headersTimeout = CONNECTION_TIMEOUT_MS;
+  server.requestTimeout = 3e4;
+  server.keepAliveTimeout = 1e3;
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve2);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Capture proxy did not bind");
+  let closing;
+  return {
+    url: `http://127.0.0.1:${address.port}`,
+    close() {
+      closing ??= new Promise((resolve2) => {
+        server.close(() => resolve2());
+        for (const socket of sockets) socket.destroy();
+      });
+      return closing;
+    }
+  };
+}
+
+// src/capture/launchCaptureBrowser.ts
+async function launchCaptureBrowser(options) {
+  const proxy = await startCaptureProxy();
+  let profile;
+  let browser;
+  let closing;
+  let unregister;
+  const close = () => {
+    closing ??= (async () => {
+      try {
+        await proxy.close();
+        if (browser) await closeManagedBrowser(browser);
+      } finally {
+        try {
+          if (profile) await rm(profile, { recursive: true, force: true });
+        } finally {
+          unregister?.();
+        }
+      }
+    })();
+    return closing;
+  };
+  try {
+    const profilePath = await mkdtemp(join2(tmpdir(), "hf-capture-profile-"));
+    profile = profilePath;
+    await mkdir(join2(profile, "Default"));
+    await writeFile(
+      join2(profile, "Default", "Preferences"),
+      JSON.stringify({
+        webrtc: { ip_handling_policy: "disable_non_proxied_udp" }
+      })
+    );
+    unregister = registerBrowserSessionCleanup(close);
+    const puppeteer = await import("puppeteer-core");
+    browser = await launchManagedBrowser(puppeteer.default, {
+      headless: true,
+      userDataDir: profile,
+      executablePath: options.executablePath,
+      protocolTimeout: options.protocolTimeout,
+      // Linux containers may lack the user namespaces Chromium's sandbox requires.
+      args: [
+        ...captureBrowserArgs(options.disableWebgl, options.width, options.height),
+        `--proxy-server=${proxy.url}`,
+        "--proxy-bypass-list=<-loopback>",
+        "--disable-quic",
+        "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"
+      ]
+    });
+    browser.once("disconnected", () => void proxy.close());
+    return {
+      browser,
+      close
+    };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
 // src/capture/lottieValidation.ts
 import AdmZip from "adm-zip";
 
@@ -398,7 +616,7 @@ function candidatePriority(url, contentType) {
 
 // src/capture/captureAttempt.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/capture/lazyScrollForCapture.ts
 var LAZY_SCROLL_STEP_DELAY_MS = 400;
@@ -650,14 +868,15 @@ async function collectAnimationCatalog(page, cdpAnimations, cdp, opts = {}) {
 
 // src/capture/scaffolding.ts
 import { existsSync, readFileSync } from "fs";
-import { join as join2, resolve } from "path";
+import { join as join3, resolve } from "path";
 function loadEnvFile(startDir) {
+  if (process.env.HYPERFRAMES_NO_CAPTURE_DOTENV === "1") return;
   try {
     let dir = resolve(startDir);
     for (let i = 0; i < 5; i++) {
       const envPath = resolve(dir, ".env");
       try {
-        applyDotEnv(readFileSync(envPath, "utf-8"), process.env);
+        applyDotEnv(readFileSync(envPath, "utf-8"), process.env, CAPTURE_ENV_KEYS);
         break;
       } catch {
         dir = resolve(dir, "..");
@@ -667,7 +886,7 @@ function loadEnvFile(startDir) {
   }
 }
 async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
-  const metaPath = join2(outputDir, "meta.json");
+  const metaPath = join3(outputDir, "meta.json");
   if (!existsSync(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
     writeNewFileSync(
@@ -694,19 +913,6 @@ async function generateProjectScaffold(outputDir, url, tokens, animationCatalog,
   }
 }
 
-// src/capture/browserLaunchArgs.ts
-function captureBrowserArgs(disableWebgl, viewportWidth, viewportHeight) {
-  return [
-    "--no-sandbox",
-    "--disable-dev-shm-usage",
-    ...disableWebgl ? ["--disable-gpu"] : ["--enable-webgl", "--ignore-gpu-blocklist", "--use-gl=angle", "--use-angle=swiftshader"],
-    "--disable-blink-features=AutomationControlled",
-    "--disable-background-timer-throttling",
-    "--disable-renderer-backgrounding",
-    `--window-size=${viewportWidth},${viewportHeight}`
-  ];
-}
-
 // src/capture/pageBlockDetection.ts
 function detectBlockedPage(evidence) {
   const isMinimalDom = evidence.bodyChildCount <= 5 && evidence.textLength < 500;
@@ -758,18 +964,18 @@ async function navigateForCapture(page, url, totalTimeoutMs) {
 }
 
 // src/capture/responseRecord.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var RESPONSE_RECORD_FILENAME = "response.json";
 function writeResponseRecord(extractedDir, record2) {
   writeCaptureFileSync(
-    join3(extractedDir, RESPONSE_RECORD_FILENAME),
+    join4(extractedDir, RESPONSE_RECORD_FILENAME),
     JSON.stringify(record2, null, 2),
     "utf-8"
   );
 }
 
 // src/capture/navigationPhase.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 async function navigatePage(context) {
   let navigation;
   try {
@@ -823,7 +1029,7 @@ async function checkPageContent(context) {
 function persistNavigationResult(context, navigationResponse, pageContentCheck) {
   context.httpStatus = navigationResponse ? navigationResponse.status() : null;
   if (context.canWrite()) {
-    writeResponseRecord(join4(context.outputDir, "extracted"), { status: context.httpStatus });
+    writeResponseRecord(join5(context.outputDir, "extracted"), { status: context.httpStatus });
   }
   const blockedReason = detectBlockedPage({
     httpStatus: context.httpStatus,
@@ -858,7 +1064,7 @@ import {
   fstatSync,
   closeSync
 } from "fs";
-import { basename, join as join5 } from "path";
+import { basename, join as join6 } from "path";
 var DEFAULT_VISION_REQUEST_TIMEOUT_MS = 3e4;
 function resolveVisionPhaseCompletion(outcome, remainingMs) {
   if (outcome.budgetExhausted || remainingMs <= 0) {
@@ -885,7 +1091,7 @@ function resolveVisionRequestTimeoutMs() {
   const configured = Number(process.env.HYPERFRAMES_VISION_TIMEOUT_MS);
   return Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_VISION_REQUEST_TIMEOUT_MS;
 }
-async function runBoundedVisionRequest(request, timeoutMs) {
+async function runBoundedVisionRequest(request2, timeoutMs) {
   const controller = new AbortController();
   let timer;
   const timeout = new Promise((_resolve, reject) => {
@@ -895,7 +1101,7 @@ async function runBoundedVisionRequest(request, timeoutMs) {
     }, timeoutMs);
   });
   try {
-    return await Promise.race([request(controller.signal), timeout]);
+    return await Promise.race([request2(controller.signal), timeout]);
   } finally {
     if (timer) clearTimeout(timer);
   }
@@ -1146,7 +1352,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
         return response.text?.trim() || "";
       };
     }
-    const imageFiles = readdirSync(join5(outputDir, "assets")).filter(
+    const imageFiles = readdirSync(join6(outputDir, "assets")).filter(
       (f) => /\.(png|jpg|jpeg|webp|gif)$/i.test(f)
     );
     const BATCH_SIZE = 20;
@@ -1174,7 +1380,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
       const batch = imageFiles.slice(i, i + BATCH_SIZE);
       const results = await Promise.allSettled(
         batch.map(async (file) => {
-          const filePath = join5(outputDir, "assets", file);
+          const filePath = join6(outputDir, "assets", file);
           const fd = openSync(filePath, "r", 384);
           let buffer;
           try {
@@ -1213,11 +1419,11 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
       `${Object.keys(geminiCaptions).length} images captioned with ${providerName}`
     );
     const svgFiles = [];
-    const assetsDir = join5(outputDir, "assets");
+    const assetsDir = join6(outputDir, "assets");
     for (const f of readdirSync(assetsDir)) {
       if (/\.svg$/i.test(f)) svgFiles.push({ file: f, relPath: f });
     }
-    const svgsSubdir = join5(assetsDir, "svgs");
+    const svgsSubdir = join6(assetsDir, "svgs");
     if (existsSync2(svgsSubdir)) {
       for (const f of readdirSync(svgsSubdir)) {
         if (/\.svg$/i.test(f)) svgFiles.push({ file: f, relPath: `svgs/${f}` });
@@ -1251,7 +1457,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
         sharp.concurrency(1);
         try {
           for (const { relPath } of batch) {
-            const filePath = join5(assetsDir, relPath);
+            const filePath = join6(assetsDir, relPath);
             try {
               const svgSource = readFileSync2(filePath, "utf-8");
               const lightFillHits = (svgSource.match(/fill\s*=\s*["'](#fff(fff)?|white|#[ef][ef][ef]|#[ef]{6})["']/gi) || []).length;
@@ -1326,11 +1532,11 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join5(outputDir, "assets");
+  const assetsPath = join6(outputDir, "assets");
   try {
     for (const file of readdirSync(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join5(assetsPath, file);
+      const filePath = join6(assetsPath, file);
       const stat = statSync(filePath);
       if (!stat.isFile()) continue;
       const sizeKb = Math.round(stat.size / 1024);
@@ -1359,7 +1565,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join5(assetsPath, "svgs");
+    const svgsPath = join6(assetsPath, "svgs");
     for (const file of readdirSync(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
@@ -1378,7 +1584,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join5(assetsPath, "fonts");
+    const fontsPath = join6(assetsPath, "fonts");
     for (const file of readdirSync(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
@@ -1387,7 +1593,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const videoLines = [];
   try {
     const manifest = JSON.parse(
-      readFileSync2(join5(outputDir, "extracted", "video-manifest.json"), "utf-8")
+      readFileSync2(join6(outputDir, "extracted", "video-manifest.json"), "utf-8")
     );
     for (const v of manifest) {
       if (!v.localPath) continue;
@@ -1405,7 +1611,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
 }
 
 // src/capture/coreExtractionPhase.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/capture/htmlExtractor.ts
 var DEFAULT_SETTLE_TIME = 3e3;
@@ -1417,12 +1623,15 @@ async function extractHtml(page, opts = {}) {
   })()`);
   for (const href of stylesheetUrls) {
     try {
-      if (isPrivateUrl(href)) continue;
-      const res = await fetch(href, {
+      const res = await safeFetch(href, {
         signal: AbortSignal.timeout(1e4),
         headers: { "User-Agent": CAPTURE_USER_AGENT }
       });
-      if (!res.ok) continue;
+      if (!res?.ok) {
+        await res?.body?.cancel().catch(() => {
+        });
+        continue;
+      }
       let css = await res.text();
       css = css.replace(/url\(\s*['"]?([^'")\s]+)['"]?\s*\)/g, (match, url) => {
         if (url.startsWith("data:") || url.startsWith("http") || url.startsWith("//")) return match;
@@ -2616,7 +2825,7 @@ async function extractDesignStyles(page) {
 
 // src/capture/mediaCapture.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { join as join6, extname } from "path";
+import { join as join7, extname } from "path";
 
 // src/capture/lottiePreviewRequests.ts
 var LOTTIE_RUNTIME_URL = "https://cdnjs.cloudflare.com/ajax/libs/lottie-web/5.12.2/lottie.min.js";
@@ -2628,9 +2837,9 @@ function allowedLottieRequest(url, resourceType) {
 }
 async function guardLottiePreviewRequests(page) {
   await page.setRequestInterception(true);
-  page.on("request", (request) => {
-    if (request.isInterceptResolutionHandled()) return;
-    const action = allowedLottieRequest(request.url(), request.resourceType()) ? request.continue() : request.abort("blockedbyclient");
+  page.on("request", (request2) => {
+    if (request2.isInterceptResolutionHandled()) return;
+    const action = allowedLottieRequest(request2.url(), request2.resourceType()) ? request2.continue() : request2.abort("blockedbyclient");
     void action.catch(() => {
     });
   });
@@ -2675,7 +2884,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir, outputDir, bud
         if (savedHashes.has(hash)) continue;
         savedHashes.add(hash);
         if (!validLottieJson(jsonData)) continue;
-        writeCaptureFileSync(join6(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeCaptureFileSync(join7(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -2685,18 +2894,18 @@ async function saveLottieAnimations(discoveredLotties, lottieDir, outputDir, bud
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget = {}) {
   const manifest = [];
-  const previewDir = join6(lottieDir, "previews");
+  const previewDir = join7(lottieDir, "previews");
   ensureCaptureDirSync(outputDir, previewDir);
   for (const file of readdirSync2(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     if (liveRemainingMs(budget, 1) <= 0) break;
     try {
-      const raw = JSON.parse(readFileSync3(join6(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync3(join7(lottieDir, file), "utf-8"));
       const fr = raw.fr || 30;
       const dur = ((raw.op || 0) - (raw.ip || 0)) / fr;
       const previewName = file.replace(".json", "-preview.png");
       let preview;
-      const fileSize = statSync2(join6(lottieDir, file)).size;
+      const fileSize = statSync2(join7(lottieDir, file)).size;
       if (fileSize > 2e6) continue;
       let previewPage;
       try {
@@ -2705,7 +2914,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
         if (liveRemainingMs(budget, 1) <= 0) break;
         await guardLottiePreviewRequests(previewPage);
         await previewPage.setViewport({ width: 400, height: 400 });
-        const animData = JSON.parse(readFileSync3(join6(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync3(join7(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -2736,7 +2945,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
         });
         if (liveRemainingMs(budget, 1) > 0) {
           const shot = await previewPage.screenshot({ type: "png", omitBackground: true });
-          writeCaptureFileSync(join6(previewDir, previewName), shot);
+          writeCaptureFileSync(join7(previewDir, previewName), shot);
           preview = `assets/lottie/previews/${previewName}`;
         }
       } catch {
@@ -2759,7 +2968,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
   }
   if (manifest.length > 0) {
     writeCaptureFileSync(
-      join6(outputDir, "extracted", "lottie-manifest.json"),
+      join7(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -2800,7 +3009,7 @@ async function downloadVideoBody(srcUrl, filename, videosDir, timeoutMs) {
     }
     if (total < 1024) return null;
     const safe = /\.[a-z0-9]+$/i.test(filename) ? filename.replace(/[^\w.-]/g, "_") : `video${ext}`;
-    writeCaptureFileSync(join6(videosDir, safe), Buffer.concat(chunks));
+    writeCaptureFileSync(join7(videosDir, safe), Buffer.concat(chunks));
     return `assets/videos/${safe}`;
   } catch {
     return null;
@@ -2912,9 +3121,9 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
   }
   const merged = [...byKey.values()];
   if (merged.length === 0) return;
-  const videoManifestDir = join6(outputDir, "assets", "videos");
+  const videoManifestDir = join7(outputDir, "assets", "videos");
   ensureCaptureDirSync(outputDir, videoManifestDir);
-  const previewDir = join6(videoManifestDir, "previews");
+  const previewDir = join7(videoManifestDir, "previews");
   ensureCaptureDirSync(outputDir, previewDir);
   const videoManifest = [];
   const dlStart = Date.now();
@@ -2951,7 +3160,7 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
                 height: Math.min(rect.height, 1080)
               }
             });
-            writeCaptureFileSync(join6(previewDir, previewName), shot);
+            writeCaptureFileSync(join7(previewDir, previewName), shot);
             preview = `assets/videos/previews/${previewName}`;
           }
         }
@@ -2981,7 +3190,7 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
   }
   if (videoManifest.length > 0) {
     writeCaptureFileSync(
-      join6(outputDir, "extracted", "video-manifest.json"),
+      join7(outputDir, "extracted", "video-manifest.json"),
       JSON.stringify(videoManifest, null, 2),
       "utf-8"
     );
@@ -3126,7 +3335,7 @@ async function runCoreExtraction(input) {
     await collectNetworkLotties();
     const saveDiscoveredLotties = async () => {
       if (discoveredLotties.length > 0 && remainingMs() > 0) {
-        const lottieDir = join7(outputDir, "assets", "lottie");
+        const lottieDir = join8(outputDir, "assets", "lottie");
         if (!canWrite()) return;
         const lottieBudget = { remainingMs, byteBudget: downloadByteBudget };
         const savedCount = await saveLottieAnimations(
@@ -3158,7 +3367,7 @@ async function runCoreExtraction(input) {
         capturedShaders = unique;
         if (canWrite()) {
           writeCaptureFileSync(
-            join7(outputDir, "extracted", "shaders.json"),
+            join8(outputDir, "extracted", "shaders.json"),
             JSON.stringify(unique, null, 2),
             "utf-8"
           );
@@ -3176,7 +3385,7 @@ async function runCoreExtraction(input) {
     state.tokens = tokens;
     if (canWrite()) {
       writeCaptureFileSync(
-        join7(outputDir, "extracted", "tokens.json"),
+        join8(outputDir, "extracted", "tokens.json"),
         serializeTokensForCapture(tokens),
         "utf-8"
       );
@@ -3187,7 +3396,7 @@ async function runCoreExtraction(input) {
       state.designStyles = designStyles;
       if (canWrite()) {
         writeCaptureFileSync(
-          join7(outputDir, "extracted", "design-styles.json"),
+          join8(outputDir, "extracted", "design-styles.json"),
           JSON.stringify(designStyles, null, 2),
           "utf-8"
         );
@@ -3271,7 +3480,7 @@ ${err.stack}` : normalizeErrorMessage(err);
   const runHtmlExtraction = async () => {
     progress("design", "Cataloging assets...");
     try {
-      const { catalogAssets } = await import("./assetCataloger-YWJRJK23.js");
+      const { catalogAssets } = await import("./assetCataloger-FE4K64GW.js");
       catalogedAssets = await catalogAssets(page1);
       progress("design", `${catalogedAssets.length} assets cataloged`);
       if (catalogedAssets.length === 0) {
@@ -3337,11 +3546,11 @@ ${err.stack}` : normalizeErrorMessage(err);
 
 // src/capture/postExtractionPhase.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/capture/fontMetadataExtractor.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import * as fontkit from "fontkit";
 function isFontCollection(value) {
   return value.type === "TTC" || value.type === "DFont";
@@ -3352,7 +3561,7 @@ function extractFontMetadata(fontsDir, outputPath) {
   if (existsSync3(fontsDir)) {
     const fontFiles = readdirSync3(fontsDir).filter((f) => /\.(woff2?|ttf|otf)$/i.test(f));
     for (const filename of fontFiles) {
-      const fullPath = join8(fontsDir, filename);
+      const fullPath = join9(fontsDir, filename);
       const meta = readSingleFont(fullPath, filename);
       if (meta.identified) {
         files.push(meta);
@@ -3526,7 +3735,7 @@ function hasVisionCredentials(skipVision) {
 }
 function writeAssetDescriptionsFile(outputDir, lines, header) {
   writeCaptureFileSync(
-    join9(outputDir, "extracted", "asset-descriptions.md"),
+    join10(outputDir, "extracted", "asset-descriptions.md"),
     header + lines.map((line) => `- ${line}`).join("\n") + "\n",
     "utf-8"
   );
@@ -3569,8 +3778,8 @@ async function runPostExtraction(input) {
     );
     try {
       const fontsManifest = extractFontMetadata(
-        join9(outputDir, "assets", "fonts"),
-        join9(outputDir, "extracted", "fonts-manifest.json")
+        join10(outputDir, "assets", "fonts"),
+        join10(outputDir, "extracted", "fonts-manifest.json")
       );
       if (fontsManifest.families.length > 0) {
         const summary = fontsManifest.families.map((f) => `${f.family}${f.variable ? " (variable)" : ""} \xD7 ${f.fileCount}`).join(", ");
@@ -3601,7 +3810,7 @@ async function runPostExtraction(input) {
       };
       if (canWrite()) {
         writeCaptureFileSync(
-          join9(outputDir, "extracted", "animations.json"),
+          join10(outputDir, "extracted", "animations.json"),
           JSON.stringify(leanCatalog, null, 2),
           "utf-8"
         );
@@ -3624,7 +3833,7 @@ async function runPostExtraction(input) {
         state.assets = assets;
         if (canWrite()) {
           writeCaptureFileSync(
-            join9(outputDir, "extracted", "icons-manifest.json"),
+            join10(outputDir, "extracted", "icons-manifest.json"),
             JSON.stringify(assetPass.icons, null, 2),
             "utf-8"
           );
@@ -3676,7 +3885,7 @@ async function runPostExtraction(input) {
       if (assets.length && Array.isArray(tokens.sections)) {
         if (canWrite()) {
           writeCaptureFileSync(
-            join9(outputDir, "extracted", "tokens.json"),
+            join10(outputDir, "extracted", "tokens.json"),
             serializeTokensForCapture(tokens),
             "utf-8"
           );
@@ -3699,14 +3908,14 @@ ${extracted.bodyHtml}
 `;
     state.pageHtml = pageHtml;
     if (canWrite())
-      writeCaptureFileSync(join9(outputDir, "extracted", "page.html"), pageHtml, "utf-8");
+      writeCaptureFileSync(join10(outputDir, "extracted", "page.html"), pageHtml, "utf-8");
   } catch (err) {
     warnings.push(`page.html write failed: ${err}`);
   }
   if (visibleTextContent) {
     if (canWrite()) {
       writeCaptureFileSync(
-        join9(outputDir, "extracted", "visible-text.txt"),
+        join10(outputDir, "extracted", "visible-text.txt"),
         visibleTextContent,
         "utf-8"
       );
@@ -3768,8 +3977,8 @@ ${extracted.bodyHtml}
         const contactSheetBudget = { remainingMs };
         const runScrollContactSheet = async () => {
           const scrollSheets = await createScrollContactSheet(
-            join9(outputDir, "screenshots"),
-            join9(outputDir, "screenshots", "contact-sheet.jpg"),
+            join10(outputDir, "screenshots"),
+            join10(outputDir, "screenshots", "contact-sheet.jpg"),
             contactSheetBudget
           );
           if (scrollSheets.length > 0)
@@ -3780,11 +3989,11 @@ ${extracted.bodyHtml}
         };
         await runScrollContactSheet();
         const runAssetContactSheet = async () => {
-          const assetsImgDir = join9(outputDir, "assets");
+          const assetsImgDir = join10(outputDir, "assets");
           if (existsSync4(assetsImgDir)) {
             const assetSheets = await createAssetContactSheet(
               assetsImgDir,
-              join9(outputDir, "assets", "contact-sheet.jpg"),
+              join10(outputDir, "assets", "contact-sheet.jpg"),
               contactSheetBudget
             );
             if (assetSheets.length > 0)
@@ -3796,11 +4005,11 @@ ${extracted.bodyHtml}
         };
         await runAssetContactSheet();
         const runSvgContactSheet = async () => {
-          const svgsDir = join9(outputDir, "assets", "svgs");
-          const assetsRootDir = join9(outputDir, "assets");
+          const svgsDir = join10(outputDir, "assets", "svgs");
+          const assetsRootDir = join10(outputDir, "assets");
           const hasSvgsDir = existsSync4(svgsDir);
           if (hasSvgsDir) ensureCaptureDirSync(outputDir, svgsDir);
-          const svgOutputPath = hasSvgsDir ? join9(outputDir, "assets", "svgs", "contact-sheet.jpg") : join9(outputDir, "assets", "contact-sheet-svgs.jpg");
+          const svgOutputPath = hasSvgsDir ? join10(outputDir, "assets", "svgs", "contact-sheet.jpg") : join10(outputDir, "assets", "contact-sheet-svgs.jpg");
           const svgSheets = await createSvgContactSheet(
             svgsDir,
             svgOutputPath,
@@ -3850,6 +4059,10 @@ async function captureWebsiteAttempt(opts, onProgress, disableWebgl, watchdog, s
     postNavigationBudgetMs = DEFAULT_POST_NAVIGATION_BUDGET_MS,
     onPhase
   } = opts;
+  const initialUrl = new URL(url);
+  if (!["http:", "https:"].includes(initialUrl.protocol) || initialUrl.username || initialUrl.password) {
+    throw new Error("Capture requires a public HTTP or HTTPS URL without credentials");
+  }
   const downloadByteBudget = createCaptureDownloadBudget();
   const warnings = [...state.warnings];
   state.warnings = warnings;
@@ -3880,20 +4093,21 @@ async function captureWebsiteAttempt(opts, onProgress, disableWebgl, watchdog, s
   };
   phase("browser", "started");
   loadEnvFile(outputDir);
-  ensureCaptureDirSync(outputDir, join10(outputDir, "extracted"));
-  ensureCaptureDirSync(outputDir, join10(outputDir, "screenshots"));
-  ensureCaptureDirSync(outputDir, join10(outputDir, "assets"));
+  ensureCaptureDirSync(outputDir, join11(outputDir, "extracted"));
+  ensureCaptureDirSync(outputDir, join11(outputDir, "screenshots"));
+  ensureCaptureDirSync(outputDir, join11(outputDir, "assets"));
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser } = await import("./manager-HEUPD2YB.js");
   const browser = await ensureBrowser();
-  const puppeteer = await import("puppeteer-core");
-  const chromeBrowser = await launchManagedBrowser(puppeteer.default, {
-    headless: true,
+  const captureBrowser = await launchCaptureBrowser({
     executablePath: browser.executablePath,
     protocolTimeout: captureProtocolTimeoutMs(timeout, budgetMs),
-    args: captureBrowserArgs(disableWebgl, viewportWidth, viewportHeight)
+    disableWebgl,
+    width: viewportWidth,
+    height: viewportHeight
   });
-  watchdog.registerBrowser(chromeBrowser);
+  const chromeBrowser = captureBrowser.browser;
+  watchdog.registerBrowser(captureBrowser);
   let animationCatalog;
   let tokens = state.tokens;
   let extracted = state.extracted;
@@ -4052,7 +4266,7 @@ async function captureWebsiteAttempt(opts, onProgress, disableWebgl, watchdog, s
         animationCatalog,
         screenshots.length > 0,
         discoveredLotties.length > 0,
-        existsSync5(join10(outputDir, "extracted", "shaders.json")),
+        existsSync5(join11(outputDir, "extracted", "shaders.json")),
         catalogedAssets,
         progress,
         warnings,
@@ -4083,8 +4297,8 @@ async function captureWebsiteAttempt(opts, onProgress, disableWebgl, watchdog, s
       lastPhase
     };
   } finally {
-    watchdog.unregisterBrowser(chromeBrowser);
-    await chromeBrowser.close();
+    watchdog.unregisterBrowser(captureBrowser);
+    await captureBrowser.close();
   }
 }