@bleedingdev/modern-js-utils 3.5.0-ultramodern.10 → 3.5.0-ultramodern.101

package/dist/cjs/universal/surface-resolution/index.js

@@ -0,0 +1,69 @@
+"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__, {
+    DEFAULT_LOCAL_ENVIRONMENTS: ()=>external_env_static_provider_js_namespaceObject.DEFAULT_LOCAL_ENVIRONMENTS,
+    ENV_STATIC_PROVIDER_NAME: ()=>external_env_static_provider_js_namespaceObject.ENV_STATIC_PROVIDER_NAME,
+    createDiscoveryError: ()=>external_validation_js_namespaceObject.createDiscoveryError,
+    createEnvStaticSurfaceResolutionProvider: ()=>external_env_static_provider_js_namespaceObject.createEnvStaticSurfaceResolutionProvider,
+    formatSurfaceRef: ()=>external_surface_ref_js_namespaceObject.formatSurfaceRef,
+    matchDeliveryUnitIdentity: ()=>external_validation_js_namespaceObject.matchDeliveryUnitIdentity,
+    parseSurfaceRef: ()=>external_surface_ref_js_namespaceObject.parseSurfaceRef,
+    selectResolvedSurface: ()=>external_validation_js_namespaceObject.selectResolvedSurface,
+    validateResolvedDeliveryUnit: ()=>external_validation_js_namespaceObject.validateResolvedDeliveryUnit,
+    validateSurfaceRef: ()=>external_surface_ref_js_namespaceObject.validateSurfaceRef
+});
+const external_env_static_provider_js_namespaceObject = require("./env-static-provider.js");
+const external_surface_ref_js_namespaceObject = require("./surface-ref.js");
+const external_validation_js_namespaceObject = require("./validation.js");
+exports.DEFAULT_LOCAL_ENVIRONMENTS = __webpack_exports__.DEFAULT_LOCAL_ENVIRONMENTS;
+exports.ENV_STATIC_PROVIDER_NAME = __webpack_exports__.ENV_STATIC_PROVIDER_NAME;
+exports.createDiscoveryError = __webpack_exports__.createDiscoveryError;
+exports.createEnvStaticSurfaceResolutionProvider = __webpack_exports__.createEnvStaticSurfaceResolutionProvider;
+exports.formatSurfaceRef = __webpack_exports__.formatSurfaceRef;
+exports.matchDeliveryUnitIdentity = __webpack_exports__.matchDeliveryUnitIdentity;
+exports.parseSurfaceRef = __webpack_exports__.parseSurfaceRef;
+exports.selectResolvedSurface = __webpack_exports__.selectResolvedSurface;
+exports.validateResolvedDeliveryUnit = __webpack_exports__.validateResolvedDeliveryUnit;
+exports.validateSurfaceRef = __webpack_exports__.validateSurfaceRef;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_LOCAL_ENVIRONMENTS",
+    "ENV_STATIC_PROVIDER_NAME",
+    "createDiscoveryError",
+    "createEnvStaticSurfaceResolutionProvider",
+    "formatSurfaceRef",
+    "matchDeliveryUnitIdentity",
+    "parseSurfaceRef",
+    "selectResolvedSurface",
+    "validateResolvedDeliveryUnit",
+    "validateSurfaceRef"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/universal/surface-resolution/surface-ref.js

@@ -0,0 +1,132 @@
+"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 SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
+const MAJOR_PATTERN = /^v[1-9][0-9]*$/;
+function parseSurfaceRef(input) {
+    if ('' === input) return {
+        ok: false,
+        error: {
+            code: 'empty'
+        }
+    };
+    const hashCount = countChar(input, '#');
+    if (0 === hashCount) return {
+        ok: false,
+        error: {
+            code: 'missing-surface-separator'
+        }
+    };
+    if (hashCount > 1) return {
+        ok: false,
+        error: {
+            code: 'multiple-surface-separators'
+        }
+    };
+    const hashIndex = input.indexOf('#');
+    const unitPart = input.slice(0, hashIndex);
+    const rest = input.slice(hashIndex + 1);
+    const atIndex = rest.indexOf('@');
+    const surfaceId = -1 === atIndex ? rest : rest.slice(0, atIndex);
+    const ref = {
+        unitId: unitPart,
+        surfaceId
+    };
+    if (-1 !== atIndex) {
+        const majorPart = rest.slice(atIndex + 1);
+        if ('' === majorPart) return {
+            ok: false,
+            error: {
+                code: 'empty-major'
+            }
+        };
+        if (!MAJOR_PATTERN.test(majorPart)) return {
+            ok: false,
+            error: {
+                code: 'invalid-major',
+                value: majorPart
+            }
+        };
+        ref.major = Number(majorPart.slice(1));
+    }
+    const error = validateSurfaceRef(ref);
+    return void 0 === error ? {
+        ok: true,
+        ref
+    } : {
+        ok: false,
+        error
+    };
+}
+function formatSurfaceRef(ref) {
+    const error = validateSurfaceRef(ref);
+    if (void 0 !== error) throw new TypeError(`Cannot format invalid SurfaceRef: ${error.code}.`);
+    const base = `${ref.unitId}#${ref.surfaceId}`;
+    return void 0 === ref.major ? base : `${base}@v${ref.major}`;
+}
+function validateSurfaceRef(ref) {
+    if ('' === ref.unitId) return {
+        code: 'empty-unit-id'
+    };
+    for (const segment of ref.unitId.split('/'))if (!SEGMENT_PATTERN.test(segment)) return {
+        code: 'invalid-unit-id',
+        segment
+    };
+    if ('' === ref.surfaceId) return {
+        code: 'empty-surface-id'
+    };
+    if (!SEGMENT_PATTERN.test(ref.surfaceId)) return {
+        code: 'invalid-surface-id'
+    };
+    if (void 0 !== ref.major && (!Number.isSafeInteger(ref.major) || ref.major < 1)) return {
+        code: 'invalid-major',
+        value: String(ref.major)
+    };
+}
+function countChar(input, char) {
+    let count = 0;
+    for (const current of input)if (current === char) count += 1;
+    return count;
+}
+__webpack_require__.d(__webpack_exports__, {
+    formatSurfaceRef: ()=>formatSurfaceRef,
+    parseSurfaceRef: ()=>parseSurfaceRef,
+    validateSurfaceRef: ()=>validateSurfaceRef
+});
+exports.formatSurfaceRef = __webpack_exports__.formatSurfaceRef;
+exports.parseSurfaceRef = __webpack_exports__.parseSurfaceRef;
+exports.validateSurfaceRef = __webpack_exports__.validateSurfaceRef;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "formatSurfaceRef",
+    "parseSurfaceRef",
+    "validateSurfaceRef"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/universal/surface-resolution/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/universal/surface-resolution/validation.js

@@ -0,0 +1,202 @@
+"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__, {
+    createDiscoveryError: ()=>createDiscoveryError,
+    matchDeliveryUnitIdentity: ()=>matchDeliveryUnitIdentity,
+    selectResolvedSurface: ()=>selectResolvedSurface,
+    validateResolvedDeliveryUnit: ()=>validateResolvedDeliveryUnit
+});
+const external_surface_ref_js_namespaceObject = require("./surface-ref.js");
+const SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
+function createDiscoveryError(code, ref, message, details) {
+    const refString = 'string' == typeof ref ? ref : (0, external_surface_ref_js_namespaceObject.formatSurfaceRef)(ref);
+    return void 0 === details ? {
+        code,
+        ref: refString,
+        message
+    } : {
+        code,
+        ref: refString,
+        message,
+        details
+    };
+}
+function isNonEmptyString(value) {
+    return 'string' == typeof value && value.length > 0;
+}
+function isValidUnitId(unitId) {
+    return unitId.split('/').every((segment)=>SEGMENT_PATTERN.test(segment));
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const COMPATIBILITY_STATUSES = [
+    'compatible',
+    'incompatible',
+    'degraded'
+];
+const SURFACE_KINDS = [
+    'component',
+    'route',
+    'api',
+    'backend'
+];
+const LOCATION_PLATFORMS = [
+    'browser-mf-manifest',
+    'node-mf-manifest',
+    'http-api',
+    'cloudflare-service-binding'
+];
+const LOCATION_REQUIRED_FIELDS = {
+    'browser-mf-manifest': [
+        'manifestUrl'
+    ],
+    'node-mf-manifest': [
+        'manifestRef'
+    ],
+    'http-api': [
+        'baseUrl',
+        'prefix'
+    ],
+    'cloudflare-service-binding': [
+        'serviceBinding'
+    ]
+};
+function validateLocation(location, path, seenPlatforms, push) {
+    if (!isRecord(location)) return void push(path, 'must be an object');
+    const platform = location.platform;
+    if ('string' != typeof platform || !LOCATION_PLATFORMS.includes(platform)) return void push(`${path}.platform`, `must be one of ${LOCATION_PLATFORMS.join(', ')}`);
+    if (seenPlatforms.has(platform)) push(`${path}.platform`, `duplicate platform ${platform} within one surface`);
+    seenPlatforms.add(platform);
+    for (const field of LOCATION_REQUIRED_FIELDS[platform] ?? [])if (!isNonEmptyString(location[field])) push(`${path}.${field}`, 'must be a non-empty string');
+    if ('cloudflare-service-binding' === platform && void 0 !== location.dispatchNamespace && !isNonEmptyString(location.dispatchNamespace)) push(`${path}.dispatchNamespace`, 'must be a non-empty string when present');
+}
+function validateSurface(surface, path, seenSurfaceIds, push) {
+    if (!isRecord(surface)) return void push(path, 'must be an object');
+    if (isNonEmptyString(surface.surfaceId)) if (SEGMENT_PATTERN.test(surface.surfaceId)) if (seenSurfaceIds.has(surface.surfaceId)) push(`${path}.surfaceId`, 'must be unique within the record');
+    else seenSurfaceIds.add(surface.surfaceId);
+    else push(`${path}.surfaceId`, 'must match the SurfaceRef SurfaceId grammar');
+    else push(`${path}.surfaceId`, 'must be a non-empty string');
+    if ('string' != typeof surface.kind || !SURFACE_KINDS.includes(surface.kind)) push(`${path}.kind`, `must be one of ${SURFACE_KINDS.join(', ')}`);
+    if (void 0 !== surface.servedMajor && (!Number.isSafeInteger(surface.servedMajor) || surface.servedMajor < 1)) push(`${path}.servedMajor`, 'must be a positive safe integer when present');
+    if (!Array.isArray(surface.locations)) return void push(`${path}.locations`, 'must be an array of locations');
+    if (0 === surface.locations.length) push(`${path}.locations`, 'must contain at least one location (no partial records)');
+    const seenPlatforms = new Set();
+    surface.locations.forEach((location, locationIndex)=>{
+        validateLocation(location, `${path}.locations[${locationIndex}]`, seenPlatforms, push);
+    });
+}
+function validateResolvedDeliveryUnit(unit) {
+    const issues = [];
+    const push = (path, message)=>{
+        issues.push({
+            path,
+            message
+        });
+    };
+    if (!isRecord(unit)) {
+        push('', 'must be an object');
+        return {
+            ok: false,
+            issues
+        };
+    }
+    const raw = unit;
+    if (isNonEmptyString(raw.unitId)) {
+        if (!isValidUnitId(raw.unitId)) push('unitId', 'must match the SurfaceRef UnitId grammar');
+    } else push('unitId', 'must be a non-empty string');
+    if (!isNonEmptyString(raw.buildMarker)) push('buildMarker', 'must be a non-empty string');
+    if (!isNonEmptyString(raw.sourceRevision)) push('sourceRevision', 'must be a non-empty string');
+    if (!isNonEmptyString(raw.baselineCohortId)) push('baselineCohortId', 'must be a non-empty string');
+    const compatibility = raw.compatibility;
+    if (isRecord(compatibility)) {
+        if ('string' != typeof compatibility.status || !COMPATIBILITY_STATUSES.includes(compatibility.status)) push('compatibility.status', `must be one of ${COMPATIBILITY_STATUSES.join(', ')}`);
+        if (compatibility.baselineCohortId !== raw.baselineCohortId) push('compatibility.baselineCohortId', 'must equal the record-level baselineCohortId (one verdict per record)');
+        if (void 0 !== compatibility.reason && !isNonEmptyString(compatibility.reason)) push('compatibility.reason', 'must be a non-empty string when present');
+    } else push('compatibility', 'must be an object');
+    if (!Array.isArray(raw.surfaces)) {
+        push('surfaces', 'must be an array of surfaces');
+        return {
+            ok: false,
+            issues
+        };
+    }
+    if (0 === raw.surfaces.length) push('surfaces', 'must contain at least one surface');
+    const seenSurfaceIds = new Set();
+    raw.surfaces.forEach((surface, surfaceIndex)=>{
+        validateSurface(surface, `surfaces[${surfaceIndex}]`, seenSurfaceIds, push);
+    });
+    return {
+        ok: 0 === issues.length,
+        issues
+    };
+}
+function selectResolvedSurface(unit, ref) {
+    if (unit.unitId !== ref.unitId) return {
+        ok: false,
+        error: createDiscoveryError('unknown-unit', ref, `Resolved record is for unit ${unit.unitId}, not ${ref.unitId}.`, {
+            recordUnitId: unit.unitId
+        })
+    };
+    const surface = unit.surfaces.find((candidate)=>candidate.surfaceId === ref.surfaceId);
+    if (void 0 === surface) return {
+        ok: false,
+        error: createDiscoveryError('unknown-surface', ref, `Unit ${unit.unitId} (buildMarker ${unit.buildMarker}) does not publish surface ${ref.surfaceId}.`, {
+            availableSurfaces: unit.surfaces.map((entry)=>entry.surfaceId)
+        })
+    };
+    return {
+        ok: true,
+        surface
+    };
+}
+function matchDeliveryUnitIdentity(expected, unit, ref) {
+    if (expected.unitId === unit.unitId && expected.buildMarker === unit.buildMarker) return;
+    return createDiscoveryError('identity-mismatch', ref, `Delivery-unit identity mismatch: expected ${expected.unitId}@${expected.buildMarker}, resolved ${unit.unitId}@${unit.buildMarker}.`, {
+        expected,
+        resolved: {
+            unitId: unit.unitId,
+            buildMarker: unit.buildMarker
+        }
+    });
+}
+exports.createDiscoveryError = __webpack_exports__.createDiscoveryError;
+exports.matchDeliveryUnitIdentity = __webpack_exports__.matchDeliveryUnitIdentity;
+exports.selectResolvedSurface = __webpack_exports__.selectResolvedSurface;
+exports.validateResolvedDeliveryUnit = __webpack_exports__.validateResolvedDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDiscoveryError",
+    "matchDeliveryUnitIdentity",
+    "selectResolvedSurface",
+    "validateResolvedDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/modulePath.mjs

@@ -2,7 +2,13 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 const SOURCE_EXTENSIONS = [
     '.ts',
-    '.js'
+    '.tsx',
+    '.js',
+    '.jsx'
+];
+const TS_EXTENSIONS = [
+    '.ts',
+    '.tsx'
 ];
 const JS_LIKE_EXTENSION_RE = /\.(?:c|m)?js$/;
 const isFile = (filepath)=>node_fs.existsSync(filepath) && node_fs.statSync(filepath).isFile();
@@ -11,8 +17,11 @@ const findSourceEntry = (resolvedPath)=>{
     if (ext) {
         if (isFile(resolvedPath)) return resolvedPath;
         if (JS_LIKE_EXTENSION_RE.test(resolvedPath)) {
-            const tsPath = `${resolvedPath.slice(0, -ext.length)}.ts`;
-            if (isFile(tsPath)) return tsPath;
+            const withoutExt = resolvedPath.slice(0, -ext.length);
+            for (const candidateExt of TS_EXTENSIONS){
+                const tsPath = `${withoutExt}${candidateExt}`;
+                if (isFile(tsPath)) return tsPath;
+            }
         }
         return;
     }

package/dist/esm/universal/backend-federation-contract/build-artifact.mjs

@@ -0,0 +1,135 @@
+import { DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_SCHEMA_VERSION } from "./constants.mjs";
+import { deliveryUnitIdentityFieldValue, validateDeliveryUnitRecord } from "./delivery-unit.mjs";
+import { addError, isRecord, nonEmptyString, recordField, validationResult } from "./validation-core.mjs";
+const createUltramodernBuildArtifact = (record)=>{
+    const deliveryUnit = {
+        appId: record.appId,
+        build: record.buildMarker,
+        buildMarker: record.buildMarker,
+        deployProfile: record.deployProfile,
+        kind: record.kind,
+        packageName: record.packageName,
+        schemaVersion: record.schemaVersion,
+        sourceRevision: record.sourceRevision,
+        unitId: record.unitId,
+        version: record.version
+    };
+    const api = {
+        appId: deliveryUnit.appId,
+        build: deliveryUnit.build,
+        buildMarker: deliveryUnit.buildMarker,
+        deployProfile: deliveryUnit.deployProfile,
+        kind: deliveryUnit.kind,
+        packageName: deliveryUnit.packageName,
+        schemaVersion: deliveryUnit.schemaVersion,
+        sourceRevision: deliveryUnit.sourceRevision,
+        surface: 'api',
+        unitId: deliveryUnit.unitId,
+        version: deliveryUnit.version
+    };
+    const ui = {
+        appId: deliveryUnit.appId,
+        build: deliveryUnit.build,
+        buildMarker: deliveryUnit.buildMarker,
+        deployProfile: deliveryUnit.deployProfile,
+        kind: deliveryUnit.kind,
+        packageName: deliveryUnit.packageName,
+        schemaVersion: deliveryUnit.schemaVersion,
+        sourceRevision: deliveryUnit.sourceRevision,
+        surface: 'ui',
+        unitId: deliveryUnit.unitId,
+        version: deliveryUnit.version
+    };
+    return {
+        deliveryUnit,
+        kind: 'ultramodern-build-artifact',
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        surfaces: {
+            api,
+            ui
+        }
+    };
+};
+const validateUltramodernBuildArtifact = (value, path = 'artifact')=>{
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    if (value.schemaVersion !== DELIVERY_UNIT_SCHEMA_VERSION) addError(errors, `${path}.schemaVersion`, `must be ${DELIVERY_UNIT_SCHEMA_VERSION}.`);
+    if ('ultramodern-build-artifact' !== value.kind) addError(errors, `${path}.kind`, 'must be "ultramodern-build-artifact".');
+    const deliveryUnit = value.deliveryUnit;
+    errors.push(...validateDeliveryUnitRecord(deliveryUnit, {
+        path: `${path}.deliveryUnit`,
+        allowBuildAlias: true
+    }).errors);
+    if (isRecord(deliveryUnit)) {
+        const build = nonEmptyString(deliveryUnit.build);
+        const buildMarker = nonEmptyString(deliveryUnit.buildMarker);
+        if (build) {
+            if (buildMarker && build !== buildMarker) addError(errors, `${path}.deliveryUnit.build`, 'must match deliveryUnit.buildMarker.');
+        } else addError(errors, `${path}.deliveryUnit.build`, 'must be a non-empty string.');
+    }
+    const surfaces = recordField(value, 'surfaces');
+    if (!surfaces) {
+        addError(errors, `${path}.surfaces`, 'must be an object.');
+        return validationResult(errors);
+    }
+    for (const surface of [
+        'ui',
+        'api'
+    ]){
+        const marker = surfaces[surface];
+        const markerPath = `${path}.surfaces.${surface}`;
+        errors.push(...validateDeliveryUnitRecord(marker, {
+            path: markerPath,
+            allowBuildAlias: true
+        }).errors);
+        if (!isRecord(marker)) continue;
+        const markerBuild = nonEmptyString(marker.build);
+        const markerBuildMarker = nonEmptyString(marker.buildMarker);
+        if (markerBuild) {
+            if (markerBuildMarker && markerBuild !== markerBuildMarker) addError(errors, `${markerPath}.build`, 'must match buildMarker.');
+        } else addError(errors, `${markerPath}.build`, 'must be non-empty string.');
+        if (marker.surface !== surface) addError(errors, `${markerPath}.surface`, `must be "${surface}".`);
+        for (const field of DELIVERY_UNIT_IDENTITY_FIELDS){
+            const deliveryUnitValue = deliveryUnitIdentityFieldValue(deliveryUnit, field, {
+                allowBuildAlias: true
+            });
+            const markerValue = deliveryUnitIdentityFieldValue(marker, field, {
+                allowBuildAlias: true
+            });
+            if (void 0 !== deliveryUnitValue && void 0 !== markerValue && deliveryUnitValue !== markerValue) addError(errors, `${markerPath}.${field}`, `must match ${path}.deliveryUnit.${field}.`);
+        }
+    }
+    return validationResult(errors);
+};
+const isUltramodernBuildArtifact = (value)=>validateUltramodernBuildArtifact(value).ok;
+const stampUltramodernBuildArtifactIdentity = (artifact, identity)=>({
+        ...artifact,
+        deliveryUnit: {
+            ...artifact.deliveryUnit,
+            build: identity.buildMarker,
+            buildMarker: identity.buildMarker,
+            sourceRevision: identity.sourceRevision
+        },
+        surfaces: {
+            ui: {
+                ...artifact.surfaces.ui,
+                build: identity.buildMarker,
+                buildMarker: identity.buildMarker,
+                sourceRevision: identity.sourceRevision
+            },
+            api: {
+                ...artifact.surfaces.api,
+                build: identity.buildMarker,
+                buildMarker: identity.buildMarker,
+                sourceRevision: identity.sourceRevision
+            }
+        }
+    });
+const stampUltramodernBuildArtifactSourceRevision = (artifact, sourceRevision)=>stampUltramodernBuildArtifactIdentity(artifact, {
+        buildMarker: artifact.deliveryUnit.buildMarker,
+        sourceRevision
+    });
+export { createUltramodernBuildArtifact, isUltramodernBuildArtifact, stampUltramodernBuildArtifactIdentity, stampUltramodernBuildArtifactSourceRevision, validateUltramodernBuildArtifact };

package/dist/esm/universal/backend-federation-contract/constants.mjs

@@ -0,0 +1,18 @@
+const BACKEND_FEDERATION_EFFECT_EXPOSE = './effect-api';
+const BACKEND_FEDERATION_MANIFEST_FILE = 'backend-mf-manifest.json';
+const BACKEND_FEDERATION_REMOTE_ENTRY_FILE = 'backendRemoteEntry.cjs';
+const BACKEND_FEDERATION_CONTRACT_VERSION = 'microvertical-server-effect-v1';
+const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = 'backend-mf-effect-v1';
+const DELIVERY_UNIT_SCHEMA_VERSION = 1;
+const DELIVERY_UNIT_KIND = 'microvertical-delivery-unit';
+const DELIVERY_UNIT_DEPLOY_PROFILE = 'cloudflare-ssr-mf-effect-v1';
+const DELIVERY_UNIT_IDENTITY_FIELDS = [
+    'unitId',
+    'buildMarker',
+    'sourceRevision'
+];
+const ULTRAMODERN_BUILD_ARTIFACT_FILE = 'ultramodern-build.json';
+const ULTRAMODERN_BUILD_ARTIFACT_PATH = `shared/${ULTRAMODERN_BUILD_ARTIFACT_FILE}`;
+const ULTRAMODERN_BUILD_MODULE_FILE = 'ultramodern-build.ts';
+const ULTRAMODERN_BUILD_MODULE_PATH = `shared/${ULTRAMODERN_BUILD_MODULE_FILE}`;
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_FILE, ULTRAMODERN_BUILD_MODULE_PATH };

package/dist/esm/universal/backend-federation-contract/delivery-unit.mjs

@@ -0,0 +1,74 @@
+import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION } from "./constants.mjs";
+import { addError, isRecord, nonEmptyString, validationResult } from "./validation-core.mjs";
+const deliveryUnitIdentityFieldValue = (value, field, options = {})=>{
+    if (!isRecord(value)) return;
+    if ('buildMarker' === field && options.allowBuildAlias) return nonEmptyString(value.buildMarker) ?? nonEmptyString(value.build);
+    return nonEmptyString(value[field]);
+};
+const validateDeliveryUnitIdentity = (value, options = {})=>{
+    const path = options.path ?? 'deliveryUnit';
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    for (const field of DELIVERY_UNIT_IDENTITY_FIELDS)if (!deliveryUnitIdentityFieldValue(value, field, options)) addError(errors, `${path}.${field}`, 'must be a non-empty string.');
+    return validationResult(errors);
+};
+const validateDeliveryUnitContractBlock = (value, options = {})=>{
+    const path = options.path ?? 'deliveryUnit';
+    const errors = [
+        ...validateDeliveryUnitIdentity(value, options).errors
+    ];
+    if (!isRecord(value)) return validationResult(errors);
+    if (value.schemaVersion !== DELIVERY_UNIT_SCHEMA_VERSION) addError(errors, `${path}.schemaVersion`, `must be ${DELIVERY_UNIT_SCHEMA_VERSION}.`);
+    if (value.kind !== DELIVERY_UNIT_KIND) addError(errors, `${path}.kind`, `must be "${DELIVERY_UNIT_KIND}".`);
+    if (!nonEmptyString(value.packageName)) addError(errors, `${path}.packageName`, 'must be a non-empty string.');
+    if (!nonEmptyString(value.version)) addError(errors, `${path}.version`, 'must be a non-empty string.');
+    return validationResult(errors);
+};
+const validateDeliveryUnitRecord = (value, options = {})=>{
+    const path = options.path ?? 'deliveryUnit';
+    const errors = [
+        ...validateDeliveryUnitContractBlock(value, {
+            ...options,
+            path
+        }).errors
+    ];
+    if (!isRecord(value)) return validationResult(errors);
+    if (!nonEmptyString(value.appId)) addError(errors, `${path}.appId`, 'must be a non-empty string.');
+    if (value.deployProfile !== DELIVERY_UNIT_DEPLOY_PROFILE) addError(errors, `${path}.deployProfile`, `must be "${DELIVERY_UNIT_DEPLOY_PROFILE}".`);
+    return validationResult(errors);
+};
+const validateDeliveryUnitBoundaryIdentity = (value, path)=>{
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return errors;
+    }
+    for (const field of DELIVERY_UNIT_IDENTITY_FIELDS)if (!deliveryUnitIdentityFieldValue(value, field)) addError(errors, `${path}.${field}`, 'must be a non-empty string.');
+    return errors;
+};
+const deliveryUnitContractBlock = (record)=>({
+        schemaVersion: record.schemaVersion,
+        kind: record.kind,
+        unitId: record.unitId,
+        packageName: record.packageName,
+        version: record.version,
+        buildMarker: record.buildMarker,
+        sourceRevision: record.sourceRevision
+    });
+const toDeliveryUnitIdentity = (value)=>{
+    const unitId = deliveryUnitIdentityFieldValue(value, 'unitId');
+    const buildMarker = deliveryUnitIdentityFieldValue(value, 'buildMarker', {
+        allowBuildAlias: true
+    });
+    const sourceRevision = deliveryUnitIdentityFieldValue(value, 'sourceRevision');
+    if (!unitId || !buildMarker || !sourceRevision) return;
+    return {
+        unitId,
+        buildMarker,
+        sourceRevision
+    };
+};
+export { deliveryUnitContractBlock, deliveryUnitIdentityFieldValue, toDeliveryUnitIdentity, validateDeliveryUnitBoundaryIdentity, validateDeliveryUnitContractBlock, validateDeliveryUnitIdentity, validateDeliveryUnitRecord };