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

package/dist/cjs/cloudflare-output-verifier/identity.js

@@ -31,10 +31,11 @@ __webpack_require__.d(__webpack_exports__, {
     verifyDeliveryUnitIdentity: ()=>verifyDeliveryUnitIdentity
 });
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
+const utils_js_namespaceObject = require("../cloudflare/utils.js");
 const external_issues_js_namespaceObject = require("./issues.js");
 const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     const stamped = manifest?.deliveryUnit;
-    const hasStamp = Boolean(stamped) && 'object' == typeof stamped;
+    const hasStamp = (0, utils_js_namespaceObject.isRecord)(stamped);
     if (declared) {
         if (!hasStamp) return void (0, external_issues_js_namespaceObject.addIssue)(issues, {
             code: 'missing-delivery-unit',
@@ -50,36 +51,124 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
             });
         }
     }
-    if (hasStamp && stamped.surfaces && 'object' == typeof stamped.surfaces) for (const surface of [
-        'ui',
-        'api'
-    ]){
-        const marker = stamped.surfaces[surface];
-        const expected = declared?.surfaces?.[surface];
-        if (declared?.surfaces && !expected) {
-            if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+    if (hasStamp) {
+        if (!(0, utils_js_namespaceObject.isRecord)(stamped.surfaces)) return void (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-delivery-unit',
+            message: 'Cloudflare worker manifest is missing delivery-unit surface markers.',
+            path: manifestPath
+        });
+        for (const surface of Object.keys(stamped.surfaces))if ('ui' !== surface && 'api' !== surface) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'delivery-unit-drift',
+            message: `Cloudflare worker manifest declares an unsupported ${surface} delivery-unit surface.`,
+            path: manifestPath
+        });
+        if (!declared?.surfaces && !Object.hasOwn(stamped.surfaces, 'ui') && !Object.hasOwn(stamped.surfaces, 'api')) return void (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-delivery-unit',
+            message: 'Cloudflare worker manifest is missing delivery-unit surface markers.',
+            path: manifestPath
+        });
+        for (const surface of [
+            'ui',
+            'api'
+        ]){
+            const marker = stamped.surfaces[surface];
+            const expected = declared?.surfaces?.[surface];
+            if (!expected && !marker) continue;
+            if (declared?.surfaces && !expected) {
+                if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            if (!(0, utils_js_namespaceObject.isRecord)(marker)) {
+                (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'missing-delivery-unit',
+                    message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, marker.surface, surface, {
                 code: 'delivery-unit-drift',
-                message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
+                message: `Cloudflare worker manifest ${surface} surface must declare surface "${surface}".`,
                 path: manifestPath
             });
-            continue;
-        }
-        if (!marker || 'object' != typeof marker) {
-            (0, external_issues_js_namespaceObject.addIssue)(issues, {
-                code: 'missing-delivery-unit',
-                message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
+            for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+                const markerValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
+                const stampedValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+                (0, external_issues_js_namespaceObject.assertEqual)(issues, markerValue, stampedValue, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
+                    path: manifestPath
+                });
+            }
+            if ('api' === surface) {
+                for (const field of [
+                    'rendererIdentity',
+                    'rendererProfile'
+                ])if (Object.hasOwn(marker, field)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest API surface must not declare ${field}.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            const identity = marker.rendererIdentity;
+            const profile = marker.rendererProfile;
+            const errors = [
+                ...(0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(identity).errors,
+                ...(0, backend_federation_contracts_namespaceObject.validateRendererProfile)(profile).errors
+            ];
+            for (const error of errors)(0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest UI ${error.path} ${error.message}`,
                 path: manifestPath
             });
-            continue;
-        }
-        for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
-            const markerValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
-            const stampedValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
-            (0, external_issues_js_namespaceObject.assertEqual)(issues, markerValue, stampedValue, {
+            if (errors.length || !(0, utils_js_namespaceObject.isRecord)(identity) || !(0, utils_js_namespaceObject.isRecord)(profile)) continue;
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, identity.buildId, marker.buildMarker, {
+                code: 'delivery-unit-drift',
+                message: 'Cloudflare worker manifest UI rendererIdentity.buildId must match its surface buildMarker.',
+                path: manifestPath
+            });
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, identity.appId, marker.appId, {
+                code: 'delivery-unit-drift',
+                message: 'Cloudflare worker manifest UI rendererIdentity.appId must match its surface appId.',
+                path: manifestPath
+            });
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, marker.appId, stamped.appId, {
+                code: 'delivery-unit-drift',
+                message: 'Cloudflare worker manifest UI surface appId must match its delivery-unit appId.',
+                path: manifestPath
+            });
+            for (const field of [
+                'renderer',
+                'protocolVersion'
+            ])(0, external_issues_js_namespaceObject.assertEqual)(issues, identity[field], profile[field], {
                 code: 'delivery-unit-drift',
-                message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
+                message: `Cloudflare worker manifest UI rendererProfile.${field} must match its renderer identity.`,
                 path: manifestPath
             });
+            const expectedUi = declared?.surfaces?.ui;
+            if (expectedUi?.rendererIdentity) {
+                for (const field of [
+                    'renderer',
+                    'appId',
+                    'entryName',
+                    'protocolVersion',
+                    'buildId'
+                ])(0, external_issues_js_namespaceObject.assertEqual)(issues, identity[field], expectedUi.rendererIdentity[field], {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest UI rendererIdentity.${field} must match the topology renderer identity.`,
+                    path: manifestPath
+                });
+                for (const error of (0, backend_federation_contracts_namespaceObject.validateRendererProfileCompatibility)(expectedUi.rendererProfile, profile).errors)(0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest UI ${error.path} ${error.message}`,
+                    path: manifestPath
+                });
+            }
         }
     }
 };

package/dist/cjs/cloudflare-output-verifier/index.js

@@ -118,6 +118,16 @@ const verifyCloudflareOutput = async (options)=>{
         }
     }
     if (wrangler) {
+        if ('string' != typeof wrangler.name || 0 === wrangler.name.trim().length) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json name must be a non-empty worker name.',
+            path: wranglerPath
+        });
+        if ('string' != typeof wrangler.compatibility_date || !/^\d{4}-\d{2}-\d{2}$/u.test(wrangler.compatibility_date)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json compatibility_date must use YYYY-MM-DD.',
+            path: wranglerPath
+        });
         (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.main, outputPlan.wrangler.main, {
             code: 'invalid-wrangler',
             message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,

package/dist/cjs/cloudflare-output-verifier/manifest.js

@@ -74,6 +74,52 @@ const verifyManifestShape = (issues, manifest, manifestPath)=>{
         message: 'Cloudflare output manifest routeSpec.routes must be array.',
         path: manifestPath
     });
+    const security = manifest.security;
+    if (security && 'object' == typeof security && 'boolean' == typeof security.enabled) {
+        const cors = security.cors;
+        if (!cors || 'object' != typeof cors || 'boolean' != typeof cors.assets || !Array.isArray(cors.allowedOrigins) || !Array.isArray(cors.allowedMethods) || !Array.isArray(cors.allowedHeaders)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-manifest',
+            message: 'Cloudflare output manifest security.cors is incomplete.',
+            path: manifestPath
+        });
+        if (security.enabled) {
+            const headers = security.headers;
+            const csp = security.contentSecurityPolicy;
+            const noindex = security.noindex;
+            if (!headers || 'object' != typeof headers || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.referrerPolicy) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.contentTypeOptions) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.permissionsPolicy)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.headers is incomplete.',
+                path: manifestPath
+            });
+            if (!csp || ![
+                'off',
+                'report-only',
+                'enforce'
+            ].includes(csp.mode) || !csp.directives || 'object' != typeof csp.directives || Array.isArray(csp.directives) || Object.values(csp.directives).some((value)=>!Array.isArray(value) || value.some((entry)=>'string' != typeof entry))) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.contentSecurityPolicy is invalid.',
+                path: manifestPath
+            });
+            if (!noindex || 'boolean' != typeof noindex.workersDev || 'boolean' != typeof noindex.localhost || !Array.isArray(noindex.previewHostnames)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.noindex is incomplete.',
+                path: manifestPath
+            });
+        }
+    } else (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest security.enabled must be a boolean.',
+        path: manifestPath
+    });
     if (manifest.bff?.runtimeFramework === 'effect') (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.bff.dispatcherExport, constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT, {
         code: 'invalid-manifest',
         message: `Cloudflare Effect BFF manifest dispatcherExport must be ${constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT}.`,

package/dist/cjs/cloudflare-output-verifier/mutation-policy.js

@@ -128,7 +128,13 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
     const files = (await Promise.all(options.scanRoots.map((scanRoot)=>walkFiles(external_node_path_default().resolve(scanRoot))))).flat();
     for (const file of files){
         if (excludedFiles.has(file)) continue;
-        const source = await promises_default().readFile(file, 'utf-8');
+        let source;
+        try {
+            source = await promises_default().readFile(file, 'utf-8');
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
         for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
             code: forbidden.code,
             message: forbidden.message,

package/dist/cjs/cloudflare-output-verifier/worker-bundles.js

@@ -55,7 +55,7 @@ const traverse_namespaceObject = require("@babel/traverse");
 var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
 const external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
 const external_issues_js_namespaceObject = require("./issues.js");
-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 getReferencedRouteWorkers = (manifest, field)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.[field] && route[field].length > 0 ? route[field] : void 0).filter((worker)=>'string' == typeof worker) : [];
 const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
 const getWorkerBundleReferences = (manifest)=>{
     const effectBffWorker = getEffectBffWorker(manifest);
@@ -67,9 +67,14 @@ const getWorkerBundleReferences = (manifest)=>{
                 reference: effectBffWorker
             }
         ] : [],
-        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+        ...getReferencedRouteWorkers(manifest, 'worker').map((reference)=>({
                 kind: 'route',
                 reference
+            })),
+        ...getReferencedRouteWorkers(manifest, 'routeDataWorker').map((reference)=>({
+                dispatcherExport: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+                kind: 'route-data',
+                reference
             }))
     ];
 };
@@ -90,7 +95,7 @@ const resolveWorkerBundleReference = (issues, outputDirectory, reference, manife
         path: workerPath
     };
 };
-const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'route-data' === reference.kind ? 'Cloudflare route data worker manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
 const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
 const getNodeName = (node)=>{
     if (!isAstNode(node)) return;
@@ -334,9 +339,9 @@ const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contrac
 };
 const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
     const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
-    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+    if ('string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
         code: 'invalid-worker-bundle',
-        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        message: 'route-data' === worker.kind ? `Cloudflare route data worker bundle must expose ${worker.dispatcherExport}.` : 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
         path: worker.path
     });
 };

package/dist/cjs/config.js

@@ -28,18 +28,23 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    createRemoteManifestUrl: ()=>remote_address_js_namespaceObject.createRemoteManifestUrl,
     getBuildConfigEnvironment: ()=>public_js_namespaceObject.getBuildConfigEnvironment,
-    resolveEffectTsgoCompiler: ()=>public_js_namespaceObject.resolveEffectTsgoCompiler,
-    withBuildConfigEnvironment: ()=>public_js_namespaceObject.withBuildConfigEnvironment
+    resolveDeployTarget: ()=>target_js_namespaceObject.resolveDeployTarget,
+    resolveEffectTsgoCompiler: ()=>public_js_namespaceObject.resolveEffectTsgoCompiler
 });
 const public_js_namespaceObject = require("./build-config/public.js");
+const remote_address_js_namespaceObject = require("./build-config/remote-address.js");
+const target_js_namespaceObject = require("./deploy-output/target.js");
+exports.createRemoteManifestUrl = __webpack_exports__.createRemoteManifestUrl;
 exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
+exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
 exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
-exports.withBuildConfigEnvironment = __webpack_exports__.withBuildConfigEnvironment;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRemoteManifestUrl",
     "getBuildConfigEnvironment",
-    "resolveEffectTsgoCompiler",
-    "withBuildConfigEnvironment"
+    "resolveDeployTarget",
+    "resolveEffectTsgoCompiler"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/deploy-output/npmAliases.js

@@ -48,6 +48,10 @@ const dependencyKeys = [
     'dependencies',
     'optionalDependencies'
 ];
+const rootDependencyKeys = [
+    ...dependencyKeys,
+    'devDependencies'
+];
 const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
 async function readPackageJson(filePath) {
     return JSON.parse(await promises_default().readFile(filePath, 'utf8'));
@@ -63,14 +67,87 @@ function parseNpmAlias(aliasName, specifier) {
         targetVersion: target.slice(versionSeparator + 1)
     };
 }
-function aliasesFromPackageJson(packageJson) {
+function aliasesFromPackageJson(packageJson, keys = dependencyKeys) {
     const aliases = [];
-    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+    for (const dependencyKey of keys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
         const alias = parseNpmAlias(aliasName, specifier);
         if (alias) aliases.push(alias);
     }
     return aliases;
 }
+async function catalogAliasesFromInstalledPackages(appDirectory, packageJson) {
+    const aliases = [];
+    for (const dependencyKey of rootDependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        if (!specifier.startsWith('catalog:')) continue;
+        let installedPackage;
+        try {
+            installedPackage = await readPackageJson(external_node_path_default().join(appDirectory, 'node_modules', aliasName, 'package.json'));
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
+        if (!installedPackage.name || !installedPackage.version) throw new Error(`Installed catalog package ${aliasName} has no identity`);
+        if (installedPackage.name !== aliasName) aliases.push({
+            aliasName,
+            targetName: installedPackage.name,
+            targetVersion: installedPackage.version
+        });
+    }
+    return aliases;
+}
+async function installedAliasesByOwner(appDirectory, emittedOwners) {
+    const aliasesByOwner = new Map();
+    let rootAliases = [];
+    const visited = new Set();
+    const rootFile = await promises_default().realpath(external_node_path_default().join(appDirectory, 'package.json'));
+    const pending = [
+        rootFile
+    ];
+    while(pending.length){
+        const file = await promises_default().realpath(pending.pop());
+        if (visited.has(file)) continue;
+        visited.add(file);
+        const owner = await readPackageJson(file);
+        const aliases = [];
+        const keys = file === rootFile ? rootDependencyKeys : dependencyKeys;
+        for (const key of keys)for (const name of Object.keys(owner[key] ?? {})){
+            let directory = external_node_path_default().dirname(file);
+            while(true){
+                const packageFile = external_node_path_default().join(directory, 'node_modules', name, 'package.json');
+                let target;
+                try {
+                    target = await readPackageJson(packageFile);
+                } catch (error) {
+                    if ('ENOENT' !== error.code) throw error;
+                    const parent = external_node_path_default().dirname(directory);
+                    if (parent === directory) break;
+                    directory = parent;
+                    continue;
+                }
+                if (!target.name || !target.version) throw new Error(`Installed package ${name} has no identity`);
+                pending.push(packageFile);
+                if (target.name !== name) aliases.push({
+                    aliasName: name,
+                    targetName: target.name,
+                    targetVersion: target.version
+                });
+                break;
+            }
+        }
+        if (file === rootFile) rootAliases = aliases;
+        const identity = `${owner.name}@${owner.version}`;
+        if (emittedOwners.has(identity)) {
+            const existing = aliasesByOwner.get(identity);
+            const normalized = (items)=>items.map((item)=>`${item.aliasName}=${aliasSpecifier(item)}`).sort().join('\n');
+            if (existing && normalized(existing) !== normalized(aliases)) throw new Error(`Cannot preserve npm aliases for ${identity}: installed contexts resolve different dependency identities`);
+            aliasesByOwner.set(identity, aliases);
+        }
+    }
+    return {
+        aliasesByOwner,
+        rootAliases
+    };
+}
 async function collectPackageRecords(nodeModulesDirectory) {
     const records = [];
     const visitedNodeModules = new Set();
@@ -191,8 +268,11 @@ async function readPackageIdentity(entryPath) {
 async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
     const records = await collectPackageRecords(external_node_path_default().join(outputDirectory, 'node_modules'));
     const appPackageJson = await readPackageJson(external_node_path_default().join(appDirectory, 'package.json'));
+    const installedAliases = await installedAliasesByOwner(appDirectory, new Set(records.map(({ packageJson })=>`${packageJson.name}@${packageJson.version}`)));
     const rootAliases = [
-        ...aliasesFromPackageJson(appPackageJson),
+        ...aliasesFromPackageJson(appPackageJson, rootDependencyKeys),
+        ...installedAliases.rootAliases,
+        ...await catalogAliasesFromInstalledPackages(appDirectory, appPackageJson),
         ...implicitAliases
     ].filter((alias)=>alias.aliasName !== alias.targetName);
     const emittedRootAliases = [];
@@ -205,9 +285,15 @@ async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAlias
         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);
+    for (const record of records){
+        const ownerAliases = [
+            ...aliasesFromPackageJson(record.packageJson),
+            ...installedAliases.aliasesByOwner.get(`${record.packageJson.name}@${record.packageJson.version}`) ?? []
+        ];
+        for (const alias of ownerAliases.filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+            const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+            if (target) await ensureAliasLink(record.directory, alias, target);
+        }
     }
     const outputPackageJsonPath = external_node_path_default().join(outputDirectory, 'package.json');
     const outputPackageJson = await readPackageJson(outputPackageJsonPath);

package/dist/cjs/deploy-output/plugin.js

@@ -37,20 +37,22 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createDeployOutputAliasesPlugin: ()=>createDeployOutputAliasesPlugin
+    createDeployOutputAliasesPlugin: ()=>createDeployOutputAliasesPlugin,
+    createDeployOutputPublicAssetsPlugin: ()=>createDeployOutputPublicAssetsPlugin
 });
 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_npmAliases_js_namespaceObject = require("./npmAliases.js");
+const external_public_assets_js_namespaceObject = require("./public-assets.js");
 const external_target_js_namespaceObject = require("./target.js");
-const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target_js_namespaceObject.resolveDeployTarget } = {})=>({
+const createDeployOutputAliasesPlugin = ()=>({
         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 appContext = api.getAppContext();
+                if ('node' !== (0, external_target_js_namespaceObject.getDeployingTarget)(appContext)) return;
+                const { appDirectory } = appContext;
                 const entry = (0, external_node_module_namespaceObject.createRequire)(__filename).resolve('@modern-js/prod-server');
                 const identity = await (0, external_npmAliases_js_namespaceObject.readPackageIdentity)(entry);
                 await (0, external_npmAliases_js_namespaceObject.preserveNpmAliases)({
@@ -67,9 +69,28 @@ const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target
             });
         }
     });
+const createDeployOutputPublicAssetsPlugin = ()=>({
+        name: '@modern-js/deploy-output-public-assets',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const appContext = api.getAppContext();
+                if ('node' !== (0, external_target_js_namespaceObject.getDeployingTarget)(appContext)) return;
+                const { appDirectory } = appContext;
+                const config = api.getNormalizedConfig();
+                await (0, external_public_assets_js_namespaceObject.stageDeclaredPublicAssets)({
+                    appDirectory,
+                    outputDirectory: external_node_path_default().join(appDirectory, '.output'),
+                    assets: (0, external_public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(config.deploy?.node?.publicAssets, external_public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE),
+                    scope: external_public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE
+                });
+            });
+        }
+    });
 exports.createDeployOutputAliasesPlugin = __webpack_exports__.createDeployOutputAliasesPlugin;
+exports.createDeployOutputPublicAssetsPlugin = __webpack_exports__.createDeployOutputPublicAssetsPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createDeployOutputAliasesPlugin"
+    "createDeployOutputAliasesPlugin",
+    "createDeployOutputPublicAssetsPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true