@j0hanz/superfetch 2.2.2 → 2.4.0

package/dist/mcp-validator.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+// --- Validation ---
+const paramsSchema = z.looseObject({});
+const mcpRequestSchema = z.looseObject({
+    jsonrpc: z.literal('2.0'),
+    method: z.string().min(1),
+    id: z.union([z.string(), z.number(), z.null()]).optional(),
+    params: paramsSchema.optional(),
+});
+export function isJsonRpcBatchRequest(body) {
+    return Array.isArray(body);
+}
+export function isMcpRequestBody(body) {
+    return mcpRequestSchema.safeParse(body).success;
+}
+export function acceptsEventStream(header) {
+    if (!header)
+        return false;
+    return header
+        .split(',')
+        .some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
+}

package/dist/mcp.d.ts

@@ -1,4 +1,3 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function createMcpServer(): McpServer;
 export declare function startStdioServer(): Promise<void>;
-//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.js

@@ -4,37 +4,47 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { registerCachedContentResource } from './cache.js';
 import { config } from './config.js';
 import { destroyAgents } from './fetch.js';
-import { logError, logInfo } from './observability.js';
+import { logError, logInfo, setMcpServer } from './observability.js';
 import { registerTools } from './tools.js';
 import { shutdownTransformWorkerPool } from './transform.js';
+function getLocalIconData() {
+    try {
+        const iconPath = new URL('../assets/logo.svg', import.meta.url);
+        const buffer = readFileSync(iconPath);
+        return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 function createServerInfo() {
+    const localIcon = getLocalIconData();
     return {
         name: config.server.name,
         version: config.server.version,
+        ...(localIcon ? { icons: [{ src: localIcon, sizes: ['any'] }] } : {}),
     };
 }
 function createServerCapabilities() {
     return {
         tools: { listChanged: true },
         resources: { listChanged: true, subscribe: true },
+        logging: {},
     };
 }
 function createServerInstructions(serverVersion) {
     try {
-        const raw = readFileSync(new URL('./instructions.md', import.meta.url), {
-            encoding: 'utf8',
-        });
-        const resolved = raw.replaceAll('{{SERVER_VERSION}}', serverVersion);
-        return resolved.trim();
+        const raw = readFileSync(new URL('./instructions.md', import.meta.url), 'utf8');
+        return raw.replaceAll('{{SERVER_VERSION}}', serverVersion).trim();
     }
     catch {
-        return `superFetch MCP server |${serverVersion}| A high-performance web content fetching and processing server.`;
+        return `Instructions unavailable | ${serverVersion}`;
     }
 }
 function registerInstructionsResource(server, instructions) {
     server.registerResource('instructions', new ResourceTemplate('internal://instructions', { list: undefined }), {
-        title: 'Server Instructions',
-        description: 'Usage guidance for the superFetch MCP server.',
+        title: `SuperFetch MCP | ${config.server.version}`,
+        description: 'Guidance for using the superFetch MCP server.',
         mimeType: 'text/markdown',
     }, (uri) => ({
         contents: [
@@ -52,6 +62,7 @@ export function createMcpServer() {
         capabilities: createServerCapabilities(),
         instructions,
     });
+    setMcpServer(server);
     registerTools(server);
     registerCachedContentResource(server);
     registerInstructionsResource(server, instructions);
@@ -118,4 +129,3 @@ export async function startStdioServer() {
     registerSignalHandlers(createShutdownHandler(server));
     await connectStdioServer(server, transport);
 }
-//# sourceMappingURL=mcp.js.map

package/dist/observability.d.ts

@@ -1,9 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export type LogMetadata = Record<string, unknown>;
 interface RequestContext {
     readonly requestId: string;
     readonly sessionId?: string;
     readonly operationId?: string;
 }
+export declare function setMcpServer(server: McpServer): void;
 export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
 export declare function getRequestId(): string | undefined;
 export declare function getSessionId(): string | undefined;
@@ -15,4 +17,3 @@ export declare function logError(message: string, error?: Error | LogMetadata):
 export declare function redactUrl(rawUrl: string): string;
 export declare function redactHeaders(headers: Record<string, unknown>): Record<string, unknown>;
 export {};
-//# sourceMappingURL=observability.d.ts.map

package/dist/observability.js

@@ -1,6 +1,10 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { config } from './config.js';
 const requestContext = new AsyncLocalStorage();
+let mcpServer;
+export function setMcpServer(server) {
+    mcpServer = server;
+}
 export function runWithRequestContext(context, fn) {
     return requestContext.run(context, fn);
 }
@@ -13,7 +17,7 @@ export function getSessionId() {
 export function getOperationId() {
     return requestContext.getStore()?.operationId;
 }
-function formatMetadata(meta) {
+function buildContextMetadata() {
     const requestId = getRequestId();
     const sessionId = getSessionId();
     const operationId = getOperationId();
@@ -24,7 +28,10 @@ function formatMetadata(meta) {
         contextMeta.sessionId = sessionId;
     if (operationId)
         contextMeta.operationId = operationId;
-    const merged = { ...contextMeta, ...meta };
+    return contextMeta;
+}
+function formatMetadata(meta) {
+    const merged = { ...buildContextMetadata(), ...meta };
     return Object.keys(merged).length > 0 ? ` ${JSON.stringify(merged)}` : '';
 }
 function createTimestamp() {
@@ -40,10 +47,31 @@ function shouldLog(level) {
     // All other levels always log
     return true;
 }
+function mapToMcpLevel(level) {
+    switch (level) {
+        case 'warn':
+            return 'warning';
+        case 'error':
+            return 'error';
+        case 'debug':
+            return 'debug';
+        case 'info':
+        default:
+            return 'info';
+    }
+}
 function writeLog(level, message, meta) {
     if (!shouldLog(level))
         return;
     process.stderr.write(`${formatLogEntry(level, message, meta)}\n`);
+    if (mcpServer) {
+        mcpServer.server
+            .sendLoggingMessage({
+            level: mapToMcpLevel(level),
+            data: meta ? { message, ...meta } : message,
+        })
+            .catch(() => { });
+    }
 }
 export function logInfo(message, meta) {
     writeLog('info', message, meta);
@@ -83,4 +111,3 @@ export function redactHeaders(headers) {
     }
     return redacted;
 }
-//# sourceMappingURL=observability.js.map

package/dist/server-tuning.d.ts

@@ -0,0 +1,9 @@
+export interface HttpServerTuningTarget {
+    headersTimeout?: number;
+    requestTimeout?: number;
+    keepAliveTimeout?: number;
+    closeIdleConnections?: () => void;
+    closeAllConnections?: () => void;
+}
+export declare function applyHttpServerTuning(server: HttpServerTuningTarget): void;
+export declare function drainConnectionsOnShutdown(server: HttpServerTuningTarget): void;

package/dist/server-tuning.js

@@ -0,0 +1,30 @@
+import { config } from './config.js';
+import { logDebug } from './observability.js';
+export function applyHttpServerTuning(server) {
+    const { headersTimeoutMs, requestTimeoutMs, keepAliveTimeoutMs } = config.server.http;
+    if (headersTimeoutMs !== undefined) {
+        server.headersTimeout = headersTimeoutMs;
+    }
+    if (requestTimeoutMs !== undefined) {
+        server.requestTimeout = requestTimeoutMs;
+    }
+    if (keepAliveTimeoutMs !== undefined) {
+        server.keepAliveTimeout = keepAliveTimeoutMs;
+    }
+}
+export function drainConnectionsOnShutdown(server) {
+    const { shutdownCloseAllConnections, shutdownCloseIdleConnections } = config.server.http;
+    if (shutdownCloseAllConnections) {
+        if (typeof server.closeAllConnections === 'function') {
+            server.closeAllConnections();
+            logDebug('Closed all HTTP connections during shutdown');
+        }
+        return;
+    }
+    if (shutdownCloseIdleConnections) {
+        if (typeof server.closeIdleConnections === 'function') {
+            server.closeIdleConnections();
+            logDebug('Closed idle HTTP connections during shutdown');
+        }
+    }
+}

package/dist/{http-utils.d.ts → session.d.ts}

@@ -1,15 +1,4 @@
 import type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-export type JsonRpcId = string | number | null;
-export interface McpRequestParams {
-    _meta?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface McpRequestBody {
-    jsonrpc: '2.0';
-    method: string;
-    id?: JsonRpcId;
-    params?: McpRequestParams;
-}
 export interface SessionEntry {
     readonly transport: StreamableHTTPServerTransport;
     createdAt: number;
@@ -34,14 +23,10 @@ export interface SlotTracker {
     readonly markInitialized: () => void;
     readonly isInitialized: () => boolean;
 }
-export declare function normalizeHost(value: string): string | null;
 export type CloseHandler = (() => void) | undefined;
 export declare function composeCloseHandlers(first: CloseHandler, second: CloseHandler): CloseHandler;
 export declare function startSessionCleanupLoop(store: SessionStore, sessionTtlMs: number): AbortController;
 export declare function createSessionStore(sessionTtlMs: number): SessionStore;
-export declare function isJsonRpcBatchRequest(body: unknown): boolean;
-export declare function isMcpRequestBody(body: unknown): body is McpRequestBody;
-export declare function acceptsEventStream(header: string | null | undefined): boolean;
 export declare function createSlotTracker(store: SessionStore): SlotTracker;
 export declare function reserveSessionSlot(store: SessionStore, maxSessions: number): boolean;
 export declare function ensureSessionCapacity({ store, maxSessions, evictOldest, }: {
@@ -49,13 +34,3 @@ export declare function ensureSessionCapacity({ store, maxSessions, evictOldest,
     maxSessions: number;
     evictOldest: (store: SessionStore) => boolean;
 }): boolean;
-export interface HttpServerTuningTarget {
-    headersTimeout?: number;
-    requestTimeout?: number;
-    keepAliveTimeout?: number;
-    closeIdleConnections?: () => void;
-    closeAllConnections?: () => void;
-}
-export declare function applyHttpServerTuning(server: HttpServerTuningTarget): void;
-export declare function drainConnectionsOnShutdown(server: HttpServerTuningTarget): void;
-//# sourceMappingURL=http-utils.d.ts.map

package/dist/{http-utils.js → session.js}

@@ -1,55 +1,5 @@
-import { isIP } from 'node:net';
 import { setInterval as setIntervalPromise } from 'node:timers/promises';
-import { z } from 'zod';
-import { config } from './config.js';
-import { logDebug, logInfo, logWarn } from './observability.js';
-// --- Host Normalization ---
-export function normalizeHost(value) {
-    const trimmed = value.trim().toLowerCase();
-    if (!trimmed)
-        return null;
-    const first = takeFirstHostValue(trimmed);
-    if (!first)
-        return null;
-    const ipv6 = stripIpv6Brackets(first);
-    if (ipv6)
-        return stripTrailingDots(ipv6);
-    if (isIpV6Literal(first)) {
-        return stripTrailingDots(first);
-    }
-    return stripTrailingDots(stripPortIfPresent(first));
-}
-function takeFirstHostValue(value) {
-    const first = value.split(',')[0];
-    if (!first)
-        return null;
-    const trimmed = first.trim();
-    return trimmed ? trimmed : null;
-}
-function stripIpv6Brackets(value) {
-    if (!value.startsWith('['))
-        return null;
-    const end = value.indexOf(']');
-    if (end === -1)
-        return null;
-    return value.slice(1, end);
-}
-function stripPortIfPresent(value) {
-    const colonIndex = value.indexOf(':');
-    if (colonIndex === -1)
-        return value;
-    return value.slice(0, colonIndex);
-}
-function isIpV6Literal(value) {
-    return isIP(value) === 6;
-}
-function stripTrailingDots(value) {
-    let result = value;
-    while (result.endsWith('.')) {
-        result = result.slice(0, -1);
-    }
-    return result;
-}
+import { logInfo, logWarn } from './observability.js';
 export function composeCloseHandlers(first, second) {
     if (!first)
         return second;
@@ -79,6 +29,13 @@ function handleSessionCleanupError(error) {
         error: error instanceof Error ? error.message : 'Unknown error',
     });
 }
+function moveSessionToEnd(sessions, sessionId, session) {
+    sessions.delete(sessionId);
+    sessions.set(sessionId, session);
+}
+function isSessionExpired(session, now, sessionTtlMs) {
+    return now - session.lastSeen > sessionTtlMs;
+}
 async function runSessionCleanupLoop(store, sessionTtlMs, signal) {
     const intervalMs = getCleanupIntervalMs(sessionTtlMs);
     for await (const getNow of setIntervalPromise(intervalMs, Date.now, {
@@ -115,8 +72,8 @@ export function createSessionStore(sessionTtlMs) {
             const session = sessions.get(sessionId);
             if (session) {
                 session.lastSeen = Date.now();
-                sessions.delete(sessionId); // Move to end (LRU behavior if needed, but Map insertion order)
-                sessions.set(sessionId, session);
+                // Move to end (LRU behavior if needed, but Map insertion order)
+                moveSessionToEnd(sessions, sessionId, session);
             }
         },
         set: (sessionId, entry) => {
@@ -145,7 +102,7 @@ export function createSessionStore(sessionTtlMs) {
             const now = Date.now();
             const evicted = [];
             for (const [id, session] of sessions.entries()) {
-                if (now - session.lastSeen > sessionTtlMs) {
+                if (isSessionExpired(session, now, sessionTtlMs)) {
                     sessions.delete(id);
                     evicted.push(session);
                 }
@@ -163,27 +120,6 @@ export function createSessionStore(sessionTtlMs) {
         },
     };
 }
-// --- Validation ---
-const paramsSchema = z.looseObject({});
-const mcpRequestSchema = z.looseObject({
-    jsonrpc: z.literal('2.0'),
-    method: z.string().min(1),
-    id: z.union([z.string(), z.number(), z.null()]).optional(),
-    params: paramsSchema.optional(),
-});
-export function isJsonRpcBatchRequest(body) {
-    return Array.isArray(body);
-}
-export function isMcpRequestBody(body) {
-    return mcpRequestSchema.safeParse(body).success;
-}
-export function acceptsEventStream(header) {
-    if (!header)
-        return false;
-    return header
-        .split(',')
-        .some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
-}
 // --- Slot Tracker ---
 export function createSlotTracker(store) {
     let slotReleased = false;
@@ -221,32 +157,3 @@ export function ensureSessionCapacity({ store, maxSessions, evictOldest, }) {
     }
     return false;
 }
-export function applyHttpServerTuning(server) {
-    const { headersTimeoutMs, requestTimeoutMs, keepAliveTimeoutMs } = config.server.http;
-    if (headersTimeoutMs !== undefined) {
-        server.headersTimeout = headersTimeoutMs;
-    }
-    if (requestTimeoutMs !== undefined) {
-        server.requestTimeout = requestTimeoutMs;
-    }
-    if (keepAliveTimeoutMs !== undefined) {
-        server.keepAliveTimeout = keepAliveTimeoutMs;
-    }
-}
-export function drainConnectionsOnShutdown(server) {
-    const { shutdownCloseAllConnections, shutdownCloseIdleConnections } = config.server.http;
-    if (shutdownCloseAllConnections) {
-        if (typeof server.closeAllConnections === 'function') {
-            server.closeAllConnections();
-            logDebug('Closed all HTTP connections during shutdown');
-        }
-        return;
-    }
-    if (shutdownCloseIdleConnections) {
-        if (typeof server.closeIdleConnections === 'function') {
-            server.closeIdleConnections();
-            logDebug('Closed idle HTTP connections during shutdown');
-        }
-    }
-}
-//# sourceMappingURL=http-utils.js.map

package/dist/tools.d.ts

@@ -1,5 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type MarkdownTransformResult } from './transform.js';
+import type { MarkdownTransformResult } from './transform-types.js';
 export interface FetchUrlInput {
     url: string;
 }
@@ -25,7 +25,6 @@ export interface ToolContentResourceBlock {
 }
 export type ToolContentBlockUnion = ToolContentBlock | ToolContentResourceLinkBlock | ToolContentResourceBlock;
 export interface ToolErrorResponse {
-    [x: string]: unknown;
     content: ToolContentBlockUnion[];
     structuredContent: {
         error: string;
@@ -34,7 +33,6 @@ export interface ToolErrorResponse {
     isError: true;
 }
 export interface ToolResponseBase {
-    [x: string]: unknown;
     content: ToolContentBlockUnion[];
     structuredContent?: Record<string, unknown>;
     isError?: boolean;
@@ -86,6 +84,10 @@ export interface ToolHandlerExtra {
 }
 export declare const FETCH_URL_TOOL_NAME = "fetch-url";
 export declare const FETCH_URL_TOOL_DESCRIPTION = "Fetches a webpage and converts it to clean Markdown format";
+interface ProgressReporter {
+    report: (progress: number, message: string) => Promise<void>;
+}
+export declare function createProgressReporter(extra?: ToolHandlerExtra): ProgressReporter;
 interface InlineContentResult {
     content?: string;
     contentSize: number;
@@ -125,4 +127,3 @@ export declare function fetchUrlToolHandler(input: FetchUrlInput, extra?: ToolHa
 export declare function withRequestContextIfMissing<TParams, TResult, TExtra = unknown>(handler: (params: TParams, extra?: TExtra) => Promise<TResult>): (params: TParams, extra?: TExtra) => Promise<TResult>;
 export declare function registerTools(server: McpServer): void;
 export {};
-//# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -5,10 +5,11 @@ import { config } from './config.js';
 import { FetchError, getErrorMessage, isSystemError } from './errors.js';
 import { fetchNormalizedUrl, normalizeUrl, transformToRawUrl, } from './fetch.js';
 import { getRequestId, logDebug, logError, logWarn, runWithRequestContext, } from './observability.js';
-import { transformHtmlToMarkdown, } from './transform.js';
+import { transformHtmlToMarkdown } from './transform.js';
 import { isObject } from './type-guards.js';
 const TRUNCATION_MARKER = '...[truncated]';
 const FETCH_PROGRESS_TOTAL = 4;
+const PROGRESS_NOTIFICATION_TIMEOUT_MS = 5000;
 const fetchUrlInputSchema = z.strictObject({
     url: z
         .url({ protocol: /^https?$/i })
@@ -46,7 +47,7 @@ const fetchUrlOutputSchema = z.strictObject({
 });
 export const FETCH_URL_TOOL_NAME = 'fetch-url';
 export const FETCH_URL_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to clean Markdown format';
-function createProgressReporter(extra) {
+export function createProgressReporter(extra) {
     const token = extra?._meta?.progressToken ?? null;
     const sendNotification = extra?.sendNotification;
     if (token === null || !sendNotification) {
@@ -55,19 +56,33 @@ function createProgressReporter(extra) {
     return {
         report: async (progress, message) => {
             try {
-                await sendNotification({
-                    method: 'notifications/progress',
-                    params: {
-                        progressToken: token,
-                        progress,
-                        total: FETCH_PROGRESS_TOTAL,
-                        message,
-                    },
-                });
+                await Promise.race([
+                    sendNotification({
+                        method: 'notifications/progress',
+                        params: {
+                            progressToken: token,
+                            progress,
+                            total: FETCH_PROGRESS_TOTAL,
+                            message,
+                        },
+                    }),
+                    new Promise((_, reject) => {
+                        setTimeout(() => {
+                            reject(new Error('Progress notification timeout'));
+                        }, PROGRESS_NOTIFICATION_TIMEOUT_MS);
+                    }),
+                ]);
             }
             catch (error) {
-                logWarn('Failed to send progress notification', {
+                const isTimeout = error instanceof Error &&
+                    error.message === 'Progress notification timeout';
+                const logMessage = isTimeout
+                    ? 'Progress notification timed out'
+                    : 'Failed to send progress notification';
+                logWarn(logMessage, {
                     error: getErrorMessage(error),
+                    progress,
+                    message,
                 });
             }
         },
@@ -106,23 +121,16 @@ function buildEmbeddedResource(content, url, title) {
         },
     };
 }
-function resolveContentToEmbed(inlineResult, fullContent, useInlineInHttpMode) {
-    if (useInlineInHttpMode) {
-        return inlineResult.content;
-    }
-    return fullContent ?? inlineResult.content;
-}
-function maybeAppendEmbeddedResource(blocks, contentToEmbed, url, title) {
-    if (!contentToEmbed)
-        return;
-    if (!url)
-        return;
-    const embeddedResource = buildEmbeddedResource(contentToEmbed, url, title);
-    if (embeddedResource) {
-        blocks.push(embeddedResource);
+function appendResourceBlocks({ blocks, inlineResult, resourceName, url, title, fullContent, }) {
+    const contentToEmbed = config.runtime.httpMode
+        ? inlineResult.content
+        : (fullContent ?? inlineResult.content);
+    if (contentToEmbed && url) {
+        const embeddedResource = buildEmbeddedResource(contentToEmbed, url, title);
+        if (embeddedResource) {
+            blocks.push(embeddedResource);
+        }
     }
-}
-function maybeAppendResourceLink(blocks, inlineResult, resourceName) {
     const resourceLink = buildResourceLink(inlineResult, resourceName);
     if (resourceLink) {
         blocks.push(resourceLink);
@@ -136,9 +144,14 @@ function buildTextBlock(structuredContent) {
 }
 function buildToolContentBlocks(structuredContent, fromCache, inlineResult, resourceName, cacheKey, fullContent, url, title) {
     const blocks = [buildTextBlock(structuredContent)];
-    const contentToEmbed = resolveContentToEmbed(inlineResult, fullContent, config.runtime.httpMode);
-    maybeAppendEmbeddedResource(blocks, contentToEmbed, url, title);
-    maybeAppendResourceLink(blocks, inlineResult, resourceName);
+    appendResourceBlocks({
+        blocks,
+        inlineResult,
+        resourceName,
+        url,
+        title,
+        fullContent,
+    });
     return blocks;
 }
 function applyInlineContentLimit(content, cacheKey) {
@@ -266,14 +279,6 @@ function logRawUrlTransformation(resolvedUrl) {
         original: resolvedUrl.originalUrl,
     });
 }
-function applyOptionalPipelineSerialization(pipelineOptions, options) {
-    if (options.serialize !== undefined) {
-        pipelineOptions.serialize = options.serialize;
-    }
-    if (options.deserialize !== undefined) {
-        pipelineOptions.deserialize = options.deserialize;
-    }
-}
 export async function performSharedFetch(options, deps = {}) {
     const executePipeline = deps.executeFetchPipeline ?? executeFetchPipeline;
     const pipelineOptions = {
@@ -281,8 +286,9 @@ export async function performSharedFetch(options, deps = {}) {
         cacheNamespace: 'markdown',
         ...(options.signal === undefined ? {} : { signal: options.signal }),
         transform: options.transform,
+        ...(options.serialize ? { serialize: options.serialize } : {}),
+        ...(options.deserialize ? { deserialize: options.deserialize } : {}),
     };
-    applyOptionalPipelineSerialization(pipelineOptions, options);
     const pipeline = await executePipeline(pipelineOptions);
     const inlineResult = applyInlineContentLimit(pipeline.data.content, pipeline.cacheKey ?? null);
     return { pipeline, inlineResult };
@@ -485,4 +491,3 @@ export function registerTools(server) {
         annotations: TOOL_DEFINITION.annotations,
     }, withRequestContextIfMissing(TOOL_DEFINITION.handler));
 }
-//# sourceMappingURL=tools.js.map

package/dist/transform-types.d.ts

@@ -77,5 +77,42 @@ export interface TransformStageContext {
     readonly stage: string;
     readonly startTime: number;
     readonly url: string;
+    readonly budgetMs?: number;
+    readonly totalBudgetMs?: number;
 }
-//# sourceMappingURL=transform-types.d.ts.map
+/**
+ * Worker message types for transform workers.
+ */
+export interface TransformWorkerTransformMessage {
+    type: 'transform';
+    id: string;
+    html: string;
+    url: string;
+    includeMetadata: boolean;
+}
+export interface TransformWorkerCancelMessage {
+    type: 'cancel';
+    id: string;
+}
+export interface TransformWorkerResultMessage {
+    type: 'result';
+    id: string;
+    result: {
+        markdown: string;
+        title?: string;
+        truncated: boolean;
+    };
+}
+export interface TransformWorkerErrorMessage {
+    type: 'error';
+    id: string;
+    error: {
+        name: string;
+        message: string;
+        url: string;
+        statusCode?: number;
+        details?: Record<string, unknown>;
+    };
+}
+export type TransformWorkerIncomingMessage = TransformWorkerTransformMessage | TransformWorkerCancelMessage;
+export type TransformWorkerOutgoingMessage = TransformWorkerResultMessage | TransformWorkerErrorMessage;

package/dist/transform-types.js

@@ -3,4 +3,3 @@
  * Extracted to avoid circular dependencies between transform modules.
  */
 export {};
-//# sourceMappingURL=transform-types.js.map