@j0hanz/superfetch 2.0.1 → 2.1.1

package/dist/transform.js

@@ -0,0 +1,1814 @@
+import { randomUUID } from 'node:crypto';
+import diagnosticsChannel from 'node:diagnostics_channel';
+import os from 'node:os';
+import { performance } from 'node:perf_hooks';
+import { Worker } from 'node:worker_threads';
+import { parseHTML } from 'linkedom';
+import { NodeHtmlMarkdown, } from 'node-html-markdown';
+import { z } from 'zod';
+import { isProbablyReaderable, Readability } from '@mozilla/readability';
+import { config } from './config.js';
+import { FetchError, getErrorMessage } from './errors.js';
+import { isRawTextContentUrl } from './fetch.js';
+import { getOperationId, getRequestId, logDebug, logError, logInfo, logWarn, redactUrl, } from './observability.js';
+import { isRecord } from './utils.js';
+function getAbortReason(signal) {
+    if (!isRecord(signal))
+        return undefined;
+    return 'reason' in signal ? signal.reason : undefined;
+}
+function getBodyInnerHtml(document) {
+    if (!isRecord(document))
+        return undefined;
+    const { body } = document;
+    if (!isRecord(body))
+        return undefined;
+    const { innerHTML } = body;
+    return typeof innerHTML === 'string' && innerHTML.length > 0
+        ? innerHTML
+        : undefined;
+}
+function getDocumentToString(document) {
+    if (!isRecord(document))
+        return undefined;
+    if (typeof document.toString !== 'function')
+        return undefined;
+    return document.toString.bind(document);
+}
+function getDocumentElementOuterHtml(document) {
+    if (!isRecord(document))
+        return undefined;
+    const { documentElement } = document;
+    if (!isRecord(documentElement))
+        return undefined;
+    const { outerHTML } = documentElement;
+    return typeof outerHTML === 'string' && outerHTML.length > 0
+        ? outerHTML
+        : undefined;
+}
+const CODE_BLOCK = {
+    fence: '```',
+    format: (code, language = '') => {
+        return `\`\`\`${language}\n${code}\n\`\`\``;
+    },
+};
+const transformChannel = diagnosticsChannel.channel('superfetch.transform');
+function publishTransformEvent(event) {
+    if (!transformChannel.hasSubscribers)
+        return;
+    try {
+        transformChannel.publish(event);
+    }
+    catch {
+        // Avoid crashing the publisher if a subscriber throws.
+    }
+}
+export function startTransformStage(url, stage) {
+    if (!transformChannel.hasSubscribers)
+        return null;
+    return {
+        stage,
+        startTime: performance.now(),
+        url: redactUrl(url),
+    };
+}
+export function endTransformStage(context, options) {
+    if (!context)
+        return;
+    const requestId = getRequestId();
+    const operationId = getOperationId();
+    const event = {
+        v: 1,
+        type: 'stage',
+        stage: context.stage,
+        durationMs: performance.now() - context.startTime,
+        url: context.url,
+        ...(requestId ? { requestId } : {}),
+        ...(operationId ? { operationId } : {}),
+        ...(options?.truncated !== undefined
+            ? { truncated: options.truncated }
+            : {}),
+    };
+    publishTransformEvent(event);
+}
+function runTransformStage(url, stage, fn) {
+    const context = startTransformStage(url, stage);
+    const result = fn();
+    endTransformStage(context);
+    return result;
+}
+function isTimeoutReason(reason) {
+    return reason instanceof Error && reason.name === 'TimeoutError';
+}
+function throwIfAborted(signal, url, stage) {
+    if (!signal)
+        return;
+    const { aborted } = signal;
+    if (!aborted)
+        return;
+    const reason = getAbortReason(signal);
+    if (isTimeoutReason(reason)) {
+        throw new FetchError('Request timeout', url, 504, {
+            reason: 'timeout',
+            stage,
+        });
+    }
+    throw new FetchError('Request was canceled', url, 499, {
+        reason: 'aborted',
+        stage,
+    });
+}
+function truncateHtml(html) {
+    const maxSize = config.constants.maxHtmlSize;
+    if (html.length <= maxSize) {
+        return html;
+    }
+    logWarn('HTML content exceeds maximum size, truncating', {
+        size: html.length,
+        maxSize,
+    });
+    return html.substring(0, maxSize);
+}
+function createMetaCollectorState() {
+    return {
+        title: {},
+        description: {},
+        author: {},
+    };
+}
+function resolveMetaField(state, field) {
+    const sources = state[field];
+    return sources.og ?? sources.twitter ?? sources.standard;
+}
+function parseOpenGraphKey(property) {
+    if (!property?.startsWith('og:'))
+        return null;
+    const key = property.replace('og:', '');
+    return key === 'title' || key === 'description' ? key : null;
+}
+function parseTwitterKey(name) {
+    if (!name?.startsWith('twitter:'))
+        return null;
+    const key = name.replace('twitter:', '');
+    return key === 'title' || key === 'description' ? key : null;
+}
+function parseStandardKey(name) {
+    if (name === 'description')
+        return 'description';
+    if (name === 'author')
+        return 'author';
+    return null;
+}
+function collectMetaTag(state, tag) {
+    const content = tag.getAttribute('content')?.trim();
+    if (!content)
+        return;
+    const ogKey = parseOpenGraphKey(tag.getAttribute('property'));
+    if (ogKey) {
+        state[ogKey].og = content;
+        return;
+    }
+    const name = tag.getAttribute('name');
+    const twitterKey = parseTwitterKey(name);
+    if (twitterKey) {
+        state[twitterKey].twitter = content;
+        return;
+    }
+    const standardKey = parseStandardKey(name);
+    if (standardKey) {
+        state[standardKey].standard = content;
+    }
+}
+function scanMetaTags(document, state) {
+    const metaTags = document.querySelectorAll('meta');
+    for (const tag of metaTags) {
+        collectMetaTag(state, tag);
+    }
+}
+function ensureTitleFallback(document, state) {
+    if (state.title.standard)
+        return;
+    const titleEl = document.querySelector('title');
+    if (titleEl?.textContent) {
+        state.title.standard = titleEl.textContent.trim();
+    }
+}
+function extractMetadata(document) {
+    const state = createMetaCollectorState();
+    scanMetaTags(document, state);
+    ensureTitleFallback(document, state);
+    const metadata = {};
+    const title = resolveMetaField(state, 'title');
+    const description = resolveMetaField(state, 'description');
+    const author = resolveMetaField(state, 'author');
+    if (title !== undefined)
+        metadata.title = title;
+    if (description !== undefined)
+        metadata.description = description;
+    if (author !== undefined)
+        metadata.author = author;
+    return metadata;
+}
+function isReadabilityCompatible(doc) {
+    if (!isRecord(doc))
+        return false;
+    return hasDocumentElement(doc) && hasQuerySelectors(doc);
+}
+function hasDocumentElement(record) {
+    return 'documentElement' in record;
+}
+function hasQuerySelectors(record) {
+    return (typeof record.querySelectorAll === 'function' &&
+        typeof record.querySelector === 'function');
+}
+function extractArticle(document) {
+    if (!isReadabilityCompatible(document)) {
+        logWarn('Document not compatible with Readability');
+        return null;
+    }
+    return mapParsedArticle(parseReadabilityArticle(document));
+}
+function parseReadabilityArticle(document) {
+    try {
+        // Readability mutates the document; operate on a clone.
+        const documentClone = document.cloneNode(true);
+        // Avoid the more expensive parse() when the page is unlikely to be readable,
+        // but don't penalize small documents where the heuristic is often too strict.
+        const rawText = documentClone.body.textContent ||
+            documentClone.documentElement.textContent;
+        const textLength = rawText.replace(/\s+/g, ' ').trim().length;
+        if (textLength >= 400 && !isProbablyReaderable(documentClone)) {
+            return null;
+        }
+        // Guard against pathological DOM sizes.
+        const reader = new Readability(documentClone, { maxElemsToParse: 20_000 });
+        return reader.parse();
+    }
+    catch (error) {
+        logError('Failed to extract article with Readability', asError(error));
+        return null;
+    }
+}
+function asError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return undefined;
+}
+function mapParsedArticle(parsed) {
+    return parsed ? mapReadabilityResult(parsed) : null;
+}
+function mapReadabilityResult(parsed) {
+    return {
+        content: parsed.content ?? '',
+        textContent: parsed.textContent ?? '',
+        ...buildOptionalArticleFields(parsed),
+    };
+}
+function buildOptionalArticleFields(parsed) {
+    const optional = {};
+    addOptionalField(optional, 'title', parsed.title);
+    addOptionalField(optional, 'byline', parsed.byline);
+    addOptionalField(optional, 'excerpt', parsed.excerpt);
+    addOptionalField(optional, 'siteName', parsed.siteName);
+    return optional;
+}
+function addOptionalField(target, key, value) {
+    if (value == null)
+        return;
+    target[key] = value;
+}
+export function extractContent(html, url, options = {
+    extractArticle: true,
+}) {
+    const emptyResult = createEmptyExtractionResult();
+    if (!isValidInput(html, url)) {
+        return emptyResult;
+    }
+    return tryExtractContent(html, url, options);
+}
+function createEmptyExtractionResult() {
+    return { article: null, metadata: {} };
+}
+function extractArticleWithStage(document, url, shouldExtract) {
+    if (!shouldExtract)
+        return null;
+    return runTransformStage(url, 'extract:article', () => resolveArticleExtraction(document, shouldExtract));
+}
+function handleExtractionFailure(error, url, signal) {
+    if (error instanceof FetchError) {
+        throw error;
+    }
+    throwIfAborted(signal, url, 'extract:error');
+    logError('Failed to extract content', error instanceof Error ? error : undefined);
+    return createEmptyExtractionResult();
+}
+function extractContentStages(html, url, options) {
+    throwIfAborted(options.signal, url, 'extract:begin');
+    const { document } = runTransformStage(url, 'extract:parse', () => parseHTML(truncateHtml(html)));
+    throwIfAborted(options.signal, url, 'extract:parsed');
+    applyBaseUri(document, url);
+    const metadata = runTransformStage(url, 'extract:metadata', () => extractMetadata(document));
+    throwIfAborted(options.signal, url, 'extract:metadata');
+    const article = extractArticleWithStage(document, url, options.extractArticle);
+    throwIfAborted(options.signal, url, 'extract:article');
+    return {
+        article,
+        metadata,
+    };
+}
+function tryExtractContent(html, url, options) {
+    try {
+        return extractContentStages(html, url, options);
+    }
+    catch (error) {
+        return handleExtractionFailure(error, url, options.signal);
+    }
+}
+function isValidInput(html, url) {
+    return (validateRequiredString(html, 'extractContent called with invalid HTML input') && validateRequiredString(url, 'extractContent called with invalid URL'));
+}
+function validateRequiredString(value, message) {
+    if (isNonEmptyString(value))
+        return true;
+    logWarn(message);
+    return false;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function resolveArticleExtraction(document, shouldExtract) {
+    return shouldExtract ? extractArticle(document) : null;
+}
+function applyBaseUri(document, url) {
+    try {
+        Object.defineProperty(document, 'baseURI', {
+            value: url,
+            writable: true,
+        });
+    }
+    catch (error) {
+        logInfo('Failed to set baseURI (non-critical)', {
+            url: url.substring(0, 100),
+            error: getErrorMessage(error),
+        });
+    }
+}
+function containsJsxTag(code) {
+    for (let index = 0; index < code.length - 1; index += 1) {
+        if (code[index] !== '<')
+            continue;
+        const next = code[index + 1];
+        if (!next)
+            continue;
+        if (next >= 'A' && next <= 'Z')
+            return true;
+    }
+    return false;
+}
+function containsWord(source, word) {
+    let startIndex = source.indexOf(word);
+    while (startIndex !== -1) {
+        const before = startIndex === 0 ? '' : source[startIndex - 1];
+        const afterIndex = startIndex + word.length;
+        const after = afterIndex >= source.length ? '' : source[afterIndex];
+        if (!isWordChar(before) && !isWordChar(after))
+            return true;
+        startIndex = source.indexOf(word, startIndex + word.length);
+    }
+    return false;
+}
+function splitLines(content) {
+    return content.split('\n');
+}
+function extractLanguageFromClassName(className) {
+    const tokens = className.match(/\S+/g);
+    if (!tokens)
+        return undefined;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower.startsWith('language-'))
+            return token.slice('language-'.length);
+        if (lower.startsWith('lang-'))
+            return token.slice('lang-'.length);
+        if (lower.startsWith('highlight-')) {
+            return token.slice('highlight-'.length);
+        }
+    }
+    return undefined;
+}
+function resolveLanguageFromDataAttribute(dataLang) {
+    const trimmed = dataLang.trim();
+    if (!trimmed)
+        return undefined;
+    for (const char of trimmed) {
+        if (!isWordChar(char))
+            return undefined;
+    }
+    return trimmed;
+}
+function isWordChar(char) {
+    if (!char)
+        return false;
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        char === '_');
+}
+const BASH_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn',
+    'pnpm',
+    'npx',
+    'brew',
+    'apt',
+    'pip',
+    'cargo',
+    'go',
+];
+const BASH_VERBS = ['install', 'add', 'run', 'build', 'start'];
+const BASH_COMMANDS = ['sudo', 'chmod', 'mkdir', 'cd', 'ls', 'cat', 'echo'];
+function detectBash(code) {
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        if (isBashIndicator(trimmed))
+            return true;
+    }
+    return false;
+}
+function startsWithCommand(line, commands) {
+    return commands.some((command) => line === command || line.startsWith(`${command} `));
+}
+function isBashIndicator(line) {
+    return (isShebang(line) ||
+        isPromptLine(line) ||
+        startsWithCommand(line, BASH_COMMANDS) ||
+        startsWithPackageManagerCommand(line));
+}
+function isShebang(line) {
+    return line.startsWith('#!');
+}
+function isPromptLine(line) {
+    return line.startsWith('$ ') || line.startsWith('# ');
+}
+function startsWithPackageManagerCommand(line) {
+    return BASH_PACKAGE_MANAGERS.some((manager) => {
+        if (!line.startsWith(`${manager} `))
+            return false;
+        const rest = line.slice(manager.length + 1);
+        return BASH_VERBS.some((verb) => rest === verb || rest.startsWith(`${verb} `));
+    });
+}
+const TYPE_HINTS = [
+    'string',
+    'number',
+    'boolean',
+    'void',
+    'any',
+    'unknown',
+    'never',
+];
+const HTML_TAGS = [
+    '<!doctype',
+    '<html',
+    '<head',
+    '<body',
+    '<div',
+    '<span',
+    '<p',
+    '<a',
+    '<script',
+    '<style',
+];
+const SQL_KEYWORDS = [
+    'select',
+    'insert',
+    'update',
+    'delete',
+    'create',
+    'alter',
+    'drop',
+];
+const JS_WORD_REGEX = /\b(?:const|let|var|function|class|async|await|export|import)\b/;
+const PYTHON_WORD_REGEX = /\b(?:def|class|import|from)\b/;
+const RUST_WORD_REGEX = /\b(?:fn|impl|struct|enum)\b/;
+const CSS_DIRECTIVE_REGEX = /@media|@import|@keyframes/;
+const CODE_DETECTORS = [
+    { language: 'jsx', detect: detectJsx },
+    { language: 'typescript', detect: detectTypescript },
+    { language: 'rust', detect: detectRust },
+    { language: 'javascript', detect: detectJavascript },
+    { language: 'python', detect: detectPython },
+    { language: 'bash', detect: detectBash },
+    { language: 'css', detect: detectCss },
+    { language: 'html', detect: detectHtml },
+    { language: 'json', detect: detectJson },
+    { language: 'yaml', detect: detectYaml },
+    { language: 'sql', detect: detectSql },
+    { language: 'go', detect: detectGo },
+];
+function detectJsx(code) {
+    const lower = code.toLowerCase();
+    if (lower.includes('classname='))
+        return true;
+    if (lower.includes('jsx:'))
+        return true;
+    if (lower.includes("from 'react'") || lower.includes('from "react"')) {
+        return true;
+    }
+    return containsJsxTag(code);
+}
+function detectTypescript(code) {
+    const lower = code.toLowerCase();
+    if (containsWord(lower, 'interface'))
+        return true;
+    if (containsWord(lower, 'type'))
+        return true;
+    return TYPE_HINTS.some((hint) => lower.includes(`: ${hint}`) || lower.includes(`:${hint}`));
+}
+function detectRust(code) {
+    const lower = code.toLowerCase();
+    return (RUST_WORD_REGEX.test(lower) ||
+        lower.includes('let mut') ||
+        (lower.includes('use ') && lower.includes('::')));
+}
+function detectJavascript(code) {
+    const lower = code.toLowerCase();
+    return JS_WORD_REGEX.test(lower);
+}
+function detectPython(code) {
+    const lower = code.toLowerCase();
+    return (PYTHON_WORD_REGEX.test(lower) ||
+        lower.includes('print(') ||
+        lower.includes('__name__'));
+}
+function detectCss(code) {
+    const lower = code.toLowerCase();
+    if (CSS_DIRECTIVE_REGEX.test(lower))
+        return true;
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        if (isCssSelectorLine(trimmed) || isCssPropertyLine(trimmed))
+            return true;
+    }
+    return false;
+}
+function detectHtml(code) {
+    const lower = code.toLowerCase();
+    return HTML_TAGS.some((tag) => lower.includes(tag));
+}
+function detectJson(code) {
+    const trimmed = code.trimStart();
+    if (!trimmed)
+        return false;
+    return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+function detectYaml(code) {
+    const lines = splitLines(code);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex <= 0)
+            continue;
+        const after = trimmed[colonIndex + 1];
+        if (after === ' ' || after === '\t')
+            return true;
+    }
+    return false;
+}
+function detectSql(code) {
+    const lower = code.toLowerCase();
+    return SQL_KEYWORDS.some((keyword) => containsWord(lower, keyword));
+}
+function detectGo(code) {
+    const lower = code.toLowerCase();
+    return (containsWord(lower, 'package') ||
+        containsWord(lower, 'func') ||
+        lower.includes('import "'));
+}
+function isCssSelectorLine(line) {
+    if (!line.startsWith('.') && !line.startsWith('#'))
+        return false;
+    return line.includes('{');
+}
+function isCssPropertyLine(line) {
+    return line.includes(':') && line.includes(';');
+}
+export function detectLanguageFromCode(code) {
+    for (const { language, detect } of CODE_DETECTORS) {
+        if (detect(code))
+            return language;
+    }
+    return undefined;
+}
+export function resolveLanguageFromAttributes(className, dataLang) {
+    const classMatch = extractLanguageFromClassName(className);
+    return classMatch ?? resolveLanguageFromDataAttribute(dataLang);
+}
+function isElement(node) {
+    return (isRecord(node) &&
+        'getAttribute' in node &&
+        typeof node.getAttribute === 'function');
+}
+const STRUCTURAL_TAGS = new Set([
+    'script',
+    'style',
+    'noscript',
+    'iframe',
+    'form',
+    'button',
+    'input',
+    'select',
+    'textarea',
+]);
+const ALWAYS_NOISE_TAGS = new Set(['nav', 'footer', 'aside']);
+const NAVIGATION_ROLES = new Set([
+    'navigation',
+    'banner',
+    'complementary',
+    'contentinfo',
+    'tree',
+    'menubar',
+    'menu',
+    'dialog',
+    'alertdialog',
+]);
+const PROMO_TOKENS = new Set([
+    'banner',
+    'promo',
+    'announcement',
+    'cta',
+    'callout',
+    'advert',
+    'ad',
+    'ads',
+    'sponsor',
+    'newsletter',
+    'subscribe',
+    'cookie',
+    'consent',
+    'popup',
+    'modal',
+    'overlay',
+    'toast',
+    'share',
+    'social',
+    'related',
+    'recommend',
+    'comment',
+    'breadcrumb',
+    'pagination',
+    'pager',
+]);
+const HEADER_NOISE_PATTERN = /\b(site-header|masthead|topbar|navbar|nav(?:bar)?|menu|header-nav)\b/i;
+const FIXED_PATTERN = /\b(fixed|sticky)\b/;
+const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
+const ISOLATE_PATTERN = /\bisolate\b/;
+const HTML_DOCUMENT_MARKERS = /<\s*(?:!doctype|html|head|body)\b/i;
+const NOISE_MARKERS = [
+    '<script',
+    '<style',
+    '<noscript',
+    '<iframe',
+    '<nav',
+    '<footer',
+    '<aside',
+    '<header',
+    '<form',
+    '<button',
+    '<input',
+    '<select',
+    '<textarea',
+    '<svg',
+    '<canvas',
+    ' aria-hidden="true"',
+    " aria-hidden='true'",
+    ' hidden',
+    ' role="navigation"',
+    " role='navigation'",
+    ' role="banner"',
+    " role='banner'",
+    ' role="complementary"',
+    " role='complementary'",
+    ' role="contentinfo"',
+    " role='contentinfo'",
+    ' role="tree"',
+    " role='tree'",
+    ' role="menubar"',
+    " role='menubar'",
+    ' role="menu"',
+    " role='menu'",
+    ' banner',
+    ' promo',
+    ' announcement',
+    ' cta',
+    ' callout',
+    ' advert',
+    ' newsletter',
+    ' subscribe',
+    ' cookie',
+    ' consent',
+    ' popup',
+    ' modal',
+    ' overlay',
+    ' toast',
+    ' fixed',
+    ' sticky',
+    ' z-50',
+    ' z-4',
+    ' isolate',
+];
+function mayContainNoise(html) {
+    const haystack = html.toLowerCase();
+    return NOISE_MARKERS.some((marker) => haystack.includes(marker));
+}
+function isFullDocumentHtml(html) {
+    return HTML_DOCUMENT_MARKERS.test(html);
+}
+function isStructuralNoiseTag(tagName) {
+    return (STRUCTURAL_TAGS.has(tagName) || tagName === 'svg' || tagName === 'canvas');
+}
+function isElementHidden(element) {
+    const style = element.getAttribute('style') ?? '';
+    return (element.getAttribute('hidden') !== null ||
+        element.getAttribute('aria-hidden') === 'true' ||
+        /\bdisplay\s*:\s*none\b/i.test(style) ||
+        /\bvisibility\s*:\s*hidden\b/i.test(style));
+}
+function hasNoiseRole(role) {
+    return role !== null && NAVIGATION_ROLES.has(role);
+}
+function tokenizeIdentifierLikeText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim()
+        .split(' ')
+        .filter(Boolean);
+}
+function matchesPromoIdOrClass(className, id) {
+    const tokens = tokenizeIdentifierLikeText(`${className} ${id}`);
+    return tokens.some((token) => PROMO_TOKENS.has(token));
+}
+function matchesHighZIsolate(className) {
+    return HIGH_Z_PATTERN.test(className) && ISOLATE_PATTERN.test(className);
+}
+function matchesFixedOrHighZIsolate(className) {
+    return FIXED_PATTERN.test(className) || matchesHighZIsolate(className);
+}
+function readElementMetadata(element) {
+    return {
+        tagName: element.tagName.toLowerCase(),
+        className: element.getAttribute('class') ?? '',
+        id: element.getAttribute('id') ?? '',
+        role: element.getAttribute('role'),
+        isHidden: isElementHidden(element),
+    };
+}
+function isBoilerplateHeader({ className, id, role, }) {
+    if (hasNoiseRole(role))
+        return true;
+    const combined = `${className} ${id}`.toLowerCase();
+    return HEADER_NOISE_PATTERN.test(combined);
+}
+function isNoiseElement(node) {
+    const metadata = readElementMetadata(node);
+    return (isStructuralNoiseTag(metadata.tagName) ||
+        ALWAYS_NOISE_TAGS.has(metadata.tagName) ||
+        (metadata.tagName === 'header' && isBoilerplateHeader(metadata)) ||
+        metadata.isHidden ||
+        hasNoiseRole(metadata.role) ||
+        matchesFixedOrHighZIsolate(metadata.className) ||
+        matchesPromoIdOrClass(metadata.className, metadata.id));
+}
+function stripNoiseNodes(document) {
+    const nodes = document.querySelectorAll('*');
+    for (let index = nodes.length - 1; index >= 0; index -= 1) {
+        const node = typeof nodes.item === 'function' ? nodes.item(index) : nodes[index];
+        if (!node)
+            continue;
+        if (isElement(node) && isNoiseElement(node)) {
+            node.remove();
+        }
+    }
+}
+function removeNoiseFromHtml(html) {
+    const shouldParse = isFullDocumentHtml(html) || mayContainNoise(html);
+    if (!shouldParse)
+        return html;
+    try {
+        const { document } = parseHTML(html);
+        stripNoiseNodes(document);
+        const bodyInnerHtml = getBodyInnerHtml(document);
+        if (bodyInnerHtml)
+            return bodyInnerHtml;
+        const docToString = getDocumentToString(document);
+        if (docToString)
+            return docToString();
+        const documentElementOuterHtml = getDocumentElementOuterHtml(document);
+        if (documentElementOuterHtml)
+            return documentElementOuterHtml;
+        return html;
+    }
+    catch {
+        return html;
+    }
+}
+function buildInlineCode(content) {
+    const runs = content.match(/`+/g);
+    const longest = runs?.sort((a, b) => b.length - a.length)[0] ?? '';
+    const delimiter = `\`${longest}`;
+    const padding = delimiter.length > 1 ? ' ' : '';
+    return `${delimiter}${padding}${content}${padding}${delimiter}`;
+}
+/**
+ * Derive alt text from an image URL by extracting and humanizing the filename.
+ * Used as a fallback when the image has no alt attribute.
+ */
+function deriveAltFromImageUrl(src) {
+    if (!src)
+        return '';
+    try {
+        // Handle both absolute and relative URLs.
+        const pathname = src.startsWith('http')
+            ? new URL(src).pathname
+            : (src.split('?')[0] ?? '');
+        // Extract filename from path.
+        const segments = pathname.split('/');
+        const filename = segments.pop() ?? '';
+        if (!filename)
+            return '';
+        // Remove file extension.
+        const dotIndex = filename.lastIndexOf('.');
+        const name = dotIndex > 0 ? filename.slice(0, dotIndex) : filename;
+        // Humanize: replace separators with spaces.
+        return name.replace(/[_-]+/g, ' ').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function isCodeBlock(parent) {
+    if (!isRecord(parent))
+        return false;
+    const tagName = typeof parent.tagName === 'string' ? parent.tagName.toUpperCase() : '';
+    return ['PRE', 'WRAPPED-PRE'].includes(tagName);
+}
+function hasGetAttribute(value) {
+    return isRecord(value) && typeof value.getAttribute === 'function';
+}
+function hasCodeBlockTranslators(value) {
+    return isRecord(value) && isRecord(value.codeBlockTranslators);
+}
+function buildInlineCodeTranslator() {
+    return {
+        spaceIfRepeatingChar: true,
+        noEscape: true,
+        postprocess: ({ content }) => buildInlineCode(content),
+    };
+}
+function resolveAttributeLanguage(node) {
+    const getAttribute = hasGetAttribute(node)
+        ? node.getAttribute.bind(node)
+        : undefined;
+    const className = getAttribute?.('class') ?? '';
+    const dataLanguage = getAttribute?.('data-language') ?? '';
+    return resolveLanguageFromAttributes(className, dataLanguage);
+}
+function resolveCodeBlockTranslators(visitor) {
+    const childTranslators = isRecord(visitor) ? visitor.instance : null;
+    return hasCodeBlockTranslators(childTranslators)
+        ? childTranslators.codeBlockTranslators
+        : null;
+}
+function buildCodeBlockTranslator(attributeLanguage, codeBlockTranslators) {
+    return {
+        noEscape: true,
+        preserveWhitespace: true,
+        ...(codeBlockTranslators
+            ? { childTranslators: codeBlockTranslators }
+            : null),
+        postprocess: ({ content }) => {
+            const language = attributeLanguage ?? detectLanguageFromCode(content) ?? '';
+            return CODE_BLOCK.format(content, language);
+        },
+    };
+}
+function buildCodeTranslator(ctx) {
+    if (!isRecord(ctx))
+        return buildInlineCodeTranslator();
+    const { node, parent, visitor } = ctx;
+    if (!isCodeBlock(parent))
+        return buildInlineCodeTranslator();
+    const attributeLanguage = resolveAttributeLanguage(node);
+    const codeBlockTranslators = resolveCodeBlockTranslators(visitor);
+    return buildCodeBlockTranslator(attributeLanguage, codeBlockTranslators);
+}
+function buildImageTranslator(ctx) {
+    if (!isRecord(ctx))
+        return { content: '' };
+    const { node } = ctx;
+    const getAttribute = hasGetAttribute(node)
+        ? node.getAttribute.bind(node)
+        : undefined;
+    const src = getAttribute?.('src') ?? '';
+    const existingAlt = getAttribute?.('alt') ?? '';
+    // Use existing alt text if present, otherwise derive from filename.
+    const alt = existingAlt.trim() || deriveAltFromImageUrl(src);
+    return {
+        content: `![${alt}](${src})`,
+    };
+}
+function createCustomTranslators() {
+    return {
+        code: (ctx) => buildCodeTranslator(ctx),
+        img: (ctx) => buildImageTranslator(ctx),
+    };
+}
+let markdownInstance = null;
+function createMarkdownInstance() {
+    return new NodeHtmlMarkdown({
+        codeFence: CODE_BLOCK.fence,
+        codeBlockStyle: 'fenced',
+        emDelimiter: '_',
+        bulletMarker: '-',
+    }, createCustomTranslators());
+}
+function getMarkdownConverter() {
+    markdownInstance ??= createMarkdownInstance();
+    return markdownInstance;
+}
+function translateHtmlToMarkdown(html, url, signal) {
+    throwIfAborted(signal, url, 'markdown:begin');
+    const cleanedHtml = runTransformStage(url, 'markdown:noise', () => removeNoiseFromHtml(html));
+    throwIfAborted(signal, url, 'markdown:cleaned');
+    const content = runTransformStage(url, 'markdown:translate', () => getMarkdownConverter().translate(cleanedHtml).trim());
+    throwIfAborted(signal, url, 'markdown:translated');
+    // Post-process the markdown to clean up common conversion artifacts.
+    return cleanupMarkdownArtifacts(content);
+}
+function appendMetadataFooter(content, metadata, url) {
+    // Metadata is placed as a footer to avoid duplicating titles when the
+    // article content already contains an H1 heading at the top.
+    const footer = buildMetadataFooter(metadata, url);
+    return footer ? `${content}\n\n${footer}` : content;
+}
+export function htmlToMarkdown(html, metadata, options) {
+    const url = options?.url ?? metadata?.url ?? '';
+    if (!html)
+        return buildMetadataFooter(metadata, url);
+    try {
+        const content = translateHtmlToMarkdown(html, url, options?.signal);
+        return appendMetadataFooter(content, metadata, url);
+    }
+    catch (error) {
+        if (error instanceof FetchError) {
+            throw error;
+        }
+        return buildMetadataFooter(metadata, url);
+    }
+}
+/**
+ * Clean up common markdown conversion artifacts:
+ * - Empty headings (e.g., "## " with no text)
+ * - Anchor-only links like [ ](#section-id) used for navigation
+ * - Concatenated links without spacing
+ * - Boilerplate phrases like "Was this page helpful?"
+ */
+function cleanupMarkdownArtifacts(content) {
+    let result = content;
+    // Remove empty Markdown headings like "## " produced by placeholder nodes.
+    result = result.replace(/^#{1,6}[ \t\u00A0]*$\r?\n?/gm, '');
+    // Remove anchor-only links like [\u200B](#section-id) or [ ](#anchor).
+    // These are navigation remnants with zero-width or whitespace text.
+    // Match: [ or whitespace or zero-width space ](#...)
+    const zeroWidthAnchorLink = /\[(?:\s|\u200B)*\]\(#[^)]*\)\s*/g;
+    result = result.replace(zeroWidthAnchorLink, '');
+    // Add line breaks between concatenated links: ](url)[text] -> ](url)\n\n[text]
+    result = result.replace(/\]\(([^)]+)\)\[/g, ']($1)\n\n[');
+    // Remove common boilerplate phrases.
+    result = result.replace(/^Was this page helpful\??\s*$/gim, '');
+    // Collapse multiple blank lines into at most two.
+    result = result.replace(/\n{3,}/g, '\n\n');
+    return result.trim();
+}
+function buildMetadataFooter(metadata, fallbackUrl) {
+    if (!metadata)
+        return '';
+    const lines = [];
+    // Horizontal rule as a clear footer separator.
+    lines.push('---');
+    if (metadata.title)
+        lines.push(`**Title:** ${metadata.title}`);
+    if (metadata.description)
+        lines.push(`**Description:** ${metadata.description}`);
+    if (metadata.author)
+        lines.push(`**Author:** ${metadata.author}`);
+    if (metadata.url)
+        lines.push(`**Source:** ${metadata.url}`);
+    else if (fallbackUrl)
+        lines.push(`**Source:** ${fallbackUrl}`);
+    if (metadata.fetchedAt)
+        lines.push(`**Fetched:** ${metadata.fetchedAt}`);
+    return lines.join('\n');
+}
+const HEADING_PATTERN = /^#{1,6}\s/m;
+const LIST_PATTERN = /^(?:[-*+])\s/m;
+const HTML_DOCUMENT_PATTERN = /^(<!doctype|<html)/i;
+function containsMarkdownHeading(content) {
+    return HEADING_PATTERN.test(content);
+}
+function containsMarkdownList(content) {
+    return LIST_PATTERN.test(content);
+}
+function containsFencedCodeBlock(content) {
+    const first = content.indexOf('```');
+    if (first === -1)
+        return false;
+    return content.includes('```', first + 3);
+}
+function looksLikeMarkdown(content) {
+    return (containsMarkdownHeading(content) ||
+        containsMarkdownList(content) ||
+        containsFencedCodeBlock(content));
+}
+function detectLineEnding(content) {
+    return content.includes('\r\n') ? '\r\n' : '\n';
+}
+const FRONTMATTER_DELIMITER = '---';
+function findFrontmatterLines(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    if (lines[0] !== FRONTMATTER_DELIMITER)
+        return null;
+    const endIndex = lines.indexOf(FRONTMATTER_DELIMITER, 1);
+    if (endIndex === -1)
+        return null;
+    return { lineEnding, lines, endIndex };
+}
+function stripOptionalQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function parseFrontmatterEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const separatorIndex = trimmed.indexOf(':');
+    if (separatorIndex <= 0)
+        return null;
+    const key = trimmed.slice(0, separatorIndex).trim().toLowerCase();
+    const value = trimmed.slice(separatorIndex + 1);
+    return { key, value };
+}
+function isTitleKey(key) {
+    return key === 'title' || key === 'name';
+}
+function extractTitleFromHeading(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let index = 0;
+        while (index < trimmed.length && trimmed[index] === '#') {
+            index += 1;
+        }
+        if (index === 0 || index > 6)
+            return undefined;
+        const nextChar = trimmed[index];
+        if (nextChar !== ' ' && nextChar !== '\t')
+            return undefined;
+        const heading = trimmed.slice(index).trim();
+        return heading.length > 0 ? heading : undefined;
+    }
+    return undefined;
+}
+function extractTitleFromRawMarkdown(content) {
+    const frontmatter = findFrontmatterLines(content);
+    if (!frontmatter) {
+        return extractTitleFromHeading(content);
+    }
+    const { lines, endIndex } = frontmatter;
+    const entry = lines
+        .slice(1, endIndex)
+        .map((line) => parseFrontmatterEntry(line))
+        .find((parsed) => parsed !== null && isTitleKey(parsed.key));
+    if (!entry)
+        return undefined;
+    const value = stripOptionalQuotes(entry.value);
+    return value || undefined;
+}
+function hasMarkdownSourceLine(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    // Only scan a small prefix to avoid wasting time on huge docs.
+    const limit = Math.min(lines.length, 50);
+    for (let index = 0; index < limit; index += 1) {
+        const line = lines[index];
+        if (!line)
+            continue;
+        if (line.trimStart().toLowerCase().startsWith('source:')) {
+            return true;
+        }
+    }
+    return false;
+}
+function addSourceToMarkdownMarkdownFormat(content, url) {
+    if (hasMarkdownSourceLine(content))
+        return content;
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
+    if (firstNonEmptyIndex !== -1) {
+        const firstLine = lines[firstNonEmptyIndex];
+        if (firstLine && /^#{1,6}\s+/.test(firstLine.trim())) {
+            const insertAt = firstNonEmptyIndex + 1;
+            const updated = [
+                ...lines.slice(0, insertAt),
+                '',
+                `Source: ${url}`,
+                '',
+                ...lines.slice(insertAt),
+            ];
+            return updated.join(lineEnding);
+        }
+    }
+    return [`Source: ${url}`, '', content].join(lineEnding);
+}
+function addSourceToMarkdown(content, url) {
+    const frontmatter = findFrontmatterLines(content);
+    if (config.transform.metadataFormat === 'markdown' && !frontmatter) {
+        return addSourceToMarkdownMarkdownFormat(content, url);
+    }
+    if (!frontmatter) {
+        return `---\nsource: "${url}"\n---\n\n${content}`;
+    }
+    const { lineEnding, lines, endIndex } = frontmatter;
+    const bodyLines = lines.slice(1, endIndex);
+    const hasSource = bodyLines.some((line) => line.trimStart().toLowerCase().startsWith('source:'));
+    if (hasSource)
+        return content;
+    const updatedLines = [
+        lines[0],
+        ...bodyLines,
+        `source: "${url}"`,
+        ...lines.slice(endIndex),
+    ];
+    return updatedLines.join(lineEnding);
+}
+function hasFrontmatter(trimmed) {
+    return trimmed.startsWith('---\n') || trimmed.startsWith('---\r\n');
+}
+function looksLikeHtmlDocument(trimmed) {
+    return HTML_DOCUMENT_PATTERN.test(trimmed);
+}
+function countCommonHtmlTags(content) {
+    const matches = content.match(/<(html|head|body|div|span|script|style|meta|link)\b/gi) ??
+        [];
+    return matches.length;
+}
+function isRawTextContent(content) {
+    const trimmed = content.trim();
+    const isHtmlDocument = looksLikeHtmlDocument(trimmed);
+    const hasMarkdownFrontmatter = hasFrontmatter(trimmed);
+    const hasTooManyHtmlTags = countCommonHtmlTags(content) > 2;
+    const isMarkdown = looksLikeMarkdown(content);
+    return (!isHtmlDocument &&
+        (hasMarkdownFrontmatter || (!hasTooManyHtmlTags && isMarkdown)));
+}
+function isLikelyHtmlContent(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return false;
+    if (looksLikeHtmlDocument(trimmed))
+        return true;
+    return countCommonHtmlTags(content) > 2;
+}
+function shouldPreserveRawContent(url, content) {
+    if (isRawTextContentUrl(url)) {
+        return !isLikelyHtmlContent(content);
+    }
+    return isRawTextContent(content);
+}
+function buildRawMarkdownPayload({ rawContent, url, includeMetadata, }) {
+    const title = extractTitleFromRawMarkdown(rawContent);
+    const content = includeMetadata
+        ? addSourceToMarkdown(rawContent, url)
+        : rawContent;
+    return { content, title };
+}
+function tryTransformRawContent({ html, url, includeMetadata, }) {
+    if (!shouldPreserveRawContent(url, html)) {
+        return null;
+    }
+    logDebug('Preserving raw markdown content', { url: url.substring(0, 80) });
+    const { content, title } = buildRawMarkdownPayload({
+        rawContent: html,
+        url,
+        includeMetadata,
+    });
+    return {
+        markdown: content,
+        title,
+        truncated: false,
+    };
+}
+const MIN_CONTENT_RATIO = 0.3;
+const MIN_HTML_LENGTH_FOR_GATE = 100;
+function stripHtmlTags(html) {
+    const parts = [];
+    let inTag = false;
+    for (const char of html) {
+        if (char === '<') {
+            inTag = true;
+            continue;
+        }
+        if (char === '>') {
+            inTag = false;
+            continue;
+        }
+        if (!inTag) {
+            parts.push(char);
+        }
+    }
+    return parts.join('');
+}
+function estimateTextLength(html) {
+    return stripHtmlTags(html).replace(/\s+/g, ' ').trim().length;
+}
+export function isExtractionSufficient(article, originalHtml) {
+    if (!article)
+        return false;
+    const articleLength = article.textContent.length;
+    const originalLength = estimateTextLength(originalHtml);
+    if (originalLength < MIN_HTML_LENGTH_FOR_GATE)
+        return true;
+    return articleLength / originalLength >= MIN_CONTENT_RATIO;
+}
+export function determineContentExtractionSource(article) {
+    return !!article;
+}
+function applyArticleMetadata(metadata, article) {
+    if (article.title !== undefined)
+        metadata.title = article.title;
+    if (article.byline !== undefined)
+        metadata.author = article.byline;
+}
+function applyExtractedMetadata(metadata, extractedMeta) {
+    if (extractedMeta.title !== undefined)
+        metadata.title = extractedMeta.title;
+    if (extractedMeta.description !== undefined) {
+        metadata.description = extractedMeta.description;
+    }
+    if (extractedMeta.author !== undefined) {
+        metadata.author = extractedMeta.author;
+    }
+}
+export function createContentMetadataBlock(url, article, extractedMeta, shouldExtractFromArticle, includeMetadata) {
+    if (!includeMetadata)
+        return undefined;
+    const now = new Date().toISOString();
+    const metadata = {
+        type: 'metadata',
+        url,
+        fetchedAt: now,
+    };
+    if (shouldExtractFromArticle && article) {
+        applyArticleMetadata(metadata, article);
+        return metadata;
+    }
+    applyExtractedMetadata(metadata, extractedMeta);
+    return metadata;
+}
+function buildContentSource({ html, url, article, extractedMeta, includeMetadata, useArticleContent, }) {
+    const metadata = createContentMetadataBlock(url, article, extractedMeta, useArticleContent, includeMetadata);
+    return {
+        sourceHtml: useArticleContent && article ? article.content : html,
+        title: useArticleContent && article ? article.title : extractedMeta.title,
+        metadata,
+    };
+}
+function logQualityGateFallback({ url, articleLength, }) {
+    logDebug('Quality gate: Readability extraction below threshold, using full HTML', {
+        url: url.substring(0, 80),
+        articleLength,
+    });
+}
+function shouldUseArticleContent(article, html, url) {
+    const shouldExtractFromArticle = determineContentExtractionSource(article);
+    if (!shouldExtractFromArticle)
+        return false;
+    if (isExtractionSufficient(article, html)) {
+        return true;
+    }
+    logQualityGateFallback({
+        url,
+        articleLength: article.textContent.length,
+    });
+    return false;
+}
+function resolveContentSource({ html, url, includeMetadata, signal, }) {
+    const { article, metadata: extractedMeta } = extractContent(html, url, {
+        extractArticle: true,
+        ...(signal ? { signal } : {}),
+    });
+    const useArticleContent = article
+        ? shouldUseArticleContent(article, html, url)
+        : false;
+    return buildContentSource({
+        html,
+        url,
+        article,
+        extractedMeta,
+        includeMetadata,
+        useArticleContent,
+    });
+}
+function tryTransformRawStage(html, url, includeMetadata) {
+    return runTransformStage(url, 'transform:raw', () => tryTransformRawContent({
+        html,
+        url,
+        includeMetadata,
+    }));
+}
+function resolveContentSourceStage(html, url, includeMetadata, signal) {
+    return runTransformStage(url, 'transform:extract', () => resolveContentSource({
+        html,
+        url,
+        includeMetadata,
+        ...(signal ? { signal } : {}),
+    }));
+}
+function buildMarkdownFromContext(context, url, signal) {
+    const content = runTransformStage(url, 'transform:markdown', () => htmlToMarkdown(context.sourceHtml, context.metadata, {
+        url,
+        ...(signal ? { signal } : {}),
+    }));
+    return {
+        markdown: content,
+        title: context.title,
+        truncated: false,
+    };
+}
+function runTotalTransformStage(url, fn) {
+    const totalStage = startTransformStage(url, 'transform:total');
+    let success = false;
+    try {
+        const result = fn();
+        success = true;
+        return result;
+    }
+    finally {
+        if (success) {
+            endTransformStage(totalStage, { truncated: false });
+        }
+    }
+}
+async function runTotalTransformStageAsync(url, fn) {
+    const totalStage = startTransformStage(url, 'transform:total');
+    let success = false;
+    try {
+        const result = await fn();
+        success = true;
+        return result;
+    }
+    finally {
+        if (success) {
+            endTransformStage(totalStage, { truncated: false });
+        }
+    }
+}
+export function transformHtmlToMarkdownInProcess(html, url, options) {
+    return runTotalTransformStage(url, () => {
+        throwIfAborted(options.signal, url, 'transform:begin');
+        const raw = tryTransformRawStage(html, url, options.includeMetadata);
+        if (raw) {
+            return raw;
+        }
+        const context = resolveContentSourceStage(html, url, options.includeMetadata, options.signal);
+        return buildMarkdownFromContext(context, url, options.signal);
+    });
+}
+const workerMessageSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('result'),
+        id: z.string(),
+        result: z.object({
+            markdown: z.string(),
+            title: z.string().optional(),
+            truncated: z.boolean(),
+        }),
+    }),
+    z.object({
+        type: z.literal('error'),
+        id: z.string(),
+        error: z.object({
+            name: z.string(),
+            message: z.string(),
+            url: z.string(),
+            statusCode: z.number().optional(),
+            details: z.record(z.string(), z.unknown()).optional(),
+        }),
+    }),
+]);
+let pool = null;
+function resolveDefaultWorkerCount() {
+    const parallelism = typeof os.availableParallelism === 'function'
+        ? os.availableParallelism()
+        : os.cpus().length;
+    return Math.min(16, Math.max(1, parallelism - 1));
+}
+const DEFAULT_TIMEOUT_MS = config.transform.timeoutMs;
+function getOrCreateTransformWorkerPool() {
+    pool ??= new WorkerPool(resolveDefaultWorkerCount(), DEFAULT_TIMEOUT_MS);
+    return pool;
+}
+export async function shutdownTransformWorkerPool() {
+    if (!pool)
+        return;
+    await pool.close();
+    pool = null;
+}
+class WorkerPool {
+    workers = [];
+    queue = [];
+    inflight = new Map();
+    timeoutMs;
+    queueMax;
+    closed = false;
+    ensureOpen() {
+        if (this.closed) {
+            throw new Error('Transform worker pool closed');
+        }
+    }
+    ensureNotAborted(signal, url, stage) {
+        if (!signal?.aborted)
+            return;
+        throw new FetchError('Request was canceled', url, 499, {
+            reason: 'aborted',
+            stage,
+        });
+    }
+    ensureQueueCapacity(url) {
+        if (this.queue.length < this.queueMax)
+            return;
+        throw new FetchError('Transform worker queue is full', url, 503, {
+            reason: 'queue_full',
+            stage: 'transform:enqueue',
+        });
+    }
+    clearAbortListener(signal, listener) {
+        if (!signal || !listener)
+            return;
+        try {
+            signal.removeEventListener('abort', listener);
+        }
+        catch {
+            // ignore
+        }
+    }
+    markSlotIdle(workerIndex) {
+        const slot = this.workers[workerIndex];
+        if (!slot)
+            return;
+        slot.busy = false;
+        slot.currentTaskId = null;
+    }
+    takeInflight(id) {
+        const inflight = this.inflight.get(id);
+        if (!inflight)
+            return null;
+        clearTimeout(inflight.timer);
+        this.clearAbortListener(inflight.signal, inflight.abortListener);
+        this.inflight.delete(id);
+        return inflight;
+    }
+    cancelWorkerTask(slot, id) {
+        if (!slot)
+            return;
+        try {
+            slot.worker.postMessage({ type: 'cancel', id });
+        }
+        catch {
+            // ignore
+        }
+    }
+    restartWorker(workerIndex, slot) {
+        if (this.closed)
+            return;
+        const target = slot ?? this.workers[workerIndex];
+        if (target) {
+            void target.worker.terminate();
+        }
+        this.workers[workerIndex] = this.spawnWorker(workerIndex);
+        this.drainQueue();
+    }
+    rejectIfClosed(reject) {
+        if (!this.closed)
+            return false;
+        reject(new Error('Transform worker pool closed'));
+        return true;
+    }
+    abortInflightTask(id, url, workerIndex) {
+        const slot = this.workers[workerIndex];
+        this.cancelWorkerTask(slot, id);
+        this.failTask(id, new FetchError('Request was canceled', url, 499, {
+            reason: 'aborted',
+            stage: 'transform:signal-abort',
+        }));
+        if (slot) {
+            this.restartWorker(workerIndex, slot);
+        }
+    }
+    abortQueuedTask(id, url, reject) {
+        const queuedIndex = this.queue.findIndex((task) => task.id === id);
+        if (queuedIndex === -1)
+            return;
+        this.queue.splice(queuedIndex, 1);
+        reject(new FetchError('Request was canceled', url, 499, {
+            reason: 'aborted',
+            stage: 'transform:queued-abort',
+        }));
+    }
+    createWorkerSlot(worker) {
+        return {
+            worker,
+            busy: false,
+            currentTaskId: null,
+        };
+    }
+    registerWorkerHandlers(workerIndex, worker) {
+        worker.on('message', (raw) => {
+            this.onWorkerMessage(workerIndex, raw);
+        });
+        worker.on('error', (error) => {
+            this.onWorkerBroken(workerIndex, `Transform worker error: ${getErrorMessage(error)}`);
+        });
+        worker.on('exit', (code) => {
+            this.onWorkerBroken(workerIndex, `Transform worker exited (code ${code})`);
+        });
+    }
+    constructor(size, timeoutMs) {
+        const safeSize = Math.max(1, size);
+        this.timeoutMs = timeoutMs;
+        this.queueMax = safeSize * 2;
+        for (let index = 0; index < safeSize; index += 1) {
+            this.workers.push(this.spawnWorker(index));
+        }
+    }
+    spawnWorker(workerIndex) {
+        const worker = new Worker(new URL('./workers/transform-worker.js', import.meta.url));
+        // Workers must not keep the process alive by themselves.
+        worker.unref();
+        const slot = this.createWorkerSlot(worker);
+        this.registerWorkerHandlers(workerIndex, worker);
+        return slot;
+    }
+    onWorkerBroken(workerIndex, message) {
+        if (this.closed)
+            return;
+        const slot = this.workers[workerIndex];
+        if (!slot)
+            return;
+        if (slot.busy && slot.currentTaskId) {
+            this.failTask(slot.currentTaskId, new Error(message));
+        }
+        this.restartWorker(workerIndex, slot);
+    }
+    resolveWorkerResult(inflight, result) {
+        inflight.resolve({
+            markdown: result.markdown,
+            truncated: result.truncated,
+            title: result.title,
+        });
+    }
+    rejectWorkerError(inflight, error) {
+        if (error.name === 'FetchError') {
+            inflight.reject(new FetchError(error.message, error.url, error.statusCode, error.details ?? {}));
+            return;
+        }
+        inflight.reject(new Error(error.message));
+    }
+    onWorkerMessage(workerIndex, raw) {
+        const parsed = workerMessageSchema.safeParse(raw);
+        if (!parsed.success)
+            return;
+        const message = parsed.data;
+        const inflight = this.takeInflight(message.id);
+        if (!inflight)
+            return;
+        this.markSlotIdle(workerIndex);
+        if (message.type === 'result') {
+            this.resolveWorkerResult(inflight, message.result);
+        }
+        else {
+            this.rejectWorkerError(inflight, message.error);
+        }
+        this.drainQueue();
+    }
+    failTask(id, error) {
+        const inflight = this.takeInflight(id);
+        if (!inflight)
+            return;
+        inflight.reject(error);
+        this.markSlotIdle(inflight.workerIndex);
+    }
+    handleAbortSignal(id, url, reject) {
+        if (this.rejectIfClosed(reject))
+            return;
+        const inflight = this.inflight.get(id);
+        if (inflight) {
+            this.abortInflightTask(id, url, inflight.workerIndex);
+            return;
+        }
+        this.abortQueuedTask(id, url, reject);
+    }
+    createPendingTask(html, url, options, resolve, reject) {
+        const id = randomUUID();
+        let abortListener;
+        if (options.signal) {
+            abortListener = () => {
+                this.handleAbortSignal(id, url, reject);
+            };
+            options.signal.addEventListener('abort', abortListener, { once: true });
+        }
+        return {
+            id,
+            html,
+            url,
+            includeMetadata: options.includeMetadata,
+            signal: options.signal,
+            abortListener,
+            resolve,
+            reject,
+        };
+    }
+    async transform(html, url, options) {
+        this.ensureOpen();
+        this.ensureNotAborted(options.signal, url, 'transform:enqueue');
+        this.ensureQueueCapacity(url);
+        return new Promise((resolve, reject) => {
+            const task = this.createPendingTask(html, url, options, resolve, reject);
+            this.queue.push(task);
+            this.drainQueue();
+        });
+    }
+    drainQueue() {
+        if (this.queue.length === 0)
+            return;
+        for (let workerIndex = 0; workerIndex < this.workers.length; workerIndex += 1) {
+            const slot = this.workers[workerIndex];
+            if (!slot || slot.busy)
+                continue;
+            const task = this.queue.shift();
+            if (!task)
+                return;
+            this.dispatch(workerIndex, slot, task);
+            if (this.queue.length === 0)
+                return;
+        }
+    }
+    dispatch(workerIndex, slot, task) {
+        if (this.rejectIfAborted(task))
+            return;
+        this.markSlotBusy(slot, task);
+        const timer = this.startTaskTimer(workerIndex, slot, task);
+        this.registerInflightTask(task, timer, workerIndex);
+        try {
+            this.sendTransformMessage(slot, task);
+        }
+        catch (error) {
+            this.handleDispatchFailure(workerIndex, slot, task, timer, error);
+        }
+    }
+    rejectIfAborted(task) {
+        if (!task.signal?.aborted)
+            return false;
+        this.clearAbortListener(task.signal, task.abortListener);
+        task.reject(new FetchError('Request was canceled', task.url, 499, {
+            reason: 'aborted',
+            stage: 'transform:dispatch',
+        }));
+        return true;
+    }
+    markSlotBusy(slot, task) {
+        slot.busy = true;
+        slot.currentTaskId = task.id;
+    }
+    startTaskTimer(workerIndex, slot, task) {
+        const timer = setTimeout(() => {
+            this.cancelWorkerTask(slot, task.id);
+            const inflight = this.takeInflight(task.id);
+            if (!inflight)
+                return;
+            inflight.reject(new FetchError('Request timeout', task.url, 504, {
+                reason: 'timeout',
+                stage: 'transform:worker-timeout',
+            }));
+            this.restartWorker(workerIndex, slot);
+        }, this.timeoutMs);
+        timer.unref();
+        return timer;
+    }
+    registerInflightTask(task, timer, workerIndex) {
+        this.inflight.set(task.id, {
+            resolve: task.resolve,
+            reject: task.reject,
+            timer,
+            signal: task.signal,
+            abortListener: task.abortListener,
+            workerIndex,
+        });
+    }
+    sendTransformMessage(slot, task) {
+        slot.worker.postMessage({
+            type: 'transform',
+            id: task.id,
+            html: task.html,
+            url: task.url,
+            includeMetadata: task.includeMetadata,
+        });
+    }
+    handleDispatchFailure(workerIndex, slot, task, timer, error) {
+        clearTimeout(timer);
+        this.clearAbortListener(task.signal, task.abortListener);
+        this.inflight.delete(task.id);
+        this.markSlotIdle(workerIndex);
+        const message = error instanceof Error
+            ? error
+            : new Error('Failed to dispatch transform worker message');
+        task.reject(message);
+        this.restartWorker(workerIndex, slot);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const terminations = this.workers.map((slot) => slot.worker.terminate());
+        this.workers.length = 0;
+        for (const [id, inflight] of this.inflight.entries()) {
+            clearTimeout(inflight.timer);
+            this.clearAbortListener(inflight.signal, inflight.abortListener);
+            inflight.reject(new Error('Transform worker pool closed'));
+            this.inflight.delete(id);
+        }
+        for (const task of this.queue) {
+            task.reject(new Error('Transform worker pool closed'));
+        }
+        this.queue.length = 0;
+        await Promise.allSettled(terminations);
+    }
+}
+function buildWorkerTransformOptions(options) {
+    return {
+        includeMetadata: options.includeMetadata,
+        ...(options.signal ? { signal: options.signal } : {}),
+    };
+}
+async function transformWithWorkerPool(html, url, options) {
+    const poolRef = getOrCreateTransformWorkerPool();
+    return poolRef.transform(html, url, buildWorkerTransformOptions(options));
+}
+function resolveWorkerFallback(error, html, url, options) {
+    if (error instanceof FetchError) {
+        throw error;
+    }
+    // Stability-first: if worker infrastructure fails, fall back to in-process.
+    throwIfAborted(options.signal, url, 'transform:worker-fallback');
+    return transformHtmlToMarkdownInProcess(html, url, options);
+}
+export async function transformHtmlToMarkdown(html, url, options) {
+    return runTotalTransformStageAsync(url, async () => {
+        throwIfAborted(options.signal, url, 'transform:begin');
+        const workerStage = startTransformStage(url, 'transform:worker');
+        try {
+            const result = await transformWithWorkerPool(html, url, options);
+            return result;
+        }
+        catch (error) {
+            const fallback = resolveWorkerFallback(error, html, url, options);
+            return fallback;
+        }
+        finally {
+            endTransformStage(workerStage);
+        }
+    });
+}