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

package/dist/esm-node/ultramodern-workspace/workspace-validation-contract.js

@@ -0,0 +1,387 @@
+import "node:module";
+import { ULTRAMODERN_CREATE_PACKAGE } from "../ultramodern-package-source.js";
+import { verticalApiGroupName } from "./api.js";
+import { createBackendFederationMetadata } from "./backend-federation.js";
+import { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig } from "./contracts.js";
+import { createDeliveryUnitRecord } from "./delivery-unit.js";
+import { remoteComponentOutputPath } from "./demo-components.js";
+import { appEmitsBrowserUi, appHasApi, appI18nNamespace, createShellHost, remoteDependencyAlias, resolveApiProtocol, resolveApiStem, sharedPackages, shellApp } from "./descriptors.js";
+import { packageName, tailwindPrefixForApp } from "./naming.js";
+import { createCloudflareSecurityContract } from "./policy.js";
+import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
+import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
+import { createAdditionalShellConfigEntry, shellDeliveryUnitBlock } from "./shells.js";
+import { resolveOwnerAttribution } from "./types.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE, CROSS_ENV_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, MODULE_FEDERATION_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_HISTORY_VERSION } from "./versions.js";
+import { createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan } from "./workspace-script-plan.js";
+const WORKSPACE_VALIDATION_CONTRACT_SCHEMA_VERSION = 2;
+const WORKSPACE_METADATA_SCHEMA_VERSION = 1;
+const WORKSPACE_VALIDATION_CONTRACT_KIND = 'modernjs.ultramodern-workspace-validation-contract';
+const modernPackageCohort = [
+    ULTRAMODERN_CREATE_PACKAGE,
+    '@modern-js/code-tools',
+    '@modern-js/app-tools',
+    '@modern-js/plugin-bff',
+    '@modern-js/plugin-i18n',
+    '@modern-js/plugin-tanstack',
+    '@modern-js/runtime'
+];
+const asJsonRecord = (value)=>value;
+function projectModuleFederationMetadata(value) {
+    const moduleFederation = asJsonRecord(value);
+    return {
+        ...moduleFederation,
+        ...Array.isArray(moduleFederation.remotes) ? {
+            remotes: moduleFederation.remotes.map((value)=>{
+                const remote = asJsonRecord(value);
+                return {
+                    id: remote.id,
+                    manifestUrl: remote.manifestUrl,
+                    name: remote.name
+                };
+            })
+        } : {}
+    };
+}
+function createReferenceTopologyExpectation(scope, remotes, primaryShell) {
+    const topology = asJsonRecord(createTopology(scope, remotes, primaryShell));
+    const shell = asJsonRecord(topology.shell);
+    return {
+        ...topology,
+        shell: {
+            ...shell,
+            moduleFederation: projectModuleFederationMetadata(shell.moduleFederation)
+        },
+        verticals: Array.isArray(topology.verticals) ? topology.verticals.map((value)=>{
+            const vertical = asJsonRecord(value);
+            return {
+                ...vertical,
+                moduleFederation: projectModuleFederationMetadata(vertical.moduleFederation)
+            };
+        }) : topology.verticals
+    };
+}
+const validationEvidencePolicy = {
+    schemaVersion: 1,
+    required: [
+        {
+            id: "typescript-compiler",
+            kind: 'compiler'
+        },
+        {
+            id: 'architecture-compiler',
+            kind: 'compiler'
+        },
+        {
+            id: 'executable-modern-config',
+            kind: 'runtime'
+        },
+        {
+            id: 'executable-runtime-config',
+            kind: 'runtime'
+        },
+        {
+            id: 'executable-module-federation-config',
+            kind: 'runtime'
+        },
+        {
+            id: 'executable-build-facade',
+            kind: 'runtime'
+        },
+        {
+            id: 'structured-package-config',
+            kind: 'structured'
+        },
+        {
+            id: 'structured-deploy-config',
+            kind: 'structured'
+        },
+        {
+            id: 'public-behavior-gates',
+            kind: 'behavior'
+        }
+    ]
+};
+function createStructuralShellPolicy(workspaceApps) {
+    return {
+        schemaVersion: 1,
+        shells: workspaceApps.filter((app)=>'shell' === app.kind).map((app)=>({
+                id: app.id,
+                packageDir: app.directory,
+                srcDir: `${app.directory}/src`
+            })),
+        forbiddenPathClasses: [
+            {
+                id: 'shell-api-surface',
+                path: 'api',
+                diagnostic: 'A thin Shell must not own an API surface (api/); business APIs belong to a MicroVertical.'
+            },
+            {
+                id: 'shell-server-surface',
+                path: 'server',
+                diagnostic: 'A thin Shell must not own a server surface (server/); server capability belongs to a MicroVertical.'
+            },
+            {
+                id: 'shell-backend-federation',
+                path: 'backend-federation.config.ts',
+                diagnostic: 'A thin Shell must not own backend-federation artifacts; backend federation belongs to a MicroVertical delivery unit.'
+            }
+        ]
+    };
+}
+function createFederatedCompositionPolicy(scope, hosts, remotes) {
+    const remotesById = new Map(remotes.map((remote)=>[
+            remote.id,
+            remote
+        ]));
+    return {
+        schemaVersion: 1,
+        hosts: [
+            ...new Map(hosts.map((host)=>[
+                    host.id,
+                    host
+                ])).values()
+        ].filter((host)=>(host.verticalRefs?.length ?? 0) > 0).map((host)=>({
+                id: host.id,
+                srcDir: `${host.directory}/src`,
+                remotes: (host.verticalRefs ?? []).map((remoteId)=>{
+                    const remote = remotesById.get(remoteId);
+                    if (void 0 === remote) throw new Error(`Unknown remote vertical reference ${remoteId} for ${host.id}.`);
+                    return {
+                        id: remote.id,
+                        directory: remote.directory,
+                        packageName: packageName(scope, remote.packageSuffix)
+                    };
+                })
+            }))
+    };
+}
+function createWorkspaceValidationContract(scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride) {
+    const resolvedPrimaryShell = primaryShell ?? createShellHost(remotes);
+    const workspaceApps = [
+        resolvedPrimaryShell,
+        ...remotes
+    ];
+    const configuredShells = [
+        resolvedPrimaryShell,
+        ...additionalShells
+    ];
+    const compactConfig = asJsonRecord(compactConfigOverride ?? createUltramodernConfig(scope, 'workspace-validation-contract', {
+        strategy: 'workspace',
+        modernPackageVersion: 'workspace:*'
+    }, workspaceApps, enableTailwind, void 0, additionalShells, resolvedPrimaryShell));
+    const fullStackVerticals = remotes.map((remote)=>({
+            id: remote.id,
+            domain: remote.domain,
+            path: remote.directory,
+            port: remote.port,
+            mfName: remote.mfName,
+            emitsApi: appHasApi(remote),
+            emitsUi: appEmitsBrowserUi(remote),
+            surfaceProfile: remote.surfaceProfile ?? 'full-stack',
+            ...appHasApi(remote) ? {
+                stem: remote.api.stem,
+                group: verticalApiGroupName(remote),
+                apiPrefix: remote.api.prefix,
+                apiProtocol: resolveApiProtocol(remote),
+                apiContractExport: './api',
+                apiClientExport: 'rpc' === resolveApiProtocol(remote) ? './api/rpc-client' : './api/client',
+                apiContractPath: 'rpc' === resolveApiProtocol(remote) ? 'shared/rpc.ts' : 'shared/api.ts',
+                apiClientPath: `src/api/${resolveApiStem(remote)}-${'rpc' === resolveApiProtocol(remote) ? 'rpc-client' : 'client'}.ts`,
+                backendFederation: createBackendFederationMetadata(scope, remote)
+            } : {},
+            tailwindPrefix: tailwindPrefixForApp(remote),
+            zephyrAlias: remoteDependencyAlias(remote),
+            packageName: packageName(scope, remote.packageSuffix),
+            deliveryUnit: createDeliveryUnitRecord(scope, remote),
+            exposes: Object.keys(remote.exposes ?? {}),
+            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
+            namespace: appI18nNamespace(remote),
+            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
+            routeMetaPaths: createRouteOwnedI18nPaths(remote).map((route)=>createRouteMetaFilePath(remote, route.canonicalPath)),
+            localisedUrls: createLocalisedUrlsMap(remote),
+            verticalRefs: remote.verticalRefs ?? []
+        }));
+    const additionalShellRecords = additionalShells.map((shell)=>{
+        const configEntry = createAdditionalShellConfigEntry(scope, shell, remotes);
+        return {
+            id: shell.id,
+            path: shell.directory,
+            packageName: packageName(scope, shell.packageSuffix),
+            port: shell.port,
+            portEnv: shell.portEnv,
+            mfName: shell.mfName,
+            tailwindPrefix: tailwindPrefixForApp(shell),
+            verticalRefs: shell.verticalRefs ?? [],
+            owner: resolveOwnerAttribution(shell.ownership),
+            deliveryUnit: shellDeliveryUnitBlock(scope, shell),
+            degradedState: {
+                required: (shell.verticalRefs ?? []).length > 0,
+                appId: shell.id,
+                status: 'degraded'
+            },
+            moduleFederation: configEntry.moduleFederation
+        };
+    });
+    return {
+        schemaVersion: WORKSPACE_VALIDATION_CONTRACT_SCHEMA_VERSION,
+        kind: WORKSPACE_VALIDATION_CONTRACT_KIND,
+        metadata: {
+            compactConfig: {
+                path: '.modernjs/ultramodern.json',
+                schemaVersion: WORKSPACE_METADATA_SCHEMA_VERSION
+            },
+            referenceTopology: {
+                path: 'topology/reference-topology.json',
+                schemaVersion: WORKSPACE_METADATA_SCHEMA_VERSION
+            },
+            ownership: {
+                path: 'topology/ownership.json',
+                schemaVersion: WORKSPACE_METADATA_SCHEMA_VERSION
+            },
+            developmentOverlay: {
+                path: 'topology/local-overlays/development.json',
+                schemaVersion: WORKSPACE_METADATA_SCHEMA_VERSION
+            },
+            ...releaseCohort ? {
+                releaseCohort: {
+                    path: '.modernjs/release-cohort.json',
+                    schemaVersion: releaseCohort.schemaVersion
+                }
+            } : {}
+        },
+        cohort: {
+            modernPackages: [
+                ...modernPackageCohort
+            ],
+            ...releaseCohort ? {
+                releaseCohort
+            } : {},
+            appIds: workspaceApps.map((app)=>app.id),
+            ...additionalShells.length > 0 ? {
+                additionalShellIds: additionalShells.map((app)=>app.id),
+                additionalShellOwnerIds: additionalShells.map((app)=>app.id),
+                additionalShellDeliveryUnitIds: additionalShells.map((app)=>app.id),
+                additionalShellDegradedStateIds: additionalShells.map((app)=>app.id),
+                additionalShellBuildMarkerIds: additionalShells.map((app)=>app.id)
+            } : {},
+            backendAppIds: fullStackVerticals.filter((app)=>app.emitsApi).map((app)=>app.id),
+            verticalIds: remotes.map((app)=>app.id),
+            sharedPackageIds: sharedPackages.map((sharedPackage)=>sharedPackage.id),
+            ownerIds: [
+                ...workspaceApps.map((app)=>app.id),
+                ...sharedPackages.map((sharedPackage)=>sharedPackage.id)
+            ],
+            packageManifests: [
+                {
+                    id: 'workspace-root',
+                    packageName: scope,
+                    path: 'package.json',
+                    role: 'workspace-root'
+                },
+                ...workspaceApps.map((app)=>({
+                        id: app.id,
+                        packageName: packageName(scope, app.packageSuffix),
+                        path: `${app.directory}/package.json`,
+                        role: app.kind
+                    })),
+                ...sharedPackages.map((sharedPackage)=>({
+                        id: sharedPackage.id,
+                        packageName: packageName(scope, sharedPackage.id),
+                        path: `${sharedPackage.directory}/package.json`,
+                        role: 'shared-package'
+                    }))
+            ],
+            ...additionalShells.length > 0 ? {
+                additionalShellManifests: additionalShells.map((app)=>({
+                        id: app.id,
+                        packageName: packageName(scope, app.packageSuffix),
+                        path: `${app.directory}/package.json`,
+                        role: 'shell'
+                    }))
+            } : {}
+        },
+        topology: {
+            compactConfig: compactConfig.topology,
+            referenceTopology: createReferenceTopologyExpectation(scope, remotes, resolvedPrimaryShell),
+            ownership: ownershipOverride ?? createOwnership(scope, remotes),
+            developmentOverlay: developmentOverlayOverride ?? createDevelopmentOverlay(scope, remotes)
+        },
+        policy: {
+            compactConfig: {
+                schemaVersion: compactConfig.schemaVersion,
+                profile: compactConfig.profile,
+                workspace: compactConfig.workspace,
+                features: compactConfig.features,
+                deploy: compactConfig.deploy,
+                moduleFederation: compactConfig.moduleFederation,
+                backendFederation: compactConfig.backendFederation,
+                agentSkills: compactConfig.agentSkills,
+                tooling: compactConfig.tooling
+            }
+        },
+        legacy: {
+            retiredMetadataPaths: [
+                '.modernjs/ultramodern-generated-contract.json',
+                '.modernjs/ultramodern-package-source.json',
+                '.modernjs/ultramodern-workspace-template-manifest.json'
+            ],
+            forbiddenCompactConfigFields: [
+                'generatedContract',
+                'packageCohort',
+                'workspaceValidationContract'
+            ],
+            forbiddenPackageSourceFields: [
+                'generatedWorkspacePackages',
+                'metadata',
+                'modernPackages'
+            ],
+            forbiddenTopologyFields: [
+                'effectServices',
+                'remotes'
+            ]
+        },
+        validationEvidencePolicy: validationEvidencePolicy,
+        packageScope: scope,
+        node: {
+            version: NODE_VERSION,
+            engineRange: '>=26'
+        },
+        versions: {
+            cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE,
+            crossEnv: CROSS_ENV_VERSION,
+            effect: EFFECT_VERSION,
+            effectVitest: EFFECT_VITEST_VERSION,
+            moduleFederation: MODULE_FEDERATION_VERSION,
+            node: NODE_VERSION,
+            pnpm: PNPM_VERSION,
+            tanstackHistory: TANSTACK_HISTORY_VERSION
+        },
+        tailwindEnabled: enableTailwind,
+        structuralShellPolicy: createStructuralShellPolicy(configuredShells),
+        federatedCompositionPolicy: createFederatedCompositionPolicy(scope, [
+            ...configuredShells,
+            ...remotes
+        ], remotes),
+        ...additionalShellRecords.length > 0 ? {
+            additionalShells: additionalShellRecords
+        } : {},
+        fullStackVerticals,
+        shellNamespace: appI18nNamespace(shellApp),
+        oldRemotePaths: [
+            'apps/remotes'
+        ],
+        scripts: createWorkspaceRootScriptPlan(remotes, {
+            shells: configuredShells
+        }),
+        packageScripts: createWorkspaceRootPackageScripts(remotes, {
+            shells: configuredShells
+        }),
+        cloudflareSecurity: createCloudflareSecurityContract(),
+        publicSurfaceManagedSourceAssetPaths: [
+            ...publicSurfaceManagedSourceAssetPaths
+        ],
+        shellRouteMetaPaths: createRouteOwnedI18nPaths(shellApp).map((route)=>createRouteMetaFilePath(shellApp, route.canonicalPath))
+    };
+}
+export { createWorkspaceValidationContract };

package/dist/esm-node/ultramodern-workspace/write-app.js

@@ -0,0 +1,106 @@
+import "node:module";
+import { createApiClient, createApiServiceEntry, createBackendEffectApiExpose, createSharedApi, createShellApiClient } from "./api.js";
+import { createRpcClientFile, createRpcContractFile } from "./api/rpc.js";
+import { createAppEnvDts, createAppRuntimeConfig, createAppStyles, createShellFrameComponent, createTailwindConfig } from "./app-files.js";
+import { createBackendFederationContractFile } from "./backend-federation.js";
+import { createFederatedComponentsRegistry, createLayout, createRemoteEntry, createRemoteExposeComponent, createRemoteExposeFragmentPage, createRemotePage, createShellPage, createShellRemoteComponents, createShellWorkerRemoteComponents, remoteComponentOutputPath } from "./demo-components.js";
+import { appEmitsBrowserUi, appHasApi, appI18nNamespace, createShellHost, distributedSsrExposes, distributedSsrFragmentSlug, resolveApiProtocol, resolveRemoteRefs } from "./descriptors.js";
+import { writeFile, writeFileReplacing, writeJson } from "./fs-io.js";
+import { createAppPublicLocaleMessages } from "./locales.js";
+import { createAppModernConfig, createBackendModuleFederationConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "./module-federation.js";
+import { createAppMfTypesTsConfig, createAppPackage, createAppTsConfig } from "./package-json.js";
+import { createPublicWebAppArtifacts } from "./public-surface.js";
+function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes = [], bridge, devPorts) {
+    const resolvedApp = 'shell' === app.kind && app.id === createShellHost(remotes).id ? createShellHost(remotes) : app;
+    const emitsUi = appEmitsBrowserUi(resolvedApp);
+    const appTailwind = enableTailwind && emitsUi;
+    const resolvedRemotes = 'shell' === resolvedApp.kind ? resolveRemoteRefs(resolvedApp, remotes) : remotes;
+    const publicWeb = createPublicWebAppArtifacts(resolvedApp);
+    const writeAppFile = (relativePath, content)=>{
+        writeFile(targetDir, `${resolvedApp.directory}/${relativePath}`, content);
+    };
+    const context = {
+        targetDir,
+        scope,
+        resolvedApp,
+        packageSource,
+        enableTailwind: appTailwind,
+        emitsUi,
+        remotes: resolvedRemotes,
+        bridge,
+        devPorts,
+        publicWeb,
+        writeAppFile
+    };
+    writeAppConfigFiles(context);
+    writeAppLocaleAndStyleFiles(context);
+    writeAppFederationConfigFiles(context);
+    writeAppRouteAndShellFiles(context);
+    writeAppApiAndRemoteExposeFiles(context);
+}
+function rewriteAppModernConfig(targetDir, scope, app, remotes, enableTailwind, devPorts) {
+    writeFileReplacing(targetDir, `${app.directory}/modern.config.ts`, createAppModernConfig(scope, app, remotes, enableTailwind, devPorts));
+}
+function writeAppConfigFiles({ targetDir, scope, resolvedApp, packageSource, enableTailwind, emitsUi, remotes, bridge, devPorts, publicWeb }) {
+    writeJson(targetDir, `${resolvedApp.directory}/package.json`, createAppPackage(scope, resolvedApp, packageSource, enableTailwind, remotes, bridge));
+    writeJson(targetDir, `${resolvedApp.directory}/tsconfig.json`, createAppTsConfig(resolvedApp, remotes));
+    writeJson(targetDir, `${resolvedApp.directory}/tsconfig.mf-types.json`, createAppMfTypesTsConfig(resolvedApp));
+    writeFile(targetDir, `${resolvedApp.directory}/src/modern-app-env.d.ts`, createAppEnvDts(resolvedApp, remotes, scope));
+    writeFile(targetDir, `${resolvedApp.directory}/src/ultramodern-build.ts`, createUltramodernBuildReexportModule());
+    writeFile(targetDir, `${resolvedApp.directory}/shared/ultramodern-build.ts`, createUltramodernBuildModule(scope, resolvedApp));
+    writeFile(targetDir, `${resolvedApp.directory}/shared/ultramodern-build.json`, createUltramodernBuildArtifactJson(scope, resolvedApp));
+    if (emitsUi) {
+        writeFile(targetDir, publicWeb.jsonLdHelperFile.path, publicWeb.jsonLdHelperFile.content);
+        writeFile(targetDir, publicWeb.routeMetadataFile.path, publicWeb.routeMetadataFile.content);
+        writeFile(targetDir, publicWeb.routeHeadFile.path, publicWeb.routeHeadFile.content);
+    }
+    writeFile(targetDir, `${resolvedApp.directory}/modern.config.ts`, createAppModernConfig(scope, resolvedApp, remotes, enableTailwind, devPorts));
+    writeFile(targetDir, `${resolvedApp.directory}/src/modern.runtime.ts`, createAppRuntimeConfig(resolvedApp, scope, remotes));
+}
+function writeAppLocaleAndStyleFiles({ targetDir, scope, resolvedApp, enableTailwind, emitsUi, remotes }) {
+    writeJson(targetDir, `${resolvedApp.directory}/locales/en/translation.json`, createAppPublicLocaleMessages(resolvedApp, 'en', remotes));
+    writeJson(targetDir, `${resolvedApp.directory}/locales/en/${appI18nNamespace(resolvedApp)}.json`, createAppPublicLocaleMessages(resolvedApp, 'en', remotes));
+    writeJson(targetDir, `${resolvedApp.directory}/locales/cs/translation.json`, createAppPublicLocaleMessages(resolvedApp, 'cs', remotes));
+    writeJson(targetDir, `${resolvedApp.directory}/locales/cs/${appI18nNamespace(resolvedApp)}.json`, createAppPublicLocaleMessages(resolvedApp, 'cs', remotes));
+    if (emitsUi) writeFile(targetDir, `${resolvedApp.directory}/src/routes/index.css`, createAppStyles(enableTailwind, scope, resolvedApp));
+    if (enableTailwind) writeFile(targetDir, `${resolvedApp.directory}/tailwind.config.ts`, createTailwindConfig());
+}
+function writeAppFederationConfigFiles({ targetDir, scope, resolvedApp, emitsUi, remotes }) {
+    if (emitsUi) writeFile(targetDir, `${resolvedApp.directory}/module-federation.config.ts`, 'shell' === resolvedApp.kind ? createShellModuleFederationConfig(scope, resolvedApp, remotes) : createRemoteModuleFederationConfig(scope, resolvedApp, remotes));
+    if (appHasApi(resolvedApp)) writeFile(targetDir, `${resolvedApp.directory}/backend-federation.config.ts`, createBackendModuleFederationConfig(resolvedApp));
+}
+function writeAppRouteAndShellFiles({ targetDir, scope, resolvedApp, emitsUi, remotes, publicWeb, writeAppFile }) {
+    if (!emitsUi) return;
+    if ((resolvedApp.verticalRefs?.length ?? 0) > 0) {
+        writeAppFile('src/federated-components.tsx', createFederatedComponentsRegistry(scope, resolvedApp, remotes));
+        writeAppFile('src/federated-components.worker.tsx', createFederatedComponentsRegistry(scope, resolvedApp, remotes, true));
+    }
+    writeAppFile('src/routes/layout.tsx', createLayout(resolvedApp.id));
+    writeAppFile('src/routes/[lang]/page.tsx', 'shell' === resolvedApp.kind ? createShellPage(resolvedApp, remotes.filter(appEmitsBrowserUi)) : createRemotePage(resolvedApp));
+    for (const generatedFile of publicWeb.routeMetaFiles)writeFile(targetDir, generatedFile.path, generatedFile.content);
+    for (const generatedFile of publicWeb.routeAliasFiles)writeFile(targetDir, generatedFile.path, generatedFile.content);
+    if ('shell' === resolvedApp.kind) {
+        writeAppFile('src/routes/vertical-components.tsx', createShellRemoteComponents(resolvedApp, remotes.filter(appEmitsBrowserUi)));
+        writeAppFile('src/routes/vertical-components.worker.tsx', createShellWorkerRemoteComponents(resolvedApp, remotes.filter(appEmitsBrowserUi)));
+        writeAppFile('src/routes/shell-frame.tsx', createShellFrameComponent(resolvedApp));
+        writeFile(targetDir, `${resolvedApp.directory}/src/api/vertical-clients.ts`, createShellApiClient(scope, remotes));
+    } else for (const expose of distributedSsrExposes(resolvedApp))writeAppFile(`src/routes/[lang]/_mf/fragment/${distributedSsrFragmentSlug(expose)}/page.tsx`, createRemoteExposeFragmentPage(resolvedApp, expose));
+}
+function writeAppApiAndRemoteExposeFiles({ targetDir, scope, resolvedApp, emitsUi, writeAppFile }) {
+    if (appHasApi(resolvedApp)) {
+        const rpcProtocol = 'rpc' === resolveApiProtocol(resolvedApp);
+        rpcProtocol ? writeFile(targetDir, `${resolvedApp.directory}/shared/rpc.ts`, createRpcContractFile(resolvedApp)) : writeFile(targetDir, `${resolvedApp.directory}/shared/api.ts`, createSharedApi(resolvedApp));
+        writeFile(targetDir, `${resolvedApp.directory}/api/index.ts`, createApiServiceEntry(resolvedApp, rpcProtocol ? '../shared/rpc.ts' : '../shared/api.ts'));
+        writeFile(targetDir, `${resolvedApp.directory}/api/backend-federation.ts`, createBackendFederationContractFile(resolvedApp));
+        writeFile(targetDir, `${resolvedApp.directory}/api/effect-api.ts`, createBackendEffectApiExpose(scope, resolvedApp));
+        rpcProtocol ? writeFile(targetDir, `${resolvedApp.directory}/src/api/${resolvedApp.api.stem}-rpc-client.ts`, createRpcClientFile(resolvedApp)) : writeFile(targetDir, `${resolvedApp.directory}/src/api/${resolvedApp.api.stem}-client.ts`, createApiClient(resolvedApp, '../../shared/api'));
+    }
+    if ('vertical' === resolvedApp.kind && emitsUi) {
+        writeAppFile('src/federation-entry.tsx', createRemoteEntry(resolvedApp));
+        for (const expose of Object.keys(resolvedApp.exposes ?? {})){
+            const outputPath = remoteComponentOutputPath(resolvedApp, expose);
+            if (outputPath) writeAppFile(outputPath.slice(resolvedApp.directory.length + 1), createRemoteExposeComponent(resolvedApp, expose));
+        }
+    }
+}
+export { rewriteAppModernConfig, writeApp };

package/dist/esm-node/ultramodern-workspace/write-workspace.js

@@ -0,0 +1,179 @@
+import "node:module";
+import node_fs from "node:fs";
+import { RELEASE_COHORT_PROJECTION_PATH, copyCreateReleaseCohort, isCreatePackageSourceCheckout, readCreateReleaseCohort } from "../ultramodern-release-cohort.js";
+import { runFreshWorkspaceTransaction } from "./add-vertical/transaction.js";
+import { createSharedDesignTokensCss } from "./app-files.js";
+import { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
+import { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig } from "./contracts.js";
+import { ULTRAMODERN_CONFIG_PATH, createShellHost, sharedPackages, shellApp } from "./descriptors.js";
+import { copyRootTemplate, formatGeneratedWorkspaceFiles, writeFile, writeFileReplacing, writeJson } from "./fs-io.js";
+import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
+import { assertUniqueTailwindPrefixes, toPackageScope } from "./naming.js";
+import { runCodeSmithOverlays } from "./overlays.js";
+import { createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createTsConfigBase } from "./package-json.js";
+import { resolvePackageSource, resolveWorkspacePackageLinkingPolicy } from "./package-source.js";
+import { renderMinimumReleaseAgeExclude } from "./policy.js";
+import { DRIZZLE_ORM_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, MODULE_FEDERATION_VERSION, MSGPACKR_VERSION, NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_HISTORY_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION, WRANGLER_VERSION, ZOD_VERSION } from "./versions.js";
+import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
+import { writeApp } from "./write-app.js";
+import { createZeropsYaml } from "./zerops.js";
+function hasExplicitInstallRequest(options) {
+    return void 0 !== options.packageSource && 'workspace' !== options.packageSource.strategy;
+}
+function writeSharedPackages(targetDir, scope) {
+    for (const sharedPackage of sharedPackages){
+        writeJson(targetDir, `${sharedPackage.directory}/package.json`, createSharedPackage(scope, sharedPackage.id, sharedPackage.description));
+        writeJson(targetDir, `${sharedPackage.directory}/tsconfig.json`, createSharedPackageTsConfig(sharedPackage.directory));
+    }
+    writeFile(targetDir, 'packages/shared-contracts/src/index.ts', createSharedContractsIndex());
+    writeFile(targetDir, 'packages/shared-design-tokens/src/index.ts', `export const sharedDesignTokens = {
+  color: {
+    accent: '#2f8f68',
+    foreground: '#133225',
+    surface: '#f6fbf7',
+  },
+} as const;
+`);
+    writeFile(targetDir, 'packages/shared-design-tokens/src/tokens.css', createSharedDesignTokensCss());
+}
+function createCompactRootPackageJson(scope, packageSource, remotes, bridge) {
+    const rootPackage = createRootPackageJson(scope, packageSource, remotes, bridge);
+    if (rootPackage.modernjs?.packageSource && 'object' == typeof rootPackage.modernjs.packageSource) rootPackage.modernjs.packageSource.config = `./${ULTRAMODERN_CONFIG_PATH}`;
+    return rootPackage;
+}
+function createCompactUltramodernConfig(scope, modernVersion, packageSource, apps = [
+    createShellHost()
+], enableTailwind = true, bridge, additionalShells = [], primaryShell) {
+    const config = createUltramodernConfig(scope, modernVersion, packageSource, apps, enableTailwind, bridge, additionalShells, primaryShell);
+    if (config.packageSource && 'object' == typeof config.packageSource && !Array.isArray(config.packageSource)) delete config.packageSource.metadata;
+    return config;
+}
+function writePnpmWorkspacePackages(targetDir, bridge) {
+    if (!bridge) return;
+    const pnpmWorkspacePath = `${targetDir}/pnpm-workspace.yaml`;
+    const pnpmWorkspace = node_fs.readFileSync(pnpmWorkspacePath, 'utf-8');
+    const packages = [
+        'apps/*',
+        'verticals/*',
+        'packages/*',
+        ...bridge.workspacePackages.map((entry)=>entry.pattern)
+    ];
+    const renderedPackages = packages.map((pattern)=>`  - ${pattern}`).join('\n');
+    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\r?\n(?: {2}- .+\r?\n)+/u, `packages:\n${renderedPackages}\n`));
+}
+function generateUltramodernWorkspace(options) {
+    const result = runFreshWorkspaceTransaction(options.targetDir, (stagingRoot)=>generateUltramodernWorkspaceInPlace({
+            ...options,
+            targetDir: stagingRoot
+        }, options.targetDir));
+    return result;
+}
+function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = options.targetDir) {
+    const beforeFiles = createFileSnapshot(options.targetDir);
+    const scope = toPackageScope(options.packageName);
+    let packageSource;
+    let releaseCohort;
+    if (isCreatePackageSourceCheckout()) {
+        if (hasExplicitInstallRequest(options)) throw new Error('A local @modern-js/ultramodern-create source checkout cannot satisfy an explicit install package source. Use workspace mode locally or run the packed published package with its authenticated release cohort projection.');
+        packageSource = resolvePackageSource({
+            ...options,
+            packageSource: {
+                strategy: 'workspace'
+            }
+        });
+    } else {
+        packageSource = resolvePackageSource(options);
+        if ('install' === packageSource.strategy) releaseCohort = readCreateReleaseCohort();
+    }
+    const bridge = normalizeUltramodernBridgeConfig(options.bridge);
+    const enableTailwind = false !== options.enableTailwind;
+    const initialVerticals = [];
+    const createdApps = [
+        createShellHost(initialVerticals),
+        ...initialVerticals
+    ];
+    assertUniqueTailwindPrefixes([
+        shellApp,
+        ...initialVerticals
+    ]);
+    node_fs.mkdirSync(options.targetDir, {
+        recursive: true
+    });
+    const minimumReleaseAgeExclude = renderMinimumReleaseAgeExclude({
+        packageSource,
+        releaseCohort
+    });
+    const workspacePackageLinkingPolicy = resolveWorkspacePackageLinkingPolicy(packageSource);
+    const excludedRootTemplates = new Set([
+        RELEASE_COHORT_PROJECTION_PATH
+    ]);
+    if (false === options.generateAgentFiles) {
+        excludedRootTemplates.add('AGENTS.md.handlebars');
+        excludedRootTemplates.add('CLAUDE.md.handlebars');
+    }
+    copyRootTemplate(options.targetDir, {
+        packageName: options.packageName,
+        packageScope: scope,
+        nodeVersion: NODE_VERSION,
+        pnpmVersion: PNPM_VERSION,
+        nodeFetchVersion: NODE_FETCH_VERSION,
+        drizzleOrmVersion: DRIZZLE_ORM_VERSION,
+        effectVersion: EFFECT_VERSION,
+        effectVitestVersion: EFFECT_VITEST_VERSION,
+        i18nextVersion: I18NEXT_VERSION,
+        moduleFederationVersion: MODULE_FEDERATION_VERSION,
+        msgpackrVersion: MSGPACKR_VERSION,
+        zodVersion: ZOD_VERSION,
+        tanstackHistoryVersion: TANSTACK_HISTORY_VERSION,
+        tanstackRouterCoreVersion: TANSTACK_ROUTER_CORE_VERSION,
+        tanstackRouterVersion: TANSTACK_ROUTER_VERSION,
+        typescriptVersion: TYPESCRIPT_VERSION,
+        wranglerVersion: WRANGLER_VERSION,
+        minimumReleaseAgeExcludeYaml: 0 === minimumReleaseAgeExclude.length ? ' []' : `\n${minimumReleaseAgeExclude.map((selector)=>`  - '${selector}'`).join('\n')}`,
+        workspacePackageLinkingYaml: Object.entries(workspacePackageLinkingPolicy).map(([key, value])=>`${key}: ${String(value)}\n`).join(''),
+        tailwindEnabled: String(enableTailwind)
+    }, excludedRootTemplates);
+    if (releaseCohort) copyCreateReleaseCohort(options.targetDir);
+    writePnpmWorkspacePackages(options.targetDir, bridge);
+    writeJson(options.targetDir, 'package.json', createCompactRootPackageJson(scope, packageSource, initialVerticals, bridge));
+    if (initialVerticals.length > 0) writeFile(options.targetDir, 'zerops.yaml', `${createZeropsYaml(scope, createdApps)}\n`);
+    writeJson(options.targetDir, 'tsconfig.base.json', createTsConfigBase());
+    writeJson(options.targetDir, 'tsconfig.json', createRootTsConfig(createdApps));
+    writeJson(options.targetDir, 'topology/reference-topology.json', createTopology(scope, initialVerticals));
+    writeJson(options.targetDir, 'topology/ownership.json', createOwnership(scope, initialVerticals));
+    writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay(scope, initialVerticals));
+    writeJson(options.targetDir, ULTRAMODERN_CONFIG_PATH, createCompactUltramodernConfig(scope, options.modernVersion, packageSource, createdApps, enableTailwind, bridge));
+    writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind, initialVerticals, bridge);
+    for (const remote of initialVerticals)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals, bridge);
+    writeSharedPackages(options.targetDir, scope);
+    writeGeneratedWorkspaceScripts(options.targetDir, scope, enableTailwind, initialVerticals, releaseCohort);
+    const preliminaryAfterFiles = createFileSnapshot(options.targetDir);
+    const preliminaryDiff = diffFileSnapshots(beforeFiles, preliminaryAfterFiles);
+    const preliminaryResult = createGenerationResult({
+        operation: 'workspace',
+        workspaceRoot: logicalWorkspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps,
+        createdPaths: preliminaryDiff.createdPaths,
+        rewrittenPaths: preliminaryDiff.rewrittenPaths
+    });
+    runCodeSmithOverlays({
+        workspaceRoot: options.targetDir,
+        overlays: options.overlays,
+        result: preliminaryResult
+    });
+    formatGeneratedWorkspaceFiles(options.targetDir);
+    const afterFiles = createFileSnapshot(options.targetDir);
+    const { createdPaths, rewrittenPaths } = diffFileSnapshots(beforeFiles, afterFiles);
+    return createGenerationResult({
+        operation: 'workspace',
+        workspaceRoot: logicalWorkspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps,
+        createdPaths,
+        rewrittenPaths
+    });
+}
+export { createCompactUltramodernConfig, generateUltramodernWorkspace, writeApp };