@bleedingdev/modern-js-app-tools 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

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)=>{
@@ -73,17 +73,19 @@ const createPresetUltramodernConfig = (options = {})=>{
             precompress: true
         },
         server,
-        ...deliveryUnit ? {
-            source: {
+        source: {
+            reactCompiler: true,
+            ...deliveryUnit ? {
                 globalVars: {
                     ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
                     ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
                     ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
                 }
-            }
-        } : {},
+            } : {}
+        },
         tools: {
             bundlerChain: setReactRouterBridgeSafeAliases,
+            lightningcssLoader: true,
             ...bundledReleaseIdentity ? {
                 rspack: (config)=>{
                     config.plugins ??= [];
@@ -107,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/env.mjs

@@ -6,7 +6,7 @@ function getAutoInjectEnv(appContext) {
     const envReg = new RegExp(`^${prefix}`);
     return Object.keys(process.env).reduce((prev, key)=>{
         const value = process.env[key];
-        if (envReg.test(key) && void 0 !== value) prev[`process.env.${key}`] = value;
+        if (envReg.test(key) && 'MODERN_MF_APP_SSR' !== key && void 0 !== value) prev[`process.env.${key}`] = value;
         return prev;
     }, {});
 }

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.
@@ -40,14 +41,18 @@ export interface PresetUltramodernOptions {
     /**
      * OTLP exporter endpoint. Setting it (or the environment variable)
      * enables the OTLP exporter unless `enableTelemetryExporters` is `false`.
-     * @default process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs'
+     * The localhost endpoint is used only when exporters are forced on with
+     * `enableTelemetryExporters: true` and no endpoint was provided.
+     * @default process.env.MODERN_TELEMETRY_OTLP_ENDPOINT
      */
     otlpEndpoint?: string;
     /**
      * VictoriaMetrics exporter endpoint. Setting it (or the environment
      * variable) enables the VictoriaMetrics exporter unless
      * `enableTelemetryExporters` is `false`.
-     * @default process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus'
+     * The localhost endpoint is used only when exporters are forced on with
+     * `enableTelemetryExporters: true` and no endpoint was provided.
+     * @default process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT
      */
     victoriaMetricsEndpoint?: string;
     /**
@@ -62,5 +67,21 @@ export interface PresetUltramodernOptions {
      */
     enableModuleFederationSSR?: boolean;
 }
+/**
+ * Materialize a fresh UltraModern preset config.
+ *
+ * This is the advanced inspection API. Use `presetUltramodern` when composing
+ * an application config so nested records, arrays, and hooks keep the normal
+ * Modern.js merge behavior.
+ */
 export declare const createPresetUltramodernConfig: (options?: PresetUltramodernOptions) => AppUserConfig;
+/**
+ * Compose an application config over the UltraModern preset.
+ *
+ * The application config is merged after the preset. Nested records are
+ * preserved, scalar values and `false` override preset values, and omitted or
+ * `undefined` values keep the preset value. Arrays and hooks compose in
+ * preset-first order. An empty record does not reset nested preset defaults;
+ * use the typed `PresetUltramodernOptions` opt-outs instead.
+ */
 export declare const presetUltramodern: (config: AppUserConfig, options?: PresetUltramodernOptions) => AppUserConfig;

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