@smoothbricks/cli 0.10.2 → 0.10.4

package/src/monorepo/runtime.ts

@@ -1,7 +1,31 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { $ } from 'bun';
-import { getOrCreateRecord, readJsonObject, setStringProperty, writeJsonObject } from '../lib/json.js';
+import {
+  ensureDependencyMap,
+  ensureEngines,
+  type PackageJson,
+  parseStringArrayText,
+  readJsonObject,
+  setPackageStringField,
+  setStringProperty,
+  writeJsonObject,
+} from '../lib/json.js';
+
+export interface RuntimeVersions {
+  node: string;
+  bun: string;
+}
+
+/** Live runtime versions from the shell PATH — the single source sync AND validate derive from. */
+export async function runtimeVersionsFromPath(root: string): Promise<RuntimeVersions> {
+  const node = runtimeCommand(root, 'node');
+  const bun = runtimeCommand(root, 'bun');
+  return {
+    node: (await $`${node} --version`.cwd(root).text()).trim().replace(/^v/, ''),
+    bun: (await $`${bun} --version`.cwd(root).text()).trim(),
+  };
+}
 
 export async function syncRootRuntimeVersions(root: string): Promise<void> {
   const packageJsonPath = join(root, 'package.json');
@@ -9,20 +33,17 @@ export async function syncRootRuntimeVersions(root: string): Promise<void> {
   if (!packageJson) {
     throw new Error('package.json not found or invalid');
   }
-  const node = runtimeCommand(root, 'node');
-  const bun = runtimeCommand(root, 'bun');
-  const nodeVersion = (await $`${node} --version`.cwd(root).text()).trim().replace(/^v/, '');
-  const bunVersion = (await $`${bun} --version`.cwd(root).text()).trim();
+  const { node: nodeVersion, bun: bunVersion } = await runtimeVersionsFromPath(root);
   const nodeMajor = nodeVersion.split('.', 1)[0];
   if (!nodeMajor) {
     throw new Error(`Unable to derive Node major version from ${nodeVersion}`);
   }
 
   let changed = false;
-  const engines = getOrCreateRecord(packageJson, 'engines');
+  const engines = ensureEngines(packageJson);
   changed = setStringProperty(engines, 'node', `>=${nodeMajor}.0.0`) || changed;
-  changed = setStringProperty(packageJson, 'packageManager', `bun@${bunVersion}`) || changed;
-  const devDependencies = getOrCreateRecord(packageJson, 'devDependencies');
+  changed = setPackageStringField(packageJson, 'packageManager', `bun@${bunVersion}`) || changed;
+  const devDependencies = ensureDependencyMap(packageJson, 'devDependencies');
   changed =
     setStringProperty(
       devDependencies,
@@ -42,6 +63,58 @@ 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.
+ */
+export async function validateRootRuntimeVersions(root: string): Promise<number> {
+  const packageJson = readJsonObject(join(root, 'package.json'));
+  if (!packageJson) {
+    console.error('package.json not found or invalid');
+    return 1;
+  }
+  return validateRuntimePins(packageJson, await runtimeVersionsFromPath(root));
+}
+
+export function validateRuntimePins(packageJson: PackageJson, runtime: RuntimeVersions): number {
+  const nodeMajor = runtime.node.split('.', 1)[0];
+  if (!nodeMajor) {
+    throw new Error(`Unable to derive Node major version from ${runtime.node}`);
+  }
+  let failures = 0;
+  const repair = 'run `smoo monorepo init --runtime-only` inside the devenv shell';
+  const enginesNode = packageJson.engines?.node ?? null;
+  if (enginesNode !== `>=${nodeMajor}.0.0`) {
+    console.error(
+      `package.json engines.node is ${enginesNode ?? 'missing'} but the PATH node is v${runtime.node} — expected >=${nodeMajor}.0.0; ${repair}`,
+    );
+    failures++;
+  }
+  const packageManager = packageJson.packageManager ?? null;
+  if (packageManager !== `bun@${runtime.bun}`) {
+    console.error(
+      `package.json packageManager is ${packageManager ?? 'missing'} but the PATH bun is ${runtime.bun} — expected bun@${runtime.bun}; ${repair}`,
+    );
+    failures++;
+  }
+  const typesNode = packageJson.devDependencies?.['@types/node'] ?? 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`,
+    );
+    failures++;
+  }
+  return failures;
+}
+
 type RuntimeTypesPinMode = 'major' | 'exact';
 
 async function runtimeTypesRange(
@@ -51,8 +124,8 @@ async function runtimeTypesRange(
   pinMode: RuntimeTypesPinMode,
 ): Promise<string> {
   const versionsText = await $`bun pm view ${packageName} versions --json`.cwd(root).text();
-  const versions = JSON.parse(versionsText) as unknown;
-  if (!Array.isArray(versions) || !versions.every((version) => typeof version === 'string')) {
+  const versions = parseStringArrayText(versionsText);
+  if (!versions) {
     throw new Error(`Unable to read published ${packageName} versions`);
   }
   return runtimeTypesRangeForPublishedVersions(packageName, runtimeVersion, pinMode, versions);
@@ -71,8 +144,13 @@ export function runtimeTypesRangeForPublishedVersions(
 
   if (pinMode === 'major') {
     const runtimeMajor = parsedRuntimeVersion[0].toString();
-    if (latestVersion(versions.filter((version) => versionMajor(version) === runtimeMajor))) {
-      return `~${runtimeMajor}.0.0`;
+    // 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.
+    const latestInMajor = latestVersion(versions.filter((version) => versionMajor(version) === runtimeMajor));
+    if (latestInMajor) {
+      return `~${latestInMajor}`;
     }
   } else if (versions.includes(runtimeVersion)) {
     return runtimeVersion;

package/src/monorepo/tool-validation.ts

@@ -1,7 +1,14 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import typia from 'typia';
 import { cliPackageVersion, isSmoothBricksCodebasePackageName } from '../lib/cli-package.js';
-import { getOrCreateRecord, readJsonObject, recordProperty, setStringProperty, writeJsonObject } from '../lib/json.js';
+import {
+  ensureDependencyMap,
+  readJsonObject,
+  setPackageStringField,
+  setStringProperty,
+  writeJsonObject,
+} from '../lib/json.js';
 import { type PackageJson, readPackageJsonObject } from '../lib/workspace.js';
 
 interface RequiredDependency {
@@ -23,6 +30,11 @@ export interface ToolContext {
   policy: ToolPolicy;
 }
 
+interface RegistryPackument {
+  versions: Record<string, unknown>;
+}
+
+const isRegistryPackument = typia.createIs<RegistryPackument>();
 const rootDevDependencies: RequiredDependency[] = [
   { name: '@biomejs/biome', fallbackVersion: '^2.3.5', minimumVersion: '2.3.0', prefix: '^' },
   { name: '@nx/js', fallbackVersion: '23.1.0', minimumVersion: '23.1.0' },
@@ -44,7 +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: '^' },
   { name: 'ttsc', fallbackVersion: '^0.18.4', minimumVersion: '0.18.4', prefix: '^' },
-  // Nx and typescript-eslint still load the TypeScript 5.x JavaScript API.
+  // 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: '^5.9.3', minimumVersion: '5.9.0', prefix: '^' },
 ];
@@ -52,7 +64,11 @@ const rootDevDependencies: RequiredDependency[] = [
 const cliPackageName = '@smoothbricks/cli';
 
 const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejandra', 'coreutils', 'gnutar'];
-const allowedNodePackages = ['nodejs_24', 'nodejs_latest'];
+// Any explicit nodejs provider is fine — the pinned major is the repo's choice
+// (Lambda parity, org convergence, …). Whether the pins in package.json agree
+// with the runtime is validated against the live PATH (validateRootRuntimeVersions),
+// never against a version template here.
+const nodePackagePattern = /(^|\s)nodejs(_\d+|_latest)?(\s|#|$)/m;
 
 export async function applyToolConfigDefaults(root: string): Promise<void> {
   const context = readToolContext(root);
@@ -77,7 +93,7 @@ export async function applyRootDevDependencyDefaults(root: string, context: Tool
     return;
   }
   let changed = false;
-  const devDependencies = getOrCreateRecord(pkg, 'devDependencies');
+  const devDependencies = ensureDependencyMap(pkg, 'devDependencies');
   for (const dependency of rootDevDependencies) {
     const current = devDependencies[dependency.name];
     if (typeof current !== 'string' || !satisfiesDependencyPolicy(context.policy, current, dependency)) {
@@ -103,7 +119,7 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
   }
   let dependencyChanged = false;
   let workspaceChanged = false;
-  const devDependencies = getOrCreateRecord(pkg, 'devDependencies');
+  const devDependencies = ensureDependencyMap(pkg, 'devDependencies');
   for (const dependency of rootDevDependencies) {
     const current = devDependencies[dependency.name];
     if (typeof current !== 'string' || !satisfiesDependencyPolicy(context.policy, current, dependency)) {
@@ -134,12 +150,12 @@ export function applyToolingPackageDefaults(root: string, policy: ToolPolicy): v
   const path = join(root, 'tooling', 'package.json');
   const pkg = readJsonObject(path) ?? { name: policy.toolingPackageName, private: true, dependencies: {} };
   let changed = false;
-  changed = setStringProperty(pkg, 'name', policy.toolingPackageName) || changed;
+  changed = setPackageStringField(pkg, 'name', policy.toolingPackageName) || changed;
   if (pkg.private !== true) {
     pkg.private = true;
     changed = true;
   }
-  const dependencies = getOrCreateRecord(pkg, 'dependencies');
+  const dependencies = ensureDependencyMap(pkg, 'dependencies');
   changed = setStringProperty(dependencies, cliPackageName, policy.cliDependencyRange) || changed;
   if (changed || !existsSync(path)) {
     mkdirSync(dirname(path), { recursive: true });
@@ -171,7 +187,7 @@ export function applyDevenvPackageDefaults(root: string): void {
   }
   let content = readFileSync(path, 'utf8');
   let changed = false;
-  if (!allowedNodePackages.some((name) => hasNixPackage(content, name))) {
+  if (!nodePackagePattern.test(content)) {
     const next = addNixPackage(content, 'nodejs_latest', '# Node.js for workspace tooling');
     changed = next !== content || changed;
     content = next;
@@ -198,7 +214,7 @@ export function validateRootDevDependencies(policy: ToolPolicy, rootPackage: Pac
     console.error('package.json not found or invalid');
     return 1;
   }
-  const devDependencies = recordProperty(pkg, 'devDependencies');
+  const devDependencies = pkg.devDependencies;
   let failures = 0;
   for (const dependency of rootDevDependencies) {
     const version = devDependencies?.[dependency.name];
@@ -226,9 +242,9 @@ export function validateToolingPackage(root: string, policy: ToolPolicy): number
     console.error('tooling/package.json not found or invalid');
     return 1;
   }
-  const dependencies = recordProperty(pkg, 'dependencies');
+  const dependencies = pkg.dependencies;
   let failures = 0;
-  const actualName = typeof pkg.name === 'string' ? pkg.name : null;
+  const actualName = pkg.name ?? null;
   if (actualName !== policy.toolingPackageName) {
     console.error(`tooling/package.json name must be ${policy.toolingPackageName}`);
     failures++;
@@ -262,8 +278,10 @@ export function validateDevenvPackages(root: string): number {
   }
   const content = readFileSync(path, 'utf8');
   let failures = 0;
-  if (!allowedNodePackages.some((name) => hasNixPackage(content, name))) {
-    console.error(`tooling/direnv/devenv.nix packages must include ${allowedNodePackages.join(' or ')}`);
+  if (!nodePackagePattern.test(content)) {
+    console.error(
+      'tooling/direnv/devenv.nix packages must include a nodejs provider (nodejs_<major> or nodejs_latest)',
+    );
     failures++;
   }
   for (const name of requiredDevenvPackages) {
@@ -334,7 +352,7 @@ function formatExpectedDependency(policy: ToolPolicy, dependency: RequiredDepend
 export function readToolContext(root: string): ToolContext {
   const rootPackage = readPackageJsonObject(join(root, 'package.json'));
   const toolingPackage = readJsonObject(join(root, 'tooling', 'package.json'));
-  const configuredCliRange = recordProperty(toolingPackage ?? {}, 'dependencies')?.[cliPackageName];
+  const configuredCliRange = toolingPackage?.dependencies?.[cliPackageName];
   return {
     rootPackage,
     policy: toolPolicy(rootPackage, typeof configuredCliRange === 'string' ? configuredCliRange : null),
@@ -342,7 +360,7 @@ export function readToolContext(root: string): ToolContext {
 }
 
 function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): ToolPolicy {
-  const name = typeof rootPackage?.name === 'string' ? rootPackage.name : null;
+  const name = rootPackage?.name ?? null;
   const isCodebase = isSmoothBricksCodebasePackageName(name ?? undefined);
   const toolingName = toolingPackageName(name);
   // A locally linked prerelease can be newer than every published CLI. Keep an existing
@@ -435,14 +453,6 @@ function compareVersions(left: Version, right: Version): number {
   return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
 }
 
-function isRegistryPackument(value: unknown): value is { versions: Record<string, unknown> } {
-  return typeof value === 'object' && value !== null && 'versions' in value && isObjectRecord(value.versions);
-}
-
-function isObjectRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 function stripRangePrefix(version: string): string {
   return version.replace(/^[~^]/, '');
 }
@@ -456,7 +466,7 @@ function addWorkspacePattern(pkg: PackageJson, pattern: string): boolean {
     workspaces.push(pattern);
     return true;
   }
-  if (isObjectRecord(workspaces) && Array.isArray(workspaces.packages)) {
+  if (workspaces && Array.isArray(workspaces.packages)) {
     if (workspaces.packages.includes(pattern)) {
       return false;
     }
@@ -472,5 +482,5 @@ function hasWorkspacePattern(pkg: PackageJson, pattern: string): boolean {
   if (Array.isArray(workspaces)) {
     return workspaces.includes(pattern);
   }
-  return isObjectRecord(workspaces) && Array.isArray(workspaces.packages) && workspaces.packages.includes(pattern);
+  return Boolean(workspaces && Array.isArray(workspaces.packages) && workspaces.packages.includes(pattern));
 }

package/src/monorepo/wrangler.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it, spyOn } from 'bun:test';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { type PackageJson, parsePackageJsonText } from '../lib/json.js';
 import { applyWranglerDefaults, firstWranglerEnv, validateWrangler } from './wrangler.js';
 
 describe('firstWranglerEnv', () => {
@@ -42,7 +43,7 @@ describe('applyWranglerDefaults', () => {
         },
       });
       const typecheck = nxTargets(pkg).typecheck;
-      expect(isRecord(typecheck) ? typecheck.dependsOn : null).toEqual(['^build', 'wrangler-types']);
+      expect(typecheck?.dependsOn ?? null).toEqual(['^build', 'wrangler-types']);
 
       const logs = captureConsoleLogs();
       applyWranglerDefaults(root);
@@ -63,8 +64,7 @@ describe('applyWranglerDefaults', () => {
     try {
       applyWranglerDefaults(root);
       const target = nxTargets(await readJson(join(root, 'packages/api/package.json')))['wrangler-types'];
-      const options = isRecord(target) ? target.options : null;
-      expect(isRecord(options) ? options.command : null).toBe(
+      expect(target?.options?.command ?? null).toBe(
         'wrangler types --env-file .dev.vars.example --include-runtime false',
       );
     } finally {
@@ -187,27 +187,23 @@ async function createWorkspace(
   return root;
 }
 
-function nxTargets(pkg: Record<string, unknown>): Record<string, unknown> {
-  const nx = pkg.nx;
-  if (!isRecord(nx) || !isRecord(nx.targets)) {
+function nxTargets(pkg: PackageJson): NonNullable<NonNullable<PackageJson['nx']>['targets']> {
+  const targets = pkg.nx?.targets;
+  if (!targets) {
     throw new Error('nx.targets not found');
   }
-  return nx.targets;
+  return targets;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-async function readJson(path: string): Promise<Record<string, unknown>> {
-  const parsed: unknown = JSON.parse(await readFile(path, 'utf8'));
-  if (!isRecord(parsed)) {
+async function readJson(path: string): Promise<PackageJson> {
+  const parsed = parsePackageJsonText(await readFile(path, 'utf8'));
+  if (!parsed) {
     throw new Error('expected JSON object');
   }
   return parsed;
 }
 
-async function writeJson(path: string, value: Record<string, unknown>): Promise<void> {
+async function writeJson(path: string, value: PackageJson): Promise<void> {
   await mkdir(join(path, '..'), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
 }

package/src/monorepo/wrangler.ts

@@ -1,13 +1,13 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { getOrCreateRecord, recordProperty, writeJsonObject } from '../lib/json.js';
+import { join } from 'node:path';
+import { ensureNx, ensureNxTargets, type NxTargetConfig, type PackageJson, writeJsonObject } from '../lib/json.js';
 import { getWorkspacePackageManifests } from '../lib/workspace.js';
 
 interface WranglerProject {
   label: string;
   dir: string;
   packageJsonPath: string;
-  json: Record<string, unknown>;
+  json: PackageJson;
   tomlPath: string;
 }
 
@@ -20,13 +20,14 @@ export function firstWranglerEnv(tomlText: string): string | null {
 function wranglerProjects(root: string): WranglerProject[] {
   const projects: WranglerProject[] = [];
   for (const pkg of getWorkspacePackageManifests(root)) {
-    const tomlPath = join(pkg.path, 'wrangler.toml');
+    const dir = join(root, pkg.path);
+    const tomlPath = join(dir, 'wrangler.toml');
     if (!existsSync(tomlPath)) {
       continue;
     }
     projects.push({
-      label: relative(root, pkg.path) || '.',
-      dir: pkg.path,
+      label: pkg.path || '.',
+      dir,
       packageJsonPath: pkg.packageJsonPath,
       json: pkg.json,
       tomlPath,
@@ -56,9 +57,9 @@ export function applyWranglerDefaults(root: string): void {
   }
   for (const project of projects) {
     const env = firstWranglerEnv(readFileSync(project.tomlPath, 'utf8'));
-    const nx = getOrCreateRecord(project.json, 'nx');
-    const targets = getOrCreateRecord(nx, 'targets');
-    const desired: Record<string, unknown> = {
+    const nx = ensureNx(project.json);
+    const targets = ensureNxTargets(nx);
+    const desired: NxTargetConfig = {
       executor: 'nx:run-commands',
       cache: true,
       inputs: ['{projectRoot}/wrangler.toml', '{projectRoot}/.dev.vars.example'],
@@ -69,14 +70,14 @@ export function applyWranglerDefaults(root: string): void {
       },
     };
     let changed = false;
-    const existing = recordProperty(targets, 'wrangler-types');
+    const existing = targets['wrangler-types'];
     if (!existing || JSON.stringify(existing) !== JSON.stringify(desired)) {
       targets['wrangler-types'] = desired;
       changed = true;
     }
-    const typecheck = recordProperty(targets, 'typecheck');
+    const typecheck = targets.typecheck;
     if (typecheck) {
-      const dependsOn: unknown[] = Array.isArray(typecheck.dependsOn) ? typecheck.dependsOn : [];
+      const dependsOn = Array.isArray(typecheck.dependsOn) ? [...typecheck.dependsOn] : [];
       if (!dependsOn.includes('wrangler-types')) {
         dependsOn.push('wrangler-types');
         typecheck.dependsOn = dependsOn;
@@ -116,9 +117,8 @@ export function validateWrangler(root: string): number {
       console.log(`⨯ ${project.label}: missing .dev.vars.example`);
       projectProblems++;
     }
-    const nx = recordProperty(project.json, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets || !recordProperty(targets, 'wrangler-types')) {
+    const targets = project.json.nx?.targets;
+    if (!targets?.['wrangler-types']) {
       console.log(`⨯ ${project.label}: missing wrangler-types nx target`);
       projectProblems++;
     }

package/src/nx/index.test.ts

@@ -7,7 +7,10 @@ import {
   nxShowProjectCommand,
   projectNamesFromNxShowProjectsOutput,
   projectNamesWithTarget,
+  projectRootFromNxProjectJson,
+  targetDependenciesFromNxProjectJson,
   targetNamesFromNxProjectJson,
+  targetOutputsFromNxProjectJson,
 } from './index.js';
 
 describe('Nx helper command construction', () => {
@@ -67,6 +70,46 @@ describe('Nx helper output formatting', () => {
     ]);
   });
 
+  it('extracts resolved roots, output declarations, and same-project target dependencies', () => {
+    const metadata = {
+      root: 'packages/native',
+      targets: {
+        'build-macos': {
+          outputs: ['{projectRoot}/dist/*.dmg'],
+          dependsOn: ['^build', 'compile-macos', { target: 'package-macos', projects: 'self' }],
+        },
+        test: { outputs: [] },
+      },
+    };
+
+    expect(projectRootFromNxProjectJson(metadata)).toBe('packages/native');
+    expect(targetOutputsFromNxProjectJson(metadata)).toEqual(
+      new Map([
+        ['build-macos', ['{projectRoot}/dist/*.dmg']],
+        ['test', []],
+      ]),
+    );
+    expect(targetDependenciesFromNxProjectJson(metadata)).toEqual(
+      new Map([['build-macos', ['^build', 'compile-macos', 'package-macos']]]),
+    );
+  });
+
+  it('omits cross-project dependencies from same-project target closures', () => {
+    expect(
+      targetDependenciesFromNxProjectJson({
+        targets: {
+          'rust-wasm': {
+            dependsOn: [
+              'prepare',
+              { target: 'cargo-wasm', projects: ['lmao-rs'] },
+              { target: 'build', projects: 'dependencies' },
+            ],
+          },
+        },
+      }),
+    ).toEqual(new Map([['rust-wasm', ['prepare']]]));
+  });
+
   it('treats missing target metadata as an empty project', () => {
     expect(targetNamesFromNxProjectJson({ name: 'cli' })).toEqual([]);
   });