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

package/dist/esm/ultramodern-workspace/shells.js

@@ -1,7 +1,6 @@
 import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
-import { createModuleFederationRemoteContracts, createNeutralOwnership, shellApp } from "./descriptors.js";
-import { packageName, toEnvSegment, toKebabCase, toPascalCase } from "./naming.js";
-import { resolveOwnerAttribution } from "./types.js";
+import { createNeutralOwnership, shellApp } from "./descriptors.js";
+import { toEnvSegment, toKebabCase, toPascalCase } from "./naming.js";
 const PRIMARY_SHELL_ID = shellApp.id;
 const FIRST_ADDITIONAL_SHELL_PORT = 3120;
 function createShellDescriptor(name, port) {
@@ -30,67 +29,4 @@ function assertValidShellName(name) {
 function shellDeliveryUnitBlock(scope, shell) {
     return shell.deliveryUnit ?? deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shell));
 }
-function createAdditionalShellConfigEntry(scope, shell, remotes = []) {
-    const verticalRefs = shell.verticalRefs ?? [];
-    return {
-        id: shell.id,
-        name: shell.id.replace(/^shell-/u, ''),
-        kind: 'shell',
-        package: packageName(scope, shell.packageSuffix),
-        path: shell.directory,
-        port: shell.port,
-        portEnv: shell.portEnv,
-        mfName: shell.mfName,
-        verticalRefs,
-        owner: resolveOwnerAttribution(shell.ownership),
-        deliveryUnit: shellDeliveryUnitBlock(scope, shell),
-        moduleFederation: {
-            role: 'host',
-            name: shell.mfName,
-            verticalRefs,
-            remotes: createModuleFederationRemoteContracts(shell, remotes),
-            ssr: true,
-            sharedContractVersion: 'mf-ssr-contract-v1'
-        }
-    };
-}
-function resolveConfiguredAdditionalShells(config) {
-    const shells = config?.shells;
-    if (!Array.isArray(shells)) return [];
-    return shells.filter((entry)=>null !== entry && 'object' == typeof entry && !Array.isArray(entry)).map((entry)=>{
-        const id = String(entry.id ?? '');
-        const suffix = 'string' == typeof entry.package ? entry.package.split('/').at(-1) ?? id : id;
-        const name = 'string' == typeof entry.name ? entry.name : id.replace(/^shell-/, '');
-        const port = 'number' == typeof entry.port ? entry.port : FIRST_ADDITIONAL_SHELL_PORT;
-        const descriptor = createShellDescriptor(name, port);
-        const moduleFederation = entry.moduleFederation && 'object' == typeof entry.moduleFederation && !Array.isArray(entry.moduleFederation) ? entry.moduleFederation : void 0;
-        const owner = entry.owner;
-        const deliveryUnit = entry.deliveryUnit;
-        const ownerAttribution = owner && 'object' == typeof owner && !Array.isArray(owner) && 'kind' in owner && ('team' === owner.kind || 'agent' === owner.kind || 'agent-team' === owner.kind) && 'id' in owner && 'string' == typeof owner.id ? {
-            kind: owner.kind,
-            id: owner.id,
-            ...'contact' in owner && 'string' == typeof owner.contact ? {
-                contact: owner.contact
-            } : {}
-        } : void 0;
-        const ownership = void 0 === ownerAttribution ? descriptor.ownership : {
-            ...descriptor.ownership,
-            owner: ownerAttribution
-        };
-        return {
-            ...descriptor,
-            id,
-            packageSuffix: suffix,
-            ownership,
-            displayName: 'string' == typeof entry.displayName ? entry.displayName : descriptor.displayName,
-            directory: 'string' == typeof entry.path ? entry.path : descriptor.directory,
-            portEnv: 'string' == typeof entry.portEnv ? entry.portEnv : descriptor.portEnv,
-            mfName: 'string' == typeof entry.mfName ? entry.mfName : 'string' == typeof moduleFederation?.name ? moduleFederation.name : descriptor.mfName,
-            verticalRefs: Array.isArray(entry.verticalRefs) ? entry.verticalRefs.filter((ref)=>'string' == typeof ref) : Array.isArray(moduleFederation?.verticalRefs) ? moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : [],
-            ...deliveryUnit && 'object' == typeof deliveryUnit && !Array.isArray(deliveryUnit) ? {
-                deliveryUnit: deliveryUnit
-            } : {}
-        };
-    });
-}
-export { FIRST_ADDITIONAL_SHELL_PORT, PRIMARY_SHELL_ID, assertValidShellName, createAdditionalShellConfigEntry, createShellDescriptor, resolveConfiguredAdditionalShells, shellDeliveryUnitBlock };
+export { FIRST_ADDITIONAL_SHELL_PORT, PRIMARY_SHELL_ID, assertValidShellName, createShellDescriptor, shellDeliveryUnitBlock };

package/dist/esm/ultramodern-workspace/tooling-command-catalog.js

@@ -1,20 +1,13 @@
-const defineToolingCommand = (command)=>({
-        ...command,
-        wrapperPath: `scripts/${command.wrapperName}.mts`
-    });
+const defineToolingCommand = (command)=>command;
 const generatedToolingCommands = [
     defineToolingCommand({
         id: 'validate',
         command: 'validate',
-        wrapperName: 'validate-ultramodern-workspace',
-        contractKey: 'validate',
         rootScript: 'contract:check'
     }),
     defineToolingCommand({
         id: 'typecheck',
         command: 'typecheck',
-        wrapperName: 'ultramodern-typecheck',
-        contractKey: 'typecheck',
         rootScript: 'typecheck',
         templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
         cwd: 'invocation'
@@ -22,79 +15,71 @@ const generatedToolingCommands = [
     defineToolingCommand({
         id: 'mfTypes',
         command: 'mf-types',
-        wrapperName: 'assert-mf-types',
-        contractKey: 'mfTypes',
         rootScript: 'mf:types'
     }),
     defineToolingCommand({
         id: 'publicSurface',
         command: 'public-surface',
-        wrapperName: 'generate-public-surface-assets',
-        contractKey: 'publicSurface',
         templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
     }),
     defineToolingCommand({
         id: 'backendFederationGenerate',
+        requiresBackendSurface: true,
         command: 'backend-federation-generate',
-        wrapperName: 'generate-node-backend-federation',
-        contractKey: 'backendFederationGenerate',
         rootScript: 'node:backend-federation:generate',
         templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
     }),
     defineToolingCommand({
         id: 'backendFederationProof',
+        requiresBackendSurface: true,
         command: 'backend-federation-proof',
-        wrapperName: 'proof-node-backend-federation',
-        contractKey: 'backendFederationProof',
         rootScript: 'node:proof',
         templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
     }),
     defineToolingCommand({
         id: 'cloudflareProof',
         command: 'cloudflare-proof',
-        wrapperName: 'proof-cloudflare-version',
-        contractKey: 'cloudflareProof',
         rootScript: 'cloudflare:proof',
         templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
     }),
     defineToolingCommand({
         id: 'cloudflareOutputVerify',
         command: 'cloudflare-output-verify',
-        wrapperName: 'verify-cloudflare-output',
-        contractKey: 'cloudflareOutputVerify',
         rootScript: 'cloudflare-output:verify'
     }),
     defineToolingCommand({
         id: 'performanceReadiness',
         command: 'performance-readiness',
-        wrapperName: 'ultramodern-performance-readiness',
-        contractKey: 'performanceReadiness',
         rootScript: 'performance:readiness',
         templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
     }),
     defineToolingCommand({
-        id: 'migrateStrictEffect',
-        command: 'migrate-strict-effect',
-        wrapperName: 'migrate-strict-effect',
-        contractKey: 'migrateStrictEffect',
-        rootScript: 'migrate:strict-effect'
+        id: 'routesGenerate',
+        command: 'routes-generate'
     }),
     defineToolingCommand({
-        id: 'routesGenerate',
-        command: 'routes-generate',
-        wrapperName: 'generate-tanstack-routes',
-        contractKey: 'routesGenerate'
+        id: 'zeropsMaterialize',
+        command: 'zerops-materialize',
+        rootScript: 'zerops:materialize',
+        requiresRemotes: true,
+        templatePath: "templates/workspace-scripts/materialize-zerops-runtime.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareSsrProof',
+        command: 'cloudflare-ssr-proof',
+        rootScript: 'cloudflare:ssr-proof',
+        requiresRemotes: true,
+        templatePath: "templates/workspace-scripts/proof-workerd-ssr.mjs"
     })
 ];
+function selectGeneratedToolingCommands(options = {}) {
+    const backendSurface = options.hasBackendSurface ?? !options.shellOnly;
+    return generatedToolingCommands.filter((command)=>(!options.shellOnly || !command.requiresRemotes) && (backendSurface || !command.requiresBackendSurface));
+}
 const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
         command.id,
         command
     ]));
 const GENERATED_TOOLING_COMMANDS = toolingCommandById;
 const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
-const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
-            command.contractKey,
-            command.wrapperPath
-        ]));
-const createGeneratedToolingWrapperMap = createToolingWrapperContract;
-export { GENERATED_TOOLING_COMMANDS, createGeneratedToolingWrapperMap, generatedToolingCommandList, generatedToolingCommands };
+export { GENERATED_TOOLING_COMMANDS, generatedToolingCommandList, generatedToolingCommands, selectGeneratedToolingCommands };

package/dist/esm/ultramodern-workspace/tsconfigs.js

@@ -1,11 +1,14 @@
 import node_path from "node:path";
-import { appHasApi, resolveRemoteRefs, sharedPackages } from "./descriptors.js";
+import { appHasApi, resolveApiProtocol, resolveRemoteRefs, sharedPackages } from "./descriptors.js";
 import { effectDiagnostics } from "./effect-diagnostics.js";
 import { relativeRootFor } from "./naming.js";
 function createTsConfigBase() {
     return {
         compilerOptions: {
             target: 'ESNext',
+            types: [
+                'node'
+            ],
             lib: [
                 'ESNext',
                 'DOM',
@@ -70,7 +73,8 @@ function createPackageTsConfig(packageDir, options = {}) {
         'src',
         'locales/**/*.json',
         'package.json',
-        'shared'
+        'shared',
+        'shared/ultramodern-build.json'
     ];
     if (resolvedOptions.includeServer) include.push('server');
     if (resolvedOptions.includeApi) include.push('api');
@@ -112,7 +116,9 @@ function createAppMfTypesTsConfig(app) {
     const exposedFiles = Object.entries(app.exposes ?? {}).sort(([left], [right])=>'./Route' === left ? -1 : './Route' === right ? 1 : 0).map(([, exposePath])=>exposePath.replace(/^\.\//u, ''));
     return {
         extends: `${relativeRootFor(app.directory)}/tsconfig.base.json`,
-        include: [
+        include: 'api-only' === app.surfaceProfile ? [
+            'rpc' === resolveApiProtocol(app) ? 'shared/rpc.ts' : 'shared/api.ts'
+        ] : [
             ...new Set([
                 ...exposedFiles,
                 'src/modern-app-env.d.ts'

package/dist/esm/ultramodern-workspace/validation/architecture.js

@@ -0,0 +1,348 @@
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { assert, sameJson, selfCheckFailure } from "./assertions.js";
+function assertCompilerArchitecture(root, workspaceValidationContract) {
+    const fullStackVerticals = workspaceValidationContract.apps.filter((app)=>'shell' !== app.kind);
+    const tailwindEnabled = workspaceValidationContract.tailwindEnabled;
+    const compactConfigPath = 'topology/reference-topology.json';
+    const readJson = (relativePath)=>JSON.parse(node_fs.readFileSync(node_path.join(root, relativePath), 'utf-8'));
+    const workspaceRequire = createRequire(node_path.join(root, 'package.json'));
+    let typescript;
+    let typescriptApi;
+    try {
+        typescript = workspaceRequire("@typescript/native/unstable/ast");
+        typescriptApi = workspaceRequire("@typescript/native/unstable/sync");
+    } catch (error) {
+        if ('MODULE_NOT_FOUND' !== error.code) throw error;
+    }
+    let compilerSnapshot;
+    let compiler;
+    try {
+        const sourceExtensions = new Set([
+            '.cjs',
+            '.cts',
+            '.js',
+            '.jsx',
+            '.mjs',
+            '.mts',
+            '.ts',
+            '.tsx'
+        ]);
+        const collectCompilerInputs = (relativeDirectory)=>{
+            const absoluteDirectory = node_path.join(root, relativeDirectory);
+            if (!node_fs.existsSync(absoluteDirectory)) return [];
+            const files = [];
+            const queue = [
+                absoluteDirectory
+            ];
+            while(queue.length > 0){
+                const current = queue.shift();
+                for (const entry of node_fs.readdirSync(current, {
+                    withFileTypes: true
+                })){
+                    const absoluteEntry = node_path.join(current, entry.name);
+                    if (entry.isDirectory()) queue.push(absoluteEntry);
+                    else if (sourceExtensions.has(node_path.extname(entry.name))) files.push(absoluteEntry);
+                }
+            }
+            return files.toSorted();
+        };
+        const initializeCompilerSnapshot = (absolutePaths)=>{
+            if (void 0 === typescript || void 0 === typescriptApi) return;
+            compiler = new typescriptApi.API({
+                cwd: root
+            });
+            compilerSnapshot = compiler.updateSnapshot({
+                openFiles: [
+                    ...absolutePaths
+                ]
+            });
+        };
+        const parseCompilerInput = (absolutePath)=>{
+            const project = compilerSnapshot?.getDefaultProjectForFile(absolutePath);
+            const sourceFile = project?.program.getSourceFile(absolutePath);
+            assert(void 0 !== sourceFile, `Native TypeScript compiler could not parse ${node_path.relative(root, absolutePath)}`);
+            return sourceFile;
+        };
+        const nodeName = (node)=>{
+            if (!node) return;
+            if (typescript.isIdentifier(node) || typescript.isPrivateIdentifier(node) || typescript.isStringLiteralLikeNode(node) || typescript.isNumericLiteral(node)) return node.text;
+        };
+        const propertyAccessPath = (node)=>{
+            if (typescript.isIdentifier(node)) return [
+                node.text
+            ];
+            if (typescript.isPropertyAccessExpression(node)) {
+                const left = propertyAccessPath(node.expression);
+                return void 0 === left ? void 0 : [
+                    ...left,
+                    node.name.text
+                ];
+            }
+            if (typescript.isElementAccessExpression(node) && typescript.isStringLiteralLikeNode(node.argumentExpression)) {
+                const left = propertyAccessPath(node.expression);
+                return void 0 === left ? void 0 : [
+                    ...left,
+                    node.argumentExpression.text
+                ];
+            }
+        };
+        function compilerFailure(sourceFile, node, contract, diagnostic, fixArea) {
+            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const relativePath = node_path.relative(root, sourceFile.fileName).split(node_path.sep).join('/');
+            throw new Error(selfCheckFailure(contract, `${diagnostic} Compiler evidence: ${relativePath}:${position.line + 1}:${position.character + 1}`, fixArea));
+        }
+        const runtimeModuleReferences = (sourceFile)=>{
+            const references = [];
+            const record = (node, specifier, kind, typeOnly = false)=>{
+                if (!typeOnly) references.push({
+                    kind,
+                    node,
+                    specifier
+                });
+            };
+            const visit = (node)=>{
+                if (typescript.isImportDeclaration(node) && typescript.isStringLiteralLikeNode(node.moduleSpecifier)) {
+                    const importClause = node.importClause;
+                    const namedBindings = importClause?.namedBindings;
+                    const namedBindingsAreTypeOnly = void 0 !== namedBindings && typescript.isNamedImports(namedBindings) && namedBindings.elements.length > 0 && namedBindings.elements.every((element)=>element.isTypeOnly);
+                    record(node, node.moduleSpecifier.text, void 0 === importClause ? 'side-effect-import' : 'static-import', importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword || importClause?.name === void 0 && namedBindingsAreTypeOnly);
+                } else if (typescript.isExportDeclaration(node) && void 0 !== node.moduleSpecifier && typescript.isStringLiteralLikeNode(node.moduleSpecifier)) record(node, node.moduleSpecifier.text, 'static-import', node.isTypeOnly);
+                else if (typescript.isCallExpression(node) && node.arguments.length > 0 && typescript.isStringLiteralLikeNode(node.arguments[0])) {
+                    if (node.expression.kind === typescript.SyntaxKind.ImportKeyword) record(node, node.arguments[0].text, 'dynamic-import');
+                    else if (typescript.isIdentifier(node.expression) && 'require' === node.expression.text) record(node, node.arguments[0].text, 'require');
+                }
+                node.forEachChild(visit);
+            };
+            visit(sourceFile);
+            return references;
+        };
+        const importDiagnosticId = (prefix, kind)=>{
+            switch(kind){
+                case 'side-effect-import':
+                    return `${prefix}-side-effect-import`;
+                case 'dynamic-import':
+                    return `${prefix}-dynamic-import`;
+                case 'require':
+                    return `${prefix}-require`;
+                default:
+                    return 'vertical-directory' === prefix ? 'vertical-directory-deep-import' : 'workspace-package-source-import';
+            }
+        };
+        const isWorkspaceSourceSpecifier = (specifier)=>{
+            const segments = specifier.split('/');
+            return segments.length > 3 && segments[0].startsWith('@') && 'src' === segments[2];
+        };
+        const resolvesInsideVerticalDirectory = (sourceFile, specifier)=>{
+            if (!specifier.startsWith('.')) return false;
+            const specifierSegments = specifier.replaceAll('\\', '/').split('/');
+            if (specifierSegments.some((segment, index)=>'verticals' === segment && void 0 !== specifierSegments[index + 1])) return true;
+            const absoluteTarget = node_path.resolve(node_path.dirname(sourceFile.fileName), specifier);
+            const verticalRoot = node_path.join(root, 'verticals') + node_path.sep;
+            if (!absoluteTarget.startsWith(verticalRoot)) return false;
+            const relativeSegments = node_path.relative(verticalRoot, absoluteTarget).split(node_path.sep);
+            return relativeSegments.length > 1;
+        };
+        const jsxTagName = (tagName)=>typescript.isIdentifier(tagName) ? tagName.text : void 0;
+        const jsxAttribute = (attributes, name)=>attributes.properties.find((property)=>typescript.isJsxAttribute(property) && nodeName(property.name) === name);
+        const isBooleanLiteral = (node, value)=>node?.kind === (value ? typescript.SyntaxKind.TrueKeyword : typescript.SyntaxKind.FalseKeyword);
+        const isCallNamed = (node, names)=>{
+            if (void 0 === node || !typescript.isCallExpression(node)) return false;
+            const accessPath = propertyAccessPath(node.expression);
+            return void 0 !== accessPath && names.has(accessPath.at(-1));
+        };
+        const objectLiteralProperty = (objectLiteral, name)=>objectLiteral.properties.find((property)=>typescript.isPropertyAssignment(property) && nodeName(property.name) === name);
+        const moduleFederationConfigArgument = (sourceFile)=>{
+            let argument;
+            const visit = (node)=>{
+                if (void 0 !== argument) return;
+                if (typescript.isCallExpression(node) && typescript.isIdentifier(node.expression) && 'createModuleFederationConfig' === node.expression.text && 1 === node.arguments.length && typescript.isObjectLiteralExpression(node.arguments[0])) {
+                    argument = node.arguments[0];
+                    return;
+                }
+                node.forEachChild(visit);
+            };
+            visit(sourceFile);
+            return argument;
+        };
+        const appDeclaresReactRouter = (appPath)=>{
+            const relativePath = `${appPath}/package.json`;
+            if (!node_fs.existsSync(node_path.join(root, relativePath))) return false;
+            const packageJson = readJson(relativePath);
+            return [
+                'react-router',
+                'react-router-dom'
+            ].some((dependency)=>[
+                    'dependencies',
+                    'devDependencies'
+                ].some((field)=>Object.hasOwn(packageJson[field] ?? {}, dependency)));
+        };
+        const bridgeRouterFixArea = 'declare bridge.enableBridgeRouter: false, or true only in an app that declares react-router or react-router-dom';
+        const assertBridgeRouterCapability = (sourceFile, appPath)=>{
+            const contract = 'module federation bridge capability';
+            const configArgument = moduleFederationConfigArgument(sourceFile);
+            if (void 0 === configArgument) compilerFailure(sourceFile, sourceFile, contract, 'Generated Module Federation must pass a literal config object to createModuleFederationConfig.', bridgeRouterFixArea);
+            const bridge = objectLiteralProperty(configArgument, 'bridge');
+            const declaration = void 0 !== bridge && typescript.isObjectLiteralExpression(bridge.initializer) ? objectLiteralProperty(bridge.initializer, 'enableBridgeRouter') : void 0;
+            if (void 0 === declaration) compilerFailure(sourceFile, bridge ?? configArgument, contract, 'Generated Module Federation must declare bridge.enableBridgeRouter in its config object.', bridgeRouterFixArea);
+            if (isBooleanLiteral(declaration.initializer, false)) return;
+            if (!isBooleanLiteral(declaration.initializer, true)) compilerFailure(sourceFile, declaration, contract, 'Generated Module Federation must declare bridge.enableBridgeRouter as a boolean literal.', bridgeRouterFixArea);
+            if (!appDeclaresReactRouter(appPath)) compilerFailure(sourceFile, declaration, contract, `Generated Module Federation enables the React bridge router while ${appPath}/package.json declares neither react-router nor react-router-dom.`, bridgeRouterFixArea);
+        };
+        const checkArchitecture = ()=>{
+            const structuralPolicy = workspaceValidationContract.structuralShellPolicy;
+            assert(structuralPolicy?.schemaVersion === 1, 'Structural thin-shell compiler policy must use schemaVersion 1');
+            const compositionPolicy = workspaceValidationContract.federatedCompositionPolicy;
+            assert(compositionPolicy?.schemaVersion === 1, 'Federated composition compiler policy must use schemaVersion 1');
+            const compilerInputs = new Set([
+                ...(structuralPolicy.shells ?? []).flatMap((shell)=>collectCompilerInputs(shell.srcDir)),
+                ...(compositionPolicy.hosts ?? []).flatMap((host)=>collectCompilerInputs(host.srcDir)),
+                ...workspaceValidationContract.apps.flatMap((app)=>collectCompilerInputs(app.path))
+            ]);
+            initializeCompilerSnapshot(compilerInputs);
+            for (const shell of structuralPolicy.shells ?? []){
+                for (const forbidden of structuralPolicy.forbiddenPathClasses ?? [])if ('shell-super-app' !== shell.id || 'backend-federation.config.ts' === forbidden.path) assert(!node_fs.existsSync(node_path.join(root, shell.packageDir, forbidden.path)), selfCheckFailure(`structural thin-shell ${forbidden.id}`, `${forbidden.diagnostic} Forbidden artifact ${shell.packageDir}/${forbidden.path} exists`, `remove forbidden thin-shell artifact ${shell.packageDir}/${forbidden.path}`));
+                if (void 0 !== compilerSnapshot) for (const absolutePath of collectCompilerInputs(shell.srcDir)){
+                    const sourceFile = parseCompilerInput(absolutePath);
+                    for (const reference of runtimeModuleReferences(sourceFile)){
+                        if (resolvesInsideVerticalDirectory(sourceFile, reference.specifier)) {
+                            const id = importDiagnosticId('vertical-directory', reference.kind);
+                            compilerFailure(sourceFile, reference.node, `structural thin-shell ${id}`, 'A thin Shell must consume only published vertical surfaces, never a vertical implementation directory.', 'consume only published surfaces from the thin shell');
+                        }
+                        if (isWorkspaceSourceSpecifier(reference.specifier)) {
+                            const id = importDiagnosticId('workspace-package', reference.kind);
+                            compilerFailure(sourceFile, reference.node, `structural thin-shell ${id}`, 'A thin Shell must consume only package exports, never another package raw src directory.', 'consume only published surfaces from the thin shell');
+                        }
+                    }
+                }
+            }
+            if (void 0 === compilerSnapshot) {
+                const packageJson = readJson('package.json');
+                assert('string' == typeof packageJson.devDependencies?.["@typescript/native"], 'Generated workspaces must declare the native TypeScript compiler used by architecture evidence');
+                assert(packageJson.scripts?.check?.split('&&').some((stage)=>'pnpm typecheck' === stage.trim()), 'Generated workspace check must execute compiler evidence before contract validation');
+                return;
+            }
+            for (const host of compositionPolicy.hosts ?? [])for (const absolutePath of collectCompilerInputs(host.srcDir)){
+                const sourceFile = parseCompilerInput(absolutePath);
+                if (sourceFile.isDeclarationFile) continue;
+                const remoteImplementation = (specifier)=>(host.remotes ?? []).find((remote)=>{
+                        if (specifier === remote.packageName) return true;
+                        if (specifier.startsWith(`${remote.packageName}/`)) {
+                            const subpath = specifier.slice(remote.packageName.length + 1);
+                            return 'api' !== subpath && !subpath.startsWith('api/');
+                        }
+                        if (!specifier.startsWith('.')) return false;
+                        const absoluteTarget = node_path.resolve(node_path.dirname(sourceFile.fileName), specifier);
+                        const remoteDirectory = node_path.join(root, remote.directory);
+                        return absoluteTarget === remoteDirectory || absoluteTarget.startsWith(remoteDirectory + node_path.sep);
+                    });
+                for (const reference of runtimeModuleReferences(sourceFile)){
+                    const remote = remoteImplementation(reference.specifier);
+                    if (void 0 !== remote) compilerFailure(sourceFile, reference.node, 'federated composition remote-runtime-package-import', `Host ${host.id} imports the ${remote.id} render implementation through ${reference.specifier}.`, 'use import type for contracts or compose the implementation through Module Federation');
+                }
+                const hydrationStateSetters = new Set();
+                const visit = (node)=>{
+                    if (typescript.isVariableDeclaration(node) && typescript.isArrayBindingPattern(node.name) && node.name.elements.length >= 2 && isCallNamed(node.initializer, new Set([
+                        'useState'
+                    ])) && isBooleanLiteral(node.initializer.arguments[0], false)) {
+                        const stateName = nodeName(node.name.elements[0].name)?.toLowerCase();
+                        const setterName = nodeName(node.name.elements[1].name);
+                        if (('hydrated' === stateName || 'ishydrated' === stateName) && void 0 !== setterName) hydrationStateSetters.add(setterName);
+                    }
+                    if ((typescript.isVariableDeclaration(node) || typescript.isFunctionDeclaration(node)) && 'createHydratedRemote' === nodeName(node.name)) compilerFailure(sourceFile, node, 'federated composition hydrated-remote-factory', 'Federated hosts must use the distributed SSR boundary directly; hydration-time remote factories are forbidden.', 'compose remote rendering through framework Module Federation primitives');
+                    if ((typescript.isPropertyAssignment(node) || typescript.isJsxAttribute(node)) && ('loading' === nodeName(node.name) || 'fallback' === nodeName(node.name))) {
+                        const value = typescript.isPropertyAssignment(node) ? node.initializer : void 0 !== node.initializer && typescript.isJsxExpression(node.initializer) ? node.initializer.expression : void 0;
+                        if (void 0 !== value && (typescript.isJsxElement(value) || typescript.isJsxSelfClosingElement(value))) {
+                            const tagName = typescript.isJsxElement(value) ? jsxTagName(value.openingElement.tagName) : jsxTagName(value.tagName);
+                            if ('ServerComponent' === tagName || 'LocalComponent' === tagName) compilerFailure(sourceFile, node, 'federated composition local-loading-copy', 'Federated hosts must not render a local component copy while loading a remote implementation.', 'use an explicit unavailable-state component instead of a local implementation copy');
+                        }
+                    }
+                    node.forEachChild(visit);
+                };
+                visit(sourceFile);
+                if (hydrationStateSetters.size > 0) {
+                    const findHydrationSetter = (node)=>{
+                        if (typescript.isCallExpression(node) && typescript.isIdentifier(node.expression) && hydrationStateSetters.has(node.expression.text) && isBooleanLiteral(node.arguments[0], true)) compilerFailure(sourceFile, node, 'federated composition hydration-flag', 'Federated hosts must hydrate the server DOM directly; hydrated-state component switching is forbidden.', 'compose remote rendering through framework Module Federation primitives');
+                        node.forEachChild(findHydrationSetter);
+                    };
+                    findHydrationSetter(sourceFile);
+                }
+            }
+            const shellRouteDirectories = (structuralPolicy.shells ?? []).map((shell)=>`${shell.packageDir}/src/routes`);
+            const appPaths = workspaceValidationContract.apps.map((app)=>app.path);
+            const configFiles = appPaths.flatMap((appPath)=>[
+                    `${appPath}/modern.config.ts`,
+                    `${appPath}/module-federation.config.ts`
+                ]);
+            const moduleFederationConfigAppPaths = new Map(appPaths.map((appPath)=>[
+                    node_path.join(root, `${appPath}/module-federation.config.ts`),
+                    appPath
+                ]).filter((entry)=>node_fs.existsSync(entry[0])));
+            const checkedFiles = new Set([
+                ...shellRouteDirectories.flatMap(collectCompilerInputs),
+                ...configFiles.map((relativePath)=>node_path.join(root, relativePath)).filter((absolutePath)=>node_fs.existsSync(absolutePath))
+            ]);
+            for (const absolutePath of checkedFiles){
+                const sourceFile = parseCompilerInput(absolutePath);
+                const isShellRoute = shellRouteDirectories.some((relativeDirectory)=>{
+                    const absoluteDirectory = node_path.join(root, relativeDirectory);
+                    return absolutePath.startsWith(absoluteDirectory + node_path.sep);
+                });
+                const moduleFederationAppPath = moduleFederationConfigAppPaths.get(absolutePath);
+                const tailwindFactories = new Set();
+                const presetFactories = new Set();
+                for (const statement of sourceFile.statements){
+                    if (!typescript.isImportDeclaration(statement) || !typescript.isStringLiteralLikeNode(statement.moduleSpecifier) || statement.importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword) continue;
+                    const bindings = statement.importClause?.namedBindings;
+                    if (void 0 !== bindings && typescript.isNamedImports(bindings)) for (const binding of bindings.elements){
+                        if (binding.isTypeOnly) continue;
+                        const imported = (binding.propertyName ?? binding.name).text;
+                        if ('@rsbuild/plugin-tailwindcss' === statement.moduleSpecifier.text && 'pluginTailwindcss' === imported) tailwindFactories.add(binding.name.text);
+                        if ('@modern-js/ultramodern-app-tools' === statement.moduleSpecifier.text && 'presetUltramodern' === imported) presetFactories.add(binding.name.text);
+                    }
+                }
+                const modernConfigApp = workspaceValidationContract.apps.find((app)=>absolutePath === node_path.join(root, app.path, 'modern.config.ts'));
+                let insideDefaultExport = false;
+                const visit = (node)=>{
+                    const previousDefaultExport = insideDefaultExport;
+                    if (typescript.isExportAssignment(node) && !node.isExportEquals) insideDefaultExport = true;
+                    if (insideDefaultExport && void 0 !== modernConfigApp && isCallNamed(node, presetFactories) && void 0 !== node.arguments[0] && typescript.isObjectLiteralExpression(node.arguments[0])) {
+                        const builderPlugins = objectLiteralProperty(node.arguments[0], 'builderPlugins');
+                        const usesTailwind = void 0 !== builderPlugins && typescript.isArrayLiteralExpression(builderPlugins.initializer) && builderPlugins.initializer.elements.some((plugin)=>isCallNamed(plugin, tailwindFactories));
+                        const emitsUi = 'shell' === modernConfigApp.kind || fullStackVerticals.some((vertical)=>vertical.id === modernConfigApp.id && vertical.emitsUi);
+                        if (usesTailwind !== (tailwindEnabled && emitsUi)) compilerFailure(sourceFile, builderPlugins ?? node, `${compactConfigPath} policy.features.tailwind`, `Tailwind feature flag is ${tailwindEnabled}, but ${modernConfigApp.id} exported config ${usesTailwind ? 'enables' : 'does not enable'} the Tailwind builder plugin.`, 'keep the Tailwind feature flag and active app builder configuration consistent');
+                    }
+                    if (typescript.isImportDeclaration(node) && typescript.isStringLiteralLikeNode(node.moduleSpecifier) && 'node:child_process' === node.moduleSpecifier.text) compilerFailure(sourceFile, node, 'framework config API node-child-process-access', 'Generated config must not invoke node:child_process directly.', 'use the framework config environment API');
+                    const accessPath = propertyAccessPath(node);
+                    if (sameJson(accessPath, [
+                        'process',
+                        'env'
+                    ])) compilerFailure(sourceFile, node, 'framework config API direct-process-env-access', 'Generated config must use the framework config environment API instead of process.env.', 'use getBuildConfigEnvironment');
+                    if (typescript.isIdentifier(node) && 'ULTRAMODERN_ZEPHYR' === node.text) compilerFailure(sourceFile, node, 'zephyr gating ultramodern-zephyr-environment-gate', 'Generated Zephyr integration must not be gated through ULTRAMODERN_ZEPHYR.', 'use Zephyr native deploy-token behavior');
+                    if (typescript.isPropertyAssignment(node)) {
+                        const property = nodeName(node.name);
+                        if ('enableBridgeRouter' === property && void 0 === moduleFederationAppPath || 'disableDynamicRemoteTypeHints' === property && isBooleanLiteral(node.initializer, true) || 'treeShakingSharedExcludePlugins' === property) compilerFailure(sourceFile, node, 'module federation bridge capability', `Generated Module Federation carries forbidden option ${property}.`, 'use framework-owned Module Federation defaults');
+                    }
+                    if (isShellRoute) {
+                        if (typescript.isJsxOpeningElement(node) && 'a' === jsxTagName(node.tagName) && void 0 !== jsxAttribute(node.attributes, 'onClick')) compilerFailure(sourceFile, node, 'shell routing synthetic-anchor-click-interception', 'Shell routing must not intercept anchor clicks synthetically.', 'use the router Link primitive');
+                        if (isCallNamed(node, new Set([
+                            'hydrateRoot',
+                            'loadRemote',
+                            'loadShare'
+                        ]))) compilerFailure(sourceFile, node, 'module federation native loading', 'Shell routing must use framework Module Federation loading primitives.', 'remove manual hydration or remote-loading wrappers');
+                        if (typescript.isBinaryExpression(node) && node.operatorToken.kind === typescript.SyntaxKind.EqualsToken && propertyAccessPath(node.left)?.slice(0, 2).join('.') === 'window.location' || typescript.isCallExpression(node) && propertyAccessPath(node.expression)?.slice(0, 2).join('.') === 'window.location') compilerFailure(sourceFile, node, 'shell routing window-location-navigation', 'Shell routing must use router navigation instead of window.location.', 'use the router navigation primitive');
+                    }
+                    node.forEachChild(visit);
+                    insideDefaultExport = previousDefaultExport;
+                };
+                visit(sourceFile);
+                if (void 0 !== moduleFederationAppPath) assertBridgeRouterCapability(sourceFile, moduleFederationAppPath);
+            }
+        };
+        checkArchitecture();
+    } finally{
+        compiler?.close();
+    }
+}
+export { assertCompilerArchitecture };