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

package/dist/cjs/ultramodern-workspace/workspace-validation-contract.cjs

@@ -0,0 +1,642 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createWorkspaceValidationContract: ()=>createWorkspaceValidationContract
+});
+const external_api_cjs_namespaceObject = require("./api.cjs");
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_contracts_cjs_namespaceObject = require("./contracts.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+const external_demo_components_cjs_namespaceObject = require("./demo-components.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_public_surface_cjs_namespaceObject = require("./public-surface.cjs");
+const external_routes_cjs_namespaceObject = require("./routes.cjs");
+const external_shells_cjs_namespaceObject = require("./shells.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const external_workspace_script_plan_cjs_namespaceObject = require("./workspace-script-plan.cjs");
+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((0, external_contracts_cjs_namespaceObject.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(external_descriptors_cjs_namespaceObject.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`,
+            ...(0, external_descriptors_cjs_namespaceObject.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: (0, external_naming_cjs_namespaceObject.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 ?? (0, external_descriptors_cjs_namespaceObject.createShellHost)(remotes);
+    const workspaceApps = [
+        resolvedPrimaryShell,
+        ...remotes
+    ];
+    const configuredShells = [
+        resolvedPrimaryShell,
+        ...additionalShells
+    ];
+    const compactConfig = asJsonRecord(compactConfigOverride ?? (0, external_contracts_cjs_namespaceObject.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: (0, external_descriptors_cjs_namespaceObject.appHasApi)(remote),
+            emitsUi: (0, external_descriptors_cjs_namespaceObject.appEmitsBrowserUi)(remote),
+            surfaceProfile: remote.surfaceProfile ?? 'full-stack',
+            ...(0, external_descriptors_cjs_namespaceObject.appHasApi)(remote) ? {
+                stem: remote.api.stem,
+                group: (0, external_api_cjs_namespaceObject.verticalApiGroupName)(remote),
+                apiPrefix: remote.api.prefix,
+                apiProtocol: (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(remote),
+                apiContractExport: './api',
+                apiClientExport: 'rpc' === (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(remote) ? './api/rpc-client' : './api/client',
+                apiContractPath: 'rpc' === (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(remote) ? 'shared/rpc.ts' : 'shared/api.ts',
+                apiClientPath: `src/api/${(0, external_descriptors_cjs_namespaceObject.resolveApiStem)(remote)}-${'rpc' === (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(remote) ? 'rpc-client' : 'client'}.ts`,
+                backendFederation: (0, external_backend_federation_cjs_namespaceObject.createBackendFederationMetadata)(scope, remote)
+            } : {},
+            tailwindPrefix: (0, external_naming_cjs_namespaceObject.tailwindPrefixForApp)(remote),
+            zephyrAlias: (0, external_descriptors_cjs_namespaceObject.remoteDependencyAlias)(remote),
+            packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, remote.packageSuffix),
+            deliveryUnit: (0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, remote),
+            exposes: Object.keys(remote.exposes ?? {}),
+            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>(0, external_demo_components_cjs_namespaceObject.remoteComponentOutputPath)(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
+            namespace: (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(remote),
+            routePagePaths: (0, external_routes_cjs_namespaceObject.createRouteOwnedI18nPaths)(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>(0, external_routes_cjs_namespaceObject.createRoutePageFilePath)(remote, route.canonicalPath)),
+            routeMetaPaths: (0, external_routes_cjs_namespaceObject.createRouteOwnedI18nPaths)(remote).map((route)=>(0, external_routes_cjs_namespaceObject.createRouteMetaFilePath)(remote, route.canonicalPath)),
+            localisedUrls: (0, external_routes_cjs_namespaceObject.createLocalisedUrlsMap)(remote),
+            verticalRefs: remote.verticalRefs ?? []
+        }));
+    const additionalShellRecords = additionalShells.map((shell)=>{
+        const configEntry = (0, external_shells_cjs_namespaceObject.createAdditionalShellConfigEntry)(scope, shell, remotes);
+        return {
+            id: shell.id,
+            path: shell.directory,
+            packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, shell.packageSuffix),
+            port: shell.port,
+            portEnv: shell.portEnv,
+            mfName: shell.mfName,
+            tailwindPrefix: (0, external_naming_cjs_namespaceObject.tailwindPrefixForApp)(shell),
+            verticalRefs: shell.verticalRefs ?? [],
+            owner: (0, external_types_cjs_namespaceObject.resolveOwnerAttribution)(shell.ownership),
+            deliveryUnit: (0, external_shells_cjs_namespaceObject.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: external_descriptors_cjs_namespaceObject.sharedPackages.map((sharedPackage)=>sharedPackage.id),
+            ownerIds: [
+                ...workspaceApps.map((app)=>app.id),
+                ...external_descriptors_cjs_namespaceObject.sharedPackages.map((sharedPackage)=>sharedPackage.id)
+            ],
+            packageManifests: [
+                {
+                    id: 'workspace-root',
+                    packageName: scope,
+                    path: 'package.json',
+                    role: 'workspace-root'
+                },
+                ...workspaceApps.map((app)=>({
+                        id: app.id,
+                        packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix),
+                        path: `${app.directory}/package.json`,
+                        role: app.kind
+                    })),
+                ...external_descriptors_cjs_namespaceObject.sharedPackages.map((sharedPackage)=>({
+                        id: sharedPackage.id,
+                        packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, sharedPackage.id),
+                        path: `${sharedPackage.directory}/package.json`,
+                        role: 'shared-package'
+                    }))
+            ],
+            ...additionalShells.length > 0 ? {
+                additionalShellManifests: additionalShells.map((app)=>({
+                        id: app.id,
+                        packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix),
+                        path: `${app.directory}/package.json`,
+                        role: 'shell'
+                    }))
+            } : {}
+        },
+        topology: {
+            compactConfig: compactConfig.topology,
+            referenceTopology: createReferenceTopologyExpectation(scope, remotes, resolvedPrimaryShell),
+            ownership: ownershipOverride ?? (0, external_contracts_cjs_namespaceObject.createOwnership)(scope, remotes),
+            developmentOverlay: developmentOverlayOverride ?? (0, external_contracts_cjs_namespaceObject.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: external_versions_cjs_namespaceObject.NODE_VERSION,
+            engineRange: '>=26'
+        },
+        versions: {
+            cloudflareCompatibilityDate: external_versions_cjs_namespaceObject.CLOUDFLARE_COMPATIBILITY_DATE,
+            effect: external_versions_cjs_namespaceObject.EFFECT_VERSION,
+            moduleFederation: external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION,
+            node: external_versions_cjs_namespaceObject.NODE_VERSION,
+            pnpm: external_versions_cjs_namespaceObject.PNPM_VERSION
+        },
+        tailwindEnabled: enableTailwind,
+        structuralShellPolicy: createStructuralShellPolicy(configuredShells),
+        federatedCompositionSourcePolicy: createFederatedCompositionSourcePolicy(scope, [
+            ...configuredShells,
+            ...remotes
+        ], remotes),
+        ...additionalShellRecords.length > 0 ? {
+            additionalShells: additionalShellRecords
+        } : {},
+        fullStackVerticals,
+        shellNamespace: (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(external_descriptors_cjs_namespaceObject.shellApp),
+        oldRemotePaths: [
+            'apps/remotes'
+        ],
+        scripts: (0, external_workspace_script_plan_cjs_namespaceObject.createWorkspaceRootScriptPlan)(remotes, {
+            shells: configuredShells
+        }),
+        packageScripts: (0, external_workspace_script_plan_cjs_namespaceObject.createWorkspaceRootPackageScripts)(remotes, {
+            shells: configuredShells
+        }),
+        cloudflareSecurity: (0, external_policy_cjs_namespaceObject.createCloudflareSecurityContract)(),
+        publicSurfaceManagedSourceAssetPaths: [
+            ...external_public_surface_cjs_namespaceObject.publicSurfaceManagedSourceAssetPaths
+        ],
+        shellRouteMetaPaths: (0, external_routes_cjs_namespaceObject.createRouteOwnedI18nPaths)(external_descriptors_cjs_namespaceObject.shellApp).map((route)=>(0, external_routes_cjs_namespaceObject.createRouteMetaFilePath)(external_descriptors_cjs_namespaceObject.shellApp, route.canonicalPath))
+    };
+}
+exports.createWorkspaceValidationContract = __webpack_exports__.createWorkspaceValidationContract;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWorkspaceValidationContract"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});