@grabbit-labs/dynafetch 0.1.3 → 0.2.0

package/dist/index.js

@@ -0,0 +1,3050 @@
+import { createRequire } from "node:module"; import { fileURLToPath as __fileURLToPath } from "node:url"; import { dirname as __dirname_fn } from "node:path"; const __filename = __fileURLToPath(import.meta.url); const __dirname = __dirname_fn(__filename); const require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../dynafetch-core/src/index.ts
+import * as net from "node:net";
+
+// ../../src/phantom/execute.ts
+import { JSDOM, VirtualConsole, CookieJar } from "jsdom";
+import WebSocket from "ws";
+import * as nodeCrypto from "crypto";
+
+// ../../src/phantom/transform.ts
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var CACHE_DIR = path.join(process.cwd(), ".next/cache/phantom");
+try {
+  if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
+} catch {
+}
+var memCache = /* @__PURE__ */ new Map();
+var fsCacheEnabled = true;
+var Transformer = class {
+  transform(code, scriptId) {
+    const hash = crypto.createHash("sha256").update(code).digest("hex");
+    const cachePath = path.join(CACHE_DIR, `${hash}.js`);
+    const memHit = memCache.get(hash);
+    if (memHit) return memHit;
+    if (fsCacheEnabled) {
+      try {
+        if (fs.existsSync(cachePath)) {
+          const diskHit = fs.readFileSync(cachePath, "utf-8");
+          memCache.set(hash, diskHit);
+          return diskHit;
+        }
+      } catch {
+        fsCacheEnabled = false;
+      }
+    }
+    const needsRewrite = process.env.PHANTOM_ENABLE_AST_IMPORT_REWRITE === "1" && code.includes("import(");
+    if (!needsRewrite) {
+      const passthrough = `try { ${code}
+ } catch(e) { console.warn('Script ${scriptId} runtime error:', e); }`;
+      memCache.set(hash, passthrough);
+      if (fsCacheEnabled) {
+        try {
+          fs.writeFileSync(cachePath, passthrough);
+        } catch {
+          fsCacheEnabled = false;
+        }
+      }
+      return passthrough;
+    }
+    let ast;
+    try {
+      ast = parse(code, {
+        sourceType: "unambiguous",
+        plugins: ["typescript", "jsx"]
+      });
+    } catch (e) {
+      const fallback = `try { ${code} } catch(e) { console.error('Script ${scriptId} failed:', e); }`;
+      memCache.set(hash, fallback);
+      if (fsCacheEnabled) {
+        try {
+          fs.writeFileSync(cachePath, fallback);
+        } catch {
+          fsCacheEnabled = false;
+        }
+      }
+      return fallback;
+    }
+    traverse(ast, {
+      CallExpression(path3) {
+        if (path3.node.callee.type === "Import") {
+          path3.replaceWith(
+            t.callExpression(
+              t.memberExpression(
+                t.identifier("__phantom"),
+                t.identifier("dynamicImport")
+              ),
+              path3.node.arguments
+            )
+          );
+        }
+      }
+    });
+    const output = generate(ast, { compact: true, minified: true }, code);
+    const result = `try { 
+      ${output.code} 
+    } catch(e) { 
+      console.warn('Script ${scriptId} runtime error:', e); 
+    }`;
+    memCache.set(hash, result);
+    if (fsCacheEnabled) {
+      try {
+        fs.writeFileSync(cachePath, result);
+      } catch {
+        fsCacheEnabled = false;
+      }
+    }
+    return result;
+  }
+};
+
+// ../dynafetch-core/src/net/worker-client.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import path2 from "node:path";
+import readline from "node:readline";
+var sessionStore = new AsyncLocalStorage();
+var transportPromise = null;
+function findPrecompiledBinary() {
+  const platform = process.platform;
+  const arch = process.arch === "x64" ? "x64" : "arm64";
+  const ext = platform === "win32" ? ".exe" : "";
+  const name = `dynafetch-net-${platform}-${arch}${ext}`;
+  const candidates = [
+    path2.resolve(__dirname, "../bin", name),
+    // installed: dist/../bin
+    path2.resolve(__dirname, "../../../dynafetch-net/bin", name),
+    // dev: dynafetch-core/src/net -> dynafetch-net/bin
+    path2.resolve(__dirname, "../../../../packages/dynafetch-net/bin", name),
+    // dev: alt layout
+    path2.resolve(process.cwd(), "packages/dynafetch-net/bin", name)
+    // dev: from workspace root
+  ];
+  for (const candidate of candidates) {
+    try {
+      const fs2 = __require("fs");
+      fs2.accessSync(candidate, fs2.constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function createWorkerCommand() {
+  const explicitBin = process.env.DYNAFETCH_NET_BIN?.trim();
+  if (explicitBin) {
+    return { command: explicitBin, args: [] };
+  }
+  const precompiled = findPrecompiledBinary();
+  if (precompiled) {
+    return { command: precompiled, args: [] };
+  }
+  return {
+    command: "go",
+    args: ["run", "."],
+    cwd: path2.resolve(process.cwd(), "packages/dynafetch-net")
+  };
+}
+function createWorkerTransport() {
+  const { command, args, cwd } = createWorkerCommand();
+  const child = spawn(command, args, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+  const pending = /* @__PURE__ */ new Map();
+  const rl = readline.createInterface({ input: child.stdout });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let payload;
+    try {
+      payload = JSON.parse(trimmed);
+    } catch (error) {
+      for (const entry of pending.values()) {
+        entry.reject(new Error(`Invalid dynafetch-net response: ${String(error)}`));
+      }
+      pending.clear();
+      return;
+    }
+    const request = pending.get(payload.id);
+    if (!request) return;
+    pending.delete(payload.id);
+    if (payload.error) {
+      request.reject(new Error(payload.error.message || payload.error.code || "dynafetch-net request failed"));
+      return;
+    }
+    request.resolve(payload.result);
+  });
+  child.stderr.on("data", (chunk) => {
+    const message = chunk.toString().trim();
+    if (message) {
+      console.warn(`[dynafetch-net] ${message}`);
+    }
+  });
+  const onExit = (code, signal) => {
+    const reason = `dynafetch-net exited (code=${code ?? "null"}, signal=${signal ?? "null"})`;
+    for (const entry of pending.values()) {
+      entry.reject(new Error(reason));
+    }
+    pending.clear();
+    transportPromise = null;
+  };
+  child.once("error", (error) => {
+    for (const entry of pending.values()) {
+      entry.reject(error);
+    }
+    pending.clear();
+    transportPromise = null;
+  });
+  child.once("exit", onExit);
+  return Promise.resolve({ child, pending });
+}
+async function getWorkerTransport() {
+  if (!transportPromise) {
+    transportPromise = createWorkerTransport();
+  }
+  return transportPromise;
+}
+async function callWorker(method, params) {
+  const transport = await getWorkerTransport();
+  const id = randomUUID();
+  const payload = JSON.stringify({ id, method, params });
+  return await new Promise((resolve, reject) => {
+    transport.pending.set(id, { resolve, reject });
+    transport.child.stdin.write(`${payload}
+`, (error) => {
+      if (!error) return;
+      transport.pending.delete(id);
+      reject(error);
+    });
+  });
+}
+async function withDynafetchSession(options, run) {
+  const session = await callWorker("openSession", options);
+  try {
+    return await sessionStore.run({ sessionId: session.sessionId }, run);
+  } finally {
+    await callWorker("closeSession", { sessionId: session.sessionId }).catch(() => {
+    });
+  }
+}
+async function dynafetchNetHealth() {
+  return await callWorker("health", {});
+}
+async function dynafetchNetFetch(request, options = {}) {
+  const session = sessionStore.getStore();
+  return await callWorker("fetch", {
+    sessionId: session?.sessionId,
+    request,
+    followRedirect: options.followRedirect,
+    maxRedirects: options.maxRedirects,
+    browserProfile: options.browserProfile,
+    timeoutSeconds: options.timeoutSeconds,
+    proxy: options.proxy
+  });
+}
+async function dynafetchNetBatchFetch(requests, options = {}) {
+  const session = sessionStore.getStore();
+  return await callWorker("batchFetch", {
+    sessionId: session?.sessionId,
+    requests,
+    followRedirect: options.followRedirect,
+    maxRedirects: options.maxRedirects,
+    browserProfile: options.browserProfile,
+    timeoutSeconds: options.timeoutSeconds,
+    proxy: options.proxy
+  });
+}
+
+// ../../src/phantom/phantom-proxy.ts
+function headersToRecord(h) {
+  const out = {};
+  h.forEach((v, k) => {
+    out[k] = v;
+  });
+  const anyH = h;
+  if (typeof anyH.getSetCookie === "function") {
+    const sc = anyH.getSetCookie();
+    if (Array.isArray(sc) && sc.length) out["set-cookie"] = sc.join("\n");
+  }
+  return out;
+}
+async function directFetch(payload) {
+  const init = {
+    method: payload.method,
+    headers: payload.headers,
+    redirect: "manual"
+  };
+  if (payload.body) init.body = payload.body;
+  const resp = await fetch(payload.url, init);
+  const body = await resp.text().catch(() => "");
+  return { status: resp.status, body, headers: headersToRecord(resp.headers) };
+}
+async function dynafetchWorkerFetch(payload) {
+  const response = await dynafetchNetFetch(payload, {
+    followRedirect: false
+  });
+  return {
+    status: response.status,
+    body: response.body,
+    headers: response.headers,
+    finalUrl: response.finalUrl,
+    error: response.error
+  };
+}
+async function phantomFetch(payload) {
+  if (process.env.PHANTOM_DISABLE_PROXY === "1" || process.env.DYNAFETCH_DISABLE_NET === "1") {
+    return directFetch(payload);
+  }
+  try {
+    return await dynafetchWorkerFetch(payload);
+  } catch (error) {
+    if (process.env.DYNAFETCH_DISABLE_DIRECT_FALLBACK === "1") {
+      throw error;
+    }
+    return await directFetch(payload);
+  }
+}
+async function phantomBatchFetch(payloads) {
+  if (payloads.length === 0) return [];
+  if (process.env.PHANTOM_DISABLE_PROXY === "1" || process.env.DYNAFETCH_DISABLE_NET === "1") {
+    return Promise.all(payloads.map((p) => directFetch(p)));
+  }
+  try {
+    const responses = await dynafetchNetBatchFetch(
+      payloads,
+      { followRedirect: false }
+    );
+    return responses.map((r) => ({
+      status: r.status,
+      body: r.body,
+      headers: r.headers,
+      finalUrl: r.finalUrl,
+      error: r.error
+    }));
+  } catch (error) {
+    if (process.env.DYNAFETCH_DISABLE_DIRECT_FALLBACK === "1") {
+      throw error;
+    }
+    return Promise.all(payloads.map((p) => directFetch(p)));
+  }
+}
+
+// ../../src/phantom/headers.ts
+var CHROME_146_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var CHROME_146_SEC_CH_UA = '"Chromium";v="146", "Not-A.Brand";v="24", "Google Chrome";v="146"';
+function chromeDocumentHeaders() {
+  const headers = {
+    accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "max-age=0",
+    priority: "u=0, i",
+    "sec-ch-ua": CHROME_146_SEC_CH_UA,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"macOS"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": CHROME_146_USER_AGENT
+  };
+  const order = [
+    "accept",
+    "accept-language",
+    "cache-control",
+    "priority",
+    "sec-ch-ua",
+    "sec-ch-ua-mobile",
+    "sec-ch-ua-platform",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "sec-fetch-user",
+    "upgrade-insecure-requests",
+    "user-agent"
+  ];
+  return { headers, order };
+}
+function chromeSubresourceHeaders(referer) {
+  const headers = {
+    accept: "*/*",
+    "accept-language": "en-US,en;q=0.9",
+    "sec-ch-ua": CHROME_146_SEC_CH_UA,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"macOS"',
+    referer,
+    "user-agent": CHROME_146_USER_AGENT
+  };
+  const order = [
+    "accept",
+    "accept-language",
+    "sec-ch-ua",
+    "sec-ch-ua-mobile",
+    "sec-ch-ua-platform",
+    "referer",
+    "user-agent"
+  ];
+  return { headers, order };
+}
+
+// ../../src/phantom/matcher.ts
+var VALID_REGEX_FLAGS = /* @__PURE__ */ new Set(["d", "g", "i", "m", "s", "u", "v", "y"]);
+function hasOnlyValidFlags(flags) {
+  for (const ch of flags) {
+    if (!VALID_REGEX_FLAGS.has(ch)) return false;
+  }
+  return true;
+}
+function dedupeFlags(flags) {
+  const seen = /* @__PURE__ */ new Set();
+  let out = "";
+  for (const ch of flags) {
+    if (!seen.has(ch)) {
+      seen.add(ch);
+      out += ch;
+    }
+  }
+  return out;
+}
+function parseRegexLiteral(input) {
+  if (!input.startsWith("/")) return null;
+  let lastSlash = -1;
+  for (let i = input.length - 1; i > 0; i--) {
+    if (input[i] !== "/") continue;
+    let slashEscapes = 0;
+    for (let j = i - 1; j >= 0 && input[j] === "\\"; j--) slashEscapes++;
+    if (slashEscapes % 2 === 0) {
+      lastSlash = i;
+      break;
+    }
+  }
+  if (lastSlash <= 0) return null;
+  return {
+    source: input.slice(1, lastSlash),
+    flags: input.slice(lastSlash + 1)
+  };
+}
+function compileMatcher(input) {
+  const matcher = String(input.matcher ?? "");
+  const fuzzyMatch = input.fuzzyMatch !== false;
+  const matcherRegex = input.matcherRegex === true;
+  if (!matcherRegex) {
+    const needle = fuzzyMatch ? matcher.toLowerCase() : matcher;
+    return {
+      kind: "plain",
+      raw: matcher,
+      test: (value) => {
+        const hay = fuzzyMatch ? value.toLowerCase() : value;
+        return hay.includes(needle);
+      },
+      find: (value) => {
+        const hay = fuzzyMatch ? value.toLowerCase() : value;
+        const idx = hay.indexOf(needle);
+        if (idx < 0) return null;
+        return { index: idx, length: Math.max(needle.length, 1) };
+      }
+    };
+  }
+  const parsed = parseRegexLiteral(matcher);
+  const source = parsed ? parsed.source : matcher;
+  let flags = parsed ? parsed.flags : "";
+  if (!source) {
+    throw new Error("Regex matcher cannot be empty.");
+  }
+  if (!hasOnlyValidFlags(flags)) {
+    throw new Error(`Invalid regex flags "${flags}".`);
+  }
+  flags = dedupeFlags(flags);
+  if (fuzzyMatch && !flags.includes("i")) flags += "i";
+  const stableFlags = flags.replace(/[gy]/g, "");
+  const regex = new RegExp(source, stableFlags);
+  return {
+    kind: "regex",
+    raw: matcher,
+    test: (value) => regex.test(value),
+    find: (value) => {
+      const m = regex.exec(value);
+      if (!m || typeof m.index !== "number") return null;
+      const len = typeof m[0] === "string" ? m[0].length : 0;
+      return { index: m.index, length: Math.max(len, 1) };
+    }
+  };
+}
+
+// ../../src/phantom/script-policy.ts
+var TELEMETRY_URL_PATTERNS = [
+  /google-analytics\.com/i,
+  /googletagmanager\.com/i,
+  /googleadservices\.com/i,
+  /doubleclick\.net/i,
+  /googleads\.g\.doubleclick\.net/i,
+  /posthog/i,
+  /segment\./i,
+  /segmentcdn/i,
+  /analytics/i,
+  /mixpanel/i,
+  /amplitude/i,
+  /fullstory/i,
+  /hotjar/i,
+  /clarity\.ms/i,
+  /newrelic/i,
+  /datadog/i,
+  /bugsnag/i,
+  /sentry/i,
+  /logrocket/i,
+  /heap/i,
+  /rudderstack/i,
+  /gtag\/js/i
+];
+var AD_URL_PATTERNS = [
+  /doubleclick/i,
+  /adservice/i,
+  /adsystem/i,
+  /adnxs/i,
+  /taboola/i,
+  /outbrain/i,
+  /criteo/i,
+  /ads-twitter\.com/i,
+  /connect\.facebook\.net.*fbevents/i
+];
+var CHAT_URL_PATTERNS = [
+  /intercom/i,
+  /drift/i,
+  /crisp\.chat/i,
+  /zendesk/i,
+  /olark/i,
+  /livechat/i,
+  /tawk\.to/i
+];
+var WIDGET_URL_PATTERNS = [
+  /maps\.googleapis\.com\/maps\/api\/js/i,
+  /maps-api-v3/i,
+  /recaptcha/i,
+  /hcaptcha/i,
+  /player\.vimeo/i,
+  /youtube\.com\/iframe_api/i,
+  /static\.zdassets\.com/i
+];
+var BOT_DEFENSE_PATTERNS = [
+  /perimeterx/i,
+  /kasada/i,
+  /kpsdk/i,
+  /datadome/i,
+  /px-cdn/i
+];
+var TELEMETRY_INLINE_PATTERNS = [
+  /GoogleAnalyticsObject/i,
+  /\bgtag\s*\(/i,
+  /\bga\s*\(\s*['"]create['"]/i,
+  /\bposthog\b/i,
+  /\bmixpanel\b/i,
+  /\bclarity\s*\(/i,
+  /\bfbq\s*\(/i,
+  /\bhj\s*\(/i,
+  /\bnewrelic\b/i,
+  /\bdatadog\b/i,
+  /\bSentry\b/i,
+  /\bLogRocket\b/i
+];
+function siteKey(hostname) {
+  const parts = hostname.split(".").filter(Boolean);
+  if (parts.length <= 2) return hostname;
+  return parts.slice(-2).join(".");
+}
+function isLikelySameSite(candidateUrl, pageUrl) {
+  try {
+    const candidate = new URL(candidateUrl);
+    const page = new URL(pageUrl);
+    if (candidate.origin === page.origin) return true;
+    return siteKey(candidate.hostname.toLowerCase()) === siteKey(page.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+function matchesAny(input, patterns) {
+  return patterns.some((pattern) => pattern.test(input));
+}
+function classifyScriptAsset(script, pageUrl) {
+  const url = script.url || "";
+  const content = script.content || "";
+  if (url && matchesAny(url, BOT_DEFENSE_PATTERNS)) return "bot-defense";
+  if (!url && matchesAny(content, BOT_DEFENSE_PATTERNS)) return "bot-defense";
+  if (url) {
+    if (matchesAny(url, TELEMETRY_URL_PATTERNS)) return "telemetry";
+    if (matchesAny(url, AD_URL_PATTERNS)) return "ads";
+    if (matchesAny(url, CHAT_URL_PATTERNS)) return "chat";
+    if (matchesAny(url, WIDGET_URL_PATTERNS)) return "widget";
+    if (isLikelySameSite(url, pageUrl)) return "application";
+    if (script.scriptKind === "module") return "application";
+    return "unknown";
+  }
+  if (matchesAny(content, TELEMETRY_INLINE_PATTERNS)) return "telemetry";
+  return "application";
+}
+function shouldSkipScriptCategory(category, policy) {
+  if (category === "bot-defense") return true;
+  if (policy === "execute-all") return false;
+  return category === "telemetry" || category === "ads" || category === "chat" || category === "widget";
+}
+function shouldSkipScriptAsset(script, pageUrl, policy) {
+  return shouldSkipScriptCategory(classifyScriptAsset(script, pageUrl), policy);
+}
+function shouldSkipDynamicScriptUrl(url, pageUrl, policy) {
+  return shouldSkipScriptAsset({ url, content: "", scriptKind: "classic", type: "external" }, pageUrl, policy);
+}
+
+// ../../src/phantom/execute.ts
+var Executor = class {
+  constructor(harvestData, options = null) {
+    this.logs = [];
+    this.targetValue = null;
+    this.matcherRegex = false;
+    this.compiledMatcher = null;
+    this.scriptCache = /* @__PURE__ */ new Map();
+    this.initialComponentName = null;
+    this.pendingRequests = 0;
+    this.pendingRequestNextId = 1;
+    this.pendingRequestMap = /* @__PURE__ */ new Map();
+    this.pendingTasks = 0;
+    this.pendingTaskNextId = 1;
+    this.pendingTaskTimers = /* @__PURE__ */ new Map();
+    this.quiescenceResolver = null;
+    this.quiescenceTimer = null;
+    this.quiescenceMaxTimer = null;
+    this.quiescenceMinTimer = null;
+    this.minifyBundle = false;
+    // Module-script support (JSDOM does not execute <script type="module">).
+    this.handledModuleScriptUrls = /* @__PURE__ */ new Set();
+    // JSDOM won't fetch/execute external scripts unless resources are enabled. We instead
+    // intercept dynamic <script src="..."> insertions and fetch+eval them ourselves.
+    this.handledClassicScriptUrls = /* @__PURE__ */ new Set();
+    this.moduleBundleCache = /* @__PURE__ */ new Map();
+    // entryUrl -> transformed bundled JS
+    this.moduleResolveCache = /* @__PURE__ */ new Map();
+    // url -> source
+    this.moduleInFlight = /* @__PURE__ */ new Map();
+    // entryUrl -> promise
+    this.windowClosed = false;
+    // Simple telemetry counters (useful for debugging).
+    this.telemetry_stubbed = 0;
+    this.telemetry_proxy = 0;
+    this.moduleWaitMs = 1500;
+    this.quiescenceOptions = {
+      minWaitMs: 200,
+      idleWaitMs: 250,
+      maxWaitMs: 5e3
+    };
+    this.timings = {
+      transform_ms_total: 0,
+      scripts_transformed_count: 0,
+      quiescence_ms: 0
+    };
+    this.executionErrors = [];
+    this.thirdPartyPolicy = "skip-noncritical";
+    // Early exit tracking
+    this.findAll = false;
+    this.fuzzyMatch = true;
+    this.earlyMatches = [];
+    this.matchFound = false;
+    this.harvestData = harvestData;
+    this.transformer = new Transformer();
+    if (options === null || typeof options === "string" || typeof options === "number") {
+      this.targetValue = options;
+    } else {
+      this.targetValue = options.targetValue ?? null;
+      this.matcherRegex = options.matcherRegex === true;
+      this.findAll = options.findAll ?? false;
+      this.fuzzyMatch = options.fuzzyMatch ?? true;
+      this.thirdPartyPolicy = options.thirdPartyPolicy ?? "skip-noncritical";
+      this.proxy = options.proxy;
+      this.applyDefaults(options.quiescence, options.moduleWaitMs);
+    }
+    if (this.targetValue !== null && this.targetValue !== void 0) {
+      const rawMatcher = String(this.targetValue);
+      if (rawMatcher.length > 0) {
+        this.compiledMatcher = compileMatcher({
+          matcher: rawMatcher,
+          matcherRegex: this.matcherRegex,
+          fuzzyMatch: this.fuzzyMatch
+        });
+      }
+    }
+    this.logs = [...harvestData.logs];
+    this.initialComponentName = this.findInitialComponentName(harvestData.initialState);
+    this.harvestData.scripts.forEach((s) => {
+      if (s.url) {
+        this.scriptCache.set(s.url, s.content);
+      }
+    });
+    this.harvestData.modulePreloads?.forEach((asset) => {
+      this.scriptCache.set(asset.url, asset.content);
+      this.moduleResolveCache.set(asset.url, {
+        contents: this.rewriteImportMeta(asset.content, asset.url),
+        loader: asset.url.endsWith(".ts") || asset.url.endsWith(".tsx") ? "ts" : "js"
+      });
+    });
+    this.harvestData.moduleGraphCache?.forEach((content, url) => {
+      if (!this.scriptCache.has(url)) {
+        this.scriptCache.set(url, content);
+      }
+    });
+  }
+  clampMs(v, min, max) {
+    if (!Number.isFinite(v)) return min;
+    return Math.max(min, Math.min(max, Math.trunc(v)));
+  }
+  applyDefaults(quiescence, moduleWaitMsOverride) {
+    const hardMaxCap = this.clampMs(Number(process.env.PHANTOM_QUIESCENCE_MAX_CAP_MS ?? 8e3), 500, 6e4);
+    const minWaitMs = this.clampMs(quiescence?.minWaitMs ?? 75, 0, 1e4);
+    const idleWaitMs = this.clampMs(quiescence?.idleWaitMs ?? 100, 0, 1e4);
+    const maxWaitMs = this.clampMs(quiescence?.maxWaitMs ?? 2e3, 0, hardMaxCap);
+    const hardModuleCap = this.clampMs(Number(process.env.PHANTOM_MODULE_WAIT_MAX_CAP_MS ?? 3e4), 1e3, 12e4);
+    this.moduleWaitMs = this.clampMs(Number(process.env.PHANTOM_MODULE_WAIT_MS ?? moduleWaitMsOverride ?? 6e3), 1e3, hardModuleCap);
+    this.quiescenceOptions = { minWaitMs, idleWaitMs, maxWaitMs };
+  }
+  logRequest(entry) {
+    this.logs.push(entry);
+    this.checkForMatch(entry);
+  }
+  checkForMatch(entry) {
+    if (!this.compiledMatcher || this.matchFound && !this.findAll) return;
+    const urlToCheck = entry.url ?? "";
+    const bodyToCheck = typeof entry.responseBody === "string" ? entry.responseBody : "";
+    if (this.compiledMatcher.test(urlToCheck) || this.compiledMatcher.test(bodyToCheck)) {
+      this.earlyMatches.push(entry);
+      if (!this.findAll) {
+        this.matchFound = true;
+        this.triggerEarlyExit();
+      }
+    }
+  }
+  triggerEarlyExit() {
+    if (this.quiescenceResolver) {
+      if (this.quiescenceTimer) {
+        clearTimeout(this.quiescenceTimer);
+        this.quiescenceTimer = null;
+      }
+      if (this.quiescenceMaxTimer) {
+        clearTimeout(this.quiescenceMaxTimer);
+        this.quiescenceMaxTimer = null;
+      }
+      if (this.quiescenceMinTimer) {
+        clearTimeout(this.quiescenceMinTimer);
+        this.quiescenceMinTimer = null;
+      }
+      this.quiescenceResolver();
+      this.quiescenceResolver = null;
+    }
+  }
+  trackRequestStart(url, kind) {
+    const id = this.pendingRequestNextId++;
+    this.pendingRequests++;
+    this.pendingRequestMap.set(id, { url, kind, startedAt: Date.now() });
+    if (this.quiescenceTimer) {
+      clearTimeout(this.quiescenceTimer);
+      this.quiescenceTimer = null;
+    }
+    return id;
+  }
+  trackRequestEnd(id) {
+    this.pendingRequests = Math.max(0, this.pendingRequests - 1);
+    if (typeof id === "number") this.pendingRequestMap.delete(id);
+    if (this.pendingRequests + this.pendingTasks === 0 && this.quiescenceResolver) {
+      this.quiescenceTimer = setTimeout(() => {
+        if (this.pendingRequests + this.pendingTasks === 0 && this.quiescenceResolver) {
+          this.quiescenceResolver();
+          this.quiescenceResolver = null;
+        }
+      }, this.quiescenceOptions.idleWaitMs);
+    }
+  }
+  trackTaskStart(kind, url, maxBlockMs) {
+    const id = this.pendingTaskNextId++;
+    this.pendingTasks++;
+    if (this.quiescenceTimer) {
+      clearTimeout(this.quiescenceTimer);
+      this.quiescenceTimer = null;
+    }
+    const ms = this.clampMs(Number(maxBlockMs ?? 0), 0, 6e4);
+    if (ms > 0) {
+      const t2 = setTimeout(() => this.trackTaskEnd(id), ms);
+      this.pendingTaskTimers.set(id, t2);
+    }
+    return id;
+  }
+  trackTaskEnd(id) {
+    const t2 = this.pendingTaskTimers.get(id);
+    if (t2) {
+      clearTimeout(t2);
+      this.pendingTaskTimers.delete(id);
+    }
+    if (this.pendingTasks > 0) this.pendingTasks--;
+    if (this.pendingRequests + this.pendingTasks === 0 && this.quiescenceResolver) {
+      this.quiescenceTimer = setTimeout(() => {
+        if (this.pendingRequests + this.pendingTasks === 0 && this.quiescenceResolver) {
+          this.quiescenceResolver();
+          this.quiescenceResolver = null;
+        }
+      }, this.quiescenceOptions.idleWaitMs);
+    }
+  }
+  waitForQuiescence() {
+    const { maxWaitMs, minWaitMs, idleWaitMs } = this.quiescenceOptions;
+    return new Promise((resolve) => {
+      const finish = () => {
+        if (!this.quiescenceResolver) return;
+        if (this.quiescenceTimer) clearTimeout(this.quiescenceTimer);
+        if (this.quiescenceMaxTimer) clearTimeout(this.quiescenceMaxTimer);
+        if (this.quiescenceMinTimer) clearTimeout(this.quiescenceMinTimer);
+        this.quiescenceTimer = null;
+        this.quiescenceMaxTimer = null;
+        this.quiescenceMinTimer = null;
+        this.quiescenceResolver = null;
+        resolve();
+      };
+      this.quiescenceResolver = finish;
+      if (this.matchFound && !this.findAll) {
+        this.triggerEarlyExit();
+        return;
+      }
+      this.quiescenceMinTimer = setTimeout(() => {
+        if (!this.quiescenceResolver) return;
+        if (this.pendingRequests + this.pendingTasks === 0) {
+          this.quiescenceTimer = setTimeout(() => {
+            if (this.quiescenceResolver) this.quiescenceResolver();
+          }, idleWaitMs);
+        }
+      }, minWaitMs);
+      this.quiescenceMaxTimer = setTimeout(() => {
+        if (this.quiescenceResolver) this.quiescenceResolver();
+      }, maxWaitMs);
+    });
+  }
+  async waitForModuleWork(timeoutMs) {
+    const pending = Array.from(this.moduleInFlight.values());
+    if (!pending.length) return;
+    const timeout = this.clampMs(timeoutMs, 0, 6e4);
+    if (timeout === 0) return;
+    const all = Promise.allSettled(pending).then(() => {
+    });
+    await Promise.race([
+      all,
+      new Promise((r) => setTimeout(r, timeout))
+    ]);
+  }
+  proxyUrlForScope(scope) {
+    if (!this.proxy) return void 0;
+    return this.proxy.scopes.has(scope) ? this.proxy.url : void 0;
+  }
+  async fetchViaProxy(url, method, headers, body, proxyScope = "api") {
+    try {
+      this.telemetry_proxy++;
+      const payload = { method, url, headers, headerOrder: Object.keys(headers), body, proxy: this.proxyUrlForScope(proxyScope) };
+      return await phantomFetch(payload);
+    } catch (e) {
+      return { status: 0, body: e.message, headers: {}, error: e.message };
+    }
+  }
+  rewriteImportMeta(source, moduleUrl) {
+    const importMetaLiteral = `({ url: ${JSON.stringify(moduleUrl)}, env: { MODE: "production", PROD: true, DEV: false, SSR: false, BASE_URL: "/" }, hot: undefined })`;
+    return source.replace(/\bimport\.meta\.url\b/g, JSON.stringify(moduleUrl)).replace(/\bimport\.meta\.env\.MODE\b/g, `"production"`).replace(/\bimport\.meta\.env\.PROD\b/g, "true").replace(/\bimport\.meta\.env\.DEV\b/g, "false").replace(/\bimport\.meta\.env\.SSR\b/g, "false").replace(/\bimport\.meta\.env\.BASE_URL\b/g, `"/"`).replace(/\bimport\.meta\.env\b/g, `${importMetaLiteral}.env`).replace(/\bimport\.meta\b/g, importMetaLiteral);
+  }
+  findInitialComponentName(initialState) {
+    for (const value of Object.values(initialState || {})) {
+      if (value && typeof value === "object" && typeof value.component === "string") {
+        return value.component;
+      }
+    }
+    return null;
+  }
+  findMatchingBraceIndex(source, startIndex) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = startIndex; i < source.length; i++) {
+      const ch = source[i];
+      if (quote) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === quote) quote = null;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === "`") {
+        quote = ch;
+        continue;
+      }
+      if (ch === "{") {
+        depth++;
+        continue;
+      }
+      if (ch === "}") {
+        depth--;
+        if (depth === 0) return i;
+      }
+    }
+    return -1;
+  }
+  extractObjectProperty(source, objectStart, objectEnd, key) {
+    const needle = `"${key}"`;
+    const keyIndex = source.indexOf(needle, objectStart);
+    if (keyIndex === -1 || keyIndex > objectEnd) return null;
+    let colonIndex = keyIndex + needle.length;
+    while (colonIndex < objectEnd && source[colonIndex] !== ":") colonIndex++;
+    if (colonIndex >= objectEnd) return null;
+    let i = colonIndex + 1;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let quote = null;
+    let escaped = false;
+    for (; i < objectEnd; i++) {
+      const ch = source[i];
+      if (quote) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === quote) quote = null;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === "`") {
+        quote = ch;
+        continue;
+      }
+      if (ch === "(") parenDepth++;
+      else if (ch === ")") parenDepth--;
+      else if (ch === "[") bracketDepth++;
+      else if (ch === "]") bracketDepth--;
+      else if (ch === "{") braceDepth++;
+      else if (ch === "}") braceDepth--;
+      else if (ch === "," && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+        return source.slice(keyIndex, i).trim();
+      }
+    }
+    return source.slice(keyIndex, objectEnd).trim();
+  }
+  pruneComponentRegistrySource(source) {
+    if (!this.initialComponentName) return null;
+    if (!source.includes(this.initialComponentName)) return null;
+    const constMatch = source.match(/const\s+([A-Za-z_$][\w$]*)\s*=\s*\{/);
+    if (!constMatch || constMatch.index == null) return null;
+    const registryVar = constMatch[1];
+    const objectStart = source.indexOf("{", constMatch.index);
+    const objectEnd = this.findMatchingBraceIndex(source, objectStart);
+    if (objectStart === -1 || objectEnd === -1) return null;
+    const propertySource = this.extractObjectProperty(source, objectStart, objectEnd, this.initialComponentName);
+    if (!propertySource) return null;
+    const exportRegex = new RegExp(`export\\{\\s*${registryVar}\\s+as\\s+([A-Za-z_$][\\w$]*)\\s*\\}`);
+    const exportMatch = source.match(exportRegex);
+    if (!exportMatch || exportMatch.index == null) return null;
+    const prefix = source.slice(0, constMatch.index);
+    const suffix = source.slice(exportMatch.index);
+    return `${prefix}const ${registryVar}={${propertySource}};${suffix}`;
+  }
+  async handleModuleScript(entryUrl, window, options = {}) {
+    const cacheKey = options.cacheKey ?? entryUrl;
+    const existing = this.moduleInFlight.get(cacheKey);
+    if (existing) return existing;
+    const p = (async () => {
+      const taskId = this.trackTaskStart("module_bundle", cacheKey, this.moduleWaitMs);
+      try {
+        if (process.env.PHANTOM_DEBUG_MODULES === "1") {
+          console.log("[Executor] Bundling module entry:", cacheKey);
+        }
+        const cached = this.moduleBundleCache.get(cacheKey);
+        if (cached) {
+          if (!this.windowClosed) window.eval(cached);
+          return;
+        }
+        const esbuildMod = await import("esbuild");
+        const buildFn = esbuildMod?.build || esbuildMod?.default?.build;
+        if (typeof buildFn !== "function") {
+          throw new Error("esbuild.build not available (esbuild import failed)");
+        }
+        const entry = new URL(entryUrl);
+        const entryOrigin = entry.origin;
+        const stripQueryHash = (u) => {
+          try {
+            const uu = new URL(u);
+            return uu.pathname.toLowerCase();
+          } catch {
+            return String(u).split("?")[0].split("#")[0].toLowerCase();
+          }
+        };
+        const isStubAsset2 = (u) => {
+          const p2 = stripQueryHash(u);
+          return p2.endsWith(".css") || p2.endsWith(".png") || p2.endsWith(".jpg") || p2.endsWith(".jpeg") || p2.endsWith(".gif") || p2.endsWith(".webp") || p2.endsWith(".avif") || p2.endsWith(".svg") || p2.endsWith(".ico") || p2.endsWith(".woff") || p2.endsWith(".woff2") || p2.endsWith(".ttf") || p2.endsWith(".otf") || p2.endsWith(".eot") || p2.endsWith(".mp3") || p2.endsWith(".mp4") || p2.endsWith(".webm") || p2.endsWith(".mov") || p2.endsWith(".wasm");
+        };
+        const getLoader = (u) => {
+          const p2 = stripQueryHash(u);
+          if (p2.endsWith(".ts") || p2.endsWith(".tsx")) return "ts";
+          return "js";
+        };
+        const httpPlugin = {
+          name: "phantom-http-url",
+          setup: (build) => {
+            build.onResolve({ filter: /.*/ }, (args) => {
+              const path3 = String(args.path || "");
+              const importer = String(args.importer || "");
+              if (path3.startsWith("data:") || path3.startsWith("blob:") || path3.startsWith("file:")) {
+                return { path: path3, external: true };
+              }
+              if (path3.startsWith("http://") || path3.startsWith("https://")) {
+                return { path: path3, namespace: "http-url" };
+              }
+              const base = (() => {
+                try {
+                  if (importer.startsWith("http://") || importer.startsWith("https://")) return importer;
+                } catch {
+                }
+                return entryUrl;
+              })();
+              try {
+                if (path3.startsWith("/")) {
+                  const origin = (() => {
+                    try {
+                      return new URL(base).origin;
+                    } catch {
+                      return entryOrigin;
+                    }
+                  })();
+                  return { path: new URL(path3, origin).toString(), namespace: "http-url" };
+                }
+                return { path: new URL(path3, base).toString(), namespace: "http-url" };
+              } catch {
+                return null;
+              }
+            });
+            build.onLoad({ filter: /.*/, namespace: "http-url" }, async (args) => {
+              const url = String(args.path || "");
+              if (isStubAsset2(url)) {
+                this.telemetry_stubbed++;
+                return { contents: 'export default "";\n', loader: "js" };
+              }
+              const cached2 = this.moduleResolveCache.get(url);
+              if (cached2) return cached2;
+              const prefetched = this.scriptCache.get(url);
+              if (prefetched != null) {
+                const pruned2 = /component_registry/i.test(url) ? this.pruneComponentRegistrySource(prefetched) : null;
+                const entry3 = { contents: this.rewriteImportMeta(pruned2 ?? prefetched, url), loader: getLoader(url) };
+                this.moduleResolveCache.set(url, entry3);
+                return entry3;
+              }
+              const { headers: subHeaders } = chromeSubresourceHeaders(this.harvestData.url);
+              subHeaders["sec-fetch-dest"] = "script";
+              subHeaders["sec-fetch-mode"] = "cors";
+              try {
+                const pageOrigin = new URL(this.harvestData.url).origin;
+                const reqOrigin = new URL(url).origin;
+                subHeaders["sec-fetch-site"] = reqOrigin === pageOrigin ? "same-origin" : "cross-site";
+              } catch {
+                subHeaders["sec-fetch-site"] = "cross-site";
+              }
+              const resp = await this.fetchViaProxy(url, "GET", subHeaders, "", "assets");
+              if (resp.error || resp.status >= 400) {
+                throw new Error(resp.error || `Module fetch failed: ${resp.status} ${url}`);
+              }
+              const body = resp.body ?? "";
+              const pruned = /component_registry/i.test(url) ? this.pruneComponentRegistrySource(body) : null;
+              const entry2 = { contents: this.rewriteImportMeta(pruned ?? body, url), loader: getLoader(url) };
+              this.moduleResolveCache.set(url, entry2);
+              return entry2;
+            });
+          }
+        };
+        const result = await buildFn({
+          bundle: true,
+          write: false,
+          format: "iife",
+          platform: "browser",
+          target: "es2020",
+          sourcemap: false,
+          minify: this.minifyBundle,
+          stdin: {
+            contents: options.inlineSource ? this.rewriteImportMeta(options.inlineSource, entryUrl) : `import ${JSON.stringify(entryUrl)};
+`,
+            sourcefile: entryUrl
+          },
+          plugins: [httpPlugin]
+        });
+        const outputText = result?.outputFiles?.[0]?.text;
+        if (!outputText) throw new Error("esbuild produced no output");
+        const bundleIdHash = nodeCrypto.createHash("sha256").update(cacheKey).digest("hex").slice(0, 10);
+        const transformed = this.transformer.transform(outputText, `module_bundle_${bundleIdHash}`);
+        this.moduleBundleCache.set(cacheKey, transformed);
+        if (!this.windowClosed) window.eval(transformed);
+        if (process.env.PHANTOM_DEBUG_MODULES === "1") {
+          console.log("[Executor] Module bundle eval complete:", cacheKey);
+        }
+      } catch (e) {
+        this.recordExecutionError(e, "unhandledRejection");
+      } finally {
+        this.trackTaskEnd(taskId);
+        this.moduleInFlight.delete(cacheKey);
+      }
+    })();
+    this.moduleInFlight.set(cacheKey, p);
+    return p;
+  }
+  recordExecutionError(err, source) {
+    const e = err instanceof Error ? err : new Error(String(err));
+    this.executionErrors.push({ source, message: e.message, stack: e.stack });
+  }
+  looksLikeESModule(code) {
+    return /(^|[^\w$.])import(?:\s+[\w*{]|\s*["']|\()/m.test(code) || /(^|[^\w$.])export\s+(?:\{|\*|default|const|function|class|let|var)\b/m.test(code) || /\bimport\.meta\b/.test(code);
+  }
+  installWebPlatformShims(window) {
+    const that = this;
+    try {
+      window.globalThis = window;
+    } catch {
+    }
+    try {
+      window.self = window;
+    } catch {
+    }
+    if (!window.atob) {
+      window.atob = (s) => Buffer.from(String(s), "base64").toString("binary");
+    }
+    if (!window.btoa) {
+      window.btoa = (s) => Buffer.from(String(s), "binary").toString("base64");
+    }
+    if (window.__phantom?.fetch) {
+      window.fetch = function fetchShim(input, init) {
+        return window.__phantom.fetch(input, init);
+      };
+    }
+    const g = globalThis;
+    if (!window.Headers && g.Headers) window.Headers = g.Headers;
+    if (!window.Request && g.Request) window.Request = g.Request;
+    if (!window.Response && g.Response) window.Response = g.Response;
+    if (!window.AbortController && g.AbortController) window.AbortController = g.AbortController;
+    if (!window.AbortSignal && g.AbortSignal) window.AbortSignal = g.AbortSignal;
+    if (!window.TextEncoder && g.TextEncoder) window.TextEncoder = g.TextEncoder;
+    if (!window.TextDecoder && g.TextDecoder) window.TextDecoder = g.TextDecoder;
+    if (!window.structuredClone && g.structuredClone) window.structuredClone = g.structuredClone.bind(g);
+    const makeStorage = () => {
+      const store = /* @__PURE__ */ new Map();
+      return {
+        get length() {
+          return store.size;
+        },
+        clear() {
+          store.clear();
+        },
+        getItem(key) {
+          return store.has(String(key)) ? store.get(String(key)) ?? null : null;
+        },
+        key(index) {
+          return Array.from(store.keys())[index] ?? null;
+        },
+        removeItem(key) {
+          store.delete(String(key));
+        },
+        setItem(key, value) {
+          store.set(String(key), String(value));
+        }
+      };
+    };
+    try {
+      if (!window.localStorage) window.localStorage = makeStorage();
+    } catch {
+      window.localStorage = makeStorage();
+    }
+    try {
+      if (!window.sessionStorage) window.sessionStorage = makeStorage();
+    } catch {
+      window.sessionStorage = makeStorage();
+    }
+    if (!window.StorageEvent) {
+      window.StorageEvent = class StorageEvent extends window.Event {
+        constructor(type, init = {}) {
+          super(type, init);
+          this.key = init.key ?? null;
+          this.oldValue = init.oldValue ?? null;
+          this.newValue = init.newValue ?? null;
+          this.storageArea = init.storageArea ?? null;
+          this.url = init.url ?? window.location.href;
+        }
+      };
+    }
+    if (!window.crypto) window.crypto = {};
+    if (!window.crypto.getRandomValues) {
+      if (g.crypto && typeof g.crypto.getRandomValues === "function") {
+        window.crypto.getRandomValues = g.crypto.getRandomValues.bind(g.crypto);
+      } else {
+        window.crypto.getRandomValues = (arr) => {
+          const buf = nodeCrypto.randomBytes(arr.length);
+          arr.set(buf);
+          return arr;
+        };
+      }
+    }
+    {
+      const _g = globalThis;
+      if (!window.MessageChannel && _g.MessageChannel) window.MessageChannel = _g.MessageChannel;
+      if (!window.MessagePort && _g.MessagePort) window.MessagePort = _g.MessagePort;
+    }
+    if (!window.requestIdleCallback) {
+      window.requestIdleCallback = (cb) => window.setTimeout(() => cb({
+        didTimeout: false,
+        timeRemaining: () => 50
+      }), 1);
+    }
+    if (!window.cancelIdleCallback) {
+      window.cancelIdleCallback = (id) => window.clearTimeout(id);
+    }
+    if (!window.ResizeObserver) {
+      window.ResizeObserver = class ResizeObserver {
+        constructor(callback) {
+          this.callback = callback;
+        }
+        observe(target) {
+          try {
+            window.setTimeout(() => {
+              const rect = typeof target?.getBoundingClientRect === "function" ? target.getBoundingClientRect() : { width: window.innerWidth, height: window.innerHeight, top: 0, left: 0, right: window.innerWidth, bottom: window.innerHeight };
+              this.callback?.([{ target, contentRect: rect, borderBoxSize: [], contentBoxSize: [] }], this);
+            }, 0);
+          } catch {
+          }
+        }
+        unobserve() {
+        }
+        disconnect() {
+        }
+      };
+    }
+    try {
+      Object.defineProperty(window.navigator, "language", { value: "en-US", configurable: true });
+      Object.defineProperty(window.navigator, "languages", { value: ["en-US", "en"], configurable: true });
+      Object.defineProperty(window.navigator, "platform", { value: "MacIntel", configurable: true });
+      Object.defineProperty(window.navigator, "onLine", { value: true, configurable: true });
+      Object.defineProperty(window.navigator, "webdriver", { value: false, configurable: true });
+      Object.defineProperty(window.navigator, "hardwareConcurrency", { value: 8, configurable: true });
+      Object.defineProperty(window.navigator, "deviceMemory", { value: 8, configurable: true });
+    } catch {
+    }
+    try {
+      Object.defineProperty(window, "innerWidth", { value: 1440, configurable: true });
+      Object.defineProperty(window, "innerHeight", { value: 900, configurable: true });
+      Object.defineProperty(window, "devicePixelRatio", { value: 2, configurable: true });
+      Object.defineProperty(window, "scrollX", { value: 0, writable: true, configurable: true });
+      Object.defineProperty(window, "scrollY", { value: 0, writable: true, configurable: true });
+    } catch {
+    }
+    if (!window.screen) {
+      window.screen = {
+        width: 1440,
+        height: 900,
+        availWidth: 1440,
+        availHeight: 900
+      };
+    }
+    if (!window.visualViewport) {
+      window.visualViewport = {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        scale: 1,
+        offsetLeft: 0,
+        offsetTop: 0,
+        pageLeft: 0,
+        pageTop: 0,
+        addEventListener() {
+        },
+        removeEventListener() {
+        }
+      };
+    }
+    if (!window.scrollTo) {
+      window.scrollTo = (x, y) => {
+        window.scrollX = typeof x === "number" ? x : window.scrollX;
+        window.scrollY = typeof y === "number" ? y : window.scrollY;
+      };
+    }
+    if (!window.scrollBy) {
+      window.scrollBy = (x, y) => {
+        window.scrollTo((window.scrollX || 0) + (Number(x) || 0), (window.scrollY || 0) + (Number(y) || 0));
+      };
+    }
+    try {
+      Object.defineProperty(window.document, "visibilityState", { value: "visible", configurable: true });
+      Object.defineProperty(window.document, "hidden", { value: false, configurable: true });
+    } catch {
+    }
+    if (!window.document.hasFocus) {
+      window.document.hasFocus = () => true;
+    }
+    if (!window.focus) {
+      window.focus = () => {
+        try {
+          window.dispatchEvent(new window.Event("focus"));
+        } catch {
+        }
+      };
+    }
+    if (!window.blur) {
+      window.blur = () => {
+        try {
+          window.dispatchEvent(new window.Event("blur"));
+        } catch {
+        }
+      };
+    }
+    const wrapCb = (cb) => {
+      if (typeof cb !== "function") return cb;
+      return function wrappedCallback(...args) {
+        try {
+          return cb.apply(this, args);
+        } catch (e) {
+          that.recordExecutionError(e, "uncaughtException");
+        }
+      };
+    };
+    const _setTimeout = window.setTimeout?.bind(window);
+    const _setInterval = window.setInterval?.bind(window);
+    if (_setTimeout) window.setTimeout = (cb, ms, ...rest) => _setTimeout(wrapCb(cb), ms, ...rest);
+    if (_setInterval) window.setInterval = (cb, ms, ...rest) => _setInterval(wrapCb(cb), ms, ...rest);
+    if (window.queueMicrotask) {
+      const _q = window.queueMicrotask.bind(window);
+      window.queueMicrotask = (cb) => _q(wrapCb(cb));
+    }
+    if (window.addEventListener) {
+      window.addEventListener("error", (ev) => {
+        that.recordExecutionError(ev?.error || ev?.message || ev, "error");
+        if (typeof ev?.preventDefault === "function") ev.preventDefault();
+      });
+      window.addEventListener("unhandledrejection", (ev) => {
+        that.recordExecutionError(ev?.reason || ev, "unhandledrejection");
+        if (typeof ev?.preventDefault === "function") ev.preventDefault();
+      });
+    }
+    let domContentLoadedDispatched = false;
+    window.__phantom_markDCLDispatched = () => {
+      domContentLoadedDispatched = true;
+    };
+    if (window.document?.addEventListener) {
+      const origDocAddEventListener = window.document.addEventListener.bind(window.document);
+      window.document.addEventListener = function(type, listener, options) {
+        const result = origDocAddEventListener(type, listener, options);
+        if (type === "DOMContentLoaded" && domContentLoadedDispatched) {
+          window.setTimeout(() => {
+            try {
+              if (typeof listener === "function") {
+                listener.call(window.document, new window.Event("DOMContentLoaded"));
+              } else if (listener && typeof listener.handleEvent === "function") {
+                listener.handleEvent.call(listener, new window.Event("DOMContentLoaded"));
+              }
+            } catch (e) {
+              that.recordExecutionError(e, "error");
+            }
+          }, 0);
+        }
+        return result;
+      };
+    }
+    const makeCtx = () => {
+      const noop = () => {
+      };
+      const base = {
+        canvas: null,
+        // Common methods used by renderers
+        save: noop,
+        restore: noop,
+        beginPath: noop,
+        closePath: noop,
+        clip: noop,
+        moveTo: noop,
+        lineTo: noop,
+        bezierCurveTo: noop,
+        quadraticCurveTo: noop,
+        rect: noop,
+        arc: noop,
+        fill: noop,
+        stroke: noop,
+        clearRect: noop,
+        fillRect: noop,
+        strokeRect: noop,
+        drawImage: noop,
+        translate: noop,
+        rotate: noop,
+        scale: noop,
+        transform: noop,
+        setTransform: noop,
+        resetTransform: noop,
+        measureText: (text) => ({ width: (String(text).length || 0) * 8 }),
+        createLinearGradient: () => ({ addColorStop: noop }),
+        createRadialGradient: () => ({ addColorStop: noop }),
+        createPattern: () => ({}),
+        getImageData: () => ({ data: new Uint8ClampedArray(0) }),
+        putImageData: noop
+      };
+      return new Proxy(base, {
+        get(target, prop) {
+          if (prop in target) return target[prop];
+          return noop;
+        },
+        set(target, prop, value) {
+          target[prop] = value;
+          return true;
+        }
+      });
+    };
+    if (window.HTMLCanvasElement && window.HTMLCanvasElement.prototype) {
+      const proto = window.HTMLCanvasElement.prototype;
+      const origGetContext = proto.getContext;
+      proto.getContext = function(type, ...args) {
+        try {
+          const ctx = origGetContext ? origGetContext.call(this, type, ...args) : null;
+          if (ctx) return ctx;
+        } catch {
+        }
+        const mock = makeCtx();
+        mock.canvas = this;
+        return mock;
+      };
+    }
+  }
+  async execute() {
+    const onNodeUncaught = (err) => this.recordExecutionError(err, "uncaughtException");
+    const onNodeUnhandled = (reason) => this.recordExecutionError(reason, "unhandledRejection");
+    process.on("uncaughtException", onNodeUncaught);
+    process.on("unhandledRejection", onNodeUnhandled);
+    try {
+      const virtualConsole = new VirtualConsole();
+      virtualConsole.on("log", (...args) => console.log("[JSDOM Log]", ...args));
+      virtualConsole.on("error", (...args) => console.error("[JSDOM Error]", ...args));
+      virtualConsole.on("warn", (...args) => console.warn("[JSDOM Warn]", ...args));
+      const cookieJar = new CookieJar();
+      this.harvestData.cookies.forEach((c) => {
+        try {
+          cookieJar.setCookieSync(c, this.harvestData.url);
+        } catch (e) {
+        }
+      });
+      const DEFAULT_UA = chromeDocumentHeaders().headers["user-agent"];
+      const htmlWithDataOnly = this.stripExecutableScripts(this.harvestData.html);
+      const dom = new JSDOM(htmlWithDataOnly, {
+        url: this.harvestData.url,
+        referrer: "https://www.google.com/",
+        runScripts: "dangerously",
+        cookieJar,
+        virtualConsole,
+        beforeParse: (window2) => {
+          try {
+            Object.defineProperty(window2.navigator, "userAgent", {
+              value: DEFAULT_UA,
+              configurable: true
+            });
+          } catch {
+          }
+          window2.IntersectionObserver = class IntersectionObserver {
+            constructor(callback) {
+              this._callback = callback;
+            }
+            observe(target) {
+              try {
+                Promise.resolve().then(() => {
+                  this._callback?.([{ target, isIntersecting: true, intersectionRatio: 1 }], this);
+                });
+              } catch {
+              }
+            }
+            unobserve() {
+            }
+            disconnect() {
+            }
+            takeRecords() {
+              return [];
+            }
+          };
+          window2.matchMedia = window2.matchMedia || function(query) {
+            return {
+              matches: false,
+              media: query,
+              onchange: null,
+              addListener: function() {
+              },
+              removeListener: function() {
+              },
+              addEventListener: function() {
+              },
+              removeEventListener: function() {
+              },
+              dispatchEvent: function() {
+                return false;
+              }
+            };
+          };
+          if (!window2.performance) {
+            window2.performance = {};
+          }
+          if (!window2.performance.mark) {
+            window2.performance.mark = (name) => {
+              return {
+                name,
+                entryType: "mark",
+                startTime: Date.now(),
+                duration: 0,
+                toJSON: () => {
+                }
+              };
+            };
+          }
+          if (!window2.performance.measure) {
+            window2.performance.measure = (name, startMark, endMark) => {
+              return {
+                name,
+                entryType: "measure",
+                startTime: Date.now(),
+                duration: 0,
+                toJSON: () => {
+                }
+              };
+            };
+          }
+          if (!window2.performance.clearMarks) {
+            window2.performance.clearMarks = () => {
+            };
+          }
+          if (!window2.performance.clearMeasures) {
+            window2.performance.clearMeasures = () => {
+            };
+          }
+          if (!window2.performance.getEntriesByName) {
+            window2.performance.getEntriesByName = () => [];
+          }
+          if (!window2.performance.getEntriesByType) {
+            window2.performance.getEntriesByType = () => [];
+          }
+          if (window2.URL) {
+            const NativeURL = window2.URL;
+            const URLShim = function(input, base) {
+              if (base === void 0 && typeof input === "string" && /^[/?#]/.test(input)) {
+                return new NativeURL(input, window2.location.href);
+              }
+              return new NativeURL(input, base);
+            };
+            try {
+              Object.setPrototypeOf(URLShim, NativeURL);
+            } catch {
+            }
+            URLShim.prototype = NativeURL.prototype;
+            window2.URL = URLShim;
+          }
+          if (!window2.requestAnimationFrame) {
+            window2.requestAnimationFrame = (callback) => window2.setTimeout(callback, 0);
+          }
+          if (!window2.cancelAnimationFrame) {
+            window2.cancelAnimationFrame = (id) => window2.clearTimeout(id);
+          }
+          if (!window2.process) {
+            window2.process = {
+              env: { NODE_ENV: "production" },
+              version: "",
+              nextTick: (cb) => window2.setTimeout(cb, 0),
+              browser: true
+            };
+          }
+          this.injectPhantom(window2);
+          this.installWebPlatformShims(window2);
+          const HOOK_FLAG = "__phantomModuleScriptHookInstalled";
+          if (!window2[HOOK_FLAG]) {
+            window2[HOOK_FLAG] = true;
+            const that = this;
+            const NodeProto = window2.Node?.prototype;
+            const syntheticLoadedLinks = /* @__PURE__ */ new WeakSet();
+            if (NodeProto) {
+              const origAppendChild = NodeProto.appendChild;
+              const origInsertBefore = NodeProto.insertBefore;
+              const maybeHandle = (node) => {
+                try {
+                  if (!node) return;
+                  const synthesizeStylesheetLoad = (el) => {
+                    const tag = String(el?.tagName || "").toLowerCase();
+                    if (tag !== "link") return;
+                    const rel = String(el.rel || el.getAttribute?.("rel") || "").toLowerCase();
+                    if (rel !== "stylesheet") return;
+                    if (syntheticLoadedLinks.has(el)) return;
+                    syntheticLoadedLinks.add(el);
+                    window2.setTimeout(() => {
+                      try {
+                        const ev = new window2.Event("load");
+                        if (typeof el.onload === "function") el.onload(ev);
+                        if (typeof el.dispatchEvent === "function") el.dispatchEvent(ev);
+                      } catch {
+                      }
+                    }, 0);
+                  };
+                  const handleOne = (el) => {
+                    const tag = String(el?.tagName || "").toLowerCase();
+                    if (tag === "link") {
+                      synthesizeStylesheetLoad(el);
+                      return;
+                    }
+                    if (tag !== "script") return;
+                    const t2 = String(el.type || el.getAttribute?.("type") || "").toLowerCase();
+                    const src = String(el.src || el.getAttribute?.("src") || "");
+                    if (!src) return;
+                    const abs = new URL(src, window2.location.href).toString();
+                    if (shouldSkipDynamicScriptUrl(abs, that.harvestData.url, that.thirdPartyPolicy)) {
+                      return;
+                    }
+                    if (t2 === "module") {
+                      if (that.handledModuleScriptUrls.has(abs)) return;
+                      that.handledModuleScriptUrls.add(abs);
+                      if (process.env.PHANTOM_DEBUG_MODULES === "1") {
+                        console.log("[Executor] Detected module script:", abs);
+                      }
+                      void that.handleModuleScript(abs, window2);
+                      return;
+                    }
+                    if (that.handledClassicScriptUrls.has(abs)) return;
+                    that.handledClassicScriptUrls.add(abs);
+                    const pendingId = that.trackRequestStart(abs, "resource_load");
+                    const start = Date.now();
+                    const logEntry = {
+                      type: "resource_load",
+                      url: abs,
+                      timestamp: start,
+                      initiator: "Dynamic Script Loader"
+                    };
+                    that.logRequest(logEntry);
+                    const runClassic = async () => {
+                      try {
+                        let code = that.scriptCache.get(abs);
+                        let headers = {};
+                        let status = 200;
+                        if (code == null) {
+                          const { headers: subHeaders } = chromeSubresourceHeaders(that.harvestData.url);
+                          subHeaders["user-agent"] = DEFAULT_UA;
+                          subHeaders["referer"] = window2.location.href;
+                          const proxyResp = await that.fetchViaProxy(abs, "GET", subHeaders, "", "assets");
+                          status = proxyResp.status;
+                          headers = proxyResp.headers || {};
+                          code = proxyResp.status < 400 ? proxyResp.body : "";
+                          that.scriptCache.set(abs, code);
+                        }
+                        logEntry.status = status;
+                        logEntry.responseHeaders = headers;
+                        logEntry.responseBody = code;
+                        that.checkForMatch(logEntry);
+                        if (status >= 400) return;
+                        if (code && that.looksLikeESModule(code)) {
+                          that.handledModuleScriptUrls.add(abs);
+                          await that.handleModuleScript(abs, window2, { cacheKey: abs });
+                          return;
+                        }
+                        const t0 = Date.now();
+                        const transformed = that.transformer.transform(code, `dynamic_script_${nodeCrypto.createHash("sha256").update(abs).digest("hex").slice(0, 10)}`);
+                        that.timings.transform_ms_total += Date.now() - t0;
+                        that.timings.scripts_transformed_count++;
+                        if (!that.windowClosed) window2.eval(transformed);
+                      } catch (e) {
+                        that.recordExecutionError(e, "error");
+                      } finally {
+                        that.trackRequestEnd(pendingId);
+                      }
+                    };
+                    void runClassic();
+                  };
+                  handleOne(node);
+                  if (typeof node.querySelectorAll === "function") {
+                    const scripts = node.querySelectorAll("script[src]");
+                    for (const s of scripts) handleOne(s);
+                    const stylesheets = node.querySelectorAll('link[rel="stylesheet"]');
+                    for (const link of stylesheets) handleOne(link);
+                  }
+                } catch {
+                }
+              };
+              if (typeof origAppendChild === "function") {
+                NodeProto.appendChild = function(child) {
+                  maybeHandle(child);
+                  const ret = origAppendChild.call(this, child);
+                  return ret;
+                };
+              }
+              if (typeof origInsertBefore === "function") {
+                NodeProto.insertBefore = function(newNode, refNode) {
+                  maybeHandle(newNode);
+                  const ret = origInsertBefore.call(this, newNode, refNode);
+                  return ret;
+                };
+              }
+              if (typeof window2.MutationObserver === "function" && window2.document) {
+                try {
+                  const obs = new window2.MutationObserver((mutations) => {
+                    try {
+                      for (const m of mutations) {
+                        const added = m?.addedNodes;
+                        if (!added) continue;
+                        for (const n of Array.from(added)) maybeHandle(n);
+                      }
+                    } catch {
+                    }
+                  });
+                  obs.observe(window2.document, { childList: true, subtree: true });
+                } catch {
+                }
+              }
+            }
+          }
+        }
+      });
+      const { window } = dom;
+      let readyStateValue = "loading";
+      try {
+        Object.defineProperty(window.document, "readyState", {
+          configurable: true,
+          get() {
+            return readyStateValue;
+          }
+        });
+      } catch {
+      }
+      const inertScriptPlaceholders = Array.from(
+        window.document.querySelectorAll('script[type="application/x-phantom-script"]')
+      );
+      const placeholderById = /* @__PURE__ */ new Map();
+      const orderedScripts = [...this.harvestData.scripts].sort((a, b) => a.order - b.order);
+      orderedScripts.forEach((script, index) => {
+        placeholderById.set(script.id, inertScriptPlaceholders[index] ?? null);
+      });
+      const syncScripts = this.harvestData.scripts.filter((s) => s.execution === "sync");
+      const deferScripts = this.harvestData.scripts.filter((s) => s.execution === "defer");
+      const asyncScripts = this.harvestData.scripts.filter((s) => s.execution === "async");
+      const currentScriptState = { value: null };
+      try {
+        Object.defineProperty(window.document, "currentScript", {
+          configurable: true,
+          get() {
+            return currentScriptState.value;
+          }
+        });
+      } catch {
+      }
+      const shouldSkipScript = (script) => {
+        return shouldSkipScriptAsset(script, this.harvestData.url, this.thirdPartyPolicy);
+      };
+      const executeScript = async (script) => {
+        if (shouldSkipScript(script)) return;
+        if (script.type === "external" && script.url) {
+          if (script.scriptKind === "module" && this.handledModuleScriptUrls.has(script.url)) return;
+          if (script.scriptKind === "classic" && this.handledClassicScriptUrls.has(script.url)) return;
+        }
+        const prevCurrentScript = currentScriptState.value;
+        const scriptEl = placeholderById.get(script.id) || window.document.createElement("script");
+        if (script.url) scriptEl.src = script.url;
+        if (script.scriptKind === "module") scriptEl.type = "module";
+        if (script.execution === "async") scriptEl.async = true;
+        if (script.execution === "defer") scriptEl.defer = true;
+        currentScriptState.value = scriptEl;
+        if (script.scriptKind === "module") {
+          try {
+            if (script.type === "external" && script.url) {
+              this.handledModuleScriptUrls.add(script.url);
+              await this.handleModuleScript(script.url, window);
+            } else {
+              const inlineEntryUrl = new URL(`./__dynafetch_inline_module__/${script.id}.mjs`, this.harvestData.url).toString();
+              await this.handleModuleScript(inlineEntryUrl, window, {
+                inlineSource: script.content,
+                cacheKey: `inline:${script.id}`
+              });
+            }
+          } catch (e) {
+            console.warn(`[Executor] Module script ${script.id} failed:`, e);
+          } finally {
+            currentScriptState.value = prevCurrentScript;
+          }
+          return;
+        }
+        if (script.type === "external" && script.url) {
+          this.handledClassicScriptUrls.add(script.url);
+        }
+        const t0 = Date.now();
+        const code = this.transformer.transform(script.content, script.id);
+        this.timings.transform_ms_total += Date.now() - t0;
+        this.timings.scripts_transformed_count++;
+        try {
+          window.eval(code);
+        } catch (e) {
+          console.warn(`[Executor] Script ${script.id} failed:`, e);
+        } finally {
+          currentScriptState.value = prevCurrentScript;
+        }
+      };
+      for (const s of syncScripts) {
+        await executeScript(s);
+        if (this.matchFound && !this.findAll) break;
+      }
+      {
+        const deferWork = (async () => {
+          for (const s of deferScripts) {
+            await executeScript(s);
+            if (this.matchFound && !this.findAll) break;
+          }
+        })();
+        await Promise.all([deferWork, this.waitForModuleWork(this.moduleWaitMs)]);
+      }
+      readyStateValue = "interactive";
+      window.document.dispatchEvent(new window.Event("readystatechange"));
+      window.document.dispatchEvent(new window.Event("DOMContentLoaded"));
+      if (typeof window.__phantom_markDCLDispatched === "function") {
+        window.__phantom_markDCLDispatched();
+      }
+      window.document.dispatchEvent(new window.Event("visibilitychange"));
+      if (asyncScripts.length > 0) {
+        await Promise.all(asyncScripts.map((s) => executeScript(s).catch(() => {
+        })));
+      }
+      if (this.moduleInFlight.size > 0) {
+        await this.waitForModuleWork(this.moduleWaitMs);
+      }
+      readyStateValue = "complete";
+      window.document.dispatchEvent(new window.Event("readystatechange"));
+      window.dispatchEvent(new window.Event("load"));
+      window.dispatchEvent(new window.Event("pageshow"));
+      window.dispatchEvent(new window.Event("focus"));
+      if (this.moduleInFlight.size > 0) {
+        await this.waitForModuleWork(this.moduleWaitMs);
+      }
+      console.log("[Executor] Waiting for network quiescence...");
+      const quiescenceStart = Date.now();
+      try {
+        await this.waitForQuiescence();
+      } catch (e) {
+        console.warn("[Executor] Quiescence wait failed:", e);
+      }
+      this.timings.quiescence_ms = Date.now() - quiescenceStart;
+      const reason = this.matchFound && !this.findAll ? "(early exit on match)" : "";
+      console.log(`[Executor] Quiescence reached in ${Date.now() - quiescenceStart}ms ${reason}`);
+      const renderedHtml = this.serializeDocument(window);
+      this.windowClosed = true;
+      try {
+        window.close();
+      } catch {
+      }
+      const result = {
+        logs: this.logs,
+        matchedRequests: this.earlyMatches,
+        renderedHtml,
+        timings: { ...this.timings },
+        errors: this.executionErrors.length ? this.executionErrors : void 0
+      };
+      const shutdownGraceMs = this.clampMs(Number(process.env.PHANTOM_SHUTDOWN_GRACE_MS ?? 50), 10, 5e3);
+      await new Promise((r) => setTimeout(r, shutdownGraceMs));
+      return result;
+    } finally {
+      process.off("uncaughtException", onNodeUncaught);
+      process.off("unhandledRejection", onNodeUnhandled);
+    }
+  }
+  serializeDocument(window) {
+    try {
+      const doctype = window.document?.doctype;
+      const serializedDoctype = doctype ? `<!DOCTYPE ${doctype.name}${doctype.publicId ? ` PUBLIC "${doctype.publicId}"` : ""}${doctype.systemId ? ` "${doctype.systemId}"` : ""}>` : "";
+      const html = window.document?.documentElement?.outerHTML ?? "";
+      return `${serializedDoctype}${html}`;
+    } catch {
+      return this.harvestData.html;
+    }
+  }
+  stripExecutableScripts(html) {
+    return html.replace(/<script\b([^>]*)>([\s\S]*?)<\/script>/gim, (match, attrs, content) => {
+      const isDataScript = attrs.includes('type="application/json"') || attrs.includes("type='application/json'") || attrs.includes('type="application/ld+json"') || attrs.includes('id="__ACGH_DATA__"');
+      if (isDataScript) return match;
+      const inertAttrs = attrs.replace(/\btype\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/i, "").trim();
+      return `<script type="application/x-phantom-script"${inertAttrs ? ` ${inertAttrs}` : ""}></script>`;
+    });
+  }
+  injectPhantom(window) {
+    const that = this;
+    const headersToObject = (h) => {
+      if (!h) return {};
+      if (typeof h.forEach === "function") {
+        const out = {};
+        try {
+          h.forEach((v, k) => {
+            out[String(k)] = String(v);
+          });
+          return out;
+        } catch {
+        }
+      }
+      if (typeof h.entries === "function") {
+        const out = {};
+        try {
+          for (const [k, v] of h.entries()) out[String(k)] = String(v);
+          return out;
+        } catch {
+        }
+      }
+      if (typeof h === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(h)) {
+          if (v === void 0 || v === null) continue;
+          out[String(k)] = Array.isArray(v) ? String(v[0]) : String(v);
+        }
+        return out;
+      }
+      return {};
+    };
+    const normalizeFetchInput = async (input, opts) => {
+      let url = input;
+      let method = opts?.method || "GET";
+      let headers = headersToObject(opts?.headers);
+      let body = opts?.body;
+      const isRequestLike = input && typeof input === "object" && (typeof input.url === "string" || typeof input.href === "string") && (typeof input.method === "string" || typeof input.headers === "object" || typeof input.headers?.forEach === "function");
+      if (isRequestLike) {
+        url = input.url || input.href;
+        method = opts?.method || input.method || method;
+        headers = { ...headersToObject(input.headers), ...headers };
+        if (body === void 0) {
+          try {
+            if (typeof input.text === "function") body = await input.text();
+          } catch {
+          }
+        }
+      }
+      const fullUrl = new URL(String(url), window.location.href).toString();
+      return { url: fullUrl, method, headers, body };
+    };
+    const toSafeResponseHeaders = (rawHeaders) => {
+      const H = window.Headers || global.Headers;
+      if (typeof H !== "function") return rawHeaders ?? {};
+      const safe = new H();
+      if (!rawHeaders) return safe;
+      for (const [k, v] of Object.entries(rawHeaders)) {
+        if (v == null) continue;
+        const value = String(v).replace(/[\r\n]+/g, ", ").trim();
+        if (!value) continue;
+        try {
+          safe.set(k, value);
+        } catch {
+        }
+      }
+      return safe;
+    };
+    window.__phantom = {
+      fetch: async (input, opts = {}) => {
+        const norm = await normalizeFetchInput(input, opts);
+        const start = Date.now();
+        const headers = {
+          "User-Agent": window.navigator.userAgent,
+          "Cookie": window.document.cookie,
+          "Referer": window.location.href,
+          ...norm.headers
+        };
+        const logEntry = {
+          type: "fetch",
+          method: norm.method || "GET",
+          url: norm.url,
+          requestHeaders: headers,
+          requestBody: norm.body,
+          timestamp: start
+        };
+        this.logRequest(logEntry);
+        const pendingId = that.trackRequestStart(norm.url, "fetch");
+        try {
+          const bodyStr = norm.body == null ? "" : typeof norm.body === "string" ? norm.body : String(norm.body);
+          const proxyResp = await that.fetchViaProxy(norm.url, norm.method || "GET", headers, bodyStr);
+          if (proxyResp.error) throw new Error(proxyResp.error);
+          logEntry.status = proxyResp.status;
+          logEntry.responseBody = proxyResp.body;
+          logEntry.responseHeaders = proxyResp.headers;
+          this.checkForMatch(logEntry);
+          return new (window.Response || global.Response)(proxyResp.body, {
+            status: proxyResp.status,
+            headers: toSafeResponseHeaders(proxyResp.headers)
+          });
+        } catch (e) {
+          logEntry.status = 0;
+          logEntry.responseBody = e.message;
+          this.checkForMatch(logEntry);
+          throw e;
+        } finally {
+          that.trackRequestEnd(pendingId);
+        }
+      },
+      WebSocket: class extends WebSocket {
+        constructor(url, protocols) {
+          super(url, protocols);
+          that.logRequest({ type: "websocket", url, timestamp: Date.now() });
+        }
+      },
+      EventSource: class {
+        constructor(url) {
+          this.readyState = 0;
+          // 0=CONNECTING, 1=OPEN, 2=CLOSED
+          this.onopen = null;
+          this.onmessage = null;
+          this.onerror = null;
+          this.listeners = /* @__PURE__ */ new Map();
+          this.url = new URL(String(url), window.location.href).toString();
+          that.logRequest({ type: "eventsource", url: this.url, timestamp: Date.now() });
+          this.readyState = 1;
+          window.setTimeout(() => {
+            try {
+              this.onopen?.({ type: "open" });
+              this.listeners.get("open")?.forEach((fn) => fn({ type: "open" }));
+            } catch (e) {
+              that.recordExecutionError(e, "error");
+            }
+          }, 0);
+        }
+        addEventListener(type, cb) {
+          if (!this.listeners.has(type)) this.listeners.set(type, /* @__PURE__ */ new Set());
+          this.listeners.get(type).add(cb);
+        }
+        removeEventListener(type, cb) {
+          this.listeners.get(type)?.delete(cb);
+        }
+        close() {
+          this.readyState = 2;
+        }
+      },
+      dynamicImport: async (url) => {
+        const fullUrl = new URL(url, window.location.href).toString();
+        const start = Date.now();
+        const logEntry = {
+          type: "dynamic_import",
+          url: fullUrl,
+          timestamp: start,
+          initiator: "dynamicImport"
+        };
+        this.logRequest(logEntry);
+        const pendingId = that.trackRequestStart(fullUrl, "dynamic_import");
+        try {
+          let code = that.scriptCache.get(fullUrl);
+          let responseHeaders;
+          let status = 200;
+          if (code == null) {
+            const proxyResp = await that.fetchViaProxy(fullUrl, "GET", {
+              "User-Agent": window.navigator.userAgent,
+              "Cookie": window.document.cookie,
+              "Referer": window.location.href
+            }, "", "assets");
+            responseHeaders = proxyResp.headers;
+            status = proxyResp.status;
+            if (proxyResp.error || proxyResp.status >= 400) {
+              logEntry.status = status;
+              logEntry.responseHeaders = responseHeaders;
+              logEntry.responseBody = null;
+              this.checkForMatch(logEntry);
+              throw new Error(proxyResp.error || `Status ${proxyResp.status}`);
+            }
+            code = proxyResp.body;
+            that.scriptCache.set(fullUrl, code);
+          }
+          logEntry.status = status;
+          logEntry.responseHeaders = responseHeaders;
+          logEntry.responseBody = code;
+          this.checkForMatch(logEntry);
+          that.handledModuleScriptUrls.add(fullUrl);
+          await that.handleModuleScript(fullUrl, window, {
+            cacheKey: `dynamic:${fullUrl}`
+          });
+          return {};
+        } finally {
+          that.trackRequestEnd(pendingId);
+        }
+      },
+      XMLHttpRequest: class {
+        constructor() {
+          this.readyState = 0;
+          this.status = 0;
+          this.statusText = "";
+          this.responseText = "";
+          this.response = null;
+          this.responseType = "";
+          this.responseURL = "";
+          this.timeout = 0;
+          this.withCredentials = false;
+          this.onreadystatechange = null;
+          this.onload = null;
+          this.onloadend = null;
+          this.onerror = null;
+          this.onprogress = null;
+          this.onabort = null;
+          this.ontimeout = null;
+          this.method = "GET";
+          this.url = "";
+          this.asyncFlag = true;
+          this.requestHeaders = {};
+          this.responseHeaders = {};
+          this.aborted = false;
+        }
+        open(method, url, async = true) {
+          this.method = String(method || "GET").toUpperCase();
+          this.url = new URL(String(url), window.location.href).toString();
+          this.asyncFlag = async !== false;
+          this.aborted = false;
+          if (process.env.PHANTOM_DEBUG_XHR === "1") {
+            console.log("[XHR open]", this.method, this.url);
+          }
+          this.readyState = 1;
+          this.responseURL = this.url;
+          this.onreadystatechange?.({ type: "readystatechange" });
+        }
+        setRequestHeader(k, v) {
+          this.requestHeaders[String(k)] = String(v);
+        }
+        addEventListener(type, cb) {
+          if (type === "load") this.onload = cb;
+          if (type === "error") this.onerror = cb;
+          if (type === "readystatechange") this.onreadystatechange = cb;
+          if (type === "progress") this.onprogress = cb;
+          if (type === "loadend") this.onloadend = cb;
+          if (type === "abort") this.onabort = cb;
+          if (type === "timeout") this.ontimeout = cb;
+        }
+        getAllResponseHeaders() {
+          return Object.entries(this.responseHeaders).map(([k, v]) => `${k}: ${v}\r
+`).join("");
+        }
+        getResponseHeader(name) {
+          const n = String(name || "").toLowerCase();
+          for (const [k, v] of Object.entries(this.responseHeaders)) {
+            if (k.toLowerCase() === n) return v;
+          }
+          return null;
+        }
+        abort() {
+          this.aborted = true;
+          this.readyState = 0;
+          this.onabort?.({ type: "abort" });
+          this.onloadend?.({ type: "loadend" });
+        }
+        async send(body) {
+          const start = Date.now();
+          const headers = {
+            "User-Agent": window.navigator.userAgent,
+            "Cookie": window.document.cookie,
+            "Referer": window.location.href,
+            ...this.requestHeaders
+          };
+          const logEntry = {
+            type: "xhr",
+            method: this.method,
+            url: this.url,
+            requestHeaders: headers,
+            requestBody: body == null ? null : typeof body === "string" ? body : String(body),
+            timestamp: start
+          };
+          that.logRequest(logEntry);
+          if (process.env.PHANTOM_DEBUG_XHR === "1") {
+            console.log("[XHR send]", this.method, this.url, {
+              hasBody: body != null,
+              headers
+            });
+          }
+          const doWork = async () => {
+            const pendingId = that.trackRequestStart(this.url, "xhr");
+            try {
+              if (this.aborted) return;
+              const proxyResp = await that.fetchViaProxy(this.url, this.method, headers, logEntry.requestBody || "");
+              if (proxyResp.error) throw new Error(proxyResp.error);
+              this.responseHeaders = proxyResp.headers || {};
+              this.status = proxyResp.status;
+              this.statusText = proxyResp.status >= 200 && proxyResp.status < 300 ? "OK" : "";
+              this.readyState = 2;
+              this.onreadystatechange?.({ type: "readystatechange" });
+              this.responseText = proxyResp.body ?? "";
+              this.readyState = 3;
+              this.onprogress?.({ type: "progress", loaded: this.responseText.length, total: this.responseText.length, lengthComputable: true });
+              this.onreadystatechange?.({ type: "readystatechange" });
+              this.readyState = 4;
+              this.response = this.responseType === "json" ? (() => {
+                try {
+                  return JSON.parse(this.responseText);
+                } catch {
+                  return null;
+                }
+              })() : this.responseText;
+              logEntry.status = proxyResp.status;
+              logEntry.responseHeaders = proxyResp.headers;
+              logEntry.responseBody = proxyResp.body;
+              that.checkForMatch(logEntry);
+              this.onreadystatechange?.({ type: "readystatechange" });
+              this.onload?.({ type: "load" });
+              this.onloadend?.({ type: "loadend" });
+            } catch (e) {
+              this.readyState = 4;
+              this.status = 0;
+              logEntry.status = 0;
+              logEntry.responseBody = e?.message || String(e);
+              that.checkForMatch(logEntry);
+              this.onreadystatechange?.({ type: "readystatechange" });
+              this.onerror?.({ type: "error", error: e });
+              this.onloadend?.({ type: "loadend" });
+            } finally {
+              that.trackRequestEnd(pendingId);
+            }
+          };
+          if (this.asyncFlag) {
+            window.setTimeout(() => {
+              void doWork();
+            }, 0);
+          } else {
+            await doWork();
+          }
+        }
+      }
+    };
+    window.XMLHttpRequest = window.__phantom.XMLHttpRequest;
+    window.EventSource = window.__phantom.EventSource;
+    window.WebSocket = window.__phantom.WebSocket;
+  }
+};
+
+// ../../src/phantom/harvest.ts
+import * as cheerio from "cheerio";
+
+// ../../src/phantom/errors.ts
+var BlockedByBotProtectionError = class extends Error {
+  constructor(url, message) {
+    super(message || `Blocked by bot protection while fetching: ${url}`);
+    this.kind = "blocked";
+    this.url = url;
+    this.name = "BlockedByBotProtectionError";
+  }
+};
+
+// ../../src/phantom/module-prefetch.ts
+var STUB_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".css",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".webm",
+  ".mov",
+  ".wasm"
+]);
+function isStubAsset(url) {
+  try {
+    const p = new URL(url).pathname.toLowerCase();
+    const ext = p.slice(p.lastIndexOf("."));
+    return STUB_EXTENSIONS.has(ext);
+  } catch {
+    const p = url.split("?")[0].split("#")[0].toLowerCase();
+    const ext = p.slice(p.lastIndexOf("."));
+    return STUB_EXTENSIONS.has(ext);
+  }
+}
+function scanImports(code, baseUrl, originFallback) {
+  const deps = [];
+  const importRe = /(?:import|export)\s*.*?from\s*['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  let m;
+  while ((m = importRe.exec(code)) !== null) {
+    const specifier = m[1] || m[2];
+    if (!specifier) continue;
+    let resolved;
+    try {
+      if (specifier.startsWith("http://") || specifier.startsWith("https://")) {
+        resolved = specifier;
+      } else if (specifier.startsWith("/")) {
+        resolved = new URL(specifier, originFallback).toString();
+      } else {
+        resolved = new URL(specifier, baseUrl).toString();
+      }
+    } catch {
+      continue;
+    }
+    if (!isStubAsset(resolved)) {
+      deps.push(resolved);
+    }
+  }
+  return deps;
+}
+async function prefetchModuleGraph(rootUrls, cache, pageUrl, opts) {
+  const maxRounds = opts?.maxRounds ?? 8;
+  const { headers: subHeaders } = chromeSubresourceHeaders(pageUrl);
+  subHeaders["sec-fetch-dest"] = "script";
+  subHeaders["sec-fetch-mode"] = "cors";
+  subHeaders["sec-fetch-site"] = "same-origin";
+  let origin;
+  try {
+    origin = new URL(pageUrl).origin;
+  } catch {
+    origin = pageUrl;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let toFetch = [];
+  let totalFetched = 0;
+  const toScan = [...rootUrls];
+  while (toScan.length > 0) {
+    const url = toScan.pop();
+    if (seen.has(url)) continue;
+    seen.add(url);
+    const code = cache.get(url);
+    if (!code) {
+      toFetch.push(url);
+      continue;
+    }
+    const deps = scanImports(code, url, origin);
+    for (const d of deps) {
+      if (!seen.has(d)) toScan.push(d);
+    }
+  }
+  for (let round = 0; round < maxRounds && toFetch.length > 0; round++) {
+    if (process.env.PHANTOM_DEBUG_MODULES === "1") {
+      console.log(`[prefetch] Round ${round}: ${toFetch.length} modules`);
+    }
+    const payloads = toFetch.map((u) => ({
+      method: "GET",
+      url: u,
+      headers: { ...subHeaders },
+      headerOrder: Object.keys(subHeaders),
+      body: "",
+      proxy: opts?.proxyUrl
+    }));
+    const responses = await phantomBatchFetch(payloads);
+    const newToScan = [];
+    for (let i = 0; i < toFetch.length; i++) {
+      const u = toFetch[i];
+      const r = responses[i];
+      if (r.status < 400 && r.body) {
+        cache.set(u, r.body);
+        totalFetched++;
+        newToScan.push(u);
+      }
+    }
+    toFetch = [];
+    for (const url of newToScan) {
+      const code = cache.get(url);
+      if (!code) continue;
+      const deps = scanImports(code, url, origin);
+      for (const d of deps) {
+        if (!seen.has(d)) {
+          seen.add(d);
+          if (cache.has(d)) {
+            newToScan.push(d);
+          } else {
+            toFetch.push(d);
+          }
+        }
+      }
+    }
+  }
+  return totalFetched;
+}
+
+// ../../src/phantom/harvest.ts
+var { headers: DEFAULT_HEADERS, order: DEFAULT_HEADER_ORDER } = chromeDocumentHeaders();
+var Harvester = class {
+  constructor(url, opts = {}) {
+    this.cookies = [];
+    this.logs = [];
+    this.prefetchExternalScripts = true;
+    this.externalScriptConcurrency = 8;
+    this.requestHeaders = {};
+    this.thirdPartyPolicy = "skip-noncritical";
+    this.prefetchModulePreloads = true;
+    this.targetUrl = url;
+    this.prefetchExternalScripts = opts.prefetchExternalScripts !== false;
+    this.externalScriptConcurrency = opts.externalScriptConcurrency ?? 8;
+    this.requestHeaders = opts.requestHeaders ?? {};
+    this.cookies = [...opts.initialCookies ?? []];
+    this.thirdPartyPolicy = opts.thirdPartyPolicy ?? "skip-noncritical";
+    this.prefetchModulePreloads = opts.prefetchModulePreloads !== false;
+    this.proxy = opts.proxy;
+  }
+  proxyUrlForScope(scope) {
+    if (!this.proxy) return void 0;
+    return this.proxy.scopes.has(scope) ? this.proxy.url : void 0;
+  }
+  buildCookieHeader() {
+    const pairs = [];
+    for (const raw of this.cookies) {
+      for (const single of raw.split("\n")) {
+        const nameVal = single.split(";")[0]?.trim();
+        if (nameVal && nameVal.includes("=")) pairs.push(nameVal);
+      }
+    }
+    return pairs.join("; ");
+  }
+  async fetchViaProxy(url, headers = {}, followRedirects = false, maxRedirects = 5, method = "GET", body = "", proxyScope = "page") {
+    let currentUrl = url;
+    let redirectCount = 0;
+    let currentMethod = method;
+    let currentBody = body;
+    while (true) {
+      try {
+        const cookieHeader = this.buildCookieHeader();
+        const reqHeaders = { ...headers };
+        if (cookieHeader) {
+          reqHeaders["Cookie"] = cookieHeader;
+        }
+        const payload = {
+          method: currentMethod,
+          url: currentUrl,
+          headers: reqHeaders,
+          headerOrder: DEFAULT_HEADER_ORDER,
+          body: currentBody,
+          proxy: this.proxyUrlForScope(proxyScope)
+        };
+        const data = await phantomFetch(payload);
+        if (data.error) throw new Error(`Proxy Error: ${data.error}`);
+        const setCookie = data.headers["Set-Cookie"] || data.headers["set-cookie"];
+        if (setCookie) this.cookies.push(setCookie);
+        if (followRedirects && data.status >= 300 && data.status < 400 && redirectCount < maxRedirects) {
+          const location = data.headers["Location"] || data.headers["location"];
+          if (location) {
+            currentUrl = new URL(location, currentUrl).toString();
+            console.log(`[Harvest] Following redirect to: ${currentUrl}`);
+            redirectCount++;
+            if (data.status === 302 || data.status === 303) {
+              currentMethod = "GET";
+              currentBody = "";
+            }
+            continue;
+          }
+        }
+        return { ...data, finalUrl: currentUrl };
+      } catch (e) {
+        console.error(`[Harvester] Proxy request failed for ${currentUrl}:`, e);
+        throw e;
+      }
+    }
+  }
+  isConsentWall(url, html) {
+    const consentDomains = ["consent.yahoo.com", "guce.yahoo.com", "consent.google.com", "consent.youtube.com"];
+    try {
+      const hostname = new URL(url).hostname;
+      if (consentDomains.some((d) => hostname.includes(d))) return true;
+    } catch {
+    }
+    const $ = cheerio.load(html);
+    const hasConsentForm = $("form.consent-form").length > 0 || $("form").filter((_, el) => {
+      const $f = $(el);
+      return $f.find('input[name="csrfToken"]').length > 0 && $f.find('input[name="sessionId"]').length > 0;
+    }).length > 0;
+    return hasConsentForm;
+  }
+  parseConsentForm(html, baseUrl) {
+    try {
+      const $ = cheerio.load(html);
+      let $form = $("form").filter((_, el) => {
+        const text = $(el).text().toLowerCase();
+        return text.includes("agree") || text.includes("accept") || text.includes("consent");
+      }).first();
+      if (!$form.length) $form = $("form").first();
+      if (!$form.length) return null;
+      const action = $form.attr("action");
+      const absoluteAction = action === void 0 || action === null ? null : action === "" ? baseUrl : new URL(action, baseUrl).toString();
+      if (!absoluteAction) return null;
+      const fields = {};
+      $form.find('input[type="hidden"]').each((_, el) => {
+        const name = $(el).attr("name");
+        const value = $(el).attr("value") ?? "";
+        if (name) fields[name] = value;
+      });
+      const agreeBtn = $form.find('button[name], input[type="submit"][name]').filter((_, el) => {
+        const text = ($(el).text() + " " + ($(el).attr("value") ?? "")).toLowerCase();
+        return text.includes("agree") || text.includes("accept") || text.includes("consent");
+      }).first();
+      if (agreeBtn.length) {
+        const name = agreeBtn.attr("name");
+        const value = agreeBtn.attr("value") ?? "agree";
+        if (name) fields[name] = value;
+      } else {
+        fields["agree"] = "agree";
+      }
+      return { action: absoluteAction, fields };
+    } catch {
+      return null;
+    }
+  }
+  looksBlocked(status, body) {
+    if (status !== 403 && status !== 429 && status !== 503 && status !== 999) return false;
+    const b = (body || "").toLowerCase();
+    if (status === 999) return true;
+    return b.includes("just a moment") || b.includes("challenge-platform") || b.includes("__cf_chl") || b.includes("cf-browser-verification") || b.includes("enable javascript and cookies to continue") || b.includes("security verification") || b.includes("captcha") || b.includes("trkcode=") || b.includes("trkinfo=");
+  }
+  async harvest() {
+    console.log(`[Harvest] Fetching ${this.targetUrl} via TLS Proxy...`);
+    let response = await this.fetchViaProxy(this.targetUrl, { ...DEFAULT_HEADERS, ...this.requestHeaders }, true);
+    if (response.status >= 400) {
+      console.log(`[Harvest] Response Body on Error:`, response.body.substring(0, 500));
+      if (this.looksBlocked(response.status, response.body || "")) {
+        throw new BlockedByBotProtectionError(
+          this.targetUrl,
+          `Site is blocked by bot protection (HTTP ${response.status}) and cannot be fetched from this environment: ${this.targetUrl}`
+        );
+      }
+      throw new Error(`Failed to fetch ${this.targetUrl}: ${response.status}`);
+    }
+    let finalUrl = response.finalUrl;
+    let html = response.body;
+    if (this.isConsentWall(finalUrl, html)) {
+      console.log(`[Harvest] Consent wall detected at ${finalUrl}, attempting bypass...`);
+      const form = this.parseConsentForm(html, finalUrl);
+      if (form) {
+        try {
+          const formBody = new URLSearchParams(form.fields).toString();
+          const postHeaders = {
+            ...DEFAULT_HEADERS,
+            ...this.requestHeaders,
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Referer": finalUrl,
+            "Origin": new URL(finalUrl).origin
+          };
+          const consentResp = await this.fetchViaProxy(form.action, postHeaders, true, 10, "POST", formBody);
+          if (consentResp.status < 400) {
+            console.log(`[Harvest] Consent POST succeeded (${consentResp.status}), final URL: ${consentResp.finalUrl}`);
+            if (!this.isConsentWall(consentResp.finalUrl, consentResp.body)) {
+              response = consentResp;
+              finalUrl = consentResp.finalUrl;
+              html = consentResp.body;
+              console.log(`[Harvest] Consent bypass successful (from redirect), got real page at ${finalUrl}`);
+            } else {
+              console.log(`[Harvest] Consent redirect still on consent page, re-fetching original URL...`);
+              const retryResp = await this.fetchViaProxy(this.targetUrl, { ...DEFAULT_HEADERS, ...this.requestHeaders }, true);
+              if (retryResp.status < 400 && !this.isConsentWall(retryResp.finalUrl, retryResp.body)) {
+                response = retryResp;
+                finalUrl = retryResp.finalUrl;
+                html = retryResp.body;
+                console.log(`[Harvest] Consent bypass successful (re-fetch), got real page at ${finalUrl}`);
+              } else {
+                console.warn(`[Harvest] Re-fetch after consent still returned consent wall, proceeding with original`);
+              }
+            }
+          } else {
+            console.warn(`[Harvest] Consent POST returned ${consentResp.status}, proceeding with consent page`);
+          }
+        } catch (e) {
+          console.warn(`[Harvest] Consent bypass failed, proceeding with consent page:`, e);
+        }
+      } else {
+        console.warn(`[Harvest] Could not parse consent form, proceeding with consent page`);
+      }
+    }
+    const $ = cheerio.load(html);
+    const scriptAssets = [];
+    const modulePreloads = [];
+    const scriptTags = $("script");
+    let skippedScriptCount = 0;
+    const fetchTasks = [];
+    const batchScriptMeta = [];
+    let scriptCounter = 0;
+    const seenModulePreloads = /* @__PURE__ */ new Set();
+    for (let i = 0; i < scriptTags.length; i++) {
+      const el = scriptTags[i];
+      const $el = $(el);
+      const src = $el.attr("src");
+      const content = $el.html();
+      const type = ($el.attr("type") || "").trim().toLowerCase();
+      const isDefer = $el.attr("defer") !== void 0;
+      const isAsync = $el.attr("async") !== void 0;
+      const scriptKind = type === "module" ? "module" : "classic";
+      let execution = "sync";
+      if (scriptKind === "module") {
+        execution = isAsync ? "async" : "defer";
+      } else {
+        if (isDefer) execution = "defer";
+        if (isAsync) execution = "async";
+      }
+      if (type && type !== "text/javascript" && type !== "application/javascript" && type !== "module" && !type.includes("json")) continue;
+      if (type && (type === "application/json" || type === "application/ld+json")) continue;
+      const order = i;
+      const id = `script_${scriptCounter++}`;
+      if (src) {
+        const absoluteUrl = new URL(src, this.targetUrl).toString();
+        const category = classifyScriptAsset({ url: absoluteUrl, content: content ?? "", scriptKind, type: "external" }, this.targetUrl);
+        if (shouldSkipScriptAsset({ url: absoluteUrl, content: content ?? "", scriptKind, type: "external" }, this.targetUrl, this.thirdPartyPolicy)) {
+          skippedScriptCount++;
+          continue;
+        }
+        if (!this.prefetchExternalScripts) continue;
+        const pageOrigin = new URL(this.targetUrl).origin;
+        const scriptOrigin = new URL(absoluteUrl).origin;
+        batchScriptMeta.push({
+          absoluteUrl,
+          id,
+          scriptKind,
+          category,
+          order,
+          execution,
+          headers: {
+            ...DEFAULT_HEADERS,
+            ...this.requestHeaders,
+            "Referer": this.targetUrl,
+            "Sec-Fetch-Dest": "script",
+            "Sec-Fetch-Mode": scriptKind === "module" ? "cors" : "no-cors",
+            "Sec-Fetch-Site": scriptOrigin === pageOrigin ? "same-origin" : "cross-site"
+          }
+        });
+      } else if (content && content.trim().length > 0) {
+        const category = classifyScriptAsset({ url: void 0, content, scriptKind, type: "inline" }, this.targetUrl);
+        if (shouldSkipScriptAsset({ url: void 0, content, scriptKind, type: "inline" }, this.targetUrl, this.thirdPartyPolicy)) {
+          skippedScriptCount++;
+          continue;
+        }
+        scriptAssets.push({ id, type: "inline", scriptKind, category, content, order, execution });
+      }
+    }
+    const modulePreloadUrls = [];
+    if (this.prefetchModulePreloads) {
+      $('link[rel="modulepreload"][href]').each((_, el) => {
+        const href = $(el).attr("href");
+        if (!href) return;
+        const absoluteUrl = new URL(href, this.targetUrl).toString();
+        if (seenModulePreloads.has(absoluteUrl)) return;
+        seenModulePreloads.add(absoluteUrl);
+        modulePreloadUrls.push(absoluteUrl);
+      });
+    }
+    const pageOriginForPreloads = new URL(this.targetUrl).origin;
+    const assetsProxyForPreloads = this.proxyUrlForScope("assets");
+    const preloadPayloads = modulePreloadUrls.map((url) => {
+      const preloadOrigin = new URL(url).origin;
+      return {
+        method: "GET",
+        url,
+        headers: {
+          ...DEFAULT_HEADERS,
+          ...this.requestHeaders,
+          "Referer": this.targetUrl,
+          "Sec-Fetch-Dest": "script",
+          "Sec-Fetch-Mode": "cors",
+          "Sec-Fetch-Site": preloadOrigin === pageOriginForPreloads ? "same-origin" : "cross-site"
+        },
+        headerOrder: DEFAULT_HEADER_ORDER,
+        body: "",
+        proxy: assetsProxyForPreloads
+      };
+    });
+    const assetsProxy = this.proxyUrlForScope("assets");
+    const scriptPayloads = batchScriptMeta.map((m) => ({
+      method: "GET",
+      url: m.absoluteUrl,
+      headers: m.headers,
+      headerOrder: DEFAULT_HEADER_ORDER,
+      body: "",
+      proxy: assetsProxy
+    }));
+    const allPayloads = [...scriptPayloads, ...preloadPayloads];
+    if (allPayloads.length > 0) {
+      console.log(`[Harvest] Batch-fetching ${scriptPayloads.length} scripts + ${preloadPayloads.length} modulepreloads...`);
+      const allResponses = await phantomBatchFetch(allPayloads);
+      for (let i = 0; i < batchScriptMeta.length; i++) {
+        const meta = batchScriptMeta[i];
+        const resp = allResponses[i];
+        const logEntry = {
+          type: "resource_load",
+          url: meta.absoluteUrl,
+          timestamp: Date.now(),
+          initiator: "Harvester",
+          status: resp.status,
+          responseHeaders: resp.headers,
+          responseBody: resp.status < 400 ? resp.body : null
+        };
+        this.logs.push(logEntry);
+        if (resp.status < 400) {
+          scriptAssets.push({
+            id: meta.id,
+            type: "external",
+            scriptKind: meta.scriptKind,
+            category: meta.category,
+            url: meta.absoluteUrl,
+            content: resp.body,
+            order: meta.order,
+            execution: meta.execution
+          });
+        } else {
+          console.warn(`[Harvest] Failed to fetch script ${meta.absoluteUrl}: status ${resp.status}`);
+        }
+      }
+      for (let i = 0; i < modulePreloadUrls.length; i++) {
+        const url = modulePreloadUrls[i];
+        const resp = allResponses[batchScriptMeta.length + i];
+        const logEntry = {
+          type: "resource_load",
+          url,
+          timestamp: Date.now(),
+          initiator: "Harvester.modulepreload",
+          status: resp.status,
+          responseHeaders: resp.headers,
+          responseBody: resp.status < 400 ? resp.body : null
+        };
+        this.logs.push(logEntry);
+        if (resp.status < 400) {
+          modulePreloads.push({ url, content: resp.body });
+        }
+      }
+    }
+    scriptAssets.sort((a, b) => a.order - b.order);
+    const initialState = {};
+    const statePatterns = [
+      /window\.__INITIAL_STATE__\s*=\s*({.+?});/,
+      /window\.__NEXT_DATA__\s*=\s*({.+?});/,
+      /window\.__NUXT__\s*=\s*({.+?});/,
+      /window\.__APP_DATA__\s*=\s*({.+?});/
+    ];
+    for (const pattern of statePatterns) {
+      const match = html.match(pattern);
+      if (match && match[1]) {
+        try {
+          initialState[pattern.toString()] = JSON.parse(match[1]);
+        } catch (e) {
+        }
+      }
+    }
+    $('script[type="application/json"]').each((_, el) => {
+      const id = $(el).attr("id");
+      const content = $(el).html();
+      if (id && content) {
+        try {
+          initialState[id] = JSON.parse(content);
+        } catch (e) {
+        }
+      }
+    });
+    $("[data-page], [data-props], [data-state]").each((index, el) => {
+      const attrs = ["data-page", "data-props", "data-state"];
+      for (const attr of attrs) {
+        const raw = $(el).attr(attr);
+        if (!raw) continue;
+        try {
+          initialState[`attr:${attr}:${index}`] = JSON.parse(raw);
+        } catch {
+        }
+      }
+    });
+    const moduleGraphCache = /* @__PURE__ */ new Map();
+    for (const s of scriptAssets) {
+      if (s.url) moduleGraphCache.set(s.url, s.content);
+    }
+    for (const mp of modulePreloads) {
+      moduleGraphCache.set(mp.url, mp.content);
+    }
+    const moduleEntryUrls = scriptAssets.filter((s) => s.scriptKind === "module" && s.url).map((s) => s.url);
+    if (moduleEntryUrls.length > 0 || modulePreloads.length > 0) {
+      const rootUrls = [...moduleEntryUrls, ...modulePreloads.map((mp) => mp.url)];
+      await prefetchModuleGraph(rootUrls, moduleGraphCache, finalUrl, {
+        proxyUrl: this.proxyUrlForScope("assets")
+      });
+    }
+    return {
+      url: finalUrl,
+      status: response.status,
+      html,
+      scripts: scriptAssets,
+      modulePreloads,
+      skippedScriptCount,
+      initialState,
+      cookies: this.cookies,
+      headers: response.headers,
+      logs: this.logs,
+      moduleGraphCache
+    };
+  }
+};
+
+// ../dynafetch-core/src/detect.ts
+function hasScriptUrl(harvest, pattern) {
+  return harvest.scripts.some((script) => Boolean(script.url && pattern.test(script.url)));
+}
+function detectFramework(harvest) {
+  const html = harvest.html;
+  const lower = html.toLowerCase();
+  if ("__NEXT_DATA__" in harvest.initialState || lower.includes("__next_data__") || lower.includes("/_next/") || hasScriptUrl(harvest, /\/_next\//i)) {
+    return "nextjs";
+  }
+  if ("__NUXT__" in harvest.initialState || lower.includes("__nuxt") || hasScriptUrl(harvest, /\/_nuxt\//i)) {
+    return "nuxt";
+  }
+  if (lower.includes("window.__remixcontext") || lower.includes("remix-context") || hasScriptUrl(harvest, /\/build\/.*entry\.client/i)) {
+    return "remix";
+  }
+  if (lower.includes("data-page=") || hasScriptUrl(harvest, /inertia-[^/]+\.js/i) || hasScriptUrl(harvest, /\/vite\/assets\//i)) {
+    return "inertia";
+  }
+  if (lower.includes("astro-island") || lower.includes("__astro") || hasScriptUrl(harvest, /\/_astro\//i)) {
+    return "astro";
+  }
+  if (lower.includes("__sveltekit") || hasScriptUrl(harvest, /\/_app\/immutable\//i)) {
+    return "sveltekit";
+  }
+  if (lower.includes("hx-get=") || lower.includes("hx-post=") || lower.includes("hx-trigger=")) {
+    return "htmx";
+  }
+  if (harvest.scripts.length > 0) {
+    return "generic-spa";
+  }
+  return "static";
+}
+
+// ../dynafetch-core/src/planner.ts
+function planDynafetch(framework, harvest, allowJsdomFallback) {
+  if (framework === "static" && harvest.scripts.length === 0) {
+    return {
+      framework,
+      strategy: "static-html",
+      reason: "document has no executable scripts; return the fetched HTML directly"
+    };
+  }
+  if (!allowJsdomFallback) {
+    return {
+      framework,
+      strategy: "static-html",
+      reason: "dynamic execution disabled; return the fetched HTML without script execution"
+    };
+  }
+  if (framework !== "generic-spa" && framework !== "static") {
+    return {
+      framework,
+      strategy: "framework-probe",
+      reason: "known framework markers detected; run the lightweight runtime under framework-aware labeling"
+    };
+  }
+  return {
+    framework,
+    strategy: "jsdom-fallback",
+    reason: "generic client-rendered page requires runtime execution to recover dynamic HTML"
+  };
+}
+
+// ../dynafetch-core/src/index.ts
+var DynafetchInputError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.name = "DynafetchInputError";
+    this.status = status;
+  }
+};
+function isPrivateOrLocalHost(hostname) {
+  const h = hostname.toLowerCase();
+  if (h === "localhost" || h.endsWith(".localhost") || h === "0.0.0.0") return true;
+  if (h === "metadata.google.internal") return true;
+  const ipVer = net.isIP(h);
+  if (!ipVer) return false;
+  if (ipVer === 4) {
+    const [a, b] = h.split(".").map((x) => Number(x));
+    if (a === 10) return true;
+    if (a === 127) return true;
+    if (a === 0) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    return false;
+  }
+  if (h === "::1") return true;
+  if (h.startsWith("fe80:")) return true;
+  if (h.startsWith("fc") || h.startsWith("fd")) return true;
+  return false;
+}
+function normalizeProxy(input) {
+  if (!input) return void 0;
+  if (typeof input === "string") {
+    const url2 = input.trim();
+    if (!url2) return void 0;
+    return { url: url2, scopes: /* @__PURE__ */ new Set(["page", "api", "assets"]) };
+  }
+  const url = input.url?.trim();
+  if (!url) return void 0;
+  const scopes = input.only?.length ? new Set(input.only) : /* @__PURE__ */ new Set(["page", "api", "assets"]);
+  return { url, scopes };
+}
+function normalizeCookies(input) {
+  if (!input) return [];
+  if (typeof input === "string") {
+    return input.split(";").map((part) => part.trim()).filter(Boolean);
+  }
+  if (Array.isArray(input)) {
+    return input.map((value) => value.trim()).filter(Boolean);
+  }
+  return Object.entries(input).map(([key, value]) => `${key}=${value}`);
+}
+function normalizeOptions(input) {
+  const options = typeof input === "string" ? { url: input } : input;
+  if (!options?.url) {
+    throw new DynafetchInputError("URL is required");
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(options.url);
+  } catch {
+    throw new DynafetchInputError("Invalid URL");
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    throw new DynafetchInputError("Only http(s) URLs are allowed");
+  }
+  if (isPrivateOrLocalHost(parsedUrl.hostname)) {
+    throw new DynafetchInputError("Refusing to fetch local/private addresses");
+  }
+  return {
+    ...options,
+    url: parsedUrl.toString(),
+    allowJsdomFallback: options.allowJsdomFallback !== false,
+    browserProfile: options.browserProfile?.trim() || "chrome_146",
+    prefetchExternalScripts: options.prefetchExternalScripts !== false,
+    prefetchModulePreloads: options.prefetchModulePreloads !== false,
+    thirdPartyPolicy: options.thirdPartyPolicy ?? "skip-noncritical"
+  };
+}
+function toWarnings(plan, errors, options) {
+  const warnings = [plan.reason];
+  if (plan.strategy === "jsdom-fallback" || plan.strategy === "framework-probe") {
+    warnings.push("runtime execution used the legacy JSDOM-based renderer while lightweight adapters are still being built");
+  }
+  if (options.maxSubrequests) {
+    warnings.push(`maxSubrequests is advisory in the current implementation (${options.maxSubrequests})`);
+  }
+  if (options.thirdPartyPolicy === "skip-noncritical") {
+    warnings.push("non-critical third-party scripts are skipped on the critical render path");
+  }
+  if (errors?.length) {
+    for (const error of errors.slice(0, 3)) {
+      warnings.push(`${error.source}: ${error.message}`);
+    }
+  }
+  return warnings;
+}
+function computeConfidence(params) {
+  let confidence = params.plan.strategy === "static-html" ? 0.92 : 0.68;
+  if (params.plan.framework !== "generic-spa" && params.plan.framework !== "static") {
+    confidence += 0.08;
+  }
+  if (params.initialStateCount > 0) {
+    confidence += 0.06;
+  }
+  if (params.plan.strategy === "jsdom-fallback") {
+    confidence -= 0.08;
+  }
+  if (params.htmlLength < 256) {
+    confidence -= 0.1;
+  }
+  confidence -= Math.min(0.28, params.executionErrors * 0.07);
+  return Math.max(0.05, Math.min(0.98, Number(confidence.toFixed(2))));
+}
+async function dynafetch(input) {
+  const options = normalizeOptions(input);
+  const timeoutSeconds = options.timeoutMs ? Math.max(1, Math.ceil(options.timeoutMs / 1e3)) : void 0;
+  const initialCookies = normalizeCookies(options.cookies);
+  const proxy = normalizeProxy(options.proxy);
+  return await withDynafetchSession(
+    {
+      browserProfile: options.browserProfile,
+      timeoutSeconds,
+      proxy: proxy?.url
+    },
+    async () => {
+      const totalStart = Date.now();
+      const harvestStart = Date.now();
+      const harvester = new Harvester(options.url, {
+        prefetchExternalScripts: options.prefetchExternalScripts,
+        prefetchModulePreloads: options.prefetchModulePreloads,
+        requestHeaders: options.headers,
+        initialCookies,
+        thirdPartyPolicy: options.thirdPartyPolicy,
+        proxy
+      });
+      const harvest = await harvester.harvest();
+      const harvestMs = Date.now() - harvestStart;
+      const framework = detectFramework(harvest);
+      const plan = planDynafetch(framework, harvest, options.allowJsdomFallback !== false);
+      let html = harvest.html;
+      let requestCount = harvest.logs.length;
+      let executionErrors;
+      let executeMs = 0;
+      let quiescenceMs = 0;
+      let scriptsTransformed = 0;
+      if (plan.strategy !== "static-html") {
+        const executeStart = Date.now();
+        const executor = new Executor(harvest, {
+          thirdPartyPolicy: options.thirdPartyPolicy,
+          quiescence: {
+            minWaitMs: options.minWaitMs,
+            idleWaitMs: options.idleWaitMs,
+            maxWaitMs: options.maxWaitMs
+          },
+          moduleWaitMs: options.moduleWaitMs,
+          proxy
+        });
+        const execution = await executor.execute();
+        executeMs = Date.now() - executeStart;
+        html = execution.renderedHtml ?? harvest.html;
+        requestCount = execution.logs.length;
+        executionErrors = execution.errors;
+        quiescenceMs = execution.timings?.quiescence_ms ?? 0;
+        scriptsTransformed = execution.timings?.scripts_transformed_count ?? 0;
+      }
+      const totalMs = Date.now() - totalStart;
+      const warnings = toWarnings(plan, executionErrors, options);
+      const confidence = computeConfidence({
+        plan,
+        initialStateCount: Object.keys(harvest.initialState).length,
+        executionErrors: executionErrors?.length ?? 0,
+        htmlLength: html.length
+      });
+      return {
+        url: options.url,
+        finalUrl: harvest.url,
+        status: harvest.status,
+        html,
+        framework,
+        strategy: plan.strategy,
+        confidence,
+        warnings,
+        timings: {
+          total: totalMs,
+          harvest: harvestMs,
+          execute: executeMs,
+          quiescence: quiescenceMs,
+          scriptsTransformed
+        },
+        requestCount
+      };
+    }
+  );
+}
+export {
+  DynafetchInputError,
+  detectFramework,
+  dynafetch,
+  dynafetchNetBatchFetch,
+  dynafetchNetFetch,
+  dynafetchNetHealth,
+  planDynafetch,
+  withDynafetchSession
+};
+//# sourceMappingURL=index.js.map