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

package/dist/cjs/backend-federation-build/index.js

@@ -0,0 +1,53 @@
+"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__, {
+    default: ()=>external_emit_js_default(),
+    emitBackendFederationArtifacts: ()=>external_emit_js_namespaceObject.emitBackendFederationArtifacts
+});
+const external_emit_js_namespaceObject = require("./emit.js");
+var external_emit_js_default = /*#__PURE__*/ __webpack_require__.n(external_emit_js_namespaceObject);
+exports["default"] = __webpack_exports__["default"];
+exports.emitBackendFederationArtifacts = __webpack_exports__.emitBackendFederationArtifacts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "emitBackendFederationArtifacts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/build-environment.js

@@ -0,0 +1,129 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getBuildConfigEnvironment: ()=>getBuildConfigEnvironment,
+    resolveEffectTsgoCompiler: ()=>resolveEffectTsgoCompiler
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_module_namespaceObject = require("node:module");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("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();
+function resolveEffectTsgoCli(from) {
+    const projectRequire = (0, external_node_module_namespaceObject.createRequire)(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse((0, external_node_fs_namespaceObject.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 (0, external_node_path_namespaceObject.resolve)((0, external_node_path_namespaceObject.dirname)(packageJsonPath), bin);
+}
+function resolveExecutableEffectTsgoCompiler(compilerPath) {
+    if ('win32' === process.platform) return compilerPath;
+    const sourcePath = (0, external_node_fs_namespaceObject.realpathSync)(compilerPath);
+    const source = (0, external_node_fs_namespaceObject.lstatSync)(sourcePath);
+    if (!source.isFile()) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    try {
+        (0, external_node_fs_namespaceObject.accessSync)(sourcePath, external_node_fs_namespaceObject.constants.X_OK);
+        return compilerPath;
+    } catch  {}
+    const cachedCompiler = executableEffectTsgoCompilers.get(sourcePath);
+    if (cachedCompiler) try {
+        (0, external_node_fs_namespaceObject.accessSync)(cachedCompiler, external_node_fs_namespaceObject.constants.X_OK);
+        return cachedCompiler;
+    } catch  {
+        executableEffectTsgoCompilers.delete(sourcePath);
+    }
+    const compilerBytes = (0, external_node_fs_namespaceObject.readFileSync)(sourcePath);
+    const compilerDigest = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(compilerBytes).digest('hex');
+    const compilerDirectory = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), 'modern-js', 'effect-tsgo', compilerDigest);
+    (0, external_node_fs_namespaceObject.mkdirSync)(compilerDirectory, {
+        recursive: true,
+        mode: 448
+    });
+    const executableCompiler = (0, external_node_path_namespaceObject.join)(compilerDirectory, (0, external_node_path_namespaceObject.basename)(sourcePath));
+    try {
+        (0, external_node_fs_namespaceObject.accessSync)(executableCompiler, external_node_fs_namespaceObject.constants.X_OK);
+    } catch  {
+        const temporaryCompiler = (0, external_node_path_namespaceObject.join)(compilerDirectory, `.${(0, external_node_path_namespaceObject.basename)(sourcePath)}.${process.pid}.tmp`);
+        (0, external_node_fs_namespaceObject.rmSync)(temporaryCompiler, {
+            force: true
+        });
+        try {
+            (0, external_node_fs_namespaceObject.writeFileSync)(temporaryCompiler, compilerBytes, {
+                flag: 'wx',
+                mode: 448
+            });
+            (0, external_node_fs_namespaceObject.chmodSync)(temporaryCompiler, 448);
+            (0, external_node_fs_namespaceObject.renameSync)(temporaryCompiler, executableCompiler);
+        } finally{
+            (0, external_node_fs_namespaceObject.rmSync)(temporaryCompiler, {
+                force: true
+            });
+        }
+    }
+    (0, external_node_fs_namespaceObject.accessSync)(executableCompiler, external_node_fs_namespaceObject.constants.X_OK);
+    executableEffectTsgoCompilers.set(sourcePath, executableCompiler);
+    return executableCompiler;
+}
+function getBuildConfigEnvironment(name) {
+    return process.env[name];
+}
+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 = (0, external_node_child_process_namespaceObject.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);
+}
+exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
+exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBuildConfigEnvironment",
+    "resolveEffectTsgoCompiler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/precompress/plugin.js

@@ -0,0 +1,124 @@
+"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__, {
+    builderPluginAdapterPrecompress: ()=>builderPluginAdapterPrecompress
+});
+const external_node_zlib_namespaceObject = require("node:zlib");
+const external_compression_webpack_plugin_namespaceObject = require("compression-webpack-plugin");
+var external_compression_webpack_plugin_default = /*#__PURE__*/ __webpack_require__.n(external_compression_webpack_plugin_namespaceObject);
+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: {
+                [external_node_zlib_namespaceObject.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(external_compression_webpack_plugin_default(), [
+                    gzipOptions
+                ]);
+                const brotliOptions = resolveCodecOptions(precompressConfig.brotli, createDefaultBrotliOptions);
+                if (brotliOptions) chain.plugin('modern-precompress-brotli').use(external_compression_webpack_plugin_default(), [
+                    brotliOptions
+                ]);
+            });
+        }
+    });
+exports.builderPluginAdapterPrecompress = __webpack_exports__.builderPluginAdapterPrecompress;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterPrecompress"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/precompress/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/public.js

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getBuildConfigEnvironment: ()=>external_build_environment_js_namespaceObject.getBuildConfigEnvironment,
+    resolveEffectTsgoCompiler: ()=>external_build_environment_js_namespaceObject.resolveEffectTsgoCompiler
+});
+const external_build_environment_js_namespaceObject = require("./build-environment.js");
+exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
+exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBuildConfigEnvironment",
+    "resolveEffectTsgoCompiler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/remote-address.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRemoteManifestUrl: ()=>createRemoteManifestUrl
+});
+const surface_resolution_namespaceObject = require("@modern-js/surface-resolution");
+const target_js_namespaceObject = require("../deploy-output/target.js");
+const external_build_environment_js_namespaceObject = require("./build-environment.js");
+function createRemoteManifestUrl(options) {
+    const env = {
+        ...Object.fromEntries([
+            options.manifestEnv,
+            options.publicUrlEnv,
+            'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'
+        ].map((name)=>[
+                name,
+                (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)(name)
+            ])),
+        MODERNJS_DEPLOY: (0, target_js_namespaceObject.resolveDeployTarget)().target
+    };
+    const address = (0, surface_resolution_namespaceObject.resolveBrowserManifestAddress)(env, options, (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)('NODE_ENV') ?? 'production');
+    if (!address.ok) throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+    return env[options.manifestEnv]?.trim() || `${options.mfName}@${address.manifestUrl}`;
+}
+exports.createRemoteManifestUrl = __webpack_exports__.createRemoteManifestUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRemoteManifestUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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/constants.js

@@ -73,7 +73,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 = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;

package/dist/cjs/cloudflare/delivery-unit.js

@@ -42,15 +42,15 @@ __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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const utils_namespaceObject = require("@modern-js/utils");
-const universal_namespaceObject = require("@modern-js/utils/universal");
 const external_release_identity_js_namespaceObject = require("../release-identity.js");
 const external_utils_js_namespaceObject = require("./utils.js");
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const TOPOLOGY_PATH = 'topology/reference-topology.json';
 const findWorkspaceRoot = async (appDirectory)=>{
     let current = external_node_path_default().resolve(appDirectory);
     for(;;){
-        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, TOPOLOGY_PATH))) return current;
         const parent = external_node_path_default().dirname(current);
         if (parent === current) return;
         current = parent;
@@ -67,41 +67,30 @@ const stampReleaseIdentity = (identity, workspaceRoot)=>{
         })
     };
 };
-const resolveCompactApp = async (appDirectory)=>{
+const resolveTopologyApp = async (appDirectory)=>{
     const workspaceRoot = await findWorkspaceRoot(appDirectory);
     if (!workspaceRoot) return;
-    let compactConfig;
-    try {
-        compactConfig = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
-    } catch  {
-        return {
-            workspaceRoot
-        };
-    }
-    if (!(0, external_utils_js_namespaceObject.isRecord)(compactConfig)) return {
-        workspaceRoot
-    };
-    const topology = (0, external_utils_js_namespaceObject.isRecord)(compactConfig.topology) ? compactConfig.topology : void 0;
-    const apps = Array.isArray(topology?.apps) ? topology.apps : void 0;
-    if (!apps) return {
-        app: compactConfig,
-        workspaceRoot
-    };
+    const topology = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, TOPOLOGY_PATH));
+    if (!(0, external_utils_js_namespaceObject.isRecord)(topology) || !(0, external_utils_js_namespaceObject.isRecord)(topology.shell) || !Array.isArray(topology.verticals) || void 0 !== topology.shells && !Array.isArray(topology.shells)) throw new Error('[cloudflare-delivery-unit] Invalid declared reference topology.');
+    const apps = [
+        topology.shell,
+        ...topology.verticals,
+        ...Array.isArray(topology.shells) ? topology.shells : []
+    ];
     const resolvedAppDirectory = external_node_path_default().resolve(appDirectory);
     const app = apps.find((candidate)=>{
         if (!(0, external_utils_js_namespaceObject.isRecord)(candidate)) return false;
-        const appPath = (0, universal_namespaceObject.nonEmptyString)(candidate.path);
+        const appPath = (0, backend_federation_contracts_namespaceObject.nonEmptyString)(candidate.path);
         return void 0 !== appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory;
     });
+    if (!(0, external_utils_js_namespaceObject.isRecord)(app)) throw new Error(`[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`);
     return {
-        ...(0, external_utils_js_namespaceObject.isRecord)(app) ? {
-            app
-        } : {},
+        app,
         workspaceRoot
     };
 };
 const createDeliveryUnitStamp = (identity, app)=>{
-    const surfaceProfile = (0, universal_namespaceObject.nonEmptyString)(app?.surfaceProfile);
+    const surfaceProfile = (0, backend_federation_contracts_namespaceObject.nonEmptyString)(app?.surfaceProfile);
     const emitsUi = 'api-only' !== surfaceProfile;
     const emitsApi = 'ui-only' !== surfaceProfile;
     return {
@@ -123,30 +112,22 @@ const createDeliveryUnitStamp = (identity, app)=>{
     };
 };
 const resolveTopologyDeliveryUnit = async (appDirectory)=>{
-    const resolved = await resolveCompactApp(appDirectory);
+    const resolved = await resolveTopologyApp(appDirectory);
     if (!resolved?.app) return;
-    const identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(resolved.app.deliveryUnit);
-    return identity ? createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app) : void 0;
+    const identity = (0, backend_federation_contracts_namespaceObject.toDeliveryUnitIdentity)(resolved.app.deliveryUnit);
+    if (!identity) throw new Error('[cloudflare-delivery-unit] Declared app is missing a valid delivery-unit identity.');
+    return createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app);
 };
 const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
-    const buildArtifactPath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
-    const buildModulePath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_MODULE_PATH);
+    const buildArtifactPath = external_node_path_default().join(appDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
     let identity;
     if (await utils_namespaceObject.fs.pathExists(buildArtifactPath)) {
         const artifact = await utils_namespaceObject.fs.readJSON(buildArtifactPath);
-        if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) return;
-        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
-    } else if (await utils_namespaceObject.fs.pathExists(buildModulePath)) {
-        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
-        const source = await utils_namespaceObject.fs.readFile(buildModulePath, 'utf8');
-        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)({
-            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
-            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
-            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
-        });
+        if (!(0, backend_federation_contracts_namespaceObject.isUltramodernBuildArtifact)(artifact)) return;
+        identity = (0, backend_federation_contracts_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
     }
     if (!identity) return;
-    const resolved = await resolveCompactApp(appDirectory);
+    const resolved = await resolveTopologyApp(appDirectory);
     if (resolved) identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
     return createDeliveryUnitStamp(identity, resolved?.app);
 };

package/dist/cjs/cloudflare/index.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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_cloudflare_output_plan_js_namespaceObject = require("../cloudflare-output-plan.js");
 const index_js_namespaceObject = require("../cloudflare-output-verifier/index.js");
@@ -73,12 +74,13 @@ 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);
         },
         async writeOutput () {
-            if (releaseEnvelopeEnabled && await utils_namespaceObject.fs.pathExists(external_node_path_default().join(distDirectory, framework_output_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
+            if (releaseEnvelopeEnabled) await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
                 apiOnly,
                 distDirectory,
                 target: 'cloudflare'
@@ -87,6 +89,11 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
                 filter: (src)=>{
                     const relativePath = external_node_path_default().relative(distDirectory, src).replace(/\\/gu, '/');
+                    if (apiOnly && '' !== relativePath && ![
+                        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+                        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                        backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE
+                    ].includes(relativePath)) return false;
                     return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && (0, external_worker_manifest_js_namespaceObject.shouldCopyToPublicAssets)(src, distDirectory, publicAssetExcludes);
                 }
             });
@@ -110,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
@@ -139,6 +146,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await (0, framework_output_js_namespaceObject.emitCloudflareStagedReleaseEnvelope)({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });