@bleedingdev/modern-js-utils 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

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

@@ -0,0 +1,136 @@
+import "node:module";
+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-node/universal/backend-federation-contract/constants.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+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-node/universal/backend-federation-contract/delivery-unit.mjs

@@ -0,0 +1,75 @@
+import "node:module";
+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 };

package/dist/esm-node/universal/backend-federation-contract/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export { createUltramodernBuildArtifact, isUltramodernBuildArtifact, stampUltramodernBuildArtifactIdentity, stampUltramodernBuildArtifactSourceRevision, validateUltramodernBuildArtifact } from "./build-artifact.mjs";
+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 } from "./constants.mjs";
+export { deliveryUnitContractBlock, deliveryUnitIdentityFieldValue, toDeliveryUnitIdentity, validateDeliveryUnitContractBlock, validateDeliveryUnitIdentity, validateDeliveryUnitRecord } from "./delivery-unit.mjs";
+export { backendFederationExposeNames, backendFederationMetadata, backendFederationVersionBoundary, toBackendFederationExposeNames, validateBackendFederationManifest, validateBackendFederationMetadata } from "./metadata.mjs";
+export { formatBackendFederationValidationErrors, nonEmptyString } from "./validation-core.mjs";

package/dist/esm-node/universal/backend-federation-contract/metadata.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, DELIVERY_UNIT_IDENTITY_FIELDS, DELIVERY_UNIT_SCHEMA_VERSION } from "./constants.mjs";
+import { deliveryUnitIdentityFieldValue, validateDeliveryUnitBoundaryIdentity, validateDeliveryUnitContractBlock } from "./delivery-unit.mjs";
+import { addError, isRecord, nonEmptyString, recordField, validateVersionField, validationResult } from "./validation-core.mjs";
+const toBackendFederationExposeNames = (value)=>{
+    const names = [];
+    if (Array.isArray(value)) for (const expose of value){
+        const name = nonEmptyString(expose) ?? (isRecord(expose) ? nonEmptyString(expose.name) : void 0);
+        if (name) names.push(name);
+    }
+    else if (isRecord(value)) names.push(...Object.keys(value).filter((name)=>name.length > 0));
+    return Array.from(new Set(names));
+};
+const backendFederationExposeNames = (value)=>{
+    if (!isRecord(value)) return [];
+    const exposes = toBackendFederationExposeNames(value.exposes);
+    const expose = nonEmptyString(value.expose);
+    return Array.from(new Set([
+        ...exposes,
+        ...expose ? [
+            expose
+        ] : []
+    ]));
+};
+const backendFederationMetadata = (value)=>isRecord(value) ? recordField(value, 'backendFederation') : void 0;
+const backendFederationVersionBoundary = (value)=>recordField(backendFederationMetadata(value), 'versionBoundary');
+const validateBackendFederationMetadata = (value, options = {})=>{
+    const path = options.path ?? 'backendFederation';
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    if (options.requireEffectRuntime && 'effect' !== value.runtimeFramework) addError(errors, `${path}.runtimeFramework`, 'must be "effect".');
+    if (options.requireEffectRuntime && true !== value.strictEffectApproach) addError(errors, `${path}.strictEffectApproach`, 'must be true.');
+    validateVersionField(errors, value, 'contractVersion', options.expectedContractVersion ?? BACKEND_FEDERATION_CONTRACT_VERSION, path, options.requireVersionFields ?? false);
+    validateVersionField(errors, value, 'nodeAdapterVersion', options.expectedNodeAdapterVersion ?? BACKEND_FEDERATION_NODE_ADAPTER_VERSION, path, options.requireVersionFields ?? false);
+    if (options.requireEffectExpose && !backendFederationExposeNames(value).includes(BACKEND_FEDERATION_EFFECT_EXPOSE)) addError(errors, `${path}.expose`, `must include "${BACKEND_FEDERATION_EFFECT_EXPOSE}".`);
+    if (options.validateDeliveryUnit ?? true) {
+        const deliveryUnit = recordField(value, 'deliveryUnit');
+        if (deliveryUnit) errors.push(...validateDeliveryUnitContractBlock(deliveryUnit, {
+            path: `${path}.deliveryUnit`
+        }).errors);
+        const versionBoundary = recordField(value, 'versionBoundary');
+        const versionBoundaryDeliveryUnit = recordField(versionBoundary, 'deliveryUnit');
+        if (versionBoundaryDeliveryUnit) errors.push(...validateDeliveryUnitBoundaryIdentity(versionBoundaryDeliveryUnit, `${path}.versionBoundary.deliveryUnit`));
+        if (deliveryUnit && versionBoundaryDeliveryUnit) for (const field of DELIVERY_UNIT_IDENTITY_FIELDS){
+            const deliveryUnitValue = deliveryUnitIdentityFieldValue(deliveryUnit, field);
+            const versionBoundaryDeliveryUnitValue = deliveryUnitIdentityFieldValue(versionBoundaryDeliveryUnit, field);
+            if (deliveryUnitValue && versionBoundaryDeliveryUnitValue && deliveryUnitValue !== versionBoundaryDeliveryUnitValue) addError(errors, `${path}.versionBoundary.deliveryUnit.${field}`, `must match ${path}.deliveryUnit.${field}.`);
+        }
+    }
+    return validationResult(errors);
+};
+const validateBackendFederationManifest = (value, options = {})=>{
+    const path = options.path ?? 'manifest';
+    const errors = [];
+    if (!isRecord(value)) {
+        addError(errors, path, 'must be an object.');
+        return validationResult(errors);
+    }
+    if (void 0 !== value.schemaVersion && value.schemaVersion !== DELIVERY_UNIT_SCHEMA_VERSION) addError(errors, `${path}.schemaVersion`, `must be ${DELIVERY_UNIT_SCHEMA_VERSION}.`);
+    const metadata = backendFederationMetadata(value);
+    if (metadata) errors.push(...validateBackendFederationMetadata(metadata, {
+        ...options,
+        path: `${path}.backendFederation`,
+        requireEffectExpose: false
+    }).errors);
+    else if (options.requireBackendFederation ?? true) addError(errors, `${path}.backendFederation`, 'must be an object.');
+    if (options.requireEffectExpose) {
+        const topLevelExposeNames = toBackendFederationExposeNames(value.exposes);
+        const metadataExposeNames = backendFederationExposeNames(metadata);
+        const exposeNames = new Set([
+            ...topLevelExposeNames,
+            ...metadataExposeNames
+        ]);
+        if (!exposeNames.has(BACKEND_FEDERATION_EFFECT_EXPOSE)) addError(errors, `${path}.exposes`, `must include "${BACKEND_FEDERATION_EFFECT_EXPOSE}".`);
+    }
+    return validationResult(errors);
+};
+export { backendFederationExposeNames, backendFederationMetadata, backendFederationVersionBoundary, toBackendFederationExposeNames, validateBackendFederationManifest, validateBackendFederationMetadata };

package/dist/esm-node/universal/backend-federation-contract/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/universal/backend-federation-contract/validation-core.mjs

@@ -0,0 +1,30 @@
+import "node:module";
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const nonEmptyString = (value)=>'string' == typeof value && value.trim().length > 0 ? value : void 0;
+const validationResult = (errors)=>({
+        ok: 0 === errors.length,
+        errors
+    });
+const addError = (errors, path, message)=>{
+    errors.push({
+        path,
+        message
+    });
+};
+const recordField = (value, field)=>{
+    const fieldValue = value?.[field];
+    return isRecord(fieldValue) ? fieldValue : void 0;
+};
+const formatBackendFederationValidationErrors = (errors)=>errors.map((error)=>`${error.path}: ${error.message}`).join('; ');
+const validateVersionField = (errors, record, field, expected, path, required)=>{
+    const compatibility = recordField(record, 'compatibility');
+    const executionSurfaces = recordField(record, 'executionSurfaces');
+    const nodeSurface = recordField(executionSurfaces, 'node');
+    const actual = nonEmptyString(record[field]) ?? nonEmptyString(compatibility?.[field]) ?? ('nodeAdapterVersion' === field ? nonEmptyString(nodeSurface?.adapterVersion) : void 0);
+    if (!actual) {
+        if (required) addError(errors, `${path}.${field}`, 'must be a non-empty string.');
+        return;
+    }
+    if (false !== expected && actual !== expected) addError(errors, `${path}.${field}`, `must be "${expected}".`);
+};
+export { addError, formatBackendFederationValidationErrors, isRecord, nonEmptyString, recordField, validateVersionField, validationResult };

package/dist/esm-node/universal/index.mjs

@@ -1,2 +1,4 @@
 import "node:module";
+export * from "./backend-federation-contract/index.mjs";
+export * from "./surface-resolution/index.mjs";
 export { cutNameByHyphen } from "./path.mjs";

package/dist/esm-node/universal/surface-resolution/env-static-provider.mjs

@@ -0,0 +1,275 @@
+import "node:module";
+import { formatSurfaceRef } from "./surface-ref.mjs";
+import { createDiscoveryError, validateResolvedDeliveryUnit } from "./validation.mjs";
+const DEFAULT_LOCAL_ENVIRONMENTS = [
+    'development',
+    'local'
+];
+const ENV_STATIC_PROVIDER_NAME = 'env-static';
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/u, '');
+}
+function envValue(env, name) {
+    const value = env[name]?.trim();
+    return void 0 !== value && value.length > 0 ? value : void 0;
+}
+function stripMfNamePrefix(value, mfName) {
+    return value.startsWith(`${mfName}@`) ? value.slice(mfName.length + 1) : value;
+}
+function createEnvContext(env, allowLocalFallback) {
+    return {
+        env,
+        allowLocalFallback,
+        cloudflareDeployEnabled: 'cloudflare' === env.MODERNJS_DEPLOY,
+        workersDevSubdomain: envValue(env, 'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'),
+        requireCloudflarePublicUrls: 'true' === env.ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS
+    };
+}
+function resolveBaseUrl(context, unit) {
+    const publicUrlEnv = `ULTRAMODERN_PUBLIC_URL_${unit.envSegment}`;
+    const configuredPublicUrl = envValue(context.env, publicUrlEnv);
+    if (void 0 !== configuredPublicUrl) return {
+        ok: true,
+        baseUrl: trimTrailingSlashes(configuredPublicUrl)
+    };
+    if (context.cloudflareDeployEnabled && void 0 !== context.workersDevSubdomain && void 0 !== unit.workerName) return {
+        ok: true,
+        baseUrl: `https://${unit.workerName}.${context.workersDevSubdomain}.workers.dev`
+    };
+    if (context.cloudflareDeployEnabled && context.requireCloudflarePublicUrls) return {
+        ok: false,
+        reason: `Cloudflare deploy requires ${publicUrlEnv} (or a configured manifest env / ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN with a worker name)`,
+        details: {
+            publicUrlEnv
+        }
+    };
+    if (void 0 !== unit.port && context.allowLocalFallback) return {
+        ok: true,
+        baseUrl: `http://localhost:${unit.port}`
+    };
+    if (void 0 !== unit.port) return {
+        ok: false,
+        reason: `No base URL available: set ${publicUrlEnv} (localhost fallback is disabled outside designated local environments)`,
+        details: {
+            publicUrlEnv
+        }
+    };
+    return {
+        ok: false,
+        reason: `No base URL available: set ${publicUrlEnv} or configure a localhost port`,
+        details: {
+            publicUrlEnv
+        }
+    };
+}
+function resolveBrowserMfManifest(context, unit) {
+    const manifestEnv = `VERTICAL_${unit.envSegment}_MF_MANIFEST`;
+    const configuredManifest = envValue(context.env, manifestEnv);
+    if (void 0 !== configuredManifest) return {
+        ok: true,
+        location: {
+            platform: 'browser-mf-manifest',
+            manifestUrl: stripMfNamePrefix(configuredManifest, unit.mfName)
+        }
+    };
+    const base = resolveBaseUrl(context, unit);
+    if (!base.ok) return {
+        ok: false,
+        reason: `browser-mf-manifest unavailable (${manifestEnv} unset; ${base.reason})`,
+        details: {
+            manifestEnv,
+            ...base.details
+        }
+    };
+    return {
+        ok: true,
+        location: {
+            platform: 'browser-mf-manifest',
+            manifestUrl: `${base.baseUrl}/mf-manifest.json`
+        }
+    };
+}
+function resolveNodeMfManifest(context, unit) {
+    const manifestEnv = `VERTICAL_${unit.envSegment}_BACKEND_MF_MANIFEST`;
+    const configuredManifest = envValue(context.env, manifestEnv);
+    if (void 0 !== configuredManifest) return {
+        ok: true,
+        location: {
+            platform: 'node-mf-manifest',
+            manifestRef: configuredManifest
+        }
+    };
+    if (void 0 !== unit.port && context.allowLocalFallback) return {
+        ok: true,
+        location: {
+            platform: 'node-mf-manifest',
+            manifestRef: `http://localhost:${unit.port}/backend-mf-manifest.json`
+        }
+    };
+    if (void 0 !== unit.port) return {
+        ok: false,
+        reason: `node-mf-manifest unavailable: set ${manifestEnv} (localhost fallback is disabled outside designated local environments)`,
+        details: {
+            manifestEnv
+        }
+    };
+    return {
+        ok: false,
+        reason: `node-mf-manifest unavailable: set ${manifestEnv} or configure a localhost port`,
+        details: {
+            manifestEnv
+        }
+    };
+}
+function resolveHttpApi(context, unit, config) {
+    const base = resolveBaseUrl(context, unit);
+    if (!base.ok) return {
+        ok: false,
+        reason: `http-api unavailable (${base.reason})`,
+        details: base.details
+    };
+    return {
+        ok: true,
+        location: {
+            platform: 'http-api',
+            baseUrl: base.baseUrl,
+            prefix: config.prefix
+        }
+    };
+}
+function resolveCloudflareServiceBinding(config) {
+    if (0 === config.serviceBinding.length) return {
+        ok: false,
+        reason: 'cloudflare-service-binding unavailable: empty serviceBinding'
+    };
+    return {
+        ok: true,
+        location: {
+            platform: 'cloudflare-service-binding',
+            serviceBinding: config.serviceBinding,
+            ...void 0 === config.dispatchNamespace ? {} : {
+                dispatchNamespace: config.dispatchNamespace
+            }
+        }
+    };
+}
+function resolveSurfaceLocations(context, unit, surface) {
+    const outcomes = [];
+    if (surface.platforms.browserMfManifest) outcomes.push(resolveBrowserMfManifest(context, unit));
+    if (surface.platforms.nodeMfManifest) outcomes.push(resolveNodeMfManifest(context, unit));
+    if (void 0 !== surface.platforms.httpApi) outcomes.push(resolveHttpApi(context, unit, surface.platforms.httpApi));
+    if (void 0 !== surface.platforms.cloudflareServiceBinding) outcomes.push(resolveCloudflareServiceBinding(surface.platforms.cloudflareServiceBinding));
+    const failure = outcomes.find((outcome)=>!outcome.ok);
+    if (void 0 !== failure && !failure.ok) return {
+        ok: false,
+        reason: `surface ${surface.surfaceId}: ${failure.reason}`,
+        details: failure.details
+    };
+    const locations = outcomes.flatMap((outcome)=>outcome.ok ? [
+            outcome.location
+        ] : []);
+    if (0 === locations.length) return {
+        ok: false,
+        reason: `surface ${surface.surfaceId} declares no platform locations`
+    };
+    return {
+        ok: true,
+        surface: {
+            surfaceId: surface.surfaceId,
+            kind: surface.kind,
+            locations
+        }
+    };
+}
+function createEnvStaticSurfaceResolutionProvider(options) {
+    const env = options.env ?? {};
+    const localEnvironments = new Set(options.localEnvironments ?? DEFAULT_LOCAL_ENVIRONMENTS);
+    const identityVerification = options.identityVerification ?? 'static-trust';
+    const unitsById = new Map(options.units.map((unit)=>[
+            unit.unitId,
+            unit
+        ]));
+    return {
+        name: ENV_STATIC_PROVIDER_NAME,
+        resolve (ref, environment) {
+            const refString = formatSurfaceRef(ref);
+            const unit = unitsById.get(ref.unitId);
+            if (void 0 === unit) return {
+                ok: false,
+                error: createDiscoveryError('unknown-unit', refString, `No statically configured delivery unit ${ref.unitId}.`, {
+                    environment,
+                    knownUnits: [
+                        ...unitsById.keys()
+                    ]
+                })
+            };
+            if (!unit.surfaces.some((surface)=>surface.surfaceId === ref.surfaceId)) return {
+                ok: false,
+                error: createDiscoveryError('unknown-surface', refString, `Unit ${unit.unitId} does not declare surface ${ref.surfaceId}.`, {
+                    environment,
+                    availableSurfaces: unit.surfaces.map((surface)=>surface.surfaceId)
+                })
+            };
+            let effectiveUnit = unit;
+            if (void 0 !== ref.major) {
+                const majorConfig = (unit.majors ?? []).find((candidate)=>candidate.major === ref.major);
+                if (void 0 === majorConfig) return {
+                    ok: false,
+                    error: createDiscoveryError('major-not-published', refString, `Unit ${unit.unitId} has no materialization for external major v${ref.major}.`, {
+                        environment,
+                        publishedMajors: (unit.majors ?? []).map((candidate)=>candidate.major)
+                    })
+                };
+                effectiveUnit = {
+                    ...unit,
+                    envSegment: majorConfig.envSegment ?? `${unit.envSegment}_V${majorConfig.major}`,
+                    port: majorConfig.port,
+                    workerName: majorConfig.workerName
+                };
+            }
+            const context = createEnvContext(env, localEnvironments.has(environment));
+            const surfaces = [];
+            for (const surfaceConfig of unit.surfaces){
+                const resolved = resolveSurfaceLocations(context, effectiveUnit, surfaceConfig);
+                if (!resolved.ok) return {
+                    ok: false,
+                    error: createDiscoveryError('provider-unavailable', refString, `env-static provider cannot assemble a complete record for ${unit.unitId}: ${resolved.reason}.`, {
+                        environment,
+                        ...resolved.details
+                    })
+                };
+                surfaces.push(void 0 === ref.major ? resolved.surface : {
+                    ...resolved.surface,
+                    servedMajor: ref.major
+                });
+            }
+            const record = {
+                unitId: unit.unitId,
+                buildMarker: unit.buildMarker,
+                sourceRevision: unit.sourceRevision,
+                baselineCohortId: unit.baselineCohortId,
+                surfaces,
+                compatibility: {
+                    status: 'compatible',
+                    baselineCohortId: unit.baselineCohortId,
+                    ...'static-trust' === identityVerification ? {
+                        reason: 'static-identity-unverified'
+                    } : {}
+                }
+            };
+            const validation = validateResolvedDeliveryUnit(record);
+            if (!validation.ok) return {
+                ok: false,
+                error: createDiscoveryError('provider-unavailable', refString, `env-static provider assembled an invalid record for ${unit.unitId}.`, {
+                    environment,
+                    issues: validation.issues
+                })
+            };
+            return {
+                ok: true,
+                unit: record
+            };
+        }
+    };
+}
+export { DEFAULT_LOCAL_ENVIRONMENTS, ENV_STATIC_PROVIDER_NAME, createEnvStaticSurfaceResolutionProvider };

package/dist/esm-node/universal/surface-resolution/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { DEFAULT_LOCAL_ENVIRONMENTS, ENV_STATIC_PROVIDER_NAME, createEnvStaticSurfaceResolutionProvider } from "./env-static-provider.mjs";
+export { formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-ref.mjs";
+export { createDiscoveryError, matchDeliveryUnitIdentity, selectResolvedSurface, validateResolvedDeliveryUnit } from "./validation.mjs";