magpie-html 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -2,6 +2,12 @@
 
 var readability = require('@mozilla/readability');
 var linkedom = require('linkedom');
+var vm4 = require('vm');
+var timers = require('timers');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var vm4__default = /*#__PURE__*/_interopDefault(vm4);
 
 // src/content/quality.ts
 function countWords(text) {
@@ -832,6 +838,32 @@ function parseAtomDate(dateString) {
 }
 
 // src/feed/atom/extract-entry.ts
+function extractAtomDate(element) {
+  let dateText = element.querySelector("updated")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  dateText = element.querySelector("modified")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  dateText = element.querySelector("issued")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  const dcDateElements = element.children.filter((child) => child.tagName === "dc:date");
+  if (dcDateElements.length > 0) {
+    dateText = dcDateElements[0].textContent;
+    if (dateText) {
+      const parsed = parseAtomDate(dateText);
+      if (parsed) return parsed;
+    }
+  }
+  return null;
+}
 function extractPerson(element) {
   const name = element.querySelector("name")?.textContent;
   if (!name) {
@@ -974,13 +1006,11 @@ function extractEntry(entryElement) {
   if (!title) {
     throw new Error("Invalid Atom entry: missing required <title> element");
   }
-  const updatedRaw = entryElement.querySelector("updated")?.textContent;
-  if (!updatedRaw) {
-    throw new Error("Invalid Atom entry: missing required <updated> element");
-  }
-  const updated = parseAtomDate(updatedRaw);
+  const updated = extractAtomDate(entryElement);
   if (!updated) {
-    throw new Error("Invalid Atom entry: invalid <updated> date");
+    throw new Error(
+      "Invalid Atom entry: missing or invalid date (tried <updated>, <modified>, <issued>, <dc:date>)"
+    );
   }
   const entry = {
     id: cleanText(id),
@@ -1230,6 +1260,32 @@ function parseXML(xml) {
 }
 
 // src/feed/atom/extract-feed.ts
+function extractAtomDate2(element) {
+  let dateText = element.querySelector("updated")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  dateText = element.querySelector("modified")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  dateText = element.querySelector("issued")?.textContent;
+  if (dateText) {
+    const parsed = parseAtomDate(dateText);
+    if (parsed) return parsed;
+  }
+  const dcDateElements = element.children.filter((child) => child.tagName === "dc:date");
+  if (dcDateElements.length > 0) {
+    dateText = dcDateElements[0].textContent;
+    if (dateText) {
+      const parsed = parseAtomDate(dateText);
+      if (parsed) return parsed;
+    }
+  }
+  return null;
+}
 function extractPerson2(element) {
   const name = element.querySelector("name")?.textContent;
   if (!name) {
@@ -1377,13 +1433,11 @@ function extractFeed(xml) {
   if (!title) {
     throw new Error("Invalid Atom feed: missing required <title> element");
   }
-  const updatedRaw = feed.querySelector("updated")?.textContent;
-  if (!updatedRaw) {
-    throw new Error("Invalid Atom feed: missing required <updated> element");
-  }
-  const updated = parseAtomDate(updatedRaw);
+  const updated = extractAtomDate2(feed);
   if (!updated) {
-    throw new Error("Invalid Atom feed: invalid <updated> date");
+    throw new Error(
+      "Invalid Atom feed: missing or invalid date (tried <updated>, <modified>, <issued>, <dc:date>)"
+    );
   }
   const result = {
     id: cleanText(id),
@@ -2445,13 +2499,12 @@ async function pluck(input, init) {
   const startTime = Date.now();
   const options = normalizeOptions2(init);
   const originalUrl = typeof input === "string" || input instanceof URL ? String(input) : input.url;
-  const abortController = new AbortController();
-  const timeoutId = setTimeout(() => abortController.abort(), options.timeout);
+  const signal = AbortSignal.timeout(options.timeout);
   try {
     const { response, redirectChain, redirectDuration } = await followRedirects(
       input,
       options,
-      abortController.signal
+      signal
     );
     const finalUrl = response.url;
     if (options.throwOnHttpError && !response.ok) {
@@ -2488,15 +2541,13 @@ async function pluck(input, init) {
     if (error instanceof PluckTimeoutError || error instanceof PluckNetworkError) {
       throw error;
     }
-    if (error.name === "AbortError") {
+    if (error.name === "TimeoutError") {
       throw new PluckTimeoutError(`Request timeout after ${options.timeout}ms`, options.timeout);
     }
     if (error instanceof TypeError) {
       throw new PluckNetworkError(`Network error: ${error.message}`, error);
     }
     throw error;
-  } finally {
-    clearTimeout(timeoutId);
   }
 }
 function normalizeOptions2(init) {
@@ -5048,6 +5099,1718 @@ function extractVerification(doc) {
     Object.entries(metadata).filter(([_, value]) => value !== void 0)
   );
 }
+
+// src/swoop/errors.ts
+var SwoopError = class extends Error {
+  name = "SwoopError";
+};
+var SwoopEnvironmentError = class extends SwoopError {
+  name = "SwoopEnvironmentError";
+};
+var SwoopTimeoutError = class extends SwoopError {
+  name = "SwoopTimeoutError";
+};
+var SwoopExecutionError = class extends SwoopError {
+  name = "SwoopExecutionError";
+};
+var SwoopSecurityError = class extends SwoopError {
+  name = "SwoopSecurityError";
+};
+
+// src/swoop/console.ts
+function createConsoleCapture(now = () => Date.now()) {
+  const entries = [];
+  const formatError = (err) => {
+    const parts = [];
+    parts.push(`${err.name}: ${err.message}${err.stack ? `
+${err.stack}` : ""}`.trim());
+    try {
+      const props = {};
+      for (const key of Object.getOwnPropertyNames(err)) {
+        if (key === "name" || key === "message" || key === "stack") continue;
+        props[key] = err[key];
+      }
+      if (Object.keys(props).length > 0) {
+        parts.push(`props: ${JSON.stringify(props)}`);
+      }
+    } catch {
+    }
+    return parts.join("\n");
+  };
+  const record = (level, args) => {
+    const msg = args.map((a) => {
+      try {
+        if (a instanceof Error) return formatError(a);
+        if (typeof a === "string") return a;
+        return String(a);
+      } catch {
+        return "[unstringifiable]";
+      }
+    }).join(" ");
+    const argStrings = args.map((a) => {
+      try {
+        if (a instanceof Error) return formatError(a);
+        if (typeof a === "string") return a;
+        return String(a);
+      } catch {
+        return "[unstringifiable]";
+      }
+    });
+    entries.push({ level, message: msg, args: argStrings, time: now() });
+  };
+  return { entries, record };
+}
+function installAsyncEnv(init) {
+  const { globalObj } = init;
+  const hostSetTimeout = timers.setTimeout;
+  const hostClearTimeout = timers.clearTimeout;
+  const hostSetInterval = timers.setInterval;
+  const hostClearInterval = timers.clearInterval;
+  const hostSetImmediate = timers.setImmediate;
+  const hostClearImmediate = timers.clearImmediate;
+  const activeTimeouts = /* @__PURE__ */ new Set();
+  const activeIntervals = /* @__PURE__ */ new Set();
+  const activeImmediates = /* @__PURE__ */ new Set();
+  let lastAsyncActivityAt = Date.now();
+  const noteAsyncActivity = () => {
+    lastAsyncActivityAt = Date.now();
+    if (init.debugProbes) {
+      try {
+        globalObj.__swoopStats.lastAsyncActivityAt = lastAsyncActivityAt;
+      } catch {
+      }
+    }
+  };
+  globalObj.__swoop_requestIdleCallback = (cb, _opts) => {
+    return hostSetTimeout(() => {
+      try {
+        noteAsyncActivity();
+        cb({
+          didTimeout: false,
+          timeRemaining: () => 0
+        });
+      } catch {
+      }
+    }, 0);
+  };
+  globalObj.__swoop_cancelIdleCallback = (handle) => hostClearTimeout(handle);
+  globalObj.__swoop_setTimeout = (...args) => {
+    const handle = hostSetTimeout(() => {
+      activeTimeouts.delete(handle);
+      noteAsyncActivity();
+      if (init.debugProbes) {
+        try {
+          globalObj.__swoopStats.timers.timeoutFired++;
+        } catch {
+        }
+      }
+      args[0]?.call?.(globalObj);
+    }, args[1]);
+    activeTimeouts.add(handle);
+    if (init.debugProbes) {
+      try {
+        globalObj.__swoopStats.timers.timeoutScheduled++;
+      } catch {
+      }
+    }
+    return handle;
+  };
+  globalObj.__swoop_clearTimeout = (handle) => {
+    activeTimeouts.delete(handle);
+    hostClearTimeout(handle);
+  };
+  globalObj.__swoop_setInterval = (...args) => {
+    const handle = hostSetInterval(() => {
+      noteAsyncActivity();
+      if (init.debugProbes) {
+        try {
+          globalObj.__swoopStats.timers.intervalFired++;
+        } catch {
+        }
+      }
+      args[0]?.call?.(globalObj);
+    }, args[1]);
+    activeIntervals.add(handle);
+    if (init.debugProbes) {
+      try {
+        globalObj.__swoopStats.timers.intervalScheduled++;
+      } catch {
+      }
+    }
+    return handle;
+  };
+  globalObj.__swoop_clearInterval = (handle) => {
+    activeIntervals.delete(handle);
+    hostClearInterval(handle);
+  };
+  globalObj.__swoop_queueMicrotask = (cb) => {
+    try {
+      process.nextTick(() => {
+        noteAsyncActivity();
+        cb.call(globalObj);
+      });
+    } catch {
+      hostSetTimeout(() => {
+        noteAsyncActivity();
+        cb.call(globalObj);
+      }, 0);
+    }
+  };
+  globalObj.__swoop_setImmediate = (cb, ...args) => {
+    const handle = hostSetImmediate(() => {
+      activeImmediates.delete(handle);
+      try {
+        noteAsyncActivity();
+        cb.call(globalObj, ...args);
+      } catch {
+      }
+    });
+    activeImmediates.add(handle);
+    return handle;
+  };
+  globalObj.__swoop_clearImmediate = (handle) => {
+    activeImmediates.delete(handle);
+    hostClearImmediate(handle);
+  };
+  globalObj.__swoop_requestAnimationFrame = (cb) => {
+    if (init.debugProbes) {
+      try {
+        globalObj.__swoopStats.timers.rafScheduled++;
+      } catch {
+      }
+    }
+    const id = hostSetTimeout(() => {
+      if (init.debugProbes) {
+        try {
+          globalObj.__swoopStats.timers.rafFired++;
+        } catch {
+        }
+      }
+      noteAsyncActivity();
+      cb.call(globalObj, Date.now());
+    }, 16);
+    return id;
+  };
+  globalObj.__swoop_cancelAnimationFrame = (id) => hostClearTimeout(id);
+  const cleanup = () => {
+    for (const h of activeTimeouts) hostClearTimeout(h);
+    for (const h of activeIntervals) hostClearInterval(h);
+    for (const h of activeImmediates) hostClearImmediate(h);
+  };
+  return {
+    hostSetTimeout,
+    hostClearTimeout,
+    hostSetInterval,
+    hostClearInterval,
+    hostSetImmediate,
+    hostClearImmediate,
+    noteAsyncActivity,
+    getLastAsyncActivityAt: () => lastAsyncActivityAt,
+    cleanup
+  };
+}
+
+// src/swoop/env/base.ts
+function computeBaseForResolve(finalUrl, document) {
+  const pageUrl = new URL(finalUrl);
+  const baseEl = document?.querySelector?.("base") ?? null;
+  const baseTagHref = baseEl?.getAttribute?.("href") ?? null;
+  const baseForResolve = (() => {
+    try {
+      return baseTagHref ? new URL(String(baseTagHref), finalUrl) : pageUrl;
+    } catch {
+      return pageUrl;
+    }
+  })();
+  return { baseForResolve, baseTagHref, baseEl };
+}
+function patchDocumentBaseURI(document, baseForResolve) {
+  try {
+    Object.defineProperty(document, "baseURI", {
+      configurable: true,
+      get: () => baseForResolve.href
+    });
+  } catch {
+  }
+}
+function patchBaseElementHref(baseEl, baseForResolve) {
+  try {
+    if (baseEl) {
+      Object.defineProperty(baseEl, "href", {
+        configurable: true,
+        get: () => baseForResolve.href,
+        set: (_v) => {
+        }
+      });
+    }
+  } catch {
+  }
+}
+
+// src/swoop/env/browser.ts
+function installBrowserShims(init) {
+  const { globalObj, domWindow, documentBaseUriForDom } = init;
+  const doc = init.document ?? globalObj.document;
+  try {
+    if (doc && doc.defaultView == null) doc.defaultView = globalObj;
+  } catch {
+  }
+  try {
+    if (doc && doc.baseURI == null) doc.baseURI = documentBaseUriForDom;
+  } catch {
+  }
+  globalObj.navigator ??= {};
+  globalObj.navigator.language ??= "en";
+  globalObj.navigator.languages ??= [globalObj.navigator.language];
+  globalObj.navigator.onLine ??= true;
+  globalObj.screen ??= {
+    width: 1280,
+    height: 720,
+    availWidth: 1280,
+    availHeight: 720,
+    colorDepth: 24
+  };
+  globalObj.devicePixelRatio ??= 1;
+  globalObj.innerWidth ??= globalObj.screen.width ?? 1280;
+  globalObj.innerHeight ??= globalObj.screen.height ?? 720;
+  globalObj.MessageChannel ??= globalThis.MessageChannel;
+  globalObj.MessagePort ??= globalThis.MessagePort;
+  globalObj.MessageEvent ??= globalThis.MessageEvent;
+  globalObj.BroadcastChannel ??= globalThis.BroadcastChannel;
+  globalObj.getComputedStyle ??= (el) => {
+    const style = el?.style ?? {};
+    return new Proxy(style, {
+      get(target, prop) {
+        if (prop === "getPropertyValue") return (name) => target?.[name] ?? "";
+        return target[prop] ?? "";
+      }
+    });
+  };
+  globalObj.PopStateEvent ??= class PopStateEvent extends (globalObj.Event ?? Event) {
+    state;
+    constructor(type, init2) {
+      super(type, init2);
+      this.state = init2?.state;
+    }
+  };
+  globalObj.HashChangeEvent ??= class HashChangeEvent extends (globalObj.Event ?? Event) {
+    oldURL;
+    newURL;
+    constructor(type, init2) {
+      super(type, init2);
+      this.oldURL = init2?.oldURL ?? "";
+      this.newURL = init2?.newURL ?? "";
+    }
+  };
+  globalObj.matchMedia ??= (query) => {
+    const listeners = /* @__PURE__ */ new Set();
+    const mql = {
+      matches: false,
+      media: String(query ?? ""),
+      onchange: null,
+      addListener: (cb) => {
+        if (typeof cb === "function") listeners.add(cb);
+      },
+      removeListener: (cb) => {
+        listeners.delete(cb);
+      },
+      addEventListener: (type, cb) => {
+        if (String(type) === "change" && typeof cb === "function") listeners.add(cb);
+      },
+      removeEventListener: (type, cb) => {
+        if (String(type) === "change") listeners.delete(cb);
+      },
+      dispatchEvent: (evt) => {
+        try {
+          for (const cb of listeners) cb.call(mql, evt);
+          if (typeof mql.onchange === "function") mql.onchange.call(mql, evt);
+        } catch {
+        }
+        return true;
+      }
+    };
+    return mql;
+  };
+  globalObj.IntersectionObserver ??= class IntersectionObserver {
+    observe(_el) {
+    }
+    unobserve(_el) {
+    }
+    disconnect() {
+    }
+    takeRecords() {
+      return [];
+    }
+  };
+  globalObj.ResizeObserver ??= class ResizeObserver {
+    observe(_el) {
+    }
+    unobserve(_el) {
+    }
+    disconnect() {
+    }
+  };
+  globalObj.MutationObserver ??= class MutationObserver {
+    observe(_target, _options) {
+    }
+    disconnect() {
+    }
+    takeRecords() {
+      return [];
+    }
+  };
+  globalObj.URL ??= URL;
+  globalObj.URLSearchParams ??= URLSearchParams;
+  globalObj.WebAssembly ??= WebAssembly;
+  globalObj.TextEncoder ??= TextEncoder;
+  globalObj.TextDecoder ??= TextDecoder;
+  globalObj.Headers ??= globalThis.Headers;
+  globalObj.Request ??= globalThis.Request;
+  globalObj.Response ??= globalThis.Response;
+  globalObj.crypto ??= globalThis.crypto;
+  globalObj.performance ??= globalThis.performance;
+  globalObj.structuredClone ??= globalThis.structuredClone;
+  globalObj.Blob ??= globalThis.Blob;
+  globalObj.FormData ??= globalThis.FormData;
+  globalObj.File ??= globalThis.File;
+  globalObj.ReadableStream ??= globalThis.ReadableStream;
+  globalObj.atob ??= (data) => Buffer.from(data, "base64").toString("binary");
+  globalObj.btoa ??= (data) => Buffer.from(data, "binary").toString("base64");
+  globalObj.WebSocket ??= class WebSocket {
+    constructor() {
+      throw new Error("swoop: WebSocket is not implemented");
+    }
+  };
+  globalObj.EventSource ??= class EventSource {
+    constructor() {
+      throw new Error("swoop: EventSource is not implemented");
+    }
+  };
+  globalObj.Worker ??= class Worker {
+    constructor() {
+      throw new Error("swoop: Worker is not implemented");
+    }
+  };
+  globalObj.SharedWorker ??= class SharedWorker {
+    constructor() {
+      throw new Error("swoop: SharedWorker is not implemented");
+    }
+  };
+  globalObj.indexedDB ??= void 0;
+  globalObj.caches ??= void 0;
+  globalObj.Notification ??= void 0;
+  globalObj.Document ??= domWindow.Document;
+  globalObj.HTMLDocument ??= domWindow.HTMLDocument ?? init.document?.constructor;
+  globalObj.Element ??= domWindow.Element;
+  globalObj.HTMLElement ??= domWindow.HTMLElement;
+  globalObj.Node ??= domWindow.Node;
+  globalObj.NodeFilter ??= domWindow.NodeFilter ?? {
+    FILTER_ACCEPT: 1,
+    FILTER_REJECT: 2,
+    FILTER_SKIP: 3,
+    SHOW_ALL: 4294967295,
+    SHOW_ELEMENT: 1,
+    SHOW_ATTRIBUTE: 2,
+    SHOW_TEXT: 4,
+    SHOW_CDATA_SECTION: 8,
+    SHOW_ENTITY_REFERENCE: 16,
+    SHOW_ENTITY: 32,
+    SHOW_PROCESSING_INSTRUCTION: 64,
+    SHOW_COMMENT: 128,
+    SHOW_DOCUMENT: 256,
+    SHOW_DOCUMENT_TYPE: 512,
+    SHOW_DOCUMENT_FRAGMENT: 1024,
+    SHOW_NOTATION: 2048
+  };
+}
+
+// src/swoop/env/cookie.ts
+function installCookieJar(document) {
+  let cookieJar = "";
+  try {
+    Object.defineProperty(document, "cookie", {
+      configurable: true,
+      get() {
+        return cookieJar;
+      },
+      set(value) {
+        if (typeof value === "string" && value.length > 0) {
+          cookieJar = cookieJar ? `${cookieJar}; ${value}` : value;
+        }
+      }
+    });
+  } catch {
+  }
+}
+
+// src/swoop/env/fetch.ts
+function installFetchShim(init) {
+  let pendingFetches = 0;
+  init.globalObj.__swoop_fetch = typeof init.hostFetch === "function" ? (...args) => {
+    init.noteAsyncActivity();
+    pendingFetches++;
+    try {
+      const input = args[0];
+      const initReq = args[1];
+      let resolvedInput = input;
+      if (typeof input === "string") {
+        resolvedInput = new URL(input, init.baseForResolveHref).href;
+      } else if (input instanceof URL) {
+        resolvedInput = input.href;
+      } else if (typeof input.url === "string") {
+        try {
+          resolvedInput = new URL(input.url, init.baseForResolveHref).href;
+        } catch {
+        }
+      }
+      if (init.debugFetch) {
+        init.recordDebug(["[fetch]", resolvedInput]);
+      }
+      const controller = new AbortController();
+      const timeoutHandle = init.hostSetTimeout(() => controller.abort(), init.remainingMs());
+      const mergedInit = { ...initReq, signal: controller.signal };
+      const p = init.hostFetch(resolvedInput, mergedInit).finally(() => {
+        init.hostClearTimeout(timeoutHandle);
+      });
+      return p.finally(() => {
+        try {
+          init.queueMicrotask(() => {
+            pendingFetches--;
+            init.noteAsyncActivity();
+          });
+        } catch {
+          pendingFetches--;
+          init.noteAsyncActivity();
+        }
+      });
+    } catch (err) {
+      pendingFetches--;
+      init.noteAsyncActivity();
+      throw err;
+    }
+  } : void 0;
+  return {
+    getPendingFetches: () => pendingFetches
+  };
+}
+
+// src/swoop/env/navigation.ts
+function createNavigationShims(init) {
+  const { pageUrl } = init;
+  const resolveAndSetHref = (href) => {
+    try {
+      const next = new URL(href, pageUrl.href);
+      pageUrl.href = next.href;
+      init.onNavigate?.(pageUrl.href);
+    } catch {
+    }
+  };
+  const location = {};
+  try {
+    Object.defineProperties(location, {
+      href: { get: () => pageUrl.href, set: (v) => resolveAndSetHref(String(v)) },
+      origin: { get: () => pageUrl.origin },
+      protocol: {
+        get: () => pageUrl.protocol,
+        set: (v) => {
+          pageUrl.protocol = String(v);
+        }
+      },
+      host: {
+        get: () => pageUrl.host,
+        set: (v) => {
+          pageUrl.host = String(v);
+        }
+      },
+      hostname: {
+        get: () => pageUrl.hostname,
+        set: (v) => {
+          pageUrl.hostname = String(v);
+        }
+      },
+      port: {
+        get: () => pageUrl.port,
+        set: (v) => {
+          pageUrl.port = String(v);
+        }
+      },
+      pathname: { get: () => pageUrl.pathname, set: (v) => resolveAndSetHref(String(v)) },
+      search: {
+        get: () => pageUrl.search,
+        set: (v) => {
+          pageUrl.search = String(v);
+        }
+      },
+      hash: {
+        get: () => pageUrl.hash,
+        set: (v) => {
+          pageUrl.hash = String(v);
+        }
+      }
+    });
+  } catch {
+  }
+  location.toString = () => pageUrl.href;
+  location.assign = (href) => resolveAndSetHref(href);
+  location.replace = (href) => resolveAndSetHref(href);
+  location.reload = () => {
+  };
+  let historyState = null;
+  const history = {
+    get state() {
+      return historyState;
+    },
+    pushState: (state, _title, url) => {
+      historyState = state;
+      if (url != null) resolveAndSetHref(String(url));
+      try {
+        init.onPopState?.(state);
+      } catch {
+      }
+    },
+    replaceState: (state, _title, url) => {
+      historyState = state;
+      if (url != null) resolveAndSetHref(String(url));
+    },
+    back: () => {
+    },
+    forward: () => {
+    },
+    go: (_delta) => {
+    }
+  };
+  return { location, history };
+}
+
+// src/swoop/env/permissive.ts
+function installPermissiveShims(globalObj) {
+  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;
+      },
+      key(index) {
+        return Array.from(store.keys())[index] ?? null;
+      },
+      removeItem(key) {
+        store.delete(String(key));
+      },
+      setItem(key, value) {
+        store.set(String(key), String(value));
+      }
+    };
+  };
+  globalObj.localStorage ??= makeStorage();
+  globalObj.sessionStorage ??= makeStorage();
+  globalObj.scrollTo ??= () => {
+  };
+  try {
+    if (globalObj.HTMLElement?.prototype && !globalObj.HTMLElement.prototype.getBoundingClientRect) {
+      globalObj.HTMLElement.prototype.getBoundingClientRect = () => ({
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        toJSON() {
+        }
+      });
+    }
+  } catch {
+  }
+  globalObj.process ??= { env: { NODE_ENV: "production" } };
+}
+
+// src/swoop/env/xhr.ts
+function installXMLHttpRequest(init) {
+  const g = init.globalObj;
+  if (g.XMLHttpRequest) return;
+  class Xhr {
+    // readyState constants
+    static UNSENT = 0;
+    static OPENED = 1;
+    static HEADERS_RECEIVED = 2;
+    static LOADING = 3;
+    static DONE = 4;
+    UNSENT = 0;
+    OPENED = 1;
+    HEADERS_RECEIVED = 2;
+    LOADING = 3;
+    DONE = 4;
+    readyState = 0;
+    status = 0;
+    statusText = "";
+    responseType = "";
+    response = null;
+    responseText = "";
+    timeout = 0;
+    withCredentials = false;
+    onreadystatechange = null;
+    onload = null;
+    onerror = null;
+    ontimeout = null;
+    onabort = null;
+    _method = "GET";
+    _url = "";
+    _headers = /* @__PURE__ */ new Map();
+    _respHeaders = null;
+    _listeners = /* @__PURE__ */ new Map();
+    _controller = null;
+    addEventListener(type, cb) {
+      const t = String(type);
+      const set = this._listeners.get(t) ?? /* @__PURE__ */ new Set();
+      set.add(cb);
+      this._listeners.set(t, set);
+    }
+    removeEventListener(type, cb) {
+      const t = String(type);
+      this._listeners.get(t)?.delete(cb);
+    }
+    _dispatch(type) {
+      const ev = { type, target: this, currentTarget: this };
+      this._listeners.get(type)?.forEach((cb) => {
+        try {
+          cb(ev);
+        } catch {
+        }
+      });
+    }
+    _setReadyState(n) {
+      this.readyState = n;
+      try {
+        this.onreadystatechange?.();
+      } catch {
+      }
+      this._dispatch("readystatechange");
+    }
+    open(method, url, async = true) {
+      this._method = String(method ?? "GET").toUpperCase();
+      this._url = String(url ?? "");
+      this._headers.clear();
+      this._respHeaders = null;
+      this._controller = null;
+      this._setReadyState(1);
+    }
+    setRequestHeader(name, value) {
+      this._headers.set(String(name), String(value));
+    }
+    getResponseHeader(name) {
+      try {
+        return this._respHeaders?.get(String(name)) ?? null;
+      } catch {
+        return null;
+      }
+    }
+    getAllResponseHeaders() {
+      try {
+        if (!this._respHeaders) return "";
+        let out = "";
+        this._respHeaders.forEach((v, k) => {
+          out += `${k}: ${v}\r
+`;
+        });
+        return out;
+      } catch {
+        return "";
+      }
+    }
+    overrideMimeType(_mime) {
+    }
+    abort() {
+      try {
+        this._controller?.abort();
+      } catch {
+      }
+      try {
+        this.onabort?.();
+      } catch {
+      }
+      this._dispatch("abort");
+    }
+    send(body) {
+      const doFetch = async () => {
+        const url = init.resolveUrl(this._url);
+        const controller = new AbortController();
+        this._controller = controller;
+        let timeoutHandle;
+        const ms = Math.min(this.timeout || 0, init.remainingMs());
+        if (ms > 0) {
+          timeoutHandle = init.hostSetTimeout(() => controller.abort(), ms);
+        }
+        try {
+          const headers = {};
+          for (const [k, v] of this._headers.entries()) headers[k] = v;
+          if (!init.fetch) throw new Error("swoop: host fetch is unavailable in this Node runtime");
+          const resp = await init.fetch(url, {
+            method: this._method,
+            headers,
+            body,
+            signal: controller.signal
+            // credentials/withCredentials ignored (Node fetch differs); best-effort.
+          });
+          this._respHeaders = resp.headers;
+          this.status = resp.status;
+          this.statusText = resp.statusText ?? "";
+          this._setReadyState(2);
+          this._setReadyState(3);
+          if (this.responseType === "arraybuffer") {
+            this.response = await resp.arrayBuffer();
+            this.responseText = "";
+          } else if (this.responseType === "blob") {
+            this.response = resp.blob ? await resp.blob() : await resp.arrayBuffer();
+            this.responseText = "";
+          } else {
+            const text = await resp.text();
+            this.responseText = text;
+            if (this.responseType === "json") {
+              try {
+                this.response = JSON.parse(text);
+              } catch {
+                this.response = null;
+              }
+            } else {
+              this.response = text;
+            }
+          }
+          this._setReadyState(4);
+          try {
+            this.onload?.();
+          } catch {
+          }
+          this._dispatch("load");
+          this._dispatch("loadend");
+        } catch {
+          this._setReadyState(4);
+          const aborted = this._controller?.signal?.aborted;
+          if (aborted) {
+            try {
+              this.ontimeout?.();
+            } catch {
+            }
+            this._dispatch("timeout");
+          } else {
+            try {
+              this.onerror?.();
+            } catch {
+            }
+            this._dispatch("error");
+          }
+          this._dispatch("loadend");
+        } finally {
+          if (timeoutHandle) init.hostClearTimeout(timeoutHandle);
+        }
+      };
+      void doFetch();
+    }
+  }
+  g.XMLHttpRequest = Xhr;
+}
+function synthesizeLifecycle(context, timeoutMs = 50) {
+  vm4__default.default.runInContext(
+    `
+      try {
+        const EventCtor = (globalThis.Event || (globalThis.window && globalThis.window.Event));
+        const dispatchDoc = (type) => { try { document.dispatchEvent(new EventCtor(type)); } catch {} };
+        const dispatchWin = (type) => { try { window.dispatchEvent(new EventCtor(type)); } catch {} };
+
+        if (typeof document.readyState !== "string") {
+          try { document.readyState = "loading"; } catch {}
+        }
+
+        dispatchDoc("readystatechange");
+        try { document.readyState = "interactive"; } catch {}
+        dispatchDoc("readystatechange");
+        dispatchDoc("DOMContentLoaded");
+        try { document.readyState = "complete"; } catch {}
+        dispatchDoc("readystatechange");
+
+        try {
+          if (typeof document.visibilityState !== "string") document.visibilityState = "visible";
+          if (typeof document.hidden !== "boolean") document.hidden = false;
+          if (typeof document.hasFocus !== "function") document.hasFocus = () => true;
+        } catch {}
+        dispatchDoc("visibilitychange");
+
+        dispatchWin("pageshow");
+        dispatchWin("load");
+
+        try { window.dispatchEvent(new PopStateEvent("popstate", { state: (history && history.state) })); } catch {}
+        try {
+          const href = String((location && location.href) || "");
+          window.dispatchEvent(new HashChangeEvent("hashchange", { oldURL: href, newURL: href }));
+        } catch {}
+      } catch {}
+    `,
+    context,
+    { timeout: timeoutMs }
+  );
+}
+
+// src/swoop/probes.ts
+function installDebugProbes(init) {
+  const { globalObj, hostSetTimeout } = init;
+  globalObj.__swoopStats = {
+    startedAt: Date.now(),
+    domOps: /* @__PURE__ */ Object.create(null),
+    mutations: 0,
+    lastDomActivityAt: 0,
+    listeners: /* @__PURE__ */ Object.create(null),
+    timers: {
+      timeoutScheduled: 0,
+      timeoutFired: 0,
+      intervalScheduled: 0,
+      intervalFired: 0,
+      rafScheduled: 0,
+      rafFired: 0
+    },
+    nav: {
+      pushState: 0,
+      replaceState: 0,
+      lastHref: null
+    },
+    appRootSamples: []
+  };
+  const bump = (name) => {
+    const s = globalObj.__swoopStats;
+    s.domOps[name] = (s.domOps[name] ?? 0) + 1;
+    s.lastDomActivityAt = Date.now();
+  };
+  const bumpListener = (type) => {
+    const s = globalObj.__swoopStats;
+    s.listeners[type] = (s.listeners[type] ?? 0) + 1;
+  };
+  const wrapProto = (proto, fn) => {
+    const orig = proto?.[fn];
+    if (typeof orig !== "function") return;
+    proto[fn] = function(...args) {
+      bump(fn);
+      return orig.apply(this, args);
+    };
+  };
+  wrapProto(globalObj.Node?.prototype, "appendChild");
+  wrapProto(globalObj.Node?.prototype, "insertBefore");
+  wrapProto(globalObj.Node?.prototype, "removeChild");
+  wrapProto(globalObj.Element?.prototype, "setAttribute");
+  wrapProto(globalObj.Element?.prototype, "removeAttribute");
+  wrapProto(globalObj.Element?.prototype, "append");
+  wrapProto(globalObj.Element?.prototype, "prepend");
+  const wrapAddListener = (target, label) => {
+    const orig = target?.addEventListener;
+    if (typeof orig !== "function") return;
+    target.addEventListener = function(type, listener, options) {
+      try {
+        bumpListener(`${label}:${String(type)}`);
+      } catch {
+      }
+      return orig.call(this, type, listener, options);
+    };
+  };
+  wrapAddListener(globalObj, "window");
+  wrapAddListener(globalObj.document, "document");
+  const MO = globalObj.MutationObserver;
+  if (typeof MO === "function") {
+    const mo = new MO(() => {
+      globalObj.__swoopStats.mutations++;
+      globalObj.__swoopStats.lastDomActivityAt = Date.now();
+    });
+    try {
+      mo.observe(globalObj.document?.documentElement, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        characterData: true
+      });
+    } catch {
+    }
+  }
+  const sample = () => {
+    try {
+      const el = globalObj.document?.querySelector?.("app-root");
+      const len = el?.innerHTML?.length ?? 0;
+      const opacity = el?.getAttribute?.("style")?.includes("opacity") ? String(el.getAttribute("style")) : null;
+      globalObj.__swoopStats.appRootSamples.push({ t: Date.now(), len, opacity });
+    } catch {
+    }
+  };
+  sample();
+  hostSetTimeout(sample, 250);
+  hostSetTimeout(sample, 1e3);
+  hostSetTimeout(sample, 2500);
+  hostSetTimeout(sample, 4500);
+}
+function emitDebugProbes(globalObj, recordDebug, now = () => Date.now()) {
+  const stats = globalObj.__swoopStats;
+  if (!stats) return;
+  const appRootHtml = (() => {
+    try {
+      const el = globalObj.document?.querySelector?.("app-root");
+      const raw = el?.innerHTML ?? "";
+      return String(raw).slice(0, 400);
+    } catch {
+      return null;
+    }
+  })();
+  recordDebug([
+    "[swoop probes]",
+    JSON.stringify({
+      mutations: stats.mutations ?? 0,
+      lastDomActivityMsAgo: stats.lastDomActivityAt && typeof stats.lastDomActivityAt === "number" ? now() - stats.lastDomActivityAt : null,
+      topDomOps: Object.entries(stats.domOps ?? {}).sort((a, b) => b[1] - a[1]).slice(0, 15),
+      topListeners: Object.entries(stats.listeners ?? {}).sort((a, b) => b[1] - a[1]).slice(0, 20),
+      timers: stats.timers ?? null,
+      lastAsyncActivityMsAgo: stats.lastAsyncActivityAt && typeof stats.lastAsyncActivityAt === "number" ? now() - stats.lastAsyncActivityAt : null,
+      nav: stats.nav ?? null,
+      location: (() => {
+        try {
+          return {
+            href: String(globalObj.location?.href ?? ""),
+            pathname: String(globalObj.location?.pathname ?? ""),
+            search: String(globalObj.location?.search ?? ""),
+            hash: String(globalObj.location?.hash ?? ""),
+            baseURI: String(globalObj.document?.baseURI ?? "")
+          };
+        } catch {
+          return null;
+        }
+      })(),
+      appRootSamples: stats.appRootSamples ?? [],
+      appRootHtmlHead: appRootHtml
+    })
+  ]);
+}
+
+// src/swoop/scripts/loader.ts
+function isScriptEl(node) {
+  return node?.tagName?.toLowerCase?.() === "script";
+}
+function createScriptLoader(init) {
+  const loadedScriptSrcs = /* @__PURE__ */ new Set();
+  let pendingScriptLoads = 0;
+  let debugScriptEvents = 0;
+  const debugScript = (...args) => {
+    if (debugScriptEvents++ > init.maxDebugEvents) return;
+    init.debug(args);
+  };
+  const loadScriptElement = async (scriptEl, parentUrlForResolve) => {
+    const rawSrc = scriptEl?.src || scriptEl?.getAttribute?.("src");
+    if (!rawSrc) return;
+    let resolvedSrc;
+    try {
+      resolvedSrc = new URL(String(rawSrc), init.baseForResolveHref).href;
+    } catch {
+      return;
+    }
+    if (loadedScriptSrcs.has(resolvedSrc)) return;
+    loadedScriptSrcs.add(resolvedSrc);
+    init.noteAsyncActivity();
+    pendingScriptLoads++;
+    const type = (scriptEl?.type || scriptEl?.getAttribute?.("type") || "").toString().trim().toLowerCase();
+    const isModule = type === "module";
+    debugScript("[swoop] load <script>", resolvedSrc, isModule ? "module" : "classic");
+    try {
+      if (isModule) {
+        await init.runModuleScript(resolvedSrc, parentUrlForResolve);
+      } else {
+        const code = await init.fetchText(resolvedSrc);
+        init.runClassicScript(code, resolvedSrc);
+      }
+      try {
+        if (typeof scriptEl?.onload === "function")
+          scriptEl.onload(new (init.globalObj.Event ?? Event)("load"));
+      } catch {
+        try {
+          scriptEl.onload?.();
+        } catch {
+        }
+      }
+      try {
+        scriptEl?.dispatchEvent?.(new (init.globalObj.Event ?? Event)("load"));
+      } catch {
+      }
+    } catch (e) {
+      try {
+        init.onError?.(resolvedSrc, e);
+      } catch {
+      }
+      try {
+        if (typeof scriptEl?.onerror === "function") scriptEl.onerror(e);
+      } catch {
+        try {
+          scriptEl.onerror?.();
+        } catch {
+        }
+      }
+      try {
+        scriptEl?.dispatchEvent?.(new (init.globalObj.Event ?? Event)("error"));
+      } catch {
+      }
+    } finally {
+      pendingScriptLoads--;
+      init.noteAsyncActivity();
+    }
+  };
+  const scheduleScriptLoad = (node, label) => {
+    init.hostSetTimeout(() => {
+      void loadScriptElement(node, `${init.pageUrlHref}#${label}`);
+    }, 0);
+  };
+  const patchScriptInsertion = (container, label) => {
+    if (!container) return;
+    const origAppendChild = container.appendChild?.bind(container);
+    const origInsertBefore = container.insertBefore?.bind(container);
+    const origAppend = container.append?.bind(container);
+    const origPrepend = container.prepend?.bind(container);
+    if (typeof origAppendChild === "function") {
+      container.appendChild = (node) => {
+        const ret = origAppendChild(node);
+        if (isScriptEl(node)) scheduleScriptLoad(node, `${label}.appendChild`);
+        return ret;
+      };
+    }
+    if (typeof origInsertBefore === "function") {
+      container.insertBefore = (node, ref) => {
+        const ret = origInsertBefore(node, ref);
+        if (isScriptEl(node)) scheduleScriptLoad(node, `${label}.insertBefore`);
+        return ret;
+      };
+    }
+    if (typeof origAppend === "function") {
+      container.append = (...nodes) => {
+        const ret = origAppend(...nodes);
+        for (const n of nodes) if (isScriptEl(n)) scheduleScriptLoad(n, `${label}.append`);
+        return ret;
+      };
+    }
+    if (typeof origPrepend === "function") {
+      container.prepend = (...nodes) => {
+        const ret = origPrepend(...nodes);
+        for (const n of nodes) if (isScriptEl(n)) scheduleScriptLoad(n, `${label}.prepend`);
+        return ret;
+      };
+    }
+  };
+  const install = () => {
+    patchScriptInsertion(init.globalObj.document?.head, "head");
+    patchScriptInsertion(init.globalObj.document?.body, "body");
+    try {
+      const elProto = init.globalObj.Element?.prototype;
+      const origSetAttr = elProto?.setAttribute;
+      if (typeof origSetAttr === "function") {
+        elProto.setAttribute = function(name, value) {
+          const ret = origSetAttr.call(this, name, value);
+          try {
+            if (this?.tagName?.toLowerCase?.() === "script" && typeof name === "string" && name.toLowerCase() === "src") {
+              scheduleScriptLoad(this, "script.setAttribute(src)");
+            }
+          } catch {
+          }
+          return ret;
+        };
+      }
+    } catch {
+    }
+    try {
+      const doc = init.globalObj.document;
+      const origCreateElement = doc?.createElement?.bind(doc);
+      if (typeof origCreateElement === "function") {
+        doc.createElement = (tagName, ...rest) => {
+          const el = origCreateElement(tagName, ...rest);
+          try {
+            if (typeof tagName === "string" && tagName.toLowerCase() === "script") {
+              const desc = Object.getOwnPropertyDescriptor(el, "src");
+              if (!desc || desc.configurable) {
+                let _src = el.getAttribute?.("src") ?? "";
+                Object.defineProperty(el, "src", {
+                  configurable: true,
+                  enumerable: true,
+                  get: () => _src,
+                  set: (v) => {
+                    _src = String(v);
+                    try {
+                      el.setAttribute?.("src", _src);
+                    } catch {
+                    }
+                    scheduleScriptLoad(el, "script.src=");
+                  }
+                });
+              }
+            }
+          } catch {
+          }
+          return el;
+        };
+      }
+    } catch {
+    }
+  };
+  return {
+    getPendingScriptLoads: () => pendingScriptLoads,
+    install
+  };
+}
+function isNodeRuntime() {
+  return typeof process !== "undefined" && typeof process.versions === "object" && typeof process.versions.node === "string";
+}
+function sleep(ms) {
+  return new Promise((resolve) => timers.setTimeout(resolve, ms));
+}
+function normalizeInit(init) {
+  return {
+    engine: init?.engine ?? "vm",
+    pluck: init?.pluck ?? {},
+    executeScripts: init?.executeScripts ?? true,
+    timeout: init?.timeout ?? 3e3,
+    waitStrategy: init?.waitStrategy ?? "networkidle",
+    idleTime: init?.idleTime ?? 250,
+    pollInterval: init?.pollInterval ?? 25,
+    maxScripts: init?.maxScripts ?? 64,
+    forwardConsole: init?.forwardConsole ?? false,
+    permissiveShims: init?.permissiveShims ?? true,
+    debugFetch: init?.debugFetch ?? false,
+    debugProbes: init?.debugProbes ?? false
+  };
+}
+function defineWindowInContext(context, timeoutMs = 50) {
+  vm4__default.default.runInContext(
+    `
+      globalThis.Window ??= function Window() {};
+      try { globalThis.Window.prototype = Object.getPrototypeOf(globalThis); } catch {}
+    `,
+    context,
+    { timeout: timeoutMs }
+  );
+}
+function ensureRealmFunctionIntrinsic(context, timeoutMs = 50) {
+  vm4__default.default.runInContext(
+    `
+      try { globalThis.Function = (function(){}).constructor; } catch {}
+    `,
+    context,
+    { timeout: timeoutMs }
+  );
+}
+function installRealmWrappers(context, timeoutMs = 50) {
+  vm4__default.default.runInContext(
+    `
+      // timers
+      if (typeof globalThis.__swoop_setTimeout === "function") {
+        globalThis.setTimeout = (...args) => globalThis.__swoop_setTimeout(...args);
+      }
+      if (typeof globalThis.__swoop_clearTimeout === "function") {
+        globalThis.clearTimeout = (...args) => globalThis.__swoop_clearTimeout(...args);
+      }
+      if (typeof globalThis.__swoop_setInterval === "function") {
+        globalThis.setInterval = (...args) => globalThis.__swoop_setInterval(...args);
+      }
+      if (typeof globalThis.__swoop_clearInterval === "function") {
+        globalThis.clearInterval = (...args) => globalThis.__swoop_clearInterval(...args);
+      }
+      if (typeof globalThis.__swoop_setImmediate === "function") {
+        globalThis.setImmediate = (...args) => globalThis.__swoop_setImmediate(...args);
+      }
+      if (typeof globalThis.__swoop_clearImmediate === "function") {
+        globalThis.clearImmediate = (...args) => globalThis.__swoop_clearImmediate(...args);
+      }
+
+      // microtasks / raf / idle
+      if (typeof globalThis.__swoop_queueMicrotask === "function") {
+        globalThis.queueMicrotask = (...args) => globalThis.__swoop_queueMicrotask(...args);
+      }
+      if (typeof globalThis.__swoop_requestAnimationFrame === "function") {
+        globalThis.requestAnimationFrame = (...args) => globalThis.__swoop_requestAnimationFrame(...args);
+      }
+      if (typeof globalThis.__swoop_cancelAnimationFrame === "function") {
+        globalThis.cancelAnimationFrame = (...args) => globalThis.__swoop_cancelAnimationFrame(...args);
+      }
+      if (typeof globalThis.__swoop_requestIdleCallback === "function") {
+        globalThis.requestIdleCallback = (...args) => globalThis.__swoop_requestIdleCallback(...args);
+      }
+      if (typeof globalThis.__swoop_cancelIdleCallback === "function") {
+        globalThis.cancelIdleCallback = (...args) => globalThis.__swoop_cancelIdleCallback(...args);
+      }
+
+      // fetch
+      if (typeof globalThis.__swoop_fetch === "function") {
+        globalThis.fetch = (...args) => globalThis.__swoop_fetch(...args);
+      }
+    `,
+    context,
+    { timeout: timeoutMs }
+  );
+}
+function createModuleLoader(init) {
+  const SourceTextModule = vm4__default.default.SourceTextModule;
+  const moduleCache = /* @__PURE__ */ new Map();
+  const pluckFn = init.pluckFn ?? pluck;
+  const loadModule = async (specifier, referencingUrl) => {
+    if (init.remainingMs() <= 0)
+      throw new Error("swoop() time budget exhausted while loading modules");
+    const resolved = new URL(specifier, referencingUrl).href;
+    const cached = moduleCache.get(resolved);
+    if (cached) return cached;
+    if (!SourceTextModule) {
+      throw new Error(
+        "Module scripts require Node `--experimental-vm-modules` (vm.SourceTextModule is unavailable)."
+      );
+    }
+    const modRes = await pluckFn(resolved, {
+      ...init.pluckInit,
+      timeout: Math.min(init.pluckInit.timeout ?? 3e4, init.remainingMs()),
+      strictContentType: false,
+      throwOnHttpError: true
+    });
+    const rawSource = await modRes.textUtf8();
+    const mod = new SourceTextModule(rawSource, {
+      context: init.context,
+      identifier: resolved,
+      initializeImportMeta: (meta) => {
+        meta.url = resolved;
+      },
+      importModuleDynamically: async (spec) => {
+        const child = await loadModule(spec, resolved);
+        await child.link(linkerFor(resolved));
+        await child.evaluate();
+        return child;
+      }
+    });
+    moduleCache.set(resolved, mod);
+    return mod;
+  };
+  const linkerFor = (referencingUrl) => async (specifier) => {
+    return await loadModule(specifier, referencingUrl);
+  };
+  return { loadModule, linkerFor };
+}
+
+// src/swoop/wait.ts
+async function waitForSettle(init) {
+  if (init.strategy === "timeout") {
+    await init.sleep(Math.max(0, init.deadlineMs - init.now()));
+    return { timedOut: init.now() >= init.deadlineMs };
+  }
+  while (init.now() < init.deadlineMs) {
+    if (init.getPendingFetches() === 0 && init.getPendingScriptLoads() === 0 && init.now() - init.getLastAsyncActivityAt() >= init.idleTimeMs) {
+      return { timedOut: false };
+    }
+    await init.sleep(init.pollIntervalMs);
+  }
+  return { timedOut: true };
+}
+
+// src/swoop/engines/vm.ts
+async function runVmEngine(args) {
+  const { entries: realmConsole, record } = createConsoleCapture();
+  const remainingMs = () => Math.max(0, args.deadline - Date.now());
+  const { window, document } = linkedom.parseHTML(args.html, { url: args.finalUrl });
+  const pageUrl = new URL(args.finalUrl);
+  const { baseForResolve, baseEl } = computeBaseForResolve(args.finalUrl, document);
+  patchDocumentBaseURI(document, baseForResolve);
+  patchBaseElementHref(baseEl, baseForResolve);
+  const documentBaseUriForDom = baseForResolve.href;
+  try {
+    document.readyState ??= "loading";
+  } catch {
+  }
+  const domWindow = window;
+  const globalObj = Object.create(domWindow);
+  globalObj.window = globalObj;
+  globalObj.self = globalObj;
+  globalObj.globalThis = globalObj;
+  globalObj.document = document;
+  try {
+    Object.defineProperty(document, "defaultView", { value: globalObj, configurable: true });
+  } catch {
+  }
+  const { location: locationShim, history: historyShim } = createNavigationShims({
+    pageUrl,
+    onNavigate: (href) => {
+      if (!args.options.debugProbes) return;
+      try {
+        globalObj.__swoopStats.nav.lastHref = String(href);
+      } catch {
+      }
+    },
+    onPopState: (state) => {
+      if (args.options.debugProbes) {
+        try {
+          globalObj.__swoopStats.nav.pushState++;
+        } catch {
+        }
+      }
+      try {
+        globalObj.dispatchEvent?.(new (globalObj.PopStateEvent ?? Event)("popstate", { state }));
+      } catch {
+      }
+    }
+  });
+  try {
+    Object.defineProperty(document, "location", {
+      configurable: true,
+      get: () => locationShim,
+      set: (v) => {
+        try {
+          locationShim.href = String(v);
+        } catch {
+        }
+      }
+    });
+  } catch {
+  }
+  globalObj.location = locationShim;
+  globalObj.history = historyShim;
+  installBrowserShims({ globalObj, domWindow, document, documentBaseUriForDom });
+  installCookieJar(document);
+  const asyncEnv = installAsyncEnv({ globalObj, debugProbes: args.options.debugProbes });
+  const noteAsyncActivity = asyncEnv.noteAsyncActivity;
+  const hostSetTimeout = asyncEnv.hostSetTimeout;
+  const hostClearTimeout = asyncEnv.hostClearTimeout;
+  if (args.options.debugProbes) {
+    try {
+      installDebugProbes({ globalObj, hostSetTimeout });
+    } catch {
+    }
+  }
+  const fetchShim = installFetchShim({
+    globalObj,
+    hostFetch: args.hostFetch,
+    baseForResolveHref: baseForResolve.href,
+    remainingMs,
+    hostSetTimeout,
+    hostClearTimeout,
+    noteAsyncActivity,
+    debugFetch: args.options.debugFetch,
+    recordDebug: (a) => record("debug", a),
+    queueMicrotask: (cb) => globalObj.__swoop_queueMicrotask(cb)
+  });
+  const addEventListener = domWindow.addEventListener?.bind(domWindow);
+  const removeEventListener = domWindow.removeEventListener?.bind(domWindow);
+  const dispatchEvent = domWindow.dispatchEvent?.bind(domWindow);
+  if (typeof addEventListener === "function") globalObj.addEventListener = addEventListener;
+  if (typeof removeEventListener === "function")
+    globalObj.removeEventListener = removeEventListener;
+  if (typeof dispatchEvent === "function") globalObj.dispatchEvent = dispatchEvent;
+  globalObj.console = {
+    debug: (...a) => record("debug", a),
+    info: (...a) => record("info", a),
+    warn: (...a) => record("warn", a),
+    error: (...a) => record("error", a),
+    log: (...a) => record("log", a)
+  };
+  if (args.options.forwardConsole) {
+    for (const level of ["debug", "info", "warn", "error", "log"]) {
+      const original = console[level]?.bind(console);
+      if (typeof original === "function") {
+        const wrapped = globalObj.console[level];
+        globalObj.console[level] = (...a) => {
+          wrapped(...a);
+          original(...a);
+        };
+      }
+    }
+  }
+  try {
+    globalObj.onerror = (message, source, line, col, error) => {
+      record("error", ["[window.onerror]", message, source, line, col, error]);
+    };
+  } catch {
+  }
+  try {
+    globalObj.onunhandledrejection = (event) => {
+      record("error", ["[unhandledrejection]", event?.reason]);
+    };
+  } catch {
+  }
+  try {
+    globalObj.addEventListener?.("error", (event) => {
+      record("error", [
+        "[error event]",
+        event?.message,
+        event?.filename,
+        event?.lineno,
+        event?.colno,
+        event?.error instanceof Error ? `${event.error.name}: ${event.error.message}
+${event.error.stack ?? ""}`.trim() : event?.error
+      ]);
+    });
+  } catch {
+  }
+  if (args.options.permissiveShims) {
+    installPermissiveShims(globalObj);
+    if (!globalObj.XMLHttpRequest) {
+      installXMLHttpRequest({
+        globalObj,
+        resolveUrl: (u) => {
+          try {
+            return new URL(u, baseForResolve.href).href;
+          } catch {
+            return u;
+          }
+        },
+        remainingMs,
+        hostSetTimeout,
+        hostClearTimeout,
+        fetch: args.hostFetch
+      });
+    }
+  }
+  const context = vm4__default.default.createContext(globalObj, { name: "magpie-html/swoop" });
+  defineWindowInContext(context);
+  ensureRealmFunctionIntrinsic(context);
+  installRealmWrappers(context);
+  const { loadModule, linkerFor } = createModuleLoader({
+    context,
+    remainingMs,
+    pluckInit: args.options.pluck
+  });
+  const scriptLoader = createScriptLoader({
+    globalObj,
+    pageUrlHref: pageUrl.href,
+    baseForResolveHref: baseForResolve.href,
+    remainingMs,
+    hostSetTimeout,
+    totalBudgetMs: args.totalBudgetMs,
+    maxDebugEvents: args.options.debugProbes ? 80 : 0,
+    debug: (a) => {
+      if (!args.options.debugProbes) return;
+      record("debug", a);
+    },
+    onError: (resolvedSrc, err) => {
+      const e = err;
+      record("error", ["[swoop] script load failed", resolvedSrc, e?.message || String(e)]);
+    },
+    noteAsyncActivity,
+    fetchText: async (url) => {
+      const sres = await pluck(url, {
+        ...args.options.pluck,
+        timeout: Math.min(args.options.pluck.timeout ?? 3e4, remainingMs()),
+        strictContentType: false,
+        throwOnHttpError: true
+      });
+      return await sres.textUtf8();
+    },
+    runClassicScript: (code, filename) => {
+      const script = new vm4__default.default.Script(code, { filename });
+      script.runInContext(context, { timeout: args.totalBudgetMs });
+    },
+    runModuleScript: async (resolvedSrc, parentUrlForResolve) => {
+      const mod = await loadModule(resolvedSrc, parentUrlForResolve);
+      await mod.link(linkerFor(resolvedSrc));
+      await mod.evaluate();
+    }
+  });
+  scriptLoader.install();
+  const getPendingScriptLoads = () => scriptLoader.getPendingScriptLoads();
+  const engineErrors = [];
+  const classicScripts = args.scripts.filter((s) => !s.isModule);
+  const moduleScriptsInOrder = args.scripts.filter((s) => s.isModule);
+  for (const s of [...classicScripts, ...moduleScriptsInOrder]) {
+    if (remainingMs() <= 0) {
+      engineErrors.push({
+        stage: "wait",
+        message: `Hard time budget (${args.totalBudgetMs}ms) exceeded while executing scripts; returning snapshot.`
+      });
+      break;
+    }
+    const scriptUrl = s.kind === "external" ? s.url : `${args.finalUrl}#inline`;
+    try {
+      if (s.isModule) {
+        const modCode = s.code;
+        const SourceTextModule = vm4__default.default.SourceTextModule;
+        if (!SourceTextModule) {
+          throw new Error(
+            "Module scripts require Node `--experimental-vm-modules` (vm.SourceTextModule is unavailable)."
+          );
+        }
+        const mod = new SourceTextModule(modCode, {
+          context,
+          identifier: scriptUrl,
+          initializeImportMeta: (meta) => {
+            meta.url = scriptUrl;
+          },
+          importModuleDynamically: async (spec) => {
+            const child = await loadModule(spec, scriptUrl);
+            await child.link(linkerFor(scriptUrl));
+            await child.evaluate();
+            return child;
+          }
+        });
+        const timeoutP = (label) => sleep(remainingMs()).then(() => {
+          throw new Error(`swoop() time budget exhausted during ${label}`);
+        });
+        const linkP = mod.link(linkerFor(scriptUrl));
+        try {
+          await Promise.race([linkP, timeoutP("module link")]);
+        } catch (e) {
+          void linkP.catch?.(() => {
+          });
+          throw e;
+        }
+        const evalP = mod.evaluate();
+        try {
+          await Promise.race([evalP, timeoutP("module evaluate")]);
+        } catch (e) {
+          void evalP.catch?.(() => {
+          });
+          throw e;
+        }
+      } else {
+        const script = new vm4__default.default.Script(s.code, { filename: scriptUrl });
+        script.runInContext(context, { timeout: args.totalBudgetMs });
+      }
+    } catch (err) {
+      const e = err;
+      engineErrors.push({
+        stage: "script",
+        scriptUrl: s.kind === "external" ? s.url : void 0,
+        message: e.message || String(e),
+        stack: e.stack
+      });
+    }
+  }
+  try {
+    synthesizeLifecycle(context, Math.min(50, remainingMs()));
+  } catch {
+  }
+  const settle = await waitForSettle({
+    strategy: args.options.waitStrategy === "timeout" || typeof globalObj.fetch !== "function" ? "timeout" : "networkidle",
+    deadlineMs: args.deadline,
+    idleTimeMs: args.options.idleTime,
+    pollIntervalMs: args.options.pollInterval,
+    sleep,
+    now: () => Date.now(),
+    getPendingFetches: () => fetchShim.getPendingFetches(),
+    getPendingScriptLoads,
+    getLastAsyncActivityAt: () => asyncEnv.getLastAsyncActivityAt()
+  });
+  if (settle.timedOut && args.options.waitStrategy === "networkidle" && typeof globalObj.fetch === "function") {
+    engineErrors.push({
+      stage: "wait",
+      message: `Hard time budget (${args.totalBudgetMs}ms) exceeded waiting for network idle; returning snapshot.`
+    });
+  }
+  const snapshot = document.documentElement?.outerHTML ?? "";
+  if (args.options.debugProbes) {
+    try {
+      emitDebugProbes(globalObj, (a) => record("debug", a));
+    } catch {
+    }
+  }
+  asyncEnv.cleanup();
+  return { snapshot, consoleEntries: realmConsole, engineErrors };
+}
+
+// src/swoop/scripts/discover.ts
+function isExecutableScriptType(type) {
+  if (!type) return true;
+  const t = type.trim().toLowerCase();
+  if (t === "") return true;
+  if (t === "text/javascript") return true;
+  if (t === "application/javascript") return true;
+  if (t === "application/ecmascript") return true;
+  if (t === "text/ecmascript") return true;
+  return false;
+}
+function isModuleScript(type) {
+  return (type ?? "").trim().toLowerCase() === "module";
+}
+async function discoverAndFetchScripts(html, finalUrl, init, pluckFn = pluck) {
+  const errors = [];
+  const scripts = [];
+  if (!init.executeScripts) return { scripts, errors };
+  const doc = parseHTML(html, finalUrl);
+  const baseHref = doc.querySelector("base[href]")?.getAttribute("href") ?? null;
+  const baseUrl = baseHref ? new URL(baseHref, finalUrl).href : finalUrl;
+  const scriptEls = Array.from(doc.querySelectorAll("script"));
+  for (const el of scriptEls.slice(0, init.maxScripts)) {
+    const type = el.getAttribute("type");
+    const isModule = isModuleScript(type);
+    if (!isModule && !isExecutableScriptType(type)) continue;
+    const src = el.getAttribute("src");
+    if (src) {
+      const scriptUrl = new URL(src, baseUrl).href;
+      try {
+        const res = await pluckFn(scriptUrl, {
+          ...init.pluck,
+          strictContentType: false,
+          throwOnHttpError: true
+        });
+        const code2 = await res.textUtf8();
+        scripts.push({ kind: "external", url: scriptUrl, code: code2, isModule });
+      } catch (err) {
+        const e = err;
+        errors.push({
+          stage: "script",
+          scriptUrl,
+          message: `Failed to fetch external script: ${e.message || String(e)}`,
+          stack: e.stack
+        });
+      }
+      continue;
+    }
+    const code = el.textContent ?? "";
+    if (code.trim().length === 0) continue;
+    scripts.push({ kind: "inline", code, isModule });
+  }
+  return { scripts, errors };
+}
+
+// src/swoop/swoop.ts
+var HOST_FETCH = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+async function swoop(url, init) {
+  const start = Date.now();
+  const options = normalizeInit(init);
+  const totalBudgetMs = Math.min(options.timeout, 5e3);
+  const deadline = start + totalBudgetMs;
+  if (!isNodeRuntime()) {
+    throw new SwoopEnvironmentError("swoop() is currently Node.js-only.");
+  }
+  const res = await pluck(String(url), {
+    ...options.pluck,
+    timeout: Math.min(options.pluck.timeout ?? 3e4, totalBudgetMs),
+    strictContentType: false,
+    throwOnHttpError: true
+  });
+  const html = await res.textUtf8();
+  const finalUrl = res.finalUrl;
+  const { scripts, errors: preErrors } = await discoverAndFetchScripts(html, finalUrl, options);
+  let snapshot = "";
+  let consoleEntries = [];
+  let engineErrors = [];
+  const r = await runVmEngine({
+    finalUrl,
+    html,
+    scripts,
+    options,
+    totalBudgetMs,
+    deadline,
+    hostFetch: HOST_FETCH
+  });
+  snapshot = r.snapshot;
+  consoleEntries = r.consoleEntries;
+  engineErrors = r.engineErrors;
+  const end = Date.now();
+  return {
+    url: finalUrl,
+    html: snapshot,
+    console: consoleEntries,
+    errors: [...preErrors, ...engineErrors],
+    timing: {
+      start,
+      end,
+      duration: end - start
+    }
+  };
+}
 /**
  * Enhanced fetch types for web scraping.
  *
@@ -5154,6 +6917,11 @@ exports.PluckNetworkError = PluckNetworkError;
 exports.PluckRedirectError = PluckRedirectError;
 exports.PluckSizeError = PluckSizeError;
 exports.PluckTimeoutError = PluckTimeoutError;
+exports.SwoopEnvironmentError = SwoopEnvironmentError;
+exports.SwoopError = SwoopError;
+exports.SwoopExecutionError = SwoopExecutionError;
+exports.SwoopSecurityError = SwoopSecurityError;
+exports.SwoopTimeoutError = SwoopTimeoutError;
 exports.assessContentQuality = assessContentQuality;
 exports.calculateReadingTime = calculateReadingTime;
 exports.countWords = countWords;
@@ -5193,5 +6961,6 @@ exports.isRSS = isRSS;
 exports.parseFeed = parseFeed;
 exports.parseHTML = parseHTML;
 exports.pluck = pluck;
+exports.swoop = swoop;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map