@duckmind/dm-windows-x64 0.62.3 → 0.63.0

package/extensions/greedysearch-dm/extractors/common.mjs

@@ -1,794 +0,0 @@
-import { randomInt } from "node:crypto";
-import { spawn } from "node:child_process";
-import { nodeRuntimeCommand } from "../src/utils/node-runtime.mjs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-const __dir = dirname(fileURLToPath(import.meta.url));
-const CDP = join(__dir, "..", "bin", "cdp.mjs");
-const VALID_CDP_COMMANDS = new Set([
-  "list",
-  "snap",
-  "eval",
-  "shot",
-  "html",
-  "nav",
-  "net",
-  "click",
-  "clickxy",
-  "type",
-  "loadall",
-  "evalraw",
-  "browse",
-  "stop",
-  "--tab"
-]);
-function cdpSafeArgv(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    throw new Error("cdp: args must be a non-empty array");
-  }
-  if (args[0] === "test")
-    return args.map((v, i) => validateArg(v, i));
-  if (!VALID_CDP_COMMANDS.has(args[0])) {
-    throw new Error(`cdp: unknown subcommand '${args[0]}'`);
-  }
-  return args.map((v, i) => validateArg(v, i));
-}
-function validateArg(value, index) {
-  if (typeof value !== "string") {
-    throw new Error(`cdp: argv[${index}] must be a string (got ${typeof value})`);
-  }
-  if (value.includes("\x00")) {
-    throw new Error(`cdp: argv[${index}] contains a null byte`);
-  }
-  return value;
-}
-export function cdp(args, timeoutMs = 30000) {
-  return cdpWithInput(args, null, timeoutMs);
-}
-export function cdpWithInput(args, input = null, timeoutMs = 30000) {
-  const safeArgs = cdpSafeArgv(args);
-  return new Promise((resolve, reject) => {
-    const proc = spawn(nodeRuntimeCommand(), [CDP, ...safeArgs], {
-      stdio: [input == null ? "ignore" : "pipe", "pipe", "pipe"]
-    });
-    if (input != null) {
-      proc.stdin.write(input);
-      proc.stdin.end();
-    }
-    let out = "";
-    let err = "";
-    proc.stdout.on("data", (d) => out += d);
-    proc.stderr.on("data", (d) => err += d);
-    const timer = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`cdp timeout: ${args[0]}`));
-    }, timeoutMs);
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      if (code === 0)
-        resolve(out.trim());
-      else
-        reject(new Error(err.trim() || `cdp exit ${code}`));
-    });
-  });
-}
-export function verifyInputText(actual, expected) {
-  const normalize = (value) => String(value ?? "").replace(/\s+/g, " ").trim();
-  const actualNormalized = normalize(actual);
-  const expectedNormalized = normalize(expected);
-  if (!expectedNormalized)
-    return false;
-  if (actualNormalized.length < Math.ceil(expectedNormalized.length * 0.8)) {
-    return false;
-  }
-  const sampleLength = Math.min(40, expectedNormalized.length);
-  return actualNormalized.includes(expectedNormalized.slice(0, sampleLength)) && actualNormalized.includes(expectedNormalized.slice(-sampleLength));
-}
-export async function getOrOpenTab(tabPrefix) {
-  if (tabPrefix)
-    return tabPrefix;
-  const list = await cdp(["list"]);
-  const anchor = list.split(`
-`)[0]?.slice(0, 8);
-  if (!anchor)
-    throw new Error("No Chrome tabs found. Is Chrome running with --remote-debugging-port=9222?");
-  const raw = await cdp([
-    "evalraw",
-    anchor,
-    "Target.createTarget",
-    '{"url":"about:blank"}'
-  ]);
-  let createdTarget;
-  try {
-    createdTarget = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Target.createTarget returned invalid JSON: ${error.message}`);
-  }
-  const { targetId } = createdTarget;
-  if (!targetId) {
-    throw new Error("Target.createTarget did not return a targetId");
-  }
-  await cdp(["list"]);
-  const tid = targetId.slice(0, 8);
-  try {
-    await injectHeadlessStealth(tid);
-  } catch (e) {
-    process.stderr.write(`[getOrOpenTab] stealth injection failed: ${e.message}
-`);
-  }
-  return tid;
-}
-export async function injectClipboardInterceptor(tab, globalVar) {
-  const code = `
-    (() => {
-      window.${globalVar} = null;
-      const _clipboard = navigator.clipboard;
-      if (!_clipboard) return;
-      const _origWriteText = typeof _clipboard.writeText === 'function'
-        ? _clipboard.writeText.bind(_clipboard)
-        : null;
-      const _origWrite = typeof _clipboard.write === 'function'
-        ? _clipboard.write.bind(_clipboard)
-        : null;
-
-      _clipboard.writeText = function(text) {
-        window.${globalVar} = String(text ?? '');
-        if (!_origWriteText) return Promise.resolve();
-        // The OS/browser clipboard write may be denied in automated Chrome or
-        // when the tab is not focused. We only need the captured text; returning
-        // a resolved promise prevents the page from surfacing a misleading
-        // "failed to copy" toast after our interceptor already succeeded.
-        return Promise.resolve(_origWriteText(text)).catch(() => undefined);
-      };
-
-      _clipboard.write = async function(items) {
-        try {
-          for (const item of items || []) {
-            if (item.types && item.types.includes('text/plain')) {
-              const blob = await item.getType('text/plain');
-              window.${globalVar} = await blob.text();
-              break;
-            }
-          }
-        } catch(e) {}
-        if (!_origWrite) return undefined;
-        try { return await _origWrite(items); }
-        catch (_) { return undefined; }
-      };
-    })();
-  `;
-  await cdp(["eval", tab, code]);
-}
-export async function clickCopyAndAwaitClipboard(tab, clickExpr, globalVar, options = {}) {
-  const { timeoutMs = 2600 } = options;
-  const retryClick = options.retryClick != null ? options.retryClick : Math.floor(timeoutMs * 0.4);
-  const code = String.raw`
-	new Promise((resolve) => {
-		const _deadline = Date.now() + ${timeoutMs};
-		const _retryAt = Date.now() + ${retryClick};
-		let _retried = false;
-		function _click() { try { ${clickExpr}; } catch(_) {} }
-		function _poll() {
-			const val = window.${globalVar};
-			if (val) { resolve(val); return; }
-			if (!_retried && Date.now() >= _retryAt) {
-				_retried = true;
-				_click();
-			}
-			if (Date.now() < _deadline) { setTimeout(_poll, 100); }
-			else { resolve(window.${globalVar} || ''); }
-		}
-		_click();
-		_poll();
-	})
-	`;
-  return await cdp(["eval", tab, code], timeoutMs + 5000).catch(() => "");
-}
-export async function injectHeadlessStealth(tab) {
-  const code = `
-(function() {
-  // ── Runtime.enable / CDP detection masking ──────────────
-  try { delete window.__REBROWSER_RUNTIME_ENABLE; } catch(_) {}
-  try { delete window.__REBROWSER_DEVTOOLS; } catch(_) {}
-  try { delete window.__nightmare; } catch(_) {}
-  try { delete window.__phantom; } catch(_) {}
-  try { delete window.callPhantom; } catch(_) {}
-  try { delete window._phantom; } catch(_) {}
-  try { delete window.Buffer; } catch(_) {}
-
-  // Real Chrome without automation should not expose navigator.webdriver at all.
-  // A literal false or an own-property getter returning undefined is itself a
-  // common stealth tell; remove both instance and prototype properties when the
-  // descriptor is configurable (as it is with --disable-blink-features).
-  try { delete navigator.webdriver; } catch(_) {}
-  try { delete Navigator.prototype.webdriver; } catch(_) {}
-  Object.defineProperty(navigator, 'vendor', { get: () => 'Google Inc.', configurable: true });
-  Object.defineProperty(navigator, 'platform', { get: () => 'Win32', configurable: true });
-  Object.defineProperty(navigator, 'maxTouchPoints', { get: () => 0, configurable: true });
-  Object.defineProperty(navigator, 'pdfViewerEnabled', { get: () => true, configurable: true });
-  Object.defineProperty(navigator, 'productSub', { get: () => '20030107', configurable: true });
-  Object.defineProperty(navigator, 'product', { get: () => 'Gecko', configurable: true });
-  var __greedyMimeTypes = null;
-  function __makeMimeTypes() {
-    var pdf = { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null };
-    var textPdf = { type: 'text/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null };
-    try { Object.setPrototypeOf(pdf, MimeType.prototype); } catch(_) {}
-    try { Object.setPrototypeOf(textPdf, MimeType.prototype); } catch(_) {}
-    var m = [pdf, textPdf];
-    try { Object.setPrototypeOf(m, MimeTypeArray.prototype); } catch(_) {}
-    m.item = function item(i) { return this[i] || null; };
-    m.namedItem = function namedItem(name) { return Array.prototype.find.call(this, function(x) { return x && x.type === name; }) || null; };
-    return m;
-  }
-  Object.defineProperty(navigator, 'plugins', {
-    get: () => {
-      __greedyMimeTypes = __greedyMimeTypes || __makeMimeTypes();
-      var plugin0 = { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' };
-      var plugin1 = { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' };
-      var plugin2 = { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' };
-      try { Object.setPrototypeOf(plugin0, Plugin.prototype); } catch(_) {}
-      try { Object.setPrototypeOf(plugin1, Plugin.prototype); } catch(_) {}
-      try { Object.setPrototypeOf(plugin2, Plugin.prototype); } catch(_) {}
-      var p = [plugin0, plugin1, plugin2];
-      p.item = function item(i) { return this[i] || null; };
-      p.namedItem = function namedItem(name) { return Array.prototype.find.call(this, function(x) { return x && x.name === name; }) || null; };
-      p.refresh = function refresh() {};
-      try { Object.setPrototypeOf(p, PluginArray.prototype); } catch(_) {}
-      try {
-        __greedyMimeTypes[0].enabledPlugin = p[0];
-        __greedyMimeTypes[1].enabledPlugin = p[0];
-      } catch(_) {}
-      return p;
-    },
-    configurable: true,
-  });
-  Object.defineProperty(navigator, 'mimeTypes', {
-    get: () => {
-      __greedyMimeTypes = __greedyMimeTypes || __makeMimeTypes();
-      return __greedyMimeTypes;
-    },
-    configurable: true,
-  });
-  Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'], configurable: true });
-  try {
-    Object.defineProperty(navigator, 'connection', { get: () => ({ effectiveType: '4g', rtt: 50, downlink: 10, downlinkMax: Infinity, saveData: false }), configurable: true });
-  } catch(_) {}
-  if (!navigator.mediaDevices) {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      get: () => ({
-        enumerateDevices: () => Promise.resolve([
-          { deviceId: 'default', kind: 'audioinput', label: '', groupId: 'default' },
-          { deviceId: 'default', kind: 'audiooutput', label: '', groupId: 'default' },
-          { deviceId: '', kind: 'videoinput', label: '', groupId: '' },
-        ]),
-        getUserMedia: () => Promise.reject(new DOMException('NotAllowedError')),
-        getDisplayMedia: () => Promise.reject(new DOMException('NotAllowedError')),
-      }),
-      configurable: true,
-    });
-  }
-  // ── Missing platform APIs (headless often lacks these) ─
-  try {
-    if (!navigator.share) {
-      navigator.share = function() { return Promise.reject(new Error('NotAllowedError')); };
-    }
-  } catch(_) {}
-  try {
-    if (!navigator.contentIndex) {
-      Object.defineProperty(navigator, 'contentIndex', { get: () => ({ add: function() {}, delete: function() {}, getAll: function() { return Promise.resolve([]); } }), configurable: true });
-    }
-  } catch(_) {}
-
-  if (!window.chrome) {
-    window.chrome = {
-      app: { isInstalled: false, InstallState: {}, RunningState: {} },
-      runtime: {
-        OnInstalledReason: {}, OnRestartRequiredReason: {}, PlatformArch: {}, PlatformNaclArch: {}, PlatformOs: {}, RequestUpdateCheckStatus: {},
-        connect: () => ({}), sendMessage: () => {}, onMessage: { addListener: () => {} }
-      },
-      loadTimes: function() { return { requestTime: 0, startLoadTime: Date.now() - 5000, commitLoadTime: Date.now() - 3000, finishDocumentLoadTime: Date.now() - 2000, finishLoadTime: Date.now() - 1000, firstPaintTime: Date.now() - 800, navigationType: 'Other', wasFetchedViaSpdy: true, wasNpnNegotiated: true, npnNegotiatedProtocol: 'h2', wasAlternateProtocolAvailable: false, connectionInfo: 'http/2' }; },
-      csi: function() { var t = Date.now(); return { onloadT: t - 2000, startE: t - 5000, pageT: 'back', tran: 2 }; },
-    };
-  }
-  var __greedyNativeFns = [];
-  function __markNative(fn) { try { __greedyNativeFns.push(fn); } catch(_) {} return fn; }
-
-  var origQuery = navigator.permissions?.query;
-  if (origQuery) {
-    navigator.permissions.query = __markNative(function query(params) {
-      if (params && params.name === 'notifications') return Promise.resolve({ state: Notification.permission || 'default', onchange: null });
-      return origQuery.apply(this, arguments);
-    });
-  }
-  try {
-    var getParam = WebGLRenderingContext.prototype.getParameter;
-    WebGLRenderingContext.prototype.getParameter = __markNative(function getParameter(p) {
-      if (p === 37445) return 'Intel Inc.';
-      if (p === 37446) return 'Intel Iris OpenGL Engine';
-      return getParam.call(this, p);
-    });
-  } catch(_) {}
-  // ── WebGL readPixels noise ──────────────────────────
-  // CreepJS and other fingerprinters draw content with WebGL and read back the
-  // rendered pixels. Adding subtle noise breaks rendering-based fingerprinting.
-  try {
-    var origReadPixels = WebGLRenderingContext.prototype.readPixels;
-    WebGLRenderingContext.prototype.readPixels = __markNative(function readPixels(x, y, width, height, format, type, pixels) {
-      var result = origReadPixels.call(this, x, y, width, height, format, type, pixels);
-      if (pixels && pixels.length > 0) {
-        pixels[0] ^= 1;
-      }
-      return result;
-    });
-  } catch(_) {}
-  Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8, configurable: true });
-  Object.defineProperty(navigator, 'deviceMemory', { get: () => 8, configurable: true });
-
-  // ── Canvas fingerprint noise ─────────────────────────
-  // Headless rendering engines produce slightly different canvas output
-  // than headed Chrome. Subtle noise breaks hash-based fingerprinting.
-  try {
-    var __canvasNoise = ((Date.now() & 0xFF) | 1);
-    var origFill = CanvasRenderingContext2D.prototype.fillText;
-    CanvasRenderingContext2D.prototype.fillText = __markNative(function fillText() {
-      this.globalAlpha = 0.9995;
-      return origFill.apply(this, arguments);
-    });
-  } catch(_) {}
-  try {
-    var origStroke = CanvasRenderingContext2D.prototype.strokeText;
-    CanvasRenderingContext2D.prototype.strokeText = __markNative(function strokeText() {
-      this.globalAlpha = 0.9995;
-      return origStroke.apply(this, arguments);
-    });
-  } catch(_) {}
-  try {
-    var origToDataURL = HTMLCanvasElement.prototype.toDataURL;
-    HTMLCanvasElement.prototype.toDataURL = __markNative(function toDataURL() {
-      var ctx = this.getContext('2d');
-      if (ctx) {
-        // Spread noise across canvas to break hash-based fingerprinting.
-        // Uses a deterministic pattern so it's consistent per page load
-        // but varies between sessions.
-        var w = this.width, h = this.height;
-        if (w > 0 && h > 0) {
-          var imgData = ctx.getImageData(0, 0, Math.min(w, 4), Math.min(h, 4));
-          if (imgData && imgData.data) {
-            for (var __i = 0; __i < imgData.data.length; __i += 4) {
-              imgData.data[__i] ^= (__canvasNoise + __i) & 0xFF;
-            }
-            ctx.putImageData(imgData, 0, 0);
-          }
-        }
-      }
-      return origToDataURL.apply(this, arguments);
-    });
-  } catch(_) {}
-
-  // ── AudioContext fingerprint noise ────────────────────
-  // Headless Chrome's AudioContext produces slightly different output.
-  // Subtle noise breaks audio-based fingerprinting.
-  try {
-    var __audioSeed = ((Date.now() & 0x1F) | 1);
-    var origGetChannelData = AudioBuffer.prototype.getChannelData;
-    AudioBuffer.prototype.getChannelData = __markNative(function getChannelData(channel) {
-      var data = origGetChannelData.call(this, channel);
-      for (var __i = 0; __i < data.length; __i += 64) {
-        data[__i] *= 0.99999;
-      }
-      return data;
-    });
-  } catch(_) {}
-
-  // ── window outer dimensions ──────────────────────────
-  // outerWidth/Height = 0 in headless — a well-known bot signal.
-  // Mirror innerWidth/Height (set by --window-size flag) so the ratio is sane.
-  try {
-    if (!window.outerWidth)  Object.defineProperty(window, 'outerWidth',  { get: () => window.innerWidth  || 1920, configurable: true });
-    if (!window.outerHeight) Object.defineProperty(window, 'outerHeight', { get: () => window.innerHeight || 1080, configurable: true });
-  } catch(_) {}
-
-  // ── screen properties ─────────────────────────────────
-  // Headless Chrome often reports an 800x600 screen even when the viewport is
-  // 1920x1080. Keep screen metrics internally consistent with our launch flags.
-  try {
-    Object.defineProperty(screen, 'width', { get: () => 1920, configurable: true });
-    Object.defineProperty(screen, 'height', { get: () => 1080, configurable: true });
-    Object.defineProperty(screen, 'availWidth', { get: () => 1920, configurable: true });
-    Object.defineProperty(screen, 'availHeight', { get: () => 1040, configurable: true });
-    Object.defineProperty(screen, 'colorDepth', { get: () => 24, configurable: true });
-    Object.defineProperty(screen, 'pixelDepth', { get: () => 24, configurable: true });
-  } catch(_) {}
-
-  // ── navigator.userAgentData (UA Client Hints) ─────────
-  // Derive version from the UA string already set by --user-agent flag so the
-  // two APIs are always consistent. Removes any "HeadlessChrome" brand entry.
-  try {
-    var _uaMajor = (navigator.userAgent.match(new RegExp('Chrome/([0-9]+)')) || [])[1] || '136';
-    var _uaFull  = (navigator.userAgent.match(new RegExp('Chrome/([0-9.]+)')) || [])[1] || (_uaMajor + '.0.0.0');
-    var _brands  = [
-      { brand: 'Not)A;Brand',  version: '99' },
-      { brand: 'Google Chrome', version: _uaMajor },
-      { brand: 'Chromium',      version: _uaMajor },
-    ];
-    Object.defineProperty(navigator, 'userAgentData', {
-      get: function() {
-        return {
-          brands: _brands, mobile: false, platform: 'Windows',
-          getHighEntropyValues: function() {
-            return Promise.resolve({
-              architecture: 'x86', bitness: '64',
-              brands: _brands,
-              fullVersionList: [
-                { brand: 'Not)A;Brand',   version: '99.0.0.0' },
-                { brand: 'Google Chrome', version: _uaFull },
-                { brand: 'Chromium',      version: _uaFull },
-              ],
-              mobile: false, model: '', platform: 'Windows',
-              platformVersion: '15.0.0', uaFullVersion: _uaFull, wow64: false,
-            });
-          },
-          toJSON: function() { return { brands: _brands, mobile: false, platform: 'Windows' }; },
-        };
-      },
-      configurable: true,
-    });
-  } catch(_) {}
-
-  // ── CDP Runtime serialization guard ──────────────────
-  // Sites detect CDP by putting a getter on Error.prototype.stack
-  // and checking if console.log triggers it (only happens when
-  // Runtime domain is enabled). We monkey-patch console methods to
-  // strip custom getters from arguments before they reach CDP.
-  try {
-    var _origLog = console.log, _origError = console.error,
-        _origWarn = console.warn, _origDebug = console.debug,
-        _origInfo = console.info;
-    var _safeArg = function(a) {
-      if (a instanceof Error) {
-        try { return new Error(a.message); } catch(_) { return a; }
-      }
-      return a;
-    };
-    console.log = __markNative(function log() { return _origLog.apply(console, Array.prototype.map.call(arguments, _safeArg)); });
-    console.error = __markNative(function error() { return _origError.apply(console, Array.prototype.map.call(arguments, _safeArg)); });
-    console.warn = __markNative(function warn() { return _origWarn.apply(console, Array.prototype.map.call(arguments, _safeArg)); });
-    console.debug = __markNative(function debug() { return _origDebug.apply(console, Array.prototype.map.call(arguments, _safeArg)); });
-    console.info = __markNative(function info() { return _origInfo.apply(console, Array.prototype.map.call(arguments, _safeArg)); });
-  } catch(_) {}
-
-  // ── Native function masking ──────────────────────────
-  // Patched APIs should not stringify as user-defined stealth code.
-  try {
-    var __nativeToString = Function.prototype.toString;
-    Function.prototype.toString = function toString() {
-      if (__greedyNativeFns.indexOf(this) !== -1) {
-        var name = this.name || '';
-        return 'function ' + name + '() { [native code] }';
-      }
-      return __nativeToString.call(this);
-    };
-  } catch(_) {}
-})();
-`;
-  await cdp([
-    "evalraw",
-    tab,
-    "Page.addScriptToEvaluateOnNewDocument",
-    JSON.stringify({ source: code })
-  ]);
-}
-export function parseSourcesFromMarkdown(text) {
-  if (!text)
-    return [];
-  const results = [];
-  let idx = 0;
-  while (idx < text.length && results.length < 10) {
-    const openBracket = text.indexOf("[", idx);
-    if (openBracket === -1)
-      break;
-    const closeBracket = text.indexOf("](", openBracket);
-    if (closeBracket === -1)
-      break;
-    const openParen = closeBracket + 2;
-    let closeParen = -1;
-    for (let p = openParen;p < text.length; p++) {
-      const ch = text[p];
-      if (ch === ")") {
-        closeParen = p;
-        break;
-      }
-      if (/\s/.test(ch))
-        break;
-    }
-    if (closeParen !== -1) {
-      const title = text.slice(openBracket + 1, closeBracket);
-      const url = text.slice(openParen, closeParen);
-      if (/^https?:\/\//i.test(url) && title) {
-        if (!results.some((r) => r.url === url)) {
-          results.push({ title, url });
-        }
-      }
-      idx = closeParen + 1;
-    } else {
-      idx = openBracket + 1;
-    }
-  }
-  return results;
-}
-function isAllDigits(s) {
-  if (!s)
-    return false;
-  for (let k = 0;k < s.length; k++) {
-    const c = s.charCodeAt(k);
-    if (c < 48 || c > 57)
-      return false;
-  }
-  return true;
-}
-export function parseSourcesFromMarkdownRefStyle(text) {
-  if (!text)
-    return [];
-  const results = [];
-  const refMap = new Map;
-  const refRegex = /^\[(\d+)\]:\s*(https?:\/\/[^\s"]+)(?:\s+"([^"]*)")?/gm;
-  let m;
-  while ((m = refRegex.exec(text)) !== null) {
-    const num = m[1];
-    const url = m[2];
-    const title = m[3] || "";
-    refMap.set(num, { url, title });
-  }
-  let cursor = 0;
-  while (cursor < text.length) {
-    const open = text.indexOf("[", cursor);
-    if (open === -1)
-      break;
-    const close = text.indexOf("]", open + 1);
-    if (close === -1)
-      break;
-    if (text[close + 1] !== "[") {
-      cursor = open + 1;
-      continue;
-    }
-    const close2 = text.indexOf("]", close + 2);
-    if (close2 === -1)
-      break;
-    const inner = text.slice(open + 1, close);
-    const numStr = text.slice(close + 2, close2);
-    if (isAllDigits(numStr)) {
-      const ref = refMap.get(numStr);
-      if (ref && !results.some((r) => r.url === ref.url)) {
-        results.push({
-          title: inner.trim() || ref.title || "",
-          url: ref.url
-        });
-      }
-    }
-    cursor = close2 + 1;
-  }
-  return results;
-}
-export const TIMING = {
-  postNav: 800,
-  postNavSlow: 1200,
-  postClick: 300,
-  postType: 300,
-  inputPoll: 400,
-  copyPoll: 600,
-  afterVerify: 1500
-};
-export async function waitForCopyButton(tab, selector, options = {}) {
-  const { timeout = 60000, onPoll } = options;
-  if (!onPoll) {
-    const code = String.raw`
-		new Promise((resolve) => {
-			const _deadline = Date.now() + ${timeout};
-			function _poll() {
-				if (document.querySelector('${selector}')) { resolve(true); return; }
-				if (Date.now() < _deadline) { setTimeout(_poll, 150); }
-				else { resolve(false); }
-			}
-			_poll();
-		})
-		`;
-    const found = await cdp(["eval", tab, code], timeout + 5000).catch(() => "false");
-    if (found === "true")
-      return;
-    throw new Error(`Copy button ('${selector}') did not appear within ${timeout}ms`);
-  }
-  const deadline = Date.now() + timeout;
-  let tick = 0;
-  while (Date.now() < deadline) {
-    const found = await cdp([
-      "eval",
-      tab,
-      `!!document.querySelector('${selector}')`
-    ]).catch(() => "false");
-    if (found === "true")
-      return;
-    await onPoll(++tick).catch(() => null);
-    await new Promise((r) => setTimeout(r, jitter(TIMING.copyPoll)));
-  }
-  throw new Error(`Copy button ('${selector}') did not appear within ${timeout}ms`);
-}
-export function jitter(ms) {
-  const variance = ms * 0.2;
-  const offset = randomInt(-Math.floor(variance), Math.floor(variance) + 1);
-  return Math.max(50, Math.round(ms + offset));
-}
-export async function waitForStreamComplete(tab, options = {}) {
-  const {
-    timeout = 20000,
-    interval = 600,
-    stableRounds = 3,
-    selector = "document.body",
-    minLength = 0,
-    isStreamingExpr = "false"
-  } = options;
-  const code = String.raw`
-	new Promise((resolve, reject) => {
-		const _deadline = Date.now() + ${timeout};
-		const _baseInterval = ${interval};
-		const _stableRounds = ${stableRounds};
-		const _minLength = ${minLength};
-		let _lastLen = -1;
-		let _stableCount = 0;
-
-		function _jitter(ms) {
-			return Math.max(50, ms + (Math.random() * ms * 0.4 - ms * 0.2));
-		}
-
-		function _poll() {
-			try {
-				// Re-query DOM each tick — element may not exist at eval start
-				const el = ${selector};
-				const cur = el?.textContent?.length ?? 0;
-				const streaming = ${isStreamingExpr};
-				if (streaming) {
-					if (cur !== _lastLen) _lastLen = cur;
-					_stableCount = 0;
-				} else if (cur >= _minLength) {
-					if (cur === _lastLen) {
-						_stableCount++;
-						if (_stableCount >= _stableRounds) { resolve(cur); return; }
-					} else {
-						_lastLen = cur;
-						_stableCount = 0;
-					}
-				}
-				if (Date.now() < _deadline) {
-					setTimeout(_poll, _jitter(_baseInterval));
-				} else {
-					if (_lastLen >= _minLength && !streaming) { resolve(_lastLen); }
-					else { reject(new Error('Generation did not stabilise within ${timeout}ms')); }
-				}
-			} catch(e) { reject(e); }
-		}
-
-		_poll();
-	})
-	`;
-  const lenStr = await cdp(["eval", tab, code], timeout + 1e4);
-  const currentLen = parseInt(lenStr, 10) || 0;
-  if (currentLen >= minLength)
-    return currentLen;
-  throw new Error(`Generation did not stabilise within ${timeout}ms`);
-}
-export async function waitForSelector(tab, selector, timeoutMs = 15000, interval = 500) {
-  const code = String.raw`
-	new Promise((resolve) => {
-		const _deadline = Date.now() + ${timeoutMs};
-		const _baseInterval = ${interval};
-
-		function _jitter(ms) {
-			return Math.max(50, ms + (Math.random() * ms * 0.4 - ms * 0.2));
-		}
-
-		function _poll() {
-			try {
-				if (document.querySelector('${selector}')) { resolve(true); return; }
-				if (Date.now() < _deadline) { setTimeout(_poll, _jitter(_baseInterval)); }
-				else { resolve(false); }
-			} catch(_) { resolve(false); }
-		}
-
-		_poll();
-	})
-	`;
-  const result = await cdp(["eval", tab, code], timeoutMs + 5000);
-  return result === "true";
-}
-export async function prepareArgs(args) {
-  const stdinIdx = args.indexOf("--stdin");
-  if (stdinIdx === -1)
-    return args;
-  const query = await new Promise((resolve) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve(data.trim()));
-  });
-  const modified = [...args];
-  modified[stdinIdx] = query;
-  return modified;
-}
-export function parseArgs(args) {
-  const short = args.includes("--short");
-  let rest = args.filter((a) => a !== "--short");
-  const tabFlagIdx = rest.indexOf("--tab");
-  const tabPrefix = tabFlagIdx === -1 ? null : rest[tabFlagIdx + 1];
-  if (tabFlagIdx !== -1) {
-    rest = rest.filter((_, i) => i !== tabFlagIdx && i !== tabFlagIdx + 1);
-  }
-  const localeIdx = rest.indexOf("--locale");
-  const locale = localeIdx === -1 ? null : rest[localeIdx + 1];
-  if (localeIdx !== -1) {
-    rest = rest.filter((_, i) => i !== localeIdx && i !== localeIdx + 1);
-  }
-  const query = rest.join(" ");
-  return { query, tabPrefix, short, locale };
-}
-export function validateQuery(args, usage) {
-  if (!args.length || args[0] === "--help") {
-    process.stderr.write(usage);
-    process.exit(1);
-  }
-}
-export function formatAnswer(answer, short, maxLen = 300) {
-  if (!short || answer.length <= maxLen)
-    return answer;
-  const truncated = answer.slice(0, maxLen);
-  const lastSpace = truncated.lastIndexOf(" ");
-  return lastSpace > 0 ? `${truncated.slice(0, lastSpace)}…` : `${truncated}…`;
-}
-export function outputJson(data) {
-  process.stdout.write(`${JSON.stringify(data, null, 2)}
-`);
-}
-export function logStage(env, stage, startTime = null) {
-  if (!env || typeof env !== "object")
-    return;
-  const elapsed = startTime ? ` (+${Date.now() - startTime}ms)` : "";
-  env.lastStage = stage;
-  if (!Array.isArray(env.stages))
-    env.stages = [];
-  env.stages.push({ stage, at: Date.now() });
-  const engine = env.engine || "extractor";
-  console.error(`[${engine}] stage: ${stage}${elapsed}`);
-}
-export function buildEnvelope({
-  engine,
-  mode = "headless",
-  clipboardEmpty = null,
-  fallbackUsed = null,
-  blockedBy = null,
-  verificationResult = null,
-  inputReady = null,
-  durationMs = null,
-  lastStage = null,
-  stages = null
-} = {}) {
-  return {
-    engine,
-    mode,
-    clipboardEmpty,
-    fallbackUsed,
-    blockedBy,
-    verificationResult,
-    inputReady,
-    durationMs,
-    lastStage,
-    stages
-  };
-}
-export function handleError(error, envelope = null) {
-  if (envelope) {
-    const out = JSON.stringify({ _envelope: envelope, error: error.message });
-    process.stdout.write(`${out}
-`);
-  }
-  process.stderr.write(`Error: ${error.message}
-`);
-  process.exit(1);
-}