@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

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

@@ -0,0 +1,597 @@
+"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__, {
+    MICROVERTICAL_RELEASE_ENVELOPE_PATH: ()=>MICROVERTICAL_RELEASE_ENVELOPE_PATH,
+    emitCloudflareStagedReleaseEnvelope: ()=>emitCloudflareStagedReleaseEnvelope,
+    emitFrameworkMicroVerticalReleaseEnvelope: ()=>emitFrameworkMicroVerticalReleaseEnvelope,
+    emitNodeStagedReleaseEnvelope: ()=>emitNodeStagedReleaseEnvelope,
+    readFrameworkMicroVerticalReleaseEnvelope: ()=>readFrameworkMicroVerticalReleaseEnvelope,
+    stageCloudflareReleaseEnvelope: ()=>stageCloudflareReleaseEnvelope,
+    verifyBuildOutputReleaseEnvelope: ()=>verifyBuildOutputReleaseEnvelope,
+    verifyCloudflareReleaseEnvelopeStaging: ()=>verifyCloudflareReleaseEnvelopeStaging,
+    verifyNodeReleaseEnvelopeStaging: ()=>verifyNodeReleaseEnvelopeStaging
+});
+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 parser_namespaceObject = require("@babel/parser");
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_index_js_namespaceObject = require("./index.js");
+const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
+const COMPILED_MODULE_PATTERN = /\.(?:c|m)?js$/u;
+const EFFECT_BFF_WORKER_PATTERN = /^worker\/__modern_bff_effect\.(?:c|m)?js$/u;
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isAstNode = (value)=>isRecord(value) && 'string' == typeof value.type;
+const visitAst = (node, visitor)=>{
+    visitor(node);
+    for (const value of Object.values(node))if (isAstNode(value)) visitAst(value, visitor);
+    else if (Array.isArray(value)) {
+        for (const item of value)if (isAstNode(item)) visitAst(item, visitor);
+    }
+};
+const compiledModuleIdentityValues = (source)=>{
+    const values = new Set();
+    const ast = (0, parser_namespaceObject.parse)(source, {
+        sourceType: 'unambiguous'
+    });
+    visitAst(ast.program, (node)=>{
+        if ('StringLiteral' === node.type && 'string' == typeof node.value) values.add(node.value);
+        else if ('TemplateElement' === node.type && isRecord(node.value) && 'string' == typeof node.value.cooked) values.add(node.value.cooked);
+    });
+    return values;
+};
+const assertEveryCompiledIdentityCarrier = async (distDirectory, logicalPaths, identity, surface)=>{
+    const compiledLogicalPaths = logicalPaths.filter((pathname)=>COMPILED_MODULE_PATTERN.test(pathname));
+    if (0 === compiledLogicalPaths.length) throw new Error(`[ultramodern-release-envelope] ${surface} has no compiled execution module carrying release identity.`);
+    for (const logicalPath of compiledLogicalPaths){
+        const source = await promises_default().readFile(external_node_path_default().join(distDirectory, logicalPath), {
+            encoding: 'utf8'
+        });
+        const values = compiledModuleIdentityValues(source);
+        if (!values.has(identity.buildMarker) || !values.has(identity.sourceRevision) || !values.has(identity.releaseVersion)) throw new Error(`[ultramodern-release-envelope] ${surface} execution module ${logicalPath} does not carry exact buildMarker ${identity.buildMarker}, sourceRevision ${identity.sourceRevision}, and releaseVersion ${identity.releaseVersion}.`);
+    }
+};
+const flattenStrings = (value)=>'string' == typeof value ? [
+        value
+    ] : Array.isArray(value) ? value.flatMap(flattenStrings) : [];
+const collectNestedStrings = (value, key)=>{
+    if (Array.isArray(value)) return value.flatMap((item)=>collectNestedStrings(item, key));
+    if (!isRecord(value)) return [];
+    return Object.entries(value).flatMap(([entryKey, entryValue])=>[
+            ...entryKey === key ? flattenStrings(entryValue) : [],
+            ...collectNestedStrings(entryValue, key)
+        ]);
+};
+const manifestReferencedClientModules = async (distDirectory, files, manifestLogicalPath = 'mf-manifest.json')=>{
+    const manifest = await readJson(external_node_path_default().join(distDirectory, manifestLogicalPath));
+    const references = [
+        ...collectNestedStrings(manifest, 'path'),
+        ...collectNestedStrings(manifest, 'name'),
+        ...collectNestedStrings(manifest, 'sync'),
+        ...collectNestedStrings(manifest, 'async')
+    ];
+    const normalizedReferences = new Set(references.filter((value)=>'string' == typeof value).map((value)=>value.replace(/^https?:\/\/[^/]+/u, '')).map((value)=>value.replace(/^\/+/u, '')));
+    return files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && [
+            ...normalizedReferences
+        ].some((reference)=>reference === logicalPath || reference.endsWith(`/${logicalPath}`) || logicalPath.endsWith(`/${reference}`)));
+};
+const routeReferencedSsrModules = async (distDirectory, files, target, routeSpecLogicalPath = 'route.json')=>{
+    const routeSpec = await readJson(external_node_path_default().join(distDirectory, routeSpecLogicalPath));
+    const field = 'node' === target ? 'bundle' : 'worker';
+    const references = collectNestedStrings(routeSpec, field).map((value)=>value.replace(/^\/+/u, ''));
+    return files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && references.includes(logicalPath));
+};
+const readJson = async (filePath)=>JSON.parse(await promises_default().readFile(filePath, 'utf8'));
+const isFilesystemPathInside = (root, candidate)=>{
+    const relative = external_node_path_default().relative(root, candidate);
+    return '' === relative || !relative.startsWith(`..${external_node_path_default().sep}`) && '..' !== relative && !external_node_path_default().isAbsolute(relative);
+};
+const isMissingPathError = (error)=>isRecord(error) && 'ENOENT' === error.code;
+const resolveSafeReleaseEnvelopePath = async ({ artifactRoot, createDirectory })=>{
+    const resolvedRoot = external_node_path_default().resolve(artifactRoot);
+    const realRoot = await promises_default().realpath(resolvedRoot);
+    const releaseDirectory = external_node_path_default().join(resolvedRoot, 'release');
+    let releaseStat;
+    try {
+        releaseStat = await promises_default().lstat(releaseDirectory);
+    } catch (error) {
+        if (!isMissingPathError(error)) throw error;
+        if (!createDirectory) return;
+        await promises_default().mkdir(releaseDirectory);
+        releaseStat = await promises_default().lstat(releaseDirectory);
+    }
+    if (releaseStat.isSymbolicLink() || !releaseStat.isDirectory()) throw new Error('[ultramodern-release-envelope] release must be a real directory inside artifactRoot, not a symlink or file.');
+    const realReleaseDirectory = await promises_default().realpath(releaseDirectory);
+    if (!isFilesystemPathInside(realRoot, realReleaseDirectory)) throw new Error('[ultramodern-release-envelope] release directory resolves outside artifactRoot.');
+    const envelopePath = external_node_path_default().join(releaseDirectory, external_node_path_default().basename(MICROVERTICAL_RELEASE_ENVELOPE_PATH));
+    try {
+        const envelopeStat = await promises_default().lstat(envelopePath);
+        if (envelopeStat.isSymbolicLink() || !envelopeStat.isFile()) throw new Error('[ultramodern-release-envelope] release envelope must be a real file inside artifactRoot, not a symlink or directory.');
+        const realEnvelopePath = await promises_default().realpath(envelopePath);
+        if (!isFilesystemPathInside(realRoot, realEnvelopePath)) throw new Error('[ultramodern-release-envelope] release envelope resolves outside artifactRoot.');
+    } catch (error) {
+        if (!isMissingPathError(error)) throw error;
+        if (!createDirectory) return;
+    }
+    return envelopePath;
+};
+const writeReleaseEnvelope = async (artifactRoot, envelope)=>{
+    const envelopePath = await resolveSafeReleaseEnvelopePath({
+        artifactRoot,
+        createDirectory: true
+    });
+    if (!envelopePath) throw new Error('[ultramodern-release-envelope] could not resolve release envelope path.');
+    await promises_default().writeFile(envelopePath, `${(0, external_index_js_namespaceObject.canonicalSerializeMicroVerticalReleaseEnvelope)(envelope)}\n`);
+};
+const readBuildArtifact = async (distDirectory)=>{
+    const artifactPath = external_node_path_default().join(distDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE);
+    const artifact = await readJson(artifactPath);
+    if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) throw new Error(`[ultramodern-release-envelope] ${universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE} is missing or invalid.`);
+    if ('workspace' === artifact.deliveryUnit.sourceRevision) throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
+    return artifact;
+};
+const assertIdentityBlock = (value, identity, location, includeReleaseVersion)=>{
+    if (!isRecord(value)) throw new Error(`[ultramodern-release-envelope] ${location} is missing delivery identity.`);
+    const expected = {
+        unitId: identity.unitId,
+        buildMarker: identity.buildMarker,
+        sourceRevision: identity.sourceRevision,
+        ...includeReleaseVersion ? {
+            version: identity.releaseVersion
+        } : void 0
+    };
+    for (const [field, expectedValue] of Object.entries(expected))if (value[field] !== expectedValue) throw new Error(`[ultramodern-release-envelope] ${location}.${field} must match ${expectedValue}; received ${String(value[field])}.`);
+};
+const readBackendManifest = async (distDirectory, identity)=>{
+    const manifest = await readJson(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE));
+    if (!isRecord(manifest) || !isRecord(manifest.backendFederation)) throw new Error('[ultramodern-release-envelope] backend federation manifest is missing backendFederation metadata.');
+    assertIdentityBlock(manifest.backendFederation.deliveryUnit, identity, 'backendFederation.deliveryUnit', true);
+    const versionBoundary = manifest.backendFederation.versionBoundary;
+    assertIdentityBlock(isRecord(versionBoundary) ? versionBoundary.deliveryUnit : void 0, identity, 'backendFederation.versionBoundary.deliveryUnit', false);
+};
+const collectFiles = async (root)=>{
+    const resolvedRoot = external_node_path_default().resolve(root);
+    const realRoot = await promises_default().realpath(resolvedRoot);
+    const collectDirectory = async (relativeDirectory)=>{
+        const directory = external_node_path_default().join(resolvedRoot, ...relativeDirectory.split('/').filter(Boolean));
+        const entries = await promises_default().readdir(directory, {
+            withFileTypes: true
+        });
+        const files = [];
+        for (const entry of entries){
+            const logicalPath = external_node_path_default().posix.join(relativeDirectory, entry.name);
+            if ('release' === logicalPath || logicalPath.startsWith('release/')) continue;
+            if (entry.isDirectory()) {
+                files.push(...await collectDirectory(logicalPath));
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push(logicalPath);
+                continue;
+            }
+            if (!entry.isSymbolicLink()) continue;
+            const lexicalPath = external_node_path_default().join(resolvedRoot, ...logicalPath.split('/'));
+            let realPath;
+            try {
+                realPath = await promises_default().realpath(lexicalPath);
+            } catch  {
+                throw new Error(`[ultramodern-release-envelope] symbolic link ${logicalPath} cannot be resolved.`);
+            }
+            if (!isFilesystemPathInside(realRoot, realPath)) throw new Error(`[ultramodern-release-envelope] symbolic link ${logicalPath} resolves outside artifactRoot.`);
+            const targetStat = await promises_default().stat(realPath);
+            if (!targetStat.isFile() && !targetStat.isDirectory()) throw new Error(`[ultramodern-release-envelope] symbolic link ${logicalPath} must resolve to a file or directory.`);
+            const targetLogicalPath = external_node_path_default().relative(realRoot, realPath).split(external_node_path_default().sep).join('/');
+            if ('release' === targetLogicalPath || targetLogicalPath.startsWith('release/')) throw new Error(`[ultramodern-release-envelope] symbolic link ${logicalPath} targets private release metadata.`);
+            if (targetStat.isDirectory() && isFilesystemPathInside(realPath, await promises_default().realpath(external_node_path_default().dirname(lexicalPath)))) throw new Error(`[ultramodern-release-envelope] symbolic link ${logicalPath} targets an ancestor directory.`);
+            files.push(logicalPath);
+        }
+        return files;
+    };
+    return (await collectDirectory('')).sort();
+};
+const releaseArtifact = (logicalPath, runtime)=>({
+        logicalPath,
+        runtime
+    });
+const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
+    const files = await collectFiles(distDirectory);
+    if ('node' === target && files.some((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath))) throw new Error('[ultramodern-release-envelope] Node target conflicts with a Cloudflare Effect API/BFF worker artifact; resolve the canonical deploy target instead of emitting a Node envelope for Cloudflare output.');
+    const uiClientPaths = files.filter((logicalPath)=>{
+        const topLevel = logicalPath.split('/')[0];
+        return 'static' === topLevel || 'html' === topLevel || 'public' === topLevel || [
+            'index.html',
+            'mf-manifest.json',
+            'mf-stats.json',
+            'remoteEntry.js',
+            'routes-manifest.json',
+            'loadable-stats.json'
+        ].includes(logicalPath);
+    });
+    const ssrPaths = 'node' === target ? files.filter((logicalPath)=>logicalPath.startsWith('bundles/') && COMPILED_MODULE_PATTERN.test(logicalPath)) : files.filter((logicalPath)=>logicalPath.startsWith('worker/') && COMPILED_MODULE_PATTERN.test(logicalPath) && !EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
+    const nodeApiEntryPaths = files.filter((logicalPath)=>logicalPath.startsWith('api/') && COMPILED_MODULE_PATTERN.test(logicalPath));
+    const apiBackendPaths = 'node' === target ? files.filter((logicalPath)=>(logicalPath.startsWith('api/') || logicalPath.startsWith('shared/')) && COMPILED_MODULE_PATTERN.test(logicalPath)) : files.filter((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
+    if (0 === uiClientPaths.length) throw new Error(`[ultramodern-release-envelope] ${target} full-stack MicroVertical has no UI/client artifacts.`);
+    if (0 === ssrPaths.length) throw new Error(`[ultramodern-release-envelope] ${target} full-stack MicroVertical has no ${'node' === target ? 'Node' : 'workerd'} SSR artifacts.`);
+    if ('node' === target && 0 === nodeApiEntryPaths.length || 0 === apiBackendPaths.length) throw new Error(`[ultramodern-release-envelope] ${target} full-stack MicroVertical has no actual ${'node' === target ? 'compiled Node Effect API artifact' : 'Effect API/BFF worker artifact'}.`);
+    const clientExecutionPaths = await manifestReferencedClientModules(distDirectory, files);
+    if (0 === clientExecutionPaths.length) throw new Error('[ultramodern-release-envelope] UI/client manifest references no compiled execution module.');
+    const ssrExecutionPaths = await routeReferencedSsrModules(distDirectory, files, target);
+    await assertEveryCompiledIdentityCarrier(distDirectory, clientExecutionPaths, identity, 'manifest-referenced UI/client');
+    await assertEveryCompiledIdentityCarrier(distDirectory, ssrExecutionPaths, identity, 'node' === target ? 'route-referenced Node SSR' : 'route-referenced Cloudflare SSR');
+    await assertEveryCompiledIdentityCarrier(distDirectory, ssrPaths, identity, 'node' === target ? 'compiled Node SSR closure' : 'compiled Cloudflare SSR/workerd closure');
+    await assertEveryCompiledIdentityCarrier(distDirectory, 'node' === target ? nodeApiEntryPaths : apiBackendPaths, identity, 'node' === target ? 'Node API/backend' : 'Cloudflare API/backend');
+    await assertEveryCompiledIdentityCarrier(distDirectory, [
+        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+    ], identity, 'backend Module Federation container');
+    const runtimeByPath = new Map();
+    const add = (paths, runtime)=>{
+        for (const logicalPath of paths){
+            const existing = runtimeByPath.get(logicalPath);
+            if (existing && existing !== runtime) throw new Error(`[ultramodern-release-envelope] artifact "${logicalPath}" cannot carry conflicting runtimes "${existing}" and "${runtime}".`);
+            runtimeByPath.set(logicalPath, runtime);
+        }
+    };
+    add(uiClientPaths, 'browser');
+    add(ssrPaths, 'node' === target ? 'nodejs' : 'workerd');
+    add(apiBackendPaths, 'node' === target ? 'nodejs' : 'workerd-effect');
+    add([
+        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE
+    ], 'module-federation-manifest');
+    add([
+        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+    ], 'node' === target ? 'nodejs' : 'commonjs-module');
+    const surfaces = {
+        uiClient: [
+            ...uiClientPaths
+        ].sort((left, right)=>left.localeCompare(right)),
+        ssr: [
+            ...ssrPaths
+        ].sort((left, right)=>left.localeCompare(right)),
+        apiBackend: [
+            ...apiBackendPaths
+        ].sort((left, right)=>left.localeCompare(right)),
+        backendFederation: {
+            manifest: universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+            container: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        }
+    };
+    const artifacts = [
+        ...runtimeByPath
+    ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath));
+    return {
+        artifacts,
+        surfaces
+    };
+};
+const pathExists = async (filePath)=>{
+    try {
+        await promises_default().access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, target })=>{
+    if (apiOnly) return;
+    const backendManifestPath = external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE);
+    const backendContainerPath = external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
+    const [hasBackendManifest, hasBackendContainer] = await Promise.all([
+        pathExists(backendManifestPath),
+        pathExists(backendContainerPath)
+    ]);
+    if (!hasBackendManifest && !hasBackendContainer) return;
+    if (!hasBackendManifest || !hasBackendContainer) throw new Error('[ultramodern-release-envelope] full-stack MicroVertical backend federation manifest and container must be emitted together.');
+    const buildArtifact = await readBuildArtifact(distDirectory);
+    const identity = {
+        unitId: buildArtifact.deliveryUnit.unitId,
+        buildMarker: buildArtifact.deliveryUnit.buildMarker,
+        sourceRevision: buildArtifact.deliveryUnit.sourceRevision,
+        releaseVersion: buildArtifact.deliveryUnit.version
+    };
+    await readBackendManifest(distDirectory, identity);
+    const { artifacts, surfaces } = await createReleaseArtifactInputs(distDirectory, identity, target);
+    const envelope = await (0, external_index_js_namespaceObject.createMicroVerticalReleaseEnvelope)({
+        artifactRoot: distDirectory,
+        target,
+        identity,
+        artifacts,
+        surfaces
+    });
+    await writeReleaseEnvelope(distDirectory, envelope);
+    return envelope;
+};
+const readFrameworkMicroVerticalReleaseEnvelope = async ({ artifactRoot, expectedTarget, logicalPathForArtifact, required = false })=>{
+    const envelopePath = await resolveSafeReleaseEnvelopePath({
+        artifactRoot,
+        createDirectory: false
+    });
+    if (!envelopePath) {
+        if (required) throw new Error(`[ultramodern-release-envelope] required envelope is missing at ${MICROVERTICAL_RELEASE_ENVELOPE_PATH}.`);
+        return;
+    }
+    return (0, external_index_js_namespaceObject.verifyMicroVerticalReleaseEnvelope)(await readJson(envelopePath), {
+        artifactRoot,
+        ...expectedTarget ? {
+            expectedTarget
+        } : {},
+        ...logicalPathForArtifact ? {
+            logicalPathForArtifact
+        } : {}
+    });
+};
+const verifyBuildOutputReleaseEnvelope = async (distDirectory, expectedTarget)=>{
+    const [hasEnvelope, hasBuildArtifact, hasBackendManifest, hasBackendEntry] = await Promise.all([
+        pathExists(external_node_path_default().join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH)),
+        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE)),
+        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE)),
+        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE))
+    ]);
+    const isFullStackMicroVertical = hasBuildArtifact && (hasBackendManifest || hasBackendEntry);
+    return readFrameworkMicroVerticalReleaseEnvelope({
+        artifactRoot: distDirectory,
+        ...expectedTarget ? {
+            expectedTarget
+        } : {},
+        required: hasEnvelope || isFullStackMicroVertical
+    });
+};
+const verifyNodeReleaseEnvelopeStaging = async ({ outputDirectory })=>readFrameworkMicroVerticalReleaseEnvelope({
+        artifactRoot: outputDirectory,
+        expectedTarget: 'node',
+        required: true
+    });
+const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=>{
+    const files = await collectFiles(outputDirectory);
+    for (const requiredPath of [
+        'index.js',
+        'package.json',
+        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+    ])if (!files.includes(requiredPath)) throw new Error(`[ultramodern-release-envelope] final Node staging is missing ${requiredPath}.`);
+    const backendFederationPaths = new Set([
+        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+    ]);
+    const uiClientPaths = files.filter((logicalPath)=>{
+        const topLevel = logicalPath.split('/')[0];
+        return 'static' === topLevel || 'html' === topLevel || 'public' === topLevel || [
+            'index.html',
+            'mf-manifest.json',
+            'mf-stats.json',
+            'remoteEntry.js',
+            'routes-manifest.json',
+            'loadable-stats.json'
+        ].includes(logicalPath);
+    });
+    const ssrPaths = files.filter((logicalPath)=>'index.js' === logicalPath || logicalPath.startsWith('bundles/') && COMPILED_MODULE_PATTERN.test(logicalPath));
+    const apiBackendPaths = files.filter((logicalPath)=>(logicalPath.startsWith('api/') || logicalPath.startsWith('shared/')) && COMPILED_MODULE_PATTERN.test(logicalPath));
+    for (const [surface, paths] of [
+        [
+            'UI/client',
+            uiClientPaths
+        ],
+        [
+            'Node SSR',
+            ssrPaths
+        ],
+        [
+            'Node API/backend',
+            apiBackendPaths
+        ]
+    ])if (0 === paths.length) throw new Error(`[ultramodern-release-envelope] final Node staging has no ${surface} artifacts.`);
+    const clientExecutionPaths = await manifestReferencedClientModules(outputDirectory, files);
+    const ssrExecutionPaths = await routeReferencedSsrModules(outputDirectory, files, 'node');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, clientExecutionPaths, identity, 'final manifest-referenced Node UI/client');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrExecutionPaths, identity, 'final route-referenced Node SSR');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrPaths.filter((logicalPath)=>'index.js' !== logicalPath), identity, 'final compiled Node SSR closure');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, apiBackendPaths.filter((logicalPath)=>logicalPath.startsWith('api/')), identity, 'final Node API/backend');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, [
+        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+    ], identity, 'final Node backend Module Federation container');
+    const runtimeByPath = new Map(files.filter((logicalPath)=>!backendFederationPaths.has(logicalPath)).map((logicalPath)=>[
+            logicalPath,
+            'nodejs-deployment'
+        ]));
+    for (const logicalPath of uiClientPaths)runtimeByPath.set(logicalPath, 'browser');
+    for (const logicalPath of ssrPaths)runtimeByPath.set(logicalPath, 'nodejs');
+    for (const logicalPath of apiBackendPaths)runtimeByPath.set(logicalPath, 'nodejs');
+    runtimeByPath.set(universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE, 'module-federation-manifest');
+    runtimeByPath.set(universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE, 'nodejs');
+    return {
+        artifacts: [
+            ...runtimeByPath
+        ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
+        surfaces: {
+            uiClient: [
+                ...uiClientPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            ssr: [
+                ...ssrPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            apiBackend: [
+                ...apiBackendPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            backendFederation: {
+                manifest: universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+                container: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+            }
+        }
+    };
+};
+const emitNodeStagedReleaseEnvelope = async ({ distDirectory, outputDirectory })=>{
+    const source = await verifyBuildOutputReleaseEnvelope(distDirectory, 'node');
+    if (!source) return;
+    const { artifacts, surfaces } = await createNodeStagedReleaseArtifactInputs(outputDirectory, source.identity);
+    const staged = await (0, external_index_js_namespaceObject.createMicroVerticalReleaseEnvelope)({
+        artifactRoot: outputDirectory,
+        target: 'node',
+        identity: source.identity,
+        artifacts,
+        surfaces
+    });
+    await writeReleaseEnvelope(outputDirectory, staged);
+    return staged;
+};
+const stageCloudflareReleaseEnvelope = async ({ distDirectory, outputDirectory })=>{
+    const source = await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
+    if (!source) return;
+    const stagedEnvelopePath = external_node_path_default().join(outputDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH);
+    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)=>{
+    const files = await collectFiles(outputDirectory);
+    for (const requiredPath of [
+        'server/index.mjs',
+        'server/modern-worker-manifest.json',
+        'wrangler.json',
+        'package.json',
+        'worker/package.json'
+    ])if (!files.includes(requiredPath)) throw new Error(`[ultramodern-release-envelope] final Cloudflare staging is missing ${requiredPath}.`);
+    if (files.some((logicalPath)=>'public/release' === logicalPath || logicalPath.startsWith('public/release/'))) throw new Error('[ultramodern-release-envelope] final Cloudflare envelope must remain private and cannot be staged under public/release.');
+    const backendManifestPath = `public/${universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`;
+    const backendContainerPath = `public/${universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
+    const apiBackendPaths = files.filter((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
+    const ssrPaths = files.filter((logicalPath)=>(logicalPath.startsWith('server/') || logicalPath.startsWith('worker/')) && COMPILED_MODULE_PATTERN.test(logicalPath) && !EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
+    const uiClientPaths = files.filter((logicalPath)=>logicalPath.startsWith('public/') && logicalPath !== backendManifestPath && logicalPath !== backendContainerPath);
+    for (const [surface, paths] of [
+        [
+            'UI/client',
+            uiClientPaths
+        ],
+        [
+            'Cloudflare SSR',
+            ssrPaths
+        ],
+        [
+            'Cloudflare API/backend',
+            apiBackendPaths
+        ]
+    ])if (0 === paths.length) throw new Error(`[ultramodern-release-envelope] final Cloudflare staging has no ${surface} artifacts.`);
+    for (const logicalPath of [
+        backendManifestPath,
+        backendContainerPath
+    ])if (!files.includes(logicalPath)) throw new Error(`[ultramodern-release-envelope] final Cloudflare staging is missing ${logicalPath}.`);
+    const clientExecutionPaths = await manifestReferencedClientModules(outputDirectory, files, 'public/mf-manifest.json');
+    const ssrExecutionPaths = await routeReferencedSsrModules(outputDirectory, files, 'cloudflare', 'server/route.json');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, clientExecutionPaths, identity, 'final manifest-referenced Cloudflare UI/client');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrExecutionPaths, identity, 'final route-referenced Cloudflare SSR');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrPaths.filter((logicalPath)=>logicalPath.startsWith('worker/')), identity, 'final compiled Cloudflare SSR/workerd closure');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, apiBackendPaths, identity, 'final Cloudflare API/backend');
+    await assertEveryCompiledIdentityCarrier(outputDirectory, [
+        backendContainerPath
+    ], identity, 'final Cloudflare backend Module Federation container');
+    const runtimeByPath = new Map();
+    for (const logicalPath of files)runtimeByPath.set(logicalPath, 'cloudflare-deployment');
+    const add = (paths, runtime)=>{
+        for (const logicalPath of paths)runtimeByPath.set(logicalPath, runtime);
+    };
+    add(uiClientPaths, 'browser');
+    add(ssrPaths, 'workerd');
+    add(apiBackendPaths, 'workerd-effect');
+    add([
+        backendManifestPath
+    ], 'module-federation-manifest');
+    add([
+        backendContainerPath
+    ], 'commonjs-module');
+    return {
+        artifacts: [
+            ...runtimeByPath
+        ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
+        surfaces: {
+            uiClient: [
+                ...uiClientPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            ssr: [
+                ...ssrPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            apiBackend: [
+                ...apiBackendPaths
+            ].sort((left, right)=>left.localeCompare(right)),
+            backendFederation: {
+                manifest: backendManifestPath,
+                container: backendContainerPath
+            }
+        }
+    };
+};
+const emitCloudflareStagedReleaseEnvelope = async ({ distDirectory, outputDirectory })=>{
+    const source = await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
+    if (!source) return;
+    const { artifacts, surfaces } = await createCloudflareStagedReleaseArtifactInputs(outputDirectory, source.identity);
+    const staged = await (0, external_index_js_namespaceObject.createMicroVerticalReleaseEnvelope)({
+        artifactRoot: outputDirectory,
+        target: 'cloudflare',
+        identity: source.identity,
+        artifacts,
+        surfaces
+    });
+    await writeReleaseEnvelope(outputDirectory, staged);
+    return staged;
+};
+const verifyCloudflareReleaseEnvelopeStaging = async (outputDirectory)=>readFrameworkMicroVerticalReleaseEnvelope({
+        artifactRoot: outputDirectory,
+        expectedTarget: 'cloudflare',
+        required: true
+    });
+exports.MICROVERTICAL_RELEASE_ENVELOPE_PATH = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_PATH;
+exports.emitCloudflareStagedReleaseEnvelope = __webpack_exports__.emitCloudflareStagedReleaseEnvelope;
+exports.emitFrameworkMicroVerticalReleaseEnvelope = __webpack_exports__.emitFrameworkMicroVerticalReleaseEnvelope;
+exports.emitNodeStagedReleaseEnvelope = __webpack_exports__.emitNodeStagedReleaseEnvelope;
+exports.readFrameworkMicroVerticalReleaseEnvelope = __webpack_exports__.readFrameworkMicroVerticalReleaseEnvelope;
+exports.stageCloudflareReleaseEnvelope = __webpack_exports__.stageCloudflareReleaseEnvelope;
+exports.verifyBuildOutputReleaseEnvelope = __webpack_exports__.verifyBuildOutputReleaseEnvelope;
+exports.verifyCloudflareReleaseEnvelopeStaging = __webpack_exports__.verifyCloudflareReleaseEnvelopeStaging;
+exports.verifyNodeReleaseEnvelopeStaging = __webpack_exports__.verifyNodeReleaseEnvelopeStaging;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MICROVERTICAL_RELEASE_ENVELOPE_PATH",
+    "emitCloudflareStagedReleaseEnvelope",
+    "emitFrameworkMicroVerticalReleaseEnvelope",
+    "emitNodeStagedReleaseEnvelope",
+    "readFrameworkMicroVerticalReleaseEnvelope",
+    "stageCloudflareReleaseEnvelope",
+    "verifyBuildOutputReleaseEnvelope",
+    "verifyCloudflareReleaseEnvelopeStaging",
+    "verifyNodeReleaseEnvelopeStaging"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});