@smoothbricks/cli 0.10.3 → 0.10.5

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,12 @@ export interface ToolContext {
   policy: ToolPolicy;
 }
 
+interface RegistryPackument {
+  versions: Record<string, unknown>;
+  'dist-tags'?: Record<string, string>;
+}
+
+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' },
@@ -43,28 +56,40 @@ 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.
+  // Exact pin: Bun patchedDependencies keys are version-locked (see patches/ttsc@0.19.3.patch).
+  { name: 'ttsc', fallbackVersion: '0.19.3' },
+  // 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: '^' },
+  { name: 'typescript', fallbackVersion: '^6.0.3', minimumVersion: '6.0.0', prefix: '^' },
+  // TS7 native compiler for ttsc (TTSC_TSGO_BINARY). Not the unscoped API package.
+  // npm alias form required — Bun cannot install @typescript/typescript6 cleanly (bun#33834).
+  { name: '@typescript/native', fallbackVersion: 'npm:typescript@^7.0.2' },
 ];
 
 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;
+
+const TTSC_PATCHED_DEPENDENCY_KEY = 'ttsc@0.19.3';
+const TTSC_PATCH_PATH = 'patches/ttsc@0.19.3.patch';
 
 export async function applyToolConfigDefaults(root: string): Promise<void> {
-  const context = readToolContext(root);
+  const context = await readToolContext(root);
   await applyRootPackageToolDefaults(root, context);
   applyToolingPackageDefaults(root, context.policy);
   applyDevenvPackageDefaults(root);
 }
 
-export function validateToolConfig(root: string): number {
-  const context = readToolContext(root);
+export async function validateToolConfig(root: string): Promise<number> {
+  const context = await readToolContext(root);
   return (
     validateRootDevDependencies(context.policy, context.rootPackage) +
+    validateTtscPatchedDependency(context.rootPackage) +
     validateToolingPackage(root, context.policy) +
     validateToolingWorkspace(context.rootPackage) +
     validateDevenvPackages(root)
@@ -77,7 +102,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)) {
@@ -88,6 +113,7 @@ export async function applyRootDevDependencyDefaults(root: string, context: Tool
   if (delete devDependencies['@smoothbricks/cli']) {
     changed = true;
   }
+  changed = ensureTtscPatchedDependency(pkg) || changed;
   if (changed) {
     writeJsonObject(join(root, 'package.json'), pkg);
     console.log('updated        package.json workspace tool dependencies');
@@ -103,7 +129,8 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
   }
   let dependencyChanged = false;
   let workspaceChanged = false;
-  const devDependencies = getOrCreateRecord(pkg, 'devDependencies');
+  let patchChanged = false;
+  const devDependencies = ensureDependencyMap(pkg, 'devDependencies');
   for (const dependency of rootDevDependencies) {
     const current = devDependencies[dependency.name];
     if (typeof current !== 'string' || !satisfiesDependencyPolicy(context.policy, current, dependency)) {
@@ -115,7 +142,8 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
     dependencyChanged = true;
   }
   workspaceChanged = addWorkspacePattern(pkg, 'tooling');
-  if (dependencyChanged || workspaceChanged) {
+  patchChanged = ensureTtscPatchedDependency(pkg);
+  if (dependencyChanged || workspaceChanged || patchChanged) {
     writeJsonObject(join(root, 'package.json'), pkg);
   }
   console.log(
@@ -128,18 +156,23 @@ 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 {
   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 +204,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 +231,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];
@@ -219,6 +252,26 @@ 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 validateTtscPatchedDependency(rootPackage: PackageJson | null): number {
+  if (!rootPackage) {
+    return 0;
+  }
+  const actual = rootPackage.patchedDependencies?.[TTSC_PATCHED_DEPENDENCY_KEY];
+  if (actual === TTSC_PATCH_PATH) {
+    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)'),
+  );
+  return 1;
+}
+
 export function validateToolingPackage(root: string, policy: ToolPolicy): number {
   const path = join(root, 'tooling', 'package.json');
   const pkg = readJsonObject(path);
@@ -226,9 +279,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 +315,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) {
@@ -313,6 +368,10 @@ function satisfiesDependencyPolicy(policy: ToolPolicy, version: string, dependen
   if (workspaceDependencyExpected(policy, dependency)) {
     return version === 'workspace:*';
   }
+  // Dual-package native compiler: must stay an npm:typescript@7 alias, never unscoped "typescript".
+  if (dependency.name === '@typescript/native') {
+    return isTypeScriptNativeAlias(version);
+  }
   if (dependency.minimumVersion === undefined) {
     return version === dependency.fallbackVersion;
   }
@@ -324,37 +383,41 @@ function satisfiesDependencyPolicy(policy: ToolPolicy, version: string, dependen
   return compareVersions(parsed, minimum) >= 0;
 }
 
+function isTypeScriptNativeAlias(version: string): boolean {
+  // Accept npm:typescript@7, npm:typescript@^7.0.2, npm:typescript@~7.0.2, etc.
+  return /^npm:typescript@(?:\^|~)?7(?:\.|$)/.test(version.trim());
+}
+
 function formatExpectedDependency(policy: ToolPolicy, dependency: RequiredDependency): string {
   if (workspaceDependencyExpected(policy, dependency)) {
     return 'workspace:*';
   }
+  if (dependency.name === '@typescript/native') {
+    return 'npm:typescript@^7 (TypeScript 7 native compiler alias for ttsc)';
+  }
   return dependency.minimumVersion ? `>= ${dependency.minimumVersion}` : dependency.fallbackVersion;
 }
 
-export function readToolContext(root: string): ToolContext {
+export async function readToolContext(root: string): Promise<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),
+    policy: await toolPolicy(rootPackage, typeof configuredCliRange === 'string' ? configuredCliRange : null),
   };
 }
 
-function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): ToolPolicy {
-  const name = typeof rootPackage?.name === 'string' ? rootPackage.name : null;
+async function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): Promise<ToolPolicy> {
+  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
-  // installable range instead of rewriting the consumer manifest to an unpublished version.
-  const publishedCliRange =
-    cliPackageVersion.includes('-') && configuredCliRange && parseVersion(configuredCliRange)
-      ? configuredCliRange
-      : `^${cliPackageVersion}`;
   return {
     isSmoothBricksCodebase: isCodebase,
     toolingPackageName: toolingName,
-    cliDependencyRange: isCodebase ? 'workspace:*' : publishedCliRange,
+    // Consumers pin the latest *published* CLI. Running a linked prerelease must not
+    // freeze tooling/package.json on an older range or rewrite it to an unpublished -next.
+    cliDependencyRange: isCodebase ? 'workspace:*' : await resolvePublishedCliDependencyRange(configuredCliRange),
   };
 }
 
@@ -379,6 +442,59 @@ async function resolveDependencyVersion(policy: ToolPolicy, dependency: Required
   return `${dependency.prefix ?? ''}${latest ?? stripRangePrefix(dependency.fallbackVersion)}`;
 }
 
+/**
+ * Consumer monorepos pin `@smoothbricks/cli` to the latest stable release.
+ * Prefer npm `dist-tags.latest`. Never write a running `-next` package version into
+ * consumer manifests; never leave an older pin just because the running CLI is prerelease.
+ */
+async function resolvePublishedCliDependencyRange(configuredCliRange: string | null): Promise<string> {
+  const latest = await fetchLatestStableVersion(cliPackageName);
+  if (latest) {
+    return `^${latest}`;
+  }
+  // Registry unavailable: if the running CLI is a stable publish, use it.
+  if (!cliPackageVersion.includes('-')) {
+    return `^${cliPackageVersion}`;
+  }
+  // Linked prerelease + offline down: keep an existing installable stable pin.
+  if (configuredCliRange && parseVersion(configuredCliRange)) {
+    return configuredCliRange;
+  }
+  // Last resort: caret of the prerelease base (0.10.5-next.0 → ^0.10.5) so manifests stay valid.
+  const base = parseVersion(cliPackageVersion);
+  return base ? `^${base.major}.${base.minor}.${base.patch}` : `^${cliPackageVersion}`;
+}
+
+async function fetchLatestStableVersion(packageName: string): Promise<string | null> {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace('%40', '@')}`;
+  const response = await fetch(url, { headers: { accept: 'application/vnd.npm.install-v1+json' } });
+  if (!response.ok) {
+    return null;
+  }
+  const body: unknown = await response.json();
+  if (!isRegistryPackument(body)) {
+    return null;
+  }
+  const tagged = body['dist-tags']?.latest;
+  if (typeof tagged === 'string' && parseVersion(tagged) && !tagged.includes('-')) {
+    return tagged;
+  }
+  let latest: Version | null = null;
+  for (const raw of Object.keys(body.versions)) {
+    if (raw.includes('-')) {
+      continue;
+    }
+    const version = parseVersion(raw);
+    if (!version) {
+      continue;
+    }
+    if (!latest || compareVersions(version, latest) > 0) {
+      latest = version;
+    }
+  }
+  return latest ? `${latest.major}.${latest.minor}.${latest.patch}` : null;
+}
+
 async function fetchLatestPatchVersion(packageName: string, minimumVersion: string): Promise<string | null> {
   const minorRange = sameMajorMinorRange(minimumVersion);
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace('%40', '@')}`;
@@ -435,14 +551,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 +564,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 +580,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

@@ -94,16 +94,20 @@ describe('Nx helper output formatting', () => {
     );
   });
 
-  it('rejects unsupported cross-project object target dependencies', () => {
-    expect(() =>
+  it('omits cross-project dependencies from same-project target closures', () => {
+    expect(
       targetDependenciesFromNxProjectJson({
         targets: {
-          build: {
-            dependsOn: [{ target: 'build', projects: 'dependencies' }],
+          'rust-wasm': {
+            dependsOn: [
+              'prepare',
+              { target: 'cargo-wasm', projects: ['lmao-rs'] },
+              { target: 'build', projects: 'dependencies' },
+            ],
           },
         },
       }),
-    ).toThrow('unsupported cross-project dependsOn');
+    ).toEqual(new Map([['rust-wasm', ['prepare']]]));
   });
 
   it('treats missing target metadata as an empty project', () => {