@bleedingdev/modern-js-ultramodern-app-tools 0.0.0 → 3.9.0-ultramodern.10

package/dist/esm-node/native-composition/index.mjs

@@ -0,0 +1,72 @@
+import "node:module";
+import { appTools } from "@modern-js/app-tools";
+import backend_federation_build from "@modern-js/app-tools-extensions/backend-federation-build";
+import { createCloudflareBuilderPlugin } from "@modern-js/app-tools-extensions/cloudflare-builder";
+import { createDeployOutputAliasesPlugin } from "@modern-js/app-tools-extensions/deploy-output/plugin";
+import { RENDERER_EXTENSIONS_PACKAGE, SERVER_EXTENSIONS_PLUGIN_NAME } from "@modern-js/app-tools-extensions/policy-defaults";
+import { collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin } from "@modern-js/app-tools-extensions/runtime-package-resolution";
+import { ultramodernI18nIntegrationPlugin } from "@modern-js/i18n-integration";
+import { ultramodernReleaseEnvelopePlugin } from "./release-envelope-plugin.mjs";
+import { ultramodernRouterIntegrationPlugin } from "./router-integration-plugin.mjs";
+import { rscDisabledRuntimePlugin } from "./rsc-disabled-plugin.mjs";
+import { ultramodernSSRIntegrationPlugin } from "./ssr-integration-plugin.mjs";
+const ultramodernAppTools = ()=>({
+        name: '@modern-js/ultramodern-app-tools',
+        usePlugins: [
+            appTools(),
+            ultramodernI18nIntegrationPlugin(),
+            ultramodernRouterIntegrationPlugin(),
+            ultramodernSSRIntegrationPlugin(),
+            backend_federation_build(),
+            createCloudflareBuilderPlugin(),
+            createDeployOutputAliasesPlugin(),
+            ultramodernReleaseEnvelopePlugin()
+        ],
+        setup (api) {
+            const runtimeModuleDirectories = collectRuntimePackageModuleDirectories([
+                RENDERER_EXTENSIONS_PACKAGE,
+                '@modern-js/i18n-integration'
+            ], import.meta.url);
+            api.modifyResolvedConfig((config)=>{
+                const builderPlugins = [
+                    ...config.builderPlugins ?? [],
+                    ...runtimeModuleDirectories.length > 0 ? [
+                        createRuntimePackageResolutionPlugin(runtimeModuleDirectories)
+                    ] : [],
+                    ...config.server?.rsc ? [] : [
+                        rscDisabledRuntimePlugin()
+                    ]
+                ];
+                return {
+                    ...config,
+                    builderPlugins
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                const name = '@modern-js/ultramodern-app-tools/server-plugin';
+                const renamed = plugins.map((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME ? {
+                        ...plugin,
+                        name
+                    } : plugin);
+                if (!renamed.some((plugin)=>plugin.name === name)) renamed.push({
+                    name
+                });
+                return {
+                    plugins: renamed
+                };
+            });
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                    name: 'rendererHead',
+                    path: RENDERER_EXTENSIONS_PACKAGE,
+                    config: {}
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+        }
+    });
+export { createPresetUltramodernConfig, presetUltramodern } from "./preset.mjs";
+export { ultramodernAppTools, ultramodernReleaseEnvelopePlugin };

package/dist/esm-node/native-composition/preset.mjs

@@ -0,0 +1,127 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { builderPluginAdapterPrecompress } from "@modern-js/app-tools-extensions/build-config/precompress/plugin";
+import { resolveEffectTsgoCompiler } from "@modern-js/app-tools-extensions/config";
+import { configureUltramodernTypeChecker } from "@modern-js/app-tools-extensions/native-type-checker";
+import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensions/release-identity";
+import { mergeConfig } from "@modern-js/plugin/cli";
+import { rspack } from "@rsbuild/core";
+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)=>{
+    const resolveNodeModulePackageJson = (packageName, fromDirectory)=>{
+        let currentDirectory = node_path.resolve(fromDirectory);
+        while(true){
+            const packageJson = node_path.join(currentDirectory, 'node_modules', packageName, 'package.json');
+            if (node_fs.existsSync(packageJson)) return node_fs.realpathSync(packageJson);
+            const parentDirectory = node_path.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) return;
+            currentDirectory = parentDirectory;
+        }
+    };
+    const reactRouterPackageJson = resolveNodeModulePackageJson('react-router', appDirectory);
+    if (reactRouterPackageJson) return node_path.dirname(reactRouterPackageJson);
+    const reactRouterDomPackageJson = resolveNodeModulePackageJson('react-router-dom', appDirectory);
+    if (!reactRouterDomPackageJson) return;
+    const nestedReactRouterPackageJson = resolveNodeModulePackageJson('react-router', node_path.dirname(reactRouterDomPackageJson));
+    if (nestedReactRouterPackageJson) return node_path.dirname(nestedReactRouterPackageJson);
+};
+const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
+    const chainContext = chain.get('context');
+    const appDirectory = 'string' == typeof chainContext && chainContext.length > 0 ? chainContext : process.cwd();
+    const reactRouterPackageDir = resolveReactRouterPackageDir(appDirectory);
+    if (!reactRouterPackageDir) return;
+    const productionEntry = node_path.join(reactRouterPackageDir, 'dist/production/index.mjs');
+    const developmentEntry = node_path.join(reactRouterPackageDir, 'dist/development/index.mjs');
+    chain.resolve.alias.set('react-router$', isProd ? productionEntry : developmentEntry);
+    chain.resolve.alias.set('react-router/dist/production/index.js', productionEntry);
+    chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
+};
+const createPresetUltramodernConfig = (options = {})=>{
+    const { appId = 'app', deliveryUnit, enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = false, enableModuleFederationSSR = true } = options;
+    const server = {};
+    const releaseIdentity = deliveryUnit ? resolveUltramodernReleaseIdentity({
+        generationBuildMarker: deliveryUnit.buildMarker,
+        unitId: deliveryUnit.unitId
+    }) : void 0;
+    const bundledReleaseIdentity = releaseIdentity ? {
+        ...releaseIdentity,
+        releaseVersion: deliveryUnit.version
+    } : void 0;
+    if (enableTelemetry) {
+        server.telemetry = {
+            enabled: true,
+            failLoudStartup: telemetryFailLoudStartup
+        };
+        if (false !== enableTelemetryExporters) {
+            const exporters = {};
+            if (true === enableTelemetryExporters || otlpEndpoint) exporters.otlp = {
+                enabled: true,
+                endpoint: otlpEndpoint || DEFAULT_OTLP_ENDPOINT
+            };
+            if (true === enableTelemetryExporters || victoriaMetricsEndpoint) exporters.victoriaMetrics = {
+                enabled: true,
+                endpoint: victoriaMetricsEndpoint || DEFAULT_VICTORIA_METRICS_ENDPOINT
+            };
+            if (Object.keys(exporters).length > 0) server.telemetry.exporters = exporters;
+        }
+    }
+    if (enableModuleFederationSSR) server.ssr = {
+        mode: 'stream',
+        moduleFederationAppSSR: true
+    };
+    const presetConfig = {
+        output: {
+            precompress: true
+        },
+        server,
+        source: {
+            reactCompiler: true,
+            ...deliveryUnit ? {
+                globalVars: {
+                    ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
+                    ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
+                    ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
+                }
+            } : {}
+        },
+        tools: {
+            bundlerChain: (chain, utils)=>{
+                setReactRouterBridgeSafeAliases(chain, utils);
+                configureUltramodernTypeChecker(chain, utils.CHAIN_ID.PLUGIN.TS_CHECKER, (from)=>resolveEffectTsgoCompiler({
+                        from
+                    }));
+            },
+            lightningcssLoader: true,
+            ...bundledReleaseIdentity ? {
+                rspack: (config)=>{
+                    config.plugins ??= [];
+                    config.plugins.push(new rspack.BannerPlugin({
+                        banner: `void ${JSON.stringify(bundledReleaseIdentity.buildMarker)};void ${JSON.stringify(bundledReleaseIdentity.sourceRevision)};void ${JSON.stringify(bundledReleaseIdentity.releaseVersion)};`,
+                        raw: true,
+                        stage: rspack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+                        test: /\.(?:c|m)?js$/u
+                    }));
+                    return config;
+                }
+            } : {}
+        }
+    };
+    if (enableBffRequestId) presetConfig.bff = {
+        requestId: appId
+    };
+    return presetConfig;
+};
+const presetUltramodern = (config, options = {})=>{
+    const merged = mergeConfig([
+        createPresetUltramodernConfig(options),
+        config
+    ]);
+    merged.builderPlugins = [
+        builderPluginAdapterPrecompress(merged.output?.precompress),
+        ...merged.builderPlugins ?? []
+    ];
+    return merged;
+};
+export { createPresetUltramodernConfig, presetUltramodern };

package/dist/esm-node/native-composition/release-envelope-plugin.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { resolveDeployTarget } from "@modern-js/app-tools-extensions/deploy-output/target";
+import { createUltramodernReleaseEnvelopePlugin } from "@modern-js/app-tools-extensions/release-envelope/plugin";
+const ultramodernReleaseEnvelopePlugin = ()=>createUltramodernReleaseEnvelopePlugin({
+        resolveDeployTarget: resolveDeployTarget
+    });
+export { ultramodernReleaseEnvelopePlugin };

package/dist/esm-node/native-composition/router-integration-plugin.mjs

@@ -0,0 +1,18 @@
+import "node:module";
+const ultramodernRouterIntegrationPlugin = ()=>({
+        name: '@modern-js/ultramodern-router-integration',
+        pre: [
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-tanstack'
+        ],
+        setup (api) {
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>({
+                    entrypoint,
+                    plugins: plugins.map((plugin)=>'@modern-js/runtime/router/internal' === plugin.path ? {
+                            ...plugin,
+                            path: '@modern-js/ultramodern-app-tools/router-runtime'
+                        } : plugin)
+                }));
+        }
+    });
+export { ultramodernRouterIntegrationPlugin };

package/dist/esm-node/native-composition/router-runtime.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+import { routerPlugin, routerProviderRegistryHooks } from "@modern-js/runtime/router/internal";
+import { createRouterPlugin } from "@modern-js/runtime-extensions/router-provider";
+import { createRouterStatePlugin } from "@modern-js/runtime-extensions/router-state-plugin";
+const createProvider = createRouterPlugin({
+    defaultProvider: {
+        name: 'react-router',
+        factory: routerPlugin
+    },
+    registryHooks: routerProviderRegistryHooks
+});
+const router_runtime_routerPlugin = (config)=>{
+    const state = createRouterStatePlugin({
+        registryHooks: routerProviderRegistryHooks
+    });
+    const provider = createProvider(config);
+    return {
+        ...provider,
+        setup (api) {
+            state.setup?.(api);
+            return provider.setup?.(api);
+        }
+    };
+};
+const router_runtime = router_runtime_routerPlugin;
+export default router_runtime;
+export { router_runtime_routerPlugin as routerPlugin };

package/dist/esm-node/native-composition/rsc-disabled-plugin.mjs

@@ -0,0 +1,81 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+const disabledRuntimeModules = {
+    'react-server-dom-rspack/client.browser': './rscDisabledClientBrowserRuntime',
+    'react-server-dom-rspack/client.edge': './rscDisabledClientEdgeRuntime',
+    'react-server-dom-rspack/client.node': './rscDisabledClientNodeRuntime',
+    'react-server-dom-rspack/server.edge': './rscDisabledServerEdgeRuntime',
+    'react-server-dom-rspack/server.node': './rscDisabledServerNodeRuntime'
+};
+const disabledRuntimeRequests = Object.keys(disabledRuntimeModules);
+function aliasMatchesRequest(aliasName, request) {
+    const exact = aliasName.endsWith('$');
+    const normalizedName = exact ? aliasName.slice(0, -1) : aliasName;
+    return exact ? normalizedName === request : request === normalizedName || request.startsWith(`${normalizedName}/`);
+}
+function objectAliasMatchesDisabledRuntime(aliasName) {
+    return disabledRuntimeRequests.some((request)=>aliasMatchesRequest(aliasName, request));
+}
+function arrayAliasMatchesDisabledRuntime(alias) {
+    const aliasName = `${alias.name}${alias.onlyModule ? '$' : ''}`;
+    return objectAliasMatchesDisabledRuntime(aliasName);
+}
+function normalizeArrayAliases(aliases) {
+    const normalized = {};
+    for (const alias of aliases){
+        if (arrayAliasMatchesDisabledRuntime(alias)) continue;
+        const aliasName = `${alias.name}${alias.onlyModule ? '$' : ''}`;
+        const existing = normalized[aliasName];
+        if (void 0 === existing) {
+            normalized[aliasName] = alias.alias;
+            continue;
+        }
+        normalized[aliasName] = [
+            ...Array.isArray(existing) ? existing : [
+                existing
+            ],
+            ...Array.isArray(alias.alias) ? alias.alias : [
+                alias.alias
+            ]
+        ];
+    }
+    return normalized;
+}
+function resolveDisabledRuntimeModules() {
+    return Object.fromEntries(Object.entries(disabledRuntimeModules).map(([request, moduleRequest])=>[
+            `${request}$`,
+            require.resolve(`@modern-js/runtime-extensions/rsc-disabled/${moduleRequest.slice(2)}`)
+        ]));
+}
+function applyDisabledRuntimeAliases(config, disabledAliases) {
+    config.resolve ??= {};
+    if (Array.isArray(config.resolve.alias)) config.resolve.alias = {
+        ...disabledAliases,
+        ...normalizeArrayAliases(config.resolve.alias)
+    };
+    else config.resolve.alias = {
+        ...disabledAliases,
+        ...Object.fromEntries(Object.entries(config.resolve.alias ?? {}).filter(([aliasName])=>!objectAliasMatchesDisabledRuntime(aliasName)))
+    };
+}
+function rscDisabledRuntimePlugin() {
+    return {
+        name: 'builder:rsc-disabled-runtime',
+        setup (api) {
+            const disabledAliases = resolveDisabledRuntimeModules();
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    applyDisabledRuntimeAliases(config, disabledAliases);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)applyDisabledRuntimeAliases(config, disabledAliases);
+                }
+            });
+        }
+    };
+}
+export { rscDisabledRuntimePlugin };

package/dist/esm-node/native-composition/server-plugin.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { default } from "@modern-js/server-runtime-extensions/server-plugin";

package/dist/esm-node/native-composition/ssr-integration-plugin.mjs

@@ -0,0 +1,105 @@
+import "node:module";
+const getRspackPlugins = (rspackConfig)=>{
+    if (!rspackConfig) return [];
+    const rspackEntries = Array.isArray(rspackConfig) ? rspackConfig : [
+        rspackConfig
+    ];
+    const plugins = [];
+    for (const entry of rspackEntries){
+        if (!entry || 'function' == typeof entry || 'object' != typeof entry) continue;
+        const maybePlugins = entry.plugins;
+        if (Array.isArray(maybePlugins)) {
+            for (const plugin of maybePlugins)if (plugin) plugins.push(plugin);
+        }
+    }
+    return plugins;
+};
+const getRspackPluginName = (plugin)=>{
+    if ('string' == typeof plugin) return plugin;
+    if ('function' == typeof plugin) return plugin.name;
+    if (Array.isArray(plugin)) {
+        const [first] = plugin;
+        if (!first) return;
+        if ('string' == typeof first) return first;
+        if ('function' == typeof first) return first.name;
+        if ('object' == typeof first) return first.name || first.constructor?.name;
+        return;
+    }
+    return plugin.name || plugin.constructor?.name;
+};
+const hasServerRenderingConfig = (userConfig)=>{
+    const { output, server } = userConfig;
+    if (output?.ssg) return true;
+    if (output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return true;
+    if (server?.ssr) return true;
+    if (server?.ssrByEntries && Object.keys(server.ssrByEntries).length > 0) return true;
+    return false;
+};
+const isModuleFederationAppSSREnabledInConfig = (ssr)=>{
+    if (!ssr || 'object' != typeof ssr) return false;
+    return true === ssr.moduleFederationAppSSR;
+};
+const isModuleFederationAppSSREnabled = (userConfig)=>{
+    if (isModuleFederationAppSSREnabledInConfig(userConfig.server?.ssr)) return true;
+    if (userConfig.server?.ssrByEntries && 'object' == typeof userConfig.server.ssrByEntries) return Object.values(userConfig.server.ssrByEntries).some(isModuleFederationAppSSREnabledInConfig);
+    return false;
+};
+const isModuleFederationRspackPlugin = (plugin)=>{
+    const candidate = getRspackPluginName(plugin);
+    return 'string' == typeof candidate && /modulefederation/i.test(candidate);
+};
+const hasModuleFederationMarker = (config)=>{
+    if ('true' === process.env.MF_SSR_PRJ) return true;
+    const define = config.source?.define || {};
+    if ('REMOTE_IP_STRATEGY' in define || 'FEDERATION_IPV4' in define) return true;
+    const plugins = getRspackPlugins(config.tools?.rspack);
+    return plugins.some(isModuleFederationRspackPlugin);
+};
+const isNodeEnvironmentTarget = (target)=>'string' == typeof target && ('node' === target || 'async-node' === target || target.startsWith('node'));
+const shouldUseModuleFederationNodeOutput = (config)=>isNodeEnvironmentTarget(config.output?.target) && hasModuleFederationMarker(config);
+const ssrIntegrationBuilderPlugin = (modernAPI)=>({
+        name: '@modern-js/ultramodern-builder-plugin-ssr',
+        pre: [
+            '@modern-js/builder-plugin-ssr'
+        ],
+        setup (api) {
+            api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
+                const isServerEnvironment = isNodeEnvironmentTarget(config.output.target) || 'workerSSR' === name;
+                const userConfig = modernAPI.getNormalizedConfig();
+                const hasServerRendering = hasServerRenderingConfig(userConfig);
+                const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
+                const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
+                const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
+                if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
+                    const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
+                    if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
+                    console.warn(warningMessage);
+                }
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
+                return mergeEnvironmentConfig(config, {
+                    source: {
+                        define: {
+                            'process.env.MODERN_MF_APP_SSR': JSON.stringify(String(isModuleFederationAppSSR))
+                        }
+                    },
+                    ...'workerSSR' === name && userConfig.deploy?.target === 'cloudflare' ? {
+                        output: {
+                            module: true
+                        }
+                    } : {},
+                    splitChunks: isServerEnvironment && (hasModuleFederationRuntimeMarker || hasExplicitMfSsrFlag) ? false : void 0
+                });
+            });
+        }
+    });
+const ultramodernSSRIntegrationPlugin = ()=>({
+        name: '@modern-js/ultramodern-ssr-integration',
+        setup (api) {
+            api.config(()=>({
+                    builderPlugins: [
+                        ssrIntegrationBuilderPlugin(api)
+                    ]
+                }));
+        }
+    });
+export { shouldUseModuleFederationNodeOutput, ultramodernSSRIntegrationPlugin };

package/dist/esm-node/native-composition/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/types/native-composition/index.d.ts

@@ -0,0 +1,6 @@
+import { type AppTools, type CliPlugin } from '@modern-js/app-tools';
+export { createPresetUltramodernConfig, type PresetUltramodernOptions, presetUltramodern, } from './preset.js';
+export { ultramodernReleaseEnvelopePlugin } from './release-envelope-plugin.js';
+export type { AppUserConfig, UltramodernAppUserConfig } from './types.js';
+/** Compose the fork's build and release features through native CLI plugins. */
+export declare const ultramodernAppTools: () => CliPlugin<AppTools>;

package/dist/types/native-composition/preset.d.ts

@@ -0,0 +1,86 @@
+import type { AppUserConfig } from './types.js';
+export interface PresetUltramodernOptions {
+    /**
+     * Stable producer identity used by BFF cross-project clients.
+     * @default "app"
+     */
+    appId?: string;
+    /**
+     * Generation-time identity root for a generated delivery unit. When set, the
+     * preset derives one build identity from the immutable source revision and
+     * injects it into every browser, SSR, API, and backend bundle.
+     */
+    deliveryUnit?: {
+        buildMarker: string;
+        unitId: string;
+        version: string;
+    };
+    /**
+     * Enable BFF requestId contract by default.
+     * @default true
+     */
+    enableBffRequestId?: boolean;
+    /**
+     * Enable telemetry contract by default.
+     * Exporters are still configured separately by applications.
+     * @default true
+     */
+    enableTelemetry?: boolean;
+    /**
+     * Enable telemetry exporters.
+     *
+     * By default each exporter is enabled only when its endpoint is explicitly
+     * configured (via the matching option or environment variable), so a bare
+     * preset app boots in production without local collectors.
+     * Set `true` to force both exporters on with their default localhost
+     * endpoints, or `false` to disable exporters entirely.
+     * @default undefined (endpoint-driven)
+     */
+    enableTelemetryExporters?: boolean;
+    /**
+     * OTLP exporter endpoint. Setting it (or the environment variable)
+     * enables the OTLP exporter unless `enableTelemetryExporters` is `false`.
+     * 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`.
+     * 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;
+    /**
+     * Enable fail-loud startup probing for telemetry exporters.
+     * Probes only run for exporters that are actually enabled.
+     * @default false
+     */
+    telemetryFailLoudStartup?: boolean;
+    /**
+     * Enable app-level Module Federation SSR handshake by default.
+     * @default true
+     */
+    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/native-composition/release-envelope-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const ultramodernReleaseEnvelopePlugin: () => CliPlugin<AppTools>;

package/dist/types/native-composition/router-integration-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+/** Add fork router policy after the native and optional provider selectors. */
+export declare const ultramodernRouterIntegrationPlugin: () => CliPlugin<AppTools>;

package/dist/types/native-composition/router-runtime.d.ts

@@ -0,0 +1,4 @@
+import { routerPlugin as nativeRouterPlugin } from '@modern-js/runtime/router/internal';
+/** Install fork observers before the native provider registers its lifecycle. */
+export declare const routerPlugin: typeof nativeRouterPlugin;
+export default routerPlugin;

package/dist/types/native-composition/rsc-disabled-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function rscDisabledRuntimePlugin(): RsbuildPlugin;

package/dist/types/native-composition/server-plugin.d.ts

@@ -0,0 +1 @@
+export { default } from '@modern-js/server-runtime-extensions/server-plugin';

package/dist/types/native-composition/ssr-integration-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { MergedEnvironmentConfig } from '@rsbuild/core';
+type EnvironmentConfigLike = Partial<Pick<MergedEnvironmentConfig, 'output' | 'source' | 'tools'>>;
+export declare const shouldUseModuleFederationNodeOutput: (config: EnvironmentConfigLike) => boolean;
+/** Apply fork SSR policy after native SSR defaults through Rsbuild hooks. */
+export declare const ultramodernSSRIntegrationPlugin: () => CliPlugin<AppTools>;
+export {};

package/dist/types/native-composition/types.d.ts

@@ -0,0 +1,24 @@
+import type { AppUserConfig as NativeAppUserConfig } from '@modern-js/app-tools';
+import type { PrecompressConfig } from '@modern-js/app-tools-extensions/build-config/precompress/plugin';
+import type { CloudflareDeployConfig } from '@modern-js/app-tools-extensions/config';
+import type { BffRuntimeUserConfig, ServerTelemetryUserConfig } from '@modern-js/runtime-extensions/server-config';
+type NativeServerConfig = NonNullable<NativeAppUserConfig['server']>;
+type NativeSSRConfig = Exclude<NativeServerConfig['ssr'], boolean | undefined>;
+/** Native Modern.js configuration with the fork's explicitly owned options. */
+export type UltramodernAppUserConfig = Omit<NativeAppUserConfig, 'output' | 'server' | 'bff' | 'deploy'> & {
+    output?: Omit<NonNullable<NativeAppUserConfig['output']>, 'precompress'> & {
+        precompress?: boolean | PrecompressConfig;
+    };
+    server?: Omit<NativeServerConfig, 'ssr' | 'telemetry'> & {
+        ssr?: boolean | (NativeSSRConfig & {
+            moduleFederationAppSSR?: boolean;
+        });
+        telemetry?: ServerTelemetryUserConfig;
+    };
+    bff?: Omit<NonNullable<NativeAppUserConfig['bff']>, keyof BffRuntimeUserConfig> & BffRuntimeUserConfig & {
+        requestId?: string;
+    };
+    deploy?: NonNullable<NativeAppUserConfig['deploy']> & CloudflareDeployConfig;
+};
+export type AppUserConfig = UltramodernAppUserConfig;
+export {};

package/dist/types-esm/native-composition/index.d.mts

@@ -0,0 +1,6 @@
+import { type AppTools, type CliPlugin } from '@modern-js/app-tools';
+export { createPresetUltramodernConfig, type PresetUltramodernOptions, presetUltramodern, } from './preset.mjs';
+export { ultramodernReleaseEnvelopePlugin } from './release-envelope-plugin.mjs';
+export type { AppUserConfig, UltramodernAppUserConfig } from './types.mjs';
+/** Compose the fork's build and release features through native CLI plugins. */
+export declare const ultramodernAppTools: () => CliPlugin<AppTools>;