arkgate 2.7.0 → 2.8.0

package/CHANGELOG.md

@@ -2,7 +2,33 @@
 
 All notable changes to ArkGate (`arkgate`; formerly `ark-runtime-kernel`) are documented here.
 
-## Unreleased
+## 2.8.0 — 2026-07-09
+
+Co-pilot quality release (roadmap **R5–R7**): labeled eval corpus, fourth mechanical-safe kind,
+and Codex multi-project MCP without silent primary overwrite. **No intentional CLI flag or JSON
+shape breaks** for the gate/co-pilot path.
+
+### Added
+
+- **R5 — labeled eval corpus:** 16 cases under `eval/cases/` (themes + labels).
+  `npm run eval:corpus` / `evalCorpus.test.ts` gate without a live agent.
+- **R6 — `import-type-of-type-exports`:** named type-only exports from mixed modules →
+  `import type` / `export type`. Dual-space names and targets with top-level side effects stay
+  **judgment**. Scan flags `namedBindingsTypeOnly` (+ `hasTopLevelSideEffects`).
+- **R7 — Codex multi-project MCP DX:** no silent primary steal; scoped
+  `[mcp_servers.ark_<slug>_<hash>]`; doctor gap `codex-home-multi-project`. Codex home logic in
+  `bin/lib/codex-home.mjs`.
+
+### Changed
+
+- Scan cache schema **v6** (typeOnlyExportNames, namedBindings, hasTopLevelSideEffects;
+  invalidates v5 after non-export side-effect honesty fix).
+- Classifier: single early judgment for `require` / `dynamic-import` on layer edges.
+- R6 honesty: impure value-export initializers (`export const db = connect()`) count as
+  top-level side effects — named type imports of those modules stay **judgment**.
+- R6 honesty: non-exported impure top-level initializers (`const boot = setup()`) and
+  non-exported class static field calls also count as side effects (same skip-on-import-type risk).
+- Codex home: single `upsertCodexMcpTable` path for primary and secondary MCP tables.
 
 ## 2.7.0 — 2026-07-09
 

package/bin/lib/agent-gates.mjs

@@ -3,7 +3,6 @@
  */
 import { createRequire } from 'node:module';
 import { spawnSync } from 'node:child_process';
-import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -23,6 +22,40 @@ import {
   createElevenLayerConfig,
   applyFrameworkLayoutOverlays
 } from '../ark-shared.mjs';
+import {
+  assessCodexHomeMcp,
+  codexArkBlockHasPreferredBin,
+  codexArkBlockNeedsRewrite,
+  codexConfigPath,
+  codexPrimaryTable,
+  codexProjectSlug,
+  codexPromptsDir,
+  codexScopedTableForRoot,
+  extractCodexArkRootFromToml,
+  extractCodexRootFromBlock,
+  isTempOrUpgradeRoot,
+  listCodexArkServerTables,
+  upsertCodexMcpTable,
+  wireCodexMcp,
+} from './codex-home.mjs';
+
+// Re-export Codex home API for existing consumers (ark-check, tests).
+export {
+  assessCodexHomeMcp,
+  codexArkBlockHasPreferredBin,
+  codexArkBlockNeedsRewrite,
+  codexConfigPath,
+  codexPrimaryTable,
+  codexProjectSlug,
+  codexPromptsDir,
+  codexScopedTableForRoot,
+  extractCodexArkRootFromToml,
+  extractCodexRootFromBlock,
+  isTempOrUpgradeRoot,
+  listCodexArkServerTables,
+  upsertCodexMcpTable,
+  wireCodexMcp,
+};
 
 /** Package root (parent of bin/). All modules live under bin/lib/. */
 const __packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
@@ -762,136 +795,6 @@ export function skillTemplateNames() {
 // skills this version ships, surface it here so agents and CI actually notice.
 // Advisory only — never affects the exit code. Copilot has no reliable directory
 // signal, so it is not auto-detected (explicit --tools only), matching resolveTools.
-// Where Codex loads slash-command prompts from. Codex reads $CODEX_HOME/prompts
-// (defaulting to ~/.codex/prompts), NOT the repo — so home copies of the /ark-*
-// skills drift out of date when a repo refresh only touches in-repo tool dirs.
-export function codexPromptsDir() {
-  const base = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-  return path.join(base, 'prompts');
-}
-
-// Where Codex reads its MCP server registrations. Unlike Claude (.claude/settings.json)
-// and Cursor (.cursor/mcp.json), Codex loads MCP servers only from $CODEX_HOME/config.toml
-// (~/.codex/config.toml) — never from .mcp.json — so wiring Codex means editing the user's
-// home config, not a repo file.
-export function codexConfigPath() {
-  const base = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-  return path.join(base, 'config.toml');
-}
-
-// Merge the [mcp_servers.ark] table into Codex's config.toml so `ark://manifest` and the
-// AI write gate are live from the first edit — the piece that was previously only shipped as
-// a copy-me sample in docs/ark-codex-config.toml. Idempotent: an existing ark table is left
-// untouched unless `force` replaces it; other content in the file is preserved. Returns a
-// status for the install summary. The table match runs from the [mcp_servers.ark] header to
-// the line before the next top-level table header (a line starting with `[`) or EOF.
-//
-// Unlike .mcp.json / .cursor/mcp.json (loaded relative to the project), config.toml is a
-// GLOBAL file — Codex launches it without the project as cwd — so `--root .` would resolve
-// against the wrong directory. The paths must be absolute, and TOML string values need the
-// backslashes/quotes escaped (matters on Windows and for repo paths containing quotes).
-export function wireCodexMcp(root, force) {
-  const file = codexConfigPath();
-  const esc = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  const absRoot = path.resolve(root);
-  const absConfig = path.join(absRoot, 'ark.config.json');
-  // Preferred product bin; absolute --root so Codex (cwd ≠ project) resolves correctly.
-  const preferredBin = 'arkgate-mcp';
-  const { command, args } = execCommandParts(root, preferredBin, [
-    '--root',
-    esc(absRoot),
-    '--config',
-    esc(absConfig),
-  ]);
-  const argsToml = args.map((value) => `"${value}"`).join(', ');
-  const makeBlock = (table) =>
-    `[mcp_servers.${table}]
-command = "${command}"
-args = [${argsToml}]`;
-  let existing = '';
-  try {
-    if (fs.existsSync(file)) existing = fs.readFileSync(file, 'utf8');
-  } catch (error) {
-    return { status: 'failed', file, message: error.message };
-  }
-  const tableRe = /(^|\n)\[mcp_servers\.ark\][^\n]*\n(?:(?!\[)[^\n]*\n?)*/;
-  const hasTable = tableRe.test(existing);
-  const existingRoot = hasTable ? extractCodexArkRootFromToml(existing) : null;
-  let differentProject = false;
-  try {
-    differentProject = Boolean(
-      existingRoot && path.resolve(existingRoot) !== absRoot
-    );
-  } catch {
-    differentProject = Boolean(existingRoot);
-  }
-  // Fail-closed: rewrite temp/upgrade roots and dual/wrong bins even without --force.
-  const mustRewrite = hasTable && codexArkBlockNeedsRewrite(existing, absRoot);
-
-  // Multi-project: another project's [mcp_servers.ark] is present. Without --force,
-  // add a project-scoped table so we do not steal the primary binding.
-  if (hasTable && differentProject && !force && !mustRewrite) {
-    const slug =
-      path
-        .basename(absRoot)
-        .replace(/[^a-zA-Z0-9_-]/g, '_')
-        .slice(0, 48) || 'project';
-    const table = `ark_${slug}`;
-    const multiRe = new RegExp(
-      `(^|\\n)\\[mcp_servers\\.${table.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\][^\\n]*\\n(?:(?!\\[)[^\\n]*\\n?)*`
-    );
-    const block = makeBlock(table);
-    let next;
-    if (multiRe.test(existing)) {
-      next = existing.replace(multiRe, (match) => `${match.startsWith('\n') ? '\n' : ''}${block}\n`);
-    } else {
-      const sep =
-        existing.length === 0
-          ? ''
-          : existing.endsWith('\n\n')
-            ? ''
-            : existing.endsWith('\n')
-              ? '\n'
-              : '\n\n';
-      next = `${existing}${sep}${block}\n`;
-    }
-    try {
-      fs.mkdirSync(path.dirname(file), { recursive: true });
-      fs.writeFileSync(file, next);
-    } catch (error) {
-      return { status: 'failed', file, message: error.message };
-    }
-    return { status: 'written-multi', file, table, primaryUnchanged: true };
-  }
-
-  if (hasTable && !force && !mustRewrite) {
-    return { status: 'skipped', file };
-  }
-  const block = makeBlock('ark');
-  let next;
-  if (hasTable) {
-    next = existing.replace(tableRe, (match) => `${match.startsWith('\n') ? '\n' : ''}${block}\n`);
-  } else {
-    const sep = existing.length === 0 ? '' : existing.endsWith('\n\n') ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
-    next = `${existing}${sep}${block}\n`;
-  }
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, next);
-  } catch (error) {
-    return { status: 'failed', file, message: error.message };
-  }
-  return {
-    status: hasTable ? 'updated' : 'written',
-    file,
-    ...(mustRewrite && !force ? { reason: 'temp-or-stale-root' } : {}),
-  };
-}
-
-// Detects stale/missing /ark-* skills in the Codex home prompts dir. Only nags
-// when at least one ark-* prompt already lives there (evidence Codex was set up
-// for this user) — never introduces Codex to someone who doesn't use it. Same
-// guards as detectSkillGaps (adopted repo, not the Ark source tree).
 export function detectCodexHomeGap(root) {
   if (!fs.existsSync(path.join(root, 'AGENTS.md'))) return null;
   if (fs.existsSync(path.join(root, 'templates', 'skills'))) return null;
@@ -1027,73 +930,6 @@ const CORE_LAYER_NAMES = new Set([
   'PersistenceAdapters',
 ]);
 
-/** Temp / upgrade sandbox roots must never remain as Codex MCP --root. */
-export function isTempOrUpgradeRoot(p) {
-  if (!p || typeof p !== 'string') return false;
-  const n = p.replace(/\\/g, '/');
-  return (
-    /\/var\/folders\//i.test(n) ||
-    /\/tmp\//i.test(n) ||
-    /\/Temp\//i.test(n) ||
-    /ark-upgrade/i.test(n) ||
-    /\/T\/(?:ark-|grok-)/i.test(n) ||
-    /[\\/]AppData[\\/]Local[\\/]Temp[\\/]/i.test(n)
-  );
-}
-
-/** Extract --root value from Codex [mcp_servers.ark] args array text. */
-export function extractCodexArkRootFromToml(tomlText) {
-  if (!tomlText || typeof tomlText !== 'string') return null;
-  const start = tomlText.search(/(^|\n)\[mcp_servers\.ark\]/);
-  if (start < 0) return null;
-  const rest = tomlText.slice(start);
-  const endMatch = rest.slice(1).search(/\n\[/);
-  const block = endMatch >= 0 ? rest.slice(0, endMatch + 1) : rest;
-  // args = ["arkgate-mcp", "--root", "/abs/path", ...]
-  const rootIdx = block.search(/"--root"\s*,\s*"/);
-  if (rootIdx < 0) {
-    // alternate: --root as adjacent string after any bin
-    const m = block.match(/"--root"\s*,\s*"([^"]+)"/);
-    return m ? m[1] : null;
-  }
-  const m = block.slice(rootIdx).match(/"--root"\s*,\s*"([^"]+)"/);
-  return m ? m[1] : null;
-}
-
-export function codexArkBlockHasPreferredBin(tomlText) {
-  if (!tomlText) return false;
-  const start = tomlText.search(/(^|\n)\[mcp_servers\.ark\]/);
-  if (start < 0) return false;
-  const rest = tomlText.slice(start);
-  const endMatch = rest.slice(1).search(/\n\[/);
-  const block = endMatch >= 0 ? rest.slice(0, endMatch + 1) : rest;
-  const bins = [...block.matchAll(/"(arkgate-mcp|ark-mcp)"/g)].map((m) => m[1]);
-  if (bins.length > 1) return false;
-  return bins.length === 1 && bins[0] === PREFERRED_MCP_BIN;
-}
-
-/**
- * True when the primary [mcp_servers.ark] block is broken (temp root / dual bin)
- * and should be rewritten fail-closed. Different permanent project roots are NOT
- * "broken" — multi-project wiring uses a secondary table instead.
- */
-export function codexArkBlockNeedsRewrite(tomlText, absRoot) {
-  if (!tomlText || !tomlText.includes('[mcp_servers.ark]')) return true;
-  const rootArg = extractCodexArkRootFromToml(tomlText);
-  if (!rootArg || isTempOrUpgradeRoot(rootArg)) return true;
-  // Permanent different project: multi-project path handles this (do not steal primary).
-  try {
-    if (path.resolve(rootArg) !== path.resolve(absRoot)) {
-      if (!isTempOrUpgradeRoot(rootArg)) return false;
-      return true;
-    }
-  } catch {
-    return true;
-  }
-  if (!codexArkBlockHasPreferredBin(tomlText)) return true;
-  return false;
-}
-
 /**
  * Production deploy path quality (universal — any consumer repo).
  * Detects when the production build host runs ESLint / typecheck as part of
@@ -1383,7 +1219,7 @@ export function collectAdoptionGaps(root, config, coverage) {
     }
   }
 
-  // --- Codex home MCP (temp path / wrong root / dual bin) ---
+  // --- Codex home MCP (temp path / wrong root / multi-project) ---
   let codexHome = null;
   if (adopted && !isProducer) {
     const codexFile = codexConfigPath();
@@ -1394,39 +1230,23 @@ export function collectAdoptionGaps(root, config, coverage) {
       toml = '';
     }
     if (toml.includes('[mcp_servers.ark]')) {
-      const rootArg = extractCodexArkRootFromToml(toml);
-      const absRoot = path.resolve(root);
-      const temp = isTempOrUpgradeRoot(rootArg);
-      let wrongRoot = false;
-      try {
-        wrongRoot = rootArg ? path.resolve(rootArg) !== absRoot : true;
-      } catch {
-        wrongRoot = true;
-      }
-      const preferredBin = codexArkBlockHasPreferredBin(toml);
-      const needsRewrite = codexArkBlockNeedsRewrite(toml, absRoot);
+      const assessed = assessCodexHomeMcp(toml, root);
       codexHome = {
         file: codexFile,
-        root: rootArg,
-        tempPath: temp,
-        wrongRoot,
-        preferredBin,
-        needsRewrite,
+        root: assessed.root,
+        tempPath: assessed.tempPath,
+        wrongRoot: assessed.wrongRoot,
+        preferredBin: assessed.preferredBin,
+        needsRewrite: assessed.needsRewrite,
+        multiProject: assessed.multiProject,
+        scopedTable: assessed.scopedTable,
       };
-      if (needsRewrite) {
+      if (assessed.gap) {
         gaps.push({
-          id: 'codex-home-mcp',
-          severity: temp || wrongRoot ? 'warn' : 'info',
-          message: temp
-            ? `Codex home MCP --root points at a temp/upgrade path (${rootArg})`
-            : wrongRoot
-              ? `Codex home MCP --root is not this project (${rootArg || 'missing'} ≠ ${absRoot})`
-              : `Codex home MCP should use a single ${PREFERRED_MCP_BIN} bin with absolute project paths`,
-          fix: arkCommand(
-            root,
-            'ark-check',
-            '--install-agent-gates --codex-home --force'
-          ),
+          id: assessed.gap.id,
+          severity: assessed.gap.severity,
+          message: assessed.gap.message,
+          fix: arkCommand(root, 'ark-check', assessed.gap.fixArgs),
         });
       }
     }

package/bin/lib/architecture-scan.mjs

@@ -15,12 +15,15 @@ import {
   isPublishCall,
   lineOf,
   moduleSpecifierFromCall,
+  namedModuleBindings,
   objectHasProperty,
   publishHasSource,
   publishSourceLiteral,
   sourceFileExportsOnlyTypes,
+  sourceFileHasTopLevelSideEffects,
   stringLiteralText,
   textOfModuleSpecifier,
+  typeOnlyExportNames,
 } from './ast-scan.mjs';
 import {
   intentLayersFromManifest,
@@ -64,11 +67,13 @@ export function scanSourceFile(ts, root, config, rules, manifestIntentLayers, fi
   }
 
   const checkModuleEdge = (specifier, node, kind, typeOnly = false) => {
+    const namedBindings = namedModuleBindings(ts, node);
     edges.push({
       specifier,
       line: lineOf(sourceFile, node.getStart(sourceFile)),
       kind,
       typeOnly,
+      ...(namedBindings ? { namedBindings } : {}),
     });
   };
 
@@ -165,6 +170,8 @@ export function scanSourceFile(ts, root, config, rules, manifestIntentLayers, fi
     contentViolations: violations,
     edges,
     exportsOnlyTypes: sourceFileExportsOnlyTypes(ts, sourceFile),
+    typeOnlyExportNames: typeOnlyExportNames(ts, sourceFile),
+    hasTopLevelSideEffects: sourceFileHasTopLevelSideEffects(ts, sourceFile),
   };
 }
 
@@ -238,6 +245,18 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
         const targetTypeOnlyExports =
           staticEdge && Boolean(targetCached?.exportsOnlyTypes) && !edge.typeOnly;
         const sourcePureTypeModule = Boolean(entry.exportsOnlyTypes);
+        // R6: every named binding is a type-only export of the target (mixed modules OK).
+        // Conservative: no dual-space value names, no top-level side effects on target
+        // (import type would skip evaluation), no default/namespace/side-effect/export*.
+        const targetTypeNames = new Set(targetCached?.typeOnlyExportNames || []);
+        const named = edge.namedBindings;
+        const namedBindingsTypeOnly =
+          staticEdge &&
+          Array.isArray(named) &&
+          named.length > 0 &&
+          targetTypeNames.size > 0 &&
+          !targetCached?.hasTopLevelSideEffects &&
+          named.every((n) => targetTypeNames.has(n));
         violations.push({
           ruleId: 'LAYER_IMPORT_VIOLATION',
           file: relFile,
@@ -248,6 +267,7 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           ...(edge.typeOnly ? { typeOnly: true } : {}),
           ...(targetTypeOnlyExports ? { targetTypeOnlyExports: true } : {}),
           ...(sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
+          ...(namedBindingsTypeOnly ? { namedBindingsTypeOnly: true } : {}),
           ...(edge.kind ? { edgeKind: edge.kind } : {}),
           message: rule.message ?? `${sourceLayer} must not ${edge.kind} ${targetLayer}.`,
         });

package/bin/lib/ast-scan.mjs

@@ -49,11 +49,15 @@ export function isTypeOnlyModuleReference(ts, node) {
  * Used so static value-syntax `import { T }` of a pure-type module can be mechanical-safe
  * (convert to `import type`). Never trust this for require()/import() edges.
  */
+function hasExportModifier(ts, node) {
+  return (
+    Array.isArray(node.modifiers) &&
+    node.modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
+  );
+}
+
 export function sourceFileExportsOnlyTypes(ts, sourceFile) {
   let sawTypeExport = false;
-  const hasExportModifier = (node) =>
-    Array.isArray(node.modifiers) &&
-    node.modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
 
   for (const stmt of sourceFile.statements) {
     // Type-only imports OK; value or side-effect imports mean runtime load of deps.
@@ -84,7 +88,7 @@ export function sourceFileExportsOnlyTypes(ts, sourceFile) {
     }
     if (ts.isExportAssignment(stmt)) return false; // export = / export default expr
     if (ts.isTypeAliasDeclaration(stmt) || ts.isInterfaceDeclaration(stmt)) {
-      if (hasExportModifier(stmt)) sawTypeExport = true;
+      if (hasExportModifier(ts, stmt)) sawTypeExport = true;
       continue;
     }
     // Any other top-level statement (const/fn/class/enum, console.log, if, …) is runtime.
@@ -93,6 +97,230 @@ export function sourceFileExportsOnlyTypes(ts, sourceFile) {
   return sawTypeExport;
 }
 
+/**
+ * Names that exist in the *value* export space of this module (runtime bindings).
+ * Used to subtract dual-space names (e.g. `export type Foo` + `export const Foo`) from
+ * type-only export sets so converting `import { Foo }` to `import type` never drops a
+ * runtime binding.
+ */
+function collectBindingIdentifiers(ts, nameNode, into) {
+  if (!nameNode) return;
+  if (ts.isIdentifier(nameNode)) {
+    into.add(nameNode.text);
+    return;
+  }
+  if (ts.isObjectBindingPattern(nameNode) || ts.isArrayBindingPattern(nameNode)) {
+    for (const el of nameNode.elements) {
+      if (ts.isOmittedExpression(el)) continue;
+      if (ts.isBindingElement(el)) collectBindingIdentifiers(ts, el.name, into);
+    }
+  }
+}
+
+export function valueExportNames(ts, sourceFile) {
+  const names = new Set();
+  const add = (n) => {
+    if (n) names.add(n);
+  };
+  for (const stmt of sourceFile.statements) {
+    // export const/let/var Foo = …
+    if (ts.isVariableStatement(stmt) && hasExportModifier(ts, stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        collectBindingIdentifiers(ts, decl.name, names);
+      }
+      continue;
+    }
+    // export function Foo / export async function Foo
+    if (ts.isFunctionDeclaration(stmt) && hasExportModifier(ts, stmt) && stmt.name) {
+      add(stmt.name.text);
+      continue;
+    }
+    // export class Foo — value + type space; treat as value so never auto import-type
+    if (ts.isClassDeclaration(stmt) && hasExportModifier(ts, stmt) && stmt.name) {
+      add(stmt.name.text);
+      continue;
+    }
+    // export enum Foo — value + type
+    if (ts.isEnumDeclaration(stmt) && hasExportModifier(ts, stmt) && stmt.name) {
+      add(stmt.name.text);
+      continue;
+    }
+    // export namespace Foo — value + type
+    if (ts.isModuleDeclaration(stmt) && hasExportModifier(ts, stmt) && stmt.name && ts.isIdentifier(stmt.name)) {
+      add(stmt.name.text);
+      continue;
+    }
+    if (!ts.isExportDeclaration(stmt)) continue;
+    // export * from '…' — unknown value surface; cannot prove type-only names alone
+    if (!stmt.exportClause) {
+      // star re-export can introduce values; flag as opaque by adding a sentinel? callers
+      // only check named bindings against explicit type-only sets — leave empty for star.
+      continue;
+    }
+    if (ts.isNamespaceExport(stmt.exportClause)) continue;
+    if (!ts.isNamedExports(stmt.exportClause)) continue;
+    // bare `export { Foo }` / `export { Foo } from '…'` without type keyword — value (or dual)
+    if (!stmt.isTypeOnly) {
+      for (const el of stmt.exportClause.elements) {
+        if (el.isTypeOnly) continue;
+        const local = el.propertyName && 'text' in el.propertyName ? el.propertyName.text : el.name?.text;
+        add(local);
+      }
+    }
+  }
+  return names;
+}
+
+/**
+ * True when an expression may run runtime work if the module is evaluated.
+ * Conservative: any call/new/await/tagged-template (or nested) is impure.
+ * Literals, identifiers, pure object/array/as/parenthesized trees are pure.
+ */
+export function expressionMayHaveSideEffects(ts, expr) {
+  if (!expr) return false;
+  if (
+    ts.isCallExpression(expr) ||
+    ts.isNewExpression(expr) ||
+    ts.isAwaitExpression(expr) ||
+    ts.isTaggedTemplateExpression(expr) ||
+    ts.isYieldExpression?.(expr)
+  ) {
+    return true;
+  }
+  // Walk children; short-circuit on first impure.
+  let impure = false;
+  const visit = (node) => {
+    if (impure) return;
+    if (
+      ts.isCallExpression(node) ||
+      ts.isNewExpression(node) ||
+      ts.isAwaitExpression(node) ||
+      ts.isTaggedTemplateExpression(node) ||
+      (typeof ts.isYieldExpression === 'function' && ts.isYieldExpression(node))
+    ) {
+      impure = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(expr, visit);
+  return impure;
+}
+
+/**
+ * True when evaluating this module may run non-trivial top-level work.
+ * Covers: expression statements, bare side-effect imports, control-flow,
+ * any top-level var initializer that call/new/await (exported or not),
+ * export-default impure expr, and class static field calls (export-agnostic).
+ * Converting `import { Type }` → `import type` would skip those effects — not auto-safe.
+ */
+export function sourceFileHasTopLevelSideEffects(ts, sourceFile) {
+  for (const stmt of sourceFile.statements) {
+    if (ts.isExpressionStatement(stmt)) return true;
+    if (ts.isImportDeclaration(stmt) && !stmt.importClause) return true; // import './x'
+    if (
+      ts.isIfStatement(stmt) ||
+      ts.isForStatement(stmt) ||
+      ts.isForInStatement(stmt) ||
+      ts.isForOfStatement(stmt) ||
+      ts.isWhileStatement(stmt) ||
+      ts.isDoStatement(stmt) ||
+      ts.isSwitchStatement(stmt) ||
+      ts.isTryStatement(stmt) ||
+      ts.isThrowStatement(stmt) ||
+      ts.isWithStatement?.(stmt)
+    ) {
+      return true;
+    }
+    // Top-level const/let/var x = <maybe impure> — including non-exported.
+    // `const db = connect(); export type Row = …` still runs connect on module load;
+    // converting `import { Row }` → `import type` would skip that work (R6 honesty).
+    if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (decl.initializer && expressionMayHaveSideEffects(ts, decl.initializer)) return true;
+      }
+    }
+    // export default <expr>
+    if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+      if (stmt.expression && expressionMayHaveSideEffects(ts, stmt.expression)) return true;
+    }
+    // Class with static field initializers that call — class body evaluates at load
+    // whether or not the class is exported.
+    if (ts.isClassDeclaration(stmt)) {
+      for (const member of stmt.members ?? []) {
+        if (
+          ts.isPropertyDeclaration(member) &&
+          member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) &&
+          member.initializer &&
+          expressionMayHaveSideEffects(ts, member.initializer)
+        ) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Names that are provably type-only exports of this module (erased at runtime).
+ * Conservative: class/enum/namespace/const/function exports are excluded even when they
+ * also introduce a type. Dual-space names (`export type Foo` + `export const Foo`) are
+ * subtracted — converting those to `import type` would drop a runtime binding.
+ * Used so `import { Row }` of a type alias from a mixed module can be mechanical-safe.
+ */
+export function typeOnlyExportNames(ts, sourceFile) {
+  const names = new Set();
+  for (const stmt of sourceFile.statements) {
+    if (ts.isTypeAliasDeclaration(stmt) || ts.isInterfaceDeclaration(stmt)) {
+      if (hasExportModifier(ts, stmt) && stmt.name) names.add(stmt.name.text);
+      continue;
+    }
+    if (!ts.isExportDeclaration(stmt)) continue;
+    const clause = stmt.exportClause;
+    if (!clause || !ts.isNamedExports(clause)) continue;
+    for (const el of clause.elements) {
+      // `export type { X }` or `export { type X }` — type-only re-exports.
+      if (stmt.isTypeOnly || el.isTypeOnly) {
+        const local = el.propertyName && 'text' in el.propertyName ? el.propertyName.text : el.name?.text;
+        if (local) names.add(local);
+      }
+    }
+  }
+  // Subtract any name that also has a value export (dual-space / value re-export).
+  const values = valueExportNames(ts, sourceFile);
+  for (const v of values) names.delete(v);
+  return [...names];
+}
+
+/**
+ * Local names of named import/export bindings on a module edge, or null when the edge
+ * is not a pure named list (default import, namespace, side-effect, export *, export =).
+ * PropertyName is preferred so `import { Row as R }` still checks target export `Row`.
+ */
+export function namedModuleBindings(ts, node) {
+  if (ts.isImportDeclaration(node)) {
+    const clause = node.importClause;
+    if (!clause) return null; // side-effect
+    if (clause.name) return null; // default import (possibly with named — still not pure-named-only)
+    const named = clause.namedBindings;
+    if (!named || !ts.isNamedImports(named) || named.elements.length === 0) return null;
+    return named.elements.map((el) => {
+      const prop = el.propertyName && 'text' in el.propertyName ? el.propertyName.text : null;
+      return prop || el.name.text;
+    });
+  }
+  if (ts.isExportDeclaration(node)) {
+    const clause = node.exportClause;
+    if (!clause || !ts.isNamedExports(clause) || clause.elements.length === 0) return null;
+    return clause.elements.map((el) => {
+      const prop = el.propertyName && 'text' in el.propertyName ? el.propertyName.text : null;
+      return prop || el.name.text;
+    });
+  }
+  return null;
+}
+
 export function propertyName(ts, node) {
   if (!node) return undefined;
   if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) return node.text;