publishport-opencli 1.8.5-pp.2 → 1.8.5-pp.21

package/dist/src/browser/dom-helpers.js

@@ -1,13 +1,5 @@
-/**
- * Shared DOM operation JS generators.
- *
- * Used by both Page (daemon mode) and CDPPage (direct CDP mode)
- * to eliminate code duplication for click, type, press, wait, scroll, etc.
- */
-/** Shared element lookup JS fragment (4-strategy resolution) */
-function resolveElementJs(safeRef, selectorSet) {
-    return `
-      const ref = ${safeRef};
+function D(g,p){return`
+      const ref = ${g};
       let el = document.querySelector('[data-opencli-ref="' + ref + '"]');
       if (!el) el = document.querySelector('[data-ref="' + ref + '"]');
       if (!el && ref.match(/^[a-zA-Z#.\\[]/)) {
@@ -16,17 +8,11 @@ function resolveElementJs(safeRef, selectorSet) {
       if (!el) {
         const idx = parseInt(ref, 10);
         if (!isNaN(idx)) {
-          el = document.querySelectorAll('${selectorSet}')[idx];
+          el = document.querySelectorAll('${p}')[idx];
         }
-      }`;
-}
-/** Generate JS to click an element by ref.
- *  Returns { status, x, y, w, h } for CDP fallback when JS click fails. */
-export function clickJs(ref) {
-    const safeRef = JSON.stringify(ref);
-    return `
+      }`}export function clickJs(g){const p=JSON.stringify(g);return`
     (() => {
-      ${resolveElementJs(safeRef, 'a, button, input, select, textarea, [role="button"], [tabindex]:not([tabindex="-1"])')}
+      ${D(p,'a, button, input, select, textarea, [role="button"], [tabindex]:not([tabindex="-1"])')}
       if (!el) throw new Error('Element not found: ' + ref);
       el.scrollIntoView({ behavior: 'instant', block: 'center' });
       const rect = el.getBoundingClientRect();
@@ -39,16 +25,9 @@ export function clickJs(ref) {
         return { status: 'js_failed', x, y, w: Math.round(rect.width), h: Math.round(rect.height), error: e.message };
       }
     })()
-  `;
-}
-/** Generate JS to type text into an element by ref.
- *  Uses native setter for React compat + execCommand for contenteditable. */
-export function typeTextJs(ref, text) {
-    const safeRef = JSON.stringify(ref);
-    const safeText = JSON.stringify(text);
-    return `
+  `}export function typeTextJs(g,p){const B=JSON.stringify(g),z=JSON.stringify(p);return`
     (() => {
-      ${resolveElementJs(safeRef, 'input, textarea, [contenteditable="true"]')}
+      ${D(B,'input, textarea, [contenteditable="true"]')}
       if (!el) throw new Error('Element not found: ' + ref);
       el.focus();
       if (el.isContentEditable) {
@@ -59,7 +38,7 @@ export function typeTextJs(ref, text) {
         sel.removeAllRanges();
         sel.addRange(range);
         document.execCommand('delete', false);
-        document.execCommand('insertText', false, ${safeText});
+        document.execCommand('insertText', false, ${z});
         el.dispatchEvent(new Event('input', { bubbles: true }));
       } else {
         // Use native setter for React/framework compatibility (match element type)
@@ -68,66 +47,44 @@ export function typeTextJs(ref, text) {
           : HTMLInputElement.prototype;
         const nativeSetter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
         if (nativeSetter) {
-          nativeSetter.call(el, ${safeText});
+          nativeSetter.call(el, ${z});
         } else {
-          el.value = ${safeText};
+          el.value = ${z};
         }
         el.dispatchEvent(new Event('input', { bubbles: true }));
         el.dispatchEvent(new Event('change', { bubbles: true }));
       }
       return 'typed';
     })()
-  `;
-}
-/** Generate JS to press a keyboard key */
-export function pressKeyJs(key, modifiers = []) {
-    const hasCtrl = modifiers.includes('Ctrl') || modifiers.includes('Control');
-    const hasAlt = modifiers.includes('Alt');
-    const hasMeta = modifiers.includes('Meta');
-    const hasShift = modifiers.includes('Shift');
-    return `
+  `}export function pressKeyJs(g,p=[]){const B=p.includes("Ctrl")||p.includes("Control"),z=p.includes("Alt"),F=p.includes("Meta"),H=p.includes("Shift");return`
     (() => {
       const el = document.activeElement || document.body;
       const init = {
-        key: ${JSON.stringify(key)},
+        key: ${JSON.stringify(g)},
         bubbles: true,
-        ctrlKey: ${hasCtrl},
-        altKey: ${hasAlt},
-        metaKey: ${hasMeta},
-        shiftKey: ${hasShift},
+        ctrlKey: ${B},
+        altKey: ${z},
+        metaKey: ${F},
+        shiftKey: ${H},
       };
       el.dispatchEvent(new KeyboardEvent('keydown', init));
       el.dispatchEvent(new KeyboardEvent('keyup', init));
       return 'pressed';
     })()
-  `;
-}
-/** Generate JS to wait for text to appear in the page */
-export function waitForTextJs(text, timeoutMs) {
-    return `
+  `}export function waitForTextJs(g,p){return`
     new Promise((resolve, reject) => {
-      const deadline = Date.now() + ${timeoutMs};
+      const deadline = Date.now() + ${p};
       const check = () => {
-        if (document.body.innerText.includes(${JSON.stringify(text)})) return resolve('found');
-        if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(text)}));
+        if (document.body.innerText.includes(${JSON.stringify(g)})) return resolve('found');
+        if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(g)}));
         setTimeout(check, 200);
       };
       check();
     })
-  `;
-}
-/** Generate JS for scroll */
-export function scrollJs(direction, amount) {
-    const dx = direction === 'left' ? -amount : direction === 'right' ? amount : 0;
-    const dy = direction === 'up' ? -amount : direction === 'down' ? amount : 0;
-    return `window.scrollBy(${dx}, ${dy})`;
-}
-/** Generate JS for auto-scroll with lazy-load detection */
-export function autoScrollJs(times, delayMs) {
-    return `
+  `}export function scrollJs(g,p){const B=g==="left"?-p:g==="right"?p:0,z=g==="up"?-p:g==="down"?p:0;return`window.scrollBy(${B}, ${z})`}export function autoScrollJs(g,p){return`
     (async () => {
       if (!document.body) return;
-      for (let i = 0; i < ${times}; i++) {
+      for (let i = 0; i < ${g}; i++) {
         const lastHeight = document.body.scrollHeight;
         window.scrollTo(0, lastHeight);
         await new Promise(resolve => {
@@ -140,19 +97,15 @@ export function autoScrollJs(times, delayMs) {
             }
           });
           observer.observe(document.body, { childList: true, subtree: true });
-          timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${delayMs});
+          timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${p});
         });
       }
     })()
-  `;
-}
-/** Generate JS to read performance resource entries as network requests */
-export function networkRequestsJs(includeStatic) {
-    return `
+  `}export function networkRequestsJs(g){return`
     (() => {
       const entries = performance.getEntriesByType('resource');
       return entries
-        ${includeStatic ? '' : '.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
+        ${g?"":'.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
         .map(e => ({
           url: e.name,
           type: e.initiatorType,
@@ -160,20 +113,10 @@ export function networkRequestsJs(includeStatic) {
           size: e.transferSize || 0,
         }));
     })()
-  `;
-}
-/**
- * Generate JS to wait until the DOM stabilizes (no mutations for `quietMs`),
- * with a hard cap at `maxMs`. Uses MutationObserver in the browser.
- *
- * Returns as soon as the page stops changing, avoiding unnecessary fixed waits.
- * If document.body is not available, falls back to a fixed sleep of maxMs.
- */
-export function waitForDomStableJs(maxMs, quietMs) {
-    return `
+  `}export function waitForDomStableJs(g,p){return`
     new Promise(resolve => {
       if (!document.body) {
-        setTimeout(() => resolve('nobody'), ${maxMs});
+        setTimeout(() => resolve('nobody'), ${g});
         return;
       }
       let timer = null;
@@ -186,46 +129,31 @@ export function waitForDomStableJs(maxMs, quietMs) {
       };
       const resetQuiet = () => {
         clearTimeout(timer);
-        timer = setTimeout(() => done('quiet'), ${quietMs});
+        timer = setTimeout(() => done('quiet'), ${p});
       };
       const obs = new MutationObserver(resetQuiet);
       obs.observe(document.body, { childList: true, subtree: true, attributes: true });
       resetQuiet();
-      cap = setTimeout(() => done('capped'), ${maxMs});
+      cap = setTimeout(() => done('capped'), ${g});
     })
-  `;
-}
-/**
- * Generate JS to wait until window.__opencli_xhr has ≥1 captured response.
- * Polls every 100ms. Resolves 'captured' on success; rejects after maxMs.
- * Used after installInterceptor() + goto() instead of a fixed sleep.
- */
-export function waitForCaptureJs(maxMs) {
-    return `
+  `}export function waitForCaptureJs(g){return`
     new Promise((resolve, reject) => {
-      const deadline = Date.now() + ${maxMs};
+      const deadline = Date.now() + ${g};
       const check = () => {
         if ((window.__opencli_xhr || []).length > 0) return resolve('captured');
-        if (Date.now() > deadline) return reject(new Error('No network capture within ${maxMs / 1000}s'));
+        if (Date.now() > deadline) return reject(new Error('No network capture within ${g/1000}s'));
         setTimeout(check, 100);
       };
       check();
     })
-  `;
-}
-/**
- * Generate JS to wait until document.querySelector(selector) returns a match.
- * Uses MutationObserver for near-instant resolution; falls back to reject after timeoutMs.
- */
-export function waitForSelectorJs(selector, timeoutMs) {
-    return `
+  `}export function waitForSelectorJs(g,p){return`
     new Promise((resolve, reject) => {
-      const sel = ${JSON.stringify(selector)};
+      const sel = ${JSON.stringify(g)};
       if (document.querySelector(sel)) return resolve('found');
       const cap = setTimeout(() => {
         obs.disconnect();
         reject(new Error('Selector not found: ' + sel));
-      }, ${timeoutMs});
+      }, ${p});
       const obs = new MutationObserver(() => {
         if (document.querySelector(sel)) {
           clearTimeout(cap);
@@ -235,5 +163,4 @@ export function waitForSelectorJs(selector, timeoutMs) {
       });
       obs.observe(document.body || document.documentElement, { childList: true, subtree: true });
     })
-  `;
-}
+  `}

package/dist/src/browser/dom-snapshot.js

@@ -1,61 +1,13 @@
-/**
- * DOM Snapshot Engine — Advanced DOM pruning for LLM consumption.
- *
- * Inspired by browser-use's multi-layer pruning pipeline, adapted for opencli's
- * Chrome Extension + CDP architecture. Runs entirely in-page via Runtime.evaluate.
- *
- * Pipeline:
- *   1. Walk DOM tree, collect visibility + layout + interactivity signals
- *   2. Prune invisible, zero-area, non-content elements
- *   3. SVG & decoration collapse
- *   4. Shadow DOM traversal
- *   5. Same-origin iframe content extraction
- *   6. Bounding-box parent-child dedup (link/button wrapping children)
- *   7. Paint-order occlusion detection (overlay/modal coverage)
- *   8. Attribute whitelist filtering
- *   9. Table-aware serialization (markdown tables)
- *  10. Token-efficient serialization with interactive indices
- *  11. data-ref annotation for click/type targeting
- *  12. Hidden interactive element hints (scroll-to-reveal)
- *  13. Incremental diff (mark new elements with *)
- *
- * Additional tools:
- *   - scrollToRefJs(ref) — scroll to a data-opencli-ref element
- *   - getFormStateJs()  — extract all form fields as structured JSON
- *
- * Compound sidecar:
- *   After the tree, a `compounds:` section lists rich JSON for every
- *   date/select/file ref — format, full option list (up to cap) with
- *   `options_total` reflecting the true count, file `accept` + `multiple`.
- *   This is what the snapshot's inline attr dump cannot express and what
- *   agents kept blowing turns on.
- */
-import { COMPOUND_INFO_JS } from './compound.js';
-// ─── Utility JS Generators ───────────────────────────────────────────
-/**
- * Generate JS to scroll to an element identified by data-opencli-ref.
- * Completes the snapshot→action loop: snapshot identifies `[3]<button>`,
- * caller can then `scrollToRef('3')` to bring it into view.
- */
-export function scrollToRefJs(ref) {
-    const safeRef = JSON.stringify(ref);
-    return `
+import{COMPOUND_INFO_JS as U}from"./compound.js";export function scrollToRefJs(q){return`
     (() => {
-      const ref = ${safeRef};
+      const ref = ${JSON.stringify(q)};
       const el = document.querySelector('[data-opencli-ref="' + ref + '"]')
         || document.querySelector('[data-ref="' + ref + '"]');
       if (!el) throw new Error('Element not found: ref=' + ref);
       el.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'nearest' });
       return { scrolled: true, tag: el.tagName.toLowerCase(), text: (el.textContent || '').trim().slice(0, 80) };
     })()
-  `.trim();
-}
-/**
- * Generate JS to extract all form field values from the page.
- * Returns structured JSON: { forms: [{ id, action, fields: [{ tag, type, name, value, ... }] }] }
- */
-export function getFormStateJs() {
-    return `
+  `.trim()}export function getFormStateJs(){return`
     (() => {
       const result = { forms: [], orphanFields: [] };
 
@@ -123,64 +75,28 @@ export function getFormStateJs() {
 
       return result;
     })()
-  `.trim();
-}
-// ─── Main Snapshot JS Generator ──────────────────────────────────────
-/**
- * Generate JavaScript code that, when evaluated in a page context via CDP
- * Runtime.evaluate, returns a pruned DOM snapshot string optimised for LLMs.
- *
- * The snapshot output format:
- *   [42]<button type=submit>Search</button>
- *   |scroll|<div> (0.5↑ 3.2↓)
- *     *[58]<a href=/r/1>Result 1</a>
- *     [59]<a href=/r/2>Result 2</a>
- *
- * - `[id]` — interactive element with backend index for targeting
- * - `*` prefix — newly appeared element (incremental diff)
- * - `|scroll|` — scrollable container with page counts
- * - `|shadow|` — Shadow DOM boundary
- * - `|iframe|` — iframe content
- * - `|table|` — markdown table rendering
- */
-export function generateSnapshotJs(opts = {}) {
-    const viewportExpand = opts.viewportExpand ?? 800;
-    const maxDepth = Math.max(1, Math.min(opts.maxDepth ?? 50, 200));
-    const interactiveOnly = opts.interactiveOnly ?? false;
-    const maxTextLength = opts.maxTextLength ?? 120;
-    const includeScrollInfo = opts.includeScrollInfo ?? true;
-    const bboxDedup = opts.bboxDedup ?? true;
-    const includeShadowDom = opts.includeShadowDom ?? true;
-    const includeIframes = opts.includeIframes ?? true;
-    const maxIframes = opts.maxIframes ?? 5;
-    const paintOrderCheck = opts.paintOrderCheck ?? true;
-    const annotateRefs = opts.annotateRefs ?? true;
-    const reportHidden = opts.reportHidden ?? true;
-    const filterAds = opts.filterAds ?? true;
-    const markdownTables = opts.markdownTables ?? true;
-    const previousHashes = opts.previousHashes ?? null;
-    return `
+  `.trim()}export function generateSnapshotJs(q={}){const z=q.viewportExpand??800,K=Math.max(1,Math.min(q.maxDepth??50,200)),Q=q.interactiveOnly??!1,V=q.maxTextLength??120,W=q.includeScrollInfo??!0,X=q.bboxDedup??!0,Y=q.includeShadowDom??!0,Z=q.includeIframes??!0,$=q.maxIframes??5,j=q.paintOrderCheck??!0,A=q.annotateRefs??!0,E=q.reportHidden??!0,F=q.filterAds??!0,G=q.markdownTables??!0,B=q.previousHashes??null;return`
 (() => {
   'use strict';
 
-  ${COMPOUND_INFO_JS}
+  ${U}
 
   // ── Config ─────────────────────────────────────────────────────────
-  const VIEWPORT_EXPAND = ${viewportExpand};
-  const MAX_DEPTH = ${maxDepth};
-  const INTERACTIVE_ONLY = ${interactiveOnly};
-  const MAX_TEXT_LEN = ${maxTextLength};
-  const INCLUDE_SCROLL_INFO = ${includeScrollInfo};
-  const BBOX_DEDUP = ${bboxDedup};
-  const INCLUDE_SHADOW_DOM = ${includeShadowDom};
-  const INCLUDE_IFRAMES = ${includeIframes};
-  const MAX_IFRAMES = ${maxIframes};
-  const PAINT_ORDER_CHECK = ${paintOrderCheck};
-  const ANNOTATE_REFS = ${annotateRefs};
-  const REPORT_HIDDEN = ${reportHidden};
-  const FILTER_ADS = ${filterAds};
-  const MARKDOWN_TABLES = ${markdownTables};
-  const PREV_HASHES = ${previousHashes ? `new Set(${previousHashes})` : 'null'};
+  const VIEWPORT_EXPAND = ${z};
+  const MAX_DEPTH = ${K};
+  const INTERACTIVE_ONLY = ${Q};
+  const MAX_TEXT_LEN = ${V};
+  const INCLUDE_SCROLL_INFO = ${W};
+  const BBOX_DEDUP = ${X};
+  const INCLUDE_SHADOW_DOM = ${Y};
+  const INCLUDE_IFRAMES = ${Z};
+  const MAX_IFRAMES = ${$};
+  const PAINT_ORDER_CHECK = ${j};
+  const ANNOTATE_REFS = ${A};
+  const REPORT_HIDDEN = ${E};
+  const FILTER_ADS = ${F};
+  const MARKDOWN_TABLES = ${G};
+  const PREV_HASHES = ${B?`new Set(${B})`:"null"};
 
   // ── Constants ──────────────────────────────────────────────────────
 
@@ -890,5 +806,4 @@ export function generateSnapshotJs(opts = {}) {
 
   return lines.join('\\n');
 })()
-  `.trim();
-}
+  `.trim()}

package/dist/src/browser/errors.js

@@ -1,78 +1,5 @@
-/**
- * Browser connection error helpers.
- *
- * Simplified — no more token/extension/CDP classification.
- * The daemon architecture has a single failure mode: daemon not reachable or extension not connected.
- */
-import { BrowserConnectError } from '../errors.js';
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
-/**
- * Extension/daemon transient patterns — service worker restarts, attach races,
- * tab closure, daemon hiccups. These warrant a longer retry delay (~1500ms)
- * because the extension needs time to recover.
- */
-const EXTENSION_TRANSIENT_PATTERNS = [
-    'Extension disconnected',
-    'Extension not connected',
-    'attach failed',
-    'Detached while handling command',
-    'Debugger is not attached to the tab',
-    'no longer exists',
-    'No tab with id',
-    'CDP connection',
-    'Daemon command failed',
-    'No window with id',
-];
-/**
- * CDP target navigation patterns — SPA client-side redirects can invalidate the
- * CDP target after chrome.tabs reports 'complete'. These warrant a shorter retry
- * delay (~200ms) because the new document is usually available quickly.
- */
-const TARGET_NAVIGATION_PATTERNS = [
-    'Inspected target navigated or closed',
-];
-function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-/**
- * Classify a browser error and return retry advice.
- *
- * Single source of truth for "is this error transient?" across all layers.
- */
-export function classifyBrowserError(err) {
-    const msg = errorMessage(err);
-    // Extension/daemon transient errors — longer recovery time
-    if (EXTENSION_TRANSIENT_PATTERNS.some(p => msg.includes(p))) {
-        return { kind: 'extension-transient', retryable: true, delayMs: 1500 };
-    }
-    // CDP target navigation errors — shorter recovery time
-    if (TARGET_NAVIGATION_PATTERNS.some(p => msg.includes(p))) {
-        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
-    }
-    // CDP protocol error with target/context invalidation (e.g., -32000 "target closed" or
-    // -32000 "Cannot find default execution context" — both indicate the inspected target
-    // went away and a fresh attach should recover).
-    if (msg.includes('-32000') && /target|context/i.test(msg)) {
-        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
-    }
-    return { kind: 'non-retryable', retryable: false, delayMs: 0 };
-}
-/**
- * Check if an error is a transient browser error worth retrying.
- * Convenience wrapper around classifyBrowserError().
- */
-export function isTransientBrowserError(err) {
-    return classifyBrowserError(err).retryable;
-}
-export function formatBrowserConnectError(kind, detail) {
-    switch (kind) {
-        case 'daemon-not-running':
-            return new BrowserConnectError('Cannot connect to opencli daemon.' + (detail ? `\n\n${detail}` : ''), `Run \`opencli doctor\` to diagnose, or \`opencli daemon restart\` to force a fresh daemon. Default port is ${DEFAULT_DAEMON_PORT}.`, kind);
-        case 'extension-not-connected':
-            return new BrowserConnectError('Browser Bridge extension is not connected.' + (detail ? `\n\n${detail}` : ''), 'Install the extension from GitHub Releases, then reload.', kind);
-        case 'command-failed':
-            return new BrowserConnectError(`Browser command failed: ${detail ?? 'unknown error'}`, undefined, kind);
-        default:
-            return new BrowserConnectError(detail ?? 'Failed to connect to browser', undefined, kind);
-    }
-}
+import{BrowserConnectError as z}from"../errors.js";import{DEFAULT_DAEMON_PORT as J}from"../constants.js";const K=["Extension disconnected","Extension not connected","attach failed","Detached while handling command","Debugger is not attached to the tab","no longer exists","No tab with id","CDP connection","Daemon command failed","No window with id"],Q=["Inspected target navigated or closed"];function W(q){return q instanceof Error?q.message:String(q)}export function classifyBrowserError(q){const x=W(q);if(K.some((H)=>x.includes(H)))return{kind:"extension-transient",retryable:!0,delayMs:1500};if(Q.some((H)=>x.includes(H)))return{kind:"target-navigation",retryable:!0,delayMs:200};if(x.includes("-32000")&&/target|context/i.test(x))return{kind:"target-navigation",retryable:!0,delayMs:200};return{kind:"non-retryable",retryable:!1,delayMs:0}}export function isTransientBrowserError(q){return classifyBrowserError(q).retryable}export function formatBrowserConnectError(q,x){switch(q){case"daemon-not-running":return new z("Cannot connect to opencli daemon."+(x?`
+
+${x}`:""),`Run \`opencli doctor\` to diagnose, or \`opencli daemon restart\` to force a fresh daemon. Default port is ${J}.`,q);case"extension-not-connected":return new z("Browser Bridge extension is not connected."+(x?`
+
+${x}`:""),"Install the extension from GitHub Releases, then reload.",q);case"command-failed":return new z(`Browser command failed: ${x??"unknown error"}`,void 0,q);default:return new z(x??"Failed to connect to browser",void 0,q)}}

package/dist/src/browser/extract.js

@@ -1,36 +1,5 @@
-/**
- * `browser extract` — agent-native article/content reading channel.
- *
- * Pipeline (from first principles — agents want the *content*, not the DOM):
- *   1. Scope:    select `--selector` (default: document.body or <main>/<article>)
- *   2. Denoise:  strip script/style/nav/header/footer/aside/iframe/svg/form, inline noise
- *   3. Convert:  HTML → Markdown via shared `htmlToMarkdown` (turndown)
- *   4. Chunk:    paragraph-boundary-aware slicing with `next_start_char` cursor
- *
- * Why a separate command:
- * - `get html --as json` returns tree structure; useless for "read the article".
- * - `get text` flattens everything; loses headings, lists, links.
- * - Markdown is the agent-readable middle ground: structure preserved, noise gone.
- *
- * Continuation contract: the envelope always carries `start`, `end`,
- * `total_chars`, and `next_start_char` (null when the last chunk was emitted).
- * Agents pass `--start <next>` to continue. No session state required.
- */
-import { htmlToMarkdown } from '../utils.js';
-const DEFAULT_CHUNK_SIZE = 20000;
-const MIN_CHUNK_SIZE = 100;
-const MAX_CHUNK_SIZE = 200000;
-const BOUNDARY_WINDOW_RATIO = 0.15;
-/**
- * Returns the JS expression string used with `page.evaluate` to produce the
- * cleaned HTML subtree that we then hand to `htmlToMarkdown`. We do the
- * denoise/clone inside the page so we can use DOM APIs (querySelectorAll,
- * cloneNode) rather than regex on serialized HTML.
- */
-export function buildExtractHtmlJs(selector) {
-    const selectorLiteral = selector ? JSON.stringify(selector) : 'null';
-    return `(() => {
-  const sel = ${selectorLiteral};
+import{htmlToMarkdown as Y}from"../utils.js";const V=20000,$=100,j=200000,F=0.15;export function buildExtractHtmlJs(f){return`(() => {
+  const sel = ${f?JSON.stringify(f):"null"};
   let root = null;
   if (sel) {
     try { root = document.querySelector(sel); }
@@ -67,66 +36,7 @@ export function buildExtractHtmlJs(selector) {
     n = walker.nextNode();
   }
   return { ok: true, url: location.href, title: document.title || '', html: clone.outerHTML || '' };
-})()`;
-}
-/**
- * Slice `content` into one chunk starting at `start` with target size
- * `chunkSize`. When the chunk would land mid-paragraph, we pull the break
- * back to the nearest `\n\n` (or `\n`) within a small window to keep the
- * output readable. If no boundary is found, we hard-cut at `start+chunkSize`.
- */
-export function chunkMarkdown(opts) {
-    const { content, start } = opts;
-    const chunkSize = Math.max(MIN_CHUNK_SIZE, Math.min(MAX_CHUNK_SIZE, opts.chunkSize));
-    if (start >= content.length) {
-        return { content: '', start, end: start, nextStartChar: null };
-    }
-    const hardEnd = Math.min(content.length, start + chunkSize);
-    if (hardEnd === content.length) {
-        return { content: content.slice(start, hardEnd), start, end: hardEnd, nextStartChar: null };
-    }
-    const windowSize = Math.max(1, Math.floor(chunkSize * BOUNDARY_WINDOW_RATIO));
-    const windowStart = Math.max(start + 1, hardEnd - windowSize);
-    const slice = content.slice(windowStart, hardEnd);
-    const paraBreak = slice.lastIndexOf('\n\n');
-    let cut = hardEnd;
-    if (paraBreak >= 0) {
-        cut = windowStart + paraBreak + 2;
-    }
-    else {
-        const lineBreak = slice.lastIndexOf('\n');
-        if (lineBreak >= 0)
-            cut = windowStart + lineBreak + 1;
-    }
-    return {
-        content: content.slice(start, cut),
-        start,
-        end: cut,
-        nextStartChar: cut,
-    };
-}
-/** End-to-end host-side pipeline: HTML → markdown → chunked envelope. */
-export function runExtractFromHtml(opts) {
-    const md = htmlToMarkdown(opts.html);
-    const chunk = chunkMarkdown({
-        content: md,
-        start: Math.max(0, opts.start),
-        chunkSize: opts.chunkSize || DEFAULT_CHUNK_SIZE,
-    });
-    return {
-        url: opts.url,
-        title: opts.title,
-        selector: opts.selector,
-        total_chars: md.length,
-        chunk_size: chunk.end - chunk.start,
-        start: chunk.start,
-        end: chunk.end,
-        next_start_char: chunk.nextStartChar,
-        content: chunk.content,
-    };
-}
-export const __extractInternals = {
-    DEFAULT_CHUNK_SIZE,
-    MIN_CHUNK_SIZE,
-    MAX_CHUNK_SIZE,
-};
+})()`}export function chunkMarkdown(f){const{content:g,start:b}=f,G=Math.max($,Math.min(j,f.chunkSize));if(b>=g.length)return{content:"",start:b,end:b,nextStartChar:null};const q=Math.min(g.length,b+G);if(q===g.length)return{content:g.slice(b,q),start:b,end:q,nextStartChar:null};const v=Math.max(1,Math.floor(G*F)),y=Math.max(b+1,q-v),J=g.slice(y,q),P=J.lastIndexOf(`
+
+`);let x=q;if(P>=0)x=y+P+2;else{const Q=J.lastIndexOf(`
+`);if(Q>=0)x=y+Q+1}return{content:g.slice(b,x),start:b,end:x,nextStartChar:x}}export function runExtractFromHtml(f){const g=Y(f.html),b=chunkMarkdown({content:g,start:Math.max(0,f.start),chunkSize:f.chunkSize||V});return{url:f.url,title:f.title,selector:f.selector,total_chars:g.length,chunk_size:b.end-b.start,start:b.start,end:b.end,next_start_char:b.nextStartChar,content:b.content}}export const __extractInternals={DEFAULT_CHUNK_SIZE:V,MIN_CHUNK_SIZE:$,MAX_CHUNK_SIZE:j};