@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm/ultramodern-workspace/add-vertical/plan.js

@@ -1,52 +1,26 @@
-import node_fs from "node:fs";
-import node_os from "node:os";
-import node_path from "node:path";
 import { WORKSPACE_PACKAGE_VERSION } from "../../ultramodern-package-source.js";
-import { rpcPath } from "../api/rpc.js";
-import { createServerExecutionOverlay } from "../backend-federation.js";
-import { ULTRAMODERN_CONFIG_PATH, appEmitsBrowserUi, appHasApi, remoteDependencyAlias, resolveApiPrefix, resolveApiProtocol, shellApp, zephyrRemoteDependency } from "../descriptors.js";
+import { appEmitsBrowserUi, appHasApi, remoteDependencyAlias, resolveApiPrefix, zephyrRemoteDependency } from "../descriptors.js";
 import { packageName } from "../naming.js";
-import { DEVELOPMENT_OVERLAY_PATH, OWNERSHIP_PATH, TOPOLOGY_PATH } from "./constants.js";
-import { addUltramodernVertical } from "./execute.js";
+import { executeAddUltramodernVertical } from "./execute.js";
 import { prepareAddUltramodernVertical } from "./preflight.js";
-import { ownershipEntry, verticalTopologyEntry } from "./topology.js";
+import { describeJsonChanges } from "./preview.js";
+import { runWorkspaceTransaction } from "./transaction.js";
 function planUltramodernVertical(options) {
     const preflight = prepareAddUltramodernVertical(options);
-    const tempRoot = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'um-vertical-plan-'));
-    const copiedWorkspaceRoot = node_path.join(tempRoot, 'workspace');
-    try {
-        copyWorkspaceForPlan(options.workspaceRoot, copiedWorkspaceRoot);
-        const plannedResult = addUltramodernVertical({
+    let jsonMutations = [];
+    const result = runWorkspaceTransaction(options.workspaceRoot, (stagingRoot)=>executeAddUltramodernVertical({
             ...options,
-            workspaceRoot: copiedWorkspaceRoot,
+            workspaceRoot: stagingRoot,
             overlays: void 0
-        });
-        return createVerticalPlan(preflight, {
-            ...plannedResult,
-            workspaceRoot: options.workspaceRoot
-        });
-    } finally{
-        node_fs.rmSync(tempRoot, {
-            recursive: true,
-            force: true
-        });
-    }
-}
-function copyWorkspaceForPlan(workspaceRoot, copiedWorkspaceRoot) {
-    const skippedDirectories = new Set([
-        '.git',
-        '.nx',
-        '.output',
-        'coverage',
-        'dist',
-        'node_modules'
-    ]);
-    node_fs.cpSync(workspaceRoot, copiedWorkspaceRoot, {
-        recursive: true,
-        filter: (sourcePath)=>!skippedDirectories.has(node_path.basename(sourcePath))
+        }, options.workspaceRoot), {
+        mode: 'preview',
+        inspectChanges: (changes)=>{
+            jsonMutations = describeJsonChanges(changes);
+        }
     });
+    return createVerticalPlan(preflight, result, jsonMutations);
 }
-function createVerticalPlan(preflight, result) {
+function createVerticalPlan(preflight, result, jsonMutations) {
     const { scope, vertical, targetShell, targetVerticals } = preflight;
     const manifestUrl = `http://localhost:${vertical.port}/mf-manifest.json`;
     return {
@@ -61,11 +35,11 @@ function createVerticalPlan(preflight, result) {
         ...vertical.api ? {
             apiPrefix: resolveApiPrefix(vertical)
         } : {},
-        jsonMutations: createDryRunJsonMutations(preflight, manifestUrl),
+        jsonMutations,
         shellDependencyChanges: createShellDependencyChanges(scope, vertical, targetShell),
         generatedContractChanges: [
             {
-                path: ULTRAMODERN_CONFIG_PATH,
+                path: 'topology/reference-topology.json',
                 addedAppIds: [
                     vertical.id
                 ],
@@ -74,114 +48,6 @@ function createVerticalPlan(preflight, result) {
         ]
     };
 }
-function createDryRunJsonMutations(preflight, manifestUrl) {
-    const { scope, vertical, targetShell, additionalShells } = preflight;
-    const additionalShellIndex = additionalShells.findIndex((shell)=>shell.id === targetShell.id);
-    const apiMutation = appHasApi(vertical) ? [
-        {
-            path: DEVELOPMENT_OVERLAY_PATH,
-            pointer: `/apis/${vertical.id}`,
-            description: `Add local API URL for ${vertical.id}`,
-            value: `http://localhost:${vertical.port}${'rpc' === resolveApiProtocol(vertical) ? rpcPath(vertical) : resolveApiPrefix(vertical)}`
-        },
-        {
-            path: DEVELOPMENT_OVERLAY_PATH,
-            pointer: `/serverExecution/${vertical.id}`,
-            description: `Add local MicroVertical server execution metadata for ${vertical.id}`,
-            value: createServerExecutionOverlay(scope, vertical)
-        }
-    ] : [];
-    const shellMutations = targetShell.id === shellApp.id ? [
-        {
-            path: TOPOLOGY_PATH,
-            pointer: '/shell/verticalRefs/-',
-            description: `Add ${vertical.id} to the ${targetShell.id} vertical references`,
-            value: vertical.id
-        },
-        {
-            path: TOPOLOGY_PATH,
-            pointer: '/shell/moduleFederation/remotes/-',
-            description: `Register ${vertical.id} as a Module Federation remote`,
-            value: {
-                id: vertical.id,
-                name: vertical.mfName,
-                manifestUrl
-            }
-        }
-    ] : [
-        {
-            path: ULTRAMODERN_CONFIG_PATH,
-            pointer: `/shells/${additionalShellIndex}/verticalRefs/-`,
-            description: `Add ${vertical.id} to the ${targetShell.id} vertical references`,
-            value: vertical.id
-        },
-        {
-            path: ULTRAMODERN_CONFIG_PATH,
-            pointer: `/shells/${additionalShellIndex}/moduleFederation/remotes`,
-            description: `Regenerate ${targetShell.id} Module Federation remotes for ${vertical.id}`
-        }
-    ];
-    return [
-        ...appEmitsBrowserUi(vertical) ? shellMutations : [],
-        {
-            path: TOPOLOGY_PATH,
-            pointer: '/verticals/-',
-            description: `Add topology entry for ${vertical.id}`,
-            value: verticalTopologyEntry(scope, vertical)
-        },
-        {
-            path: OWNERSHIP_PATH,
-            pointer: '/owners/-',
-            description: `Add ownership entry for ${vertical.id}`,
-            value: ownershipEntry(scope, vertical)
-        },
-        {
-            path: DEVELOPMENT_OVERLAY_PATH,
-            pointer: `/ports/${vertical.id}`,
-            description: `Reserve development port ${vertical.port}`,
-            value: vertical.port
-        },
-        ...appEmitsBrowserUi(vertical) ? [
-            {
-                path: DEVELOPMENT_OVERLAY_PATH,
-                pointer: `/manifests/${vertical.id}`,
-                description: `Add local Module Federation manifest URL for ${vertical.id}`,
-                value: manifestUrl
-            }
-        ] : [],
-        ...apiMutation,
-        {
-            path: 'package.json',
-            pointer: "/scripts",
-            description: "Regenerate workspace scripts for the new vertical set"
-        },
-        {
-            path: `${targetShell.directory}/package.json`,
-            pointer: '/dependencies',
-            description: `Wire shell dependencies for ${vertical.id}`
-        },
-        {
-            path: 'tsconfig.json',
-            pointer: '/references',
-            description: `Add ${vertical.id} to the root TS-Go build graph`
-        },
-        {
-            path: `${targetShell.directory}/tsconfig.json`,
-            pointer: '/references',
-            description: `Add ${vertical.id} to the shell TS-Go project references`
-        },
-        {
-            path: `${targetShell.directory}/tsconfig.mf-types.json`,
-            pointer: '/include',
-            description: 'Keep shell Module Federation DTS compilation scoped'
-        },
-        {
-            path: ULTRAMODERN_CONFIG_PATH,
-            pointer: '/topology/apps',
-            description: `Regenerate compact config with ${vertical.id}`
-        }
-    ];
-}
 function createShellDependencyChanges(scope, vertical, shell) {
     return [
         ...appEmitsBrowserUi(vertical) ? [

package/dist/esm/ultramodern-workspace/add-vertical/preflight.js

@@ -1,14 +1,12 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { normalizeCompactConfig } from "../../ultramodern-tooling/config.js";
-import { ULTRAMODERN_CONFIG_PATH, createRemoteManifestEnv, createVerticalDescriptor, shellApp } from "../descriptors.js";
+import { normalizeWorkspaceInputs } from "../../ultramodern-tooling/config.js";
+import { createRemoteManifestEnv, createVerticalDescriptor } from "../descriptors.js";
 import { readJsonFile } from "../fs-io.js";
 import { assertUniqueTailwindPrefixes, normalizePath, toPackageScope } from "../naming.js";
-import { resolveConfiguredAdditionalShells } from "../shells.js";
 import { isRecord } from "../types.js";
 import { DEVELOPMENT_OVERLAY_PATH, OWNERSHIP_PATH, TOPOLOGY_PATH } from "./constants.js";
-import { verticalsFromTopology } from "./topology.js";
-import { assertCanCreate, assertGlobalPortUniqueness, assertValidVerticalName, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort } from "./workspace-state.js";
+import { assertCanCreate, assertGlobalPortUniqueness, assertValidVerticalName, nextAvailablePort, workspaceOperationSettings } from "./workspace-state.js";
 class UnknownUltramodernShellError extends Error {
     constructor(sourcePath, requestedShellId, available){
         const issue = {
@@ -31,30 +29,26 @@ function prepareAddUltramodernVertical(options) {
     const topology = readRequiredJsonObject(topologyPath);
     const ownership = readRequiredJsonObject(ownershipPath);
     const overlay = readRequiredJsonObject(overlayPath);
-    const config = readRequiredWorkspaceConfig(options.workspaceRoot);
     assertOptionalJsonObject(topology.shell, 'topology.shell', topologyPath);
     assertOptionalJsonArray(topology.verticals, 'topology.verticals', topologyPath);
     assertOptionalJsonArray(ownership.owners, 'ownership.owners', ownershipPath);
     assertOptionalJsonObject(overlay.ports, 'overlay.ports', overlayPath);
     assertOptionalJsonObject(overlay.manifests, 'overlay.manifests', overlayPath);
     assertOptionalJsonObject(overlay.apis, 'overlay.apis', overlayPath);
+    const workspace = normalizeWorkspaceInputs(options.workspaceRoot, {
+        topology,
+        overlay
+    });
+    const { packageSource, enableTailwind, bridge } = workspaceOperationSettings(options, workspace.config);
     overlay.ports ??= {};
     const scope = toPackageScope(String(rootPackage.name ?? node_path.basename(options.workspaceRoot)));
-    const packageSource = existingPackageSource(options.workspaceRoot, options.modernVersion, options.packageSource);
-    const enableTailwind = options.enableTailwind ?? existingTailwindEnabled(options.workspaceRoot);
-    const bridge = existingBridgeConfig(options.workspaceRoot);
-    const existingVerticals = verticalsFromTopology(topology, overlay.ports);
-    const additionalShells = resolveConfiguredAdditionalShells(config);
-    const primaryShell = createPrimaryShellDescriptor(topology, config);
-    const primaryShellPort = 'number' == typeof overlay.ports[primaryShell.id] ? overlay.ports[primaryShell.id] : primaryShell.port;
-    const resolvedPrimaryShell = {
-        ...primaryShell,
-        port: primaryShellPort
-    };
-    const targetShell = resolveTargetShell(options.shell, resolvedPrimaryShell, additionalShells, node_path.join(options.workspaceRoot, ULTRAMODERN_CONFIG_PATH));
+    const existingVerticals = workspace.verticals;
+    const additionalShells = workspace.additionalShells;
+    const resolvedPrimaryShell = workspace.primaryShell;
+    const targetShell = resolveTargetShell(options.shell, resolvedPrimaryShell, additionalShells, topologyPath);
     const portsWithPrimary = {
         ...overlay.ports,
-        [primaryShell.id]: primaryShellPort
+        [resolvedPrimaryShell.id]: resolvedPrimaryShell.port
     };
     assertGlobalPortUniqueness(portsWithPrimary, additionalShells);
     const port = nextAvailablePort(portsWithPrimary, additionalShells);
@@ -87,7 +81,7 @@ function prepareAddUltramodernVertical(options) {
         ownershipPath,
         overlayPath,
         rootPackage,
-        config,
+        config: workspace.config,
         topology,
         ownership,
         overlay,
@@ -108,32 +102,6 @@ function readRequiredJsonObject(filePath) {
     if (!isRecord(value)) throw new Error(`UltraModern workspace file must contain a JSON object: ${filePath}`);
     return value;
 }
-function readRequiredWorkspaceConfig(workspaceRoot) {
-    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
-    const config = readRequiredJsonObject(compactPath);
-    normalizeCompactConfig(workspaceRoot, compactPath, config);
-    return config;
-}
-function createPrimaryShellDescriptor(topology, config) {
-    const compactShell = config.topology?.apps?.find((app)=>app?.id === shellApp.id);
-    const verticalRefs = Array.isArray(topology.shell?.verticalRefs) ? topology.shell.verticalRefs.filter((id)=>'string' == typeof id) : Array.isArray(compactShell?.moduleFederation?.verticalRefs) ? compactShell.moduleFederation.verticalRefs.filter((id)=>'string' == typeof id) : [];
-    return {
-        ...shellApp,
-        verticalRefs,
-        ...'string' == typeof compactShell?.path ? {
-            directory: compactShell.path
-        } : {},
-        ...'number' == typeof compactShell?.port ? {
-            port: compactShell.port
-        } : {},
-        ...'string' == typeof compactShell?.portEnv ? {
-            portEnv: compactShell.portEnv
-        } : {},
-        ...'string' == typeof compactShell?.moduleFederation?.name ? {
-            mfName: compactShell.moduleFederation.name
-        } : {}
-    };
-}
 function resolveTargetShell(requestedShellId, primaryShell, additionalShells, sourcePath) {
     if (void 0 === requestedShellId || requestedShellId === primaryShell.id) return primaryShell;
     const targetShell = additionalShells.find((shell)=>shell.id === requestedShellId);
@@ -195,4 +163,4 @@ function assertNonEmptyString(value, label) {
 function assertSafeOutputPath(relativePath, appId) {
     if (node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/u).includes('..')) throw new Error(`Unsafe output path for ${appId}: ${relativePath}`);
 }
-export { UnknownUltramodernShellError, assertNonEmptyString, createPrimaryShellDescriptor, prepareAddUltramodernVertical };
+export { UnknownUltramodernShellError, assertNonEmptyString, prepareAddUltramodernVertical, readRequiredJsonObject };

package/dist/esm/ultramodern-workspace/add-vertical/preview.js

@@ -0,0 +1,40 @@
+import { isDeepStrictEqual } from "node:util";
+function describeJsonChanges(changes) {
+    const mutations = [];
+    for (const change of changes){
+        if (!change.relativePath.endsWith('.json') || change.before?.symlink || change.after?.symlink) continue;
+        let before;
+        let after;
+        try {
+            before = change.before && JSON.parse(change.before.content.toString());
+            after = change.after && JSON.parse(change.after.content.toString());
+        } catch  {
+            continue;
+        }
+        const visit = (previous, next, pointer)=>{
+            if (isDeepStrictEqual(previous, next)) return;
+            if (Array.isArray(previous) && Array.isArray(next) && previous.every((value, index)=>isDeepStrictEqual(value, next[index])) && next.length >= previous.length) {
+                for (const value of next.slice(previous.length))visit(void 0, value, `${pointer}/-`);
+                return;
+            }
+            if (previous && next && 'object' == typeof previous && 'object' == typeof next && !Array.isArray(previous) && !Array.isArray(next)) {
+                for (const key of new Set([
+                    ...Object.keys(previous),
+                    ...Object.keys(next)
+                ]))visit(previous[key], next[key], `${pointer}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+                return;
+            }
+            mutations.push({
+                path: change.relativePath,
+                pointer,
+                description: `${void 0 === next ? 'Remove' : void 0 === previous ? 'Add' : 'Update'} ${pointer || 'document'}`,
+                ...void 0 === next ? {} : {
+                    value: next
+                }
+            });
+        };
+        visit(before, after, '');
+    }
+    return mutations;
+}
+export { describeJsonChanges };

package/dist/esm/ultramodern-workspace/add-vertical/shell-files.js

@@ -1,21 +1,30 @@
+import node_fs from "node:fs";
 import node_path from "node:path";
 import { createShellApiClient } from "../api.js";
 import { createAppEnvDts, createAppRuntimeConfig, createShellFrameComponent } from "../app-files.js";
 import { createShellPage, createShellRemoteComponents, createShellWorkerRemoteComponents } from "../demo-components.js";
 import { appEmitsBrowserUi, appI18nNamespace, resolveRemoteRefs, shellApp } from "../descriptors.js";
-import { readJsonFile, writeFileReplacing, writeJsonFile } from "../fs-io.js";
+import { readJsonFile, writeJsonFile } from "../fs-io.js";
 import { createAppPublicLocaleMessages } from "../locales.js";
 import { createAppModernConfig, createShellModuleFederationConfig } from "../module-federation.js";
 import { createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createRootPackageJson } from "../package-json.js";
 import { createPublicWebAppArtifacts, rewriteWorkspaceAssetsForApp } from "../public-surface.js";
-function updateRootWorkspaceScripts(workspaceRoot, scope, packageSource, remotes, bridge, additionalShells = []) {
+import { preserveConsumerWorkspaceArtifacts } from "../workspace-artifact-ownership.js";
+function updateRootWorkspaceScripts(workspaceRoot, scope, packageSource, remotes, bridge, additionalShells = [], previousRemotes = remotes, _primaryShell = shellApp, previousAdditionalShells = additionalShells) {
     const packagePath = node_path.join(workspaceRoot, 'package.json');
     const rootPackage = readJsonFile(packagePath);
     const generatedRootPackage = createRootPackageJson(scope, packageSource, remotes, bridge, additionalShells);
-    rootPackage.scripts = generatedRootPackage.scripts;
+    const previousRootPackage = createRootPackageJson(scope, packageSource, previousRemotes, bridge, previousAdditionalShells);
+    const existingScripts = rootPackage.scripts ?? {};
+    rootPackage.scripts = {
+        ...generatedRootPackage.scripts,
+        ...existingScripts
+    };
+    if (existingScripts.dev === previousRootPackage.scripts.dev) rootPackage.scripts.dev = generatedRootPackage.scripts.dev;
+    for (const [name, command] of Object.entries(generatedRootPackage.scripts))if (void 0 === existingScripts[name] || existingScripts[name] === previousRootPackage.scripts[name]) rootPackage.scripts[name] = command;
     writeJsonFile(packagePath, rootPackage);
 }
-function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes, bridge, shell = shellApp, devPorts) {
+function shellAppArtifacts(scope, packageSource, enableTailwind, remotes, bridge, shell, devPorts) {
     const shellHost = {
         ...shell,
         verticalRefs: shell.verticalRefs ?? remotes.filter(appEmitsBrowserUi).map((remote)=>remote.id)
@@ -23,26 +32,79 @@ function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwin
     const shellRemotes = resolveRemoteRefs(shellHost, remotes);
     const uiRemotes = shellRemotes.filter(appEmitsBrowserUi);
     const publicWeb = createPublicWebAppArtifacts(shellHost);
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/package.json`), createAppPackage(scope, shellHost, packageSource, enableTailwind, remotes, bridge));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/tsconfig.json`), createAppTsConfig(shellHost, shellRemotes));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/tsconfig.mf-types.json`), createAppMfTypesTsConfig(shellHost));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/modern-app-env.d.ts`, createAppEnvDts(shellHost, shellRemotes, scope));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/modern.config.ts`, createAppModernConfig(scope, shellHost, shellRemotes, enableTailwind, devPorts));
-    writeFileReplacing(workspaceRoot, publicWeb.jsonLdHelperFile.path, publicWeb.jsonLdHelperFile.content);
-    writeFileReplacing(workspaceRoot, publicWeb.routeMetadataFile.path, publicWeb.routeMetadataFile.content);
-    writeFileReplacing(workspaceRoot, publicWeb.routeHeadFile.path, publicWeb.routeHeadFile.content);
-    for (const generatedFile of publicWeb.routeMetaFiles)writeFileReplacing(workspaceRoot, generatedFile.path, generatedFile.content);
-    rewriteWorkspaceAssetsForApp(workspaceRoot, shellHost);
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/modern.runtime.ts`, createAppRuntimeConfig(shellHost, scope, shellRemotes));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/locales/en/translation.json`), createAppPublicLocaleMessages(shellHost, 'en', shellRemotes));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/locales/en/${appI18nNamespace(shellHost)}.json`), createAppPublicLocaleMessages(shellHost, 'en', shellRemotes));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/locales/cs/translation.json`), createAppPublicLocaleMessages(shellHost, 'cs', shellRemotes));
-    writeJsonFile(node_path.join(workspaceRoot, `${shellHost.directory}/locales/cs/${appI18nNamespace(shellHost)}.json`), createAppPublicLocaleMessages(shellHost, 'cs', shellRemotes));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/module-federation.config.ts`, createShellModuleFederationConfig(scope, shellHost, shellRemotes));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/routes/[lang]/page.tsx`, createShellPage(shellHost, uiRemotes));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/routes/vertical-components.tsx`, createShellRemoteComponents(shellHost, uiRemotes));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/routes/vertical-components.worker.tsx`, createShellWorkerRemoteComponents(shellHost, uiRemotes));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/routes/shell-frame.tsx`, createShellFrameComponent(shellHost));
-    writeFileReplacing(workspaceRoot, `${shellHost.directory}/src/api/vertical-clients.ts`, createShellApiClient(scope, remotes));
+    const json = (value)=>`${JSON.stringify(value, null, 2)}\n`;
+    const files = {
+        [`${shellHost.directory}/tsconfig.json`]: json(createAppTsConfig(shellHost, shellRemotes)),
+        [`${shellHost.directory}/tsconfig.mf-types.json`]: json(createAppMfTypesTsConfig(shellHost)),
+        [`${shellHost.directory}/src/modern-app-env.d.ts`]: createAppEnvDts(shellHost, shellRemotes, scope),
+        [`${shellHost.directory}/modern.config.ts`]: createAppModernConfig(scope, shellHost, shellRemotes, enableTailwind, devPorts),
+        [publicWeb.jsonLdHelperFile.path]: publicWeb.jsonLdHelperFile.content,
+        [publicWeb.routeMetadataFile.path]: publicWeb.routeMetadataFile.content,
+        [publicWeb.routeHeadFile.path]: publicWeb.routeHeadFile.content,
+        ...Object.fromEntries(publicWeb.routeMetaFiles.map((file)=>[
+                file.path,
+                file.content
+            ])),
+        [`${shellHost.directory}/src/modern.runtime.ts`]: createAppRuntimeConfig(shellHost, scope, shellRemotes),
+        ...Object.fromEntries([
+            'en',
+            'cs'
+        ].flatMap((language)=>[
+                'translation',
+                appI18nNamespace(shellHost)
+            ].map((namespace)=>[
+                    `${shellHost.directory}/locales/${language}/${namespace}.json`,
+                    json(createAppPublicLocaleMessages(shellHost, language, shellRemotes))
+                ]))),
+        [`${shellHost.directory}/module-federation.config.ts`]: createShellModuleFederationConfig(scope, shellHost, shellRemotes),
+        [`${shellHost.directory}/src/routes/[lang]/page.tsx`]: createShellPage(shellHost, uiRemotes),
+        [`${shellHost.directory}/src/routes/vertical-components.tsx`]: createShellRemoteComponents(shellHost, uiRemotes),
+        [`${shellHost.directory}/src/routes/vertical-components.worker.tsx`]: createShellWorkerRemoteComponents(shellHost, uiRemotes),
+        [`${shellHost.directory}/src/routes/shell-frame.tsx`]: createShellFrameComponent(shellHost),
+        [`${shellHost.directory}/src/api/vertical-clients.ts`]: createShellApiClient(scope, remotes)
+    };
+    return {
+        shellHost,
+        packageJson: createAppPackage(scope, shellHost, packageSource, enableTailwind, remotes, bridge),
+        artifacts: Object.entries(files).map(([relativePath, content])=>({
+                relativePath,
+                content
+            }))
+    };
+}
+function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes, bridge, shell = shellApp, devPorts, previous = {
+    shell,
+    remotes,
+    devPorts
+}) {
+    const before = shellAppArtifacts(scope, packageSource, previous.enableTailwind ?? enableTailwind, previous.remotes, bridge, previous.shell, previous.devPorts);
+    const next = shellAppArtifacts(scope, packageSource, enableTailwind, remotes, bridge, shell, devPorts);
+    const { io } = preserveConsumerWorkspaceArtifacts(workspaceRoot, before.artifacts);
+    for (const artifact of next.artifacts)io.write(node_path.join(workspaceRoot, artifact.relativePath), artifact.content);
+    const packagePath = node_path.join(workspaceRoot, shell.directory, 'package.json');
+    const existing = node_fs.existsSync(packagePath) ? readJsonFile(packagePath) : {};
+    const packageJson = {
+        ...next.packageJson,
+        ...existing,
+        'zephyr:dependencies': {
+            ...next.packageJson['zephyr:dependencies'],
+            ...Object.fromEntries(Object.entries(existing['zephyr:dependencies'] ?? {}).filter(([key, value])=>before.packageJson['zephyr:dependencies']?.[key] !== value))
+        },
+        dependencies: {
+            ...next.packageJson.dependencies,
+            ...existing.dependencies
+        },
+        devDependencies: {
+            ...next.packageJson.devDependencies,
+            ...existing.devDependencies
+        },
+        scripts: {
+            ...next.packageJson.scripts,
+            ...existing.scripts
+        }
+    };
+    for (const [name, command] of Object.entries(next.packageJson.scripts))if (existing.scripts?.[name] === void 0 || existing.scripts[name] === before.packageJson.scripts?.[name]) packageJson.scripts[name] = command;
+    writeJsonFile(packagePath, packageJson);
+    rewriteWorkspaceAssetsForApp(workspaceRoot, next.shellHost);
 }
 export { rewriteShellAppFiles, updateRootWorkspaceScripts };

package/dist/esm/ultramodern-workspace/add-vertical/topology.js

@@ -81,6 +81,9 @@ function verticalsFromTopology(topology, ports) {
             portEnv: `VERTICAL_${toEnvSegment(domain)}_PORT`,
             port: 'number' == typeof ports[vertical.id] ? ports[vertical.id] : 0,
             mfName: vertical.moduleFederation?.name ?? `vertical${toPascalCase(domain)}`,
+            ...vertical.deliveryUnit ? {
+                deliveryUnit: vertical.deliveryUnit
+            } : {},
             ...void 0 === surfaceProfile ? {} : {
                 surfaceProfile
             },
@@ -90,7 +93,7 @@ function verticalsFromTopology(topology, ports) {
             ...Array.isArray(vertical.moduleFederation?.exposes) ? {
                 exposes: Object.fromEntries(vertical.moduleFederation.exposes.map((expose)=>[
                         expose,
-                        './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : ''
+                        vertical.moduleFederation?.exposePaths?.[expose] ?? ('./Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : '')
                     ]))
             } : {},
             ...Array.isArray(vertical.moduleFederation?.verticalRefs) ? {