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

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

@@ -0,0 +1,605 @@
+import "node:module";
+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, EFFECT_VERSION, MODULE_FEDERATION_VERSION, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+import { createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan } from "./workspace-script-plan.js";
+const WORKSPACE_VALIDATION_CONTRACT_SCHEMA_VERSION = 1;
+const WORKSPACE_METADATA_SCHEMA_VERSION = 1;
+const WORKSPACE_VALIDATION_CONTRACT_KIND = 'modernjs.ultramodern-workspace-validation-contract';
+const modernPackageCohort = [
+    '@modern-js/create',
+    '@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
+    };
+}
+function createGeneratedSurfacePolicy(workspaceApps) {
+    const shellRouteDirectories = workspaceApps.filter((app)=>'shell' === app.kind).map((app)=>({
+            kind: 'directory',
+            path: `${app.directory}/src/routes`,
+            extensions: [
+                '.ts',
+                '.tsx'
+            ]
+        }));
+    const appConfigPaths = workspaceApps.map((app)=>`${app.directory}/modern.config.ts`);
+    const moduleFederationConfigPaths = workspaceApps.filter(appEmitsBrowserUi).map((app)=>`${app.directory}/module-federation.config.ts`);
+    const appPackagePaths = workspaceApps.map((app)=>`${app.directory}/package.json`);
+    const sourceDirectories = workspaceApps.flatMap((app)=>[
+            `${app.directory}/src`,
+            ...appHasApi(app) ? [
+                `${app.directory}/api`
+            ] : []
+        ]);
+    return {
+        schemaVersion: 1,
+        rules: [
+            {
+                id: 'effect-diagnostics-suppressions',
+                paths: [
+                    ...sourceDirectories.map((path)=>({
+                            kind: 'directory',
+                            path,
+                            extensions: [
+                                '.ts',
+                                '.tsx'
+                            ]
+                        })),
+                    {
+                        kind: 'directory',
+                        path: "scripts",
+                        extensions: [
+                            '.mts',
+                            '.ts'
+                        ],
+                        excludePaths: [
+                            "scripts/validate-ultramodern-workspace.mts"
+                        ]
+                    },
+                    ...appConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        })),
+                    ...moduleFederationConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        }))
+                ],
+                patterns: [
+                    {
+                        id: 'effect-diagnostics-directive',
+                        expression: '@effect-diagnostics\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated sources must not suppress Effect diagnostics.',
+                        fixArea: 'remove the @effect-diagnostics suppression directive'
+                    }
+                ]
+            },
+            {
+                id: 'zephyr-gating',
+                paths: [
+                    {
+                        kind: 'file',
+                        path: 'package.json'
+                    },
+                    ...appPackagePaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        })),
+                    ...appConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        })),
+                    ...moduleFederationConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        }))
+                ],
+                patterns: [
+                    {
+                        id: 'ultramodern-zephyr-environment-gate',
+                        expression: '\\bULTRAMODERN_ZEPHYR\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated Zephyr integration must not be gated or disabled through ULTRAMODERN_ZEPHYR.',
+                        fixArea: 'use the framework-owned Zephyr integration without a gate'
+                    }
+                ]
+            },
+            {
+                id: 'module-federation-bridge-escapes',
+                paths: moduleFederationConfigPaths.map((path)=>({
+                        kind: 'file',
+                        path
+                    })),
+                patterns: [
+                    {
+                        id: 'bridge-router-disabled',
+                        expression: '\\benableBridgeRouter\\s*:\\s*false\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated Module Federation must keep bridge routing enabled.',
+                        fixArea: 'remove enableBridgeRouter: false'
+                    },
+                    {
+                        id: 'dynamic-remote-type-hints-disabled',
+                        expression: '\\bdisableDynamicRemoteTypeHints\\s*:\\s*true\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated Module Federation must keep dynamic remote type hints enabled.',
+                        fixArea: 'remove disableDynamicRemoteTypeHints: true'
+                    },
+                    {
+                        id: 'shared-exclude-plugin-tree-shaking',
+                        expression: '\\btreeShakingSharedExcludePlugins\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated Module Federation must not exclude shared plugins from tree shaking.',
+                        fixArea: 'remove treeShakingSharedExcludePlugins'
+                    }
+                ]
+            },
+            {
+                id: 'shell-routing-native-navigation',
+                paths: shellRouteDirectories,
+                patterns: [
+                    {
+                        id: 'window-location-navigation',
+                        expression: '\\bwindow\\s*\\.\\s*location(?:\\s*\\.\\s*(?:assign|replace|reload)\\s*\\(|\\s*\\.\\s*href\\s*=|\\s*=)',
+                        flags: 'u',
+                        diagnostic: 'Generated shell routing must use native router navigation instead of window.location.',
+                        fixArea: 'replace manual window.location navigation with the router primitive'
+                    },
+                    {
+                        id: 'synthetic-anchor-click-interception',
+                        structuralMatcher: {
+                            kind: 'jsx-attribute',
+                            elementName: 'a',
+                            attributeName: 'onClick'
+                        },
+                        diagnostic: 'Generated shell routing must not intercept anchor clicks synthetically.',
+                        fixArea: 'use the router Link primitive without preventDefault interception'
+                    }
+                ]
+            },
+            {
+                id: 'module-federation-native-loading',
+                paths: shellRouteDirectories,
+                patterns: [
+                    {
+                        id: 'manual-module-federation-loading-wrapper',
+                        expression: '\\b(?:hydrateRoot|loadRemote|loadShare)\\s*\\(',
+                        flags: 'u',
+                        diagnostic: 'Generated shell routing must use native Module Federation loading primitives.',
+                        fixArea: 'remove the manual Module Federation hydration or loading wrapper'
+                    }
+                ]
+            },
+            {
+                id: 'framework-config-api',
+                paths: [
+                    ...appConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        })),
+                    ...moduleFederationConfigPaths.map((path)=>({
+                            kind: 'file',
+                            path
+                        }))
+                ],
+                patterns: [
+                    {
+                        id: 'direct-process-env-access',
+                        expression: '\\bprocess\\s*\\.\\s*env\\b',
+                        flags: 'u',
+                        diagnostic: 'Generated config must use the framework config environment API instead of direct process.env access.',
+                        fixArea: 'replace direct process.env access with the framework config API'
+                    },
+                    {
+                        id: 'node-child-process-access',
+                        expression: '[\'"]node:child_process[\'"]',
+                        flags: 'u',
+                        diagnostic: 'Generated config must not invoke node:child_process directly.',
+                        fixArea: 'use the framework config API instead of node:child_process'
+                    }
+                ]
+            }
+        ]
+    };
+}
+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.'
+            }
+        ],
+        forbiddenImportPatterns: [
+            {
+                id: 'vertical-directory-deep-import',
+                expression: 'from\\s+[\'"][^\'"]*verticals/[^\'"/]+/',
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published vertical surfaces (package root or Module Federation), never deep-import a vertical directory.'
+            },
+            {
+                id: 'vertical-directory-side-effect-import',
+                expression: String.raw`import\s+['"][^'"]*verticals/[^'"/]+/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published vertical surfaces; side-effect imports of vertical directories are forbidden.'
+            },
+            {
+                id: 'vertical-directory-dynamic-import',
+                expression: String.raw`import\s*\(\s*['"][^'"]*verticals/[^'"/]+/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published vertical surfaces; dynamic imports of vertical directories are forbidden.'
+            },
+            {
+                id: 'vertical-directory-require',
+                expression: String.raw`require\s*\(\s*['"][^'"]*verticals/[^'"/]+/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published vertical surfaces; require() of vertical directories is forbidden.'
+            },
+            {
+                id: 'workspace-package-source-import',
+                expression: 'from\\s+[\'"]@[^\'"/]+/[^\'"/]+/src/',
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published package surfaces, never deep-import another package’s raw src/ internals (published subpath exports are allowed).'
+            },
+            {
+                id: 'workspace-package-side-effect-import',
+                expression: String.raw`import\s+['"]@[^/'"]+/[^/'"]+/src/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published package surfaces; side-effect imports of raw package src/ are forbidden.'
+            },
+            {
+                id: 'workspace-package-dynamic-import',
+                expression: String.raw`import\s*\(\s*['"]@[^/'"]+/[^/'"]+/src/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published package surfaces; dynamic imports of raw package src/ are forbidden.'
+            },
+            {
+                id: 'workspace-package-require',
+                expression: String.raw`require\s*\(\s*['"]@[^/'"]+/[^/'"]+/src/`,
+                flags: 'u',
+                diagnostic: 'A thin Shell must consume only published package surfaces; require() of raw package src/ is forbidden.'
+            }
+        ]
+    };
+}
+function createFederatedCompositionSourcePolicy(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)
+                    };
+                })
+            })),
+        forbiddenSourcePatterns: [
+            {
+                id: 'hydrated-remote-factory',
+                expression: '\\bcreateHydratedRemote\\b',
+                flags: 'u',
+                diagnostic: 'Federated hosts must use the framework distributed SSR boundary directly; hydration-time remote factories are forbidden.'
+            },
+            {
+                id: 'hydration-flag',
+                expression: '\\[\\s*(?:is)?[Hh]ydrated\\s*,\\s*set(?:Is)?Hydrated\\s*\\]\\s*=\\s*useState\\s*\\(\\s*false\\s*\\)',
+                flags: 'u',
+                diagnostic: 'Federated hosts must hydrate the server DOM directly; hydrated-state component switching is forbidden.'
+            },
+            {
+                id: 'local-loading-copy',
+                expression: '(?:loading\\s*:\\s*|fallback\\s*=\\s*\\{\\s*)<\\s*(?:ServerComponent|LocalComponent)\\b',
+                flags: 'u',
+                diagnostic: 'Federated hosts must not render a local component copy while loading a remote implementation.'
+            }
+        ]
+    };
+}
+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'
+            ]
+        },
+        generatedSurfacePolicy: createGeneratedSurfacePolicy([
+            ...workspaceApps,
+            ...additionalShells
+        ]),
+        packageScope: scope,
+        node: {
+            version: NODE_VERSION,
+            engineRange: '>=26'
+        },
+        versions: {
+            cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE,
+            effect: EFFECT_VERSION,
+            moduleFederation: MODULE_FEDERATION_VERSION,
+            node: NODE_VERSION,
+            pnpm: PNPM_VERSION
+        },
+        tailwindEnabled: enableTailwind,
+        structuralShellPolicy: createStructuralShellPolicy(configuredShells),
+        federatedCompositionSourcePolicy: createFederatedCompositionSourcePolicy(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 };