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

package/dist/esm/build-config/remote-address.mjs

@@ -0,0 +1,20 @@
+import { resolveBrowserManifestAddress } from "@modern-js/surface-resolution";
+import { resolveDeployTarget } from "../deploy-output/target.mjs";
+import { getBuildConfigEnvironment } from "./build-environment.mjs";
+function createRemoteManifestUrl(options) {
+    const env = {
+        ...Object.fromEntries([
+            options.manifestEnv,
+            options.publicUrlEnv,
+            'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'
+        ].map((name)=>[
+                name,
+                getBuildConfigEnvironment(name)
+            ])),
+        MODERNJS_DEPLOY: resolveDeployTarget().target
+    };
+    const address = resolveBrowserManifestAddress(env, options, getBuildConfigEnvironment('NODE_ENV') ?? 'production');
+    if (!address.ok) throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+    return env[options.manifestEnv]?.trim() || `${options.mfName}@${address.manifestUrl}`;
+}
+export { createRemoteManifestUrl };

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

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

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

@@ -1,13 +1,13 @@
 import node_path from "node:path";
+import { ULTRAMODERN_BUILD_ARTIFACT_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/backend-federation-contracts";
 import { fs } from "@modern-js/utils";
-import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/utils/universal";
 import { resolveUltramodernReleaseIdentity } from "../release-identity.mjs";
 import { isRecord } from "./utils.mjs";
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const TOPOLOGY_PATH = 'topology/reference-topology.json';
 const findWorkspaceRoot = async (appDirectory)=>{
     let current = node_path.resolve(appDirectory);
     for(;;){
-        if (await fs.pathExists(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        if (await fs.pathExists(node_path.join(current, TOPOLOGY_PATH))) return current;
         const parent = node_path.dirname(current);
         if (parent === current) return;
         current = parent;
@@ -24,36 +24,25 @@ 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 fs.readJSON(node_path.join(workspaceRoot, COMPACT_CONFIG_PATH));
-    } catch  {
-        return {
-            workspaceRoot
-        };
-    }
-    if (!isRecord(compactConfig)) return {
-        workspaceRoot
-    };
-    const topology = 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 fs.readJSON(node_path.join(workspaceRoot, TOPOLOGY_PATH));
+    if (!isRecord(topology) || !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 = node_path.resolve(appDirectory);
     const app = apps.find((candidate)=>{
         if (!isRecord(candidate)) return false;
         const appPath = nonEmptyString(candidate.path);
         return void 0 !== appPath && node_path.resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory;
     });
+    if (!isRecord(app)) throw new Error(`[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`);
     return {
-        ...isRecord(app) ? {
-            app
-        } : {},
+        app,
         workspaceRoot
     };
 };
@@ -80,30 +69,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 = toDeliveryUnitIdentity(resolved.app.deliveryUnit);
-    return identity ? createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app) : void 0;
+    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 = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
-    const buildModulePath = node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
     let identity;
     if (await fs.pathExists(buildArtifactPath)) {
         const artifact = await fs.readJSON(buildArtifactPath);
         if (!isUltramodernBuildArtifact(artifact)) return;
         identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
-    } else if (await 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 fs.readFile(buildModulePath, 'utf8');
-        identity = toDeliveryUnitIdentity({
-            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
-            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
-            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
-        });
     }
     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/esm/cloudflare/index.mjs

@@ -1,4 +1,5 @@
 import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE } from "@modern-js/backend-federation-contracts";
 import { fs } from "@modern-js/utils";
 import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
 import { assertCloudflareOutput } from "../cloudflare-output-verifier/index.mjs";
@@ -31,12 +32,13 @@ 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);
         },
         async writeOutput () {
-            if (releaseEnvelopeEnabled && await fs.pathExists(node_path.join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await emitFrameworkMicroVerticalReleaseEnvelope({
+            if (releaseEnvelopeEnabled) await emitFrameworkMicroVerticalReleaseEnvelope({
                 apiOnly,
                 distDirectory,
                 target: 'cloudflare'
@@ -45,6 +47,11 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             await fs.copy(distDirectory, publicDirectory, {
                 filter: (src)=>{
                     const relativePath = node_path.relative(distDirectory, src).replace(/\\/gu, '/');
+                    if (apiOnly && '' !== relativePath && ![
+                        BACKEND_FEDERATION_MANIFEST_FILE,
+                        BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                        ULTRAMODERN_BUILD_ARTIFACT_FILE
+                    ].includes(relativePath)) return false;
                     return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes);
                 }
             });
@@ -68,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
@@ -97,6 +104,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await emitCloudflareStagedReleaseEnvelope({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });

package/dist/esm/cloudflare/worker-manifest.mjs

@@ -1,5 +1,6 @@
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { getCloudflareWorkerRouteDataEntryName } from "../cloudflare-output-contract.mjs";
 import { readRouteSpec } from "./artifacts.mjs";
 import { ASSETS_BINDING, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, PUBLIC_ASSETS_DIRECTORY, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY } from "./constants.mjs";
 import { createI18nWorkerManifest } from "./i18n-worker.mjs";
@@ -65,13 +66,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
     const routeSpec = await readRouteSpec(outputDirectory);
     const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
         const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        const routeDataWorker = route.isSSR && 'string' == typeof route.entryName ? `${WORKER_BUNDLE_DIRECTORY}/${getCloudflareWorkerRouteDataEntryName(route.entryName)}.js` : void 0;
+        const hasRouteDataWorker = routeDataWorker ? await fs.pathExists(node_path.join(outputDirectory, routeDataWorker)) : false;
         return {
             urlPath: route.urlPath,
             entryName: route.entryName,
             entryPath: route.entryPath,
             isSSR: Boolean(route.isSSR),
             worker,
-            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false
+            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false,
+            ...hasRouteDataWorker ? {
+                routeDataWorker
+            } : {}
         };
     }));
     const bffPrefix = modernConfig.bff?.prefix;
@@ -131,9 +137,12 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
 };
 const createWorkerModuleLoaders = (manifest)=>{
     const imports = new Map();
-    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
-        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
-        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    for (const route of manifest.routeSpec.routes)for (const worker of [
+        route.workerExists ? route.worker : void 0,
+        route.routeDataWorker
+    ])if (worker) {
+        const importPath = `../${String(worker).replace(/^\/+/u, '')}`;
+        imports.set(worker, `() => import(${JSON.stringify(importPath)})`);
     }
     if (manifest.bff?.worker) {
         const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;

package/dist/esm/cloudflare/wrangler-config.mjs

@@ -1,12 +1,16 @@
 import node_path from "node:path";
 import { ASSETS_BINDING, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, WORKER_ENTRY } from "./constants.mjs";
 import { isJsonRecord, normalizeRelativePath } from "./utils.mjs";
-const getCompatibilityDate = (modernConfig)=>{
-    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
-    const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
-    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+const assertSupportedCompatibilityDate = (compatibilityDate, label)=>{
+    if ('string' != typeof compatibilityDate) throw new Error(`${label} must be a YYYY-MM-DD string.`);
+    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`${label} must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+    if (compatibilityDate < DEFAULT_COMPATIBILITY_DATE) throw new Error(`${label} must be ${DEFAULT_COMPATIBILITY_DATE} or later, the date the Cloudflare worker Node.js built-in contract is verified against; received ${JSON.stringify(compatibilityDate)}.`);
     return compatibilityDate;
 };
+const getCompatibilityDate = (modernConfig, wranglerCompatibilityDate)=>{
+    if (void 0 !== wranglerCompatibilityDate) return assertSupportedCompatibilityDate(wranglerCompatibilityDate, 'deploy.worker.wrangler.compatibility_date');
+    return assertSupportedCompatibilityDate(modernConfig.deploy?.worker?.compatibilityDate?.trim() || DEFAULT_COMPATIBILITY_DATE, 'deploy.worker.compatibilityDate');
+};
 const getWorkerName = (appDirectory)=>{
     const basename = node_path.basename(appDirectory);
     return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
@@ -21,11 +25,11 @@ const getConfiguredWrangler = (modernConfig)=>{
     if (!isJsonRecord(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
     return wrangler;
 };
-const createWranglerCompatibilityFlags = (configuredFlags)=>{
+const createWranglerCompatibilityFlags = (configuredFlags, label = 'deploy.worker.wrangler.compatibility_flags')=>{
     if (void 0 === configuredFlags) return [
         ...REQUIRED_COMPATIBILITY_FLAGS
     ];
-    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error('deploy.worker.wrangler.compatibility_flags must be an array of strings.');
+    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error(`${label} must be an array of strings.`);
     return [
         ...new Set([
             ...configuredFlags,
@@ -33,6 +37,26 @@ const createWranglerCompatibilityFlags = (configuredFlags)=>{
         ])
     ];
 };
+const createWranglerEnvironments = (wranglerEnv)=>{
+    if (void 0 === wranglerEnv) return;
+    if (!isJsonRecord(wranglerEnv)) throw new Error('deploy.worker.wrangler.env must be an object.');
+    return Object.fromEntries(Object.entries(wranglerEnv).map(([name, environment])=>{
+        const label = `deploy.worker.wrangler.env.${name}`;
+        if (!isJsonRecord(environment)) throw new Error(`${label} must be an object.`);
+        return [
+            name,
+            {
+                ...environment,
+                ...void 0 === environment.compatibility_date ? {} : {
+                    compatibility_date: assertSupportedCompatibilityDate(environment.compatibility_date, `${label}.compatibility_date`)
+                },
+                ...void 0 === environment.compatibility_flags ? {} : {
+                    compatibility_flags: createWranglerCompatibilityFlags(environment.compatibility_flags, `${label}.compatibility_flags`)
+                }
+            }
+        ];
+    }));
+};
 const createWranglerAssetsConfig = (configuredAssets)=>{
     if (void 0 !== configuredAssets && !isJsonRecord(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
     return {
@@ -129,17 +153,21 @@ const createWorkerManifestServiceBindings = (serviceBindings)=>{
 };
 const createWranglerConfig = (appDirectory, modernConfig)=>{
     const wrangler = getConfiguredWrangler(modernConfig);
+    const environments = createWranglerEnvironments(wrangler.env);
     const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
     const serviceBindings = createWorkerServiceBindings(modernConfig, wrangler.services);
     const wranglerServices = createWranglerServices(serviceBindings);
     return {
         $schema: 'node_modules/wrangler/config-schema.json',
         name: getConfiguredWorkerName(appDirectory, modernConfig),
-        compatibility_date: getCompatibilityDate(modernConfig),
         ...wrangler,
+        compatibility_date: getCompatibilityDate(modernConfig, wrangler.compatibility_date),
         main: WORKER_ENTRY,
         compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
         assets: createWranglerAssetsConfig(wrangler.assets),
+        ...void 0 === environments ? {} : {
+            env: environments
+        },
         ...void 0 === d1Databases ? {} : {
             d1_databases: d1Databases
         },