rsshub 1.0.0-master.fd741f1 → 1.0.0-master.fd8463a

package/lib/utils/puppeteer.ts

@@ -1,45 +1,42 @@
 import { config } from '@/config';
-import puppeteer from 'puppeteer';
+import puppeteer, { Browser, Page } from 'rebrowser-puppeteer';
 import logger from './logger';
 import proxy from './proxy';
-import proxyChain from 'proxy-chain';
-
-import { type PuppeteerExtra, addExtra } from 'puppeteer-extra';
-import StealthPlugin from 'puppeteer-extra-plugin-stealth';
-
-const options = {
-    args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-infobars', '--window-position=0,0', '--ignore-certificate-errors', '--ignore-certificate-errors-spki-list', `--user-agent=${config.ua}`],
-    headless: true,
-    ignoreHTTPSErrors: true,
-};
+import { anonymizeProxy } from 'proxy-chain';
 
 /**
- * @param {Object} extraOptions
- * @param {boolean} extraOptions.stealth - Use puppeteer-extra-plugin-stealth
+ * @deprecated use getPage instead
  * @returns Puppeteer browser
  */
-const outPuppeteer = async (
-    extraOptions: {
-        stealth?: boolean;
-    } = {}
-) => {
-    let insidePuppeteer: PuppeteerExtra | typeof puppeteer = puppeteer;
-    if (extraOptions.stealth) {
-        insidePuppeteer = addExtra(puppeteer);
-        insidePuppeteer.use(StealthPlugin());
-    }
+const outPuppeteer = async () => {
+    const options = {
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-blink-features=AutomationControlled',
+            '--window-position=0,0',
+            '--ignore-certificate-errors',
+            '--ignore-certificate-errors-spki-list',
+            `--user-agent=${config.ua}`,
+        ],
+        headless: true,
+        ignoreHTTPSErrors: true,
+    };
 
-    if (proxy.proxyUri) {
-        if (proxy.proxyUrlHandler?.username || proxy.proxyUrlHandler?.password) {
+    const insidePuppeteer: typeof puppeteer = puppeteer;
+
+    const currentProxy = proxy.getCurrentProxy();
+    if (currentProxy && proxy.proxyObj.url_regex === '.*') {
+        if (currentProxy.urlHandler?.username || currentProxy.urlHandler?.password) {
             // only proxies with authentication need to be anonymized
-            if (proxy.proxyUrlHandler.protocol === 'http:') {
-                options.args.push(`--proxy-server=${await proxyChain.anonymizeProxy(proxy.proxyUri)}`);
+            if (currentProxy.urlHandler.protocol === 'http:') {
+                options.args.push(`--proxy-server=${await anonymizeProxy(currentProxy.uri)}`);
             } else {
                 logger.warn('SOCKS/HTTPS proxy with authentication is not supported by puppeteer, continue without proxy');
             }
         } else {
             // Chromium cannot recognize socks5h and socks4a, so we need to trim their postfixes
-            options.args.push(`--proxy-server=${proxy.proxyUri.replace('socks5h://', 'socks5://').replace('socks4a://', 'socks4://')}`);
+            options.args.push(`--proxy-server=${currentProxy.uri.replace('socks5h://', 'socks5://').replace('socks4a://', 'socks4://')}`);
         }
     }
     const browser = await (config.puppeteerWSEndpoint
@@ -62,3 +59,130 @@ const outPuppeteer = async (
 };
 
 export default outPuppeteer;
+
+/**
+ * @returns Puppeteer page
+ */
+export const getPuppeteerPage = async (
+    url: string,
+    instanceOptions: {
+        onBeforeLoad?: (page: Page, browser?: Browser) => Promise<void> | void;
+        gotoConfig?: {
+            waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+        };
+        noGoto?: boolean;
+    } = {}
+) => {
+    const options = {
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-blink-features=AutomationControlled',
+            '--window-position=0,0',
+            '--ignore-certificate-errors',
+            '--ignore-certificate-errors-spki-list',
+            `--user-agent=${config.ua}`,
+        ],
+        headless: true,
+        ignoreHTTPSErrors: true,
+    };
+
+    const insidePuppeteer: typeof puppeteer = puppeteer;
+
+    let allowProxy = false;
+    const proxyRegex = new RegExp(proxy.proxyObj.url_regex);
+    let urlHandler;
+    try {
+        urlHandler = new URL(url);
+    } catch {
+        // ignore
+    }
+
+    if (proxyRegex.test(url) && url.startsWith('http') && !(urlHandler && urlHandler.host === proxy.proxyUrlHandler?.host)) {
+        allowProxy = true;
+    }
+
+    let hasProxy = false;
+    let currentProxyState: any = null;
+    const currentProxy = proxy.getCurrentProxy();
+    if (currentProxy && allowProxy) {
+        currentProxyState = currentProxy;
+        if (currentProxy.urlHandler?.username || currentProxy.urlHandler?.password) {
+            // only proxies with authentication need to be anonymized
+            if (currentProxy.urlHandler.protocol === 'http:') {
+                const urlObj = new URL(currentProxy.uri);
+                urlObj.username = '';
+                urlObj.password = '';
+                options.args.push(`--proxy-server=${urlObj.toString().replace(/\/$/, '')}`);
+                hasProxy = true;
+            } else {
+                logger.warn('SOCKS/HTTPS proxy with authentication is not supported by puppeteer, continue without proxy');
+            }
+        } else {
+            // Chromium cannot recognize socks5h and socks4a, so we need to trim their postfixes
+            options.args.push(`--proxy-server=${currentProxy.uri.replace('socks5h://', 'socks5://').replace('socks4a://', 'socks4://')}`);
+            hasProxy = true;
+        }
+    }
+    let browser: Browser;
+    if (config.puppeteerWSEndpoint) {
+        const endpointURL = new URL(config.puppeteerWSEndpoint);
+        endpointURL.searchParams.set('launch', JSON.stringify(options));
+        endpointURL.searchParams.set('stealth', 'true');
+        const endpoint = endpointURL.toString();
+        browser = await insidePuppeteer.connect({
+            browserWSEndpoint: endpoint,
+        });
+    } else {
+        browser = await insidePuppeteer.launch(
+            config.chromiumExecutablePath
+                ? {
+                      executablePath: config.chromiumExecutablePath,
+                      ...options,
+                  }
+                : options
+        );
+    }
+
+    setTimeout(async () => {
+        await browser.close();
+    }, 30000);
+
+    const page = await browser.newPage();
+
+    if (hasProxy && currentProxyState) {
+        logger.debug(`Proxying request in puppeteer via ${currentProxyState.uri}: ${url}`);
+    }
+
+    if (hasProxy && currentProxyState && (currentProxyState.urlHandler?.username || currentProxyState.urlHandler?.password)) {
+        await page.authenticate({
+            username: currentProxyState.urlHandler?.username,
+            password: currentProxyState.urlHandler?.password,
+        });
+    }
+
+    if (instanceOptions.onBeforeLoad) {
+        await instanceOptions.onBeforeLoad(page, browser);
+    }
+
+    if (!instanceOptions.noGoto) {
+        try {
+            await page.goto(url, instanceOptions.gotoConfig || { waitUntil: 'domcontentloaded' });
+        } catch (error) {
+            if (hasProxy && currentProxyState && proxy.multiProxy) {
+                logger.warn(`Puppeteer navigation failed with proxy ${currentProxyState.uri}, marking as failed: ${error}`);
+                proxy.markProxyFailed(currentProxyState.uri);
+                throw error;
+            }
+            throw error;
+        }
+    }
+
+    return {
+        page,
+        destory: async () => {
+            await browser.close();
+        },
+        browser,
+    };
+};

package/lib/utils/rand-user-agent.test.ts

@@ -7,14 +7,14 @@ const mobileUa = randUserAgent({ browser: 'mobile safari', os: 'ios', device: 'm
 
 describe('rand-user-agent', () => {
     it('chrome should not include headlesschrome', () => {
-        const uaArr = Array(100)
+        const uaArr = Array.from({ length: 100 })
             .fill(null)
             .map(() => randUserAgent({ browser: 'chrome', os: 'windows' }));
         const match = uaArr.find((e) => !!(e.includes('Chrome-Lighthouse') || e.includes('HeadlessChrome')));
         expect(match).toBeFalsy();
     });
     it('chrome should not include electron', () => {
-        const uaArr = Array(100)
+        const uaArr = Array.from({ length: 100 })
             .fill(null)
             .map(() => randUserAgent({ browser: 'chrome', os: 'windows' }));
         const match = uaArr.find((e) => !!e.includes('Electron'));

package/lib/utils/readable-social.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from 'vitest';
+import { fallback, queryToBoolean, queryToInteger, queryToFloat } from './readable-social';
+
+describe('fallback', () => {
+    test('应该返回第一个存在的参数', () => {
+        expect(fallback('primary', 'secondary', 'default')).toBe('primary');
+        expect(fallback(undefined, 42, 0)).toBe(42);
+        expect(fallback(null, '', 'default')).toBe('');
+    });
+
+    test('应该返回默认值', () => {
+        expect(fallback(undefined, null, 'default')).toBe('default');
+        expect(fallback(null, undefined, 3.14)).toBe(3.14);
+    });
+});
+
+describe('queryToBoolean', () => {
+    test('should handle truthy values', () => {
+        expect(queryToBoolean('1')).toBe(true);
+        expect(queryToBoolean('true')).toBe(true);
+    });
+
+    test('should handle falsy values', () => {
+        expect(queryToBoolean('0')).toBe(false);
+        expect(queryToBoolean('false')).toBe(false);
+    });
+});
+
+describe('queryToInteger', () => {
+    test('should parse valid integers', () => {
+        expect(queryToInteger('42')).toBe(42);
+        expect(queryToInteger('-3')).toBe(-3);
+    });
+
+    test('should handle invalid inputs', () => {
+        expect(queryToInteger(null)).toBeNull();
+        expect(queryToInteger('abc')).toBeNaN();
+    });
+});
+
+describe('queryToFloat', () => {
+    test('should handle undefined', () => {
+        expect(queryToFloat(undefined)).toBeUndefined();
+    });
+
+    test('should handle null', () => {
+        expect(queryToFloat(null)).toBeNull();
+    });
+
+    test('should return undefined for invalid input', () => {
+        expect(queryToFloat('invalid')).toBeNaN();
+    });
+
+    test('should process array input', () => {
+        expect(queryToFloat(['3.14'])).toBe(3.14);
+    });
+
+    test('should convert numeric string', () => {
+        expect(queryToFloat('9.8')).toBe(9.8);
+    });
+
+    test('should handle edge cases', () => {
+        expect(queryToFloat('3.1415926')).toBeCloseTo(3.141_592_6);
+    });
+});

package/lib/utils/readable-social.ts

@@ -39,4 +39,18 @@ const queryToInteger = (s) => {
     return Number.parseInt(s);
 };
 
-export { fallback, queryToBoolean, queryToInteger };
+const queryToFloat = (s) => {
+    if (s === undefined || s === null) {
+        return s;
+    }
+    if (Array.isArray(s)) {
+        if (s.length === 0) {
+            return;
+        }
+        s = s[0];
+    }
+    s = s.toString();
+    return Number.parseFloat(s);
+};
+
+export { fallback, queryToBoolean, queryToInteger, queryToFloat };

package/lib/utils/request-rewriter/fetch.ts

@@ -60,7 +60,7 @@ const wrappedFetch: typeof undici.fetch = async (input: RequestInfo, init?: Requ
     config.enableRemoteDebugging && useCustomHeader(request.headers);
 
     // proxy
-    if (!init?.dispatcher && proxy.dispatcher && (proxy.proxyObj.strategy !== 'on_retry' || isRetry)) {
+    if (!init?.dispatcher && (proxy.proxyObj.strategy !== 'on_retry' || isRetry)) {
         const proxyRegex = new RegExp(proxy.proxyObj.url_regex);
         let urlHandler;
         try {
@@ -70,13 +70,51 @@ const wrappedFetch: typeof undici.fetch = async (input: RequestInfo, init?: Requ
         }
 
         if (proxyRegex.test(request.url) && request.url.startsWith('http') && !(urlHandler && urlHandler.host === proxy.proxyUrlHandler?.host)) {
-            options.dispatcher = proxy.dispatcher;
-            logger.debug(`Proxying request: ${request.url}`);
+            const currentProxy = proxy.getCurrentProxy();
+            if (currentProxy) {
+                const dispatcher = proxy.getDispatcherForProxy(currentProxy);
+                if (dispatcher) {
+                    options.dispatcher = dispatcher;
+                    logger.debug(`Proxying request via ${currentProxy.uri}: ${request.url}`);
+                }
+            }
         }
     }
 
     await limiterQueue.removeTokens(1);
-    return undici.fetch(request, options);
+
+    const maxRetries = proxy.multiProxy?.allProxies.length || 1;
+
+    const attemptRequest = async (attempt: number): Promise<Response> => {
+        try {
+            return await undici.fetch(request, options);
+        } catch (error) {
+            if (options.dispatcher && proxy.multiProxy && attempt < maxRetries - 1) {
+                const currentProxy = proxy.getCurrentProxy();
+                if (currentProxy) {
+                    logger.warn(`Request failed with proxy ${currentProxy.uri}, trying next proxy: ${error}`);
+                    proxy.markProxyFailed(currentProxy.uri);
+
+                    const nextProxy = proxy.getCurrentProxy();
+                    if (nextProxy && nextProxy.uri !== currentProxy.uri) {
+                        const nextDispatcher = proxy.getDispatcherForProxy(nextProxy);
+                        if (nextDispatcher) {
+                            options.dispatcher = nextDispatcher;
+                        }
+                        logger.debug(`Retrying request with proxy ${nextProxy.uri}: ${request.url}`);
+                        return attemptRequest(attempt + 1);
+                    } else {
+                        logger.warn('No more proxies available, trying without proxy');
+                        delete options.dispatcher;
+                        return attemptRequest(attempt + 1);
+                    }
+                }
+            }
+            throw error;
+        }
+    };
+
+    return attemptRequest(0);
 };
 
 export default wrappedFetch;

package/lib/utils/timezone.ts

@@ -1,4 +1,4 @@
-import { strict as assert } from 'assert';
+import { strict as assert } from 'node:assert';
 
 const millisInAnHour = 60 * 60 * 1000;
 const serverTimezone = -new Date().getTimezoneOffset() / 60;

package/lib/utils/wechat-mp.ts

@@ -26,7 +26,8 @@
  */
 
 import ofetch from '@/utils/ofetch';
-import { type Cheerio, type CheerioAPI, type Element, load } from 'cheerio';
+import { type Cheerio, type CheerioAPI, load } from 'cheerio';
+import type { Element } from 'domhandler';
 import { parseDate } from '@/utils/parse-date';
 import cache from '@/utils/cache';
 import logger from '@/utils/logger';
@@ -127,7 +128,7 @@ const showTypeMap = {
 const showTypeMapReverse = Object.fromEntries(Object.entries(showTypeMap).map(([k, v]) => [v, k]));
 
 class ExtractMetadata {
-    private static genAssignmentRegExp = (varName: string, valuePattern: string, assignPattern: string) => RegExp(`\\b${varName}\\s*${assignPattern}\\s*(?<quote>["'])(?<value>${valuePattern})\\k<quote>`, 'mg');
+    private static genAssignmentRegExp = (varName: string, valuePattern: string, assignPattern: string) => new RegExp(`\\b${varName}\\s*${assignPattern}\\s*(?<quote>["'])(?<value>${valuePattern})\\k<quote>`, 'mg');
 
     private static genExtractFunc = (
         varName: string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsshub",
-  "version": "1.0.0-master.fd741f1",
+  "version": "1.0.0-master.fd8463a",
   "description": "Make RSS Great Again!",
   "keywords": [
     "RSS"
@@ -33,148 +33,148 @@
   },
   "dependencies": {
     "@bbob/html": "4.2.0",
+    "@bbob/plugin-helper": "4.2.0",
     "@bbob/preset-html5": "4.2.0",
-    "@hono/node-server": "1.13.8",
-    "@hono/zod-openapi": "0.19.2",
-    "@notionhq/client": "2.3.0",
+    "@hono/node-server": "1.14.4",
+    "@hono/zod-openapi": "0.19.9",
+    "@notionhq/client": "3.1.3",
     "@opentelemetry/api": "1.9.0",
-    "@opentelemetry/exporter-prometheus": "0.57.2",
-    "@opentelemetry/exporter-trace-otlp-http": "0.57.2",
-    "@opentelemetry/resources": "1.30.1",
-    "@opentelemetry/sdk-metrics": "1.30.1",
-    "@opentelemetry/sdk-trace-base": "1.30.1",
-    "@opentelemetry/semantic-conventions": "1.30.0",
+    "@opentelemetry/exporter-prometheus": "0.202.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.202.0",
+    "@opentelemetry/resources": "2.0.1",
+    "@opentelemetry/sdk-metrics": "2.0.1",
+    "@opentelemetry/sdk-trace-base": "2.0.1",
+    "@opentelemetry/semantic-conventions": "1.34.0",
     "@postlight/parser": "2.2.3",
     "@rss3/sdk": "0.0.25",
-    "@scalar/hono-api-reference": "0.7.2",
-    "@sentry/node": "9.7.0",
+    "@scalar/hono-api-reference": "0.9.7",
+    "@sentry/node": "9.33.0",
     "@tonyrl/rand-user-agent": "2.0.83",
     "aes-js": "3.1.2",
     "art-template": "4.13.2",
-    "cheerio": "1.0.0",
-    "chrono-node": "2.7.8",
-    "city-timezones": "1.3.0",
+    "cheerio": "1.1.0",
+    "city-timezones": "1.3.1",
     "cross-env": "7.0.3",
     "crypto-js": "4.2.0",
     "currency-symbol-map": "5.1.0",
     "dayjs": "1.11.8",
-    "destr": "2.0.3",
+    "destr": "2.0.5",
     "directory-import": "3.3.2",
-    "dotenv": "16.4.7",
-    "entities": "6.0.0",
+    "dotenv": "17.0.0",
+    "entities": "6.0.1",
     "etag": "1.8.1",
     "fanfou-sdk": "5.0.0",
-    "form-data": "4.0.2",
-    "googleapis": "148.0.0",
-    "hono": "4.7.5",
+    "form-data": "4.0.3",
+    "googleapis": "150.0.1",
+    "hono": "4.8.3",
     "html-to-text": "9.0.5",
     "http-cookie-agent": "6.0.8",
     "https-proxy-agent": "7.0.6",
     "iconv-lite": "0.6.3",
-    "imapflow": "1.0.184",
+    "imapflow": "1.0.188",
     "instagram-private-api": "1.46.1",
-    "ioredis": "5.6.0",
+    "ioredis": "5.6.1",
     "ip-regex": "5.0.0",
-    "jsdom": "26.0.0",
+    "jsdom": "26.1.0",
     "json-bigint": "1.0.0",
     "jsonpath-plus": "10.3.0",
     "jsrsasign": "10.9.0",
-    "lru-cache": "11.0.2",
+    "lru-cache": "11.1.0",
     "lz-string": "1.5.0",
-    "mailparser": "3.7.2",
+    "mailparser": "3.7.4",
     "markdown-it": "14.1.0",
+    "mixi2": "0.2.2",
     "module-alias": "2.2.3",
-    "narou": "1.1.0",
-    "notion-to-md": "3.1.7",
+    "narou": "1.2.0",
+    "notion-to-md": "3.1.9",
     "oauth-1.0a": "2.2.6",
     "ofetch": "1.4.1",
     "otplib": "12.0.1",
+    "p-map": "7.0.3",
     "pac-proxy-agent": "7.2.0",
-    "proxy-chain": "2.5.7",
-    "puppeteer": "22.6.2",
-    "puppeteer-extra": "3.3.6",
-    "puppeteer-extra-plugin-stealth": "2.11.2",
-    "puppeteer-extra-plugin-user-data-dir": "2.4.1",
-    "puppeteer-extra-plugin-user-preferences": "2.4.1",
-    "query-string": "9.1.1",
-    "rate-limiter-flexible": "6.2.0",
+    "proxy-chain": "2.5.9",
+    "query-string": "9.2.1",
+    "rate-limiter-flexible": "7.1.1",
     "re2js": "1.1.0",
+    "rebrowser-puppeteer": "24.8.1",
     "rfc4648": "1.5.4",
     "rss-parser": "3.13.0",
-    "sanitize-html": "2.15.0",
+    "sanitize-html": "2.17.0",
     "simplecc-wasm": "1.1.0",
     "socks-proxy-agent": "8.0.5",
     "source-map": "0.7.4",
     "telegram": "2.26.22",
-    "tiny-async-pool": "2.1.0",
     "title": "4.0.1",
-    "tldts": "6.1.84",
+    "tldts": "7.0.9",
     "tosource": "2.0.0-alpha.3",
     "tough-cookie": "5.1.2",
-    "tsx": "4.19.3",
-    "twitter-api-v2": "1.21.0",
-    "ufo": "1.5.4",
-    "undici": "6.21.2",
+    "tsx": "4.20.3",
+    "twitter-api-v2": "1.24.0",
+    "ufo": "1.6.1",
+    "undici": "6.21.3",
     "uuid": "11.1.0",
     "winston": "3.17.0",
     "xxhash-wasm": "1.1.0",
-    "zod": "3.24.2"
+    "youtubei.js": "14.0.0",
+    "zod": "3.25.67"
   },
   "devDependencies": {
-    "@babel/preset-env": "7.26.9",
-    "@babel/preset-typescript": "7.26.0",
+    "@babel/preset-env": "7.27.2",
+    "@babel/preset-typescript": "7.27.1",
     "@bbob/types": "4.2.0",
-    "@eslint/eslintrc": "3.3.0",
-    "@eslint/js": "9.22.0",
+    "@eslint/eslintrc": "3.3.1",
+    "@eslint/js": "9.30.0",
     "@microsoft/eslint-formatter-sarif": "3.1.0",
-    "@stylistic/eslint-plugin": "4.2.0",
+    "@stylistic/eslint-plugin": "5.1.0",
     "@types/aes-js": "3.1.4",
     "@types/babel__preset-env": "7.10.0",
     "@types/crypto-js": "4.2.2",
     "@types/eslint": "9.6.1",
-    "@types/etag": "1.8.3",
+    "@types/etag": "1.8.4",
     "@types/fs-extra": "11.0.4",
     "@types/html-to-text": "9.0.4",
-    "@types/imapflow": "1.0.20",
+    "@types/imapflow": "1.0.22",
     "@types/js-beautify": "1.14.3",
     "@types/jsdom": "21.1.7",
     "@types/json-bigint": "1.0.4",
     "@types/jsrsasign": "10.5.13",
     "@types/lint-staged": "13.3.0",
-    "@types/mailparser": "3.4.5",
+    "@types/mailparser": "3.4.6",
     "@types/markdown-it": "14.1.2",
     "@types/module-alias": "2.0.4",
-    "@types/node": "22.13.10",
-    "@types/sanitize-html": "2.13.0",
-    "@types/supertest": "6.0.2",
-    "@types/tiny-async-pool": "2.0.3",
+    "@types/node": "24.0.8",
+    "@types/sanitize-html": "2.16.0",
+    "@types/supertest": "6.0.3",
     "@types/title": "3.4.3",
     "@types/uuid": "10.0.0",
-    "@typescript-eslint/eslint-plugin": "8.27.0",
-    "@typescript-eslint/parser": "8.27.0",
-    "@vercel/nft": "0.29.2",
+    "@typescript-eslint/eslint-plugin": "8.35.1",
+    "@typescript-eslint/parser": "8.35.1",
+    "@vercel/nft": "0.29.4",
     "@vitest/coverage-v8": "2.1.9",
-    "discord-api-types": "0.37.119",
-    "eslint": "9.22.0",
-    "eslint-config-prettier": "10.1.1",
+    "discord-api-types": "0.38.14",
+    "domhandler": "5.0.3",
+    "eslint": "9.30.0",
+    "eslint-config-prettier": "10.1.5",
     "eslint-nibble": "8.1.0",
-    "eslint-plugin-n": "17.16.2",
-    "eslint-plugin-prettier": "5.2.3",
-    "eslint-plugin-unicorn": "57.0.0",
-    "eslint-plugin-yml": "1.17.0",
+    "eslint-plugin-n": "17.20.0",
+    "eslint-plugin-prettier": "5.5.1",
+    "eslint-plugin-unicorn": "59.0.1",
+    "eslint-plugin-yml": "1.18.0",
     "fs-extra": "11.3.0",
-    "globals": "16.0.0",
-    "got": "14.4.6",
+    "globals": "16.2.0",
+    "got": "14.4.7",
     "husky": "9.1.7",
     "js-beautify": "1.15.4",
-    "lint-staged": "15.5.0",
+    "lint-staged": "16.1.2",
+    "magic-string": "0.30.17",
     "mockdate": "3.0.5",
     "msw": "2.4.3",
-    "node-network-devtools": "1.0.25",
-    "prettier": "3.5.3",
+    "node-network-devtools": "1.0.28",
+    "prettier": "3.6.2",
     "remark-parse": "11.0.0",
-    "supertest": "7.1.0",
-    "typescript": "5.8.2",
+    "supertest": "7.1.1",
+    "tsdown": "0.12.9",
+    "typescript": "5.8.3",
     "unified": "11.0.5",
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "2.1.9",
@@ -184,16 +184,16 @@
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsx scripts/workflow/build-routes.ts",
+    "build": "tsx scripts/workflow/build-routes.ts && tsdown",
     "build:docs": "tsx scripts/workflow/build-docs.ts",
     "dev": "cross-env NODE_ENV=dev tsx watch --inspect --clear-screen=false lib/index.ts",
     "dev:cache": "cross-env NODE_ENV=production tsx watch --clear-screen=false lib/index.ts",
-    "format": "prettier \"**/*.{ts,tsx,js,json}\" --write && eslint --cache --fix \"**/*.{ts,tsx,js,yml}\"",
-    "format:check": "prettier \"**/*.{ts,tsx,js,json}\" --check && eslint --cache \"**/*.{ts,tsx,js,yml}\"",
+    "format": "prettier \"**/*.{ts,tsx,js,json}\" --write --experimental-cli && eslint --cache --fix \"**/*.{ts,tsx,js,yml}\"",
+    "format:check": "prettier \"**/*.{ts,tsx,js,json}\" --check --experimental-cli && eslint --cache \"**/*.{ts,tsx,js,yml}\"",
     "format:staged": "lint-staged",
     "lint": "eslint --cache .",
     "profiling": "cross-env NODE_ENV=production tsx --prof lib/index.ts",
-    "start": "cross-env NODE_ENV=production tsx lib/index.ts",
+    "start": "cross-env NODE_ENV=production node dist/index.js",
     "test": "npm run format:check && npm run vitest:coverage",
     "vitest": "cross-env NODE_ENV=test vitest",
     "vitest:coverage": "cross-env NODE_ENV=test vitest --coverage.enabled --reporter=junit",