@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.14 → 3.9.0-ultramodern.16

package/dist/cjs/cloudflare/artifacts.js

@@ -47,6 +47,7 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
+const public_assets_js_namespaceObject = require("../deploy-output/public-assets.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const normalizeCloudflareArtifact = (artifact, index)=>{
@@ -62,18 +63,7 @@ const normalizeCloudflareArtifact = (artifact, index)=>{
     };
 };
 const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
-const normalizeCloudflarePublicAsset = (asset, index)=>{
-    const from = (0, external_utils_js_namespaceObject.normalizeRelativePath)(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
-    const to = (0, external_utils_js_namespaceObject.normalizeRelativePath)(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
-        allowRoot: true
-    });
-    return {
-        from,
-        to,
-        index
-    };
-};
-const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
+const getCloudflarePublicAssets = (modernConfig)=>(0, public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(modernConfig.deploy?.worker?.publicAssets, public_assets_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSET_SCOPE);
 const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
     for (const artifact of artifacts){
         const sourcePath = external_node_path_default().join(appDirectory, artifact.from);
@@ -81,13 +71,12 @@ const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)
         await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(outputDirectory, artifact.to));
     }
 };
-const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
-    for (const asset of publicAssets){
-        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
-        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
-        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(publicDirectory, asset.to));
-    }
-};
+const copyCloudflarePublicAssets = async (appDirectory, outputDirectory, publicAssets)=>(0, public_assets_js_namespaceObject.stageDeclaredPublicAssets)({
+        appDirectory,
+        outputDirectory,
+        assets: publicAssets,
+        scope: public_assets_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSET_SCOPE
+    });
 const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
     for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
         if (!database.migrationsDir) continue;

package/dist/cjs/cloudflare/index.js

@@ -74,6 +74,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
     const publicAssetExcludes = (0, external_worker_manifest_js_namespaceObject.getPublicAssetExcludes)(appDirectory, modernConfig);
     const releaseEnvelopeEnabled = api.isPluginExists('@modern-js/ultramodern-release-envelope');
     let hasReleaseEnvelope = false;
+    let declaredPublicAssets = [];
     return {
         async prepare () {
             await utils_namespaceObject.fs.remove(outputDirectory);
@@ -116,7 +117,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
                 await utils_namespaceObject.fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await (0, external_artifacts_js_namespaceObject.copyCloudflareArtifacts)(appDirectory, outputDirectory, cloudflareArtifacts);
-            await (0, external_artifacts_js_namespaceObject.copyCloudflarePublicAssets)(appDirectory, publicDirectory, (0, external_artifacts_js_namespaceObject.getCloudflarePublicAssets)(modernConfig));
+            declaredPublicAssets = await (0, external_artifacts_js_namespaceObject.copyCloudflarePublicAssets)(appDirectory, outputDirectory, (0, external_artifacts_js_namespaceObject.getCloudflarePublicAssets)(modernConfig));
             await (0, external_artifacts_js_namespaceObject.copyCloudflareD1Migrations)(appDirectory, outputDirectory, modernConfig);
             await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, (0, external_wrangler_config_js_namespaceObject.createWranglerConfig)(appDirectory, modernConfig), {
                 spaces: 2
@@ -145,6 +146,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await (0, framework_output_js_namespaceObject.emitCloudflareStagedReleaseEnvelope)({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });

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

@@ -37,12 +37,14 @@ 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 } = {})=>({
         name: '@modern-js/deploy-output-aliases',
@@ -67,9 +69,27 @@ const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target
             });
         }
     });
+const createDeployOutputPublicAssetsPlugin = ({ resolveDeployTarget = external_target_js_namespaceObject.resolveDeployTarget } = {})=>({
+        name: '@modern-js/deploy-output-public-assets',
+        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;
+                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

package/dist/cjs/deploy-output/public-assets.js

@@ -0,0 +1,146 @@
+"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__, {
+    CLOUDFLARE_PUBLIC_ASSET_SCOPE: ()=>CLOUDFLARE_PUBLIC_ASSET_SCOPE,
+    DECLARED_PUBLIC_ASSET_DIRECTORY: ()=>DECLARED_PUBLIC_ASSET_DIRECTORY,
+    NODE_PUBLIC_ASSET_SCOPE: ()=>NODE_PUBLIC_ASSET_SCOPE,
+    normalizeDeclaredPublicAssets: ()=>normalizeDeclaredPublicAssets,
+    resolveAddedDeclaredPublicAssetPaths: ()=>resolveAddedDeclaredPublicAssetPaths,
+    stageDeclaredPublicAssets: ()=>stageDeclaredPublicAssets
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_js_namespaceObject = require("../cloudflare/utils.js");
+const DECLARED_PUBLIC_ASSET_DIRECTORY = 'public';
+const CLOUDFLARE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.worker.publicAssets',
+    output: 'Cloudflare public output'
+};
+const NODE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.node.publicAssets',
+    output: 'Node public output'
+};
+const normalizeDeclaredPublicAssets = (assets, scope)=>(assets ?? []).map((asset, index)=>({
+            from: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.from, `${scope.label}[${index}].from`, 'app root'),
+            to: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.to, `${scope.label}[${index}].to`, scope.output, {
+                allowRoot: true
+            }),
+            index
+        }));
+const isMissingPathError = (error)=>error instanceof Error && 'code' in error && 'ENOENT' === error.code;
+const pathExists = async (filePath)=>{
+    try {
+        await promises_default().lstat(filePath);
+        return true;
+    } catch (error) {
+        if (isMissingPathError(error)) return false;
+        throw error;
+    }
+};
+const listDeclaredPublicAssetFiles = async (appDirectory, assets, scope)=>{
+    const files = [];
+    const owners = new Map();
+    const add = (index, logicalPath)=>{
+        const owner = owners.get(logicalPath);
+        if (void 0 !== owner) throw new Error(`${scope.label}[${index}] and ${scope.label}[${owner}] both stage ${JSON.stringify(logicalPath)}.`);
+        owners.set(logicalPath, index);
+        files.push({
+            index,
+            logicalPath
+        });
+    };
+    const visit = async (asset, sourcePath, destination)=>{
+        const stat = await promises_default().lstat(sourcePath);
+        if (stat.isSymbolicLink()) throw new Error(`${scope.label}[${asset.index}].from must not contain symbolic links: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        if (stat.isFile()) {
+            if (destination === DECLARED_PUBLIC_ASSET_DIRECTORY) throw new Error(`${scope.label}[${asset.index}].to must name a file when ${scope.label}[${asset.index}].from is a file.`);
+            add(asset.index, destination);
+            return;
+        }
+        if (!stat.isDirectory()) throw new Error(`${scope.label}[${asset.index}].from must contain only files and directories: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        const entries = (await promises_default().readdir(sourcePath)).sort();
+        for (const entry of entries)await visit(asset, external_node_path_default().join(sourcePath, entry), external_node_path_default().posix.join(destination, entry));
+    };
+    for (const asset of assets){
+        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
+        if (!await pathExists(sourcePath)) throw new Error(`${scope.label}[${asset.index}].from does not exist: ${asset.from}`);
+        await visit(asset, sourcePath, external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to));
+    }
+    return files;
+};
+const resolveAddedDeclaredPublicAssetPaths = async ({ appDirectory, assets, generatedRoot, scope })=>{
+    const added = [];
+    for (const file of (await listDeclaredPublicAssetFiles(appDirectory, assets, scope)))if (!await pathExists(external_node_path_default().join(generatedRoot, file.logicalPath))) added.push(file.logicalPath);
+    return added.sort();
+};
+const stageDeclaredPublicAssets = async ({ appDirectory, outputDirectory, assets, scope })=>{
+    const files = await listDeclaredPublicAssetFiles(appDirectory, assets, scope);
+    const added = [];
+    for (const file of files){
+        const asset = assets.find((candidate)=>candidate.index === file.index);
+        const relativePath = external_node_path_default().posix.relative(external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to), file.logicalPath);
+        const destination = external_node_path_default().join(outputDirectory, file.logicalPath);
+        const replacesGeneratedFile = await pathExists(destination);
+        await promises_default().mkdir(external_node_path_default().dirname(destination), {
+            recursive: true
+        });
+        await promises_default().copyFile(external_node_path_default().join(appDirectory, asset.from, relativePath), destination);
+        if (!replacesGeneratedFile) added.push(file.logicalPath);
+    }
+    return added.sort();
+};
+exports.CLOUDFLARE_PUBLIC_ASSET_SCOPE = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSET_SCOPE;
+exports.DECLARED_PUBLIC_ASSET_DIRECTORY = __webpack_exports__.DECLARED_PUBLIC_ASSET_DIRECTORY;
+exports.NODE_PUBLIC_ASSET_SCOPE = __webpack_exports__.NODE_PUBLIC_ASSET_SCOPE;
+exports.normalizeDeclaredPublicAssets = __webpack_exports__.normalizeDeclaredPublicAssets;
+exports.resolveAddedDeclaredPublicAssetPaths = __webpack_exports__.resolveAddedDeclaredPublicAssetPaths;
+exports.stageDeclaredPublicAssets = __webpack_exports__.stageDeclaredPublicAssets;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_PUBLIC_ASSET_SCOPE",
+    "DECLARED_PUBLIC_ASSET_DIRECTORY",
+    "NODE_PUBLIC_ASSET_SCOPE",
+    "normalizeDeclaredPublicAssets",
+    "resolveAddedDeclaredPublicAssetPaths",
+    "stageDeclaredPublicAssets"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/release-envelope/framework-output.js

@@ -66,6 +66,16 @@ const isEffectBffWorkerArtifact = (logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(
 const CRAWLER_POLICY_PATH = 'public/robots.txt';
 const isPublicMetadataPath = (logicalPath)=>'public/_headers' === logicalPath || /^public\/\.well-known\/[^/]+\.json$/u.test(logicalPath);
 const PUBLIC_BUILD_ARTIFACT_PATH = `public/${backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE}`;
+const DECLARED_PUBLIC_ASSET_RUNTIME = 'public-asset';
+const resolveDeclaredPublicAssets = (files, declaredPublicAssets, target)=>{
+    const staged = new Set(files);
+    const declared = new Set();
+    for (const logicalPath of declaredPublicAssets){
+        if (!logicalPath.startsWith('public/') || !staged.has(logicalPath)) throw new Error(`[ultramodern-release-envelope] final ${target} staging has no declared public asset file ${JSON.stringify(logicalPath)}.`);
+        declared.add(logicalPath);
+    }
+    return declared;
+};
 const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
 const flattenStrings = (value)=>'string' == typeof value ? [
         value
@@ -454,8 +464,9 @@ const verifyNodeReleaseEnvelopeStaging = async ({ outputDirectory })=>readFramew
         expectedTarget: 'node',
         required: true
     });
-const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity, apiOnly)=>{
+const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity, apiOnly, declaredPublicAssets)=>{
     const files = await collectFiles(outputDirectory);
+    const declaredPublicAssetPaths = resolveDeclaredPublicAssets(files, declaredPublicAssets, 'Node');
     for (const requiredPath of [
         'index.js',
         'package.json',
@@ -468,7 +479,7 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity,
     ]);
     const uiClientPaths = files.filter((logicalPath)=>{
         const topLevel = logicalPath.split('/')[0];
-        return 'static' === topLevel || 'html' === topLevel || 'public' === topLevel && logicalPath !== CRAWLER_POLICY_PATH && !isPublicMetadataPath(logicalPath) || [
+        return 'static' === topLevel || 'html' === topLevel || 'public' === topLevel && logicalPath !== CRAWLER_POLICY_PATH && !isPublicMetadataPath(logicalPath) && !declaredPublicAssetPaths.has(logicalPath) || [
             'index.html',
             'mf-manifest.json',
             'mf-stats.json',
@@ -502,6 +513,7 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity,
             'nodejs-deployment'
         ]));
     for (const logicalPath of uiClientPaths)runtimeByPath.set(logicalPath, 'browser');
+    for (const logicalPath of declaredPublicAssetPaths)runtimeByPath.set(logicalPath, DECLARED_PUBLIC_ASSET_RUNTIME);
     if (files.includes(CRAWLER_POLICY_PATH)) runtimeByPath.set(CRAWLER_POLICY_PATH, 'crawler-policy');
     for (const logicalPath of files.filter(isPublicMetadataPath))runtimeByPath.set(logicalPath, 'public-metadata');
     for (const logicalPath of apiOnly ? [] : ssrPaths)runtimeByPath.set(logicalPath, 'nodejs');
@@ -546,10 +558,10 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity,
         }
     };
 };
-const emitNodeStagedReleaseEnvelope = async ({ distDirectory, outputDirectory })=>{
+const emitNodeStagedReleaseEnvelope = async ({ declaredPublicAssets = [], distDirectory, outputDirectory })=>{
     const source = await verifyBuildOutputReleaseEnvelope(distDirectory, 'node');
     if (!source) return;
-    const { artifacts, surfaces } = await createNodeStagedReleaseArtifactInputs(outputDirectory, source.identity, 0 === source.surfaces.uiClient.length);
+    const { artifacts, surfaces } = await createNodeStagedReleaseArtifactInputs(outputDirectory, source.identity, 0 === source.surfaces.uiClient.length, declaredPublicAssets);
     const staged = await (0, external_index_js_namespaceObject.createMicroVerticalReleaseEnvelope)({
         artifactRoot: outputDirectory,
         target: 'node',
@@ -567,8 +579,9 @@ const stageCloudflareReleaseEnvelope = async ({ distDirectory, outputDirectory }
     if (await pathExists(stagedEnvelopePath)) throw new Error('[ultramodern-release-envelope] Cloudflare staging contains a stale envelope before final output generation.');
     return source;
 };
-const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, identity, apiOnly)=>{
+const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, identity, apiOnly, declaredPublicAssets)=>{
     const files = await collectFiles(outputDirectory);
+    const declaredPublicAssetPaths = resolveDeclaredPublicAssets(files, declaredPublicAssets, 'Cloudflare');
     for (const requiredPath of [
         'server/index.mjs',
         'server/modern-worker-manifest.json',
@@ -584,7 +597,7 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
     const apiBackendPaths = files.filter(isEffectBffWorkerArtifact);
     if (!files.some((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath))) throw new Error('[ultramodern-release-envelope] final Cloudflare staging has no actual Effect API/BFF worker artifact.');
     const ssrPaths = files.filter((logicalPath)=>(logicalPath.startsWith('server/') || logicalPath.startsWith('worker/')) && COMPILED_MODULE_PATTERN.test(logicalPath) && !isEffectBffWorkerArtifact(logicalPath));
-    const uiClientPaths = files.filter((logicalPath)=>logicalPath.startsWith('public/') && logicalPath !== CRAWLER_POLICY_PATH && !isPublicMetadataPath(logicalPath) && logicalPath !== PUBLIC_BUILD_ARTIFACT_PATH && logicalPath !== backendManifestPath && logicalPath !== backendContainerPath);
+    const uiClientPaths = files.filter((logicalPath)=>logicalPath.startsWith('public/') && logicalPath !== CRAWLER_POLICY_PATH && !isPublicMetadataPath(logicalPath) && !declaredPublicAssetPaths.has(logicalPath) && logicalPath !== PUBLIC_BUILD_ARTIFACT_PATH && logicalPath !== backendManifestPath && logicalPath !== backendContainerPath);
     if (apiOnly && (uiClientPaths.length > 0 || ssrPaths.some((path)=>'server/index.mjs' !== path))) throw new Error('[ultramodern-release-envelope] final API-only Cloudflare staging contains an undeclared UI/client or SSR surface.');
     for (const [surface, paths] of [
         [
@@ -613,6 +626,9 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
         for (const logicalPath of paths)runtimeByPath.set(logicalPath, runtime);
     };
     add(uiClientPaths, 'browser');
+    add([
+        ...declaredPublicAssetPaths
+    ], DECLARED_PUBLIC_ASSET_RUNTIME);
     if (files.includes(CRAWLER_POLICY_PATH)) runtimeByPath.set(CRAWLER_POLICY_PATH, 'crawler-policy');
     add(files.filter(isPublicMetadataPath), 'public-metadata');
     add(apiOnly ? [] : ssrPaths, 'workerd');
@@ -661,10 +677,10 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
         }
     };
 };
-const emitCloudflareStagedReleaseEnvelope = async ({ distDirectory, outputDirectory })=>{
+const emitCloudflareStagedReleaseEnvelope = async ({ declaredPublicAssets = [], distDirectory, outputDirectory })=>{
     const source = await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
     if (!source) return;
-    const { artifacts, surfaces } = await createCloudflareStagedReleaseArtifactInputs(outputDirectory, source.identity, 0 === source.surfaces.uiClient.length);
+    const { artifacts, surfaces } = await createCloudflareStagedReleaseArtifactInputs(outputDirectory, source.identity, 0 === source.surfaces.uiClient.length, declaredPublicAssets);
     const staged = await (0, external_index_js_namespaceObject.createMicroVerticalReleaseEnvelope)({
         artifactRoot: outputDirectory,
         target: 'cloudflare',

package/dist/cjs/release-envelope/plugin.js

@@ -41,6 +41,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const public_assets_js_namespaceObject = require("../deploy-output/public-assets.js");
 const external_framework_output_js_namespaceObject = require("./framework-output.js");
 const resolveActiveDeployTarget = (api, resolveDeployTarget)=>{
     const { metaName } = api.getAppContext();
@@ -53,7 +54,8 @@ const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
         pre: [
             '@modern-js/backend-federation-build',
             '@modern-js/plugin-bff',
-            '@modern-js/deploy-output-aliases'
+            '@modern-js/deploy-output-aliases',
+            '@modern-js/deploy-output-public-assets'
         ],
         post: [
             '@modern-js/plugin-deploy'
@@ -86,6 +88,12 @@ const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
                 const { appDirectory, distDirectory } = api.getAppContext();
                 const outputDirectory = external_node_path_default().join(appDirectory, '.output');
                 const releaseEnvelope = await (0, external_framework_output_js_namespaceObject.emitNodeStagedReleaseEnvelope)({
+                    declaredPublicAssets: await (0, public_assets_js_namespaceObject.resolveAddedDeclaredPublicAssetPaths)({
+                        appDirectory,
+                        assets: (0, public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(api.getNormalizedConfig().deploy?.node?.publicAssets, public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE),
+                        generatedRoot: distDirectory,
+                        scope: public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE
+                    }),
                     distDirectory,
                     outputDirectory
                 });

package/dist/cjs/templates/cloudflare-entry.005-worker-dispatch.mjs

@@ -160,14 +160,46 @@ async function dispatchRouteWorker(route, request, env, ctx) {
   );
 }
 
-function matchesPrefix(pathname, prefix) {
+// Worker Static Assets decode percent-encoded paths, so an encoded spelling
+// of a mounted prefix (`/%70refix/...`, `/prefix%2F...`) would otherwise skip
+// the BFF or service binding that owns the prefix and reach ASSETS directly.
+// Resolve such spellings to the canonical pathname the owner sees; a
+// backslash or undecodable spelling becomes a path the owner rejects.
+function resolvePrefixPathname(pathname, prefix) {
   if (!prefix || prefix === '/') {
-    return true;
+    return pathname;
   }
 
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  let candidate = pathname;
+
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    if (candidate === normalized || candidate.startsWith(`${normalized}/`)) {
+      return candidate;
+    }
+    if (candidate.startsWith(`${normalized}\\`)) {
+      return `${normalized}/__invalid_encoded_path__`;
+    }
+
+    let decoded;
+    try {
+      decoded = decodeURIComponent(candidate);
+    } catch {
+      return candidate.toLowerCase().startsWith(normalized.toLowerCase())
+        ? `${normalized}/__invalid_encoded_path__`
+        : null;
+    }
+    if (decoded === candidate) {
+      return null;
+    }
+    candidate = decoded;
+  }
 
-  return pathname === normalized || pathname.startsWith(`${normalized}/`);
+  return null;
+}
+
+function matchesPrefix(pathname, prefix) {
+  return resolvePrefixPathname(pathname, prefix) !== null;
 }
 
 function createRequestForMountedPrefix(request, prefix) {
@@ -177,12 +209,13 @@ function createRequestForMountedPrefix(request, prefix) {
 
   const url = new URL(request.url);
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  const matchedPathname = resolvePrefixPathname(url.pathname, normalized);
 
-  if (!matchesPrefix(url.pathname, normalized)) {
+  if (matchedPathname === null) {
     return request;
   }
 
-  const nextPath = url.pathname.slice(normalized.length) || '/';
+  const nextPath = matchedPathname.slice(normalized.length) || '/';
   url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
 
   return new Request(url, request);
@@ -309,12 +342,21 @@ function getEffectBffDispatcher(bff, runtime) {
 async function dispatchBffRequest(request, env) {
   const bff = MODERN_WORKER_MANIFEST.bff;
 
-  if (
-    !bff?.worker ||
-    !matchesPrefix(new URL(request.url).pathname, bff.prefix)
-  ) {
+  const requestUrl = new URL(request.url);
+  const matchedPathname = resolvePrefixPathname(
+    requestUrl.pathname,
+    bff?.prefix,
+  );
+  if (!bff?.worker || matchedPathname === null) {
     return null;
   }
+  const canonicalRequest =
+    matchedPathname === requestUrl.pathname
+      ? request
+      : new Request(
+          Object.assign(requestUrl, { pathname: matchedPathname }),
+          request,
+        );
   if (bff.runtimeFramework !== 'effect') {
     return createEffectBffDispatcherErrorResponse(
       bff,
@@ -347,7 +389,7 @@ async function dispatchBffRequest(request, env) {
       return createEffectBffDispatcherErrorResponse(bff, error);
     }
 
-    return effectDispatcher.dispatch(request, { env });
+    return effectDispatcher.dispatch(canonicalRequest, { env });
   }
 
   const directHandler =

package/dist/esm/cloudflare/artifacts.mjs

@@ -1,5 +1,6 @@
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { CLOUDFLARE_PUBLIC_ASSET_SCOPE, normalizeDeclaredPublicAssets, stageDeclaredPublicAssets } from "../deploy-output/public-assets.mjs";
 import { RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_SPEC_OUTPUT } from "./constants.mjs";
 import { normalizeRelativePath } from "./utils.mjs";
 const normalizeCloudflareArtifact = (artifact, index)=>{
@@ -15,18 +16,7 @@ const normalizeCloudflareArtifact = (artifact, index)=>{
     };
 };
 const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
-const normalizeCloudflarePublicAsset = (asset, index)=>{
-    const from = normalizeRelativePath(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
-    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
-        allowRoot: true
-    });
-    return {
-        from,
-        to,
-        index
-    };
-};
-const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
+const getCloudflarePublicAssets = (modernConfig)=>normalizeDeclaredPublicAssets(modernConfig.deploy?.worker?.publicAssets, CLOUDFLARE_PUBLIC_ASSET_SCOPE);
 const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
     for (const artifact of artifacts){
         const sourcePath = node_path.join(appDirectory, artifact.from);
@@ -34,13 +24,12 @@ const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)
         await fs.copy(sourcePath, node_path.join(outputDirectory, artifact.to));
     }
 };
-const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
-    for (const asset of publicAssets){
-        const sourcePath = node_path.join(appDirectory, asset.from);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
-        await fs.copy(sourcePath, node_path.join(publicDirectory, asset.to));
-    }
-};
+const copyCloudflarePublicAssets = async (appDirectory, outputDirectory, publicAssets)=>stageDeclaredPublicAssets({
+        appDirectory,
+        outputDirectory,
+        assets: publicAssets,
+        scope: CLOUDFLARE_PUBLIC_ASSET_SCOPE
+    });
 const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
     for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
         if (!database.migrationsDir) continue;

package/dist/esm/cloudflare/index.mjs

@@ -32,6 +32,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
     const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
     const releaseEnvelopeEnabled = api.isPluginExists('@modern-js/ultramodern-release-envelope');
     let hasReleaseEnvelope = false;
+    let declaredPublicAssets = [];
     return {
         async prepare () {
             await fs.remove(outputDirectory);
@@ -74,7 +75,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
                 await fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
-            await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
+            declaredPublicAssets = await copyCloudflarePublicAssets(appDirectory, outputDirectory, getCloudflarePublicAssets(modernConfig));
             await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
             await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
@@ -103,6 +104,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await emitCloudflareStagedReleaseEnvelope({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });

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

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import node_path from "node:path";
 import { preserveNpmAliases, readPackageIdentity } from "./npmAliases.mjs";
+import { NODE_PUBLIC_ASSET_SCOPE, normalizeDeclaredPublicAssets, stageDeclaredPublicAssets } from "./public-assets.mjs";
 import { resolveDeployTarget as external_target_mjs_resolveDeployTarget } from "./target.mjs";
 const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target_mjs_resolveDeployTarget } = {})=>({
         name: '@modern-js/deploy-output-aliases',
@@ -25,4 +26,20 @@ const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target
             });
         }
     });
-export { createDeployOutputAliasesPlugin };
+const createDeployOutputPublicAssetsPlugin = ({ resolveDeployTarget = external_target_mjs_resolveDeployTarget } = {})=>({
+        name: '@modern-js/deploy-output-public-assets',
+        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;
+                await stageDeclaredPublicAssets({
+                    appDirectory,
+                    outputDirectory: node_path.join(appDirectory, '.output'),
+                    assets: normalizeDeclaredPublicAssets(config.deploy?.node?.publicAssets, NODE_PUBLIC_ASSET_SCOPE),
+                    scope: NODE_PUBLIC_ASSET_SCOPE
+                });
+            });
+        }
+    });
+export { createDeployOutputAliasesPlugin, createDeployOutputPublicAssetsPlugin };