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

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

@@ -40,6 +40,7 @@ __webpack_require__.d(__webpack_exports__, {
     MICROVERTICAL_RELEASE_ENVELOPE_KIND: ()=>external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND,
     MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: ()=>external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
     MICROVERTICAL_RELEASE_TARGETS: ()=>external_types_js_namespaceObject.MICROVERTICAL_RELEASE_TARGETS,
+    SHELL_RELEASE_ENVELOPE_KIND: ()=>external_types_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND,
     canonicalSerializeMicroVerticalReleaseEnvelope: ()=>external_canonical_js_namespaceObject.canonicalSerializeMicroVerticalReleaseEnvelope,
     createMicroVerticalReleaseEnvelope: ()=>createMicroVerticalReleaseEnvelope,
     verifyMicroVerticalReleaseEnvelope: ()=>verifyMicroVerticalReleaseEnvelope
@@ -49,6 +50,7 @@ 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 backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_canonical_js_namespaceObject = require("./canonical.js");
 const external_types_js_namespaceObject = require("./types.js");
 const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
@@ -74,6 +76,10 @@ const assertTarget = (value, location = 'target')=>{
     if (!TARGETS.has(target)) throw new Error(`${location} must be one of: ${external_types_js_namespaceObject.MICROVERTICAL_RELEASE_TARGETS.join(', ')}.`);
     return target;
 };
+const assertEnvelopeKind = (value)=>{
+    if (value !== external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND && value !== external_types_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND) throw new Error(`envelope.kind must be "${external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND}" or "${external_types_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND}".`);
+    return value;
+};
 const assertReleaseIdentity = (value, location = 'identity')=>{
     const identity = assertRecord(value, location);
     assertExactKeys(identity, [
@@ -232,7 +238,7 @@ const assertUniqueSortedArtifacts = (artifacts, location)=>{
     if (paths.some((logicalPath, index)=>logicalPath !== sorted[index])) throw new Error(`${location} must be sorted by logicalPath.`);
 };
 const assertSurfacePaths = (value, location)=>{
-    if (!Array.isArray(value) || 0 === value.length) throw new Error(`${location} must contain at least one artifact path.`);
+    if (!Array.isArray(value)) throw new Error(`${location} must be an array of artifact paths.`);
     const paths = value.map((item, index)=>assertNormalizedLogicalPath(item, `${location}[${index}]`));
     const sorted = [
         ...paths
@@ -241,26 +247,51 @@ const assertSurfacePaths = (value, location)=>{
     if (new Set(paths).size !== paths.length) throw new Error(`${location} must not contain duplicate artifact paths.`);
     return paths;
 };
-const assertSurfaces = (value)=>{
+const assertSurfaces = (value, kind)=>{
     const surfaces = assertRecord(value, 'surfaces');
     assertExactKeys(surfaces, [
         'uiClient',
         'ssr',
         'apiBackend',
-        'backendFederation'
+        ...kind !== external_types_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND && Object.hasOwn(surfaces, 'backendFederation') ? [
+            'backendFederation'
+        ] : []
     ], 'surfaces');
-    const backendFederation = assertRecord(surfaces.backendFederation, 'surfaces.backendFederation');
-    assertExactKeys(backendFederation, [
+    const backendFederation = Object.hasOwn(surfaces, 'backendFederation') ? assertRecord(surfaces.backendFederation, 'surfaces.backendFederation') : void 0;
+    if (backendFederation) assertExactKeys(backendFederation, [
         'manifest',
         'container'
     ], 'surfaces.backendFederation');
+    const uiClient = assertSurfacePaths(surfaces.uiClient, 'surfaces.uiClient');
+    const ssr = assertSurfacePaths(surfaces.ssr, 'surfaces.ssr');
+    const apiBackend = assertSurfacePaths(surfaces.apiBackend, 'surfaces.apiBackend');
+    if (uiClient.length > 0 && 0 === ssr.length) throw new Error('surfaces.ssr must contain at least one artifact path when UI/client is declared.');
+    if (ssr.length > 0 && 0 === uiClient.length) throw new Error('surfaces.uiClient must contain at least one artifact path when SSR is declared.');
+    if (0 === apiBackend.length && (backendFederation || 0 === uiClient.length)) throw new Error('surfaces.apiBackend must contain at least one artifact path.');
+    if (kind === external_types_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND) {
+        if (0 === uiClient.length || 0 === ssr.length) throw new Error('Shell surfaces.uiClient and surfaces.ssr must each contain at least one artifact path.');
+        return {
+            kind,
+            surfaces: {
+                uiClient,
+                ssr,
+                apiBackend
+            }
+        };
+    }
+    if (apiBackend.length > 0 && !backendFederation) throw new Error('surfaces.backendFederation is required when API/backend is declared.');
     return {
-        uiClient: assertSurfacePaths(surfaces.uiClient, 'surfaces.uiClient'),
-        ssr: assertSurfacePaths(surfaces.ssr, 'surfaces.ssr'),
-        apiBackend: assertSurfacePaths(surfaces.apiBackend, 'surfaces.apiBackend'),
-        backendFederation: {
-            manifest: assertNormalizedLogicalPath(backendFederation.manifest, 'surfaces.backendFederation.manifest'),
-            container: assertNormalizedLogicalPath(backendFederation.container, 'surfaces.backendFederation.container')
+        kind,
+        surfaces: {
+            uiClient,
+            ssr,
+            apiBackend,
+            ...backendFederation ? {
+                backendFederation: {
+                    manifest: assertNormalizedLogicalPath(backendFederation.manifest, 'surfaces.backendFederation.manifest'),
+                    container: assertNormalizedLogicalPath(backendFederation.container, 'surfaces.backendFederation.container')
+                }
+            } : {}
         }
     };
 };
@@ -270,12 +301,14 @@ const assertSurfaceReferences = (artifacts, surfaces)=>{
         uiClient: surfaces.uiClient,
         ssr: surfaces.ssr,
         apiBackend: surfaces.apiBackend,
-        'backendFederation.manifest': [
-            surfaces.backendFederation.manifest
-        ],
-        'backendFederation.container': [
-            surfaces.backendFederation.container
-        ]
+        ...'backendFederation' in surfaces && surfaces.backendFederation ? {
+            'backendFederation.manifest': [
+                surfaces.backendFederation.manifest
+            ],
+            'backendFederation.container': [
+                surfaces.backendFederation.container
+            ]
+        } : {}
     }))for (const logicalPath of paths)if (!artifactPaths.has(logicalPath)) throw new Error(`surfaces.${surface} references unbound artifact "${logicalPath}".`);
 };
 const assertTargetSurfaceContract = (target, artifacts, surfaces)=>{
@@ -293,12 +326,14 @@ const assertTargetSurfaceContract = (target, artifacts, surfaces)=>{
     assertRuntime(surfaces.uiClient, 'browser', 'UI/client');
     assertRuntime(surfaces.ssr, 'node' === target ? 'nodejs' : 'workerd', 'SSR');
     assertRuntime(surfaces.apiBackend, 'node' === target ? 'nodejs' : 'workerd-effect', 'API/backend');
-    assertRuntime([
-        surfaces.backendFederation.manifest
-    ], 'module-federation-manifest', 'backend federation manifest');
-    assertRuntime([
-        surfaces.backendFederation.container
-    ], 'node' === target ? 'nodejs' : 'commonjs-module', 'backend federation container');
+    if ('backendFederation' in surfaces && surfaces.backendFederation) {
+        assertRuntime([
+            surfaces.backendFederation.manifest
+        ], 'module-federation-manifest', 'backend federation manifest');
+        assertRuntime([
+            surfaces.backendFederation.container
+        ], 'node' === target ? 'nodejs' : 'commonjs-module', 'backend federation container');
+    }
 };
 const deepFreeze = (value)=>{
     if (null !== value && 'object' == typeof value && !Object.isFrozen(value)) {
@@ -307,6 +342,51 @@ const deepFreeze = (value)=>{
     }
     return value;
 };
+const assertReleaseUi = (value, identity, surfaces)=>{
+    if (0 === surfaces.uiClient.length) {
+        if (void 0 !== value) throw new Error('envelope.ui is forbidden for an API-only release.');
+        return;
+    }
+    const ui = assertRecord(value, 'envelope.ui');
+    assertExactKeys(ui, [
+        'rendererIdentity',
+        'rendererProfile',
+        'routerBindings'
+    ], 'envelope.ui');
+    const routerBindings = assertRecord(ui.routerBindings, 'envelope.ui.routerBindings');
+    const errors = [
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(ui.rendererIdentity, 'envelope.ui.rendererIdentity').errors,
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererProfile)(ui.rendererProfile, 'envelope.ui.rendererProfile').errors,
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererRouterBindings)(routerBindings, Object.keys(routerBindings), 'envelope.ui.routerBindings').errors
+    ];
+    if (errors.length > 0) throw new Error((0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(errors));
+    const rendererIdentity = ui.rendererIdentity;
+    const rendererProfile = ui.rendererProfile;
+    if (!Object.hasOwn(routerBindings, rendererIdentity.entryName)) throw new Error('envelope.ui.routerBindings must include the primary rendererIdentity.entryName.');
+    if (rendererIdentity.buildId !== identity.buildMarker) throw new Error('envelope.ui.rendererIdentity.buildId must match identity.buildMarker.');
+    for (const field of [
+        'renderer',
+        'protocolVersion'
+    ])if (rendererIdentity[field] !== rendererProfile[field]) throw new Error(`envelope.ui.rendererProfile.${field} must match rendererIdentity.${field}.`);
+    return {
+        rendererIdentity: {
+            ...rendererIdentity
+        },
+        rendererProfile: {
+            ...rendererProfile,
+            compiler: {
+                ...rendererProfile.compiler
+            },
+            hydration: {
+                ...rendererProfile.hydration
+            },
+            router: {
+                ...rendererProfile.router
+            }
+        },
+        routerBindings: (0, backend_federation_contracts_namespaceObject.immutableRendererRouterBindings)(routerBindings)
+    };
+};
 const assertEnvelope = (value)=>{
     const envelope = assertRecord(value, 'envelope');
     assertExactKeys(envelope, [
@@ -314,26 +394,35 @@ const assertEnvelope = (value)=>{
         'kind',
         'target',
         'identity',
+        ...Object.hasOwn(envelope, 'ui') ? [
+            'ui'
+        ] : [],
         'artifacts',
         'surfaces',
         'envelopeDigest'
     ], 'envelope');
     if (envelope.schemaVersion !== external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION) throw new Error(`envelope.schemaVersion must be ${external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION}.`);
-    if (envelope.kind !== external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND) throw new Error(`envelope.kind must be "${external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND}".`);
+    const kind = assertEnvelopeKind(envelope.kind);
     if (!Array.isArray(envelope.artifacts) || 0 === envelope.artifacts.length) throw new Error('envelope.artifacts must contain at least one artifact.');
     const artifacts = envelope.artifacts.map((artifact, index)=>assertReleaseArtifact(artifact, `envelope.artifacts[${index}]`));
     assertUniqueSortedArtifacts(artifacts, 'envelope.artifacts');
     const target = assertTarget(envelope.target, 'envelope.target');
-    const surfaces = assertSurfaces(envelope.surfaces);
+    const releaseSurfaces = assertSurfaces(envelope.surfaces, kind);
+    const { surfaces } = releaseSurfaces;
+    if (0 === surfaces.uiClient.length && Object.hasOwn(envelope, 'ui')) throw new Error('envelope.ui is forbidden for an API-only release.');
     assertSurfaceReferences(artifacts, surfaces);
     assertTargetSurfaceContract(target, artifacts, surfaces);
+    const identity = assertReleaseIdentity(envelope.identity, 'envelope.identity');
+    const ui = assertReleaseUi(envelope.ui, identity, surfaces);
     const parsed = {
+        ...releaseSurfaces,
         schemaVersion: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
-        kind: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND,
         target,
-        identity: assertReleaseIdentity(envelope.identity, 'envelope.identity'),
+        identity,
+        ...ui ? {
+            ui
+        } : {},
         artifacts,
-        surfaces,
         envelopeDigest: assertNonEmptyString(envelope.envelopeDigest, 'envelope.envelopeDigest')
     };
     if (!SHA256_PATTERN.test(parsed.envelopeDigest)) throw new Error('envelope.envelopeDigest must be a lowercase SHA-256 digest.');
@@ -341,36 +430,59 @@ const assertEnvelope = (value)=>{
     if (parsed.envelopeDigest !== expectedDigest) throw new Error('envelope.envelopeDigest does not match canonical payload.');
     return parsed;
 };
-const createMicroVerticalReleaseEnvelope = async (input)=>{
+async function createMicroVerticalReleaseEnvelope(input) {
     const artifactRoot = await promises_default().realpath(external_node_path_default().resolve(input.artifactRoot));
     const target = assertTarget(input.target);
     const identity = assertReleaseIdentity(input.identity);
+    const kind = assertEnvelopeKind(void 0 === input.kind ? external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND : input.kind);
     if (!Array.isArray(input.artifacts) || 0 === input.artifacts.length) throw new Error('artifacts must contain at least one artifact.');
     const inputs = input.artifacts.map((artifact, index)=>assertArtifactInput(artifact, `artifacts[${index}]`));
     const sortedInputs = [
         ...inputs
     ].sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath));
     assertUniqueSortedArtifacts(sortedInputs, 'artifacts');
-    const surfaces = assertSurfaces(input.surfaces);
+    const releaseSurfaces = assertSurfaces(input.surfaces, kind);
+    const { surfaces } = releaseSurfaces;
+    if (0 === surfaces.uiClient.length && Object.hasOwn(input, 'ui')) throw new Error('envelope.ui is forbidden for an API-only release.');
     assertSurfaceReferences(sortedInputs, surfaces);
     assertTargetSurfaceContract(target, sortedInputs, surfaces);
+    const ui = assertReleaseUi(input.ui, identity, surfaces);
     const artifacts = await Promise.all(sortedInputs.map((artifact)=>readFinalArtifact(artifactRoot, artifact)));
     assertTargetSurfaceContract(target, artifacts, surfaces);
     const payload = {
+        ...releaseSurfaces,
         schemaVersion: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
-        kind: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND,
         target,
         identity,
-        artifacts,
-        surfaces
+        ...ui ? {
+            ui
+        } : {},
+        artifacts
     };
     return deepFreeze({
         ...payload,
         envelopeDigest: (0, external_canonical_js_namespaceObject.digestMicroVerticalReleaseEnvelopePayload)(payload)
     });
-};
-const verifyMicroVerticalReleaseEnvelope = async (value, options)=>{
+}
+async function verifyMicroVerticalReleaseEnvelope(value, options) {
     const envelope = assertEnvelope(value);
+    if (void 0 !== options.expectedRendererProfile) {
+        const result = (0, backend_federation_contracts_namespaceObject.validateRendererProfileCompatibility)(options.expectedRendererProfile, envelope.ui?.rendererProfile, 'envelope.ui.rendererProfile');
+        if (!result.ok) throw new Error((0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(result.errors));
+    }
+    if (void 0 !== options.expectedRendererIdentity) {
+        const expected = options.expectedRendererIdentity;
+        const result = (0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(expected, 'expectedRendererIdentity');
+        if (!result.ok) throw new Error((0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(result.errors));
+        for (const field of [
+            'renderer',
+            'protocolVersion',
+            'appId',
+            'entryName',
+            'buildId'
+        ])if (envelope.ui?.rendererIdentity[field] !== expected[field]) throw new Error(`envelope.ui.rendererIdentity.${field} must match the consuming renderer identity.`);
+    }
+    if (void 0 !== options.expectedKind && envelope.kind !== options.expectedKind) throw new Error(`envelope.kind must be "${options.expectedKind}" for this release owner; received "${envelope.kind}".`);
     if (void 0 !== options.expectedTarget && envelope.target !== options.expectedTarget) throw new Error(`envelope.target must be "${options.expectedTarget}" for this staging target; received "${envelope.target}".`);
     const artifactRoot = await promises_default().realpath(external_node_path_default().resolve(options.artifactRoot));
     for (const artifact of envelope.artifacts){
@@ -379,10 +491,11 @@ const verifyMicroVerticalReleaseEnvelope = async (value, options)=>{
         if (!matches) throw new Error('file' === artifact.kind && 'file' === finalArtifact.kind ? `Artifact "${artifact.logicalPath}" digest does not match final artifact bytes.` : `Artifact "${artifact.logicalPath}" does not match its final filesystem binding.`);
     }
     return deepFreeze(envelope);
-};
+}
 exports.MICROVERTICAL_RELEASE_ENVELOPE_KIND = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_KIND;
 exports.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION;
 exports.MICROVERTICAL_RELEASE_TARGETS = __webpack_exports__.MICROVERTICAL_RELEASE_TARGETS;
+exports.SHELL_RELEASE_ENVELOPE_KIND = __webpack_exports__.SHELL_RELEASE_ENVELOPE_KIND;
 exports.canonicalSerializeMicroVerticalReleaseEnvelope = __webpack_exports__.canonicalSerializeMicroVerticalReleaseEnvelope;
 exports.createMicroVerticalReleaseEnvelope = __webpack_exports__.createMicroVerticalReleaseEnvelope;
 exports.verifyMicroVerticalReleaseEnvelope = __webpack_exports__.verifyMicroVerticalReleaseEnvelope;
@@ -390,6 +503,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MICROVERTICAL_RELEASE_ENVELOPE_KIND",
     "MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION",
     "MICROVERTICAL_RELEASE_TARGETS",
+    "SHELL_RELEASE_ENVELOPE_KIND",
     "canonicalSerializeMicroVerticalReleaseEnvelope",
     "createMicroVerticalReleaseEnvelope",
     "verifyMicroVerticalReleaseEnvelope"

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

@@ -41,50 +41,59 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const public_assets_js_namespaceObject = require("../deploy-output/public-assets.js");
+const target_js_namespaceObject = require("../deploy-output/target.js");
 const external_framework_output_js_namespaceObject = require("./framework-output.js");
-const resolveActiveDeployTarget = (api, resolveDeployTarget)=>{
-    const { metaName } = api.getAppContext();
-    const config = api.getNormalizedConfig();
-    if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
-    return resolveDeployTarget(config);
-};
-const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
+const createUltramodernReleaseEnvelopePlugin = ({ resolveRendererProfile } = {})=>({
         name: '@modern-js/ultramodern-release-envelope',
         pre: [
             '@modern-js/backend-federation-build',
             '@modern-js/plugin-bff',
-            '@modern-js/deploy-output-aliases'
+            '@modern-js/deploy-output-aliases',
+            '@modern-js/deploy-output-public-assets'
         ],
         post: [
             '@modern-js/plugin-deploy'
         ],
         setup (api) {
-            const emitBuildEnvelope = async (target)=>{
-                const { apiOnly, distDirectory } = api.getAppContext();
+            const emitBuildEnvelope = async (target, requirePromotable = true)=>{
+                const { apiOnly, appDirectory, distDirectory } = api.getAppContext();
                 await (0, external_framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
                     apiOnly,
+                    appDirectory,
                     distDirectory,
-                    target
+                    role: api.getNormalizedConfig().deploy?.releaseEnvelopeRole,
+                    requirePromotable,
+                    target,
+                    ...!apiOnly && resolveRendererProfile ? {
+                        expectedRendererProfile: resolveRendererProfile(api.getNormalizedConfig())
+                    } : {}
                 });
             };
             api.onAfterBuild(async ()=>{
-                const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
+                const configuredTarget = api.getAppContext().deployTarget?.target;
                 if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
+                await emitBuildEnvelope(configuredTarget, false);
             });
             api.onBeforeDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api, resolveDeployTarget);
+                const configuredTarget = (0, target_js_namespaceObject.getDeployingTarget)(api.getAppContext());
                 if ('node' !== configuredTarget) return;
                 await emitBuildEnvelope(configuredTarget);
                 const { distDirectory } = api.getAppContext();
                 await (0, external_framework_output_js_namespaceObject.verifyBuildOutputReleaseEnvelope)(distDirectory, configuredTarget);
             });
             api.onAfterDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api, resolveDeployTarget);
+                const configuredTarget = (0, target_js_namespaceObject.getDeployingTarget)(api.getAppContext());
                 if ('node' !== configuredTarget) return;
                 const { appDirectory, distDirectory } = api.getAppContext();
                 const outputDirectory = external_node_path_default().join(appDirectory, '.output');
                 const releaseEnvelope = await (0, external_framework_output_js_namespaceObject.emitNodeStagedReleaseEnvelope)({
+                    declaredPublicAssets: await (0, public_assets_js_namespaceObject.resolveAddedDeclaredPublicAssetPaths)({
+                        appDirectory,
+                        assets: (0, public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(api.getNormalizedConfig().deploy?.node?.publicAssets, public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE),
+                        generatedRoot: distDirectory,
+                        scope: public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE
+                    }),
                     distDirectory,
                     outputDirectory
                 });

package/dist/cjs/release-envelope/renderer-output-stamp.js

@@ -0,0 +1,170 @@
+"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__, {
+    emitRendererBuildArtifact: ()=>emitRendererBuildArtifact,
+    rendererBuildArtifactStampPlugin: ()=>rendererBuildArtifactStampPlugin,
+    stampFinalizedRendererBuildArtifact: ()=>stampFinalizedRendererBuildArtifact,
+    validateFinalizedRendererBuild: ()=>validateFinalizedRendererBuild
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+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 external_node_util_namespaceObject = require("node:util");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
+const validateFinalizedRendererBuild = (output, context, appId)=>{
+    const entryNames = context.entrypoints.map((entry)=>entry.entryName);
+    const primary = context.entrypoints.find((entry)=>entry.isMainEntry) ?? context.entrypoints[0];
+    const errors = [
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(output.ui.rendererIdentity).errors,
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererProfile)(output.ui.rendererProfile).errors,
+        ...(0, backend_federation_contracts_namespaceObject.validateRendererRouterBindings)(output.ui.routerBindings, entryNames, 'routerBindings').errors
+    ];
+    if (errors.length) throw new Error((0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(errors));
+    if (!primary || new Set(entryNames).size !== entryNames.length || context.entrypoints.filter((entry)=>entry.isMainEntry).length > 1 || output.ui.rendererIdentity.entryName !== primary.entryName || output.ui.rendererIdentity.appId !== appId || output.ui.rendererIdentity.buildId !== output.buildMarker || output.ui.rendererIdentity.renderer !== output.ui.rendererProfile.renderer) throw new Error('Finalized renderer output conflicts with the actual application entries and release identity.');
+};
+const stampFinalizedRendererBuildArtifact = (artifact, output, context)=>{
+    (0, backend_federation_contracts_namespaceObject.assertUltramodernBuildArtifact)(artifact);
+    const ui = artifact.surfaces.ui;
+    if (!ui) throw new Error('Finalized renderer output requires a declared UI artifact');
+    validateFinalizedRendererBuild(output, context, artifact.deliveryUnit.appId);
+    const drifted = [
+        !(0, external_node_util_namespaceObject.isDeepStrictEqual)({
+            ...ui.rendererIdentity,
+            buildId: output.ui.rendererIdentity.buildId
+        }, output.ui.rendererIdentity) && `rendererIdentity (captured entry ${ui.rendererIdentity.entryName}, built entry ${output.ui.rendererIdentity.entryName})`,
+        !(0, external_node_util_namespaceObject.isDeepStrictEqual)(ui.rendererProfile, output.ui.rendererProfile) && 'rendererProfile',
+        !(0, external_node_util_namespaceObject.isDeepStrictEqual)(ui.routerBindings, output.ui.routerBindings) && `routerBindings (captured entries ${Object.keys(ui.routerBindings).join(', ')}, built entries ${Object.keys(output.ui.routerBindings).join(', ')})`
+    ].filter(Boolean);
+    if (drifted.length) throw new Error(`Finalized renderer output conflicts with the captured application profile or router bindings: ${drifted.join('; ')} differ from ${backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH}. After changing modern.config entries, renderer or router, recapture it with \`ultramodern-create ultramodern sync-delivery-unit\`.`);
+    const identity = {
+        buildMarker: output.buildMarker,
+        sourceRevision: output.sourceRevision
+    };
+    const stamped = (0, backend_federation_contracts_namespaceObject.stampUltramodernBuildArtifactIdentity)(artifact, identity);
+    return (0, backend_federation_contracts_namespaceObject.stampUltramodernBuildArtifactIdentity)({
+        ...stamped,
+        surfaces: {
+            ...stamped.surfaces,
+            ui: {
+                ...stamped.surfaces.ui,
+                ...output.ui
+            }
+        }
+    }, identity);
+};
+async function writeOwnedArtifact(file, bytes) {
+    await promises_default().mkdir(external_node_path_default().dirname(file), {
+        recursive: true
+    });
+    const temporary = `${file}.${(0, external_node_crypto_namespaceObject.randomUUID)()}.tmp`;
+    let created = false;
+    try {
+        const handle = await promises_default().open(temporary, 'wx');
+        created = true;
+        try {
+            await handle.writeFile(bytes);
+        } finally{
+            await handle.close();
+        }
+        await promises_default().rename(temporary, file);
+    } finally{
+        if (created) await promises_default().rm(temporary, {
+            force: true
+        });
+    }
+}
+async function emitRendererBuildArtifact(context, options) {
+    const source = external_node_path_default().join(context.appDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
+    const bytes = await promises_default().readFile(source).catch((error)=>{
+        if ('ENOENT' === error.code) return;
+        throw error;
+    });
+    if (!bytes) {
+        const declaration = await promises_default().stat(source.replace(/\.json$/u, '.ts')).catch((error)=>{
+            if ('ENOENT' === error.code) return;
+            throw error;
+        });
+        if (declaration) throw new Error('Generated UI artifact declaration is missing its build carrier');
+        return;
+    }
+    const artifact = JSON.parse(bytes.toString('utf8'));
+    (0, backend_federation_contracts_namespaceObject.assertUltramodernBuildArtifact)(artifact);
+    const finalized = await options.resolveRendererBuild(context);
+    const stamped = stampFinalizedRendererBuildArtifact(artifact, finalized, context);
+    const serialized = `${JSON.stringify(stamped, null, 2)}\n`;
+    for (const directory of [
+        context.distDirectory,
+        external_node_path_default().join(context.distDirectory, 'public')
+    ])await writeOwnedArtifact(external_node_path_default().join(directory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE), serialized);
+    return stamped;
+}
+function rendererBuildArtifactStampPlugin(options) {
+    if ('string' != typeof options.rendererBuildPlugin || !options.rendererBuildPlugin || options.rendererBuildPlugin.trim() !== options.rendererBuildPlugin || 'function' != typeof options.resolveRendererBuild) throw new Error('Renderer artifact stamping requires its owning metadata producer');
+    return {
+        name: '@modern-js/renderer-build-artifact-stamp',
+        pre: [
+            options.rendererBuildPlugin
+        ],
+        required: [
+            options.rendererBuildPlugin
+        ],
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const context = api.getAppContext();
+                if (context.apiOnly) return;
+                await emitRendererBuildArtifact(context, options);
+            });
+        }
+    };
+}
+exports.emitRendererBuildArtifact = __webpack_exports__.emitRendererBuildArtifact;
+exports.rendererBuildArtifactStampPlugin = __webpack_exports__.rendererBuildArtifactStampPlugin;
+exports.stampFinalizedRendererBuildArtifact = __webpack_exports__.stampFinalizedRendererBuildArtifact;
+exports.validateFinalizedRendererBuild = __webpack_exports__.validateFinalizedRendererBuild;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "emitRendererBuildArtifact",
+    "rendererBuildArtifactStampPlugin",
+    "stampFinalizedRendererBuildArtifact",
+    "validateFinalizedRendererBuild"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -27,24 +27,26 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = 3;
-const MICROVERTICAL_RELEASE_ENVELOPE_KIND = 'ultramodern-target-microvertical-release-envelope';
+__webpack_require__.d(__webpack_exports__, {
+    MICROVERTICAL_RELEASE_ENVELOPE_KIND: ()=>external_contract_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND,
+    MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: ()=>external_contract_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
+    MICROVERTICAL_RELEASE_TARGETS: ()=>MICROVERTICAL_RELEASE_TARGETS,
+    SHELL_RELEASE_ENVELOPE_KIND: ()=>external_contract_js_namespaceObject.SHELL_RELEASE_ENVELOPE_KIND
+});
+const external_contract_js_namespaceObject = require("./contract.js");
 const MICROVERTICAL_RELEASE_TARGETS = [
     'node',
     'cloudflare'
 ];
-__webpack_require__.d(__webpack_exports__, {}, {
-    MICROVERTICAL_RELEASE_ENVELOPE_KIND: MICROVERTICAL_RELEASE_ENVELOPE_KIND,
-    MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
-    MICROVERTICAL_RELEASE_TARGETS: MICROVERTICAL_RELEASE_TARGETS
-});
 exports.MICROVERTICAL_RELEASE_ENVELOPE_KIND = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_KIND;
 exports.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION;
 exports.MICROVERTICAL_RELEASE_TARGETS = __webpack_exports__.MICROVERTICAL_RELEASE_TARGETS;
+exports.SHELL_RELEASE_ENVELOPE_KIND = __webpack_exports__.SHELL_RELEASE_ENVELOPE_KIND;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MICROVERTICAL_RELEASE_ENVELOPE_KIND",
     "MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION",
-    "MICROVERTICAL_RELEASE_TARGETS"
+    "MICROVERTICAL_RELEASE_TARGETS",
+    "SHELL_RELEASE_ENVELOPE_KIND"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/release-identity.js

@@ -34,13 +34,16 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
 const external_node_crypto_namespaceObject = require("node:crypto");
+const invokeGit = external_node_child_process_namespaceObject.execFileSync;
 const BUILD_MARKER_NAMESPACE = 'ultramodern-delivery-unit-release-build-marker:v1';
 const PROMOTABLE_SOURCE_REVISION_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
+const workspaceGitEnv = ()=>Object.fromEntries(Object.entries(process.env).filter(([name])=>!name.toUpperCase().startsWith('GIT_')));
 const gitOutput = (workspaceRoot, args)=>{
     try {
-        return (0, external_node_child_process_namespaceObject.execFileSync)('git', args, {
+        return invokeGit('git', args, {
             cwd: workspaceRoot,
             encoding: 'utf8',
+            env: workspaceGitEnv(),
             stdio: [
                 'ignore',
                 'pipe',
@@ -52,9 +55,9 @@ const gitOutput = (workspaceRoot, args)=>{
     }
 };
 const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(`${BUILD_MARKER_NAMESPACE}:${unitId}:${generationBuildMarker}:${sourceRevision}`).digest('hex').slice(0, 16);
-const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configuredSourceRevision)=>{
+const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configuredSourceRevision, environment = process.env)=>{
     const configuredArgumentValue = configuredSourceRevision?.trim();
-    const configuredEnvironmentValue = process.env.ULTRAMODERN_SOURCE_REVISION?.trim();
+    const configuredEnvironmentValue = environment.ULTRAMODERN_SOURCE_REVISION?.trim();
     const configuredArgument = configuredArgumentValue && 'workspace' !== configuredArgumentValue ? configuredArgumentValue : void 0;
     const configuredEnvironment = configuredEnvironmentValue && 'workspace' !== configuredEnvironmentValue ? configuredEnvironmentValue : void 0;
     if (configuredArgument && configuredEnvironment && configuredArgument !== configuredEnvironment) throw new Error(`Configured source revision ${configuredArgument} does not match environment source revision ${configuredEnvironment}.`);
@@ -82,9 +85,9 @@ const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configu
     if (configured && configured !== revision) throw new Error(`Configured source revision ${configured} does not match clean Git HEAD ${revision}.`);
     return revision;
 };
-const resolveUltramodernReleaseIdentity = ({ generationBuildMarker, sourceRevision: configuredSourceRevision, unitId, workspaceRoot })=>{
+const resolveUltramodernReleaseIdentity = ({ generationBuildMarker, sourceRevision: configuredSourceRevision, unitId, workspaceRoot, environment })=>{
     const explicitSourceRevision = configuredSourceRevision?.trim();
-    const sourceRevision = resolveUltramodernSourceRevision(workspaceRoot, explicitSourceRevision);
+    const sourceRevision = resolveUltramodernSourceRevision(workspaceRoot, explicitSourceRevision, environment);
     return {
         buildMarker: 'workspace' === sourceRevision ? generationBuildMarker : createUltramodernReleaseBuildMarker({
             generationBuildMarker,