@j0hanz/superfetch 1.2.5 → 2.0.1

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

@@ -1,33 +1,9 @@
-import { ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { FetchError } from '../errors/app-error.js';
-import { isSystemError } from './error-utils.js';
-const IS_DEVELOPMENT_WITH_STACK_TRACES = process.env.NODE_ENV === 'development' &&
-    process.env.EXPOSE_STACK_TRACES === 'true';
-const MCP_ERROR_CODE_MAP = {
-    VALIDATION_ERROR: String(ErrorCode.InvalidParams),
-    INVALID_PARAMS: String(ErrorCode.InvalidParams),
-    INTERNAL_ERROR: String(ErrorCode.InternalError),
-    FETCH_ERROR: String(ErrorCode.InternalError),
-    BATCH_ERROR: String(ErrorCode.InternalError),
-    PROMISE_REJECTED: String(ErrorCode.InternalError),
-    UNKNOWN_ERROR: String(ErrorCode.InternalError),
-};
-const NUMERIC_ERROR_CODE = /^-?\d+$/;
-function normalizeToolErrorCode(code) {
-    if (!code)
-        return String(ErrorCode.InternalError);
-    if (NUMERIC_ERROR_CODE.test(code))
-        return code;
-    if (code.startsWith('HTTP_'))
-        return String(ErrorCode.InternalError);
-    return MCP_ERROR_CODE_MAP[code] ?? code;
-}
-export function createToolErrorResponse(message, url, code, details = {}) {
+import { isSystemError } from './error-details.js';
+export function createToolErrorResponse(message, url) {
     const structuredContent = {
-        ...details,
         error: message,
         url,
-        errorCode: normalizeToolErrorCode(code),
     };
     return {
         content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
@@ -35,29 +11,21 @@ export function createToolErrorResponse(message, url, code, details = {}) {
         isError: true,
     };
 }
-function formatErrorMessage(baseMessage, error, fallback) {
-    const message = fallback ? `${fallback}: ${error.message}` : error.message;
-    if (IS_DEVELOPMENT_WITH_STACK_TRACES && error.stack) {
-        return `${message}\n${error.stack}`;
-    }
-    return message;
-}
-export function handleToolError(error, url, fallbackMessage = 'Operation failed', details = {}) {
-    if (isValidationError(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, details);
-    }
-    if (error instanceof Error) {
-        const message = formatErrorMessage(error.message, error, fallbackMessage);
-        return createToolErrorResponse(message, url, 'UNKNOWN_ERROR', details);
-    }
-    return createToolErrorResponse(`${fallbackMessage}: Unknown error`, url, 'UNKNOWN_ERROR', details);
+export function handleToolError(error, url, fallbackMessage = 'Operation failed') {
+    const message = resolveToolErrorMessage(error, fallbackMessage);
+    return createToolErrorResponse(message, url);
 }
 function isValidationError(error) {
     return (error instanceof Error &&
         isSystemError(error) &&
         error.code === 'VALIDATION_ERROR');
 }
+function resolveToolErrorMessage(error, fallbackMessage) {
+    if (isValidationError(error) || error instanceof FetchError) {
+        return error.message;
+    }
+    if (error instanceof Error) {
+        return `${fallbackMessage}: ${error.message}`;
+    }
+    return `${fallbackMessage}: Unknown error`;
+}

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

@@ -0,0 +1,7 @@
+export interface TransformResult {
+    readonly url: string;
+    readonly transformed: boolean;
+    readonly platform?: string;
+}
+export declare function transformToRawUrl(url: string): TransformResult;
+export declare function isRawTextContentUrl(url: string): boolean;

package/dist/utils/url-transformer.js

@@ -0,0 +1,147 @@
+import { logDebug } from '../services/logger.js';
+const GITHUB_BLOB_RULE = {
+    name: 'github',
+    pattern: /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/i,
+    transform: (match) => {
+        const owner = match[1] ?? '';
+        const repo = match[2] ?? '';
+        const branch = match[3] ?? '';
+        const path = match[4] ?? '';
+        return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${path}`;
+    },
+};
+const GITHUB_GIST_RULE = {
+    name: 'github-gist',
+    pattern: /^https?:\/\/gist\.github\.com\/([^/]+)\/([a-f0-9]+)(?:#file-(.+)|\/raw\/([^/]+))?$/i,
+    transform: (match) => {
+        const user = match[1] ?? '';
+        const gistId = match[2] ?? '';
+        const hashFile = match[3];
+        const rawFile = match[4];
+        const filename = rawFile ?? hashFile?.replace(/-/g, '.');
+        const filePath = filename ? `/${filename}` : '';
+        return `https://gist.githubusercontent.com/${user}/${gistId}/raw${filePath}`;
+    },
+};
+const GITLAB_BLOB_RULE = {
+    name: 'gitlab',
+    pattern: /^(https?:\/\/(?:[^/]+\.)?gitlab\.com\/[^/]+\/[^/]+)\/-\/blob\/([^/]+)\/(.+)$/i,
+    transform: (match) => {
+        const baseUrl = match[1] ?? '';
+        const branch = match[2] ?? '';
+        const path = match[3] ?? '';
+        return `${baseUrl}/-/raw/${branch}/${path}`;
+    },
+};
+const BITBUCKET_SRC_RULE = {
+    name: 'bitbucket',
+    pattern: /^(https?:\/\/(?:www\.)?bitbucket\.org\/[^/]+\/[^/]+)\/src\/([^/]+)\/(.+)$/i,
+    transform: (match) => {
+        const baseUrl = match[1] ?? '';
+        const branch = match[2] ?? '';
+        const path = match[3] ?? '';
+        return `${baseUrl}/raw/${branch}/${path}`;
+    },
+};
+const TRANSFORM_RULES = [
+    GITHUB_BLOB_RULE,
+    GITHUB_GIST_RULE,
+    GITLAB_BLOB_RULE,
+    BITBUCKET_SRC_RULE,
+];
+function isRawUrl(url) {
+    const lowerUrl = url.toLowerCase();
+    return (lowerUrl.includes('raw.githubusercontent.com') ||
+        lowerUrl.includes('gist.githubusercontent.com') ||
+        lowerUrl.includes('/-/raw/') ||
+        /bitbucket\.org\/[^/]+\/[^/]+\/raw\//.test(lowerUrl));
+}
+function getUrlWithoutParams(url) {
+    const hashIndex = url.indexOf('#');
+    const queryIndex = url.indexOf('?');
+    let endIndex = url.length;
+    if (queryIndex !== -1) {
+        if (hashIndex !== -1) {
+            endIndex = Math.min(queryIndex, hashIndex);
+        }
+        else {
+            endIndex = queryIndex;
+        }
+    }
+    else if (hashIndex !== -1) {
+        endIndex = hashIndex;
+    }
+    const hash = hashIndex !== -1 ? url.slice(hashIndex) : '';
+    return {
+        base: url.slice(0, endIndex),
+        hash,
+    };
+}
+function resolveUrlToMatch(rule, base, hash) {
+    if (rule.name !== 'github-gist')
+        return base;
+    if (!hash.startsWith('#file-'))
+        return base;
+    return base + hash;
+}
+function applyTransformRules(base, hash) {
+    for (const rule of TRANSFORM_RULES) {
+        const urlToMatch = resolveUrlToMatch(rule, base, hash);
+        const match = rule.pattern.exec(urlToMatch);
+        if (match) {
+            return { url: rule.transform(match), platform: rule.name };
+        }
+    }
+    return null;
+}
+export function transformToRawUrl(url) {
+    if (!url)
+        return { url, transformed: false };
+    if (isRawUrl(url)) {
+        return { url, transformed: false };
+    }
+    const { base, hash } = getUrlWithoutParams(url);
+    const result = applyTransformRules(base, hash);
+    if (!result)
+        return { url, transformed: false };
+    logDebug('URL transformed to raw content URL', {
+        platform: result.platform,
+        original: url.substring(0, 100),
+        transformed: result.url.substring(0, 100),
+    });
+    return {
+        url: result.url,
+        transformed: true,
+        platform: result.platform,
+    };
+}
+const RAW_TEXT_EXTENSIONS = new Set([
+    '.md',
+    '.markdown',
+    '.txt',
+    '.json',
+    '.yaml',
+    '.yml',
+    '.toml',
+    '.xml',
+    '.csv',
+    '.rst',
+    '.adoc',
+    '.org',
+]);
+export function isRawTextContentUrl(url) {
+    if (!url)
+        return false;
+    if (isRawUrl(url))
+        return true;
+    const { base } = getUrlWithoutParams(url);
+    const lowerBase = base.toLowerCase();
+    return hasKnownRawTextExtension(lowerBase);
+}
+function hasKnownRawTextExtension(urlBaseLower) {
+    for (const ext of RAW_TEXT_EXTENSIONS) {
+        if (urlBaseLower.endsWith(ext))
+            return true;
+    }
+    return false;
+}

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

@@ -1,7 +1,6 @@
 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>;
+export declare function validateAndNormalizeUrl(urlString: string): string;

package/dist/utils/url-validator.js

@@ -1,29 +1,38 @@
-import { lookup } from 'node:dns/promises';
 import { BlockList, isIP } from 'node:net';
 import { config } from '../config/index.js';
-import { createErrorWithCode } from './error-utils.js';
+import { createErrorWithCode } from './error-details.js';
+import { buildIpv4, buildIpv6 } from './ip-address.js';
 const BLOCK_LIST = new BlockList();
+const IPV6_ZERO = buildIpv6([0, 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_LOOPBACK = buildIpv6([0, 0, 0, 0, 0, 0, 0, 1]);
+const IPV6_64_FF9B = buildIpv6(['64', 'ff9b', 0, 0, 0, 0, 0, 0]);
+const IPV6_64_FF9B_1 = buildIpv6(['64', 'ff9b', 1, 0, 0, 0, 0, 0]);
+const IPV6_2001 = buildIpv6(['2001', 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_2002 = buildIpv6(['2002', 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_FC00 = buildIpv6(['fc00', 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_FE80 = buildIpv6(['fe80', 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_FF00 = buildIpv6(['ff00', 0, 0, 0, 0, 0, 0, 0]);
 const BLOCKED_IPV4_SUBNETS = [
-    { subnet: '0.0.0.0', prefix: 8 },
-    { subnet: '10.0.0.0', prefix: 8 },
-    { subnet: '100.64.0.0', prefix: 10 },
-    { subnet: '127.0.0.0', prefix: 8 },
-    { subnet: '169.254.0.0', prefix: 16 },
-    { subnet: '172.16.0.0', prefix: 12 },
-    { subnet: '192.168.0.0', prefix: 16 },
-    { subnet: '224.0.0.0', prefix: 4 },
-    { subnet: '240.0.0.0', prefix: 4 },
+    { subnet: buildIpv4([0, 0, 0, 0]), prefix: 8 },
+    { subnet: buildIpv4([10, 0, 0, 0]), prefix: 8 },
+    { subnet: buildIpv4([100, 64, 0, 0]), prefix: 10 },
+    { subnet: buildIpv4([127, 0, 0, 0]), prefix: 8 },
+    { subnet: buildIpv4([169, 254, 0, 0]), prefix: 16 },
+    { subnet: buildIpv4([172, 16, 0, 0]), prefix: 12 },
+    { subnet: buildIpv4([192, 168, 0, 0]), prefix: 16 },
+    { subnet: buildIpv4([224, 0, 0, 0]), prefix: 4 },
+    { subnet: buildIpv4([240, 0, 0, 0]), prefix: 4 },
 ];
 const BLOCKED_IPV6_SUBNETS = [
-    { subnet: '::', prefix: 128 },
-    { subnet: '::1', prefix: 128 },
-    { subnet: '64:ff9b::', prefix: 96 },
-    { subnet: '64:ff9b:1::', prefix: 48 },
-    { subnet: '2001::', prefix: 32 },
-    { subnet: '2002::', prefix: 16 },
-    { subnet: 'fc00::', prefix: 7 },
-    { subnet: 'fe80::', prefix: 10 },
-    { subnet: 'ff00::', prefix: 8 },
+    { subnet: IPV6_ZERO, prefix: 128 },
+    { subnet: IPV6_LOOPBACK, prefix: 128 },
+    { subnet: IPV6_64_FF9B, prefix: 96 },
+    { subnet: IPV6_64_FF9B_1, prefix: 48 },
+    { subnet: IPV6_2001, prefix: 32 },
+    { subnet: IPV6_2002, prefix: 16 },
+    { subnet: IPV6_FC00, prefix: 7 },
+    { subnet: IPV6_FE80, prefix: 10 },
+    { subnet: IPV6_FF00, prefix: 8 },
 ];
 for (const entry of BLOCKED_IPV4_SUBNETS) {
     BLOCK_LIST.addSubnet(entry.subnet, entry.prefix, 'ipv4');
@@ -31,36 +40,6 @@ for (const entry of BLOCKED_IPV4_SUBNETS) {
 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)) {
@@ -91,55 +70,6 @@ function isBlockedByList(ip, ipType) {
     }
     return BLOCK_LIST.check(ip, 'ipv6');
 }
-function lookupWithTimeout(hostname) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(createValidationError(`DNS lookup timed out for ${hostname}`));
-        }, DNS_LOOKUP_TIMEOUT_MS);
-        lookup(hostname, { all: true })
-            .then((result) => {
-            clearTimeout(timer);
-            resolve(result);
-        })
-            .catch((error) => {
-            clearTimeout(timer);
-            reject(error instanceof Error ? error : createValidationError(String(error)));
-        });
-    });
-}
-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];
-        if (addresses.length === 0) {
-            throw createValidationError(`Unable to resolve hostname: ${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;
-        if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
-            throw createValidationError(`Unable to resolve hostname: ${hostname}`);
-        }
-        if (error instanceof Error) {
-            throw error;
-        }
-        throw createValidationError(String(error));
-    }
-}
 export function normalizeUrl(urlString) {
     const trimmedUrl = requireTrimmedUrl(urlString);
     assertUrlLength(trimmedUrl);
@@ -150,10 +80,8 @@ export function normalizeUrl(urlString) {
     assertHostnameAllowed(hostname);
     return { normalizedUrl: url.href, hostname };
 }
-export async function validateAndNormalizeUrl(urlString) {
-    const { normalizedUrl, hostname } = normalizeUrl(urlString);
-    await assertResolvedAddressesAllowed(hostname);
-    return normalizedUrl;
+export function validateAndNormalizeUrl(urlString) {
+    return normalizeUrl(urlString).normalizedUrl;
 }
 const VALIDATION_ERROR_CODE = 'VALIDATION_ERROR';
 function createValidationError(message) {
@@ -175,10 +103,12 @@ function assertUrlLength(url) {
     throw createValidationError(`URL exceeds maximum length of ${config.constants.maxUrlLength} characters`);
 }
 function parseUrl(urlString) {
-    if (!URL.canParse(urlString)) {
+    try {
+        return new URL(urlString);
+    }
+    catch {
         throw createValidationError('Invalid URL format');
     }
-    return new URL(urlString);
 }
 function assertHttpProtocol(url) {
     if (url.protocol === 'http:' || url.protocol === 'https:')
@@ -199,15 +129,24 @@ function normalizeHostname(url) {
 }
 const BLOCKED_HOST_SUFFIXES = ['.local', '.internal'];
 function assertHostnameAllowed(hostname) {
-    if (config.security.blockedHosts.has(hostname)) {
-        throw createValidationError(`Blocked host: ${hostname}. Internal hosts are not allowed`);
-    }
-    if (isBlockedIp(hostname)) {
-        throw createValidationError(`Blocked IP range: ${hostname}. Private IPs are not allowed`);
-    }
-    if (matchesBlockedSuffix(hostname)) {
-        throw createValidationError(`Blocked hostname pattern: ${hostname}. Internal domain suffixes are not allowed`);
-    }
+    assertNotBlockedHost(hostname);
+    assertNotBlockedIp(hostname);
+    assertNotBlockedHostnameSuffix(hostname);
+}
+function assertNotBlockedHost(hostname) {
+    if (!config.security.blockedHosts.has(hostname))
+        return;
+    throw createValidationError(`Blocked host: ${hostname}. Internal hosts are not allowed`);
+}
+function assertNotBlockedIp(hostname) {
+    if (!isBlockedIp(hostname))
+        return;
+    throw createValidationError(`Blocked IP range: ${hostname}. Private IPs are not allowed`);
+}
+function assertNotBlockedHostnameSuffix(hostname) {
+    if (!matchesBlockedSuffix(hostname))
+        return;
+    throw createValidationError(`Blocked hostname pattern: ${hostname}. Internal domain suffixes are not allowed`);
 }
 function matchesBlockedSuffix(hostname) {
     return BLOCKED_HOST_SUFFIXES.some((suffix) => hostname.endsWith(suffix));

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

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

package/dist/workers/content-transform.worker.js

@@ -0,0 +1,40 @@
+import { parentPort } from 'node:worker_threads';
+import { isRecord } from '../utils/guards.js';
+import { transformHtmlToMarkdownSync } from '../tools/utils/content-transform.js';
+const port = parentPort;
+function isWorkerTransformRequest(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'number' &&
+        typeof value.html === 'string' &&
+        typeof value.url === 'string' &&
+        typeof value.options === 'object');
+}
+function handleMessage(value) {
+    if (!port)
+        return;
+    if (!isWorkerTransformRequest(value))
+        return;
+    const { id, html, url, options } = value;
+    try {
+        const result = transformHtmlToMarkdownSync(html, url, options);
+        const response = {
+            id,
+            ok: true,
+            result,
+        };
+        port.postMessage(response);
+    }
+    catch (error) {
+        const response = {
+            id,
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+        port.postMessage(response);
+    }
+}
+if (!port) {
+    process.exit(1);
+}
+port.on('message', handleMessage);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@j0hanz/superfetch",
-  "version": "1.2.5",
+  "version": "2.0.1",
   "mcpName": "io.github.j0hanz/superfetch",
-  "description": "Intelligent web content fetcher MCP server that converts HTML to clean, AI-readable JSONL format",
+  "description": "Intelligent web content fetcher MCP server that converts HTML to clean, AI-readable Markdown",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -28,54 +28,53 @@
     "web-fetching",
     "content-extraction",
     "readability",
-    "jsonl",
+    "markdown",
     "ai-tools",
     "model-context-protocol",
     "superfetch"
   ],
   "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "build": "tsc -p tsconfig.build.json && shx chmod +x dist/*.js",
+    "build": "tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run build && npm run lint",
+    "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
-    "release": "node scripts/release.js",
     "format": "prettier --write .",
     "type-check": "tsc --noEmit",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "npm run build --silent && node --test --experimental-transform-types",
     "test:coverage": "npm run build --silent && node --test --experimental-transform-types --experimental-test-coverage",
-    "bench": "npm run build && node scripts/bench.mjs",
     "knip": "knip",
-    "knip:fix": "knip --fix"
+    "knip:fix": "knip --fix",
+    "inspector": "npx @modelcontextprotocol/inspector",
+    "prepublishOnly": "npm run lint && npm run type-check && npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "@mozilla/readability": "^0.6.0",
-    "cheerio": "^1.1.2",
-    "domhandler": "^5.0.3",
     "express": "^5.2.1",
     "linkedom": "^0.18.12",
     "turndown": "^7.2.2",
-    "undici": "^6.22.0",
-    "zod": "^4.3.4"
+    "undici": "^6.23.0",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@trivago/prettier-plugin-sort-imports": "^6.0.0",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/express": "^5.0.6",
     "@types/node": "^22.19.3",
     "@types/turndown": "^5.0.6",
     "eslint": "^9.23.2",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-de-morgan": "^2.0.0",
+    "eslint-plugin-depend": "^1.4.0",
+    "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unused-imports": "^4.3.0",
-    "knip": "^5.78.0",
+    "knip": "^5.80.1",
     "prettier": "^3.7.4",
-    "shx": "^0.4.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.51.0"
+    "typescript-eslint": "^8.52.0"
   },
   "engines": {
     "node": ">=20.12.0"