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

package/dist/cjs/plugins/deploy/platforms/templates/vercel-entry.mjs

@@ -2,57 +2,78 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProdServer } from '@modern-js/prod-server';
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 p_genPluginImportsCode;
-if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
 let requestHandler = null;
 let handlerCreationPromise = null;
+
 async function loadRoutes(routeFilepath) {
-    try {
-        await fs.access(routeFilepath);
-        const content = await fs.readFile(routeFilepath, 'utf-8');
-        const routeSpec = JSON.parse(content);
-        return routeSpec.routes || [];
-    } catch (error) {
-        console.warn('route.json not found or invalid, continuing with empty routes.');
-        return [];
-    }
+  try {
+    await fs.access(routeFilepath);
+    const content = await fs.readFile(routeFilepath, 'utf-8');
+    const routeSpec = JSON.parse(content);
+    return routeSpec.routes || [];
+  } catch (error) {
+    console.warn(
+      'route.json not found or invalid, continuing with empty routes.',
+    );
+    return [];
+  }
 }
+
 async function initServer() {
-    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
-    const routes = await loadRoutes(routeFilepath);
-    const dynamicProdOptions = p_dynamicProdOptions;
-    const prodServerOptions = {
-        pwd: __dirname,
-        routes,
-        disableCustomHook: true,
-        appContext: {
-            sharedDirectory: p_sharedDirectory,
-            apiDirectory: p_apiDirectory,
-            lambdaDirectory: p_lambdaDirectory
-        },
-        plugins: p_plugins,
-        serverConfigPath: p_serverDirectory,
-        ...dynamicProdOptions
-    };
-    const app = await createProdServer(prodServerOptions);
-    return app.getRequestListener();
+  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+  const routes = await loadRoutes(routeFilepath);
+
+  const dynamicProdOptions = p_dynamicProdOptions;
+
+  const prodServerOptions = {
+    pwd: __dirname,
+    routes,
+    disableCustomHook: true,
+    appContext: {
+      sharedDirectory: p_sharedDirectory,
+      apiDirectory: p_apiDirectory,
+      lambdaDirectory: p_lambdaDirectory,
+    },
+    plugins: p_plugins,
+    serverConfigPath: p_serverDirectory,
+    ...dynamicProdOptions,
+  };
+  const app = await createProdServer(prodServerOptions);
+
+  return app.getRequestListener();
 }
+
 async function createHandler() {
-    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
-        try {
-            requestHandler = await initServer();
-        } catch (error) {
-            console.error('Error creating server:', error);
-            process.exit(1);
-        }
+  if (!handlerCreationPromise) {
+    handlerCreationPromise = (async () => {
+      try {
+        requestHandler = await initServer();
+      } catch (error) {
+        console.error('Error creating server:', error);
+        process.exit(1);
+      }
     })();
-    await handlerCreationPromise;
-    return requestHandler;
+  }
+  await handlerCreationPromise;
+  return requestHandler;
 }
+
 createHandler();
-const handler = async (req, res)=>{
-    if (!requestHandler) await createHandler();
-    return requestHandler(req, res);
+
+const handler = async (req, res) => {
+  if (!requestHandler) {
+    await createHandler();
+  }
+  return requestHandler(req, res);
 };
+
 export default handler;

package/dist/cjs/plugins/deploy/utils/npmAliases.js

@@ -0,0 +1,226 @@
+"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__, {
+    preserveNpmAliases: ()=>preserveNpmAliases,
+    readPackageIdentity: ()=>readPackageIdentity
+});
+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 dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises_default().readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson) {
+    const aliases = [];
+    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = external_node_path_default().join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(external_node_path_default().join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises_default().readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(external_node_path_default().join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises_default().readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = external_node_path_default().join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(external_node_path_default().join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = external_node_path_default().resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises_default().readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = external_node_path_default().join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = external_node_path_default().resolve(outputDirectory);
+    const resolvedOutputRoot = await promises_default().realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${external_node_path_default().sep}`)){
+        const candidate = external_node_path_default().join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises_default().realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${external_node_path_default().sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(external_node_path_default().join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = external_node_path_default().dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = external_node_path_default().join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises_default().mkdir(external_node_path_default().dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises_default().realpath(aliasPath),
+            promises_default().realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = external_node_path_default().relative(external_node_path_default().dirname(aliasPath), target.directory);
+    await promises_default().symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = external_node_path_default().dirname(entryPath);
+    const root = external_node_path_default().parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(external_node_path_default().join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = external_node_path_default().dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(external_node_path_default().join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(external_node_path_default().join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = external_node_path_default().join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises_default().writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+exports.preserveNpmAliases = __webpack_exports__.preserveNpmAliases;
+exports.readPackageIdentity = __webpack_exports__.readPackageIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preserveNpmAliases",
+    "readPackageIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/ultramodernReleaseEnvelope.js

@@ -0,0 +1,100 @@
+"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__, {
+    default: ()=>ultramodernReleaseEnvelope
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const framework_output_js_namespaceObject = require("../ultramodern-release-envelope/framework-output.js");
+const index_js_namespaceObject = require("./deploy/index.js");
+const resolveActiveDeployTarget = (api)=>{
+    const { metaName } = api.getAppContext();
+    const config = api.getNormalizedConfig();
+    if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
+    return (0, index_js_namespaceObject.resolveDeployTarget)(config);
+};
+const ultramodernReleaseEnvelope = ()=>({
+        name: '@modern-js/ultramodern-release-envelope',
+        pre: [
+            '@modern-js/backend-federation-build',
+            '@modern-js/plugin-bff'
+        ],
+        setup (api) {
+            const emitBuildEnvelope = async (target)=>{
+                const { apiOnly, distDirectory } = api.getAppContext();
+                await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
+                    apiOnly,
+                    distDirectory,
+                    target
+                });
+            };
+            api.onAfterBuild(async ()=>{
+                const configuredTarget = (0, index_js_namespaceObject.resolveDeployTarget)(api.getNormalizedConfig());
+                if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
+                await emitBuildEnvelope(configuredTarget);
+            });
+            api.onBeforeDeploy(async ()=>{
+                const configuredTarget = resolveActiveDeployTarget(api);
+                if ('node' !== configuredTarget) return;
+                await emitBuildEnvelope(configuredTarget);
+                const { distDirectory } = api.getAppContext();
+                await (0, framework_output_js_namespaceObject.verifyBuildOutputReleaseEnvelope)(distDirectory, configuredTarget);
+            });
+            api.onAfterDeploy(async ()=>{
+                const configuredTarget = resolveActiveDeployTarget(api);
+                if ('node' !== configuredTarget) return;
+                const { appDirectory, distDirectory } = api.getAppContext();
+                const outputDirectory = external_node_path_default().join(appDirectory, '.output');
+                const releaseEnvelope = await (0, framework_output_js_namespaceObject.emitNodeStagedReleaseEnvelope)({
+                    distDirectory,
+                    outputDirectory
+                });
+                if (releaseEnvelope) await (0, framework_output_js_namespaceObject.verifyNodeReleaseEnvelopeStaging)({
+                    outputDirectory
+                });
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/presetUltramodern.js

@@ -45,6 +45,8 @@ var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const cli_namespaceObject = require("@modern-js/plugin/cli");
+const core_namespaceObject = require("@rsbuild/core");
+const external_ultramodern_release_identity_js_namespaceObject = require("./ultramodern-release-identity.js");
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -77,8 +79,16 @@ const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
     chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
 };
 const createPresetUltramodernConfig = (options = {})=>{
-    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
+    const { appId = 'app', deliveryUnit, enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
     const server = {};
+    const releaseIdentity = deliveryUnit ? (0, external_ultramodern_release_identity_js_namespaceObject.resolveUltramodernReleaseIdentity)({
+        generationBuildMarker: deliveryUnit.buildMarker,
+        unitId: deliveryUnit.unitId
+    }) : void 0;
+    const bundledReleaseIdentity = releaseIdentity ? {
+        ...releaseIdentity,
+        releaseVersion: deliveryUnit.version
+    } : void 0;
     if (enableTelemetry) {
         server.telemetry = {
             enabled: true,
@@ -106,8 +116,29 @@ const createPresetUltramodernConfig = (options = {})=>{
             precompress: true
         },
         server,
+        ...deliveryUnit ? {
+            source: {
+                globalVars: {
+                    ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
+                    ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
+                    ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
+                }
+            }
+        } : {},
         tools: {
-            bundlerChain: setReactRouterBridgeSafeAliases
+            bundlerChain: setReactRouterBridgeSafeAliases,
+            ...bundledReleaseIdentity ? {
+                rspack: (config)=>{
+                    config.plugins ??= [];
+                    config.plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+                        banner: `void ${JSON.stringify(bundledReleaseIdentity.buildMarker)};void ${JSON.stringify(bundledReleaseIdentity.sourceRevision)};void ${JSON.stringify(bundledReleaseIdentity.releaseVersion)};`,
+                        raw: true,
+                        stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+                        test: /\.(?:c|m)?js$/u
+                    }));
+                    return config;
+                }
+            } : {}
         }
     };
     if (enableBffRequestId) presetConfig.bff = {

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

@@ -0,0 +1,68 @@
+"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__, {
+    canonicalSerializeMicroVerticalReleaseEnvelope: ()=>canonicalSerializeMicroVerticalReleaseEnvelope,
+    canonicalSerializeMicroVerticalReleaseEnvelopePayload: ()=>canonicalSerializeMicroVerticalReleaseEnvelopePayload,
+    digestMicroVerticalReleaseEnvelopePayload: ()=>digestMicroVerticalReleaseEnvelopePayload,
+    releaseEnvelopePayload: ()=>releaseEnvelopePayload
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const serializeCanonicalValue = (value)=>{
+    if (null === value || 'object' != typeof value) {
+        if ('number' == typeof value && !Number.isFinite(value)) throw new Error('Canonical release-envelope values must be finite.');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) return `[${value.map(serializeCanonicalValue).join(',')}]`;
+    return `{${Object.keys(value).sort().map((key)=>`${JSON.stringify(key)}:${serializeCanonicalValue(value[key])}`).join(',')}}`;
+};
+const releaseEnvelopePayload = (envelope)=>({
+        schemaVersion: envelope.schemaVersion,
+        kind: envelope.kind,
+        target: envelope.target,
+        identity: envelope.identity,
+        artifacts: envelope.artifacts,
+        surfaces: envelope.surfaces
+    });
+const canonicalSerializeMicroVerticalReleaseEnvelopePayload = (payload)=>serializeCanonicalValue(payload);
+const canonicalSerializeMicroVerticalReleaseEnvelope = (envelope)=>serializeCanonicalValue(envelope);
+const digestMicroVerticalReleaseEnvelopePayload = (payload)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(canonicalSerializeMicroVerticalReleaseEnvelopePayload(payload)).digest('hex');
+exports.canonicalSerializeMicroVerticalReleaseEnvelope = __webpack_exports__.canonicalSerializeMicroVerticalReleaseEnvelope;
+exports.canonicalSerializeMicroVerticalReleaseEnvelopePayload = __webpack_exports__.canonicalSerializeMicroVerticalReleaseEnvelopePayload;
+exports.digestMicroVerticalReleaseEnvelopePayload = __webpack_exports__.digestMicroVerticalReleaseEnvelopePayload;
+exports.releaseEnvelopePayload = __webpack_exports__.releaseEnvelopePayload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canonicalSerializeMicroVerticalReleaseEnvelope",
+    "canonicalSerializeMicroVerticalReleaseEnvelopePayload",
+    "digestMicroVerticalReleaseEnvelopePayload",
+    "releaseEnvelopePayload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});