@j0hanz/superfetch 1.2.1 → 1.2.3

package/dist/tools/schemas.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const fetchUrlInputSchema: z.ZodObject<{
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    customHeaders: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     retries: z.ZodDefault<z.ZodNumber>;
 } & {
@@ -11,6 +11,7 @@ export declare const fetchUrlInputSchema: z.ZodObject<{
     maxContentLength: z.ZodOptional<z.ZodNumber>;
 } & {
     format: z.ZodDefault<z.ZodEnum<["jsonl", "markdown"]>>;
+    includeContentBlocks: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     url: string;
     extractMainContent: boolean;
@@ -18,20 +19,22 @@ export declare const fetchUrlInputSchema: z.ZodObject<{
     retries: number;
     format: "jsonl" | "markdown";
     timeout: number;
-    customHeaders?: Record<string, string> | undefined;
     maxContentLength?: number | undefined;
+    includeContentBlocks?: boolean | undefined;
+    customHeaders?: Record<string, string> | undefined;
 }, {
     url: string;
-    customHeaders?: Record<string, string> | undefined;
     extractMainContent?: boolean | undefined;
     includeMetadata?: boolean | undefined;
+    maxContentLength?: number | undefined;
     retries?: number | undefined;
     format?: "jsonl" | "markdown" | undefined;
-    maxContentLength?: number | undefined;
+    includeContentBlocks?: boolean | undefined;
     timeout?: number | undefined;
+    customHeaders?: Record<string, string> | undefined;
 }>;
 export declare const fetchMarkdownInputSchema: z.ZodObject<{
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    customHeaders: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     retries: z.ZodDefault<z.ZodNumber>;
 } & {
@@ -46,16 +49,16 @@ export declare const fetchMarkdownInputSchema: z.ZodObject<{
     includeMetadata: boolean;
     retries: number;
     timeout: number;
-    customHeaders?: Record<string, string> | undefined;
     maxContentLength?: number | undefined;
+    customHeaders?: Record<string, string> | undefined;
 }, {
     url: string;
-    customHeaders?: Record<string, string> | undefined;
     extractMainContent?: boolean | undefined;
     includeMetadata?: boolean | undefined;
-    retries?: number | undefined;
     maxContentLength?: number | undefined;
+    retries?: number | undefined;
     timeout?: number | undefined;
+    customHeaders?: Record<string, string> | undefined;
 }>;
 export declare const fetchUrlOutputSchema: z.ZodObject<{
     url: z.ZodString;
@@ -74,30 +77,30 @@ export declare const fetchUrlOutputSchema: z.ZodObject<{
     errorCode: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     url: string;
-    contentBlocks: number;
     fetchedAt: string;
     format: "jsonl" | "markdown";
+    contentBlocks: number;
     cached: boolean;
     error?: string | undefined;
-    content?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
+    content?: string | undefined;
     contentSize?: number | undefined;
     errorCode?: string | undefined;
 }, {
     url: string;
-    contentBlocks: number;
     fetchedAt: string;
     format: "jsonl" | "markdown";
+    contentBlocks: number;
     cached: boolean;
     error?: string | undefined;
-    content?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
+    content?: string | undefined;
     contentSize?: number | undefined;
     errorCode?: string | undefined;
 }>;
@@ -111,13 +114,13 @@ export declare const fetchMarkdownOutputSchema: z.ZodObject<{
         fileName: z.ZodString;
         expiresAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        fileName: string;
         expiresAt: string;
         downloadUrl: string;
-    }, {
         fileName: string;
+    }, {
         expiresAt: string;
         downloadUrl: string;
+        fileName: string;
     }>>;
 } & {
     contentSize: z.ZodOptional<z.ZodNumber>;
@@ -139,9 +142,9 @@ export declare const fetchMarkdownOutputSchema: z.ZodObject<{
     resourceMimeType?: string | undefined;
     contentSize?: number | undefined;
     file?: {
-        fileName: string;
         expiresAt: string;
         downloadUrl: string;
+        fileName: string;
     } | undefined;
     errorCode?: string | undefined;
 }, {
@@ -156,9 +159,9 @@ export declare const fetchMarkdownOutputSchema: z.ZodObject<{
     resourceMimeType?: string | undefined;
     contentSize?: number | undefined;
     file?: {
-        fileName: string;
         expiresAt: string;
         downloadUrl: string;
+        fileName: string;
     } | undefined;
     errorCode?: string | undefined;
 }>;

package/dist/tools/schemas.js

@@ -1,8 +1,16 @@
 import { z } from 'zod';
 import { config } from '../config/index.js';
+const MAX_HEADER_NAME_LENGTH = 128;
+const MAX_HEADER_VALUE_LENGTH = 2048;
+const MAX_HEADER_COUNT = 50;
+const MAX_CONTENT_LENGTH = config.constants.maxContentSize;
+const customHeadersSchema = z
+    .record(z.string().max(MAX_HEADER_NAME_LENGTH), z.string().max(MAX_HEADER_VALUE_LENGTH))
+    .refine((headers) => Object.keys(headers).length <= MAX_HEADER_COUNT, {
+    message: `customHeaders must have at most ${MAX_HEADER_COUNT} entries`,
+});
 const requestOptionsSchema = z.object({
-    customHeaders: z
-        .record(z.string())
+    customHeaders: customHeadersSchema
         .optional()
         .describe('Custom HTTP headers for the request'),
     timeout: z
@@ -30,6 +38,7 @@ const extractionOptionsSchema = z.object({
     maxContentLength: z
         .number()
         .positive()
+        .max(MAX_CONTENT_LENGTH)
         .optional()
         .describe('Maximum content length in characters'),
 });
@@ -38,6 +47,10 @@ const formatOptionsSchema = z.object({
         .enum(['jsonl', 'markdown'])
         .default('jsonl')
         .describe('Output format'),
+    includeContentBlocks: z
+        .boolean()
+        .optional()
+        .describe('Include content block counts when format=markdown'),
 });
 const resourceFieldsSchema = z.object({
     contentSize: z.number().optional().describe('Content length in characters'),
@@ -64,14 +77,22 @@ const fileDownloadSchema = z.object({
 });
 export const fetchUrlInputSchema = requestOptionsSchema
     .extend({
-    url: z.string().min(1).describe('The URL to fetch'),
+    url: z
+        .string()
+        .min(1)
+        .max(config.constants.maxUrlLength)
+        .describe('The URL to fetch'),
 })
     .merge(extractionOptionsSchema)
     .merge(formatOptionsSchema)
     .strict();
 export const fetchMarkdownInputSchema = requestOptionsSchema
     .extend({
-    url: z.string().min(1).describe('The URL to fetch'),
+    url: z
+        .string()
+        .min(1)
+        .max(config.constants.maxUrlLength)
+        .describe('The URL to fetch'),
 })
     .merge(extractionOptionsSchema)
     .strict();

package/dist/tools/utils/common.js

@@ -6,22 +6,26 @@ export function createContentMetadataBlock(url, article, extractedMeta, shouldEx
     if (!includeMetadata)
         return undefined;
     const now = new Date().toISOString();
-    return shouldExtractFromArticle && article
-        ? {
-            type: 'metadata',
-            title: article.title,
-            author: article.byline,
-            url,
-            fetchedAt: now,
-        }
-        : {
-            type: 'metadata',
-            title: extractedMeta.title,
-            description: extractedMeta.description,
-            author: extractedMeta.author,
-            url,
-            fetchedAt: now,
-        };
+    const metadata = {
+        type: 'metadata',
+        url,
+        fetchedAt: now,
+    };
+    if (shouldExtractFromArticle && article) {
+        if (article.title !== undefined)
+            metadata.title = article.title;
+        if (article.byline !== undefined)
+            metadata.author = article.byline;
+        return metadata;
+    }
+    if (extractedMeta.title !== undefined)
+        metadata.title = extractedMeta.title;
+    if (extractedMeta.description !== undefined) {
+        metadata.description = extractedMeta.description;
+    }
+    if (extractedMeta.author !== undefined)
+        metadata.author = extractedMeta.author;
+    return metadata;
 }
 export function truncateContent(content, maxLength, suffix = TRUNCATION_MARKER) {
     if (maxLength === undefined ||

package/dist/tools/utils/content-transform-async.d.ts

@@ -0,0 +1,6 @@
+import type { JsonlTransformResult, MarkdownTransformResult, TransformOptions } from '../../config/types/content.js';
+export declare function transformHtmlToJsonlAsync(html: string, url: string, options: TransformOptions): Promise<JsonlTransformResult>;
+export declare function transformHtmlToMarkdownAsync(html: string, url: string, options: TransformOptions): Promise<MarkdownTransformResult>;
+export declare function transformHtmlToMarkdownWithBlocksAsync(html: string, url: string, options: TransformOptions & {
+    includeContentBlocks?: boolean;
+}): Promise<JsonlTransformResult>;

package/dist/tools/utils/content-transform-async.js

@@ -0,0 +1,33 @@
+import { logWarn } from '../../services/logger.js';
+import { runTransformInWorker, } from '../../services/transform-worker-pool.js';
+import { transformHtmlToJsonl, transformHtmlToMarkdown, transformHtmlToMarkdownWithBlocks, } from './content-transform.js';
+async function runOrFallback(job, fallback) {
+    try {
+        const result = await runTransformInWorker(job);
+        if (result)
+            return result;
+    }
+    catch (error) {
+        logWarn('Transform worker unavailable; using main thread', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return fallback();
+}
+export async function transformHtmlToJsonlAsync(html, url, options) {
+    const result = await runOrFallback({ mode: 'jsonl', html, url, options }, () => transformHtmlToJsonl(html, url, options));
+    return result;
+}
+export async function transformHtmlToMarkdownAsync(html, url, options) {
+    const result = await runOrFallback({ mode: 'markdown', html, url, options }, () => transformHtmlToMarkdown(html, url, options));
+    return result;
+}
+export async function transformHtmlToMarkdownWithBlocksAsync(html, url, options) {
+    const result = await runOrFallback({
+        mode: 'markdown-blocks',
+        html,
+        url,
+        options,
+    }, () => transformHtmlToMarkdownWithBlocks(html, url, options));
+    return result;
+}

package/dist/tools/utils/content-transform.d.ts

@@ -8,7 +8,10 @@ interface ContentLengthOptions {
 }
 interface MarkdownOptions extends ExtractionOptions, ContentLengthOptions {
 }
+interface MarkdownWithBlocksOptions extends ExtractionOptions, ContentLengthOptions {
+    readonly includeContentBlocks?: boolean;
+}
 export declare function transformHtmlToJsonl(html: string, url: string, options: ExtractionOptions & ContentLengthOptions): JsonlTransformResult;
 export declare function transformHtmlToMarkdown(html: string, url: string, options: MarkdownOptions): MarkdownTransformResult;
-export declare function transformHtmlToMarkdownWithBlocks(html: string, url: string, options: ExtractionOptions & ContentLengthOptions): JsonlTransformResult;
+export declare function transformHtmlToMarkdownWithBlocks(html: string, url: string, options: MarkdownWithBlocksOptions): JsonlTransformResult;
 export {};

package/dist/tools/utils/content-transform.js

@@ -1,6 +1,6 @@
 import { TRUNCATION_MARKER } from '../../config/formatting.js';
 import { extractContent } from '../../services/extractor.js';
-import { parseHtml } from '../../services/parser.js';
+import { parseHtml, parseHtmlWithMetadata } from '../../services/parser.js';
 import { sanitizeText } from '../../utils/sanitizer.js';
 import { toJsonl } from '../../transformers/jsonl.transformer.js';
 import { htmlToMarkdown } from '../../transformers/markdown.transformer.js';
@@ -56,7 +56,10 @@ function decodeHtmlEntities(value) {
 }
 function buildJsonlPayload(context, maxContentLength) {
     const contentBlocks = parseHtml(context.sourceHtml);
-    const { content, truncated } = truncateContent(toJsonl(contentBlocks, context.metadata), maxContentLength);
+    return buildJsonlPayloadFromBlocks(contentBlocks, context.metadata, maxContentLength);
+}
+function buildJsonlPayloadFromBlocks(contentBlocks, metadata, maxContentLength) {
+    const { content, truncated } = truncateContent(toJsonl(contentBlocks, metadata), maxContentLength);
     return {
         content,
         contentBlocks: contentBlocks.length,
@@ -69,6 +72,17 @@ function buildMarkdownPayload(context, maxContentLength) {
     return { content, truncated };
 }
 export function transformHtmlToJsonl(html, url, options) {
+    if (!options.extractMainContent && options.includeMetadata) {
+        const parsed = parseHtmlWithMetadata(html);
+        const metadataBlock = createContentMetadataBlock(url, null, parsed.metadata, false, true);
+        const { content, contentBlocks, truncated } = buildJsonlPayloadFromBlocks(parsed.blocks, metadataBlock, options.maxContentLength);
+        return {
+            content,
+            contentBlocks,
+            title: parsed.metadata.title,
+            ...(truncated && { truncated }),
+        };
+    }
     const context = resolveContentSource(html, url, options);
     const { content, contentBlocks, truncated } = buildJsonlPayload(context, options.maxContentLength);
     return {
@@ -88,8 +102,28 @@ export function transformHtmlToMarkdown(html, url, options) {
     };
 }
 export function transformHtmlToMarkdownWithBlocks(html, url, options) {
+    const includeContentBlocks = options.includeContentBlocks ?? true;
+    if (includeContentBlocks &&
+        !options.extractMainContent &&
+        options.includeMetadata) {
+        const parsed = parseHtmlWithMetadata(html);
+        const context = {
+            sourceHtml: html,
+            title: parsed.metadata.title,
+            metadata: createContentMetadataBlock(url, null, parsed.metadata, false, true),
+        };
+        const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
+        return {
+            content,
+            contentBlocks: parsed.blocks.length,
+            title: context.title,
+            ...(truncated && { truncated }),
+        };
+    }
     const context = resolveContentSource(html, url, options);
-    const contentBlocks = parseHtml(context.sourceHtml);
+    const contentBlocks = includeContentBlocks
+        ? parseHtml(context.sourceHtml)
+        : [];
     const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
     return {
         content,

package/dist/tools/utils/fetch-pipeline.js

@@ -1,7 +1,7 @@
 import * as cache from '../../services/cache.js';
-import { fetchUrlWithRetry } from '../../services/fetcher.js';
+import { fetchNormalizedUrlWithRetry } from '../../services/fetcher.js';
 import { logDebug } from '../../services/logger.js';
-import { validateAndNormalizeUrl } from '../../utils/url-validator.js';
+import { assertResolvedAddressesAllowed, normalizeUrl, } from '../../utils/url-validator.js';
 import { appendHeaderVary } from './cache-vary.js';
 function attemptCacheRetrieval(cacheKey, deserialize, cacheNamespace, normalizedUrl) {
     if (!cacheKey)
@@ -42,16 +42,19 @@ function attemptCacheRetrieval(cacheKey, deserialize, cacheNamespace, normalized
  * @returns Promise resolving to the pipeline result
  */
 export async function executeFetchPipeline(options) {
-    const normalizedUrl = await validateAndNormalizeUrl(options.url);
+    const { normalizedUrl, hostname } = normalizeUrl(options.url);
     const cacheKey = resolveCacheKey(options, normalizedUrl);
     const cachedResult = attemptCacheRetrieval(cacheKey, options.deserialize, options.cacheNamespace, normalizedUrl);
     if (cachedResult)
         return cachedResult;
+    await assertResolvedAddressesAllowed(hostname);
     const fetchOptions = buildFetchOptions(options);
     logDebug('Fetching URL', { url: normalizedUrl, retries: options.retries });
-    const html = await fetchUrlWithRetry(normalizedUrl, fetchOptions, options.retries);
-    const data = options.transform(html, normalizedUrl);
-    persistCache(cacheKey, data, options.serialize, normalizedUrl);
+    const html = await fetchNormalizedUrlWithRetry(normalizedUrl, fetchOptions, options.retries);
+    const data = await options.transform(html, normalizedUrl);
+    if (cache.isEnabled()) {
+        persistCache(cacheKey, data, options.serialize, normalizedUrl);
+    }
     return buildPipelineResult(normalizedUrl, data, cacheKey);
 }
 function resolveCacheKey(options, normalizedUrl) {
@@ -59,20 +62,28 @@ function resolveCacheKey(options, normalizedUrl) {
     return cache.createCacheKey(options.cacheNamespace, normalizedUrl, cacheVary);
 }
 function buildFetchOptions(options) {
-    return {
-        customHeaders: options.customHeaders,
-        signal: options.signal,
-        timeout: options.timeout,
-    };
+    const fetchOptions = {};
+    if (options.customHeaders !== undefined) {
+        fetchOptions.customHeaders = options.customHeaders;
+    }
+    if (options.signal !== undefined) {
+        fetchOptions.signal = options.signal;
+    }
+    if (options.timeout !== undefined) {
+        fetchOptions.timeout = options.timeout;
+    }
+    return fetchOptions;
 }
 function persistCache(cacheKey, data, serialize, normalizedUrl) {
     if (!cacheKey)
         return;
     const serializer = serialize ?? JSON.stringify;
-    cache.set(cacheKey, serializer(data), {
-        url: normalizedUrl,
-        title: extractTitle(data),
-    });
+    const metadata = { url: normalizedUrl };
+    const title = extractTitle(data);
+    if (title !== undefined) {
+        metadata.title = title;
+    }
+    cache.set(cacheKey, serializer(data), metadata);
 }
 function extractTitle(value) {
     if (!value || typeof value !== 'object')

package/dist/utils/content-cleaner.d.ts

@@ -1,5 +1,5 @@
 export declare function cleanParagraph(text: string): string | null;
 export declare function cleanHeading(text: string): string | null;
-export declare function cleanListItems(items: string[]): string[];
+export declare function cleanListItems(items: readonly string[]): readonly string[];
 export declare function cleanCodeBlock(code: string): string | null;
 export declare function removeInlineTimestamps(text: string): string;

package/dist/utils/download-url.d.ts

@@ -1,8 +1,16 @@
+import { config } from '../config/index.js';
 import type { FileDownloadInfo } from '../config/types/tools.js';
+import * as cache from '../services/cache.js';
+import { generateSafeFilename } from './filename-generator.js';
 interface DownloadInfoOptions {
     cacheKey: string | null;
     url: string;
     title?: string;
 }
-export declare function buildFileDownloadInfo(options: DownloadInfoOptions): FileDownloadInfo | null;
+interface DownloadInfoDeps {
+    readonly config?: typeof config;
+    readonly cache?: Pick<typeof cache, 'get' | 'parseCacheKey'>;
+    readonly generateSafeFilename?: typeof generateSafeFilename;
+}
+export declare function buildFileDownloadInfo(options: DownloadInfoOptions, deps?: DownloadInfoDeps): FileDownloadInfo | null;
 export {};

package/dist/utils/download-url.js

@@ -1,22 +1,25 @@
 import { config } from '../config/index.js';
 import * as cache from '../services/cache.js';
 import { generateSafeFilename } from './filename-generator.js';
-export function buildFileDownloadInfo(options) {
-    if (!config.runtime.httpMode) {
+export function buildFileDownloadInfo(options, deps = {}) {
+    const resolvedConfig = deps.config ?? config;
+    const resolvedCache = deps.cache ?? cache;
+    const resolveFilename = deps.generateSafeFilename ?? generateSafeFilename;
+    if (!resolvedConfig.runtime.httpMode) {
         return null;
     }
-    if (!config.cache.enabled || !options.cacheKey) {
+    if (!resolvedConfig.cache.enabled || !options.cacheKey) {
         return null;
     }
-    const parts = cache.parseCacheKey(options.cacheKey);
+    const parts = resolvedCache.parseCacheKey(options.cacheKey);
     if (!parts)
         return null;
-    const cacheEntry = cache.get(options.cacheKey);
+    const cacheEntry = resolvedCache.get(options.cacheKey);
     if (!cacheEntry)
         return null;
     const { expiresAt, title, url } = cacheEntry;
     const downloadUrl = buildDownloadUrl(parts.namespace, parts.urlHash);
-    const fileName = generateSafeFilename(url, title ?? options.title, parts.urlHash, resolveExtension(parts.namespace));
+    const fileName = resolveFilename(url, title ?? options.title, parts.urlHash, resolveExtension(parts.namespace));
     return { downloadUrl, fileName, expiresAt };
 }
 function buildDownloadUrl(namespace, hash) {

package/dist/utils/tool-error-handler.d.ts

@@ -1,3 +1,3 @@
 import type { ToolErrorResponse } from '../config/types/tools.js';
-export declare function createToolErrorResponse(message: string, url: string, code: string): ToolErrorResponse;
-export declare function handleToolError(error: unknown, url: string, fallbackMessage?: string): ToolErrorResponse;
+export declare function createToolErrorResponse(message: string, url: string, code: string, details?: Record<string, unknown>): ToolErrorResponse;
+export declare function handleToolError(error: unknown, url: string, fallbackMessage?: string, details?: Record<string, unknown>): ToolErrorResponse;

package/dist/utils/tool-error-handler.js

@@ -22,12 +22,12 @@ function normalizeToolErrorCode(code) {
         return String(ErrorCode.InternalError);
     return MCP_ERROR_CODE_MAP[code] ?? code;
 }
-export function createToolErrorResponse(message, url, code) {
+export function createToolErrorResponse(message, url, code, details = {}) {
     const structuredContent = {
+        ...details,
         error: message,
         url,
         errorCode: normalizeToolErrorCode(code),
-        errorType: code,
     };
     return {
         content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
@@ -42,19 +42,19 @@ function formatErrorMessage(baseMessage, error, fallback) {
     }
     return message;
 }
-export function handleToolError(error, url, fallbackMessage = 'Operation failed') {
+export function handleToolError(error, url, fallbackMessage = 'Operation failed', details = {}) {
     if (isValidationError(error)) {
-        return createToolErrorResponse(error.message, url, 'VALIDATION_ERROR');
+        return createToolErrorResponse(error.message, url, 'VALIDATION_ERROR', details);
     }
     if (error instanceof FetchError) {
         const message = formatErrorMessage(error.message, error);
-        return createToolErrorResponse(message, url, error.code);
+        return createToolErrorResponse(message, url, error.code, details);
     }
     if (error instanceof Error) {
         const message = formatErrorMessage(error.message, error, fallbackMessage);
-        return createToolErrorResponse(message, url, 'UNKNOWN_ERROR');
+        return createToolErrorResponse(message, url, 'UNKNOWN_ERROR', details);
     }
-    return createToolErrorResponse(`${fallbackMessage}: Unknown error`, url, 'UNKNOWN_ERROR');
+    return createToolErrorResponse(`${fallbackMessage}: Unknown error`, url, 'UNKNOWN_ERROR', details);
 }
 function isValidationError(error) {
     return (error instanceof Error &&

package/dist/utils/url-validator.d.ts

@@ -1,2 +1,7 @@
 export declare function isBlockedIp(ip: string): boolean;
+export declare function assertResolvedAddressesAllowed(hostname: string): Promise<void>;
+export declare function normalizeUrl(urlString: string): {
+    normalizedUrl: string;
+    hostname: string;
+};
 export declare function validateAndNormalizeUrl(urlString: string): Promise<string>;

package/dist/utils/url-validator.js

@@ -32,6 +32,35 @@ for (const entry of BLOCKED_IPV6_SUBNETS) {
     BLOCK_LIST.addSubnet(entry.subnet, entry.prefix, 'ipv6');
 }
 const DNS_LOOKUP_TIMEOUT_MS = 5000;
+const DNS_DECISION_TTL_MS = 60000;
+const DNS_DECISION_MAX = 1000;
+const dnsDecisionCache = new Map();
+function getCachedDnsDecision(hostname) {
+    const cached = dnsDecisionCache.get(hostname);
+    if (!cached)
+        return null;
+    if (cached.expiresAt <= Date.now()) {
+        dnsDecisionCache.delete(hostname);
+        return null;
+    }
+    return cached;
+}
+function setCachedDnsDecision(hostname, ok) {
+    dnsDecisionCache.set(hostname, {
+        ok,
+        expiresAt: Date.now() + DNS_DECISION_TTL_MS,
+    });
+    if (dnsDecisionCache.size <= DNS_DECISION_MAX)
+        return;
+    const evictCount = Math.ceil(DNS_DECISION_MAX * 0.05);
+    const iterator = dnsDecisionCache.keys();
+    for (let i = 0; i < evictCount; i++) {
+        const { value, done } = iterator.next();
+        if (done)
+            break;
+        dnsDecisionCache.delete(value);
+    }
+}
 function matchesBlockedIpPatterns(resolvedIp) {
     for (const pattern of config.security.blockedIpPatterns) {
         if (pattern.test(resolvedIp)) {
@@ -78,7 +107,14 @@ function lookupWithTimeout(hostname) {
         });
     });
 }
-async function assertResolvedAddressesAllowed(hostname) {
+export async function assertResolvedAddressesAllowed(hostname) {
+    const cached = getCachedDnsDecision(hostname);
+    if (cached) {
+        if (!cached.ok) {
+            throw createValidationError(`Blocked IP range resolved from hostname: ${hostname}`);
+        }
+        return;
+    }
     try {
         const result = await lookupWithTimeout(hostname);
         const addresses = Array.isArray(result) ? result : [result];
@@ -87,9 +123,11 @@ async function assertResolvedAddressesAllowed(hostname) {
         }
         for (const { address } of addresses) {
             if (isBlockedIp(address.toLowerCase())) {
+                setCachedDnsDecision(hostname, false);
                 throw createValidationError(`Blocked IP range resolved from hostname: ${hostname}`);
             }
         }
+        setCachedDnsDecision(hostname, true);
     }
     catch (error) {
         const code = error?.code;
@@ -102,7 +140,7 @@ async function assertResolvedAddressesAllowed(hostname) {
         throw createValidationError(String(error));
     }
 }
-export async function validateAndNormalizeUrl(urlString) {
+export function normalizeUrl(urlString) {
     const trimmedUrl = requireTrimmedUrl(urlString);
     assertUrlLength(trimmedUrl);
     const url = parseUrl(trimmedUrl);
@@ -110,8 +148,12 @@ export async function validateAndNormalizeUrl(urlString) {
     assertNoCredentials(url);
     const hostname = normalizeHostname(url);
     assertHostnameAllowed(hostname);
+    return { normalizedUrl: url.href, hostname };
+}
+export async function validateAndNormalizeUrl(urlString) {
+    const { normalizedUrl, hostname } = normalizeUrl(urlString);
     await assertResolvedAddressesAllowed(hostname);
-    return url.href;
+    return normalizedUrl;
 }
 const VALIDATION_ERROR_CODE = 'VALIDATION_ERROR';
 function createValidationError(message) {

package/dist/workers/transform-worker.d.ts

@@ -0,0 +1 @@
+export {};