@bleedingdev/modern-js-app-tools 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

package/dist/esm-node/plugins/deploy/platforms/templates/vercel-entry.cjs

@@ -1,77 +1,57 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const { createProdServer } = require('@modern-js/prod-server');
-
 p_genPluginImportsCode;
-
-if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = 'production';
-}
-
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
 let requestHandler = null;
 let handlerCreationPromise = null;
-
 async function loadRoutes(routeFilepath) {
-  try {
-    await fs.access(routeFilepath);
-    const content = await fs.readFile(routeFilepath, 'utf-8');
-    const routeSpec = JSON.parse(content);
-    return routeSpec.routes || [];
-  } catch (error) {
-    console.warn(
-      'route.json not found or invalid, continuing with empty routes.',
-    );
-    return [];
-  }
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
 }
-
 async function initServer() {
-  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
-  const routes = await loadRoutes(routeFilepath);
-
-  const dynamicProdOptions = p_dynamicProdOptions;
-
-  const prodServerOptions = {
-    pwd: __dirname,
-    routes,
-    disableCustomHook: true,
-    appContext: {
-      sharedDirectory: p_sharedDirectory,
-      apiDirectory: p_apiDirectory,
-      lambdaDirectory: p_lambdaDirectory,
-      bffRuntimeFramework: p_bffRuntimeFramework,
-    },
-    plugins: p_plugins,
-    serverConfigPath: p_serverDirectory,
-    ...dynamicProdOptions,
-  };
-  const app = await createProdServer(prodServerOptions);
-
-  return app.getRequestListener();
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
 }
-
 async function createHandler() {
-  if (!handlerCreationPromise) {
-    handlerCreationPromise = (async () => {
-      try {
-        requestHandler = await initServer();
-      } catch (error) {
-        console.error('Error creating server:', error);
-        process.exit(1);
-      }
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
     })();
-  }
-  await handlerCreationPromise;
-  return requestHandler;
+    await handlerCreationPromise;
+    return requestHandler;
 }
-
 createHandler();
-
-const handler = async (req, res) => {
-  if (!requestHandler) {
-    await createHandler();
-  }
-  return requestHandler(req, res);
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
 };
-
 module.exports = handler;

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

@@ -2,78 +2,57 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProdServer } from '@modern-js/prod-server';
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 p_genPluginImportsCode;
-
-if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = 'production';
-}
-
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
 let requestHandler = null;
 let handlerCreationPromise = null;
-
 async function loadRoutes(routeFilepath) {
-  try {
-    await fs.access(routeFilepath);
-    const content = await fs.readFile(routeFilepath, 'utf-8');
-    const routeSpec = JSON.parse(content);
-    return routeSpec.routes || [];
-  } catch (error) {
-    console.warn(
-      'route.json not found or invalid, continuing with empty routes.',
-    );
-    return [];
-  }
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
 }
-
 async function initServer() {
-  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
-  const routes = await loadRoutes(routeFilepath);
-
-  const dynamicProdOptions = p_dynamicProdOptions;
-
-  const prodServerOptions = {
-    pwd: __dirname,
-    routes,
-    disableCustomHook: true,
-    appContext: {
-      sharedDirectory: p_sharedDirectory,
-      apiDirectory: p_apiDirectory,
-      lambdaDirectory: p_lambdaDirectory,
-    },
-    plugins: p_plugins,
-    serverConfigPath: p_serverDirectory,
-    ...dynamicProdOptions,
-  };
-  const app = await createProdServer(prodServerOptions);
-
-  return app.getRequestListener();
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
 }
-
 async function createHandler() {
-  if (!handlerCreationPromise) {
-    handlerCreationPromise = (async () => {
-      try {
-        requestHandler = await initServer();
-      } catch (error) {
-        console.error('Error creating server:', error);
-        process.exit(1);
-      }
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
     })();
-  }
-  await handlerCreationPromise;
-  return requestHandler;
+    await handlerCreationPromise;
+    return requestHandler;
 }
-
 createHandler();
-
-const handler = async (req, res) => {
-  if (!requestHandler) {
-    await createHandler();
-  }
-  return requestHandler(req, res);
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
 };
-
 export default handler;

package/dist/esm-node/plugins/ultramodernReleaseEnvelope.mjs

@@ -1,53 +1,7 @@
 import "node:module";
-import node_path from "node:path";
-import { emitFrameworkMicroVerticalReleaseEnvelope, emitNodeStagedReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyNodeReleaseEnvelopeStaging } from "../ultramodern-release-envelope/framework-output.mjs";
+import { createUltramodernReleaseEnvelopePlugin } from "@modern-js/app-tools-extensions/release-envelope/plugin";
 import { resolveDeployTarget } from "./deploy/index.mjs";
-const resolveActiveDeployTarget = (api)=>{
-    const { metaName } = api.getAppContext();
-    const config = api.getNormalizedConfig();
-    if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
-    return resolveDeployTarget(config);
-};
-const ultramodernReleaseEnvelope = ()=>({
-        name: '@modern-js/ultramodern-release-envelope',
-        pre: [
-            '@modern-js/backend-federation-build',
-            '@modern-js/plugin-bff'
-        ],
-        setup (api) {
-            const emitBuildEnvelope = async (target)=>{
-                const { apiOnly, distDirectory } = api.getAppContext();
-                await emitFrameworkMicroVerticalReleaseEnvelope({
-                    apiOnly,
-                    distDirectory,
-                    target
-                });
-            };
-            api.onAfterBuild(async ()=>{
-                const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
-                if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
-            });
-            api.onBeforeDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api);
-                if ('node' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
-                const { distDirectory } = api.getAppContext();
-                await verifyBuildOutputReleaseEnvelope(distDirectory, configuredTarget);
-            });
-            api.onAfterDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api);
-                if ('node' !== configuredTarget) return;
-                const { appDirectory, distDirectory } = api.getAppContext();
-                const outputDirectory = node_path.join(appDirectory, '.output');
-                const releaseEnvelope = await emitNodeStagedReleaseEnvelope({
-                    distDirectory,
-                    outputDirectory
-                });
-                if (releaseEnvelope) await verifyNodeReleaseEnvelopeStaging({
-                    outputDirectory
-                });
-            });
-        }
+const ultramodernReleaseEnvelope = ()=>createUltramodernReleaseEnvelopePlugin({
+        resolveDeployTarget: resolveDeployTarget
     });
 export default ultramodernReleaseEnvelope;

package/dist/esm-node/presetUltramodern.mjs

@@ -1,9 +1,9 @@
 import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
+import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensions/release-identity";
 import { mergeConfig } from "@modern-js/plugin/cli";
 import { rspack } from "@rsbuild/core";
-import { resolveUltramodernReleaseIdentity } from "./ultramodern-release-identity.mjs";
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -109,4 +109,5 @@ const presetUltramodern = (config, options = {})=>mergeConfig([
         createPresetUltramodernConfig(options),
         config
     ]);
+export { default as ultramodernReleaseEnvelopePlugin } from "./plugins/ultramodernReleaseEnvelope.mjs";
 export { createPresetUltramodernConfig, presetUltramodern };

package/dist/esm-node/run/index.mjs

@@ -8,25 +8,25 @@ import { loadInternalPlugins } from "../utils/loadPlugins.mjs";
 async function createRunOptions({ cwd, initialLog, metaName = 'modern-js', version, internalPlugins, configFile }) {
     const nodeVersion = process.versions.node;
     const versionArr = nodeVersion.split('.').map(Number);
-    if (versionArr[0] <= 16) console.warn(`
-  ${chalk.bgRed.white.bold(' ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ')}
+    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 7) throw new Error(`
+  ${chalk.bgRed.white.bold(' UNSUPPORTED NODE.JS RUNTIME ')}
 
-  ${chalk.red.bold('Node.js 16 End-of-Life Notice:')}
-  ${chalk.red('- Security updates and support have ended for Node.js 16')}
+  ${chalk.red.bold(`UltraModern.js requires Node.js >=26.7.0; detected v${nodeVersion}.`)}
+  ${chalk.red('- Legacy Node runtimes and TypeScript transpiler fallbacks are unsupported.')}
 
   ${chalk.yellow('▸ Detected Runtime:')}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js LTS (v18.x or higher)')}
-  ${chalk.green('▸ Recommended:')} ${chalk.green.bold('Node.js LTS (v22.x or higher)')}
+  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js v26.7.0 or higher')}
+  ${chalk.green('▸ Pinned Runtime:')} ${chalk.green.bold('Node.js v26.7.0')}
 
   ${chalk.cyan('Immediate Action Required:')}
     ${chalk.gray('├──')} ${chalk.yellow('Recommended Upgrade')}
-       ${chalk.bold('nvm install 22 --lts && nvm use 22')}
+       ${chalk.bold('mise install && mise exec -- node --version')}
     ${chalk.gray('├──')} ${chalk.yellow('Manual Installation')}
-       ${chalk.underline('https://nodejs.org/download/release/lts-hydrogen/')}
+       ${chalk.underline('https://nodejs.org/download/release/v26.7.0/')}
      ${chalk.gray('└──')} ${chalk.yellow('Environment Verification')}
        ${chalk.bold('node -v && npm -v')}
 
-  ${chalk.hex('#AAAAAA').italic('[Security Advisory] Node.js 16 is no longer supported. Upgrade immediately for security and compatibility.')}
+  ${chalk.hex('#AAAAAA').italic('[Runtime Policy] Upgrade Node; UltraModern.js intentionally carries no legacy transpiler fallback.')}
       `);
     const command = process.argv[2];
     const cliParams = minimist(process.argv.slice(2));

package/dist/esm-node/utils/register.mjs

@@ -50,12 +50,16 @@ const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
 };
 const resolveTsRuntimeRegisterMode = ()=>{
     const hasNativeTypeScriptSupport = process.features?.typescript;
-    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
-    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    const nodeVersion = process.versions.node.split('.').map(Number);
+    const supportsNativeTypeScript = (nodeVersion[0] > 26 || 26 === nodeVersion[0] && nodeVersion[1] >= 7) && [
+        true,
+        'strip'
+    ].includes(hasNativeTypeScriptSupport);
     if (supportsNativeTypeScript) return 'node-loader';
     return 'unsupported';
 };
 const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
+    if ('unsupported' === resolveTsRuntimeRegisterMode()) throw new Error(`UltraModern.js requires Node.js >=26.7.0 with native TypeScript support; detected v${process.versions.node}. Legacy TypeScript runtime transpilers are unsupported.`);
     const tsconfigPath = resolveServerTsconfig(appDir, options.tsconfigPath);
     const isTsProject = await fs.pathExists(tsconfigPath);
     if (!isTsProject) return;
@@ -70,7 +74,6 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
         paths,
         absoluteBaseUrl
     });
-    if ('unsupported' === registerMode) return;
     if ('node-loader' === registerMode) {
         const { registerPathsLoader } = await import("../esm/register-esm.mjs");
         await registerPathsLoader({

package/dist/types/builder/generator/getBuilderEnvironments.d.ts

@@ -1,34 +1,5 @@
-import type { ModifyBundlerChainFn } from '@rsbuild/core';
 import type { AppNormalizedConfig } from '../../types';
 import type { AppToolsContext } from '../../types/plugin';
-export declare function getCloudflareWorkerRspackConfig(workerEntryNames: Iterable<string>): {
-    readonly experiments: {
-        readonly outputModule: true;
-    };
-    readonly externals: {
-        [k: string]: string;
-    };
-    readonly externalsType: 'module-import';
-    readonly module: {
-        readonly parser: {
-            readonly javascript: {
-                readonly dynamicImportMode: 'eager';
-            };
-        };
-    };
-    readonly optimization: {
-        readonly runtimeChunk: {
-            readonly name: string;
-        };
-        readonly splitChunks: {
-            readonly chunks: 'all';
-            readonly minSize: 0;
-            readonly name: string;
-        };
-    };
-};
-export declare function applyCloudflareWorkerRspackConfig(chain: Parameters<ModifyBundlerChainFn>[0], workerEntryNames: Iterable<string>): void;
-export declare function applyCloudflareWorkerMfRuntimeBoundary(chain: Parameters<ModifyBundlerChainFn>[0]): void;
 export declare function getBuilderEnvironments(normalizedConfig: AppNormalizedConfig, appContext: AppToolsContext, tempBuilderConfig: Omit<AppNormalizedConfig, 'plugins'>): {
     environments: Record<string, import("@rsbuild/core").EnvironmentConfig>;
     builderConfig: Omit<AppNormalizedConfig, "plugins">;

package/dist/types/builder/shared/builderPlugins/adapterSSR.d.ts

@@ -1,3 +1,14 @@
+import { type Rspack } from '@modern-js/builder';
 import { type RsbuildPlugin } from '@rsbuild/core';
+import type { AppNormalizedConfig } from '../../../types';
+import type { AppToolsContext } from '../../../types/plugin';
 import type { BuilderOptions } from '../types';
 export declare const builderPluginAdapterSSR: (options: BuilderOptions) => RsbuildPlugin;
+/**
+ * When a stream SSR project has lazy compilation enabled, return a
+ * `lazyCompilation` value whose `test` forces route components eager (so
+ * first-screen chunk/CSS injection works). Returns undefined when it does not
+ * apply (not stream SSR, RSC, lazy disabled, or no route components collected),
+ * so the caller leaves the config untouched.
+ */
+export declare function getSSRLazyCompilation(current: unknown, normalizedConfig: AppNormalizedConfig, appContext: AppToolsContext, eagerRouteComponentFilesByEntry: BuilderOptions['eagerRouteComponentFilesByEntry']): Rspack.LazyCompilationOptions | undefined;

package/dist/types/builder/shared/builderPlugins/index.d.ts

@@ -1,6 +1,5 @@
 export * from './adapterBasic';
 export * from './adapterHtml';
-export * from './adapterLazyCompilation';
 export * from './adapterPrecompress';
 export * from './adapterSSR';
 export * from './builderHooks';

package/dist/types/builder/shared/bundlerPlugins/index.d.ts

@@ -1,4 +1,3 @@
-export * from './CssExtractRuntimePlugin';
 export * from './HtmlAsyncChunkPlugin';
 export * from './HtmlBottomTemplate';
 export * from './RouterPlugin';

package/dist/types/builder/shared/lazyCompilation.d.ts

@@ -6,7 +6,7 @@ type ModuleLike = {
 type LazyCompilationTestFn = (m: ModuleLike) => boolean;
 /** Matches Rspack's `LazyCompilationOptions['test']`. */
 type LazyCompilationTest = RegExp | LazyCompilationTestFn | undefined;
-type EagerRouteComponentInfo = {
+export type EagerRouteComponentInfo = {
     files: Set<string>;
     /** Specifiers that could not be resolved, keyed by entry name. */
     unresolvedByEntry: Map<string, string[]>;
@@ -15,8 +15,8 @@ type EagerRouteComponentInfo = {
  * Aggregate the per-entry route component data (collected by the router plugin
  * during route generation and threaded in as
  * `BuilderOptions.eagerRouteComponentFilesByEntry`) into the flat shape
- * {@link planRouteEagerLazyCompilation} expects: one Set of all route files
- * plus the unresolved specifiers keyed by entry.
+ * {@link planSSRLazyCompilation} expects: one Set of all route files plus the
+ * unresolved specifiers keyed by entry.
  */
 export declare function aggregateEagerRouteComponentFiles(byEntry: EagerRouteComponentFilesByEntry | undefined): EagerRouteComponentInfo;
 /**
@@ -25,8 +25,8 @@ export declare function aggregateEagerRouteComponentFiles(byEntry: EagerRouteCom
  * render time), while delegating all other modules to the user's `test`
  * (defaulting to lazy when the user did not provide one).
  */
-export declare function buildRouteEagerLazyCompilationTest(eagerRouteFiles: Set<string>, userTest?: LazyCompilationTest): LazyCompilationTestFn;
-type SSRLazyPlan = {
+export declare function buildSSRLazyCompilationTest(eagerRouteFiles: Set<string>, userTest?: LazyCompilationTest): LazyCompilationTestFn;
+export type SSRLazyPlan = {
     apply: false;
     unresolvedByEntry?: Map<string, string[]>;
 } | {
@@ -34,10 +34,10 @@ type SSRLazyPlan = {
     lazyCompilation: Record<string, unknown>;
 };
 /**
- * Decide whether to apply route-eager lazy compilation for a project.
+ * Decide whether to apply the route-eager lazy compilation for an SSR project.
  * Checks unresolved route components FIRST: if any exist we cannot guarantee
  * they are eager, so we skip the optimization (and surface them so the caller
  * can warn) rather than silently leaving a route lazy. `current` is the
  * existing `dev.lazyCompilation` value (lazy must be enabled for this to apply).
  */
-export declare function planRouteEagerLazyCompilation(current: unknown, info: EagerRouteComponentInfo): SSRLazyPlan;
+export declare function planSSRLazyCompilation(current: unknown, info: EagerRouteComponentInfo): SSRLazyPlan;

package/dist/types/plugins/analyze/getServerRoutes.d.ts

@@ -6,4 +6,4 @@ export declare const getServerRoutes: (entrypoints: Entrypoint[], { appContext,
     config: AppNormalizedConfig;
 }) => ServerRoute[];
 export declare const getProdServerRoutes: (distDirectory: string) => any;
-export declare const getProdEntrypoints: (distDirectory: string, routes: ServerRoute[], mainEntryName?: any) => Entrypoint[];
+export declare const getProdEntrypoints: (distDirectory: string, routes: ServerRoute[], mainEntryName?: string) => Entrypoint[];

package/dist/types/plugins/backend-federation/codegen.d.ts

@@ -1,6 +1,7 @@
+import type { BackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security';
 import { type BackendFederationApp } from './config';
 export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => Promise<string>;
-export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp) => {
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp, entryIntegrity: BackendFederationEntryIntegrity) => {
     schemaVersion: number;
     id: string;
     name: string;
@@ -28,6 +29,8 @@ export declare const createBackendManifest: (workspaceRoot: string, distDirector
         ssrPublicPath: string;
     };
     entry: {
+        byteLength: number;
+        sha256: string;
         file: string;
         path: string;
         type: string;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/index.d.ts

@@ -1,18 +1 @@
-import type { CloudflareDeliveryUnitIdentity } from './identity';
-import type { CloudflareOutputVerifierResult } from './issues';
-export type { CloudflareDeliveryUnitIdentity } from './identity';
-export type { CloudflareOutputVerifierIssue, CloudflareOutputVerifierIssueCode, CloudflareOutputVerifierResult, } from './issues';
-export { type VerifyCloudflareOutputMutationPolicyOptions, verifyCloudflareOutputMutationPolicy, } from './mutation-policy';
-export interface VerifyCloudflareOutputOptions {
-    outputDirectory: string;
-    importWorker?: boolean;
-    /**
-     * Topology-declared delivery-unit record (from the workspace compact config).
-     * When provided, the Cloudflare worker manifest must carry a matching
-     * `deliveryUnit` stamp so the deployed worker snapshot is proven to derive
-     * from the same delivery unit as the Node/API surfaces (ADR-0019 lane D).
-     */
-    deliveryUnit?: CloudflareDeliveryUnitIdentity;
-}
-export declare const verifyCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<CloudflareOutputVerifierResult>;
-export declare const assertCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<void>;
+export * from '@modern-js/app-tools-extensions/cloudflare-output-verifier';

package/dist/types/presetUltramodern.d.ts

@@ -1,4 +1,5 @@
 import type { AppUserConfig } from './types';
+export { default as ultramodernReleaseEnvelopePlugin } from './plugins/ultramodernReleaseEnvelope';
 export interface PresetUltramodernOptions {
     /**
      * Stable producer identity used by BFF cross-project clients.

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

@@ -1,5 +1,5 @@
-import type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerServiceBindingConfig, DeployTarget, JsonValue } from './cloudflareDeploy';
-export type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerSecurityCorsConfig, CloudflareWorkerSecurityCspConfig, CloudflareWorkerSecurityCspMode, CloudflareWorkerSecurityNoindexConfig, CloudflareWorkerServiceBindingConfig, CloudflareWorkerServiceBindingFragmentConfig, DeployTarget, JsonValue, } from './cloudflareDeploy';
+import type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerServiceBindingConfig, DeployTarget, JsonValue } from '@modern-js/app-tools-extensions/config';
+export type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerSecurityCorsConfig, CloudflareWorkerSecurityCspConfig, CloudflareWorkerSecurityCspMode, CloudflareWorkerSecurityNoindexConfig, CloudflareWorkerServiceBindingConfig, CloudflareWorkerServiceBindingFragmentConfig, DeployTarget, JsonValue, } from '@modern-js/app-tools-extensions/config';
 export interface MicroFrontend {
     /**
      * Specifies whether to enable the HTML entry.

package/docs/community/showcase.md

@@ -1,10 +1,8 @@
-# Showcase
+# Ecosystem
 
-Welcome to the Modern.js showcase page! Here, we present a collection of websites that have been built using Modern.js.
+UltraModern.js builds on a focused ecosystem of frameworks and tools. These projects provide the Effect, TanStack Router, build, documentation, and Module Federation foundations used by the fork.
 
-If you have built a website using Modern.js, we would love for you to share it with the community. Simply reply to the GitHub discussion thread with a link to your website. We will collect content on a regular basis and display it on the current page.
-
-## The Cases
+## Projects
 
 
 [![](/img/features/framework.svg)UltraModern.jsFramework

package/docs/guides/advanced-features/bff/frameworks.md

@@ -117,7 +117,7 @@ const response = await api.client.hello.ping({});
 
 The `api.client.*` surface is materialized by the BFF loader for `@api/index` imports. Do not import `api/index` directly and expect `client` to run in server code, scripts, or tests; direct entry imports expose the server runtime definition, and `client` is only a typed placeholder there.
 
-For UltraModern, Effect `HttpApi` plus Effect BFF is the single blessed authored HTTP path. Use `HttpApi` endpoints with `query`, `params`, `payload`, `success`, and declared errors such as `HttpApiSchema.status(...)`; implement them with `HttpApiBuilder.group(...).handle(...)` and `HttpApiBuilder.layer(...).pipe(Layer.provide(...))`, then default-export the entry as `defineEffectBff({ api, layer })`. See `packages/cli/plugin-bff/tests/effect-httpapi-schema-validation.test.ts` for the real shapes.
+For UltraModern, Effect `HttpApi` plus Effect BFF is the single blessed authored HTTP path. Use `HttpApi` endpoints with `query`, `params`, `payload`, `success`, and declared errors such as `HttpApiSchema.status(...)`; implement them with `HttpApiBuilder.group(...).handle(...)` and `HttpApiBuilder.layer(...).pipe(Layer.provide(...))`, then default-export the entry as `defineEffectBff({ api, layer })`. See `packages/server/bff-effect/tests/effect-edge-runtime.test.ts` for the live runtime shape.
 
 Hono and `api/lambda/**` are internal compatibility only and feature-frozen.
 

package/docs/guides/basic-features/deploy.md

@@ -260,11 +260,11 @@ Assuming the directory structure of the Monorepo repository is as follows:
 First, you need to configure the **Root Directory** as `packages/app` on the Vercel platform:
 
 ![](https://sf16-sg.tiktokcdn.com/obj/eden-sg/lmeh7nuptpfnuhd/vercel-root-directory.png)
-Specify Node.js runtime as `20.x`:
+Specify Node.js runtime as `26.7.0` or newer:
 
 ```json title="package.json"
 "engines": {
-  "node": "20.x"
+  "node": ">=26.7.0"
 }
 ```