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

package/dist/esm-node/ultramodern-workspace/add-vertical/execute.js

@@ -0,0 +1,136 @@
+import "node:module";
+import node_path from "node:path";
+import { rpcPath } from "../api/rpc.js";
+import { createServerExecutionOverlay } from "../backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "../delivery-unit.js";
+import { ULTRAMODERN_CONFIG_PATH, appEmitsBrowserUi, appHasApi, createModuleFederationRemoteContracts, resolveApiPrefix, resolveApiProtocol, shellApp } from "../descriptors.js";
+import { formatGeneratedWorkspaceFiles, writeFileReplacing, writeJsonFile } from "../fs-io.js";
+import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "../generation-result.js";
+import { runCodeSmithOverlays } from "../overlays.js";
+import { createRootTsConfig } from "../package-json.js";
+import { writeGeneratedWorkspaceScripts } from "../workspace-scripts.js";
+import { rewriteAppModernConfig } from "../write-app.js";
+import { createCompactUltramodernConfig, writeApp } from "../write-workspace.js";
+import { createZeropsYaml } from "../zerops.js";
+import { prepareAddUltramodernVertical } from "./preflight.js";
+import { rewriteShellAppFiles, updateRootWorkspaceScripts } from "./shell-files.js";
+import { ownershipEntry, verticalTopologyEntry } from "./topology.js";
+import { runWorkspaceTransaction } from "./transaction.js";
+import { configuredDevelopmentPorts } from "./workspace-state.js";
+function addUltramodernVertical(options) {
+    return runWorkspaceTransaction(options.workspaceRoot, ()=>executeAddUltramodernVertical(options));
+}
+function executeAddUltramodernVertical(options) {
+    const beforeFiles = createFileSnapshot(options.workspaceRoot);
+    const { scope, topologyPath, ownershipPath, overlayPath, topology, ownership, overlay, packageSource, enableTailwind, bridge, primaryShell, additionalShells, targetShell, targetVerticals, vertical, updatedVerticals } = prepareAddUltramodernVertical(options);
+    const nextTargetShell = {
+        ...targetShell,
+        verticalRefs: targetVerticals.filter(appEmitsBrowserUi).map((remote)=>remote.id)
+    };
+    const nextPrimaryShell = targetShell.id === primaryShell.id ? {
+        ...primaryShell,
+        verticalRefs: nextTargetShell.verticalRefs
+    } : primaryShell;
+    const nextAdditionalShells = additionalShells.map((shell)=>shell.id === nextTargetShell.id ? nextTargetShell : shell);
+    const configuredDevPorts = nextAdditionalShells.length > 0 ? configuredDevelopmentPorts({
+        ...overlay.ports,
+        [primaryShell.id]: primaryShell.port,
+        [vertical.id]: vertical.port
+    }, nextAdditionalShells).toSorted((left, right)=>left - right) : void 0;
+    writeApp(options.workspaceRoot, scope, vertical, packageSource, enableTailwind, updatedVerticals, bridge, configuredDevPorts);
+    if (targetShell.id === primaryShell.id) {
+        topology.shell ??= {};
+        topology.shell.deliveryUnit = deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shellApp));
+        topology.shell.verticalRefs = nextTargetShell.verticalRefs;
+        topology.shell.moduleFederation ??= {};
+        topology.shell.moduleFederation.remotes = createModuleFederationRemoteContracts(nextPrimaryShell, updatedVerticals).map((remote)=>({
+                id: remote.id,
+                name: remote.name,
+                manifestUrl: remote.manifestUrl
+            }));
+    }
+    topology.verticals ??= [];
+    topology.verticals.push(verticalTopologyEntry(scope, vertical));
+    ownership.owners ??= [];
+    ownership.owners.push(ownershipEntry(scope, vertical));
+    overlay.ports[vertical.id] = vertical.port;
+    overlay.manifests ??= {};
+    if (appEmitsBrowserUi(vertical)) overlay.manifests[vertical.id] = `http://localhost:${vertical.port}/mf-manifest.json`;
+    else delete overlay.manifests[vertical.id];
+    if (appHasApi(vertical)) {
+        overlay.serverExecution ??= {};
+        overlay.serverExecution[vertical.id] = createServerExecutionOverlay(scope, vertical);
+        overlay.apis ??= {};
+        overlay.apis[vertical.id] = `http://localhost:${vertical.port}${'rpc' === resolveApiProtocol(vertical) ? rpcPath(vertical) : resolveApiPrefix(vertical)}`;
+    }
+    writeJsonFile(topologyPath, topology);
+    writeJsonFile(ownershipPath, ownership);
+    writeJsonFile(overlayPath, overlay);
+    writeJsonFile(node_path.join(options.workspaceRoot, ULTRAMODERN_CONFIG_PATH), createCompactUltramodernConfig(scope, options.modernVersion, packageSource, [
+        {
+            ...nextPrimaryShell
+        },
+        ...updatedVerticals
+    ], enableTailwind, bridge, nextAdditionalShells, nextPrimaryShell));
+    writeFileReplacing(options.workspaceRoot, 'zerops.yaml', `${createZeropsYaml(scope, [
+        nextPrimaryShell,
+        ...updatedVerticals,
+        ...nextAdditionalShells
+    ])}\n`);
+    for (const shellToRefresh of [
+        nextPrimaryShell,
+        ...nextAdditionalShells
+    ])rewriteShellAppFiles(options.workspaceRoot, scope, packageSource, enableTailwind, updatedVerticals, bridge, shellToRefresh.id === nextTargetShell.id ? nextTargetShell : shellToRefresh, configuredDevPorts);
+    writeGeneratedWorkspaceScripts(options.workspaceRoot, scope, enableTailwind, updatedVerticals, void 0, nextAdditionalShells, nextPrimaryShell);
+    updateRootWorkspaceScripts(options.workspaceRoot, scope, packageSource, updatedVerticals, bridge, nextAdditionalShells);
+    writeJsonFile(node_path.join(options.workspaceRoot, 'tsconfig.json'), createRootTsConfig([
+        nextPrimaryShell,
+        ...updatedVerticals,
+        ...nextAdditionalShells
+    ]));
+    if (configuredDevPorts) {
+        for (const app of [
+            nextPrimaryShell,
+            ...updatedVerticals,
+            ...nextAdditionalShells
+        ])if (app.id !== vertical.id && app.id !== nextTargetShell.id) rewriteAppModernConfig(options.workspaceRoot, scope, app, updatedVerticals, enableTailwind, configuredDevPorts);
+    }
+    const preliminaryAfterFiles = createFileSnapshot(options.workspaceRoot);
+    const preliminaryDiff = diffFileSnapshots(beforeFiles, preliminaryAfterFiles);
+    const preliminaryResult = createGenerationResult({
+        operation: 'vertical',
+        workspaceRoot: options.workspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps: [
+            vertical
+        ],
+        createdPaths: preliminaryDiff.createdPaths,
+        rewrittenPaths: preliminaryDiff.rewrittenPaths
+    });
+    runCodeSmithOverlays({
+        workspaceRoot: options.workspaceRoot,
+        overlays: options.overlays,
+        result: preliminaryResult
+    });
+    const afterOverlaysFiles = createFileSnapshot(options.workspaceRoot);
+    const changedPaths = diffFileSnapshots(beforeFiles, afterOverlaysFiles);
+    formatGeneratedWorkspaceFiles(options.workspaceRoot, [
+        ...changedPaths.createdPaths,
+        ...changedPaths.rewrittenPaths
+    ]);
+    const afterFiles = createFileSnapshot(options.workspaceRoot);
+    const { createdPaths, rewrittenPaths } = diffFileSnapshots(beforeFiles, afterFiles);
+    return createGenerationResult({
+        operation: 'vertical',
+        workspaceRoot: options.workspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps: [
+            vertical
+        ],
+        createdPaths,
+        rewrittenPaths
+    });
+}
+export { addUltramodernVertical };

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

@@ -0,0 +1,206 @@
+import "node:module";
+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 { packageName } from "../naming.js";
+import { DEVELOPMENT_OVERLAY_PATH, OWNERSHIP_PATH, TOPOLOGY_PATH } from "./constants.js";
+import { addUltramodernVertical } from "./execute.js";
+import { prepareAddUltramodernVertical } from "./preflight.js";
+import { ownershipEntry, verticalTopologyEntry } from "./topology.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({
+            ...options,
+            workspaceRoot: copiedWorkspaceRoot,
+            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))
+    });
+}
+function createVerticalPlan(preflight, result) {
+    const { scope, vertical, targetShell, targetVerticals } = preflight;
+    const manifestUrl = `http://localhost:${vertical.port}/mf-manifest.json`;
+    return {
+        ...result,
+        dryRun: true,
+        selectedPort: vertical.port,
+        moduleFederationRemote: {
+            id: vertical.id,
+            name: vertical.mfName,
+            manifestUrl
+        },
+        ...vertical.api ? {
+            apiPrefix: resolveApiPrefix(vertical)
+        } : {},
+        jsonMutations: createDryRunJsonMutations(preflight, manifestUrl),
+        shellDependencyChanges: createShellDependencyChanges(scope, vertical, targetShell),
+        generatedContractChanges: [
+            {
+                path: ULTRAMODERN_CONFIG_PATH,
+                addedAppIds: [
+                    vertical.id
+                ],
+                shellVerticalRefs: targetVerticals.filter(appEmitsBrowserUi).map((vertical)=>vertical.id)
+            }
+        ]
+    };
+}
+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) ? [
+            {
+                path: `${shell.directory}/package.json`,
+                section: 'zephyr:dependencies',
+                packageName: remoteDependencyAlias(vertical),
+                version: zephyrRemoteDependency(scope, vertical)
+            }
+        ] : [],
+        ...appHasApi(vertical) ? [
+            {
+                path: `${shell.directory}/package.json`,
+                section: 'dependencies',
+                packageName: packageName(scope, vertical.packageSuffix),
+                version: WORKSPACE_PACKAGE_VERSION
+            }
+        ] : []
+    ];
+}
+export { planUltramodernVertical };

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

@@ -0,0 +1,199 @@
+import "node:module";
+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 { 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";
+class UnknownUltramodernShellError extends Error {
+    constructor(sourcePath, requestedShellId, available){
+        const issue = {
+            field: 'shell',
+            value: requestedShellId,
+            reason: 'unknown',
+            available
+        };
+        super(`Unknown target shell "${requestedShellId}" in ${sourcePath}. Available shells: ${available.join(', ') || 'none'}.`), this.sourcePath = sourcePath, this.code = 'ULTRAMODERN_UNKNOWN_TARGET_SHELL';
+        this.name = 'UnknownUltramodernShellError';
+        this.issue = issue;
+    }
+}
+function prepareAddUltramodernVertical(options) {
+    const name = assertValidVerticalName(options.name);
+    const topologyPath = node_path.join(options.workspaceRoot, TOPOLOGY_PATH);
+    const ownershipPath = node_path.join(options.workspaceRoot, OWNERSHIP_PATH);
+    const overlayPath = node_path.join(options.workspaceRoot, DEVELOPMENT_OVERLAY_PATH);
+    const rootPackage = readRequiredJsonObject(node_path.join(options.workspaceRoot, 'package.json'));
+    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);
+    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 portsWithPrimary = {
+        ...overlay.ports,
+        [primaryShell.id]: primaryShellPort
+    };
+    assertGlobalPortUniqueness(portsWithPrimary, additionalShells);
+    const port = nextAvailablePort(portsWithPrimary, additionalShells);
+    const vertical = createVerticalDescriptor(name, port, {
+        preset: options.preset,
+        apiProtocol: options.apiProtocol,
+        horizontalRemote: options.horizontalRemote
+    });
+    const updatedVerticals = [
+        ...existingVerticals,
+        vertical
+    ];
+    const targetVerticals = [
+        ...existingVerticals.filter((id)=>(targetShell.verticalRefs ?? []).includes(id.id)),
+        vertical
+    ];
+    const allApps = [
+        resolvedPrimaryShell,
+        ...updatedVerticals,
+        ...additionalShells
+    ];
+    assertCanCreate(options.workspaceRoot, vertical.directory);
+    validateWorkspaceAppDescriptors(allApps);
+    validateUniqueWorkspaceAppDescriptors(allApps);
+    assertUniqueTailwindPrefixes(allApps);
+    return {
+        name,
+        scope,
+        topologyPath,
+        ownershipPath,
+        overlayPath,
+        rootPackage,
+        config,
+        topology,
+        ownership,
+        overlay,
+        packageSource,
+        enableTailwind,
+        bridge,
+        primaryShell: resolvedPrimaryShell,
+        additionalShells,
+        targetShell,
+        targetVerticals,
+        vertical,
+        updatedVerticals
+    };
+}
+function readRequiredJsonObject(filePath) {
+    if (!node_fs.existsSync(filePath)) throw new Error(`Missing UltraModern workspace file: ${filePath}`);
+    const value = readJsonFile(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);
+    if (!targetShell) {
+        const available = [
+            primaryShell,
+            ...additionalShells
+        ].map((shell)=>shell.id);
+        throw new UnknownUltramodernShellError(sourcePath, requestedShellId, available);
+    }
+    return targetShell;
+}
+function assertOptionalJsonObject(value, label, filePath) {
+    if (void 0 !== value && !isRecord(value)) throw new Error(`${label} in ${filePath} must be a JSON object`);
+}
+function assertOptionalJsonArray(value, label, filePath) {
+    if (void 0 !== value && !Array.isArray(value)) throw new Error(`${label} in ${filePath} must be a JSON array`);
+}
+function validateWorkspaceAppDescriptors(apps) {
+    for (const app of apps){
+        const appLabel = 'string' == typeof app.id && app.id ? app.id : '<unknown>';
+        assertNonEmptyString(app.id, `app id for ${appLabel}`);
+        assertNonEmptyString(app.directory, `directory for ${appLabel}`);
+        assertSafeOutputPath(app.directory, appLabel);
+        assertNonEmptyString(app.packageSuffix, `package suffix for ${appLabel}`);
+        assertNonEmptyString(app.displayName, `display name for ${appLabel}`);
+        if ('shell' !== app.kind && 'vertical' !== app.kind) throw new Error(`Invalid app kind for ${appLabel}: ${String(app.kind)}`);
+        assertNonEmptyString(app.portEnv, `port env for ${appLabel}`);
+        if ('number' != typeof app.port || !Number.isFinite(app.port) || app.port <= 0) throw new Error(`Invalid development port for ${appLabel}`);
+        assertNonEmptyString(app.mfName, `Module Federation name for ${appLabel}`);
+        if (app.api) {
+            assertNonEmptyString(app.api.prefix, `API prefix for ${appLabel}`);
+            if (!app.api.prefix.startsWith('/')) throw new Error(`API prefix for ${appLabel} must start with "/"`);
+        }
+    }
+}
+function validateUniqueWorkspaceAppDescriptors(apps) {
+    assertUniqueAppField(apps, 'app id', (app)=>app.id);
+    assertUniqueAppField(apps, 'package suffix', (app)=>app.packageSuffix);
+    assertUniqueAppField(apps, 'output path', (app)=>normalizePath(app.directory));
+    assertUniqueAppField(apps, 'Module Federation name', (app)=>app.mfName);
+    assertUniqueAppField(apps, 'development port', (app)=>String(app.port));
+    assertUniqueAppField(apps, 'API prefix', (app)=>app.api?.prefix);
+    assertUniqueAppField(apps, 'manifest environment name', (app)=>'vertical' === app.kind ? createRemoteManifestEnv(app) : void 0);
+}
+function assertUniqueAppField(apps, label, readValue) {
+    const seen = new Map();
+    for (const app of apps){
+        const value = readValue(app);
+        if (!value) continue;
+        const previousId = seen.get(value);
+        if (previousId) throw new Error(`Duplicate ${label} "${value}" for ${previousId} and ${app.id}`);
+        seen.set(value, app.id);
+    }
+}
+function assertNonEmptyString(value, label) {
+    if ('string' != typeof value || 0 === value.length) throw new Error(`Invalid ${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 };

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

@@ -0,0 +1,66 @@
+import "node:module";
+import node_path from "node:path";
+import { WORKSPACE_PACKAGE_VERSION } from "../../ultramodern-package-source.js";
+import { createShellApiClient } from "../api.js";
+import { createAppEnvDts, createAppRuntimeConfig, createShellFrameComponent } from "../app-files.js";
+import { createShellPage, createShellRemoteComponents, createShellWorkerRemoteComponents } from "../demo-components.js";
+import { appEmitsBrowserUi, appHasApi, appI18nNamespace, remoteDependencyAlias, resolveRemoteRefs, shellApp, zephyrRemoteDependency } from "../descriptors.js";
+import { readJsonFile, writeFileReplacing, writeJsonFile } from "../fs-io.js";
+import { createAppPublicLocaleMessages } from "../locales.js";
+import { createAppModernConfig, createShellModuleFederationConfig } from "../module-federation.js";
+import { packageName } from "../naming.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 = []) {
+    const packagePath = node_path.join(workspaceRoot, 'package.json');
+    const rootPackage = readJsonFile(packagePath);
+    const generatedRootPackage = createRootPackageJson(scope, packageSource, remotes, bridge, additionalShells);
+    rootPackage.scripts = generatedRootPackage.scripts;
+    writeJsonFile(packagePath, rootPackage);
+}
+function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes, bridge, shell = shellApp, devPorts) {
+    const shellHost = {
+        ...shell,
+        verticalRefs: shell.verticalRefs ?? remotes.filter(appEmitsBrowserUi).map((remote)=>remote.id)
+    };
+    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));
+}
+function addShellZephyrDependency(workspaceRoot, scope, remote, shell = shellApp) {
+    const packagePath = node_path.join(workspaceRoot, shell.directory, 'package.json');
+    const shellPackage = readJsonFile(packagePath);
+    shellPackage['zephyr:dependencies'] ??= {};
+    shellPackage['zephyr:dependencies'][remoteDependencyAlias(remote)] = zephyrRemoteDependency(scope, remote);
+    writeJsonFile(packagePath, shellPackage);
+}
+function addShellWorkspaceDependency(workspaceRoot, scope, remote, shell = shellApp) {
+    if (!appHasApi(remote)) return;
+    const packagePath = node_path.join(workspaceRoot, shell.directory, 'package.json');
+    const shellPackage = readJsonFile(packagePath);
+    shellPackage.dependencies ??= {};
+    shellPackage.dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
+    writeJsonFile(packagePath, shellPackage);
+}
+export { addShellWorkspaceDependency, addShellZephyrDependency, rewriteShellAppFiles, updateRootWorkspaceScripts };