@smoothbricks/cli 0.10.2 → 0.10.4

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

@@ -29,7 +29,6 @@ const buildOutputDependencies = [
   '*-web',
   '*-html',
   '*-css',
-  '*-ios',
   '*-android',
   '*-native',
   '*-napi',
@@ -263,7 +262,7 @@ describe('workspace package script policy', () => {
     try {
       expect(validateWorkspaceDependencies(root)).toBe(2);
 
-      const resolvedTargetsByProject = new Map([['native', new Set(['build', 'tsc-js', 'zig-wasm'])]]);
+      const resolvedTargetsByProject = new Map([['native', new Set(['build', 'tsc-js', 'tsdown-js'])]]);
       applyWorkspaceDependencyDefaults(root, { resolvedTargetsByProject });
 
       const native = await readJson(join(root, 'packages/native/package.json'));
@@ -285,17 +284,17 @@ describe('workspace package script policy', () => {
           dependencies: { '@smoothbricks/lib': 'workspace:*' },
           scripts: {
             'build:custom': 'nx run native:build:custom',
-            'build:zig': 'nx run native:build:zig',
+            'build:bundle': 'nx run native:build:bundle',
             'build:ts': 'nx run native:build:ts',
           },
           nx: {
             name: 'native',
             targets: {
-              build: { dependsOn: ['^build', 'build:ts', 'build:zig', 'build:custom'] },
+              build: { dependsOn: ['^build', 'build:ts', 'build:bundle', 'build:custom'] },
               'build:custom': {},
-              'build:zig': {
+              'build:bundle': {
                 executor: 'nx:run-commands',
-                options: { command: 'zig build wasm', cwd: '{projectRoot}' },
+                options: { command: 'tsdown', cwd: '{projectRoot}' },
               },
               'build:ts': {
                 executor: 'nx:run-commands',
@@ -308,25 +307,21 @@ describe('workspace package script policy', () => {
     });
     try {
       await writeJson(join(root, 'packages/native/tsconfig.lib.json'), {});
-      await writeFile(
-        join(root, 'packages/native/build.zig'),
-        'pub fn build(b: *std.Build) void { _ = b.step("wasm", "Build wasm"); }\n',
-      );
       expect(validateWorkspaceDependencies(root)).toBe(6);
 
-      const resolvedTargetsByProject = new Map([['native', new Set(['build', 'custom', 'tsc-js', 'zig-wasm'])]]);
+      const resolvedTargetsByProject = new Map([['native', new Set(['build', 'custom', 'tsc-js', 'tsdown-js'])]]);
       applyWorkspaceDependencyDefaults(root, { resolvedTargetsByProject });
 
       const native = await readJson(join(root, 'packages/native/package.json'));
       expect(native.scripts).toEqual({
         'build:custom': 'nx run native:custom',
-        'build:zig': 'nx run native:zig-wasm',
+        'build:bundle': 'nx run native:tsdown-js',
         'build:ts': 'nx run native:tsc-js',
       });
       expect(native.nx).toEqual({
         name: 'native',
         targets: {
-          build: { dependsOn: ['^build', 'tsc-js', 'zig-wasm', 'custom'] },
+          build: { dependsOn: ['^build', 'tsc-js', 'tsdown-js', 'custom'] },
         },
       });
       expect(validateWorkspaceDependencies(root, { resolvedTargetsByProject })).toBe(0);
@@ -345,7 +340,7 @@ describe('workspace package script policy', () => {
           nx: {
             name: 'native',
             targets: {
-              build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'zig-wasm', 'custom'] },
+              build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'tsdown-js', 'custom'] },
             },
           },
         },
@@ -353,14 +348,10 @@ describe('workspace package script policy', () => {
     });
     try {
       await writeJson(join(root, 'packages/native/tsconfig.lib.json'), {});
-      await writeFile(
-        join(root, 'packages/native/build.zig'),
-        'pub fn build(b: *std.Build) void { _ = b.step("wasm", "Build wasm"); }\n',
-      );
       const resolvedTargetsByProject = new Map([
         [
           'native',
-          { targets: new Set(['build', 'tsc-js', 'zig-wasm']), buildDependsOn: ['^build', 'tsc-js', 'zig-wasm'] },
+          { targets: new Set(['build', 'tsc-js', 'tsdown-js']), buildDependsOn: ['^build', 'tsc-js', 'tsdown-js'] },
         ],
       ]);
 
@@ -370,7 +361,7 @@ describe('workspace package script policy', () => {
       expect(native.nx).toEqual({
         name: 'native',
         targets: {
-          build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'zig-wasm', 'custom'] },
+          build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'tsdown-js', 'custom'] },
         },
       });
     } finally {
@@ -390,8 +381,8 @@ describe('workspace package script policy', () => {
             targets: {
               build: {
                 executor: 'nx:run-commands',
-                options: { command: 'zig build wasm', cwd: '{projectRoot}' },
-                dependsOn: ['^build', 'zig-wasm'],
+                options: { command: 'tsdown', cwd: '{projectRoot}' },
+                dependsOn: ['^build', 'tsdown-js'],
               },
             },
           },
@@ -399,12 +390,8 @@ describe('workspace package script policy', () => {
       ],
     });
     try {
-      await writeFile(
-        join(root, 'packages/native/build.zig'),
-        'pub fn build(b: *std.Build) void { _ = b.step("wasm", "Build wasm"); }\n',
-      );
       const resolvedTargetsByProject = new Map([
-        ['native', { targets: new Set(['build', 'zig-wasm']), buildDependsOn: ['^build', 'zig-wasm'] }],
+        ['native', { targets: new Set(['build', 'tsdown-js']), buildDependsOn: ['^build', 'tsdown-js'] }],
       ]);
 
       applyWorkspaceDependencyDefaults(root, { resolvedTargetsByProject });
@@ -415,8 +402,8 @@ describe('workspace package script policy', () => {
         targets: {
           build: {
             executor: 'nx:run-commands',
-            options: { command: 'zig build wasm', cwd: '{projectRoot}' },
-            dependsOn: ['^build', 'zig-wasm'],
+            options: { command: 'tsdown', cwd: '{projectRoot}' },
+            dependsOn: ['^build', 'tsdown-js'],
           },
         },
       });
@@ -435,7 +422,7 @@ describe('workspace package script policy', () => {
           nx: {
             name: 'native',
             targets: {
-              build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'zig-wasm'] },
+              build: { executor: 'nx:noop', dependsOn: ['^build', 'tsc-js', 'tsdown-js'] },
             },
           },
         },
@@ -445,7 +432,7 @@ describe('workspace package script policy', () => {
       const resolvedTargetsByProject = new Map([
         [
           'native',
-          { targets: new Set(['build', 'tsc-js', 'zig-wasm']), buildDependsOn: ['^build', 'tsc-js', 'zig-wasm'] },
+          { targets: new Set(['build', 'tsc-js', 'tsdown-js']), buildDependsOn: ['^build', 'tsc-js', 'tsdown-js'] },
         ],
       ]);
 
@@ -499,7 +486,7 @@ describe('workspace package script policy', () => {
     });
     try {
       const resolvedTargetsByProject = new Map([
-        ['native', { targets: new Set(['build', 'tsc-js', 'zig-wasm']), buildDependsOn: buildOutputDependencies }],
+        ['native', { targets: new Set(['build', 'tsc-js', 'tsdown-js']), buildDependsOn: buildOutputDependencies }],
       ]);
 
       applyWorkspaceDependencyDefaults(root, { resolvedTargetsByProject });
@@ -559,20 +546,6 @@ describe('workspace package script policy', () => {
     }
   });
 
-  it('rejects build.zig without steps', async () => {
-    const root = await createWorkspace({
-      rootName: '@smoothbricks/codebase',
-      packages: [{ dir: 'native', name: '@smoothbricks/native', nx: { name: 'native' } }],
-    });
-    try {
-      await writeFile(join(root, 'packages/native/build.zig'), 'pub fn build(b: *std.Build) void { _ = b; }\n');
-
-      expect(validateWorkspaceDependencies(root)).toBe(1);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
   it('rejects old test tsconfig output for packages with test runners', async () => {
     const root = await createWorkspace({
       rootName: '@smoothbricks/codebase',
@@ -729,17 +702,13 @@ describe('workspace package script policy', () => {
     }
   });
 
-  it('accepts noEmit test tsconfig and build.zig with an explicit step', async () => {
+  it('accepts a noEmit test tsconfig', async () => {
     const root = await createWorkspace({
       rootName: '@smoothbricks/codebase',
       packages: [{ dir: 'native', name: '@smoothbricks/native', nx: { name: 'native', targets: { lint: {} } } }],
     });
     try {
       await writeJson(join(root, 'packages/native/tsconfig.test.json'), { compilerOptions: { noEmit: true } });
-      await writeFile(
-        join(root, 'packages/native/build.zig'),
-        'pub fn build(b: *std.Build) void { _ = b.step("build", "Build native artifact"); }\n',
-      );
 
       expect(validateWorkspaceDependencies(root)).toBe(0);
     } finally {
@@ -974,6 +943,56 @@ describe('workspace package script policy', () => {
       await rm(root, { recursive: true, force: true });
     }
   });
+  it('validates generic CI skip tags against resolved project targets', async () => {
+    const root = await createWorkspace({
+      rootName: '@fixture/root',
+      packages: [
+        {
+          dir: 'worker',
+          name: '@fixture/worker',
+          nx: { name: 'worker', tags: ['ci:skip:test', 'ci:skip:test.integration'], targets: {} },
+        },
+      ],
+    });
+    try {
+      const resolvedTargetsByProject = new Map([['worker', new Set(['build', 'test', 'test.integration'])]]);
+      expect(validateWorkspaceDependencies(root, { resolvedTargetsByProject })).toBe(0);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects malformed and missing-target CI skip tags', async () => {
+    const root = await createWorkspace({
+      rootName: '@fixture/root',
+      packages: [
+        {
+          dir: 'malformed',
+          name: '@fixture/malformed',
+          nx: { name: 'malformed', tags: ['ci:skip:'], targets: {} },
+        },
+        {
+          dir: 'missing',
+          name: '@fixture/missing',
+          nx: { name: 'missing', tags: ['ci:skip:test'], targets: {} },
+        },
+      ],
+    });
+    const errors = captureConsoleErrors();
+    try {
+      const resolvedTargetsByProject = new Map([
+        ['malformed', new Set(['test'])],
+        ['missing', new Set(['build'])],
+      ]);
+      expect(validateWorkspaceDependencies(root, { resolvedTargetsByProject })).toBe(2);
+      expect(errors).toContain(
+        'packages/malformed: nx tag ci:skip: must use ci:skip:<target> with one exact Nx target name',
+      );
+      expect(errors).toContain('packages/missing: nx tag ci:skip:test names missing Nx target test');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });
 
 async function createWorkspace(input: {

package/src/monorepo/package-policy.ts

@@ -21,15 +21,22 @@ import {
   checkWorkspaceConfigPolicy,
 } from '@smoothbricks/nx-plugin/workspace-config-policy';
 import {
-  getOrCreateRecord,
-  hasOwnString,
-  isRecord,
+  ensureNx,
+  ensurePublishConfig,
+  ensureRepositoryObject,
+  ensureScripts,
+  type PackageExportMap,
+  type PackageExports,
+  type PackageJson,
   readJsonObject,
-  recordProperty,
   requiredJsonObject,
-  setMissingStringProperty,
+  type StringMap,
+  setMissingPackageStringField,
+  setMissingRepositoryField,
+  setNxName,
+  setPublishAccess,
+  setRepositoryField,
   setStringProperty,
-  stringProperty,
   writeJsonObject,
 } from '../lib/json.js';
 import {
@@ -68,12 +75,12 @@ export function applyRootScriptDefaults(root: string): void {
   if (!rootPackage) {
     return;
   }
-  const scripts = getOrCreateRecord(rootPackage, 'scripts');
+  const scripts = ensureScripts(rootPackage);
   let changed = false;
   for (const [name, command] of Object.entries(rootScriptPolicy)) {
     changed = setStringProperty(scripts, name, command) || changed;
   }
-  const nx = getOrCreateRecord(rootPackage, 'nx');
+  const nx = ensureNx(rootPackage);
   if (!Array.isArray(nx.includedScripts) || nx.includedScripts.length !== 0) {
     nx.includedScripts = [];
     changed = true;
@@ -97,7 +104,7 @@ export function applyNxPluginDefaults(root: string): void {
 
 export function applyPublicPackageDefaults(root: string): void {
   const rootPackage = requiredJsonObject(join(root, 'package.json'));
-  const rootLicense = stringProperty(rootPackage, 'license');
+  const rootLicense = rootPackage.license;
   const rootRepository = repositoryInfo(rootPackage);
 
   for (const pkg of listPublicPackages(root)) {
@@ -110,18 +117,21 @@ export function applyPublicPackageDefaults(root: string): void {
       rootLicense &&
       rootLicense !== 'UNLICENSED'
     ) {
-      changed = setMissingStringProperty(pkg.json, 'license', rootLicense) || changed;
+      changed = setMissingPackageStringField(pkg.json, 'license', rootLicense) || changed;
     }
-    const publishConfig = getOrCreateRecord(pkg.json, 'publishConfig');
-    changed = setStringProperty(publishConfig, 'access', 'public') || changed;
-
-    const repository = getOrCreateRecord(pkg.json, 'repository');
-    changed =
-      setStringProperty(repository, 'type', existingRepository?.type ?? rootRepository?.type ?? 'git') || changed;
-    if (existingRepository && !stringProperty(repository, 'url')) {
-      changed = setStringProperty(repository, 'url', existingRepository.url) || changed;
+    const publishConfig = ensurePublishConfig(pkg.json);
+    changed = setPublishAccess(publishConfig, 'public') || changed;
+
+    if (typeof pkg.json.repository !== 'string') {
+      const repository = ensureRepositoryObject(pkg.json);
+      changed =
+        setRepositoryField(repository, 'type', existingRepository?.type ?? rootRepository?.type ?? 'git') || changed;
+      if (existingRepository) {
+        changed = setMissingRepositoryField(repository, 'url', existingRepository.url) || changed;
+      }
+      changed = setRepositoryField(repository, 'directory', pkg.path.replaceAll('\\', '/')) || changed;
     }
-    changed = setStringProperty(repository, 'directory', pkg.path.replaceAll('\\', '/')) || changed;
+
     changed = normalizeExportConditionOrder(pkg.json.exports) || changed;
     if (hasDevelopmentSourceExport(pkg.json.exports)) {
       changed = addFileEntry(pkg.json, 'src') || changed;
@@ -172,7 +182,7 @@ export function applyNxReleaseDefaults(root: string): void {
 
 export function applyNxProjectNameDefaults(root: string): void {
   const rootPackage = requiredJsonObject(join(root, 'package.json'));
-  const rootName = stringProperty(rootPackage, 'name');
+  const rootName = rootPackage.name;
   if (!rootName) {
     return;
   }
@@ -181,8 +191,8 @@ export function applyNxProjectNameDefaults(root: string): void {
     if (!suggestedName) {
       continue;
     }
-    const nx = getOrCreateRecord(pkg.json, 'nx');
-    const changed = setStringProperty(nx, 'name', suggestedName);
+    const nx = ensureNx(pkg.json);
+    const changed = setNxName(nx, suggestedName);
     if (changed) {
       writeJsonObject(pkg.packageJsonPath, pkg.json);
       console.log(`updated        ${pkg.path}/package.json nx.name`);
@@ -198,11 +208,10 @@ export function listValidCommitScopes(root: string): ReadonlySet<string> {
 
 export function listNxProjectNames(root: string): string[] {
   const rootPackage = readJsonObject(join(root, 'package.json'));
-  const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+  const rootName = rootPackage?.name ?? null;
   const names: string[] = [];
   for (const pkg of getWorkspacePackageManifests(root)) {
-    const nx = recordProperty(pkg.json, 'nx');
-    const configuredName = nx ? stringProperty(nx, 'name') : null;
+    const configuredName = pkg.json.nx?.name;
     const suggestedName = rootName ? suggestNxProjectName(rootName, pkg.name) : null;
     if (configuredName) {
       names.push(configuredName);
@@ -220,11 +229,11 @@ export function validateRootPackagePolicy(root: string): number {
     return 1;
   }
   let failures = 0;
-  if (!stringProperty(rootPackage, 'name')) {
+  if (!rootPackage.name) {
     console.error('package.json must define name');
     failures++;
   }
-  if (!stringProperty(rootPackage, 'license')) {
+  if (!rootPackage.license) {
     console.error('package.json must define repo-wide license');
     failures++;
   }
@@ -234,19 +243,19 @@ export function validateRootPackagePolicy(root: string): number {
   }
   failures += validateRootScripts(rootPackage);
   failures += validateRootNxScriptInference(rootPackage);
-  const packageManager = stringProperty(rootPackage, 'packageManager');
+  const packageManager = rootPackage.packageManager;
   if (!packageManager?.startsWith('bun@')) {
     console.error('package.json packageManager must use bun@<version>');
     failures++;
   }
   const bunVersion = packageManager?.startsWith('bun@') ? packageManager.slice('bun@'.length) : null;
-  const devDependencies = recordProperty(rootPackage, 'devDependencies');
+  const devDependencies = rootPackage.devDependencies;
   if (!bunVersion || !devDependencies || devDependencies['@types/bun'] !== bunVersion) {
     console.error('package.json devDependencies.@types/bun must match packageManager bun version');
     failures++;
   }
-  const engines = recordProperty(rootPackage, 'engines');
-  if (!engines || !stringProperty(engines, 'node')) {
+  const engines = rootPackage.engines;
+  if (!engines?.node) {
     console.error('package.json engines.node must be defined');
     failures++;
   }
@@ -268,7 +277,7 @@ export function validateNxReleaseConfig(root: string): number {
 
 export function validateNxProjectNames(root: string): number {
   const rootPackage = readJsonObject(join(root, 'package.json'));
-  const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+  const rootName = rootPackage?.name ?? null;
   if (!rootName) {
     return 0;
   }
@@ -278,8 +287,7 @@ export function validateNxProjectNames(root: string): number {
     if (!suggestedName) {
       continue;
     }
-    const nx = recordProperty(pkg.json, 'nx');
-    const configuredName = nx ? stringProperty(nx, 'name') : null;
+    const configuredName = pkg.json.nx?.name ?? null;
     if (configuredName !== suggestedName) {
       console.error(
         `${pkg.path}: package.json nx.name must be "${suggestedName}" so fix(${suggestedName}): maps to this project`,
@@ -318,16 +326,19 @@ export function validatePublicPackageMetadata(root: string): number {
       console.error(`${pkg.path}: npm:public package must not be private`);
       failures++;
     }
-    if (!stringProperty(pkg.json, 'license')) {
+    if (!pkg.json.license) {
       console.error(`${pkg.path}: public package must define license`);
       failures++;
     }
-    const publishConfig = recordProperty(pkg.json, 'publishConfig');
-    if (!publishConfig || stringProperty(publishConfig, 'access') !== 'public') {
+    const publishConfig = pkg.json.publishConfig;
+    if (publishConfig?.access !== 'public') {
       console.error(`${pkg.path}: public package must define publishConfig.access = public`);
       failures++;
     }
-    const repository = recordProperty(pkg.json, 'repository');
+    const repository =
+      pkg.json.repository !== null && pkg.json.repository !== undefined && typeof pkg.json.repository !== 'string'
+        ? pkg.json.repository
+        : null;
     const packageRepository = packageRepositoryInfo(pkg);
     if (!packageRepository) {
       console.error(`${pkg.path}: public package must define repository.url`);
@@ -345,11 +356,11 @@ export function validatePublicPackageMetadata(root: string): number {
       );
       failures++;
     }
-    if (!repository || !stringProperty(repository, 'type')) {
+    if (!repository?.type) {
       console.error(`${pkg.path}: public package must define repository.type`);
       failures++;
     }
-    if (!repository || stringProperty(repository, 'directory') !== pkg.path.replaceAll('\\', '/')) {
+    if (!repository || repository.directory !== pkg.path.replaceAll('\\', '/')) {
       console.error(`${pkg.path}: public package repository.directory must be ${pkg.path.replaceAll('\\', '/')}`);
       failures++;
     }
@@ -357,11 +368,14 @@ export function validatePublicPackageMetadata(root: string): number {
       console.error(`${pkg.path}: public package must define files`);
       failures++;
     }
-    if (!isRecord(pkg.json.exports) && !isRecord(pkg.json.bin)) {
+    const hasBin =
+      typeof pkg.json.bin === 'string' ||
+      (pkg.json.bin !== null && pkg.json.bin !== undefined && typeof pkg.json.bin === 'object');
+    if (!isPackageExportMap(pkg.json.exports) && !hasBin) {
       console.error(`${pkg.path}: public package must define exports or bin`);
       failures++;
     }
-    if (!hasOwnString(pkg.json, 'types') && !isRecord(pkg.json.bin)) {
+    if (typeof pkg.json.types !== 'string' && !hasBin) {
       console.error(`${pkg.path}: public library package must define types`);
       failures++;
     }
@@ -371,10 +385,11 @@ export function validatePublicPackageMetadata(root: string): number {
 
 export function validateWorkspaceDependencies(root: string, options: PackageTargetPolicyOptions = {}): number {
   let failures = 0;
+  failures += validateCiSkipTags(root, options);
   const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
   for (const pkg of listPackageJsonRecords(root)) {
     for (const field of workspaceDependencyFields) {
-      const dependencies = recordProperty(pkg.json, field);
+      const dependencies = pkg.json[field];
       if (!dependencies) {
         continue;
       }
@@ -404,14 +419,41 @@ export function validateWorkspaceDependencies(root: string, options: PackageTarg
   return failures;
 }
 
+const ciSkipTagPrefix = 'ci:skip:';
+const invalidCiSkipTargetSyntax = /[,*?[\]{}]/;
+
+function validateCiSkipTags(root: string, options: PackageTargetPolicyOptions): number {
+  let failures = 0;
+  for (const pkg of getWorkspacePackages(root)) {
+    const resolved = options.resolvedTargetsByProject?.get(pkg.projectName);
+    const resolvedTargets = resolved && 'targets' in resolved ? resolved.targets : resolved;
+    for (const tag of pkg.tags) {
+      if (tag !== 'ci:skip' && !tag.startsWith(ciSkipTagPrefix)) {
+        continue;
+      }
+      const target = tag.startsWith(ciSkipTagPrefix) ? tag.slice(ciSkipTagPrefix.length) : '';
+      if (!target || invalidCiSkipTargetSyntax.test(target)) {
+        console.error(`${pkg.path}: nx tag ${tag} must use ci:skip:<target> with one exact Nx target name`);
+        failures++;
+        continue;
+      }
+      if (resolvedTargets && !resolvedTargets.has(target)) {
+        console.error(`${pkg.path}: nx tag ${tag} names missing Nx target ${target}`);
+        failures++;
+      }
+    }
+  }
+  return failures;
+}
+
 // ---------------------------------------------------------------------------
 // Helpers kept in CLI (not Nx-specific)
 // ---------------------------------------------------------------------------
 
-function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNames: Set<string>): boolean {
+function fixWorkspaceDependencyRanges(pkg: PackageJson, workspaceNames: Set<string>): boolean {
   let changed = false;
   for (const field of workspaceDependencyFields) {
-    const dependencies = recordProperty(pkg, field);
+    const dependencies = pkg[field];
     if (!dependencies) {
       continue;
     }
@@ -425,8 +467,8 @@ function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNam
   return changed;
 }
 
-function validateRootScripts(rootPackage: Record<string, unknown>): number {
-  const scripts = recordProperty(rootPackage, 'scripts');
+function validateRootScripts(rootPackage: PackageJson): number {
+  const scripts = rootPackage.scripts;
   let failures = 0;
   for (const [name, command] of Object.entries(rootScriptPolicy)) {
     if (scripts?.[name] !== command) {
@@ -443,9 +485,9 @@ function validateRootScripts(rootPackage: Record<string, unknown>): number {
   return failures;
 }
 
-function validateRootNxScriptInference(rootPackage: Record<string, unknown>): number {
-  const nx = recordProperty(rootPackage, 'nx');
-  if (nx && Array.isArray(nx.includedScripts) && nx.includedScripts.length === 0) {
+function validateRootNxScriptInference(rootPackage: PackageJson): number {
+  const includedScripts = rootPackage.nx?.includedScripts;
+  if (Array.isArray(includedScripts) && includedScripts.length === 0) {
     return 0;
   }
   console.error('package.json nx.includedScripts must be [] so root scripts do not become recursive Nx targets.');
@@ -469,12 +511,12 @@ function unscopedPackageName(packageName: string): string {
   return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
 }
 
-function recordKeysAreSorted(record: Record<string, unknown>): boolean {
+function recordKeysAreSorted(record: StringMap): boolean {
   const keys = Object.keys(record);
-  return keys.every((key, index) => index === 0 || keys[index - 1] <= key);
+  return keys.every((key, index) => index === 0 || (keys[index - 1] ?? '') <= key);
 }
 
-function sortRecordInPlace(record: Record<string, unknown>): boolean {
+function sortRecordInPlace(record: StringMap): boolean {
   if (recordKeysAreSorted(record)) {
     return false;
   }
@@ -488,8 +530,11 @@ function sortRecordInPlace(record: Record<string, unknown>): boolean {
   return true;
 }
 
-function normalizeExportConditionOrder(value: unknown): boolean {
-  if (!isRecord(value)) {
+function isPackageExportMap(value: PackageExports): value is PackageExportMap {
+  return value !== null && value !== undefined && typeof value === 'object';
+}
+function normalizeExportConditionOrder(value: PackageExports): boolean {
+  if (!isPackageExportMap(value)) {
     return false;
   }
   let changed = false;
@@ -518,8 +563,8 @@ function normalizeExportConditionOrder(value: unknown): boolean {
   return true;
 }
 
-function hasDevelopmentSourceExport(value: unknown): boolean {
-  if (!isRecord(value)) {
+function hasDevelopmentSourceExport(value: PackageExports): boolean {
+  if (!isPackageExportMap(value)) {
     return false;
   }
   for (const [key, child] of Object.entries(value)) {
@@ -533,12 +578,12 @@ function hasDevelopmentSourceExport(value: unknown): boolean {
   return false;
 }
 
-function addFileEntry(pkg: Record<string, unknown>, entry: string): boolean {
+function addFileEntry(pkg: PackageJson, entry: string): boolean {
   const files = pkg.files;
   if (!Array.isArray(files) || files.includes(entry)) {
     return false;
   }
-  const firstNegated = files.findIndex((file) => typeof file === 'string' && file.startsWith('!'));
+  const firstNegated = files.findIndex((file) => file.startsWith('!'));
   if (firstNegated === -1) {
     files.push(entry);
   } else {