@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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

@@ -0,0 +1,268 @@
+"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,
+    withBuildConfigEnvironment: ()=>withBuildConfigEnvironment
+});
+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();
+const BUILD_CONFIG_ENVIRONMENT_PLUGIN = 'ModernJsBuildConfigEnvironmentLeasePlugin';
+const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry/v1');
+const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry-brand/v1');
+const LIFECYCLE_HOOK_NAMES = [
+    'run',
+    'watchRun',
+    'afterDone',
+    'failed',
+    'shutdown',
+    'watchClose'
+];
+function restoreEnvironment(name, value) {
+    if (void 0 === value) delete process.env[name];
+    else process.env[name] = value;
+}
+function createEnvironmentLeaseRegistry() {
+    const environmentLeases = new Map();
+    return Object.freeze({
+        acquire (name, value) {
+            let lease = environmentLeases.get(name);
+            if (lease) {
+                if (lease.value !== value) throw new Error(`Build config environment "${name}" already has an active lease for a different value.`);
+                if (process.env[name] !== lease.value) throw new Error(`Build config environment lease for "${name}" lost ownership before another lease was acquired.`);
+            } else {
+                lease = {
+                    originalValue: process.env[name],
+                    owners: new Set(),
+                    value
+                };
+                process.env[name] = value;
+                environmentLeases.set(name, lease);
+            }
+            const owner = Symbol(name);
+            lease.owners.add(owner);
+            let released = false;
+            return ()=>{
+                if (released) return;
+                if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) throw new Error(`Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`);
+                released = true;
+                const lostOwnership = process.env[name] !== lease.value;
+                lease.owners.delete(owner);
+                if (0 === lease.owners.size) {
+                    environmentLeases.delete(name);
+                    restoreEnvironment(name, lease.originalValue);
+                } else if (lostOwnership) process.env[name] = lease.value;
+                if (lostOwnership) throw new Error(`Build config environment lease for "${name}" lost ownership before restoration.`);
+            };
+        },
+        brand: ENVIRONMENT_LEASE_REGISTRY_BRAND
+    });
+}
+function getEnvironmentLeaseRegistry() {
+    const descriptor = Object.getOwnPropertyDescriptor(process, ENVIRONMENT_LEASE_REGISTRY_KEY);
+    if (descriptor) {
+        const registry = descriptor.value;
+        if (descriptor.configurable || descriptor.enumerable || descriptor.writable || registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND || 'function' != typeof registry.acquire) throw new Error('The process-global build config environment lease registry is occupied by an incompatible value.');
+        return registry;
+    }
+    const registry = createEnvironmentLeaseRegistry();
+    Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
+        configurable: false,
+        enumerable: false,
+        value: registry,
+        writable: false
+    });
+    return registry;
+}
+function acquireEnvironmentLease(name, value) {
+    return getEnvironmentLeaseRegistry().acquire(name, value);
+}
+function releaseAfterFailure(release, originalError) {
+    try {
+        release();
+    } catch (restorationError) {
+        throw new AggregateError([
+            originalError,
+            restorationError
+        ], 'Build config environment setup and restoration both failed.');
+    }
+    throw originalError;
+}
+class BuildConfigEnvironmentLeasePlugin {
+    apply(compiler) {
+        const hooks = compiler.hooks;
+        try {
+            const lifecycleHooks = {};
+            for (const hookName of LIFECYCLE_HOOK_NAMES){
+                const hook = hooks[hookName];
+                if (!hook || 'function' != typeof hook.tap) throw new Error(`Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`);
+                lifecycleHooks[hookName] = hook;
+            }
+            let mode = 'pending';
+            const modeTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MIN_SAFE_INTEGER
+            };
+            const releaseTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MAX_SAFE_INTEGER
+            };
+            const releaseAfterOneShot = ()=>{
+                if ('watch' !== mode && true !== compiler.watchMode) this.release();
+            };
+            lifecycleHooks.run.tap(modeTap, ()=>{
+                mode = 'run';
+            });
+            lifecycleHooks.watchRun.tap(modeTap, ()=>{
+                mode = 'watch';
+            });
+            lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.shutdown.tap(releaseTap, this.release);
+            lifecycleHooks.watchClose.tap(releaseTap, this.release);
+        } catch (error) {
+            releaseAfterFailure(this.release, error);
+        }
+    }
+    constructor(release){
+        this.release = release;
+    }
+}
+function resolveEffectTsgoCli(from) {
+    const projectRequire = (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 withBuildConfigEnvironment(name, value, setup) {
+    return async (config, ...args)=>{
+        const release = acquireEnvironmentLease(name, value);
+        try {
+            const configured = await setup(config, ...args) ?? config;
+            configured.plugins = [
+                ...configured.plugins ?? [],
+                new BuildConfigEnvironmentLeasePlugin(release)
+            ];
+            return configured;
+        } catch (error) {
+            releaseAfterFailure(release, error);
+        }
+    };
+}
+function resolveEffectTsgoCompiler(options) {
+    const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
+    if (configuredCompiler) try {
+        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+    } catch  {
+        throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    }
+    try {
+        const compiler = (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;
+exports.withBuildConfigEnvironment = __webpack_exports__.withBuildConfigEnvironment;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBuildConfigEnvironment",
+    "resolveEffectTsgoCompiler",
+    "withBuildConfigEnvironment"
+].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,46 @@
+"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,
+    withBuildConfigEnvironment: ()=>external_build_environment_js_namespaceObject.withBuildConfigEnvironment
+});
+const external_build_environment_js_namespaceObject = require("./build-environment.js");
+exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
+exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
+exports.withBuildConfigEnvironment = __webpack_exports__.withBuildConfigEnvironment;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBuildConfigEnvironment",
+    "resolveEffectTsgoCompiler",
+    "withBuildConfigEnvironment"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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,8 +42,8 @@ __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';
@@ -90,7 +90,7 @@ const resolveCompactApp = async (appDirectory)=>{
     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;
     });
     return {
@@ -101,7 +101,7 @@ const resolveCompactApp = async (appDirectory)=>{
     };
 };
 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 {
@@ -125,25 +125,16 @@ const createDeliveryUnitStamp = (identity, app)=>{
 const resolveTopologyDeliveryUnit = async (appDirectory)=>{
     const resolved = await resolveCompactApp(appDirectory);
     if (!resolved?.app) return;
-    const identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(resolved.app.deliveryUnit);
+    const identity = (0, backend_federation_contracts_namespaceObject.toDeliveryUnitIdentity)(resolved.app.deliveryUnit);
     return identity ? createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app) : void 0;
 };
 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);

package/dist/cjs/cloudflare-output-contract.js

@@ -40,18 +40,51 @@ const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
 const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
 const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    'assert',
+    'assert/strict',
     'async_hooks',
     'buffer',
+    'child_process',
     'crypto',
+    'dgram',
+    'dns',
+    'domain',
     'events',
+    'fs',
     'fs/promises',
+    'http',
+    'http2',
+    'inspector',
     'module',
+    'net',
+    'os',
     'path',
     'process',
+    'readline',
+    'readline/promises',
+    'repl',
+    'sqlite',
     'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
     'string_decoder',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
     'url',
-    'util'
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib'
+];
+const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
+    'cloudflare:sockets'
 ];
 const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
     'nodejs_compat',
@@ -71,6 +104,7 @@ __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_WORKER_NODE_BUILTINS: CLOUDFLARE_WORKER_NODE_BUILTINS,
     CLOUDFLARE_WORKER_PACKAGE_FILE: CLOUDFLARE_WORKER_PACKAGE_FILE,
     CLOUDFLARE_WORKER_PACKAGE_TYPE: CLOUDFLARE_WORKER_PACKAGE_TYPE,
+    CLOUDFLARE_WORKER_PLATFORM_MODULES: CLOUDFLARE_WORKER_PLATFORM_MODULES,
     CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE
 });
 exports.CLOUDFLARE_ASSETS_BINDING = __webpack_exports__.CLOUDFLARE_ASSETS_BINDING;
@@ -86,6 +120,7 @@ exports.CLOUDFLARE_WORKER_MANIFEST = __webpack_exports__.CLOUDFLARE_WORKER_MANIF
 exports.CLOUDFLARE_WORKER_NODE_BUILTINS = __webpack_exports__.CLOUDFLARE_WORKER_NODE_BUILTINS;
 exports.CLOUDFLARE_WORKER_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_FILE;
 exports.CLOUDFLARE_WORKER_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_TYPE;
+exports.CLOUDFLARE_WORKER_PLATFORM_MODULES = __webpack_exports__.CLOUDFLARE_WORKER_PLATFORM_MODULES;
 exports.CLOUDFLARE_WRANGLER_CONFIG_FILE = __webpack_exports__.CLOUDFLARE_WRANGLER_CONFIG_FILE;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_ASSETS_BINDING",
@@ -101,6 +136,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_WORKER_NODE_BUILTINS",
     "CLOUDFLARE_WORKER_PACKAGE_FILE",
     "CLOUDFLARE_WORKER_PACKAGE_TYPE",
+    "CLOUDFLARE_WORKER_PLATFORM_MODULES",
     "CLOUDFLARE_WRANGLER_CONFIG_FILE"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -30,7 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     verifyDeliveryUnitIdentity: ()=>verifyDeliveryUnitIdentity
 });
-const universal_namespaceObject = require("@modern-js/utils/universal");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_issues_js_namespaceObject = require("./issues.js");
 const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     const stamped = manifest?.deliveryUnit;
@@ -41,8 +41,8 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
             message: `Cloudflare worker manifest is missing the delivery-unit identity declared by the workspace topology (expected unitId ${declared.unitId}, buildMarker ${declared.buildMarker}).`,
             path: manifestPath
         });
-        for (const field of universal_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
-            const stampedValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+        for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+            const stampedValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
             (0, external_issues_js_namespaceObject.assertEqual)(issues, stampedValue, declared[field], {
                 code: 'delivery-unit-drift',
                 message: `Cloudflare worker manifest deliveryUnit.${field} must match the topology delivery-unit record (expected ${declared[field]}, received ${stampedValue ?? 'undefined'}).`,
@@ -72,9 +72,9 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
             });
             continue;
         }
-        for (const field of universal_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
-            const markerValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
-            const stampedValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+        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'}).`,

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

@@ -223,7 +223,10 @@ const analyzeWorkerModule = (source)=>{
     };
 };
 const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set([
+    ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`),
+    ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PLATFORM_MODULES
+]);
 const isInsideDirectory = (directory, filePath)=>{
     const relative = external_node_path_default().relative(directory, filePath);
     return 0 === relative.length || !relative.startsWith('..') && !external_node_path_default().isAbsolute(relative);