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

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

@@ -0,0 +1,397 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    assertCompilerArchitecture: ()=>assertCompilerArchitecture
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_assertions_cjs_namespaceObject = require("./assertions.cjs");
+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(external_node_fs_default().readFileSync(external_node_path_default().join(root, relativePath), 'utf-8'));
+    const workspaceRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().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 = external_node_path_default().join(root, relativeDirectory);
+            if (!external_node_fs_default().existsSync(absoluteDirectory)) return [];
+            const files = [];
+            const queue = [
+                absoluteDirectory
+            ];
+            while(queue.length > 0){
+                const current = queue.shift();
+                for (const entry of external_node_fs_default().readdirSync(current, {
+                    withFileTypes: true
+                })){
+                    const absoluteEntry = external_node_path_default().join(current, entry.name);
+                    if (entry.isDirectory()) queue.push(absoluteEntry);
+                    else if (sourceExtensions.has(external_node_path_default().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);
+            (0, external_assertions_cjs_namespaceObject.assert)(void 0 !== sourceFile, `Native TypeScript compiler could not parse ${external_node_path_default().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 = external_node_path_default().relative(root, sourceFile.fileName).split(external_node_path_default().sep).join('/');
+            throw new Error((0, external_assertions_cjs_namespaceObject.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 = external_node_path_default().resolve(external_node_path_default().dirname(sourceFile.fileName), specifier);
+            const verticalRoot = external_node_path_default().join(root, 'verticals') + external_node_path_default().sep;
+            if (!absoluteTarget.startsWith(verticalRoot)) return false;
+            const relativeSegments = external_node_path_default().relative(verticalRoot, absoluteTarget).split(external_node_path_default().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 (!external_node_fs_default().existsSync(external_node_path_default().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;
+            (0, external_assertions_cjs_namespaceObject.assert)(structuralPolicy?.schemaVersion === 1, 'Structural thin-shell compiler policy must use schemaVersion 1');
+            const compositionPolicy = workspaceValidationContract.federatedCompositionPolicy;
+            (0, external_assertions_cjs_namespaceObject.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) (0, external_assertions_cjs_namespaceObject.assert)(!external_node_fs_default().existsSync(external_node_path_default().join(root, shell.packageDir, forbidden.path)), (0, external_assertions_cjs_namespaceObject.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');
+                (0, external_assertions_cjs_namespaceObject.assert)('string' == typeof packageJson.devDependencies?.["@typescript/native"], 'Generated workspaces must declare the native TypeScript compiler used by architecture evidence');
+                (0, external_assertions_cjs_namespaceObject.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 = external_node_path_default().resolve(external_node_path_default().dirname(sourceFile.fileName), specifier);
+                        const remoteDirectory = external_node_path_default().join(root, remote.directory);
+                        return absoluteTarget === remoteDirectory || absoluteTarget.startsWith(remoteDirectory + external_node_path_default().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)=>[
+                    external_node_path_default().join(root, `${appPath}/module-federation.config.ts`),
+                    appPath
+                ]).filter((entry)=>external_node_fs_default().existsSync(entry[0])));
+            const checkedFiles = new Set([
+                ...shellRouteDirectories.flatMap(collectCompilerInputs),
+                ...configFiles.map((relativePath)=>external_node_path_default().join(root, relativePath)).filter((absolutePath)=>external_node_fs_default().existsSync(absolutePath))
+            ]);
+            for (const absolutePath of checkedFiles){
+                const sourceFile = parseCompilerInput(absolutePath);
+                const isShellRoute = shellRouteDirectories.some((relativeDirectory)=>{
+                    const absoluteDirectory = external_node_path_default().join(root, relativeDirectory);
+                    return absolutePath.startsWith(absoluteDirectory + external_node_path_default().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 === external_node_path_default().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 ((0, external_assertions_cjs_namespaceObject.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();
+    }
+}
+exports.assertCompilerArchitecture = __webpack_exports__.assertCompilerArchitecture;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertCompilerArchitecture"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,140 @@
+"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__);
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+const canonicalizeJson = (value)=>{
+    if (Array.isArray(value)) {
+        const entries = value.map(canonicalizeJson);
+        const keyedEntries = entries.every((entry)=>null !== entry && 'object' == typeof entry && !Array.isArray(entry) && 'id' in entry && 'string' == typeof entry.id);
+        if (keyedEntries) {
+            const ids = entries.map((entry)=>entry.id);
+            if (new Set(ids).size === ids.length) return entries.toSorted((left, right)=>left.id.localeCompare(right.id));
+        }
+        return entries;
+    }
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.keys(value).toSorted().map((key)=>[
+            key,
+            canonicalizeJson(value[key])
+        ]));
+    return value;
+};
+const sameJson = (actual, expected)=>JSON.stringify(canonicalizeJson(actual)) === JSON.stringify(canonicalizeJson(expected));
+const formatJson = (value)=>void 0 === value ? 'undefined' : JSON.stringify(canonicalizeJson(value));
+const selfCheckFailure = (contract, message, fixArea)=>`MicroVertical contract self-check failed: ${contract}. ${message}. Fix area: ${fixArea}.`;
+function assertSelfCheck(condition, contract, message, fixArea) {
+    assert(condition, selfCheckFailure(contract, message, fixArea));
+}
+const assertSameJson = (actual, expected, contract, fixArea)=>{
+    assertSelfCheck(sameJson(actual, expected), contract, `Expected ${formatJson(expected)}, found ${formatJson(actual)}`, fixArea);
+};
+const assertIncludesJson = (actual, required, contract, fixArea)=>{
+    assertArray(actual, contract, fixArea);
+    for (const entry of required)assertSelfCheck(actual.some((value)=>sameJson(value, entry)), contract, `Missing required entry ${formatJson(entry)}`, fixArea);
+};
+function assertObject(value, contract, fixArea) {
+    assertSelfCheck(null !== value && 'object' == typeof value && !Array.isArray(value), contract, `Expected JSON object, found ${formatJson(value)}`, fixArea);
+}
+function assertArray(value, contract, fixArea) {
+    assertSelfCheck(Array.isArray(value), contract, `Expected JSON array, found ${formatJson(value)}`, fixArea);
+}
+const assertUniqueStrings = (values, contract)=>{
+    assert(Array.isArray(values), `${contract} must be an array`);
+    const seen = new Set();
+    for (const value of values){
+        assert('string' == typeof value && value.length > 0, `${contract} must contain non-empty strings`);
+        assert(!seen.has(value), `Duplicate value "${value}" in ${contract}`);
+        seen.add(value);
+    }
+};
+const assertUniqueIdEntries = (entries, contract)=>{
+    assert(Array.isArray(entries), `${contract} must be an array`);
+    const seen = new Set();
+    for (const entry of entries){
+        const id = entry?.id;
+        assert('string' == typeof id && id.length > 0, `${contract} entries must have non-empty string ids`);
+        assert(!seen.has(id), `Duplicate id "${id}" in ${contract}`);
+        seen.add(id);
+    }
+};
+const assertSameIdCohort = (entries, expectedIds, contract, fixArea)=>{
+    assert(entries && expectedIds, `${contract} must be an array`);
+    assertUniqueIdEntries(entries, contract);
+    assertSameJson(entries.map((entry)=>entry.id).toSorted(), [
+        ...expectedIds
+    ].toSorted(), `${contract} cohort`, fixArea);
+};
+__webpack_require__.d(__webpack_exports__, {
+    assert: ()=>assert,
+    assertArray: ()=>assertArray,
+    assertObject: ()=>assertObject,
+    assertSelfCheck: ()=>assertSelfCheck
+}, {
+    assertIncludesJson: assertIncludesJson,
+    assertSameIdCohort: assertSameIdCohort,
+    assertSameJson: assertSameJson,
+    assertUniqueIdEntries: assertUniqueIdEntries,
+    assertUniqueStrings: assertUniqueStrings,
+    canonicalizeJson: canonicalizeJson,
+    formatJson: formatJson,
+    sameJson: sameJson,
+    selfCheckFailure: selfCheckFailure
+});
+exports.assert = __webpack_exports__.assert;
+exports.assertArray = __webpack_exports__.assertArray;
+exports.assertIncludesJson = __webpack_exports__.assertIncludesJson;
+exports.assertObject = __webpack_exports__.assertObject;
+exports.assertSameIdCohort = __webpack_exports__.assertSameIdCohort;
+exports.assertSameJson = __webpack_exports__.assertSameJson;
+exports.assertSelfCheck = __webpack_exports__.assertSelfCheck;
+exports.assertUniqueIdEntries = __webpack_exports__.assertUniqueIdEntries;
+exports.assertUniqueStrings = __webpack_exports__.assertUniqueStrings;
+exports.canonicalizeJson = __webpack_exports__.canonicalizeJson;
+exports.formatJson = __webpack_exports__.formatJson;
+exports.sameJson = __webpack_exports__.sameJson;
+exports.selfCheckFailure = __webpack_exports__.selfCheckFailure;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assert",
+    "assertArray",
+    "assertIncludesJson",
+    "assertObject",
+    "assertSameIdCohort",
+    "assertSameJson",
+    "assertSelfCheck",
+    "assertUniqueIdEntries",
+    "assertUniqueStrings",
+    "canonicalizeJson",
+    "formatJson",
+    "sameJson",
+    "selfCheckFailure"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});