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

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

@@ -0,0 +1,399 @@
+"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_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,
+    canonicalSerializeMicroVerticalReleaseEnvelope: ()=>external_canonical_js_namespaceObject.canonicalSerializeMicroVerticalReleaseEnvelope,
+    createMicroVerticalReleaseEnvelope: ()=>createMicroVerticalReleaseEnvelope,
+    verifyMicroVerticalReleaseEnvelope: ()=>verifyMicroVerticalReleaseEnvelope
+});
+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_canonical_js_namespaceObject = require("./canonical.js");
+const external_types_js_namespaceObject = require("./types.js");
+const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+const SOURCE_REVISION_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
+const TARGETS = new Set(external_types_js_namespaceObject.MICROVERTICAL_RELEASE_TARGETS);
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const assertRecord = (value, location)=>{
+    if (!isRecord(value)) throw new Error(`${location} must be an object.`);
+    return value;
+};
+const assertExactKeys = (value, expected, location)=>{
+    const expectedKeys = new Set(expected);
+    for (const key of Object.keys(value))if (!expectedKeys.has(key)) throw new Error(`${location} contains unknown field "${key}".`);
+    for (const key of expected)if (!(key in value)) throw new Error(`${location}.${key} is required.`);
+};
+const assertNonEmptyString = (value, location)=>{
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${location} must be a non-empty string.`);
+    if (value !== value.trim()) throw new Error(`${location} must not contain surrounding whitespace.`);
+    return value;
+};
+const assertTarget = (value, location = 'target')=>{
+    const target = assertNonEmptyString(value, location);
+    if (!TARGETS.has(target)) throw new Error(`${location} must be one of: ${external_types_js_namespaceObject.MICROVERTICAL_RELEASE_TARGETS.join(', ')}.`);
+    return target;
+};
+const assertReleaseIdentity = (value, location = 'identity')=>{
+    const identity = assertRecord(value, location);
+    assertExactKeys(identity, [
+        'unitId',
+        'buildMarker',
+        'sourceRevision',
+        'releaseVersion'
+    ], location);
+    const sourceRevision = assertNonEmptyString(identity.sourceRevision, `${location}.sourceRevision`);
+    if (!SOURCE_REVISION_PATTERN.test(sourceRevision)) throw new Error(`${location}.sourceRevision must be an exact lowercase 40- or 64-character Git object ID; "${sourceRevision}" is not promotable.`);
+    return {
+        unitId: assertNonEmptyString(identity.unitId, `${location}.unitId`),
+        buildMarker: assertNonEmptyString(identity.buildMarker, `${location}.buildMarker`),
+        sourceRevision,
+        releaseVersion: assertNonEmptyString(identity.releaseVersion, `${location}.releaseVersion`)
+    };
+};
+const assertNormalizedLogicalPath = (value, location)=>{
+    const logicalPath = assertNonEmptyString(value, location);
+    if (logicalPath.includes('\\') || external_node_path_default().posix.isAbsolute(logicalPath) || external_node_path_default().posix.normalize(logicalPath) !== logicalPath || '.' === logicalPath || logicalPath.split('/').some((segment)=>'..' === segment || '.' === segment)) throw new Error(`${location} must be a normalized relative POSIX path.`);
+    return logicalPath;
+};
+const isPathInside = (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 assertArtifactInput = (value, location)=>{
+    const artifact = assertRecord(value, location);
+    assertExactKeys(artifact, [
+        'logicalPath',
+        'runtime'
+    ], location);
+    return {
+        logicalPath: assertNormalizedLogicalPath(artifact.logicalPath, `${location}.logicalPath`),
+        runtime: assertNonEmptyString(artifact.runtime, `${location}.runtime`)
+    };
+};
+const readFinalArtifact = async (artifactRoot, input, resolvedLogicalPath = input.logicalPath)=>{
+    const artifactInput = {
+        logicalPath: input.logicalPath,
+        runtime: input.runtime
+    };
+    const logicalPath = assertNormalizedLogicalPath(resolvedLogicalPath, `staged path for ${input.logicalPath}`);
+    const resolvedRoot = external_node_path_default().resolve(artifactRoot);
+    const logicalSegments = logicalPath.split('/');
+    const lexicalPath = external_node_path_default().resolve(resolvedRoot, ...logicalSegments);
+    if (!isPathInside(resolvedRoot, lexicalPath)) throw new Error(`Artifact logicalPath "${logicalPath}" resolves outside artifactRoot.`);
+    const realRoot = await promises_default().realpath(resolvedRoot);
+    for(let index = 0; index < logicalSegments.length - 1; index++){
+        const linkLogicalPath = logicalSegments.slice(0, index + 1).join('/');
+        const candidate = external_node_path_default().join(resolvedRoot, ...logicalSegments.slice(0, index + 1));
+        let candidateStat;
+        try {
+            candidateStat = await promises_default().lstat(candidate);
+        } catch  {
+            throw new Error(`Artifact "${logicalPath}" does not exist.`);
+        }
+        if (candidateStat.isSymbolicLink()) throw new Error(`Artifact "${logicalPath}" traverses symbolic-link ancestor "${linkLogicalPath}"; bind the symbolic link itself.`);
+    }
+    let lexicalStat;
+    try {
+        lexicalStat = await promises_default().lstat(lexicalPath);
+    } catch  {
+        throw new Error(`Artifact "${logicalPath}" does not exist.`);
+    }
+    if (lexicalStat.isSymbolicLink()) {
+        let realTarget;
+        try {
+            realTarget = await promises_default().realpath(lexicalPath);
+        } catch  {
+            throw new Error(`Artifact symbolic link "${logicalPath}" cannot be resolved.`);
+        }
+        if (!isPathInside(realRoot, realTarget)) throw new Error(`Artifact logicalPath "${logicalPath}" resolves outside artifactRoot.`);
+        const targetStat = await promises_default().stat(realTarget);
+        const targetKind = targetStat.isFile() ? 'file' : targetStat.isDirectory() ? 'directory' : void 0;
+        if (!targetKind) throw new Error(`Artifact symbolic link "${logicalPath}" must resolve to a file or directory.`);
+        const targetLogicalPath = external_node_path_default().relative(realRoot, realTarget).split(external_node_path_default().sep).join('/');
+        if ('release' === targetLogicalPath || targetLogicalPath.startsWith('release/')) throw new Error(`Artifact symbolic link "${logicalPath}" targets private release metadata.`);
+        if ('directory' === targetKind && isPathInside(realTarget, await promises_default().realpath(external_node_path_default().dirname(lexicalPath)))) throw new Error(`Artifact symbolic link "${logicalPath}" targets an ancestor directory.`);
+        return {
+            ...artifactInput,
+            kind: 'symbolic-link',
+            linkTarget: await promises_default().readlink(lexicalPath),
+            targetKind,
+            targetLogicalPath
+        };
+    }
+    if (!lexicalStat.isFile()) throw new Error(`Artifact "${logicalPath}" must be a file or symlink.`);
+    const realPath = await promises_default().realpath(lexicalPath);
+    if (!isPathInside(realRoot, realPath)) throw new Error(`Artifact logicalPath "${logicalPath}" resolves outside artifactRoot.`);
+    const bytes = await promises_default().readFile(realPath);
+    return {
+        ...artifactInput,
+        kind: 'file',
+        byteLength: bytes.byteLength,
+        sha256: (0, external_node_crypto_namespaceObject.createHash)('sha256').update(bytes).digest('hex')
+    };
+};
+const assertReleaseArtifact = (value, location)=>{
+    const artifact = assertRecord(value, location);
+    const kind = assertNonEmptyString(artifact.kind, `${location}.kind`);
+    const input = {
+        logicalPath: artifact.logicalPath,
+        runtime: artifact.runtime
+    };
+    if ('file' === kind) {
+        assertExactKeys(artifact, [
+            'kind',
+            'logicalPath',
+            'runtime',
+            'byteLength',
+            'sha256'
+        ], location);
+        const byteLength = artifact.byteLength;
+        if ('number' != typeof byteLength || !Number.isSafeInteger(byteLength) || byteLength < 0) throw new Error(`${location}.byteLength must be a non-negative integer.`);
+        const sha256 = assertNonEmptyString(artifact.sha256, `${location}.sha256`);
+        if (!SHA256_PATTERN.test(sha256)) throw new Error(`${location}.sha256 must be a lowercase SHA-256 digest.`);
+        return {
+            ...assertArtifactInput(input, location),
+            kind,
+            byteLength,
+            sha256
+        };
+    }
+    if ('symbolic-link' === kind) {
+        assertExactKeys(artifact, [
+            'kind',
+            'logicalPath',
+            'runtime',
+            'linkTarget',
+            'targetKind',
+            'targetLogicalPath'
+        ], location);
+        const targetKind = assertNonEmptyString(artifact.targetKind, `${location}.targetKind`);
+        if ('directory' !== targetKind && 'file' !== targetKind) throw new Error(`${location}.targetKind must be "directory" or "file".`);
+        return {
+            ...assertArtifactInput(input, location),
+            kind,
+            linkTarget: assertNonEmptyString(artifact.linkTarget, `${location}.linkTarget`),
+            targetKind,
+            targetLogicalPath: assertNormalizedLogicalPath(artifact.targetLogicalPath, `${location}.targetLogicalPath`)
+        };
+    }
+    throw new Error(`${location}.kind must be "file" or "symbolic-link".`);
+};
+const assertUniqueSortedArtifacts = (artifacts, location)=>{
+    const paths = artifacts.map((artifact)=>artifact.logicalPath);
+    const unique = new Set(paths);
+    if (unique.size !== paths.length) {
+        const duplicate = paths.find((logicalPath, index)=>paths.indexOf(logicalPath) !== index);
+        throw new Error(`Duplicate artifact logicalPath "${duplicate}".`);
+    }
+    const sorted = [
+        ...paths
+    ].sort((left, right)=>left.localeCompare(right));
+    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.`);
+    const paths = value.map((item, index)=>assertNormalizedLogicalPath(item, `${location}[${index}]`));
+    const sorted = [
+        ...paths
+    ].sort((left, right)=>left.localeCompare(right));
+    if (paths.some((logicalPath, index)=>logicalPath !== sorted[index])) throw new Error(`${location} must be sorted by logicalPath.`);
+    if (new Set(paths).size !== paths.length) throw new Error(`${location} must not contain duplicate artifact paths.`);
+    return paths;
+};
+const assertSurfaces = (value)=>{
+    const surfaces = assertRecord(value, 'surfaces');
+    assertExactKeys(surfaces, [
+        'uiClient',
+        'ssr',
+        'apiBackend',
+        'backendFederation'
+    ], 'surfaces');
+    const backendFederation = assertRecord(surfaces.backendFederation, 'surfaces.backendFederation');
+    assertExactKeys(backendFederation, [
+        'manifest',
+        'container'
+    ], 'surfaces.backendFederation');
+    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')
+        }
+    };
+};
+const assertSurfaceReferences = (artifacts, surfaces)=>{
+    const artifactPaths = new Set(artifacts.map((artifact)=>artifact.logicalPath));
+    for (const [surface, paths] of Object.entries({
+        uiClient: surfaces.uiClient,
+        ssr: surfaces.ssr,
+        apiBackend: surfaces.apiBackend,
+        '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)=>{
+    const byPath = new Map(artifacts.map((artifact)=>[
+            artifact.logicalPath,
+            artifact
+        ]));
+    const assertRuntime = (paths, expected, surface)=>{
+        for (const logicalPath of paths){
+            const artifact = byPath.get(logicalPath);
+            if (artifact?.runtime !== expected) throw new Error(`${target} ${surface} artifact "${logicalPath}" must use runtime "${expected}"; received "${String(artifact?.runtime)}".`);
+            if ('kind' in artifact && 'file' !== artifact.kind) throw new Error(`${target} ${surface} artifact "${logicalPath}" must be a file.`);
+        }
+    };
+    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');
+};
+const deepFreeze = (value)=>{
+    if (null !== value && 'object' == typeof value && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))deepFreeze(child);
+    }
+    return value;
+};
+const assertEnvelope = (value)=>{
+    const envelope = assertRecord(value, 'envelope');
+    assertExactKeys(envelope, [
+        'schemaVersion',
+        'kind',
+        'target',
+        'identity',
+        '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}".`);
+    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);
+    assertSurfaceReferences(artifacts, surfaces);
+    assertTargetSurfaceContract(target, artifacts, surfaces);
+    const parsed = {
+        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'),
+        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.');
+    const expectedDigest = (0, external_canonical_js_namespaceObject.digestMicroVerticalReleaseEnvelopePayload)((0, external_canonical_js_namespaceObject.releaseEnvelopePayload)(parsed));
+    if (parsed.envelopeDigest !== expectedDigest) throw new Error('envelope.envelopeDigest does not match canonical payload.');
+    return parsed;
+};
+const createMicroVerticalReleaseEnvelope = async (input)=>{
+    const artifactRoot = await promises_default().realpath(external_node_path_default().resolve(input.artifactRoot));
+    const target = assertTarget(input.target);
+    const identity = assertReleaseIdentity(input.identity);
+    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);
+    assertSurfaceReferences(sortedInputs, surfaces);
+    assertTargetSurfaceContract(target, sortedInputs, surfaces);
+    const artifacts = await Promise.all(sortedInputs.map((artifact)=>readFinalArtifact(artifactRoot, artifact)));
+    assertTargetSurfaceContract(target, artifacts, surfaces);
+    const payload = {
+        schemaVersion: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
+        kind: external_types_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_KIND,
+        target,
+        identity,
+        artifacts,
+        surfaces
+    };
+    return deepFreeze({
+        ...payload,
+        envelopeDigest: (0, external_canonical_js_namespaceObject.digestMicroVerticalReleaseEnvelopePayload)(payload)
+    });
+};
+const verifyMicroVerticalReleaseEnvelope = async (value, options)=>{
+    const envelope = assertEnvelope(value);
+    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){
+        const finalArtifact = await readFinalArtifact(artifactRoot, artifact, options.logicalPathForArtifact?.(artifact) ?? artifact.logicalPath);
+        const matches = finalArtifact.kind === artifact.kind && ('file' === artifact.kind && 'file' === finalArtifact.kind ? finalArtifact.byteLength === artifact.byteLength && finalArtifact.sha256 === artifact.sha256 : 'symbolic-link' === artifact.kind && 'symbolic-link' === finalArtifact.kind && finalArtifact.linkTarget === artifact.linkTarget && finalArtifact.targetKind === artifact.targetKind && finalArtifact.targetLogicalPath === artifact.targetLogicalPath);
+        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.canonicalSerializeMicroVerticalReleaseEnvelope = __webpack_exports__.canonicalSerializeMicroVerticalReleaseEnvelope;
+exports.createMicroVerticalReleaseEnvelope = __webpack_exports__.createMicroVerticalReleaseEnvelope;
+exports.verifyMicroVerticalReleaseEnvelope = __webpack_exports__.verifyMicroVerticalReleaseEnvelope;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MICROVERTICAL_RELEASE_ENVELOPE_KIND",
+    "MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION",
+    "MICROVERTICAL_RELEASE_TARGETS",
+    "canonicalSerializeMicroVerticalReleaseEnvelope",
+    "createMicroVerticalReleaseEnvelope",
+    "verifyMicroVerticalReleaseEnvelope"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,51 @@
+"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__);
+const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = 3;
+const MICROVERTICAL_RELEASE_ENVELOPE_KIND = 'ultramodern-target-microvertical-release-envelope';
+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;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MICROVERTICAL_RELEASE_ENVELOPE_KIND",
+    "MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION",
+    "MICROVERTICAL_RELEASE_TARGETS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-release-identity.js

@@ -0,0 +1,110 @@
+"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__, {
+    createUltramodernReleaseBuildMarker: ()=>createUltramodernReleaseBuildMarker,
+    resolveUltramodernReleaseIdentity: ()=>resolveUltramodernReleaseIdentity,
+    resolveUltramodernSourceRevision: ()=>resolveUltramodernSourceRevision
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_crypto_namespaceObject = require("node:crypto");
+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 gitOutput = (workspaceRoot, args)=>{
+    try {
+        return (0, external_node_child_process_namespaceObject.execFileSync)('git', [
+            '-C',
+            workspaceRoot,
+            ...args
+        ], {
+            encoding: 'utf8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ]
+        }).trim();
+    } catch  {
+        return;
+    }
+};
+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 configuredArgumentValue = configuredSourceRevision?.trim();
+    const configuredEnvironmentValue = process.env.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}.`);
+    const configured = configuredArgument ?? configuredEnvironment;
+    const gitRoot = gitOutput(workspaceRoot, [
+        'rev-parse',
+        '--show-toplevel'
+    ]);
+    if (!gitRoot) {
+        if (!configured) return 'workspace';
+        if (!PROMOTABLE_SOURCE_REVISION_PATTERN.test(configured)) throw new Error(`Configured source revision ${configured} must be an exact lowercase 40- or 64-character Git object ID.`);
+        return configured;
+    }
+    const revision = gitOutput(gitRoot, [
+        'rev-parse',
+        'HEAD'
+    ]);
+    const status = gitOutput(gitRoot, [
+        'status',
+        '--porcelain=v1',
+        '--untracked-files=all'
+    ]);
+    if (!revision || void 0 === status || status.length > 0) return 'workspace';
+    if (!PROMOTABLE_SOURCE_REVISION_PATTERN.test(revision)) return 'workspace';
+    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 explicitSourceRevision = configuredSourceRevision?.trim();
+    const sourceRevision = resolveUltramodernSourceRevision(workspaceRoot, explicitSourceRevision);
+    return {
+        buildMarker: 'workspace' === sourceRevision ? generationBuildMarker : createUltramodernReleaseBuildMarker({
+            generationBuildMarker,
+            sourceRevision,
+            unitId
+        }),
+        sourceRevision
+    };
+};
+exports.createUltramodernReleaseBuildMarker = __webpack_exports__.createUltramodernReleaseBuildMarker;
+exports.resolveUltramodernReleaseIdentity = __webpack_exports__.resolveUltramodernReleaseIdentity;
+exports.resolveUltramodernSourceRevision = __webpack_exports__.resolveUltramodernSourceRevision;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createUltramodernReleaseBuildMarker",
+    "resolveUltramodernReleaseIdentity",
+    "resolveUltramodernSourceRevision"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/builder/generator/getBuilderEnvironments.mjs

@@ -2,6 +2,7 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
 import { isProd, isSSR, isServiceWorker, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { CLOUDFLARE_WORKER_NODE_BUILTINS } from "../../plugins/deploy/platforms/cloudflare-output-contract.mjs";
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
 const JS_OR_TS_EXTS = [
@@ -14,20 +15,6 @@ const JS_OR_TS_EXTS = [
     '.cjs',
     '.cts'
 ];
-const CLOUDFLARE_WORKER_NODE_BUILTINS = [
-    'async_hooks',
-    'buffer',
-    'crypto',
-    'events',
-    'fs/promises',
-    'module',
-    'path',
-    'process',
-    'stream',
-    'string_decoder',
-    'url',
-    'util'
-];
 const CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR = node_path.resolve(__dirname, '../../plugins/deploy/platforms/templates');
 function findExistingFile(candidates) {
     return candidates.find((candidate)=>node_fs.existsSync(candidate));
@@ -258,7 +245,17 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
                         });
                         chain.output.module(true).library({
                             type: 'module'
-                        }).chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+                        }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+                        chain.optimization.usedExports(false).providedExports(true).innerGraph(false).sideEffects(false);
+                        for (const condition of [
+                            'workerd',
+                            'worker',
+                            'webpack',
+                            isProd() ? 'production' : 'development',
+                            'import',
+                            'require',
+                            'module'
+                        ])chain.resolve.conditionNames.add(condition);
                         chain.plugins.delete('plugin-module-federation');
                         if (tanstackRouterSsrServerFile) {
                             chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);

package/dist/esm/builder/shared/builderPlugins/adapterPrecompress.mjs

@@ -30,10 +30,19 @@ const mergeCompressionOptions = (base, next)=>{
         ...base,
         ...next
     };
-    if (base.compressionOptions || next.compressionOptions) merged.compressionOptions = {
-        ...base.compressionOptions,
-        ...next.compressionOptions
-    };
+    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)=>{