@smoothbricks/cli 0.10.6 → 0.10.7

package/src/monorepo/managed-files.test.ts

@@ -4,17 +4,17 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LINUX_PLATFORM_TARGET_GLOBS, PLATFORM_TARGET_GLOBS } from '@smoothbricks/nx-plugin/workspace-config-policy';
 import fc from 'fast-check';
+import { type NxProjects, targetNamesFromProjects } from '../nx/index.js';
 import {
   deployTargetInfoFromProjects,
   extractInlineLocalBlocksForTest,
   INLINE_LOCAL_BEGIN,
   INLINE_LOCAL_END,
   LOCAL_SECTION_MARKER,
-  type NxGraphProjectNode,
+  managedFileTargetsForTest,
   platformTargetGlobsForTest,
   reinsertInlineLocalBlocksForTest,
   splitLocalSectionForTest,
-  targetNamesFromProjects,
 } from './managed-files.js';
 
 const MANAGED = '# managed content\npath merge=driver\n';
@@ -176,48 +176,57 @@ describe('managed publish platform discovery', () => {
 });
 
 describe('nx graph project helpers', () => {
-  const sampleNodes: Record<string, NxGraphProjectNode> = {
+  const sampleProjects: NxProjects = {
     lib: {
-      data: {
-        targets: {
-          build: {},
-          'bundle-linux': {},
-          lint: {},
-        },
+      targets: {
+        build: {},
+        'bundle-linux': {},
+        lint: {},
       },
     },
     app: {
-      data: {
-        targets: {
-          deploy: {
-            options: { command: 'echo no' },
-            configurations: {
-              staging: { command: 'wrangler deploy --env staging' },
-              production: { options: { command: 'wrangler deploy --env production' } },
-            },
+      targets: {
+        deploy: {
+          options: { command: 'echo no' },
+          configurations: {
+            staging: { command: 'wrangler deploy --env staging' },
+            production: { options: { command: 'wrangler deploy --env production' } },
           },
-          'package-macos': {},
         },
+        'package-macos': {},
       },
     },
   };
 
   it('collects target names from graph nodes without project names', () => {
-    expect(targetNamesFromProjects(sampleNodes).sort()).toEqual(
+    expect(targetNamesFromProjects(sampleProjects).sort()).toEqual(
       ['build', 'bundle-linux', 'deploy', 'lint', 'package-macos'].sort(),
     );
   });
 
   it('detects deploy configurations and cloudflare provider from graph nodes', () => {
-    expect(deployTargetInfoFromProjects(sampleNodes, 'staging')).toEqual({
+    expect(deployTargetInfoFromProjects(sampleProjects, 'staging')).toEqual({
       exists: true,
       provider: 'cloudflare',
     });
-    expect(deployTargetInfoFromProjects(sampleNodes, 'production')).toEqual({
+    expect(deployTargetInfoFromProjects(sampleProjects, 'production')).toEqual({
       exists: true,
       provider: 'cloudflare',
     });
-    expect(deployTargetInfoFromProjects(sampleNodes, 'preview')).toEqual({ exists: false });
+    expect(deployTargetInfoFromProjects(sampleProjects, 'preview')).toEqual({ exists: false });
+  });
+});
+
+describe('managed raw files', () => {
+  it('manages the devenv wrapper as an executable byte-exact copy', async () => {
+    expect(managedFileTargetsForTest).toContainEqual({ target: 'tooling/devenv', executable: true });
+
+    const [source, generated] = await Promise.all([
+      readFile(join(REPO_ROOT, 'packages', 'cli', 'managed', 'raw', 'tooling', 'devenv'), 'utf8'),
+      readFile(join(REPO_ROOT, 'tooling', 'devenv'), 'utf8'),
+    ]);
+
+    expect(generated).toBe(source);
   });
 });
 

package/src/monorepo/managed-files.ts

@@ -2,10 +2,9 @@ import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, writeFi
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PLATFORM_TARGET_GLOBS } from '@smoothbricks/nx-plugin/workspace-config-policy';
-// Nx package exports are CLI-oriented; this is the module the CLI uses for graph + daemon IPC.
-import { createProjectGraphAsync } from 'nx/src/project-graph/project-graph.js';
-import type { PackageJson } from '../lib/json.js';
+import type { NxTargetConfig, PackageJson } from '../lib/json.js';
 import { listReleasePackages, readPackageJson } from '../lib/workspace.js';
+import { loadNxProjects, type NxProjects, targetNamesFromProjects } from '../nx/index.js';
 import { renderCiWorkflowYaml } from './ci-workflow.js';
 import { renderPublishWorkflowYaml } from './publish-workflow.js';
 
@@ -155,6 +154,12 @@ const managedFiles: ManagedFile[] = [
     source: 'envrc',
     target: '.envrc',
   },
+  {
+    kind: 'raw',
+    source: 'tooling/devenv',
+    target: 'tooling/devenv',
+    executable: true,
+  },
   {
     kind: 'raw',
     source: 'tooling/direnv/repo-path',
@@ -201,11 +206,6 @@ const managedFiles: ManagedFile[] = [
     target: 'tooling/direnv/merge-newer-pins.sh',
     executable: true,
   },
-  {
-    kind: 'raw',
-    source: 'patches/ttsc@0.19.3.patch',
-    target: 'patches/ttsc@0.19.3.patch',
-  },
   {
     kind: 'generated',
     source: 'ci-workflow',
@@ -254,6 +254,8 @@ const managedFiles: ManagedFile[] = [
   },
 ];
 
+export const managedFileTargetsForTest = managedFiles.map(({ target, executable }) => ({ target, executable }));
+
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 export async function applyManagedFiles(root: string, mode: 'update' | 'check' | 'diff'): Promise<FileResult[]> {
@@ -337,7 +339,7 @@ async function getManagedFileContext(root: string): Promise<ManagedFileContext>
   const ciPushBranches = getCiPushBranches(packageJson?.json);
   const ciRunsOn = getCiRunsOn(packageJson?.json);
   // In-process Nx API → daemon socket (no second Node/`nx` CLI process).
-  const nxProjects = await loadNxGraphProjects(root);
+  const nxProjects = await loadNxProjects(root);
   const stagingDeploy = deployTargetInfoFromProjects(nxProjects, 'staging');
   const productionDeploy = deployTargetInfoFromProjects(nxProjects, 'production');
   const platformTargetGlobs = platformTargetGlobsForTest(targetNamesFromProjects(nxProjects));
@@ -366,67 +368,12 @@ export function platformTargetGlobsForTest(targetNames: Iterable<string>): strin
   });
 }
 
-/** Resolved Nx project node as returned under `graph.nodes` / project-graph.json. */
-export type NxGraphProjectNode = {
-  data?: { targets?: Record<string, NxGraphTarget> };
-  targets?: Record<string, NxGraphTarget>;
-};
-
-type NxGraphTarget = {
-  command?: string;
-  options?: { command?: string };
-  configurations?: Record<string, { command?: string; options?: { command?: string } }>;
-};
-
-/**
- * Load resolved project nodes via Nx's programmatic API.
- *
- * `createProjectGraphAsync` is what the CLI uses: with the daemon up it speaks the
- * daemon unix socket instead of rebuilding the graph in a fresh Node process.
- * Spawning `nx graph` / `nx show` only added CLI boot + plugin-worker overhead on
- * top of that. smoo runs under Bun; Bun can import this CJS module directly.
- */
-async function loadNxGraphProjects(root: string): Promise<Record<string, NxGraphProjectNode>> {
-  const prevCwd = process.cwd();
-  process.chdir(root);
-  try {
-    const graph = (await createProjectGraphAsync()) as {
-      nodes: Record<string, { data?: { targets?: Record<string, NxGraphTarget> } }>;
-    };
-    const out: Record<string, NxGraphProjectNode> = {};
-    for (const [name, node] of Object.entries(graph.nodes)) {
-      out[name] = { data: { targets: node.data?.targets ?? {} } };
-    }
-    return out;
-  } finally {
-    process.chdir(prevCwd);
-  }
-}
-
-function targetsOfProject(node: NxGraphProjectNode): Record<string, NxGraphTarget> {
-  return node.data?.targets ?? node.targets ?? {};
-}
-
-/** Test seam: collect target names from a graph.nodes map. */
-export function targetNamesFromProjects(nodes: Record<string, NxGraphProjectNode>): string[] {
-  const targetNames = new Set<string>();
-  for (const node of Object.values(nodes)) {
-    for (const name of Object.keys(targetsOfProject(node))) {
-      targetNames.add(name);
-    }
-  }
-  return [...targetNames];
-}
-
 /** Test seam: deploy configuration presence/provider from graph nodes. */
-export function deployTargetInfoFromProjects(
-  nodes: Record<string, NxGraphProjectNode>,
-  configuration: string,
-): DeployTargetInfo {
+export function deployTargetInfoFromProjects(projects: NxProjects, configuration: string): DeployTargetInfo {
   let exists = false;
   let provider: DeployTargetInfo['provider'];
-  for (const node of Object.values(nodes)) {
-    const info = deployTargetInfoFromTargets(targetsOfProject(node), configuration);
+  for (const project of Object.values(projects)) {
+    const info = deployTargetInfoFromTargets(project.targets ?? {}, configuration);
     if (!info.exists) {
       continue;
     }
@@ -436,7 +383,7 @@ export function deployTargetInfoFromProjects(
   return { exists, provider };
 }
 
-function deployTargetInfoFromTargets(targets: Record<string, NxGraphTarget>, configuration: string): DeployTargetInfo {
+function deployTargetInfoFromTargets(targets: Record<string, NxTargetConfig>, configuration: string): DeployTargetInfo {
   const deploy = targets.deploy;
   if (!deploy) {
     return { exists: false };

package/src/monorepo/package-policy.test.ts

@@ -11,6 +11,8 @@ import {
 
 const TIMEOUT_FLAG = `--timeout=${BOUNDED_TEST_PER_TEST_TIMEOUT_MS}`;
 
+import { validateCommitMessage } from './commit-msg.js';
+
 import {
   applyFixableMonorepoDefaults,
   applyNxPluginDefaults,
@@ -245,6 +247,35 @@ describe('Nx project name policy', () => {
       await rm(root, { recursive: true, force: true });
     }
   });
+
+  it('uses nx.name from an exact workspace package as the commit scope', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-package-policy-'));
+    try {
+      await writeJson(join(root, 'package.json'), {
+        name: '@smoothbricks/codebase',
+        version: '0.0.0',
+        private: true,
+        workspaces: ['tooling'],
+      });
+      await writeJson(join(root, 'tooling/package.json'), {
+        name: '@smoothbricks/internal-tooling',
+        private: true,
+        nx: { name: 'tooling' },
+      });
+
+      const validScopes = listValidCommitScopes(root);
+      expect(validScopes).toEqual(new Set(['release', 'tooling']));
+      expect(validateCommitMessage('fix(tooling): repair tooling\n', { validScopes })).toBeNull();
+      expect(validateCommitMessage('fix(internal-tooling): repair tooling\n', { validScopes })).toContain(
+        'Invalid conventional commit scope',
+      );
+      expect(validateCommitMessage('fix(arbitrary): repair tooling\n', { validScopes })).toContain(
+        'Invalid conventional commit scope',
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('workspace package script policy', () => {

package/src/monorepo/package-policy.ts

@@ -165,7 +165,7 @@ export function applyWorkspaceDependencyDefaults(root: string, options: PackageT
   } else {
     console.log('unchanged      tsconfig.test.json policy');
   }
-  if (applyWorkspaceBoundedTestTargetPolicy(root)) {
+  if (applyWorkspaceBoundedTestTargetPolicy(root, options)) {
     console.log('updated        package test targets bounded execution policy');
   } else {
     console.log('unchanged      package test targets bounded execution policy');
@@ -409,7 +409,7 @@ export function validateWorkspaceDependencies(root: string, options: PackageTarg
     console.error(`${issue.path}: ${issue.message}`);
     failures++;
   }
-  for (const issue of checkWorkspaceBoundedTestTargetPolicy(root)) {
+  for (const issue of checkWorkspaceBoundedTestTargetPolicy(root, options)) {
     console.error(`${issue.path}: ${issue.message}`);
     failures++;
   }

package/src/monorepo/packs/index.ts

@@ -414,10 +414,12 @@ export function resolvedTargetsByProject(projects: ProjectTargets[]): Map<string
     projects.map((project) => [
       project.project,
       {
+        ...(project.root ? { root: project.root } : {}),
         targets: new Set(project.targets),
         ...(project.buildDependsOn ? { buildDependsOn: project.buildDependsOn } : {}),
         ...(project.targetDependencies ? { targetDependencies: project.targetDependencies } : {}),
         ...(project.targetExecutors ? { targetExecutors: project.targetExecutors } : {}),
+        ...(project.targetOptions ? { targetOptions: project.targetOptions } : {}),
         ...(project.targetScripts ? { targetScripts: project.targetScripts } : {}),
       },
     ]),

package/src/monorepo/publish-workflow.ts

@@ -785,6 +785,11 @@ function renderMacosPlatformSteps(options: PublishWorkflowDefinitionOptions): st
     `          "${githubExpression('runner.temp')}/macos-platform-outputs"`,
     '',
     `      # Step ${stepNumber++}`,
+    '      - name: 🧪 Unit test macOS and iOS packages',
+    '        run:',
+    `          smoo github-ci nx-run-many --targets test --projects-with-targets "${MACOS_PLATFORM_TARGET_GLOBS.join(',')}"`,
+    '',
+    `      # Step ${stepNumber++}`,
     '      - name: 📤 Upload macOS platform outputs',
     '        uses: actions/upload-artifact@v7.0.1',
     '        with:',

package/src/monorepo/runtime.test.ts

@@ -3,16 +3,16 @@ import type { PackageJson } from '../lib/json.js';
 import { runtimeTypesRangeForPublishedVersions, validateRuntimePins } from './runtime.js';
 
 describe('runtimeTypesRangeForPublishedVersions', () => {
-  test('uses the newest published minor within the installed Node major, never the ~major.0.0 floor', () => {
+  test('anchors a caret range at the newest published version in the installed Node major', () => {
     expect(
       runtimeTypesRangeForPublishedVersions('@types/node', '24.12.0', 'major', ['24.0.0', '24.12.4', '25.9.1']),
-    ).toBe('~24.12.4');
+    ).toBe('^24.12.4');
   });
 
-  test('falls back to latest published @types/node when the Node major is unpublished', () => {
-    expect(
+  test('rejects fallback types from a different Node major', () => {
+    expect(() =>
       runtimeTypesRangeForPublishedVersions('@types/node', '26.0.0', 'major', ['24.12.4', '25.9.0', '25.9.1']),
-    ).toBe('~25.9.1');
+    ).toThrow('runtime major 26');
   });
 
   test('uses the installed Bun version when @types/bun has published it', () => {
@@ -23,10 +23,10 @@ describe('runtimeTypesRangeForPublishedVersions', () => {
     expect(runtimeTypesRangeForPublishedVersions('@types/bun', '1.3.15', 'exact', ['1.3.13', '1.3.14'])).toBe('1.3.14');
   });
 
-  test('ignores non-stable version strings when choosing the fallback', () => {
-    expect(runtimeTypesRangeForPublishedVersions('@types/node', '26.0.0', 'major', ['25.9.1', '26.0.0-beta.1'])).toBe(
-      '~25.9.1',
-    );
+  test('ignores non-stable version strings when choosing the same-major anchor', () => {
+    expect(
+      runtimeTypesRangeForPublishedVersions('@types/node', '26.0.0', 'major', ['25.9.1', '26.0.2', '26.1.0-beta.1']),
+    ).toBe('^26.0.2');
   });
 });
 
@@ -35,23 +35,29 @@ describe('validateRuntimePins', () => {
   const aligned = () => ({
     engines: { node: '>=24.0.0' },
     packageManager: 'bun@1.3.14',
-    devDependencies: { '@types/node': '~24.13.0' },
+    devDependencies: { '@types/node': '^24.13.0' },
   });
 
-  test('passes when every pin agrees with the PATH runtimes', () => {
-    expect(validateRuntimePins(aligned(), runtime)).toBe(0);
+  test('accepts caret ranges anchored at any patch or minor in the PATH Node major', () => {
+    for (const version of ['^24.0.3', '^24.13.0']) {
+      const pkg = aligned();
+      pkg.devDependencies['@types/node'] = version;
+      expect(validateRuntimePins(pkg, runtime)).toBe(0);
+    }
   });
 
   test('fails when @types/node tracks a different major than the PATH node', () => {
     const pkg = aligned();
-    pkg.devDependencies['@types/node'] = '~26.1.1';
+    pkg.devDependencies['@types/node'] = '^26.1.1';
     expect(validateRuntimePins(pkg, runtime)).toBe(1);
   });
 
-  test('fails the ~major.0.0 floor pin even when the major matches', () => {
-    const pkg = aligned();
-    pkg.devDependencies['@types/node'] = '~24.0.0';
-    expect(validateRuntimePins(pkg, runtime)).toBe(1);
+  test('rejects exact and tilde @types/node pins even when the major matches', () => {
+    for (const version of ['24.13.0', '~24.13.0']) {
+      const pkg = aligned();
+      pkg.devDependencies['@types/node'] = version;
+      expect(validateRuntimePins(pkg, runtime)).toBe(1);
+    }
   });
 
   test('fails engines.node and packageManager drift against the PATH runtimes', () => {

package/src/monorepo/runtime.ts

@@ -66,8 +66,8 @@ export async function syncRootRuntimeVersions(root: string): Promise<void> {
 /**
  * Validate that package.json runtime pins agree with the LIVE PATH runtimes,
  * never a stored template. Offline by design: structural alignment only
- * (majors, exact bun pin, no `~major.0.0` floor) — the registry is not
- * consulted. Repair: `smoo monorepo init --runtime-only` inside the devenv shell.
+ * (Node types float within the runtime major; Bun types stay exact) — the registry
+ * is not consulted. Repair: `smoo monorepo init --runtime-only` inside the devenv shell.
  */
 export async function validateRootRuntimeVersions(root: string): Promise<number> {
   const packageJson = readJsonObject(join(root, 'package.json'));
@@ -100,15 +100,10 @@ export function validateRuntimePins(packageJson: PackageJson, runtime: RuntimeVe
     failures++;
   }
   const typesNode = packageJson.devDependencies?.['@types/node'] ?? null;
-  const typesNodeParts = typesNode ? /^~(\d+)\.(\d+)\.(\d+)$/.exec(typesNode) : null;
+  const typesNodeParts = typesNode ? /^\^(\d+)\.(\d+)\.(\d+)$/.exec(typesNode) : null;
   if (!typesNodeParts || typesNodeParts[1] !== nodeMajor) {
     console.error(
-      `package.json @types/node is ${typesNode ?? 'missing'} but the PATH node is v${runtime.node} — types track the runtime major (~${nodeMajor}.x.y, newest published minor); ${repair}`,
-    );
-    failures++;
-  } else if (typesNodeParts[2] === '0' && typesNodeParts[3] === '0') {
-    console.error(
-      `package.json @types/node is pinned to the ~${nodeMajor}.0.0 floor — tilde locks the first patch line and strands the repo on early broken releases; ${repair} to repin to the newest published ${nodeMajor}.x`,
+      `package.json @types/node is ${typesNode ?? 'missing'} but the PATH node is v${runtime.node} — expected a caret range within the runtime major (^${nodeMajor}.x.y); ${repair}`,
     );
     failures++;
   }
@@ -144,15 +139,15 @@ export function runtimeTypesRangeForPublishedVersions(
 
   if (pinMode === 'major') {
     const runtimeMajor = parsedRuntimeVersion[0].toString();
-    // Newest published types WITHIN the runtime major — never the `~major.0.0`
-    // floor: tilde locks the patch line, so the floor can strand consumers on a
-    // broken early release (e.g. @types/node 24.0.x's URLPattern/DOM TS2403
-    // conflict, fixed in 24.13) with no path to the repaired minors.
+    // Anchor the range at the newest published types in the runtime major. The caret
+    // admits later patches and minors without crossing into a different Node major.
     const latestInMajor = latestVersion(versions.filter((version) => versionMajor(version) === runtimeMajor));
-    if (latestInMajor) {
-      return `~${latestInMajor}`;
+    if (!latestInMajor) {
+      throw new Error(`Unable to find published ${packageName} versions for runtime major ${runtimeMajor}`);
     }
-  } else if (versions.includes(runtimeVersion)) {
+    return `^${latestInMajor}`;
+  }
+  if (versions.includes(runtimeVersion)) {
     return runtimeVersion;
   }
 
@@ -162,7 +157,7 @@ export function runtimeTypesRangeForPublishedVersions(
   }
 
   console.warn(`${packageName} has no published types for runtime ${runtimeVersion}; using ${latest}`);
-  return pinMode === 'major' ? `~${latest}` : latest;
+  return latest;
 }
 
 function latestVersion(versions: readonly string[]): string | null {

package/src/monorepo/tool-validation.test.ts

@@ -19,7 +19,7 @@ const registryVersions: Record<string, string[]> = {
   'eslint-stdout': ['1.1.1', '1.1.2'],
   nx: ['23.1.0'],
   prettier: ['3.6.1'],
-  ttsc: ['0.19.3'],
+  ttsc: ['0.25.0'],
   typescript: ['6.0.3'],
   // alias package is not fetched from registry under this name when using fallback
   '@typescript/native': ['7.0.2'],
@@ -50,6 +50,9 @@ describe('tool configuration validation', () => {
         devDependencies: {
           '@smoothbricks/cli': 'workspace:*',
         },
+        patchedDependencies: {
+          'ttsc@0.19.3': 'patches/ttsc@0.19.3.patch',
+        },
       });
       const devenvPath = join(root, 'tooling/direnv/devenv.nix');
       await mkdir(dirname(devenvPath), { recursive: true });
@@ -76,10 +79,10 @@ describe('tool configuration validation', () => {
       expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe('workspace:*');
       expect(rootPackage.devDependencies['eslint-stdout']).toBe('workspace:*');
       expect(rootPackage.devDependencies.nx).toBe('23.1.0');
-      expect(rootPackage.devDependencies.ttsc).toBe('0.19.3');
+      expect(rootPackage.devDependencies.ttsc).toBe('0.25.0');
       expect(rootPackage.devDependencies.typescript).toBe('^6.0.3');
       expect(rootPackage.devDependencies['@typescript/native']).toBe('npm:typescript@^7.0.2');
-      expect(rootPackage.patchedDependencies['ttsc@0.19.3']).toBe('patches/ttsc@0.19.3.patch');
+      expect(rootPackage.patchedDependencies?.['ttsc@0.19.3']).toBeUndefined();
       expect(rootPackage.workspaces).toContain('tooling');
       expect(toolingPackage.name).toBe('@smoothbricks/tooling');
       expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe('workspace:*');
@@ -91,7 +94,7 @@ describe('tool configuration validation', () => {
     }
   });
 
-  it('accepts newer dependency versions above the policy floor', async () => {
+  it('accepts newer dependencies after removing even an empty obsolete ttsc patch key', async () => {
     const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
     try {
       await writeJson(join(root, 'package.json'), {
@@ -108,12 +111,12 @@ describe('tool configuration validation', () => {
           'eslint-stdout': await currentEslintStdoutRange(),
           nx: '24.0.0',
           prettier: '^3.7.0',
-          ttsc: '0.19.3',
+          ttsc: '0.25.0',
           typescript: '^6.0.0',
           '@typescript/native': 'npm:typescript@^7.0.2',
         },
         patchedDependencies: {
-          'ttsc@0.19.3': 'patches/ttsc@0.19.3.patch',
+          'ttsc@0.19.3': '',
         },
       });
       await writeJson(join(root, 'tooling/package.json'), {
@@ -143,7 +146,11 @@ describe('tool configuration validation', () => {
 `,
       );
 
+      expect(await validateToolConfig(root)).toBe(1);
+      await applyToolConfigDefaults(root);
       expect(await validateToolConfig(root)).toBe(0);
+      const rootPackage = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+      expect(rootPackage.patchedDependencies?.['ttsc@0.19.3']).toBeUndefined();
     } finally {
       await rm(root, { recursive: true, force: true });
     }
@@ -210,7 +217,7 @@ describe('tool configuration validation', () => {
           eslint: '^10.0.0',
           nx: '24.0.0',
           prettier: '^3.7.0',
-          ttsc: '0.19.3',
+          ttsc: '0.25.0',
           typescript: '^6.0.0',
         },
       });
@@ -224,7 +231,7 @@ describe('tool configuration validation', () => {
       expect(rootPackage.devDependencies['eslint-stdout']).toBe(await currentEslintStdoutRange());
       expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe(await currentNxPluginRange());
       expect(rootPackage.devDependencies['@typescript/native']).toBe('npm:typescript@^7.0.2');
-      expect(rootPackage.patchedDependencies?.['ttsc@0.19.3']).toBe('patches/ttsc@0.19.3.patch');
+      expect(rootPackage.patchedDependencies?.['ttsc@0.19.3']).toBeUndefined();
       expect(toolingPackage.name).toBe('@fixture/tooling');
       expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe(await currentCliRange());
     } finally {

package/src/monorepo/tool-validation.ts

@@ -56,8 +56,7 @@ const rootDevDependencies: RequiredDependency[] = [
   },
   { name: 'nx', fallbackVersion: '23.1.0', minimumVersion: '23.1.0' },
   { name: 'prettier', fallbackVersion: '^3.6.1', minimumVersion: '3.6.0', prefix: '^' },
-  // Exact pin: Bun patchedDependencies keys are version-locked (see patches/ttsc@0.19.3.patch).
-  { name: 'ttsc', fallbackVersion: '0.19.3' },
+  { name: 'ttsc', fallbackVersion: '0.25.0' },
   // Nx and typescript-eslint still load the TypeScript JS API (6.x).
   // Compilation is exclusively delegated to ttsc by the Nx plugin targets.
   { name: 'typescript', fallbackVersion: '^6.0.3', minimumVersion: '6.0.0', prefix: '^' },
@@ -75,8 +74,7 @@ const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejan
 // never against a version template here.
 const nodePackagePattern = /(^|\s)nodejs(_\d+|_latest)?(\s|#|$)/m;
 
-const TTSC_PATCHED_DEPENDENCY_KEY = 'ttsc@0.19.3';
-const TTSC_PATCH_PATH = 'patches/ttsc@0.19.3.patch';
+const obsoleteTtscPatchedDependencyKey = 'ttsc@0.19.3';
 
 export async function applyToolConfigDefaults(root: string): Promise<void> {
   const context = await readToolContext(root);
@@ -89,7 +87,7 @@ export async function validateToolConfig(root: string): Promise<number> {
   const context = await readToolContext(root);
   return (
     validateRootDevDependencies(context.policy, context.rootPackage) +
-    validateTtscPatchedDependency(context.rootPackage) +
+    validateObsoleteTtscPatchRemoved(context.rootPackage) +
     validateToolingPackage(root, context.policy) +
     validateToolingWorkspace(context.rootPackage) +
     validateDevenvPackages(root)
@@ -113,7 +111,7 @@ export async function applyRootDevDependencyDefaults(root: string, context: Tool
   if (delete devDependencies['@smoothbricks/cli']) {
     changed = true;
   }
-  changed = ensureTtscPatchedDependency(pkg) || changed;
+  changed = removeObsoleteTtscPatch(pkg) || changed;
   if (changed) {
     writeJsonObject(join(root, 'package.json'), pkg);
     console.log('updated        package.json workspace tool dependencies');
@@ -129,7 +127,6 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
   }
   let dependencyChanged = false;
   let workspaceChanged = false;
-  let patchChanged = false;
   const devDependencies = ensureDependencyMap(pkg, 'devDependencies');
   for (const dependency of rootDevDependencies) {
     const current = devDependencies[dependency.name];
@@ -142,8 +139,8 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
     dependencyChanged = true;
   }
   workspaceChanged = addWorkspacePattern(pkg, 'tooling');
-  patchChanged = ensureTtscPatchedDependency(pkg);
-  if (dependencyChanged || workspaceChanged || patchChanged) {
+  dependencyChanged = removeObsoleteTtscPatch(pkg) || dependencyChanged;
+  if (dependencyChanged || workspaceChanged) {
     writeJsonObject(join(root, 'package.json'), pkg);
   }
   console.log(
@@ -156,11 +153,6 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
       ? 'updated        package.json tooling workspace'
       : 'unchanged      package.json tooling workspace',
   );
-  console.log(
-    patchChanged
-      ? 'updated        package.json patchedDependencies for ttsc'
-      : 'unchanged      package.json patchedDependencies for ttsc',
-  );
 }
 
 export function applyToolingPackageDefaults(root: string, policy: ToolPolicy): void {
@@ -252,22 +244,25 @@ export function validateRootDevDependencies(policy: ToolPolicy, rootPackage: Pac
   return failures;
 }
 
-function ensureTtscPatchedDependency(pkg: PackageJson): boolean {
-  const patched = ensureDependencyMap(pkg, 'patchedDependencies');
-  return setStringProperty(patched, TTSC_PATCHED_DEPENDENCY_KEY, TTSC_PATCH_PATH);
+function removeObsoleteTtscPatch(pkg: PackageJson): boolean {
+  const patchedDependencies = pkg.patchedDependencies;
+  if (!patchedDependencies || !(obsoleteTtscPatchedDependencyKey in patchedDependencies)) {
+    return false;
+  }
+  delete patchedDependencies[obsoleteTtscPatchedDependencyKey];
+  if (Object.keys(patchedDependencies).length === 0) {
+    delete pkg.patchedDependencies;
+  }
+  return true;
 }
 
-function validateTtscPatchedDependency(rootPackage: PackageJson | null): number {
-  if (!rootPackage) {
-    return 0;
-  }
-  const actual = rootPackage.patchedDependencies?.[TTSC_PATCHED_DEPENDENCY_KEY];
-  if (actual === TTSC_PATCH_PATH) {
+function validateObsoleteTtscPatchRemoved(rootPackage: PackageJson | null): number {
+  const patchedDependencies = rootPackage?.patchedDependencies;
+  if (!patchedDependencies || !(obsoleteTtscPatchedDependencyKey in patchedDependencies)) {
     return 0;
   }
   console.error(
-    `package.json patchedDependencies.${TTSC_PATCHED_DEPENDENCY_KEY} must be ${TTSC_PATCH_PATH}` +
-      (typeof actual === 'string' ? `; found ${actual}` : ' (required for declaration-emit fix)'),
+    `package.json patchedDependencies.${obsoleteTtscPatchedDependencyKey} must be removed; ttsc 0.25.0 emits typia declarations without the obsolete patch`,
   );
   return 1;
 }