@bleedingdev/modern-js-create 3.4.0-ultramodern.0 → 3.4.0-ultramodern.10

package/templates/workspace-scripts/ultramodern-typecheck.mjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+} from 'node:fs';
+import os from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const args = process.argv.slice(2);
+const workspaceRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+const cpuCount = Math.max(
+  1,
+  typeof os.availableParallelism === 'function'
+    ? os.availableParallelism()
+    : os.cpus().length,
+);
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function parsePositiveInt(value, label) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    fail(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+function envPositiveInt(name, fallback) {
+  const value = process.env[name]?.trim();
+  return value ? parsePositiveInt(value, name) : fallback;
+}
+
+function readArgs() {
+  let buildTarget;
+  let projectTarget;
+  let checkers;
+  let builders;
+  const passthrough = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const next = args[index + 1];
+
+    if (arg === '--') {
+      passthrough.push(...args.slice(index + 1));
+      break;
+    }
+
+    if (arg === '--build' || arg === '-b') {
+      buildTarget = next && !next.startsWith('-') ? next : 'tsconfig.json';
+      if (buildTarget === next) {
+        index += 1;
+      }
+      continue;
+    }
+
+    if (arg === '--project' || arg === '-p') {
+      if (!next || next.startsWith('-')) {
+        fail(`${arg} requires a tsconfig path.`);
+      }
+      projectTarget = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--checkers') {
+      if (!next || next.startsWith('-')) {
+        fail('--checkers requires a positive integer.');
+      }
+      checkers = parsePositiveInt(next, '--checkers');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--builders') {
+      if (!next || next.startsWith('-')) {
+        fail('--builders requires a positive integer.');
+      }
+      builders = parsePositiveInt(next, '--builders');
+      index += 1;
+      continue;
+    }
+
+    passthrough.push(arg);
+  }
+
+  if (buildTarget && projectTarget) {
+    fail('Choose either --build or --project, not both.');
+  }
+
+  return {
+    mode: buildTarget ? 'build' : 'project',
+    target: buildTarget ?? projectTarget ?? 'tsconfig.json',
+    checkers,
+    builders,
+    passthrough,
+  };
+}
+
+function resolveTsgoBinary() {
+  const explicitBinary = process.env.EFFECT_TSGO_BIN || process.env.TSGO_BIN;
+  if (explicitBinary) {
+    return explicitBinary;
+  }
+
+  const cli = process.env.EFFECT_TSGO_CLI || 'effect-tsgo';
+  const result = spawnSync(cli, ['get-exe-path'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (result.error) {
+    fail(
+      `Unable to run ${cli}. Run pnpm install or set EFFECT_TSGO_BIN to the native-preview tsgo binary.`,
+    );
+  }
+  if (result.status !== 0) {
+    fail(
+      result.stderr?.trim() ||
+        `${cli} get-exe-path exited with status ${result.status}.`,
+    );
+  }
+
+  return result.stdout.trim() || cli;
+}
+
+const parsed = readArgs();
+const defaultBuilders = Math.min(8, Math.max(1, Math.floor(cpuCount / 2)));
+const builders =
+  parsed.builders ??
+  envPositiveInt('ULTRAMODERN_TSGO_BUILDERS', defaultBuilders);
+const defaultCheckers =
+  parsed.mode === 'build'
+    ? Math.min(4, Math.max(1, Math.floor(cpuCount / builders)))
+    : Math.min(8, Math.max(2, cpuCount - 1));
+const checkers =
+  parsed.checkers ??
+  envPositiveInt('ULTRAMODERN_TSGO_CHECKERS', defaultCheckers);
+const tsgoBin = resolveTsgoBinary();
+
+if (!existsSync(tsgoBin)) {
+  fail(`TS-Go binary not found at ${tsgoBin}. Run pnpm install.`);
+}
+
+try {
+  accessSync(tsgoBin, constants.X_OK);
+} catch {
+  chmodSync(tsgoBin, 0o755);
+}
+
+mkdirSync(join(workspaceRoot, 'node_modules/.cache/tsgo'), {
+  recursive: true,
+});
+
+const tsgoArgs =
+  parsed.mode === 'build'
+    ? [
+        '--build',
+        parsed.target,
+        '--pretty',
+        'false',
+        '--checkers',
+        String(checkers),
+        '--builders',
+        String(builders),
+        '--stopBuildOnErrors',
+        ...parsed.passthrough,
+      ]
+    : [
+        '--project',
+        parsed.target,
+        '--noEmit',
+        '--pretty',
+        'false',
+        '--checkers',
+        String(checkers),
+        ...parsed.passthrough,
+      ];
+
+const result = spawnSync(tsgoBin, tsgoArgs, {
+  stdio: 'inherit',
+});
+
+if (result.error) {
+  throw result.error;
+}
+
+process.exit(result.status ?? 1);

package/templates/workspace-scripts/validate-ultramodern-workspace.mjs.handlebars

@@ -91,6 +91,8 @@ const expectedRemoteSubsetsForRefs = refs =>
     .map(expectedRemoteContractSubset);
 const requiredMicroVerticalPaths = vertical => [
   `${vertical.path}/package.json`,
+  `${vertical.path}/tsconfig.json`,
+  `${vertical.path}/tsconfig.mf-types.json`,
   `${vertical.path}/modern.config.ts`,
   `${vertical.path}/module-federation.config.ts`,
   `${vertical.path}/api/effect/index.ts`,
@@ -222,6 +224,15 @@ const assertMicroVerticalContractGraph = ({
     '.modernjs/ultramodern-generated-contract.json shell moduleFederation.remotes',
     'regenerate the generated shell Module Federation contract',
   );
+  assertSameJson(
+    shellContract.ssr,
+    {
+      mode: 'string',
+      moduleFederationAppSSR: true,
+    },
+    '.modernjs/ultramodern-generated-contract.json shell SSR contract',
+    'restore generated string SSR Module Federation settings',
+  );
 
   for (const vertical of fullStackVerticals) {
     const expectedRefs = vertical.verticalRefs ?? [];
@@ -353,6 +364,7 @@ const assertMicroVerticalContractGraph = ({
           contract: contractEntry.effect?.contract,
           client: contractEntry.effect?.client,
         },
+        ssr: contractEntry.ssr,
       },
       {
         kind: 'vertical',
@@ -369,12 +381,136 @@ const assertMicroVerticalContractGraph = ({
           contract: './shared/effect/api',
           client: './effect/client',
         },
+        ssr: {
+          mode: 'string',
+          moduleFederationAppSSR: true,
+        },
       },
       `.modernjs/ultramodern-generated-contract.json apps.${vertical.id}`,
       'regenerate the generated MicroVertical contract entry',
     );
   }
 };
+const toPosixPath = value => value.split(path.sep).join('/');
+const referenceFrom = (fromPath, toPath) => ({
+  path: toPosixPath(path.relative(fromPath, toPath)),
+});
+const sharedPackagePaths = [
+  'packages/shared-contracts',
+  'packages/shared-design-tokens',
+];
+const tsgoCacheKey = packagePath => packagePath.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+const assertProjectReferenceEmitConfig = (tsConfig, packagePath) => {
+  const compilerOptions = tsConfig.compilerOptions ?? {};
+  const relativeRoot = toPosixPath(path.relative(packagePath, '.')) || '.';
+  assert(compilerOptions.composite === true, `${packagePath} must stay a composite TS-Go project`);
+  assert(compilerOptions.declaration === true, `${packagePath} must emit declarations for TS-Go build mode`);
+  assert(compilerOptions.declarationMap === false, `${packagePath} must not emit declaration maps during checks`);
+  assert(compilerOptions.emitDeclarationOnly === true, `${packagePath} must only emit declarations during checks`);
+  assert(compilerOptions.noEmit === false, `${packagePath} must override root noEmit for TS-Go build mode`);
+  assert(
+    compilerOptions.outDir === `${relativeRoot}/node_modules/.cache/tsgo/declarations/${tsgoCacheKey(packagePath)}`,
+    `${packagePath} must emit TS-Go declarations into the generated cache`,
+  );
+  assert(
+    compilerOptions.tsBuildInfoFile === `${relativeRoot}/node_modules/.cache/tsgo/${tsgoCacheKey(packagePath)}.tsbuildinfo`,
+    `${packagePath} must keep TS-Go build info in the generated cache`,
+  );
+};
+const assertTsConfigReferenceGraph = () => {
+  const rootTsConfig = readJson('tsconfig.json');
+  const shellTsConfig = readJson('apps/shell-super-app/tsconfig.json');
+  const shellMfTypesTsConfig = readJson(
+    'apps/shell-super-app/tsconfig.mf-types.json',
+  );
+  const expectedRootReferences = [
+    ...sharedPackagePaths,
+    'apps/shell-super-app',
+    ...fullStackVerticals.map(vertical => vertical.path),
+  ].map(referencePath => ({ path: referencePath }));
+  const expectedShellReferences = [
+    ...sharedPackagePaths,
+    ...fullStackVerticals.map(vertical => vertical.path),
+  ].map(referencePath =>
+    referenceFrom('apps/shell-super-app', referencePath),
+  );
+
+  assertSameJson(
+    rootTsConfig.files,
+    [],
+    'tsconfig.json files',
+    'restore the generated root project-reference tsconfig',
+  );
+  assertSameJson(
+    rootTsConfig.references ?? [],
+    expectedRootReferences,
+    'tsconfig.json references',
+    'restore the generated root project-reference graph',
+  );
+  assertSameJson(
+    shellTsConfig.references ?? [],
+    expectedShellReferences,
+    'apps/shell-super-app/tsconfig.json references',
+    'restore the generated shell project-reference graph',
+  );
+  assertProjectReferenceEmitConfig(
+    shellTsConfig,
+    'apps/shell-super-app',
+  );
+  assertSameJson(
+    shellMfTypesTsConfig,
+    {
+      extends: './tsconfig.json',
+      include: ['src/modern-app-env.d.ts'],
+    },
+    'apps/shell-super-app/tsconfig.mf-types.json',
+    'restore the generated shell Module Federation DTS boundary',
+  );
+  for (const sharedPackagePath of sharedPackagePaths) {
+    assertProjectReferenceEmitConfig(
+      readJson(`${sharedPackagePath}/tsconfig.json`),
+      sharedPackagePath,
+    );
+  }
+
+  for (const vertical of fullStackVerticals) {
+    const verticalTsConfig = readJson(`${vertical.path}/tsconfig.json`);
+    const verticalMfTypesTsConfig = readJson(
+      `${vertical.path}/tsconfig.mf-types.json`,
+    );
+    const expectedVerticalReferences = [
+      ...sharedPackagePaths,
+      ...(vertical.verticalRefs ?? [])
+        .map(verticalRef =>
+          fullStackVerticals.find(candidate => candidate.id === verticalRef),
+        )
+        .filter(Boolean)
+        .map(referencedVertical => referencedVertical.path),
+    ].map(referencePath => referenceFrom(vertical.path, referencePath));
+    assertSameJson(
+      verticalTsConfig.references ?? [],
+      expectedVerticalReferences,
+      `${vertical.path}/tsconfig.json references`,
+      'restore the generated MicroVertical project-reference graph',
+    );
+    assertProjectReferenceEmitConfig(verticalTsConfig, vertical.path);
+    assertSameJson(
+      verticalMfTypesTsConfig,
+      {
+        extends: './tsconfig.json',
+        include: [
+          'src/federation-entry.tsx',
+          ...vertical.componentPaths.map(componentPath =>
+            componentPath.replace(`${vertical.path}/`, ''),
+          ),
+          'src/modern-app-env.d.ts',
+        ],
+      },
+      `${vertical.path}/tsconfig.mf-types.json`,
+      'restore the generated MicroVertical Module Federation DTS boundary',
+    );
+  }
+};
 const packageJsonFiles = startDir => {
   const files = [];
   const queue = [startDir];
@@ -511,10 +647,79 @@ const assertCloudflareQualityGates = (appId, qualityGates) => {
   assert(qualityGates?.csp?.finalMode === 'report-only-dogfood', `${appId} CSP final mode decision is missing`);
 };
 const extractAssetPrefixExpression = modernConfig => {
-  const match = /const assetPrefix =\n(?<expression>[\s\S]*?);/u.exec(modernConfig);
+  const match = /const\s+assetPrefix\s*=\s*(?<expression>[\s\S]*?);/u.exec(modernConfig);
   assert(match?.groups?.expression, 'modern.config.ts must assign assetPrefix');
   return match.groups.expression;
 };
+const stripYamlInlineComment = value => {
+  let quote = undefined;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (character === quote && value[index - 1] !== '\\') {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === '#' && (index === 0 || /\s/u.test(value[index - 1]))) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value.trimEnd();
+};
+const normalizeYamlScalar = value => {
+  const trimmed = stripYamlInlineComment(value).trim();
+  if (
+    ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) &&
+    trimmed.length >= 2
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+};
+const extractWorkflowNodeVersions = workflowText => {
+  const versions = [];
+  const lines = workflowText.split(/\r?\n/u);
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const match = /^(?<indent>\s*)node-version\s*:\s*(?<value>.*)$/u.exec(
+      lines[lineIndex],
+    );
+    if (!match?.groups) {
+      continue;
+    }
+
+    let value = normalizeYamlScalar(match.groups.value);
+    if (value === '' || value === '|' || value === '>') {
+      const currentIndent = match.groups.indent.length;
+      for (
+        let nextLineIndex = lineIndex + 1;
+        nextLineIndex < lines.length;
+        nextLineIndex += 1
+      ) {
+        const nextLine = lines[nextLineIndex];
+        const nextTrimmed = nextLine.trim();
+        if (nextTrimmed === '' || nextTrimmed.startsWith('#')) {
+          continue;
+        }
+        const nextIndent = nextLine.match(/^\s*/u)?.[0]?.length ?? 0;
+        if (nextIndent <= currentIndent) {
+          break;
+        }
+        value = normalizeYamlScalar(nextTrimmed);
+        break;
+      }
+    }
+    if (value !== '') {
+      versions.push(value);
+    }
+  }
+  return versions;
+};
 const expectedWorkerName = packageSuffix => `${packageScope}-${packageSuffix}`.slice(0, 63);
 const expectedChunkLoadingGlobal = mfName =>
   `__ULTRAMODERN_${mfName
@@ -559,6 +764,7 @@ const requiredPaths = [
   '.gitignore',
   'package.json',
   'pnpm-workspace.yaml',
+  'tsconfig.json',
   'tsconfig.base.json',
   'oxlint.config.ts',
   'oxfmt.config.ts',
@@ -581,7 +787,10 @@ const requiredPaths = [
   'scripts/setup-agent-reference-repos.mjs',
   'scripts/ultramodern-performance-readiness.config.mjs',
   'scripts/ultramodern-performance-readiness.mjs',
+  'scripts/ultramodern-typecheck.mjs',
   'apps/shell-super-app/package.json',
+  'apps/shell-super-app/tsconfig.json',
+  'apps/shell-super-app/tsconfig.mf-types.json',
   'apps/shell-super-app/modern.config.ts',
   'apps/shell-super-app/module-federation.config.ts',
   'apps/shell-super-app/src/modern-app-env.d.ts',
@@ -597,9 +806,13 @@ const requiredPaths = [
   'apps/shell-super-app/src/routes/ultramodern-route-metadata.ts',
   'apps/shell-super-app/src/routes/[lang]/page.tsx',
   ...{{shellRouteMetaPathsJson}},
+  'packages/shared-contracts/package.json',
   'packages/shared-contracts/src/index.ts',
+  'packages/shared-contracts/tsconfig.json',
+  'packages/shared-design-tokens/package.json',
   'packages/shared-design-tokens/src/index.ts',
   'packages/shared-design-tokens/src/tokens.css',
+  'packages/shared-design-tokens/tsconfig.json',
 ];
 
 for (const vertical of fullStackVerticals) {
@@ -643,6 +856,7 @@ assertMicroVerticalContractGraph({
   overlay,
   shellPackage,
 });
+assertTsConfigReferenceGraph();
 
 assert(rootPackage.private === true, 'Root package must be private');
 assert(typeof rootPackage.packageManager === 'string', 'Root must declare packageManager');
@@ -660,7 +874,12 @@ assert(generatedContract.node?.engineRange === '>=26', 'Generated contract must
 assert(readText('.mise.toml').includes(`node = "${expectedNodeVersion}"`), 'mise must pin the generated Node version');
 assert(readText('.mise.toml').includes(`pnpm = "${packageManagerPnpmVersion}"`), 'mise must pin the generated pnpm version');
 const workflowText = readText('.github/workflows/ultramodern-workspace-gates.yml');
-assert(workflowText.includes(`node-version: "${expectedNodeVersion}"`), 'CI workflow must pin the generated Node version');
+const workflowNodeVersions = extractWorkflowNodeVersions(workflowText);
+assert(workflowNodeVersions.length > 0, 'CI workflow must configure setup-node node-version');
+assert(
+  workflowNodeVersions.every(nodeVersion => nodeVersion === expectedNodeVersion),
+  `CI workflow must pin the generated Node version ${expectedNodeVersion}; found ${workflowNodeVersions.join(', ')}`,
+);
 assert(!workflowText.includes('FORCE_JAVASCRIPT_ACTIONS_TO_NODE24'), 'CI workflow must not carry the legacy Node 24 override');
 assert(rootPackage.modernjs?.preset === 'presetUltramodern', 'Root must declare presetUltramodern');
 assert(rootPackage.modernjs?.packageSource?.config === './.modernjs/ultramodern-package-source.json', 'Root must point at package source metadata');
@@ -711,6 +930,7 @@ assert(
 );
 assert(rootPackage.scripts?.['cloudflare:build'] === expectedCloudflareBuildScript, 'Root cloudflare:build script is incorrect');
 assert(!('ultramodern:check' in (rootPackage.scripts ?? {})), 'Root must not expose ultramodern:check');
+assert(rootPackage.scripts?.typecheck === 'node ./scripts/ultramodern-typecheck.mjs --build tsconfig.json', 'Root typecheck must run TS-Go build mode across project references');
 assert(rootPackage.scripts?.['contract:check'] === 'node ./scripts/validate-ultramodern-workspace.mjs', 'Root must expose contract:check');
 assert(rootPackage.scripts?.['i18n:boundaries'] === 'node ./scripts/check-ultramodern-i18n-boundaries.mjs', 'Root must expose i18n:boundaries');
 assert(rootPackage.scripts?.['performance:readiness'] === 'node ./scripts/ultramodern-performance-readiness.mjs', 'Root must expose default-on performance readiness diagnostics');
@@ -723,6 +943,9 @@ assert(performanceReadinessConfig.includes("failOn: 'framework-invariant'"), 'Pe
 assert(performanceReadinessScript.includes("ULTRAMODERN_PERFORMANCE_READINESS_DIAGNOSTICS"), 'Performance readiness script must support env opt-out');
 assert(performanceReadinessScript.includes('ultramodern-performance-readiness-diagnostics-v1'), 'Performance readiness script must emit the deterministic report profile');
 const i18nBoundaryScript = readText('scripts/check-ultramodern-i18n-boundaries.mjs');
+const ultramodernTypecheckScript = readText('scripts/ultramodern-typecheck.mjs');
+assert(ultramodernTypecheckScript.includes("'--checkers'") && ultramodernTypecheckScript.includes("'--builders'"), 'Root typecheck script must drive TS-Go checker and builder parallelism');
+assert(ultramodernTypecheckScript.includes('effect-tsgo') && ultramodernTypecheckScript.includes('get-exe-path'), 'Root typecheck script must resolve the @effect/tsgo native-preview binary');
 assert(
   i18nBoundaryScript.includes("from '@modern-js/code-tools'") &&
     i18nBoundaryScript.includes('runWorkspaceSourceCheck'),
@@ -775,6 +998,7 @@ assert(generatedContract.performanceReadiness?.optOut?.env === 'ULTRAMODERN_PERF
 assert(JSON.stringify(generatedContract.performanceReadiness?.signals?.map(signal => signal.id)) === JSON.stringify(expectedPerformanceReadinessSignals), 'Performance readiness signal ids are incorrect');
 
 const shellModernConfig = readText('apps/shell-super-app/modern.config.ts');
+const shellModuleFederationConfig = readText('apps/shell-super-app/module-federation.config.ts');
 const shellRouteHead = readText('apps/shell-super-app/src/routes/ultramodern-route-head.tsx');
 const shellRouteMetadata = readText('apps/shell-super-app/src/routes/ultramodern-route-metadata.ts');
 assert(shellRouteMetadata.includes('@generated by @modern-js/create'), 'Shell route metadata compatibility manifest must be marked generated');
@@ -819,12 +1043,16 @@ assert(shellModernConfig.includes('assetPrefix,'), 'Shell modern.config.ts must
 assert(shellContract?.config?.dev?.assetPrefix === '/', 'Shell dev asset prefix must stay origin-relative');
 assert(shellContract?.config?.output?.assetPrefix?.default === '/', 'Shell asset prefix must default to origin-relative paths');
 assert(JSON.stringify(shellContract?.config?.output?.assetPrefix?.envFallbackOrder) === JSON.stringify(['MODERN_ASSET_PREFIX', 'ULTRAMODERN_ASSET_PREFIX']), 'Shell asset prefix env fallback order is incorrect');
+assert(shellContract?.config?.output?.disableTsChecker === false, 'Shell must keep the framework TypeScript checker enabled');
 assert(shellContract?.config?.performance?.readinessDiagnostics?.default === 'enabled', 'Shell performance readiness diagnostics must be default-on');
 assert(shellContract?.config?.performance?.readinessDiagnostics?.failOn === 'framework-invariant', 'Shell performance readiness diagnostics must only fail framework invariants by default');
 assert(shellContract?.config?.performance?.readinessDiagnostics?.optOut?.env === 'ULTRAMODERN_PERFORMANCE_READINESS_DIAGNOSTICS=false', 'Shell performance readiness env opt-out is incorrect');
 assert(JSON.stringify(shellContract?.config?.source?.siteUrl?.envFallbackOrder) === JSON.stringify(['MODERN_PUBLIC_SITE_URL', 'ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP', 'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN', 'SHELL_SUPER_APP_PORT']), 'Shell site URL env fallback order is incorrect');
 assert(shellContract?.config?.rspack?.output?.uniqueName === 'shellSuperApp', 'Shell Rspack uniqueName is incorrect');
 assert(shellContract?.config?.rspack?.output?.chunkLoadingGlobal === expectedChunkLoadingGlobal('shellSuperApp'), 'Shell Rspack chunkLoadingGlobal is incorrect');
+assert(shellContract?.moduleFederation?.dts?.compilerInstance === 'tsgo', 'Shell must keep mandatory DTS compiler');
+assert(shellContract?.moduleFederation?.dts?.tsConfigPath === './tsconfig.mf-types.json', 'Shell must keep dedicated Module Federation DTS tsconfig');
+assert(shellModuleFederationConfig.includes("tsConfigPath: './tsconfig.mf-types.json'"), 'Shell Module Federation config must use the dedicated DTS tsconfig');
 assert(topology.shell?.cloudflare?.workerName === expectedWorkerName('shell-super-app'), 'Shell topology Cloudflare workerName is incorrect');
 assert(shellContract?.styling?.federation?.owner?.id === 'shell-super-app', 'Shell CSS federation owner is missing');
 assert(shellContract?.styling?.federation?.role === 'shell-base-overlay', 'Shell must own base and overlay CSS');
@@ -859,6 +1087,7 @@ assert(!('effectServices' in topology), 'Default APIs must be vertical-owned, no
 for (const vertical of fullStackVerticals) {
   const packageJson = readJson(`${vertical.path}/package.json`);
   const modernConfig = readText(`${vertical.path}/modern.config.ts`);
+  const moduleFederationConfig = readText(`${vertical.path}/module-federation.config.ts`);
   const routeHead = readText(`${vertical.path}/src/routes/ultramodern-route-head.tsx`);
   const routeMetadata = readText(`${vertical.path}/src/routes/ultramodern-route-metadata.ts`);
   assert(routeMetadata.includes('@generated by @modern-js/create'), `${vertical.id} route metadata compatibility manifest must be marked generated`);
@@ -913,6 +1142,7 @@ for (const vertical of fullStackVerticals) {
   assert(contractEntry?.config?.dev?.assetPrefix === '/', `${vertical.id} dev asset prefix must stay origin-relative`);
   assert(contractEntry?.config?.output?.assetPrefix?.default === '/', `${vertical.id} asset prefix must default to origin-relative paths`);
   assert(JSON.stringify(contractEntry?.config?.output?.assetPrefix?.envFallbackOrder) === JSON.stringify(['MODERN_ASSET_PREFIX', 'ULTRAMODERN_ASSET_PREFIX']), `${vertical.id} asset prefix env fallback order is incorrect`);
+  assert(contractEntry?.config?.output?.disableTsChecker === false, `${vertical.id} must keep the framework TypeScript checker enabled`);
   assert(contractEntry?.config?.performance?.readinessDiagnostics?.default === 'enabled', `${vertical.id} performance readiness diagnostics must be default-on`);
   assert(contractEntry?.config?.performance?.readinessDiagnostics?.failOn === 'framework-invariant', `${vertical.id} performance readiness diagnostics must only fail framework invariants by default`);
   assert(contractEntry?.config?.performance?.readinessDiagnostics?.optOut?.config === 'scripts/ultramodern-performance-readiness.config.mjs', `${vertical.id} performance readiness opt-out config is incorrect`);
@@ -922,6 +1152,8 @@ for (const vertical of fullStackVerticals) {
   assert(contractEntry?.moduleFederation?.name === vertical.mfName, `${vertical.id} MF name is incorrect`);
   assert(JSON.stringify(contractEntry?.moduleFederation?.exposes) === JSON.stringify(vertical.exposes), `${vertical.id} MF exposes are incorrect`);
   assert(contractEntry?.moduleFederation?.dts?.compilerInstance === 'tsgo', `${vertical.id} must keep mandatory DTS compiler`);
+  assert(contractEntry?.moduleFederation?.dts?.tsConfigPath === './tsconfig.mf-types.json', `${vertical.id} must keep dedicated Module Federation DTS tsconfig`);
+  assert(moduleFederationConfig.includes("tsConfigPath: './tsconfig.mf-types.json'"), `${vertical.id} Module Federation config must use the dedicated DTS tsconfig`);
   assert(JSON.stringify(contractEntry?.moduleFederation?.verticalRefs ?? []) === JSON.stringify(vertical.verticalRefs), `${vertical.id} MF verticalRefs are incorrect`);
   assert(
     JSON.stringify((contractEntry?.moduleFederation?.remotes ?? []).map(remote => remote.id)) ===