@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/esm-node/build-config/build-environment.mjs

@@ -0,0 +1,225 @@
+import "node:module";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { accessSync, chmodSync, constants, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const EFFECT_TSGO_RESOLUTION_ERROR = 'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+const executableEffectTsgoCompilers = new Map();
+const BUILD_CONFIG_ENVIRONMENT_PLUGIN = 'ModernJsBuildConfigEnvironmentLeasePlugin';
+const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry/v1');
+const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry-brand/v1');
+const LIFECYCLE_HOOK_NAMES = [
+    'run',
+    'watchRun',
+    'afterDone',
+    'failed',
+    'shutdown',
+    'watchClose'
+];
+function restoreEnvironment(name, value) {
+    if (void 0 === value) delete process.env[name];
+    else process.env[name] = value;
+}
+function createEnvironmentLeaseRegistry() {
+    const environmentLeases = new Map();
+    return Object.freeze({
+        acquire (name, value) {
+            let lease = environmentLeases.get(name);
+            if (lease) {
+                if (lease.value !== value) throw new Error(`Build config environment "${name}" already has an active lease for a different value.`);
+                if (process.env[name] !== lease.value) throw new Error(`Build config environment lease for "${name}" lost ownership before another lease was acquired.`);
+            } else {
+                lease = {
+                    originalValue: process.env[name],
+                    owners: new Set(),
+                    value
+                };
+                process.env[name] = value;
+                environmentLeases.set(name, lease);
+            }
+            const owner = Symbol(name);
+            lease.owners.add(owner);
+            let released = false;
+            return ()=>{
+                if (released) return;
+                if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) throw new Error(`Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`);
+                released = true;
+                const lostOwnership = process.env[name] !== lease.value;
+                lease.owners.delete(owner);
+                if (0 === lease.owners.size) {
+                    environmentLeases.delete(name);
+                    restoreEnvironment(name, lease.originalValue);
+                } else if (lostOwnership) process.env[name] = lease.value;
+                if (lostOwnership) throw new Error(`Build config environment lease for "${name}" lost ownership before restoration.`);
+            };
+        },
+        brand: ENVIRONMENT_LEASE_REGISTRY_BRAND
+    });
+}
+function getEnvironmentLeaseRegistry() {
+    const descriptor = Object.getOwnPropertyDescriptor(process, ENVIRONMENT_LEASE_REGISTRY_KEY);
+    if (descriptor) {
+        const registry = descriptor.value;
+        if (descriptor.configurable || descriptor.enumerable || descriptor.writable || registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND || 'function' != typeof registry.acquire) throw new Error('The process-global build config environment lease registry is occupied by an incompatible value.');
+        return registry;
+    }
+    const registry = createEnvironmentLeaseRegistry();
+    Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
+        configurable: false,
+        enumerable: false,
+        value: registry,
+        writable: false
+    });
+    return registry;
+}
+function acquireEnvironmentLease(name, value) {
+    return getEnvironmentLeaseRegistry().acquire(name, value);
+}
+function releaseAfterFailure(release, originalError) {
+    try {
+        release();
+    } catch (restorationError) {
+        throw new AggregateError([
+            originalError,
+            restorationError
+        ], 'Build config environment setup and restoration both failed.');
+    }
+    throw originalError;
+}
+class BuildConfigEnvironmentLeasePlugin {
+    apply(compiler) {
+        const hooks = compiler.hooks;
+        try {
+            const lifecycleHooks = {};
+            for (const hookName of LIFECYCLE_HOOK_NAMES){
+                const hook = hooks[hookName];
+                if (!hook || 'function' != typeof hook.tap) throw new Error(`Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`);
+                lifecycleHooks[hookName] = hook;
+            }
+            let mode = 'pending';
+            const modeTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MIN_SAFE_INTEGER
+            };
+            const releaseTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MAX_SAFE_INTEGER
+            };
+            const releaseAfterOneShot = ()=>{
+                if ('watch' !== mode && true !== compiler.watchMode) this.release();
+            };
+            lifecycleHooks.run.tap(modeTap, ()=>{
+                mode = 'run';
+            });
+            lifecycleHooks.watchRun.tap(modeTap, ()=>{
+                mode = 'watch';
+            });
+            lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.shutdown.tap(releaseTap, this.release);
+            lifecycleHooks.watchClose.tap(releaseTap, this.release);
+        } catch (error) {
+            releaseAfterFailure(this.release, error);
+        }
+    }
+    constructor(release){
+        this.release = release;
+    }
+}
+function resolveEffectTsgoCli(from) {
+    const projectRequire = createRequire(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const bin = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.[EFFECT_TSGO_BIN];
+    if (!bin) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    return resolve(dirname(packageJsonPath), bin);
+}
+function resolveExecutableEffectTsgoCompiler(compilerPath) {
+    if ('win32' === process.platform) return compilerPath;
+    const sourcePath = realpathSync(compilerPath);
+    const source = lstatSync(sourcePath);
+    if (!source.isFile()) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    try {
+        accessSync(sourcePath, constants.X_OK);
+        return compilerPath;
+    } catch  {}
+    const cachedCompiler = executableEffectTsgoCompilers.get(sourcePath);
+    if (cachedCompiler) try {
+        accessSync(cachedCompiler, constants.X_OK);
+        return cachedCompiler;
+    } catch  {
+        executableEffectTsgoCompilers.delete(sourcePath);
+    }
+    const compilerBytes = readFileSync(sourcePath);
+    const compilerDigest = createHash('sha256').update(compilerBytes).digest('hex');
+    const compilerDirectory = join(tmpdir(), 'modern-js', 'effect-tsgo', compilerDigest);
+    mkdirSync(compilerDirectory, {
+        recursive: true,
+        mode: 448
+    });
+    const executableCompiler = join(compilerDirectory, basename(sourcePath));
+    try {
+        accessSync(executableCompiler, constants.X_OK);
+    } catch  {
+        const temporaryCompiler = join(compilerDirectory, `.${basename(sourcePath)}.${process.pid}.tmp`);
+        rmSync(temporaryCompiler, {
+            force: true
+        });
+        try {
+            writeFileSync(temporaryCompiler, compilerBytes, {
+                flag: 'wx',
+                mode: 448
+            });
+            chmodSync(temporaryCompiler, 448);
+            renameSync(temporaryCompiler, executableCompiler);
+        } finally{
+            rmSync(temporaryCompiler, {
+                force: true
+            });
+        }
+    }
+    accessSync(executableCompiler, constants.X_OK);
+    executableEffectTsgoCompilers.set(sourcePath, executableCompiler);
+    return executableCompiler;
+}
+function getBuildConfigEnvironment(name) {
+    return process.env[name];
+}
+function withBuildConfigEnvironment(name, value, setup) {
+    return async (config, ...args)=>{
+        const release = acquireEnvironmentLease(name, value);
+        try {
+            const configured = await setup(config, ...args) ?? config;
+            configured.plugins = [
+                ...configured.plugins ?? [],
+                new BuildConfigEnvironmentLeasePlugin(release)
+            ];
+            return configured;
+        } catch (error) {
+            releaseAfterFailure(release, error);
+        }
+    };
+}
+function resolveEffectTsgoCompiler(options) {
+    const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
+    if (configuredCompiler) try {
+        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+    } catch  {
+        throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    }
+    try {
+        const compiler = execFileSync(process.execPath, [
+            resolveEffectTsgoCli(options.from),
+            'get-exe-path'
+        ], {
+            encoding: 'utf-8'
+        }).trim();
+        if (compiler) return resolveExecutableEffectTsgoCompiler(compiler);
+    } catch  {}
+    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+}
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment };

package/dist/esm-node/build-config/precompress/plugin.mjs

@@ -0,0 +1,77 @@
+import "node:module";
+import { constants } from "node:zlib";
+import compression_webpack_plugin from "compression-webpack-plugin";
+const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
+const DEFAULT_PRECOMPRESS_THRESHOLD = 10240;
+const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
+const createDefaultGzipOptions = ()=>({
+        algorithm: 'gzip',
+        filename: '[path][base].gz',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            level: 6
+        }
+    });
+const createDefaultBrotliOptions = ()=>({
+        algorithm: 'brotliCompress',
+        filename: '[path][base].br',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            params: {
+                [constants.BROTLI_PARAM_QUALITY]: 9
+            }
+        }
+    });
+const mergeCompressionOptions = (base, next)=>{
+    const merged = {
+        ...base,
+        ...next
+    };
+    if (base.compressionOptions || next.compressionOptions) {
+        const baseCompressionOptions = base.compressionOptions;
+        const nextCompressionOptions = next.compressionOptions;
+        const mergedCompressionOptions = {
+            ...baseCompressionOptions,
+            ...nextCompressionOptions
+        };
+        if (baseCompressionOptions?.params || nextCompressionOptions?.params) mergedCompressionOptions.params = {
+            ...baseCompressionOptions?.params,
+            ...nextCompressionOptions?.params
+        };
+        merged.compressionOptions = mergedCompressionOptions;
+    }
+    return merged;
+};
+const resolveCodecOptions = (codecConfig, createDefaultOptions)=>{
+    if (false === codecConfig) return null;
+    if (void 0 === codecConfig || true === codecConfig) return createDefaultOptions();
+    return mergeCompressionOptions(createDefaultOptions(), codecConfig);
+};
+const resolvePrecompressConfig = (precompress)=>{
+    if (false === precompress || void 0 === precompress) return false;
+    if (true === precompress) return {};
+    return precompress;
+};
+const builderPluginAdapterPrecompress = (precompress)=>({
+        name: 'builder-plugin-adapter-modern-precompress',
+        setup (api) {
+            api.modifyBundlerChain((chain, { isProd, target })=>{
+                if (!isProd || 'web' !== target) return;
+                const precompressConfig = resolvePrecompressConfig(precompress);
+                if (false === precompressConfig) return;
+                const gzipOptions = resolveCodecOptions(precompressConfig.gzip, createDefaultGzipOptions);
+                if (gzipOptions) chain.plugin('modern-precompress-gzip').use(compression_webpack_plugin, [
+                    gzipOptions
+                ]);
+                const brotliOptions = resolveCodecOptions(precompressConfig.brotli, createDefaultBrotliOptions);
+                if (brotliOptions) chain.plugin('modern-precompress-brotli').use(compression_webpack_plugin, [
+                    brotliOptions
+                ]);
+            });
+        }
+    });
+export { builderPluginAdapterPrecompress };

package/dist/esm-node/build-config/precompress/types.mjs

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

package/dist/esm-node/build-config/public.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment } from "./build-environment.mjs";

package/dist/esm-node/cloudflare/constants.mjs

@@ -19,7 +19,7 @@ const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
 ];
 const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
 const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = '__modern_create_effect_bff_dispatcher';
-const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.';
 const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
 const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 const REQUIRED_COMPATIBILITY_FLAGS = CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;

package/dist/esm-node/cloudflare/delivery-unit.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import node_path from "node:path";
+import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/backend-federation-contracts";
 import { fs } from "@modern-js/utils";
-import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/utils/universal";
 import { resolveUltramodernReleaseIdentity } from "../release-identity.mjs";
 import { isRecord } from "./utils.mjs";
 const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';

package/dist/esm-node/cloudflare-output-contract.mjs

@@ -12,21 +12,54 @@ const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
 const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
 const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    'assert',
+    'assert/strict',
     'async_hooks',
     'buffer',
+    'child_process',
     'crypto',
+    'dgram',
+    'dns',
+    'domain',
     'events',
+    'fs',
     'fs/promises',
+    'http',
+    'http2',
+    'inspector',
     'module',
+    'net',
+    'os',
     'path',
     'process',
+    'readline',
+    'readline/promises',
+    'repl',
+    'sqlite',
     'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
     'string_decoder',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
     'url',
-    'util'
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib'
+];
+const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
+    'cloudflare:sockets'
 ];
 const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
     'nodejs_compat',
     'global_fetch_strictly_public'
 ];
-export { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WRANGLER_CONFIG_FILE };
+export { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WORKER_PLATFORM_MODULES, CLOUDFLARE_WRANGLER_CONFIG_FILE };

package/dist/esm-node/cloudflare-output-verifier/identity.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { DELIVERY_UNIT_IDENTITY_FIELDS, deliveryUnitIdentityFieldValue } from "@modern-js/utils/universal";
+import { DELIVERY_UNIT_IDENTITY_FIELDS, deliveryUnitIdentityFieldValue } from "@modern-js/backend-federation-contracts";
 import { addIssue, assertEqual } from "./issues.mjs";
 const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     const stamped = manifest?.deliveryUnit;

package/dist/esm-node/cloudflare-output-verifier/worker-bundles.mjs

@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
-import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS } from "../cloudflare-output-contract.mjs";
+import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PLATFORM_MODULES } from "../cloudflare-output-contract.mjs";
 import { addIssue } from "./issues.mjs";
 const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
 const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
@@ -175,7 +175,10 @@ const analyzeWorkerModule = (source)=>{
     };
 };
 const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set([
+    ...CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`),
+    ...CLOUDFLARE_WORKER_PLATFORM_MODULES
+]);
 const isInsideDirectory = (directory, filePath)=>{
     const relative = node_path.relative(directory, filePath);
     return 0 === relative.length || !relative.startsWith('..') && !node_path.isAbsolute(relative);

package/dist/esm-node/config.mjs

@@ -1 +1,2 @@
 import "node:module";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment } from "./build-config/public.mjs";

package/dist/esm-node/deploy-output/npmAliases.mjs

@@ -0,0 +1,175 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+const dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises.readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson) {
+    const aliases = [];
+    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(node_path.join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises.readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(node_path.join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises.readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = node_path.join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(node_path.join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = node_path.resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises.readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = node_path.join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = node_path.resolve(outputDirectory);
+    const resolvedOutputRoot = await promises.realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${node_path.sep}`)){
+        const candidate = node_path.join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises.realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${node_path.sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(node_path.join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = node_path.dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = node_path.join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises.mkdir(node_path.dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises.realpath(aliasPath),
+            promises.realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = node_path.relative(node_path.dirname(aliasPath), target.directory);
+    await promises.symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = node_path.dirname(entryPath);
+    const root = node_path.parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(node_path.join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = node_path.dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(node_path.join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(node_path.join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = node_path.join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises.writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+export { preserveNpmAliases, readPackageIdentity };

package/dist/esm-node/deploy-output/plugin.mjs

@@ -0,0 +1,31 @@
+import "node:module";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { preserveNpmAliases, readPackageIdentity } from "./npmAliases.mjs";
+import { resolveDeployTarget as external_target_mjs_resolveDeployTarget } from "./target.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
+const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target_mjs_resolveDeployTarget } = {})=>({
+        name: '@modern-js/deploy-output-aliases',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY || 'node' !== resolveDeployTarget(config)) return;
+                const entry = createRequire(__rspack_import_meta_filename__).resolve('@modern-js/prod-server');
+                const identity = await readPackageIdentity(entry);
+                await preserveNpmAliases({
+                    appDirectory,
+                    outputDirectory: node_path.join(appDirectory, '.output'),
+                    implicitAliases: [
+                        {
+                            aliasName: '@modern-js/prod-server',
+                            targetName: identity.name,
+                            targetVersion: identity.version
+                        }
+                    ]
+                });
+            });
+        }
+    });
+export { createDeployOutputAliasesPlugin };

package/dist/esm-node/deploy-output/target.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { provider } from "std-env";
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const resolveDeployTarget = (config, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>config.deploy?.target || envDeployTarget || (detectedProvider ? providerDeployTargets[detectedProvider] : void 0) || 'node';
+export { resolveDeployTarget };