@j0hanz/superfetch 2.6.0 → 2.7.1

package/dist/cache.js

@@ -41,14 +41,6 @@ export function parseCachedPayload(raw) {
 export function resolveCachedPayloadContent(payload) {
     return payload.markdown ?? payload.content ?? null;
 }
-function stableStringify(value) {
-    try {
-        return stableJsonStringify(value);
-    }
-    catch {
-        return null;
-    }
-}
 function createHashFragment(input, length) {
     return sha256Hex(input).substring(0, length);
 }
@@ -63,9 +55,18 @@ export function createCacheKey(namespace, url, vary) {
     const urlHash = createHashFragment(url, CACHE_CONSTANTS.URL_HASH_LENGTH);
     let varyHash;
     if (vary) {
-        const varyString = typeof vary === 'string' ? vary : stableStringify(vary);
-        if (varyString === null)
-            return null;
+        let varyString;
+        if (typeof vary === 'string') {
+            varyString = vary;
+        }
+        else {
+            try {
+                varyString = stableJsonStringify(vary);
+            }
+            catch {
+                return null;
+            }
+        }
         if (varyString) {
             varyHash = createHashFragment(varyString, CACHE_CONSTANTS.VARY_HASH_LENGTH);
         }
@@ -102,9 +103,12 @@ class InMemoryCacheStore {
         if (!this.isEnabled())
             return [];
         const now = Date.now();
-        return Array.from(this.entries.entries())
-            .filter(([, entry]) => entry.expiresAtMs > now)
-            .map(([key]) => key);
+        const result = [];
+        for (const [key, entry] of this.entries) {
+            if (entry.expiresAtMs > now)
+                result.push(key);
+        }
+        return result;
     }
     onUpdate(listener) {
         const wrapped = (event) => {
@@ -131,7 +135,8 @@ class InMemoryCacheStore {
         const entry = this.entries.get(cacheKey);
         if (!entry)
             return undefined;
-        if (entry.expiresAtMs <= Date.now()) {
+        const now = Date.now();
+        if (entry.expiresAtMs <= now) {
             this.entries.delete(cacheKey);
             return undefined;
         }
@@ -157,12 +162,11 @@ class InMemoryCacheStore {
         };
         this.entries.delete(cacheKey);
         this.entries.set(cacheKey, entry);
-        // Eviction
+        // Eviction (LRU: first insertion-order key)
         if (this.entries.size > this.max) {
             const firstKey = this.entries.keys().next();
-            if (!firstKey.done) {
+            if (!firstKey.done)
                 this.entries.delete(firstKey.value);
-            }
         }
         this.notify(cacheKey);
     }
@@ -170,9 +174,9 @@ class InMemoryCacheStore {
         if (this.updateEmitter.listenerCount('update') === 0)
             return;
         const parts = parseCacheKey(cacheKey);
-        if (parts) {
-            this.updateEmitter.emit('update', { cacheKey, ...parts });
-        }
+        if (!parts)
+            return;
+        this.updateEmitter.emit('update', { cacheKey, ...parts });
     }
     logError(message, cacheKey, error) {
         logWarn(message, {
@@ -231,7 +235,6 @@ function resolveCachedMarkdownText(raw) {
     return raw;
 }
 export function registerCachedContentResource(server, serverIcons) {
-    // Resource Registration
     server.registerResource('cached-content', new ResourceTemplate('superfetch://cache/{namespace}/{urlHash}', {
         list: listCachedResources,
     }), {
@@ -288,7 +291,7 @@ export function registerCachedContentResource(server, serverIcons) {
     store.onUpdate(({ cacheKey }) => {
         if (!server.isConnected() || !initialized)
             return;
-        // Check capabilities via unsafe cast or helper (SDK limitation)
+        // Check capabilities via unsafe cast (SDK limitation)
         const capabilities = server.server.getClientCapabilities();
         const uri = toResourceUri(cacheKey);
         if (capabilities?.resources?.subscribe && uri && subscriptions.has(uri)) {

package/dist/config.js

@@ -3,16 +3,19 @@ import { findPackageJSON } from 'node:module';
 import { isIP } from 'node:net';
 import process from 'node:process';
 import { domainToASCII } from 'node:url';
-const packageJsonPath = findPackageJSON(import.meta.url);
-if (!packageJsonPath) {
-    throw new Error('package.json not found');
-}
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-if (typeof packageJson.version !== 'string') {
-    throw new Error('package.json version is missing');
+function readServerVersion(moduleUrl) {
+    const packageJsonPath = findPackageJSON(moduleUrl);
+    if (!packageJsonPath)
+        throw new Error('package.json not found');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    if (typeof packageJson.version !== 'string') {
+        throw new Error('package.json version is missing');
+    }
+    return packageJson.version;
 }
-export const serverVersion = packageJson.version;
+export const serverVersion = readServerVersion(import.meta.url);
 const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+const ALLOWED_LOG_LEVELS = new Set(LOG_LEVELS);
 const DEFAULT_HEADING_KEYWORDS = [
     'overview',
     'introduction',
@@ -34,6 +37,9 @@ const DEFAULT_HEADING_KEYWORDS = [
     'acknowledgments',
     'appendix',
 ];
+class ConfigError extends Error {
+    name = 'ConfigError';
+}
 function isMissingEnvFileError(error) {
     if (!error || typeof error !== 'object')
         return false;
@@ -54,23 +60,20 @@ function loadEnvFileIfAvailable() {
 }
 loadEnvFileIfAvailable();
 const { env } = process;
-class ConfigError extends Error {
-    name = 'ConfigError';
-}
 function buildIpv4(parts) {
     return parts.join('.');
 }
-function formatHostForUrl(hostname) {
-    if (hostname.includes(':') && !hostname.startsWith('['))
-        return `[${hostname}]`;
-    return hostname;
-}
 function stripTrailingDots(value) {
     let result = value;
     while (result.endsWith('.'))
         result = result.slice(0, -1);
     return result;
 }
+function formatHostForUrl(hostname) {
+    if (hostname.includes(':') && !hostname.startsWith('['))
+        return `[${hostname}]`;
+    return hostname;
+}
 function normalizeHostname(value) {
     const trimmed = value.trim();
     if (!trimmed)
@@ -86,24 +89,29 @@ function normalizeHostValue(value) {
     const raw = value.trim();
     if (!raw)
         return null;
+    // Full URL
     if (raw.includes('://')) {
         if (!URL.canParse(raw))
             return null;
         return normalizeHostname(new URL(raw).hostname);
     }
+    // host[:port]
     const candidateUrl = `http://${raw}`;
     if (URL.canParse(candidateUrl)) {
         return normalizeHostname(new URL(candidateUrl).hostname);
     }
     const lowered = raw.toLowerCase();
+    // [::1]:port
     if (lowered.startsWith('[')) {
         const end = lowered.indexOf(']');
         if (end === -1)
             return null;
         return normalizeHostname(lowered.slice(1, end));
     }
+    // Bare IPv6
     if (isIP(lowered) === 6)
         return stripTrailingDots(lowered);
+    // Split host:port (single colon only)
     const firstColon = lowered.indexOf(':');
     if (firstColon === -1)
         return normalizeHostname(lowered);
@@ -159,27 +167,6 @@ function normalizeLocale(value) {
         return undefined;
     return trimmed;
 }
-function parseUrlEnv(value, name) {
-    if (!value)
-        return undefined;
-    if (!URL.canParse(value)) {
-        throw new ConfigError(`Invalid ${name} value: ${value}`);
-    }
-    return new URL(value);
-}
-function readUrlEnv(name) {
-    return parseUrlEnv(env[name], name);
-}
-function parseAllowedHosts(envValue) {
-    const hosts = new Set();
-    for (const entry of parseList(envValue)) {
-        const normalized = normalizeHostValue(entry);
-        if (normalized)
-            hosts.add(normalized);
-    }
-    return hosts;
-}
-const ALLOWED_LOG_LEVELS = new Set(LOG_LEVELS);
 function isLogLevel(value) {
     return ALLOWED_LOG_LEVELS.has(value);
 }
@@ -202,6 +189,26 @@ function parsePort(envValue) {
         return 0;
     return parseInteger(envValue, 3000, 1024, 65535);
 }
+function parseUrlEnv(value, name) {
+    if (!value)
+        return undefined;
+    if (!URL.canParse(value)) {
+        throw new ConfigError(`Invalid ${name} value: ${value}`);
+    }
+    return new URL(value);
+}
+function readUrlEnv(name) {
+    return parseUrlEnv(env[name], name);
+}
+function parseAllowedHosts(envValue) {
+    const hosts = new Set();
+    for (const entry of parseList(envValue)) {
+        const normalized = normalizeHostValue(entry);
+        if (normalized)
+            hosts.add(normalized);
+    }
+    return hosts;
+}
 const MAX_HTML_BYTES = 10 * 1024 * 1024; // 10 MB
 const MAX_INLINE_CONTENT_CHARS = 0;
 const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
@@ -216,23 +223,28 @@ const DEFAULT_TOOL_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS +
     DEFAULT_TOOL_TIMEOUT_PADDING_MS;
 function resolveWorkerResourceLimits() {
     const limits = {};
+    let hasAny = false;
     const maxOldGenerationSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_MAX_OLD_GENERATION_MB, 1);
     const maxYoungGenerationSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB, 1);
     const codeRangeSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_CODE_RANGE_MB, 1);
     const stackSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_STACK_MB, 1);
     if (maxOldGenerationSizeMb !== undefined) {
         limits.maxOldGenerationSizeMb = maxOldGenerationSizeMb;
+        hasAny = true;
     }
     if (maxYoungGenerationSizeMb !== undefined) {
         limits.maxYoungGenerationSizeMb = maxYoungGenerationSizeMb;
+        hasAny = true;
     }
     if (codeRangeSizeMb !== undefined) {
         limits.codeRangeSizeMb = codeRangeSizeMb;
+        hasAny = true;
     }
     if (stackSizeMb !== undefined) {
         limits.stackSizeMb = stackSizeMb;
+        hasAny = true;
     }
-    return Object.keys(limits).length > 0 ? limits : undefined;
+    return hasAny ? limits : undefined;
 }
 function readOAuthUrls(baseUrl) {
     const issuerUrl = readUrlEnv('OAUTH_ISSUER_URL');
@@ -318,8 +330,8 @@ const host = (env.HOST ?? LOOPBACK_V4).trim();
 const port = parsePort(env.PORT);
 const maxConnections = parseInteger(env.SERVER_MAX_CONNECTIONS, 0, 0);
 const blockPrivateConnections = parseBoolean(env.SERVER_BLOCK_PRIVATE_CONNECTIONS, false);
-const baseUrl = new URL(`http://${formatHostForUrl(host)}:${port}`);
 const allowRemote = parseBoolean(env.ALLOW_REMOTE, false);
+const baseUrl = new URL(`http://${formatHostForUrl(host)}:${port}`);
 const runtimeState = {
     httpMode: false,
 };

package/dist/dom-noise-removal.js

@@ -8,6 +8,7 @@ const DIALOG_MIN_CHARS_FOR_PRESERVATION = 500;
 const NAV_FOOTER_MIN_CHARS_FOR_PRESERVATION = 500;
 // Merged markers for fast rejection
 const HTML_DOCUMENT_MARKERS = /<\s*(?:!doctype|html|head|body)\b/i;
+const HTML_FRAGMENT_MARKERS = /<\s*(?:article|main|section|div|nav|footer|header|aside|table|ul|ol)\b/i;
 // Split into smaller regexes to stay within sonarjs/regex-complexity limit
 const NOISE_PATTERNS = [
     /<\s*(?:script|style|noscript|iframe|nav|footer|header|form|button|input|select|textarea|svg|canvas)\b/i,
@@ -451,7 +452,9 @@ function mayContainNoise(html) {
     return NOISE_PATTERNS.some((re) => re.test(sample));
 }
 export function removeNoiseFromHtml(html, document, baseUrl) {
-    const shouldParse = isFullDocumentHtml(html) || mayContainNoise(html);
+    const shouldParse = isFullDocumentHtml(html) ||
+        mayContainNoise(html) ||
+        HTML_FRAGMENT_MARKERS.test(html);
     if (!shouldParse)
         return html;
     try {

package/dist/fetch.d.ts

@@ -42,4 +42,5 @@ export declare function fetchNormalizedUrl(normalizedUrl: string, options?: Fetc
 export declare function fetchNormalizedUrlBuffer(normalizedUrl: string, options?: FetchOptions): Promise<{
     buffer: Uint8Array;
     encoding: string;
+    truncated: boolean;
 }>;