@bleedingdev/modern-js-ultramodern-app-tools 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/README.md

@@ -0,0 +1,189 @@
+# UltraModern.js application tools
+
+Select the application renderer in `modern.config.ts`. `defineConfig` registers
+the selected compiler, runtime, router integration and server lifecycle.
+
+```ts
+import { defineConfig } from '@modern-js/ultramodern-app-tools';
+
+export default defineConfig({
+  renderer: 'solid', // 'react' or 'octane'; omitted means 'react'
+  server: { ssr: true },
+});
+```
+
+Use Node **26.10.0 or newer**. Run the installed application's public CLI:
+
+```sh
+pnpm exec ultramodern dev
+pnpm exec ultramodern build
+pnpm exec ultramodern serve
+```
+
+The selector belongs to this config import. Do not add another `appTools()` or
+`ultramodernAppTools()` base plugin. Changing the renderer requires matching
+native application source and dependencies, then a dev-server restart and a
+document reload. The generated entries own mounting and hydration.
+
+## Native application imports
+
+| Renderer | Component authoring | Application router |
+| --- | --- | --- |
+| React | `react` | `react-router`, or the configured TanStack integration |
+| Solid 2 | `solid-js`, `@solidjs/web` | `@modern-js/renderer-solid/router` |
+| Octane | `octane` | `@modern-js/renderer-octane/router` |
+
+Solid and Octane use their native component syntax and managed filesystem
+routes. Generated applications import the runtime modules of their renderer
+package automatically: `/entry-client`, `/entry-server`, `/router`, `/i18n`
+and `/manifest`, plus `/federation` for Solid. `/plugin` is the build-only
+adapter; only the CLI loads it.
+
+### Renderer adapters
+
+Every renderer is a `RendererAdapter` from `@modern-js/renderer-core/adapter`.
+`defineConfig` loads only the selected one:
+
+- `react` is a composed adapter (`src/renderers/react`). Its `compose()`
+  registers the Modern.js React graph.
+- `solid` and `octane` are native adapters exported from
+  `@modern-js/renderer-<renderer>/plugin`. Each one carries its build profile,
+  runtime entry modules, Rsbuild compiler plugin, compiler artifact checks,
+  Module Federation singletons, worker support and create templates.
+
+This package keeps the renderer-neutral parts: config selection, the
+registered renderers' package and source-extension ownership, capability
+checks, and one build, dev, SSG, worker and federation pipeline for every
+native adapter. The entries it generates hold only data: `index.ts` calls the
+renderer's `startNativeClient()`, `index.server.ts` calls
+`createNativeServerEntry()`, and `app.client.ts`/`app.server.ts` list the
+route modules. Mounting, hydration, documents, sessions, i18n and data
+endpoints live in `@modern-js/renderer-core/entry-client` and
+`@modern-js/renderer-core/entry-server`.
+
+## Supported preview profile
+
+Solid **2.0.0-rc.13** and Octane are Node previews with CSR, native streaming SSR,
+hydration, route loading and actions. Their exact compiler, runtime and router
+pins come from `resolveRendererProfile` exported by this package. Octane uses
+the maintained [BleedingDev release artifacts](https://github.com/bleedingdev/octane/releases)
+selected by that profile.
+
+Native previews reject React Server Components, React runtime i18n
+configuration and CSS declaration emission beside authored source. Octane
+also rejects Module Federation.
+These limits are checked before output generation; there is no preview bypass.
+
+Native apps localize with `i18nPlugin()` from this package, which takes the
+same `localeDetection`/`backend` options as `@modern-js/plugin-i18n`. URLs are
+language-prefixed (`/cs/about`), translations come from
+`locales/<language>/<namespace>.json`, and components use `useI18n`,
+`LocalizedLink` and `I18nProvider` from `@modern-js/renderer-<renderer>/i18n`.
+Install `i18next` and `@modern-js/i18n-runtime-extensions` next to the renderer:
+
+```ts
+import { defineConfig, i18nPlugin } from '@modern-js/ultramodern-app-tools';
+
+export default defineConfig({
+  renderer: 'solid',
+  server: { ssr: true },
+  plugins: [
+    i18nPlugin({
+      localeDetection: { languages: ['en', 'cs'], fallbackLanguage: 'en' },
+    }),
+  ],
+});
+```
+
+`output.ssg` and `output.ssgByEntries` prerender native routes after the build,
+in the same `dist/html/<entry>/<route>/index.html` layout as React SSG. Each
+document's search-free loader data is written beside it, so client navigation
+between prerendered routes works on a static host. A route cannot use both SSR
+and SSG.
+
+`import Icon from './icon.svg?component'` compiles an SVG into a Solid or
+Octane component; `output.svgDefaultExport: 'component'` does the same for
+plain `.svg` imports from scripts. Stylesheets and `?url` imports keep URLs.
+Add `/// <reference types="@modern-js/ultramodern-app-tools/types" />` for the
+`?component` module type.
+
+Solid's native public route snapshots accept immutable plain records, arrays,
+scalars and checked top-level deferred Promise slots. Rich HTTP data transport
+is a separate `@modern-js/renderer-core/data` surface. Request objects, headers,
+bindings and session state remain private to the request.
+Authored deferred Promises use the standard prototype without custom own
+properties. Symbol-bearing source Promises from async-hooks instrumentation and
+Node's `--no-async-context-frame` mode are outside this preview profile.
+
+Generate a workspace with the selected dependencies through
+[`@modern-js/ultramodern-create`](../../toolkit/ultramodern-create/README.md).
+Build and document identities bind the application source and installed
+compiler/runtime cohort; stale manifests or hydration identities fail before
+application startup.
+
+## Workspace applications
+
+Generated workspace applications declare their identity and authored options:
+
+```ts
+import {
+  defineConfig,
+  presetUltramodernWorkspace,
+} from '@modern-js/ultramodern-app-tools';
+
+export default defineConfig(
+  presetUltramodernWorkspace(
+    { html: { title: 'Catalog' } },
+    { appId: 'catalog', from: import.meta.url },
+  ),
+);
+```
+
+The workspace preset reads `topology/reference-topology.json` and
+`topology/local-overlays/development.json` relative to that config. Those records
+provide app identity, renderer, development ports, composed remote references
+and delivery unit identity. An authored `renderer` must match the topology.
+Adding a shell or vertical changes the records; existing application configs
+keep their authored contents.
+
+The native package resolves build output and cache directories, remote asset
+origins, canonical site origins, local CORS and Cloudflare service bindings and
+fragment routes. Deploy target selection uses Modern.js's native resolver.
+`deployTarget` and `environment` options allow explicit programmatic build inputs.
+`createPresetUltramodernWorkspaceConfig(options)` exposes the resolved config for
+inspection.
+
+Cloudflare fragment bindings use the expose names from each remote's authored
+Module Federation config. The shared config inspector accepts literal objects
+and string arrays. Dynamic declarations use Modern.js's native config loader
+during config resolution, including async functions, environment and command
+arguments. Authored worker settings and services remain part of the merged
+config; dynamic bindings use the loaded exposes.
+
+The old generated `performance.rsdoctor` setting was not part of Modern.js's
+supported config and had no effect. The native preset omits it.
+
+Zephyr registers only for browser applications. It loads the application's
+declared `zephyr-rspack-plugin` only when `ZE_CI_TOKEN` is present, and requires
+`ZE_FAIL_BUILD=true` in that deploy environment. Ordinary builds require no
+Zephyr account. The preset does not mutate environment variables.
+The Zephyr SDK reads credentials and its fail-build flag from `process.env`.
+When supplying `environment` explicitly, enabled Zephyr inputs must match those
+process values; a mismatch fails during plugin setup before registration.
+
+Authored config merges after native policy. Scalars and `false` override defaults;
+nested records are preserved; arrays and hooks compose in preset-first order.
+The existing typed preset options, including `enableTelemetry`,
+`enableTelemetryExporters`, `enableBffRequestId` and
+`enableModuleFederationSSR`, also apply to workspace presets.
+
+Standalone applications can continue using `presetUltramodern(config, options)`.
+
+## React base plugin
+
+`defineConfig` is the entry for every renderer. A React application that keeps
+`defineConfig` from `@modern-js/app-tools` registers the same React graph with
+`plugins: [ultramodernAppTools()]` instead. It keeps the fork's default React
+renderer and server behavior; pass `rendererExtensions: false` or
+`serverExtensions: false` to `ultramodernAppTools()` to opt out of either
+policy. Use one base: never combine it with this package's `defineConfig`.

package/bin/ultramodern.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+
+const [major, minor] = process.versions.node.split('.').map(Number);
+if (major < 26 || (major === 26 && minor < 10)) {
+  console.error(
+    `UltraModern.js requires Node.js >=26.10.0; detected v${process.versions.node}.`,
+  );
+  process.exit(1);
+}
+
+const { version } = JSON.parse(
+  await readFile(new URL('../package.json', import.meta.url), 'utf8'),
+);
+process.env.MODERN_JS_VERSION ??= version;
+
+const { run } = await import('../dist/esm-node/native-composition/cli.mjs');
+try {
+  await run({ version });
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+}

package/dist/cjs/native-composition/cli.js

@@ -0,0 +1,196 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRunOptions: ()=>createRunOptions,
+    generateRouteArtifacts: ()=>generateRouteArtifacts,
+    run: ()=>run
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const run_namespaceObject = require("@modern-js/app-tools/cli/run");
+const cli_namespaceObject = require("@modern-js/plugin/cli");
+const plugin_run_namespaceObject = require("@modern-js/plugin/run");
+const utils_namespaceObject = require("@modern-js/utils");
+const commander_namespaceObject = require("@modern-js/utils/commander");
+const core_namespaceObject = require("@rsbuild/core");
+const external_config_js_namespaceObject = require("./config.js");
+const external_native_entry_command_js_namespaceObject = require("./native-entry-command.js");
+async function createLauncherOptions(options) {
+    const configFile = external_node_path_default().resolve(options.cwd ?? process.cwd(), options.configFile ?? 'modern.config');
+    const runOptions = await (0, run_namespaceObject.createRunOptions)({
+        ...options,
+        configFile,
+        internalPlugins: {}
+    });
+    if (!runOptions.configFile && void 0 !== options.configFile && external_node_fs_default().existsSync(configFile)) return {
+        ...runOptions,
+        configFile
+    };
+    return runOptions;
+}
+async function createRunOptions(options) {
+    let routeConfig;
+    if ('routes-generate' === process.argv[2]) {
+        const command = (0, external_native_entry_command_js_namespaceObject.createRouteGenerationCommand)(new commander_namespaceObject.Command('ultramodern')).exitOverride();
+        await command.parseAsync(process.argv.slice(3), {
+            from: 'user'
+        });
+        routeConfig = command.opts().config;
+    }
+    const runOptions = await createLauncherOptions(options);
+    return routeConfig ? {
+        ...runOptions,
+        configFile: routeConfig
+    } : runOptions;
+}
+async function run(options) {
+    if ('routes-generate' === process.argv[2]) {
+        const flags = process.argv.slice(3);
+        if (flags.includes('-h') || flags.includes('--help')) return void process.stdout.write((0, external_native_entry_command_js_namespaceObject.createRouteGenerationCommand)(new commander_namespaceObject.Command('ultramodern')).helpInformation());
+        if (flags.includes('-V') || flags.includes('--version')) return void process.stdout.write(`${options.version}\n`);
+    }
+    const runOptions = await createRunOptions(options);
+    if ('routes-generate' === process.argv[2]) return void await generateRouteArtifacts({
+        appDirectory: options.cwd ?? process.cwd(),
+        configPath: runOptions.configFile || void 0,
+        version: options.version
+    });
+    await (0, plugin_run_namespaceObject.run)(runOptions);
+}
+let routeGenerationQueue = Promise.resolve();
+const routeGeneratorCli = (0, cli_namespaceObject.createCli)();
+function generateRouteArtifacts(options) {
+    const task = routeGenerationQueue.then(async ()=>{
+        const previousArgv = process.env.MODERN_ARGV;
+        let dispose;
+        let getEntrypoints;
+        let generationFailed = false;
+        let generationError;
+        let disposalFailed = false;
+        let disposalError;
+        process.env.MODERN_ARGV = 'node ultramodern routes-generate';
+        try {
+            const appDirectory = external_node_path_default().resolve(options.appDirectory);
+            (0, core_namespaceObject.loadEnv)({
+                cwd: appDirectory,
+                mode: process.env.MODERN_ENV || process.env.NODE_ENV,
+                prefixes: [
+                    'MODERN_'
+                ]
+            });
+            const loaded = await (0, external_config_js_namespaceObject.loadUltramodernConfigFile)({
+                appDirectory,
+                configFile: options.configPath,
+                command: 'routes-generate',
+                env: (0, utils_namespaceObject.getNodeEnv)()
+            });
+            const runOptions = await createLauncherOptions({
+                cwd: appDirectory,
+                version: options.version ?? process.env.MODERN_JS_VERSION ?? '0.0.0'
+            });
+            const lifecycle = {
+                name: '@modern-js/ultramodern-route-generation-lifecycle',
+                setup (api) {
+                    api.updateAppContext({
+                        configFile: loaded.configFile
+                    });
+                    dispose = ()=>api.getHooks().onBeforeExit.call();
+                    getEntrypoints = ()=>api.getAppContext().entrypoints;
+                }
+            };
+            const { appContext } = await routeGeneratorCli.init({
+                ...runOptions,
+                configFile: false,
+                config: loaded.config,
+                command: 'routes-generate',
+                internalPlugins: [
+                    lifecycle,
+                    ...runOptions.internalPlugins
+                ]
+            });
+            const entrypoints = getEntrypoints?.();
+            if (!entrypoints?.length) throw new Error('Route generation requires an application entry');
+            await appContext.hooks.generateEntryCode.call({
+                entrypoints: [
+                    ...entrypoints
+                ]
+            });
+        } catch (error) {
+            generationFailed = true;
+            generationError = error;
+        } finally{
+            try {
+                await dispose?.();
+            } catch (error) {
+                disposalFailed = true;
+                disposalError = error;
+            } finally{
+                try {
+                    routeGeneratorCli.dispose();
+                } finally{
+                    if (void 0 === previousArgv) delete process.env.MODERN_ARGV;
+                    else process.env.MODERN_ARGV = previousArgv;
+                }
+            }
+        }
+        if (generationFailed && disposalFailed) throw new AggregateError([
+            generationError,
+            disposalError
+        ], 'Route generation failed and disposal also failed', {
+            cause: generationError
+        });
+        if (generationFailed) throw generationError;
+        if (disposalFailed) throw disposalError;
+    });
+    routeGenerationQueue = task.then(()=>void 0, ()=>void 0);
+    return task;
+}
+exports.createRunOptions = __webpack_exports__.createRunOptions;
+exports.generateRouteArtifacts = __webpack_exports__.generateRouteArtifacts;
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRunOptions",
+    "generateRouteArtifacts",
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-composition/config-metadata-worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_config_metadata_js_namespaceObject = require("./config-metadata.js");
+process.once('disconnect', ()=>process.exit(1));
+function reply(message, exitCode) {
+    process.send(message, ()=>process.exit(exitCode));
+}
+process.once('message', (options)=>{
+    (0, external_config_metadata_js_namespaceObject.readUltramodernConfigMetadata)(options).then((result)=>reply({
+            result
+        }, 0), (value)=>{
+        const error = value instanceof Error ? value : new Error(String(value));
+        reply({
+            error: {
+                message: error.message,
+                stack: error.stack
+            }
+        }, 1);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-composition/config-metadata.js

@@ -0,0 +1,195 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    loadUltramodernConfigMetadata: ()=>loadUltramodernConfigMetadata,
+    readUltramodernConfigMetadata: ()=>readUltramodernConfigMetadata
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const core_namespaceObject = require("@rsbuild/core");
+const external_config_js_namespaceObject = require("./config.js");
+function inside(directory, file) {
+    const relative = external_node_path_default().relative(directory, file);
+    return '' !== relative && !relative.startsWith(`..${external_node_path_default().sep}`) && '..' !== relative && !external_node_path_default().isAbsolute(relative);
+}
+function isMissingModule(error) {
+    const code = error?.code;
+    return 'MODULE_NOT_FOUND' === code || 'ERR_MODULE_NOT_FOUND' === code;
+}
+function registerFallbackResolution(sourceRoot, options) {
+    const packageRoots = options.fallbackPackageRoots ?? [];
+    const staged = options.stagedWorkspace;
+    if (!packageRoots.length && !staged) return;
+    let resolving = false;
+    return (0, external_node_module_namespaceObject.registerHooks)({
+        resolve (specifier, context, nextResolve) {
+            try {
+                return nextResolve(specifier, context);
+            } catch (error) {
+                const parentURL = context.parentURL;
+                if (resolving || !isMissingModule(error) || !parentURL?.startsWith('file:') || specifier.startsWith('.') || specifier.includes(':') || external_node_path_default().isAbsolute(specifier) || (0, external_node_module_namespaceObject.isBuiltin)(specifier)) throw error;
+                const parent = (0, external_node_url_namespaceObject.fileURLToPath)(parentURL);
+                if (parent.split(external_node_path_default().sep).includes('node_modules') || !inside(sourceRoot, parent)) throw error;
+                const anchors = [
+                    ...staged && inside(staged.root, parent) ? [
+                        external_node_path_default().join(staged.originalRoot, external_node_path_default().relative(staged.root, parent))
+                    ] : [],
+                    ...packageRoots.map((root)=>external_node_path_default().join(root, 'package.json'))
+                ];
+                const esm = context.conditions.includes('import') && !context.conditions.includes('require');
+                resolving = true;
+                try {
+                    for (const anchor of anchors)try {
+                        if (esm) return nextResolve(specifier, {
+                            ...context,
+                            parentURL: (0, external_node_url_namespaceObject.pathToFileURL)(anchor).href
+                        });
+                        return {
+                            url: (0, external_node_url_namespaceObject.pathToFileURL)((0, external_node_module_namespaceObject.createRequire)(anchor).resolve(specifier)).href,
+                            shortCircuit: true
+                        };
+                    } catch (fallbackError) {
+                        if (!isMissingModule(fallbackError)) throw fallbackError;
+                    }
+                } finally{
+                    resolving = false;
+                }
+                throw error;
+            }
+        }
+    });
+}
+async function readUltramodernConfigMetadata(options) {
+    const appDirectory = external_node_path_default().resolve(options.appDirectory);
+    const env = (0, core_namespaceObject.loadEnv)({
+        cwd: appDirectory,
+        mode: process.env.MODERN_ENV || options.env,
+        prefixes: [
+            'MODERN_'
+        ]
+    });
+    const hooks = registerFallbackResolution(external_node_path_default().resolve(options.sourceRoot ?? appDirectory), options);
+    try {
+        const loaded = await (0, external_config_js_namespaceObject.loadUltramodernConfigFile)({
+            appDirectory,
+            configFile: options.configFile,
+            env: options.env,
+            command: options.command
+        });
+        const resolution = await (0, external_config_js_namespaceObject.resolveUltramodernEntryIdentities)({
+            appDirectory,
+            installedAppDirectory: options.stagedWorkspace && (appDirectory === external_node_path_default().resolve(options.stagedWorkspace.root) || inside(external_node_path_default().resolve(options.stagedWorkspace.root), appDirectory)) ? external_node_path_default().resolve(options.stagedWorkspace.originalRoot, external_node_path_default().relative(options.stagedWorkspace.root, appDirectory)) : appDirectory,
+            config: loaded.config,
+            command: options.command,
+            configFile: loaded.configFile
+        });
+        return {
+            renderer: loaded.config.renderer,
+            ...resolution
+        };
+    } finally{
+        hooks?.deregister();
+        env.cleanup();
+    }
+}
+function workerFile() {
+    let directory = external_node_path_default().dirname(__filename);
+    while(!external_node_fs_default().existsSync(external_node_path_default().join(directory, 'package.json'))){
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) throw new Error('Cannot find the UltraModern app tools package root');
+        directory = parent;
+    }
+    return external_node_path_default().join(directory, 'dist/cjs/native-composition/config-metadata-worker.js');
+}
+function loadUltramodernConfigMetadata(options) {
+    const appDirectory = external_node_path_default().resolve(options.appDirectory);
+    return new Promise((resolve, reject)=>{
+        const child = (0, external_node_child_process_namespaceObject.fork)(workerFile(), [], {
+            cwd: appDirectory,
+            execArgv: [],
+            env: {
+                ...process.env,
+                NODE_ENV: options.env
+            },
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe',
+                'ipc'
+            ]
+        });
+        let output = '';
+        const collect = (chunk)=>{
+            output = `${output}${chunk.toString()}`.slice(-65536);
+        };
+        child.stdout?.on('data', collect);
+        child.stderr?.on('data', collect);
+        let message;
+        child.once('message', (value)=>{
+            message = value;
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal)=>{
+            if (message && 'result' in message) resolve(message.result);
+            else if (message) {
+                const error = new Error(message.error.message);
+                error.stack = message.error.stack;
+                reject(error);
+            } else reject(new Error(`Loading ${appDirectory}/modern.config exited (${signal ?? code}) without a result.${output ? `\n${output}` : ''}`));
+        });
+        child.send({
+            ...options,
+            appDirectory
+        });
+    });
+}
+exports.loadUltramodernConfigMetadata = __webpack_exports__.loadUltramodernConfigMetadata;
+exports.readUltramodernConfigMetadata = __webpack_exports__.readUltramodernConfigMetadata;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadUltramodernConfigMetadata",
+    "readUltramodernConfigMetadata"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-composition/config-read-context.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isEntryMetadataRead: ()=>isEntryMetadataRead,
+    withEntryMetadataRead: ()=>withEntryMetadataRead
+});
+const external_node_async_hooks_namespaceObject = require("node:async_hooks");
+const storeKey = Symbol.for('ultramodern.entry-metadata-read');
+const entryMetadataRead = globalThis[storeKey] ??= new external_node_async_hooks_namespaceObject.AsyncLocalStorage();
+function withEntryMetadataRead(read) {
+    return entryMetadataRead.run(true, read);
+}
+function isEntryMetadataRead() {
+    return true === entryMetadataRead.getStore();
+}
+exports.isEntryMetadataRead = __webpack_exports__.isEntryMetadataRead;
+exports.withEntryMetadataRead = __webpack_exports__.withEntryMetadataRead;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isEntryMetadataRead",
+    "withEntryMetadataRead"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});