@bleedingdev/modern-js-app-tools 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

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

@@ -1,399 +0,0 @@
-"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

@@ -1,51 +0,0 @@
-"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

@@ -1,110 +0,0 @@
-"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/shared/builderPlugins/adapterLazyCompilation.mjs

@@ -1,36 +0,0 @@
-import { isUseRsc, logger } from "@modern-js/utils";
-import { aggregateEagerRouteComponentFiles, planRouteEagerLazyCompilation } from "../lazyCompilation.mjs";
-const builderPluginAdapterLazyCompilation = (options)=>({
-        name: 'builder-plugin-adapter-modern-lazy-compilation',
-        setup (api) {
-            api.modifyRsbuildConfig((config)=>{
-                const lazyCompilation = getRouteEagerLazyCompilation(options, config);
-                if (void 0 === lazyCompilation) return config;
-                return {
-                    ...config,
-                    dev: {
-                        ...config.dev,
-                        lazyCompilation
-                    }
-                };
-            });
-        }
-    });
-function getRouteEagerLazyCompilation(options, config) {
-    const current = config.dev?.lazyCompilation;
-    if (!current || isUseRsc(options.normalizedConfig)) return;
-    const plan = planRouteEagerLazyCompilation(current, aggregateEagerRouteComponentFiles(options.eagerRouteComponentFilesByEntry));
-    if (!plan.apply) {
-        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(options.appContext.appDirectory, plan.unresolvedByEntry);
-        return;
-    }
-    return plan.lazyCompilation;
-}
-const warnedLazyApps = new Set();
-function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
-    if (warnedLazyApps.has(appDirectory)) return;
-    warnedLazyApps.add(appDirectory);
-    const detail = Array.from(unresolvedByEntry).map(([entry, components])=>`${entry}: ${components.join(', ')}`).join('; ');
-    logger.warn(`[lazyCompilation] Skipped route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may delay route rendering for these routes.`);
-}
-export { builderPluginAdapterLazyCompilation };

package/dist/esm/builder/shared/bundlerPlugins/CssExtractRuntimePlugin.mjs

@@ -1,30 +0,0 @@
-const PLUGIN_NAME = 'ModernjsCssExtractRuntimePlugin';
-const CSS_LOADING_RUNTIME_MODULE = 'webpack/runtime/css loading';
-const CSS_EXTRACT_STYLESHEET_MATCH = '\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;';
-const CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL = `\t\tvar absoluteHref = tag.href;
-\t\tvar absoluteFullHref = new URL(fullhref, document.baseURI).href;
-\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref || absoluteHref === absoluteFullHref)) return tag;`;
-const isAutomaticPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath;
-const normalizeCssExtractRuntimeStylesheetLookup = (source)=>{
-    if (!source.includes('__webpack_require__.miniCssF')) return source;
-    const occurrences = source.split(CSS_EXTRACT_STYLESHEET_MATCH).length - 1;
-    if (1 !== occurrences) throw new Error(`Unsupported CssExtractRspackPlugin runtime shape: expected one stylesheet lookup, found ${occurrences}.`);
-    return source.replace(CSS_EXTRACT_STYLESHEET_MATCH, CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL);
-};
-class CssExtractRuntimePlugin {
-    apply(compiler) {
-        if (!isAutomaticPublicPath(compiler.options.output.publicPath)) return;
-        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
-            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (runtimeModule)=>{
-                if (runtimeModule.identifier() !== CSS_LOADING_RUNTIME_MODULE) return;
-                const runtimeSource = runtimeModule.source?.source;
-                if ('string' != typeof runtimeSource) return;
-                runtimeModule.source.source = normalizeCssExtractRuntimeStylesheetLookup(runtimeSource);
-            });
-        });
-    }
-    constructor(){
-        this.name = PLUGIN_NAME;
-    }
-}
-export { CssExtractRuntimePlugin, normalizeCssExtractRuntimeStylesheetLookup };