@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/cjs/ultramodern-workspace/delivery-unit-schema/types.cjs

@@ -0,0 +1,292 @@
+"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__, {
+    assertNever: ()=>assertNever,
+    formatSurfaceRef: ()=>formatSurfaceRef,
+    parseDeliveryUnitDescriptor: ()=>parseDeliveryUnitDescriptor,
+    parseSurfaceRef: ()=>parseSurfaceRef,
+    projectDeliveryUnitToV1: ()=>projectDeliveryUnitToV1,
+    resolvePublicationZone: ()=>resolvePublicationZone,
+    serializeDeliveryUnitDescriptor: ()=>serializeDeliveryUnitDescriptor
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_types_cjs_namespaceObject = require("../types.cjs");
+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;
+}
+function resolvePublicationZone(zone) {
+    return zone ?? {
+        zone: 'coordinated'
+    };
+}
+const KNOWN_DESCRIPTOR_KEYS = new Set([
+    'unitId',
+    'kind',
+    'owner',
+    'sourceRevision',
+    'buildMarker',
+    'baselineCohort',
+    'publicationZone',
+    'surfaces'
+]);
+const KNOWN_SURFACE_KEYS = new Set([
+    'kind',
+    'surfaceId',
+    'locations',
+    'protocol',
+    'externallyPublished'
+]);
+function splitUnknown(source, known) {
+    const unknown = {};
+    let hasUnknown = false;
+    for (const [key, value] of Object.entries(source))if (!known.has(key)) {
+        unknown[key] = value;
+        hasUnknown = true;
+    }
+    return hasUnknown ? unknown : void 0;
+}
+function parseDeliveryUnitDescriptor(source) {
+    const rawSurfaces = Array.isArray(source.surfaces) ? source.surfaces : [];
+    const surfaces = rawSurfaces.map((entry)=>{
+        const surface = entry;
+        const unknown = splitUnknown(entry, KNOWN_SURFACE_KEYS);
+        return void 0 === unknown ? surface : {
+            ...surface,
+            unknownFields: unknown
+        };
+    });
+    const descriptor = {
+        unitId: source.unitId,
+        kind: source.kind,
+        owner: source.owner,
+        sourceRevision: source.sourceRevision,
+        buildMarker: source.buildMarker,
+        baselineCohort: source.baselineCohort,
+        surfaces
+    };
+    if (void 0 !== source.publicationZone) descriptor.publicationZone = source.publicationZone;
+    const unknown = splitUnknown(source, KNOWN_DESCRIPTOR_KEYS);
+    if (void 0 !== unknown) descriptor.unknownFields = unknown;
+    return descriptor;
+}
+function serializeDeliveryUnitDescriptor(descriptor) {
+    const surfaces = descriptor.surfaces.map((surface)=>{
+        const { unknownFields, ...known } = surface;
+        return {
+            ...unknownFields ?? {},
+            ...known
+        };
+    });
+    const { unknownFields, surfaces: _surfaces, ...knownRest } = descriptor;
+    const output = {
+        ...unknownFields ?? {},
+        ...knownRest,
+        surfaces
+    };
+    return output;
+}
+function projectKind(kind) {
+    switch(kind){
+        case 'shell':
+            return 'shell';
+        case 'microvertical':
+        case 'horizontal-remote':
+            return 'vertical';
+        default:
+            return assertNever(kind);
+    }
+}
+function lastSegment(unitId) {
+    const segments = unitId.split('/');
+    return segments[segments.length - 1] ?? unitId;
+}
+function projectApi(surfaces, mode) {
+    const apiSurface = surfaces.find((surface)=>'api' === surface.kind);
+    if (void 0 === apiSurface) return;
+    const http = apiSurface.locations.find((location)=>'http' === location.platform);
+    return {
+        stem: apiSurface.surfaceId,
+        prefix: http?.address ?? `/${apiSurface.surfaceId}`,
+        consumedBy: [],
+        ...'extended-v1' === mode && (0, external_types_cjs_namespaceObject.isVerticalApiProtocol)(apiSurface.protocol) ? {
+            protocol: apiSurface.protocol
+        } : {}
+    };
+}
+function projectDeliveryUnitToV1(descriptor, context) {
+    const appId = lastSegment(descriptor.unitId);
+    const mode = context.mode ?? 'strict-legacy';
+    const api = projectApi(descriptor.surfaces, mode);
+    const ownership = 'team' === descriptor.owner.kind ? context.ownership : {
+        ...context.ownership,
+        owner: {
+            ...descriptor.owner
+        }
+    };
+    const app = {
+        id: appId,
+        directory: context.directory,
+        packageSuffix: context.packageSuffix,
+        displayName: context.displayName,
+        kind: projectKind(descriptor.kind),
+        portEnv: context.portEnv,
+        port: context.port,
+        mfName: context.mfName,
+        ownership,
+        ...'extended-v1' === mode && 'horizontal-remote' === descriptor.kind ? {
+            deliveryUnitKind: 'horizontal-remote'
+        } : {},
+        ...void 0 === api ? {} : {
+            api
+        }
+    };
+    const deliveryUnitRecord = {
+        appId,
+        buildMarker: descriptor.buildMarker,
+        deployProfile: universal_namespaceObject.DELIVERY_UNIT_DEPLOY_PROFILE,
+        kind: universal_namespaceObject.DELIVERY_UNIT_KIND,
+        packageName: context.packageName,
+        schemaVersion: universal_namespaceObject.DELIVERY_UNIT_SCHEMA_VERSION,
+        sourceRevision: descriptor.sourceRevision,
+        unitId: descriptor.unitId,
+        version: context.version
+    };
+    return {
+        app,
+        deliveryUnitRecord,
+        preservedUnknownFields: descriptor.unknownFields ?? {}
+    };
+}
+function assertNever(value) {
+    throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
+}
+exports.assertNever = __webpack_exports__.assertNever;
+exports.formatSurfaceRef = __webpack_exports__.formatSurfaceRef;
+exports.parseDeliveryUnitDescriptor = __webpack_exports__.parseDeliveryUnitDescriptor;
+exports.parseSurfaceRef = __webpack_exports__.parseSurfaceRef;
+exports.projectDeliveryUnitToV1 = __webpack_exports__.projectDeliveryUnitToV1;
+exports.resolvePublicationZone = __webpack_exports__.resolvePublicationZone;
+exports.serializeDeliveryUnitDescriptor = __webpack_exports__.serializeDeliveryUnitDescriptor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertNever",
+    "formatSurfaceRef",
+    "parseDeliveryUnitDescriptor",
+    "parseSurfaceRef",
+    "projectDeliveryUnitToV1",
+    "resolvePublicationZone",
+    "serializeDeliveryUnitDescriptor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/delivery-unit-schema/up-projection.cjs

@@ -0,0 +1,188 @@
+"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__);
+function ownershipToOwner(ownership) {
+    if (void 0 !== ownership.owner) {
+        const { kind, id, contact } = ownership.owner;
+        return void 0 === contact ? {
+            kind,
+            id
+        } : {
+            kind,
+            id,
+            contact
+        };
+    }
+    return {
+        kind: 'team',
+        id: ownership.team,
+        contact: ownership.slack
+    };
+}
+function projectKindUp(app, mode) {
+    if ('shell' === app.kind) return 'shell';
+    return 'extended-v1' === mode && 'horizontal-remote' === app.deliveryUnitKind ? 'horizontal-remote' : 'microvertical';
+}
+const SEGMENT_UNSAFE = /[^A-Za-z0-9._-]+/g;
+const SEGMENT_TRIM = /^-+|-+$/g;
+function exposeSurfaceId(key) {
+    const trimmed = key.replace(/^\.\//, '');
+    const cleaned = trimmed.replace(SEGMENT_UNSAFE, '-').replace(SEGMENT_TRIM, '');
+    return '' === cleaned ? 'surface' : cleaned;
+}
+function exposeSurface(app, key, value) {
+    const isRoute = /route/i.test(key) || /route/i.test(value);
+    const location = {
+        platform: 'browser-mf',
+        manifestUrl: `http://localhost:${app.port}/mf-manifest.json`
+    };
+    const common = {
+        surfaceId: exposeSurfaceId(key),
+        locations: [
+            location
+        ]
+    };
+    return isRoute ? {
+        kind: 'route',
+        ...common
+    } : {
+        kind: 'component',
+        ...common
+    };
+}
+function apiSurface(api, protocol, address = api.prefix) {
+    return {
+        kind: 'api',
+        surfaceId: api.stem,
+        protocol,
+        locations: [
+            {
+                platform: 'http',
+                address
+            }
+        ]
+    };
+}
+function projectSurfaces(app, protocol) {
+    const surfaces = [];
+    for (const [key, value] of Object.entries(app.exposes ?? {}))surfaces.push(exposeSurface(app, key, value));
+    if (void 0 !== app.api) surfaces.push(apiSurface(app.api, protocol));
+    return surfaces;
+}
+function projectV1ToDeliveryUnit(app, context) {
+    const mode = context.mode ?? 'strict-legacy';
+    const protocol = context.apiProtocol ?? ('extended-v1' === mode ? app.api?.protocol : void 0) ?? 'rest';
+    return {
+        unitId: `${context.scope}/${app.domain ?? app.id}`,
+        kind: projectKindUp(app, mode),
+        owner: ownershipToOwner(app.ownership),
+        sourceRevision: context.sourceRevision,
+        buildMarker: context.buildMarker,
+        baselineCohort: context.baselineCohort,
+        publicationZone: {
+            zone: 'coordinated'
+        },
+        surfaces: projectSurfaces(app, protocol)
+    };
+}
+class V1UnrepresentableError extends Error {
+    constructor(reason){
+        super(`Descriptor unrepresentable in v1: ${reason}.`), this.code = 'unrepresentable-in-v1';
+        this.name = 'V1UnrepresentableError';
+        this.reason = reason;
+    }
+}
+function checkSurfaceRepresentable(surface, mode) {
+    if ('component' === surface.kind || 'route' === surface.kind) return 'component-or-route-surface';
+    if ('backend' === surface.kind) return 'backend-surface';
+    if ('rest' !== surface.protocol && !('extended-v1' === mode && 'rpc' === surface.protocol)) return 'non-rest-protocol';
+    const [first, ...rest] = surface.locations;
+    if (void 0 === first || rest.length > 0 || 'http' !== first.platform) return 'unsupported-surface-shape';
+    if (void 0 !== surface.externallyPublished || void 0 !== surface.unknownFields) return 'unsupported-surface-shape';
+}
+function checkV1Representable(descriptor, mode = 'strict-legacy') {
+    const unrepresentable = (reason)=>({
+            representable: false,
+            code: 'unrepresentable-in-v1',
+            reason
+        });
+    if ('strict-legacy' === mode && 'horizontal-remote' === descriptor.kind) return unrepresentable('horizontal-remote-kind');
+    if (void 0 !== descriptor.unknownFields) return unrepresentable('unknown-fields');
+    const zone = descriptor.publicationZone;
+    if (void 0 === zone) return unrepresentable('non-canonical-zone');
+    if ('external' === zone.zone) return unrepresentable('external-zone');
+    if ('coordinated' !== zone.zone || 1 !== Object.keys(zone).length) return unrepresentable('non-canonical-zone');
+    let apiSurfaceCount = 0;
+    for (const surface of descriptor.surfaces){
+        if ('api' === surface.kind) {
+            apiSurfaceCount += 1;
+            if (apiSurfaceCount > 1) return unrepresentable('multiple-api-surfaces');
+        }
+        const reason = checkSurfaceRepresentable(surface, mode);
+        if (void 0 !== reason) return unrepresentable(reason);
+    }
+    return {
+        representable: true
+    };
+}
+function assertV1Representable(descriptor, mode = 'strict-legacy') {
+    const result = checkV1Representable(descriptor, mode);
+    if (!result.representable) throw new V1UnrepresentableError(result.reason);
+}
+__webpack_require__.d(__webpack_exports__, {
+    V1UnrepresentableError: ()=>V1UnrepresentableError,
+    apiSurface: ()=>apiSurface,
+    assertV1Representable: ()=>assertV1Representable,
+    checkV1Representable: ()=>checkV1Representable,
+    exposeSurface: ()=>exposeSurface,
+    exposeSurfaceId: ()=>exposeSurfaceId,
+    ownershipToOwner: ()=>ownershipToOwner,
+    projectV1ToDeliveryUnit: ()=>projectV1ToDeliveryUnit
+});
+exports.V1UnrepresentableError = __webpack_exports__.V1UnrepresentableError;
+exports.apiSurface = __webpack_exports__.apiSurface;
+exports.assertV1Representable = __webpack_exports__.assertV1Representable;
+exports.checkV1Representable = __webpack_exports__.checkV1Representable;
+exports.exposeSurface = __webpack_exports__.exposeSurface;
+exports.exposeSurfaceId = __webpack_exports__.exposeSurfaceId;
+exports.ownershipToOwner = __webpack_exports__.ownershipToOwner;
+exports.projectV1ToDeliveryUnit = __webpack_exports__.projectV1ToDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "V1UnrepresentableError",
+    "apiSurface",
+    "assertV1Representable",
+    "checkV1Representable",
+    "exposeSurface",
+    "exposeSurfaceId",
+    "ownershipToOwner",
+    "projectV1ToDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/delivery-unit-stamp.cjs

@@ -0,0 +1,59 @@
+"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__, {
+    isPlainObject: ()=>isPlainObject,
+    stampDeliveryUnitIdentity: ()=>stampDeliveryUnitIdentity
+});
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app));
+    entry.deliveryUnit = block;
+    if (isPlainObject(entry.backendFederation)) {
+        entry.backendFederation.deliveryUnit = block;
+        if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
+        entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
+        return;
+    }
+    const contract = (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app);
+    if (void 0 !== contract) entry.backendFederation = contract;
+}
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.stampDeliveryUnitIdentity = __webpack_exports__.stampDeliveryUnitIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isPlainObject",
+    "stampDeliveryUnitIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/delivery-unit-sync.cjs

@@ -0,0 +1,150 @@
+"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__, {
+    runSyncDeliveryUnit: ()=>runSyncDeliveryUnit
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
+const config_cjs_namespaceObject = require("../ultramodern-tooling/config.cjs");
+const external_delivery_unit_stamp_cjs_namespaceObject = require("./delivery-unit-stamp.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_module_federation_cjs_namespaceObject = require("./module-federation.cjs");
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function writeTextIfChanged(absolutePath, content) {
+    if (external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().readFileSync(absolutePath, 'utf-8') === content) return false;
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function runSyncDeliveryUnit(args, context) {
+    const parsed = (0, external_node_util_namespaceObject.parseArgs)({
+        args,
+        options: {
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
+            workspace: {
+                type: 'string'
+            }
+        },
+        strict: true,
+        allowPositionals: false
+    });
+    if (parsed.values.help) {
+        process.stdout.write(`Usage:
+  ultramodern-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each delivery unit it writes the
+delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
+topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+and backendFederation.versionBoundary.identityRoot) and regenerates
+<app>/shared/ultramodern-build.{json,ts}. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = parsed.values.workspace;
+    const workspaceRoot = workspaceOverride ? external_node_path_default().resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (!external_node_fs_default().existsSync(compactPath)) throw new Error(`Missing ${external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`ultramodern-create ultramodern migrate-strict-effect\` first.`);
+    const config = (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const workspaceApps = (0, config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(config);
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(workspaceApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(external_node_fs_default().readFileSync(compactPath, 'utf-8'));
+    if ((0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
+        if (!(0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(entry)) continue;
+        const app = appById.get(String(entry.id));
+        if (app) (0, external_delivery_unit_stamp_cjs_namespaceObject.stampDeliveryUnitIdentity)(entry, scope, app);
+    }
+    track(external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = external_node_path_default().join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (external_node_fs_default().existsSync(topologyPath)) {
+        const topology = JSON.parse(external_node_fs_default().readFileSync(topologyPath, 'utf-8'));
+        if ((0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
+            if (!(0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) (0, external_delivery_unit_stamp_cjs_namespaceObject.stampDeliveryUnitIdentity)(entry, scope, app);
+        }
+        if ((0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(topology) && (0, external_delivery_unit_stamp_cjs_namespaceObject.isPlainObject)(topology.shell)) {
+            const shell = appById.get(String(topology.shell.id));
+            if (shell) (0, external_delivery_unit_stamp_cjs_namespaceObject.stampDeliveryUnitIdentity)(topology.shell, scope, shell);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of workspaceApps){
+        const buildModulePath = external_node_path_default().join(app.directory, 'shared/ultramodern-build.ts');
+        const buildArtifactPath = external_node_path_default().join(app.directory, 'shared/ultramodern-build.json');
+        track(buildModulePath, writeTextIfChanged(external_node_path_default().join(workspaceRoot, buildModulePath), (0, external_module_federation_cjs_namespaceObject.createUltramodernBuildModule)(scope, app)));
+        track(buildArtifactPath, writeTextIfChanged(external_node_path_default().join(workspaceRoot, buildArtifactPath), (0, external_module_federation_cjs_namespaceObject.createUltramodernBuildArtifactJson)(scope, app)));
+    }
+    if (0 === written.length) process.stdout.write('[ultramodern] sync-delivery-unit: already in sync; no files written.\n');
+    else {
+        process.stdout.write(`[ultramodern] sync-delivery-unit: wrote ${written.length} file(s):\n`);
+        for (const relativePath of written)process.stdout.write(`  wrote    ${relativePath}\n`);
+        for (const relativePath of unchanged)process.stdout.write(`  in-sync  ${relativePath}\n`);
+    }
+    return 0;
+}
+exports.runSyncDeliveryUnit = __webpack_exports__.runSyncDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runSyncDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});