@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.17 → 3.2.0-ultramodern.22

package/dist/esm-node/plugins/deploy/index.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { provider } from "std-env";
+import { createCloudflarePreset } from "./platforms/cloudflare.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
@@ -9,14 +10,18 @@ const deployPresets = {
     node: createNodePreset,
     vercel: createVercelPreset,
     netlify: createNetlifyPreset,
-    ghPages: createGhPagesPreset
+    ghPages: createGhPagesPreset,
+    cloudflare: createCloudflarePreset
 };
+const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
+const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
+const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>modernConfig.deploy?.target || envDeployTarget || detectedProvider || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
+    if (!isDeployTarget(deployTarget)) throw new Error(`Unknown deploy target: '${deployTarget}'. deploy.target or MODERNJS_DEPLOY should be one of: ${getSupportedDeployTargets().join(', ')}.`);
     const createPreset = deployPresets[deployTarget];
-    if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
     return createPreset({
         appContext,
         modernConfig,
@@ -27,12 +32,12 @@ async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
 const deploy = ()=>({
         name: '@modern-js/plugin-deploy',
         setup: (api)=>{
-            const deployTarget = process.env.MODERNJS_DEPLOY || provider || 'node';
             api.deploy(async ()=>{
                 const appContext = api.getAppContext();
                 const { metaName } = appContext;
-                if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
                 const modernConfig = api.getNormalizedConfig();
+                const deployTarget = resolveDeployTarget(modernConfig);
+                if ('modern-js' !== metaName && !modernConfig.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
                 const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
@@ -42,3 +47,4 @@ const deploy = ()=>({
         }
     });
 export default deploy;
+export { getSupportedDeployTargets, resolveDeployTarget };

package/dist/esm-node/plugins/deploy/platforms/cloudflare.mjs

@@ -0,0 +1,185 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { readTemplate } from "../utils/index.mjs";
+const WORKER_ENTRY = 'server/index.mjs';
+const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const ASSETS_BINDING = 'ASSETS';
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = 'public';
+const WORKER_BUNDLE_DIRECTORY = 'worker';
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const getCompatibilityDate = ()=>new Date().toISOString().slice(0, 10);
+const getWorkerName = (appDirectory)=>{
+    const basename = node_path.basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const readRouteSpec = async (outputDirectory)=>{
+    const routeSpecPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    if (!await fs.pathExists(routeSpecPath)) return {
+        routes: []
+    };
+    const routeSpec = await fs.readJSON(routeSpecPath);
+    return {
+        ...routeSpec,
+        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
+    };
+};
+const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+    const routeSpec = await readRouteSpec(outputDirectory);
+    const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
+        const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        return {
+            urlPath: route.urlPath,
+            entryName: route.entryName,
+            entryPath: route.entryPath,
+            isSSR: Boolean(route.isSSR),
+            worker,
+            bundle: 'string' == typeof route.bundle ? route.bundle : void 0,
+            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false,
+            bundleExists: 'string' == typeof route.bundle ? await fs.pathExists(node_path.join(outputDirectory, route.bundle)) : false
+        };
+    }));
+    const bffPrefix = modernConfig.bff?.prefix;
+    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const isEffectBff = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectBffWorkerExists = await fs.pathExists(node_path.join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    return {
+        version: 1,
+        runtime: {
+            type: 'cloudflare-module-worker',
+            entry: WORKER_ENTRY,
+            fetchExport: true,
+            nodeListen: false
+        },
+        assets: {
+            binding: ASSETS_BINDING,
+            directory: `./${PUBLIC_ASSETS_DIRECTORY}`
+        },
+        routeSpec: {
+            file: ROUTE_SPEC_OUTPUT,
+            routes
+        },
+        workerBundles: {
+            directory: WORKER_BUNDLE_DIRECTORY,
+            format: 'esm',
+            importableFromModuleWorker: true,
+            requestHandlerExport: 'requestHandler'
+        },
+        resources: {
+            loadableStats: LOADABLE_STATS_FILE,
+            routeManifest: ROUTE_MANIFEST_FILE
+        },
+        bff: isEffectBff && primaryBffPrefix && effectBffWorkerExists ? {
+            runtimeFramework: 'effect',
+            prefix: primaryBffPrefix,
+            worker: BFF_EFFECT_WORKER_ENTRY
+        } : void 0
+    };
+};
+const createWorkerModuleLoaders = (manifest)=>{
+    const imports = new Map();
+    for (const route of manifest.routeSpec.routes){
+        if (route.worker && route.workerExists) {
+            const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
+            imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+        }
+        if (route.bundle && route.bundleExists) {
+            const importPath = `../${String(route.bundle).replace(/^\/+/u, '')}`;
+            imports.set(route.bundle, `() => import(${JSON.stringify(importPath)})`);
+        }
+    }
+    if (manifest.bff?.worker) {
+        const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;
+        imports.set(manifest.bff.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (0 === imports.size) return '{}';
+    const loaders = [
+        ...imports.entries()
+    ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
+    return `{\n${loaders.join(',\n')}\n}`;
+};
+const shouldCopyToPublicAssets = (src, distDirectory)=>{
+    const relativePath = node_path.relative(distDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const [topLevelDirectory] = normalizedRelativePath.split('/');
+    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY;
+};
+const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
+    const relativePath = node_path.relative(workerBundleDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const basename = node_path.basename(normalizedRelativePath);
+    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
+    return [
+        '.cjs',
+        '.js',
+        '.mjs'
+    ].includes(node_path.extname(normalizedRelativePath));
+};
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { appDirectory, distDirectory } = appContext;
+    const outputDirectory = node_path.join(appDirectory, '.output');
+    const publicDirectory = node_path.join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
+    const workerEntryPath = node_path.join(outputDirectory, WORKER_ENTRY);
+    const workerManifestPath = node_path.join(outputDirectory, WORKER_MANIFEST);
+    const routeSpecOutputPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = node_path.join(outputDirectory, 'wrangler.json');
+    return {
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory)
+            });
+            await fs.ensureDir(node_path.dirname(workerEntryPath));
+            await fs.ensureDir(node_path.dirname(workerManifestPath));
+            const routeSpecSourcePath = node_path.join(distDirectory, ROUTE_SPEC_FILE);
+            if (await fs.pathExists(routeSpecSourcePath)) await fs.copy(routeSpecSourcePath, routeSpecOutputPath);
+            const workerBundleSourceDirectory = node_path.join(distDirectory, WORKER_BUNDLE_DIRECTORY);
+            if (await fs.pathExists(workerBundleSourceDirectory)) await fs.copy(workerBundleSourceDirectory, node_path.join(outputDirectory, WORKER_BUNDLE_DIRECTORY), {
+                filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+            });
+            const serverBundleSourceDirectory = node_path.join(distDirectory, SERVER_BUNDLE_DIRECTORY);
+            if (await fs.pathExists(serverBundleSourceDirectory)) {
+                await fs.copy(serverBundleSourceDirectory, node_path.join(outputDirectory, SERVER_BUNDLE_DIRECTORY));
+                await fs.writeJSON(node_path.join(outputDirectory, SERVER_BUNDLE_DIRECTORY, 'package.json'), {
+                    type: 'commonjs'
+                });
+            }
+            await fs.writeJSON(wranglerConfigPath, {
+                $schema: 'node_modules/wrangler/config-schema.json',
+                name: getWorkerName(appDirectory),
+                main: WORKER_ENTRY,
+                compatibility_date: getCompatibilityDate(),
+                compatibility_flags: [
+                    'nodejs_compat'
+                ],
+                assets: {
+                    directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+                    binding: ASSETS_BINDING
+                }
+            }, {
+                spaces: 2
+            });
+            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+                spaces: 2
+            });
+            await fs.writeJSON(node_path.join(outputDirectory, 'package.json'), {
+                type: 'module'
+            });
+        },
+        async genEntry () {
+            const template = await readTemplate('cloudflare-entry.mjs');
+            const manifest = await fs.readJSON(workerManifestPath);
+            await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+        }
+    };
+};
+export { createCloudflarePreset };

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -0,0 +1,227 @@
+const ASSETS_BINDING = 'ASSETS';
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
+const workerModulePromises = new Map();
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';
+async function fetchAsset(request, env) {
+    const assets = env?.[ASSETS_BINDING];
+    if (!assets || 'function' != typeof assets.fetch) return null;
+    const response = await assets.fetch(request);
+    if (404 === response.status) return null;
+    return response;
+}
+async function fetchAssetByPath(pathname, request, env) {
+    const url = new URL(request.url);
+    url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
+    return fetchAsset(new Request(url, request), env);
+}
+async function readAssetText(pathname, request, env) {
+    const response = await fetchAssetByPath(pathname, request, env);
+    if (!response || !response.ok) return;
+    return response.text();
+}
+async function readAssetJson(pathname, request, env) {
+    const text = await readAssetText(pathname, request, env);
+    if (!text) return {};
+    return JSON.parse(text);
+}
+function normalizeRoutePath(pathname) {
+    if ('/' === pathname) return pathname;
+    return pathname.replace(/\/+$/u, '');
+}
+function routeMatches(route, pathname) {
+    if ('string' != typeof route.urlPath) return false;
+    const routePath = normalizeRoutePath(route.urlPath);
+    const requestPath = normalizeRoutePath(pathname);
+    return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
+}
+function findRoute(request) {
+    const { pathname } = new URL(request.url);
+    const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
+    return [
+        ...routes
+    ].sort((left, right)=>{
+        const leftLength = left.urlPath?.length || 0;
+        const rightLength = right.urlPath?.length || 0;
+        return rightLength - leftLength;
+    }).find((route)=>routeMatches(route, pathname));
+}
+async function fetchRouteHtml(route, request, env) {
+    if (!route?.entryPath) return null;
+    return fetchAssetByPath(route.entryPath, request, env);
+}
+function createNoopMonitors() {
+    const noop = ()=>{};
+    return {
+        debug: noop,
+        error: noop,
+        info: noop,
+        warn: noop
+    };
+}
+function createRequestHandlerOptions({ route, htmlTemplate, routeManifest, loadableStats }) {
+    const monitors = createNoopMonitors();
+    return {
+        resource: {
+            route,
+            routeManifest,
+            loadableStats,
+            htmlTemplate,
+            entryName: route.entryName
+        },
+        params: {},
+        loaderContext: {},
+        config: {},
+        locals: {},
+        staticGenerate: false,
+        monitors,
+        onError (error) {
+            monitors.error(error);
+        },
+        onTiming () {},
+        reporter: {
+            reportTiming: ()=>{}
+        }
+    };
+}
+async function getRequestHandlerOptions(route, request, env) {
+    const [htmlTemplate, routeManifest, loadableStats] = await Promise.all([
+        readAssetText(route.entryPath, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.routeManifest, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.loadableStats, request, env)
+    ]);
+    return createRequestHandlerOptions({
+        route,
+        htmlTemplate: htmlTemplate || '',
+        routeManifest,
+        loadableStats
+    });
+}
+async function loadWorkerModule(workerPath) {
+    const loader = WORKER_MODULE_LOADERS[workerPath];
+    if (!loader) return;
+    if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
+    return workerModulePromises.get(workerPath);
+}
+function getFetchHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    return defaultExport && 'object' == typeof defaultExport && 'function' == typeof defaultExport.fetch && defaultExport.fetch.bind(defaultExport) || 'function' == typeof workerModule.fetch && workerModule.fetch;
+}
+async function getRequestHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const defaultRequestHandler = defaultExport && 'object' == typeof defaultExport && 'requestHandler' in defaultExport ? defaultExport.requestHandler : void 0;
+    return await workerModule.requestHandler || await defaultRequestHandler || ('function' == typeof defaultExport ? defaultExport : void 0);
+}
+async function dispatchRouteWorker(route, request, env, ctx) {
+    const candidatePaths = [
+        route.worker,
+        route.bundle
+    ].filter(Boolean);
+    let missingPath;
+    for (const candidatePath of candidatePaths){
+        const workerModule = await loadWorkerModule(candidatePath);
+        if (!workerModule) {
+            missingPath = candidatePath;
+            continue;
+        }
+        const fetchHandler = getFetchHandler(workerModule);
+        if (fetchHandler) return fetchHandler(request, env, ctx);
+        const requestHandler = await getRequestHandler(workerModule);
+        if ('function' == typeof requestHandler) {
+            const requestHandlerOptions = await getRequestHandlerOptions(route, request, env);
+            return requestHandler(request, requestHandlerOptions);
+        }
+    }
+    if (missingPath) return new Response(`Worker bundle not found: ${missingPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': missingPath
+        }
+    });
+    if (candidatePaths.length > 0) return new Response(`Worker bundle has no fetch or requestHandler export: ${candidatePaths.join(', ')}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': candidatePaths.join(', ')
+        }
+    });
+    return new Response('Route has no worker bundle', {
+        status: 500
+    });
+}
+function matchesPrefix(pathname, prefix) {
+    if (!prefix || '/' === prefix) return true;
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createRequestForMountedPrefix(request, prefix) {
+    if (!prefix || '/' === prefix) return request;
+    const url = new URL(request.url);
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    if (!matchesPrefix(url.pathname, normalized)) return request;
+    const nextPath = url.pathname.slice(normalized.length) || '/';
+    url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
+    return new Request(url, request);
+}
+function createEffectContext(originalRequest, mountedRequest, env) {
+    const url = new URL(originalRequest.url);
+    return {
+        request: mountedRequest,
+        env: env || {},
+        path: url.pathname,
+        method: originalRequest.method,
+        operationContext: {
+            request: mountedRequest,
+            env: env || {},
+            path: url.pathname,
+            method: originalRequest.method
+        }
+    };
+}
+async function dispatchBffRequest(request, env) {
+    const bff = MODERN_WORKER_MANIFEST.bff;
+    if (!bff?.worker || !matchesPrefix(new URL(request.url).pathname, bff.prefix)) return null;
+    const workerModule = await loadWorkerModule(bff.worker);
+    if (!workerModule) return new Response(`BFF worker bundle not found: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
+    const effectContext = createEffectContext(request, mountedRequest, env);
+    const defaultExport = workerModule.default;
+    const runtime = defaultExport && 'object' == typeof defaultExport ? {
+        ...workerModule,
+        ...defaultExport
+    } : workerModule;
+    const directHandler = 'function' == typeof runtime.handler && runtime.handler || 'function' == typeof defaultExport && defaultExport;
+    const createdHandler = 'function' == typeof runtime.createHandler ? runtime.createHandler().handler : void 0;
+    const handler = directHandler || createdHandler;
+    if ('function' != typeof handler) return new Response(`BFF worker bundle has no handler export: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    return handler.length > 1 ? handler(mountedRequest, effectContext) : handler(mountedRequest);
+}
+export default {
+    async fetch (request, env, ctx) {
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return assetResponse;
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return bffResponse;
+        const route = findRoute(request);
+        if (route?.worker) return dispatchRouteWorker(route, request, env, ctx);
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return htmlResponse;
+        return new Response('Not found', {
+            status: 404
+        });
+    }
+};

package/dist/esm-node/rsbuild.mjs

@@ -8,12 +8,12 @@ import { loadInternalPlugins } from "./utils/loadPlugins.mjs";
 import { __webpack_require__ } from "./rslib-runtime.mjs";
 import * as __rspack_external__modern_js_plugin_cli_caa09fa2 from "@modern-js/plugin/cli";
 __webpack_require__.add({
-    "@modern-js/plugin/cli?f956" (module) {
+    "@modern-js/plugin/cli?8936" (module) {
         module.exports = __rspack_external__modern_js_plugin_cli_caa09fa2;
     }
 });
 const MODERN_META_NAME = 'modern-js';
-const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?f956");
+const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?8936");
 async function resolveModernRsbuildConfig(options) {
     const { cwd = process.cwd(), metaName = MODERN_META_NAME } = options;
     const configFile = options.configPath || getConfigFile(void 0, cwd);

package/dist/types/plugins/deploy/index.d.ts

@@ -1,3 +1,6 @@
-import type { AppTools, CliPlugin } from '../../types';
+import type { AppTools, AppToolsNormalizedConfig, CliPlugin } from '../../types';
+import type { DeployTarget } from '../../types/config/deploy';
+export declare const getSupportedDeployTargets: () => DeployTarget[];
+export declare const resolveDeployTarget: (modernConfig: AppToolsNormalizedConfig, envDeployTarget?: string | undefined, detectedProvider?: import("std-env").ProviderName) => string;
 declare const _default: () => CliPlugin<AppTools>;
 export default _default;

package/dist/types/plugins/deploy/platforms/cloudflare.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePreset } from './platform';
+export declare const createCloudflarePreset: CreatePreset;

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.d.mts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(request: any, env: any, ctx: any): Promise<any>;
+};
+export default _default;

package/dist/types/types/config/deploy.d.ts

@@ -26,7 +26,14 @@ export interface MicroFrontend {
      */
     attestation?: string;
 }
+export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
 export interface DeployUserConfig {
+    /**
+     * Selects the deploy output preset.
+     * `MODERNJS_DEPLOY` still overrides provider auto-detection when set.
+     * @default node
+     */
+    target?: DeployTarget;
     /**
      * Used to configure micro-frontend sub-application information.
      * @default false

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.17",
+  "version": "3.2.0-ultramodern.22",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -85,8 +85,8 @@
     "@babel/parser": "^7.29.3",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@rsbuild/core": "2.0.6",
-    "@swc/core": "1.15.33",
+    "@rsbuild/core": "2.0.7",
+    "@swc/core": "1.15.40",
     "@swc/helpers": "^0.5.21",
     "compression-webpack-plugin": "^12.0.0",
     "es-module-lexer": "^2.1.0",
@@ -98,22 +98,22 @@
     "ndepe": "^0.1.13",
     "pkg-types": "^2.3.1",
     "std-env": "4.1.0",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.2.0-ultramodern.17",
-    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.2.0-ultramodern.17",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.17",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.17",
-    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.2.0-ultramodern.17",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.17",
-    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.2.0-ultramodern.17",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.2.0-ultramodern.17",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.17",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.17"
+    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.2.0-ultramodern.22",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.2.0-ultramodern.22",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.22",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.22",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.2.0-ultramodern.22",
+    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.2.0-ultramodern.22",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.22",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.22",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.22",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.2.0-ultramodern.22"
   },
   "devDependencies": {
     "@rslib/core": "0.21.5",
     "@types/babel__traverse": "7.28.0",
-    "@types/node": "^25.8.0",
-    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "@types/node": "^25.9.1",
+    "@typescript/native-preview": "7.0.0-dev.20260526.1",
     "tsconfig-paths": "^4.2.0",
     "@scripts/rstest-config": "2.66.0"
   },