@smoothbricks/cli 0.2.0 → 0.3.0

package/dist/monorepo/package-policy.js

@@ -1,9 +1,12 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { getOrCreateRecord, hasOwn, hasOwnString, isRecord, readJsonObject, recordProperty, requiredJsonObject, setMissingStringProperty, setStringProperty, stringProperty, writeJsonObject, } from '../lib/json.js';
-import { getWorkspacePackages, listPackageJsonRecords, listPublicPackages, packageRepositoryInfo, repositoryInfo, sameRepositoryAfterNormalization, workspaceDependencyFields, } from '../lib/workspace.js';
-export const SMOO_NX_VERSION_ACTIONS = '@smoothbricks/cli/nx-version-actions';
-export const SMOO_NX_RELEASE_TAG_PATTERN = '{projectName}@{version}';
+import { join } from 'node:path';
+import { applyWorkspaceBoundedTestTargetPolicy, checkWorkspaceBoundedTestTargetPolicy, } from '@smoothbricks/nx-plugin/bounded-test-policy';
+import { applyPackageTargetPolicy, checkPackageTargetPolicy, } from '@smoothbricks/nx-plugin/package-target-policy';
+import { applyReleaseConfigPolicy, checkReleaseConfigPolicy, SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS, } from '@smoothbricks/nx-plugin/release-config-policy';
+import { applyTypecheckTestPolicy, checkTypecheckTestPolicy } from '@smoothbricks/nx-plugin/typecheck-test-policy';
+import { applyWorkspaceConfigPolicy, checkWorkspaceConfigPolicy, } from '@smoothbricks/nx-plugin/workspace-config-policy';
+import { getOrCreateRecord, hasOwnString, isRecord, readJsonObject, recordProperty, requiredJsonObject, setMissingStringProperty, setStringProperty, stringProperty, writeJsonObject, } from '../lib/json.js';
+import { getWorkspacePackageManifests, getWorkspacePackages, listPackageJsonRecords, listPublicPackages, packageRepositoryInfo, repositoryInfo, sameRepositoryAfterNormalization, workspaceDependencyFields, } from '../lib/workspace.js';
+export { SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS };
 const extraCommitScopes = ['release'];
 const rootScriptPolicy = {
     lint: 'nx run-many -t lint',
@@ -11,17 +14,6 @@ const rootScriptPolicy = {
     'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
     'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
 };
-const nxJsTypescriptPlugin = '@nx/js/typescript';
-const smoothBricksNxPlugin = '@smoothbricks/nx-plugin';
-const expectedSharedGlobalsNamedInput = ['{workspaceRoot}/.github/workflows/ci.yml'];
-const defaultProductionNamedInput = [
-    '{projectRoot}/src/**/*',
-    '{projectRoot}/package.json',
-    '!{projectRoot}/**/__tests__/**',
-    '!{projectRoot}/**/*.test.*',
-    '!{projectRoot}/**/*.spec.*',
-];
-const impreciseProductionInputs = new Set(['default', '{projectRoot}/**/*', '{projectRoot}/**']);
 export function applyFixableMonorepoDefaults(root) {
     applyRootScriptDefaults(root);
     applyNxPluginDefaults(root);
@@ -53,22 +45,7 @@ export function applyRootScriptDefaults(root) {
     }
 }
 export function applyNxPluginDefaults(root) {
-    const nxJsonPath = join(root, 'nx.json');
-    const nxJson = readJsonObject(nxJsonPath);
-    if (!nxJson) {
-        return;
-    }
-    let changed = removeColonTargetDefaults(nxJson);
-    changed = applyBuildTargetDefault(nxJson) || changed;
-    changed = applyNamedInputDefaults(nxJson) || changed;
-    const currentPlugins = Array.isArray(nxJson.plugins) ? nxJson.plugins : [];
-    const nextPlugins = upsertNxPlugin(upsertNxPlugin(currentPlugins, expectedNxJsTypescriptPlugin()), smoothBricksNxPlugin);
-    if (JSON.stringify(currentPlugins) !== JSON.stringify(nextPlugins)) {
-        nxJson.plugins = nextPlugins;
-        changed = true;
-    }
-    if (changed) {
-        writeJsonObject(nxJsonPath, nxJson);
+    if (applyWorkspaceConfigPolicy(root)) {
         console.log('updated        nx.json smoo plugin config');
     }
     else {
@@ -114,58 +91,33 @@ export function applyPublicPackageDefaults(root) {
 export function applyWorkspaceDependencyDefaults(root, options = {}) {
     const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     for (const pkg of listPackageJsonRecords(root)) {
-        let changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
-        const projectName = packageNxProjectName(pkg.json);
-        const resolvedProject = projectName ? options.resolvedTargetsByProject?.get(projectName) : undefined;
-        const resolvedTargets = resolvedProjectTargetNames(resolvedProject);
-        changed = migratePackageColonTargets(pkg.json, resolvedTargets) || changed;
-        changed = rewriteColonTargetDependenciesInPackage(pkg.json, resolvedTargets) || changed;
-        changed = removePackageColonTargets(pkg.json) || changed;
-        changed = removeRedundantNoopBuildTarget(pkg.json, resolvedProject) || changed;
-        changed = applyPackageScriptPolicy(pkg.json, pkg.path, workspaceNames, { resolvedTargets }) || changed;
+        const changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
         if (changed) {
             writeJsonObject(pkg.packageJsonPath, pkg.json);
-            console.log(`updated        ${pkg.path}/package.json workspace dependency policy`);
-        }
-        else {
-            console.log(`unchanged      ${pkg.path}/package.json workspace dependency policy`);
+            console.log(`updated        ${pkg.path}/package.json workspace dependency ranges`);
         }
-        applyBunTestTsconfigDefaults(root, pkg.path, pkg.json, workspaceNames);
-        applyTsconfigTestReferenceDefaults(root, pkg.path);
     }
-}
-export function applyNxReleaseDefaults(root) {
-    const nxJsonPath = join(root, 'nx.json');
-    const nxJson = requiredJsonObject(nxJsonPath);
-    let changed = false;
-    const release = getOrCreateRecord(nxJson, 'release');
-    changed = setStringProperty(release, 'projectsRelationship', 'independent') || changed;
-    const version = getOrCreateRecord(release, 'version');
-    changed = setStringProperty(version, 'specifierSource', 'conventional-commits') || changed;
-    changed = setStringProperty(version, 'currentVersionResolver', 'git-tag') || changed;
-    changed = setStringProperty(version, 'fallbackCurrentVersionResolver', 'disk') || changed;
-    changed = setStringProperty(version, 'versionActions', SMOO_NX_VERSION_ACTIONS) || changed;
-    if (delete version.preVersionCommand) {
-        changed = true;
+    if (applyPackageTargetPolicy(root, options)) {
+        console.log('updated        package Nx target policy');
     }
-    const releaseTag = getOrCreateRecord(release, 'releaseTag');
-    changed = setStringProperty(releaseTag, 'pattern', SMOO_NX_RELEASE_TAG_PATTERN) || changed;
-    const changelog = getOrCreateRecord(release, 'changelog');
-    changed = setBooleanProperty(changelog, 'workspaceChangelog', false) || changed;
-    const projectChangelogs = getOrCreateRecord(changelog, 'projectChangelogs');
-    changed = setBooleanProperty(projectChangelogs, 'createRelease', false) || changed;
-    changed = setBooleanProperty(projectChangelogs, 'file', false) || changed;
-    const renderOptions = getOrCreateRecord(projectChangelogs, 'renderOptions');
-    if (typeof renderOptions.authors !== 'boolean') {
-        renderOptions.authors = true;
-        changed = true;
+    else {
+        console.log('unchanged      package Nx target policy');
     }
-    if (typeof renderOptions.applyUsernameToAuthors !== 'boolean') {
-        renderOptions.applyUsernameToAuthors = true;
-        changed = true;
+    if (applyTypecheckTestPolicy(root)) {
+        console.log('updated        tsconfig.test.json policy');
     }
-    if (changed) {
-        writeJsonObject(nxJsonPath, nxJson);
+    else {
+        console.log('unchanged      tsconfig.test.json policy');
+    }
+    if (applyWorkspaceBoundedTestTargetPolicy(root)) {
+        console.log('updated        package test targets bounded execution policy');
+    }
+    else {
+        console.log('unchanged      package test targets bounded execution policy');
+    }
+}
+export function applyNxReleaseDefaults(root) {
+    if (applyReleaseConfigPolicy(root)) {
         console.log('updated        nx.json release config');
     }
     else {
@@ -178,12 +130,13 @@ export function applyNxProjectNameDefaults(root) {
     if (!rootName) {
         return;
     }
-    for (const pkg of getWorkspacePackages(root)) {
+    for (const pkg of getWorkspacePackageManifests(root)) {
         const suggestedName = suggestNxProjectName(rootName, pkg.name);
         if (!suggestedName) {
             continue;
         }
-        const changed = applyPackageNxConfig(pkg.json, { projectName: suggestedName }).changed;
+        const nx = getOrCreateRecord(pkg.json, 'nx');
+        const changed = setStringProperty(nx, 'name', suggestedName);
         if (changed) {
             writeJsonObject(pkg.packageJsonPath, pkg.json);
             console.log(`updated        ${pkg.path}/package.json nx.name`);
@@ -200,7 +153,7 @@ export function listNxProjectNames(root) {
     const rootPackage = readJsonObject(join(root, 'package.json'));
     const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
     const names = [];
-    for (const pkg of getWorkspacePackages(root)) {
+    for (const pkg of getWorkspacePackageManifests(root)) {
         const nx = recordProperty(pkg.json, 'nx');
         const configuredName = nx ? stringProperty(nx, 'name') : null;
         const suggestedName = rootName ? suggestNxProjectName(rootName, pkg.name) : null;
@@ -253,83 +206,13 @@ export function validateRootPackagePolicy(root) {
     return failures;
 }
 export function validateNxReleaseConfig(root) {
-    const nxJson = readJsonObject(join(root, 'nx.json'));
-    if (!nxJson) {
-        console.error('nx.json not found or invalid');
-        return 1;
-    }
-    const release = recordProperty(nxJson, 'release');
-    const version = release ? recordProperty(release, 'version') : null;
-    const releaseTag = release ? recordProperty(release, 'releaseTag') : null;
-    const changelog = release ? recordProperty(release, 'changelog') : null;
-    const projectChangelogs = changelog ? recordProperty(changelog, 'projectChangelogs') : null;
-    const renderOptions = projectChangelogs ? recordProperty(projectChangelogs, 'renderOptions') : null;
     let failures = 0;
-    if (!release) {
-        console.error('nx.json release config is missing');
+    for (const issue of checkWorkspaceConfigPolicy(root)) {
+        console.error(issue.message);
         failures++;
     }
-    failures += validateNxPluginConfig(nxJson);
-    if (release && stringProperty(release, 'projectsRelationship') !== 'independent') {
-        console.error('nx.json release.projectsRelationship must be independent');
-        failures++;
-    }
-    if (!version) {
-        console.error('nx.json release.version config is missing');
-        failures++;
-    }
-    if (version && stringProperty(version, 'specifierSource') !== 'conventional-commits') {
-        console.error('nx.json release.version.specifierSource must be conventional-commits');
-        failures++;
-    }
-    // Nx requires git-tag as the primary resolver when deriving versions from
-    // conventional commits. Disk is only a fallback for initial untagged packages.
-    if (version && stringProperty(version, 'currentVersionResolver') !== 'git-tag') {
-        console.error('nx.json release.version.currentVersionResolver must be git-tag');
-        failures++;
-    }
-    if (version && stringProperty(version, 'fallbackCurrentVersionResolver') !== 'disk') {
-        console.error('nx.json release.version.fallbackCurrentVersionResolver must be disk');
-        failures++;
-    }
-    if (version && stringProperty(version, 'versionActions') !== SMOO_NX_VERSION_ACTIONS) {
-        console.error(`nx.json release.version.versionActions must be ${SMOO_NX_VERSION_ACTIONS}`);
-        failures++;
-    }
-    if (version && stringProperty(version, 'preVersionCommand')) {
-        console.error('nx.json release.version.preVersionCommand must not be defined; smoo builds npm-missing packages before publish');
-        failures++;
-    }
-    if (!releaseTag) {
-        console.error('nx.json release.releaseTag config is missing');
-        failures++;
-    }
-    if (releaseTag && stringProperty(releaseTag, 'pattern') !== SMOO_NX_RELEASE_TAG_PATTERN) {
-        console.error(`nx.json release.releaseTag.pattern must be ${SMOO_NX_RELEASE_TAG_PATTERN}`);
-        failures++;
-    }
-    if (!changelog) {
-        console.error('nx.json release.changelog config is missing');
-        failures++;
-    }
-    if (changelog && changelog.workspaceChangelog !== false) {
-        console.error('nx.json release.changelog.workspaceChangelog must be false');
-        failures++;
-    }
-    if (!projectChangelogs) {
-        console.error('nx.json release.changelog.projectChangelogs config is missing');
-        failures++;
-    }
-    if (projectChangelogs && projectChangelogs.createRelease !== false) {
-        console.error('nx.json release.changelog.projectChangelogs.createRelease must be false');
-        failures++;
-    }
-    if (projectChangelogs && projectChangelogs.file !== false) {
-        console.error('nx.json release.changelog.projectChangelogs.file must be false');
-        failures++;
-    }
-    if (!renderOptions) {
-        console.error('nx.json release.changelog.projectChangelogs.renderOptions config is missing');
+    for (const issue of checkReleaseConfigPolicy(root)) {
+        console.error(issue.message);
         failures++;
     }
     return failures;
@@ -341,7 +224,7 @@ export function validateNxProjectNames(root) {
         return 0;
     }
     let failures = 0;
-    for (const pkg of getWorkspacePackages(root)) {
+    for (const pkg of getWorkspacePackageManifests(root)) {
         const suggestedName = suggestNxProjectName(rootName, pkg.name);
         if (!suggestedName) {
             continue;
@@ -429,16 +312,9 @@ export function validatePublicPackageMetadata(root) {
     return failures;
 }
 export function validateWorkspaceDependencies(root, options = {}) {
-    const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     let failures = 0;
+    const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     for (const pkg of listPackageJsonRecords(root)) {
-        const projectName = packageNxProjectName(pkg.json);
-        const resolvedTargets = resolvedProjectTargetNames(projectName ? options.resolvedTargetsByProject?.get(projectName) : undefined);
-        failures += validateExplicitNxTargets(pkg.json, pkg.path, resolvedTargets);
-        failures += validateBunTestTsconfigPresence(root, pkg.path, pkg.json);
-        failures += validateTsconfigTestPolicy(root, pkg.path);
-        failures += validateTsconfigTestReferencePolicy(root, pkg.path);
-        failures += validateBuildZigPolicy(root, pkg.path);
         for (const field of workspaceDependencyFields) {
             const dependencies = recordProperty(pkg.json, field);
             if (!dependencies) {
@@ -451,151 +327,27 @@ export function validateWorkspaceDependencies(root, options = {}) {
                 }
             }
         }
-        failures += validatePackageScriptPolicy(pkg.json, pkg.path, workspaceNames, { resolvedTargets });
     }
-    if (failures === 0) {
-        console.log('Workspace dependency policy is valid.');
-    }
-    return failures;
-}
-export function applyPackageScriptPolicy(pkg, _packagePath, workspaceNames, options = {}) {
-    if (!hasWorkspaceDependency(pkg, workspaceNames)) {
-        return false;
-    }
-    const scripts = recordProperty(pkg, 'scripts');
-    if (!scripts) {
-        return false;
-    }
-    const projectName = packageNxProjectName(pkg);
-    if (!projectName) {
-        return false;
-    }
-    const nxConfig = applyPackageNxConfig(pkg, { projectName, targets: true });
-    const targets = nxConfig.targets;
-    let changed = nxConfig.changed;
-    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
-        if (typeof rawCommand !== 'string') {
-            continue;
-        }
-        const rewrite = classifyScriptRewrite(scriptName, rawCommand);
-        if (!rewrite) {
-            continue;
-        }
-        const targetName = rewrite.targetName;
-        const alias = nxRunAlias(projectName, targetName, rewrite.continuous);
-        const existingTarget = recordProperty(targets, targetName);
-        if (!existingTarget &&
-            targetName !== scriptName &&
-            targetExistsInResolvedProject(targetName, options.resolvedTargets)) {
-            if (scripts[scriptName] !== alias) {
-                scripts[scriptName] = alias;
-                changed = true;
-            }
-            continue;
-        }
-        const existingOptions = existingTarget ? recordProperty(existingTarget, 'options') : null;
-        const existingCommand = existingOptions ? stringProperty(existingOptions, 'command') : null;
-        const command = isScriptRunnerCommand(existingCommand, scriptName)
-            ? rewrite.command
-            : (existingCommand ?? rewrite.command);
-        const target = existingTarget ?? {};
-        changed = setStringProperty(target, 'executor', 'nx:run-commands') || changed;
-        changed = setStringArrayProperty(target, 'dependsOn', expectedTargetDependencies(targetName)) || changed;
-        if (rewrite.continuous && target.continuous !== true) {
-            target.continuous = true;
-            changed = true;
-        }
-        const targetOptions = getOrCreateRecord(target, 'options');
-        changed = setStringProperty(targetOptions, 'command', command) || changed;
-        changed = setStringProperty(targetOptions, 'cwd', '{projectRoot}') || changed;
-        for (const [name, value] of Object.entries(rewrite.env)) {
-            const env = getOrCreateRecord(targetOptions, 'env');
-            changed = setStringProperty(env, name, value) || changed;
-        }
-        if (targets[targetName] !== target) {
-            targets[targetName] = target;
-            changed = true;
-        }
-        if (scripts[scriptName] !== alias) {
-            scripts[scriptName] = alias;
-            changed = true;
-        }
+    for (const issue of checkPackageTargetPolicy(root, options)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
     }
-    return changed;
-}
-export function validatePackageScriptPolicy(pkg, packagePath, workspaceNames, options = {}) {
-    if (!hasWorkspaceDependency(pkg, workspaceNames)) {
-        return 0;
+    for (const issue of checkTypecheckTestPolicy(root)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
     }
-    const scripts = recordProperty(pkg, 'scripts');
-    if (!scripts) {
-        return 0;
+    for (const issue of checkWorkspaceBoundedTestTargetPolicy(root)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
     }
-    const nx = recordProperty(pkg, 'nx');
-    const projectName = nx ? stringProperty(nx, 'name') : stringProperty(pkg, 'name');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    let failures = 0;
-    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
-        if (typeof rawCommand !== 'string') {
-            continue;
-        }
-        const alias = parseNxRunAlias(rawCommand);
-        const rewrite = alias
-            ? { targetName: alias.targetName, continuous: isContinuousTarget(alias.targetName, '') }
-            : classifyScriptRewrite(scriptName, rawCommand);
-        if (!rewrite || (alias && projectName && alias.projectName !== projectName)) {
-            if (alias && projectName && alias.projectName !== projectName) {
-                console.error(`${packagePath}: scripts.${scriptName} must delegate to project ${projectName}`);
-                failures++;
-            }
-            continue;
-        }
-        if (!projectName) {
-            console.error(`${packagePath}: package scripts that use workspace dependencies require package.json nx.name`);
-            failures++;
-            continue;
-        }
-        const expectedAlias = nxRunAlias(projectName, rewrite.targetName, rewrite.continuous);
-        if (rawCommand !== expectedAlias) {
-            console.error(`${packagePath}: scripts.${scriptName} must delegate to ${expectedAlias}`);
-            failures++;
-            continue;
-        }
-        const target = targets ? recordProperty(targets, rewrite.targetName) : null;
-        if (!target &&
-            rewrite.targetName !== scriptName &&
-            targetExistsInResolvedProject(rewrite.targetName, options.resolvedTargets)) {
-            continue;
-        }
-        if (rewrite.targetName.includes(':')) {
-            continue;
-        }
-        const targetOptions = target ? recordProperty(target, 'options') : null;
-        const command = targetOptions ? stringProperty(targetOptions, 'command') : null;
-        if (!target || stringProperty(target, 'executor') !== 'nx:run-commands' || !targetOptions || !command) {
-            console.error(`${packagePath}: nx.targets.${rewrite.targetName} must use nx:run-commands with options.command`);
-            failures++;
-            continue;
-        }
-        if (stringProperty(targetOptions, 'cwd') !== '{projectRoot}') {
-            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.options.cwd must be {projectRoot}`);
-            failures++;
-        }
-        if (!targetDependsOn(target, expectedTargetDependencies(rewrite.targetName))) {
-            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.dependsOn must include ${expectedTargetDependencies(rewrite.targetName).join(', ')}`);
-            failures++;
-        }
-        if (rewrite.continuous && target.continuous !== true) {
-            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.continuous must be true`);
-            failures++;
-        }
-        if (isScriptRunnerCommand(command, scriptName)) {
-            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.options.command must not call scripts.${scriptName}`);
-            failures++;
-        }
+    if (failures === 0) {
+        console.log('Workspace dependency policy is valid.');
     }
     return failures;
 }
+// ---------------------------------------------------------------------------
+// Helpers kept in CLI (not Nx-specific)
+// ---------------------------------------------------------------------------
 function fixWorkspaceDependencyRanges(pkg, workspaceNames) {
     let changed = false;
     for (const field of workspaceDependencyFields) {
@@ -635,804 +387,19 @@ function validateRootNxScriptInference(rootPackage) {
     console.error('package.json nx.includedScripts must be [] so root scripts do not become recursive Nx targets.');
     return 1;
 }
-function validateNxPluginConfig(nxJson) {
-    let failures = 0;
-    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
-    if (targetDefaults) {
-        for (const targetName of Object.keys(targetDefaults)) {
-            if (targetName.includes(':')) {
-                console.error(`nx.json targetDefaults.${targetName} must not use colon target names. ` +
-                    'Nx CLI syntax already uses project:target:configuration, so smoo Nx target names must be unambiguous tool-output names.');
-                failures++;
-            }
-        }
-    }
-    failures += validateBuildTargetDefault(nxJson);
-    failures += validateNamedInputDefaults(nxJson);
-    const plugins = Array.isArray(nxJson.plugins) ? nxJson.plugins : [];
-    const nxJsPlugin = plugins.find(isNxJsTypescriptPlugin);
-    if (!nxJsPlugin) {
-        console.error(`nx.json plugins must configure ${nxJsTypescriptPlugin}. ` +
-            'Official Nx owns TypeScript library inference; smoo configures it so tsconfig.lib.json produces tsc-js and leaves build available as an aggregate target.');
-        failures++;
-    }
-    else if (nxJsBuildTargetName(nxJsPlugin) !== 'tsc-js') {
-        console.error(`nx.json ${nxJsTypescriptPlugin} build.targetName must be tsc-js. ` +
-            'TypeScript library output is a concrete tool-output target; build is reserved for aggregate targets that depend on concrete build work.');
-        failures++;
-    }
-    if (!plugins.includes(smoothBricksNxPlugin) && !plugins.some(isSmoothBricksNxPluginRecord)) {
-        console.error(`nx.json plugins must include ${smoothBricksNxPlugin}. ` +
-            'Smoo relies on this plugin to infer convention targets that official Nx does not provide, including typecheck-tests, non-TypeScript build-tool targets, and aggregate build/lint targets.');
-        failures++;
-    }
-    return failures;
-}
-function validateExplicitNxTargets(pkg, packagePath, resolvedTargets) {
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets) {
-        return 0;
-    }
-    let failures = 0;
-    for (const [targetName, rawTarget] of Object.entries(targets)) {
-        if (targetName.includes(':')) {
-            console.error(`${packagePath}: package.json nx.targets.${targetName} must not use colon target names. ` +
-                'Nx CLI syntax already uses project:target:configuration; use a concrete tool-output target name and keep colon names only as package-script aliases.');
-            failures++;
-        }
-        if (!isRecord(rawTarget)) {
-            continue;
-        }
-        failures += validateTargetDependencies(rawTarget, `${packagePath}: nx.targets.${targetName}`, resolvedTargets);
-    }
-    return failures;
-}
-function validateTargetDependencies(target, label, resolvedTargets) {
-    if (!Array.isArray(target.dependsOn)) {
-        return 0;
-    }
-    let failures = 0;
-    for (const dependency of target.dependsOn) {
-        if (typeof dependency !== 'string') {
-            continue;
-        }
-        if (dependency.includes(':')) {
-            console.error(`${label}.dependsOn must not include colon target dependency ${dependency}`);
-            failures++;
-            continue;
-        }
-        if (label.endsWith('nx.targets.build') &&
-            !dependency.startsWith('^') &&
-            !targetExistsInResolvedProject(dependency, resolvedTargets)) {
-            console.error(`${label}.dependsOn references missing target ${dependency}`);
-            failures++;
-        }
-    }
-    return failures;
-}
-function validateTsconfigTestPolicy(root, packagePath) {
-    const path = join(root, packagePath, 'tsconfig.test.json');
-    const tsconfig = readJsonObject(path);
-    if (!tsconfig) {
-        return 0;
-    }
-    const compilerOptions = recordProperty(tsconfig, 'compilerOptions');
-    let failures = 0;
-    if (!compilerOptions || compilerOptions.noEmit !== true) {
-        console.error(`${packagePath}/tsconfig.test.json compilerOptions.noEmit must be true`);
-        failures++;
-    }
-    if (compilerOptions?.composite === true) {
-        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.composite = true. ` +
-            'Bun test typechecking is a no-emit validation pass, not a TypeScript build-mode project.');
-        failures++;
-    }
-    if (compilerOptions?.declaration === true) {
-        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.declaration = true`);
-        failures++;
-    }
-    if (compilerOptions?.declarationMap === true) {
-        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.declarationMap = true`);
-        failures++;
-    }
-    if (compilerOptions?.outDir === 'dist-test') {
-        console.error(`${packagePath}/tsconfig.test.json must not emit to dist-test`);
-        failures++;
-    }
-    if (typeof compilerOptions?.tsBuildInfoFile === 'string' && compilerOptions.tsBuildInfoFile.includes('dist-test')) {
-        console.error(`${packagePath}/tsconfig.test.json must not write tsbuildinfo under dist-test`);
-        failures++;
-    }
-    return failures;
-}
-function validateTsconfigTestReferencePolicy(root, packagePath) {
-    const testTsconfigPath = join(root, packagePath, 'tsconfig.test.json');
-    if (!existsSync(testTsconfigPath)) {
-        return 0;
-    }
-    const projectTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.json'));
-    if (!projectTsconfigHasTestReference(projectTsconfig)) {
-        return 0;
-    }
-    console.error(`${packagePath}/tsconfig.json must not reference ./tsconfig.test.json. ` +
-        'Test typechecking is run by the inferred typecheck-tests target with tsc --noEmit, not TypeScript build mode.');
-    return 1;
-}
-function validateBunTestTsconfigPresence(root, packagePath, pkg) {
-    if (!usesBunTest(pkg)) {
-        return 0;
-    }
-    const path = join(root, packagePath, 'tsconfig.test.json');
-    if (existsSync(path)) {
-        return 0;
-    }
-    console.error(`${packagePath}: bun test requires tsconfig.test.json because Bun executes tests without typechecking. ` +
-        'Run smoo monorepo validate --fix to create the no-emit test typecheck config.');
-    return 1;
-}
-function applyBunTestTsconfigDefaults(root, packagePath, pkg, workspaceNames) {
-    if (!usesBunTest(pkg)) {
-        return;
-    }
-    const tsconfigTestPath = join(root, packagePath, 'tsconfig.test.json');
-    const existing = readJsonObject(tsconfigTestPath);
-    const tsconfigTest = existing ?? {};
-    let changed = existing === null;
-    changed = applyTsconfigTestDefaults(root, packagePath, pkg, tsconfigTest, workspaceNames) || changed;
-    if (changed) {
-        writeJsonObject(tsconfigTestPath, tsconfigTest);
-        console.log(`updated        ${packagePath}/tsconfig.test.json bun test typecheck config`);
-    }
-    else {
-        console.log(`unchanged      ${packagePath}/tsconfig.test.json bun test typecheck config`);
-    }
-}
-function applyTsconfigTestReferenceDefaults(root, packagePath) {
-    const projectTsconfigPath = join(root, packagePath, 'tsconfig.json');
-    const projectTsconfig = readJsonObject(projectTsconfigPath);
-    if (!projectTsconfig || !projectTsconfigHasTestReference(projectTsconfig)) {
-        return;
-    }
-    const references = Array.isArray(projectTsconfig.references) ? projectTsconfig.references : [];
-    projectTsconfig.references = references.filter((entry) => !isRecord(entry) || entry.path !== './tsconfig.test.json');
-    writeJsonObject(projectTsconfigPath, projectTsconfig);
-    console.log(`updated        ${packagePath}/tsconfig.json removed test project reference`);
-}
-function applyTsconfigTestDefaults(root, packagePath, pkg, tsconfigTest, workspaceNames) {
-    let changed = setMissingStringProperty(tsconfigTest, 'extends', defaultTsconfigTestExtends(root, packagePath));
-    const compilerOptions = getOrCreateRecord(tsconfigTest, 'compilerOptions');
-    changed = copyLibCompilerOptions(root, packagePath, compilerOptions) || changed;
-    changed = setBooleanProperty(compilerOptions, 'composite', false) || changed;
-    changed = setBooleanProperty(compilerOptions, 'declaration', false) || changed;
-    changed = setBooleanProperty(compilerOptions, 'declarationMap', false) || changed;
-    changed = setBooleanProperty(compilerOptions, 'emitDeclarationOnly', false) || changed;
-    changed = setBooleanProperty(compilerOptions, 'noEmit', true) || changed;
-    changed = mergeStringListProperty(compilerOptions, 'types', ['bun']) || changed;
-    if (delete compilerOptions.outDir) {
-        changed = true;
-    }
-    if (delete compilerOptions.tsBuildInfoFile) {
-        changed = true;
-    }
-    changed =
-        mergeStringListProperty(tsconfigTest, 'include', [
-            'src/**/*.test.ts',
-            'src/**/*.spec.ts',
-            'src/**/__tests__/**/*.ts',
-            'src/**/__tests__/**/*.tsx',
-            'src/test-suite-tracer.ts',
-        ]) || changed;
-    for (const referencePath of collectTsconfigTestReferencePaths(root, packagePath, pkg, workspaceNames)) {
-        changed = addTsconfigReference(tsconfigTest, referencePath) || changed;
-    }
-    return changed;
-}
-function defaultTsconfigTestExtends(root, packagePath) {
-    const libTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.lib.json'));
-    return stringProperty(libTsconfig ?? {}, 'extends') ?? '../../tsconfig.base.json';
-}
-function copyLibCompilerOptions(root, packagePath, target) {
-    const libTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.lib.json'));
-    const libCompilerOptions = libTsconfig ? recordProperty(libTsconfig, 'compilerOptions') : null;
-    if (!libCompilerOptions) {
-        return false;
-    }
-    let changed = false;
-    for (const key of ['baseUrl', 'module', 'moduleResolution', 'jsx', 'lib']) {
-        if (hasOwn(libCompilerOptions, key) && target[key] !== libCompilerOptions[key]) {
-            target[key] = libCompilerOptions[key];
-            changed = true;
-        }
-    }
-    return changed;
-}
-function collectTsconfigTestReferencePaths(root, packagePath, pkg, workspaceNames) {
-    const paths = existsSync(join(root, packagePath, 'tsconfig.lib.json')) ? ['./tsconfig.lib.json'] : [];
-    const packagesByName = new Map(getWorkspacePackages(root).map((workspacePkg) => [workspacePkg.name, workspacePkg]));
-    for (const field of workspaceDependencyFields) {
-        const dependencies = recordProperty(pkg, field);
-        if (!dependencies) {
-            continue;
-        }
-        for (const dependencyName of Object.keys(dependencies)) {
-            if (!workspaceNames.has(dependencyName)) {
-                continue;
-            }
-            const dependencyPackage = packagesByName.get(dependencyName);
-            if (!dependencyPackage) {
-                continue;
-            }
-            const dependencyTsconfig = join(root, dependencyPackage.path, 'tsconfig.lib.json');
-            if (!existsSync(dependencyTsconfig)) {
-                continue;
-            }
-            const refPath = relative(join(root, packagePath), dependencyTsconfig).replaceAll('\\', '/');
-            if (!paths.includes(refPath)) {
-                paths.push(refPath);
-            }
-        }
-    }
-    return paths;
-}
-function usesBunTest(pkg) {
-    const scripts = recordProperty(pkg, 'scripts');
-    if (scripts && Object.values(scripts).some((command) => typeof command === 'string' && isBunTestCommand(command))) {
-        return true;
-    }
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets) {
-        return false;
-    }
-    for (const target of Object.values(targets)) {
-        if (!isRecord(target)) {
-            continue;
-        }
-        const options = recordProperty(target, 'options');
-        const command = options ? stringProperty(options, 'command') : null;
-        if (command && isBunTestCommand(command)) {
-            return true;
-        }
-    }
-    return false;
-}
-function isBunTestCommand(command) {
-    return /^bun\s+test(?:\s|$)/.test(parseEnvPrefixedCommand(command).command.trim());
-}
-function mergeStringListProperty(record, key, values) {
-    const rawCurrent = record[key];
-    const current = Array.isArray(rawCurrent)
-        ? rawCurrent.filter((entry) => typeof entry === 'string')
-        : [];
-    const next = [...current];
-    for (const value of values) {
-        if (!next.includes(value)) {
-            next.push(value);
-        }
-    }
-    if (Array.isArray(rawCurrent) &&
-        next.length === rawCurrent.length &&
-        next.every((entry, index) => entry === rawCurrent[index])) {
-        return false;
-    }
-    record[key] = next;
-    return true;
-}
-function addTsconfigReference(tsconfig, path) {
-    const current = Array.isArray(tsconfig.references)
-        ? tsconfig.references.filter((entry) => isRecord(entry))
-        : [];
-    if (current.some((entry) => entry.path === path)) {
-        return false;
-    }
-    tsconfig.references = [...current, { path }];
-    return true;
-}
-function projectTsconfigHasTestReference(projectTsconfig) {
-    return Boolean(projectTsconfig &&
-        Array.isArray(projectTsconfig.references) &&
-        projectTsconfig.references.some((entry) => isRecord(entry) && entry.path === './tsconfig.test.json'));
-}
-function validateBuildZigPolicy(root, packagePath) {
-    const path = join(root, packagePath, 'build.zig');
-    if (!existsSync(path)) {
-        return 0;
-    }
-    if (/\bb\.step\s*\(/.test(readFileSync(path, 'utf8'))) {
-        return 0;
-    }
-    console.error(`${packagePath}/build.zig must define at least one b.step(...) target`);
-    return 1;
-}
-function applyBuildTargetDefault(nxJson) {
-    const targetDefaults = getOrCreateRecord(nxJson, 'targetDefaults');
-    const build = getOrCreateRecord(targetDefaults, 'build');
-    let changed = setBooleanProperty(build, 'cache', true);
-    changed = setStringArrayProperty(build, 'outputs', ['{projectRoot}/dist']) || changed;
-    return changed;
-}
-function validateBuildTargetDefault(nxJson) {
-    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
-    const build = targetDefaults ? recordProperty(targetDefaults, 'build') : null;
-    let failures = 0;
-    if (!build || build.cache !== true) {
-        console.error('nx.json targetDefaults.build.cache must be true');
-        failures++;
-    }
-    const outputs = build?.outputs;
-    if (!Array.isArray(outputs) || outputs.length !== 1 || outputs[0] !== '{projectRoot}/dist') {
-        console.error('nx.json targetDefaults.build.outputs must be ["{projectRoot}/dist"]');
-        failures++;
-    }
-    return failures;
-}
-function applyNamedInputDefaults(nxJson) {
-    const namedInputs = getOrCreateRecord(nxJson, 'namedInputs');
-    let changed = false;
-    if (!Array.isArray(namedInputs.default)) {
-        namedInputs.default = ['{projectRoot}/**/*', 'sharedGlobals'];
-        changed = true;
-    }
-    changed = setStringArrayProperty(namedInputs, 'sharedGlobals', expectedSharedGlobalsNamedInput) || changed;
-    const production = namedInputs.production;
-    if (!Array.isArray(production) || !isPreciseProductionNamedInput(production)) {
-        namedInputs.production = defaultProductionNamedInput;
-        changed = true;
-    }
-    return changed;
-}
-function validateNamedInputDefaults(nxJson) {
-    const namedInputs = recordProperty(nxJson, 'namedInputs');
-    const production = namedInputs?.production;
-    let failures = 0;
-    if (!namedInputs) {
-        console.error('nx.json namedInputs must be configured so production builds have precise cache inputs.');
-        return 1;
-    }
-    if (!Array.isArray(namedInputs.default)) {
-        console.error('nx.json namedInputs.default must be an array; smoo allows it to remain broad for non-production tasks.');
-        failures++;
-    }
-    if (!stringArrayEquals(namedInputs.sharedGlobals, expectedSharedGlobalsNamedInput)) {
-        console.error('nx.json namedInputs.sharedGlobals must include only {workspaceRoot}/.github/workflows/ci.yml');
-        failures++;
-    }
-    if (!Array.isArray(production)) {
-        console.error('nx.json namedInputs.production must be an array of precise production inputs.');
-        return failures + 1;
-    }
-    if (!isPreciseProductionNamedInput(production)) {
-        console.error('nx.json namedInputs.production must enumerate precise production inputs. Do not include default or broad {projectRoot}/** globs; use language/tool-specific paths such as {projectRoot}/src/**/*, {projectRoot}/Cargo.toml, or {projectRoot}/pyproject.toml.');
-        failures++;
-    }
-    return failures;
-}
-function isPreciseProductionNamedInput(production) {
-    let hasPositiveProjectInput = false;
-    for (const input of production) {
-        if (typeof input !== 'string') {
-            return false;
-        }
-        const normalized = input.startsWith('!') ? input.slice(1) : input;
-        if (impreciseProductionInputs.has(input) || impreciseProductionInputs.has(normalized)) {
-            return false;
-        }
-        if (!input.startsWith('!') && normalized.startsWith('{projectRoot}/')) {
-            hasPositiveProjectInput = true;
-        }
-    }
-    return hasPositiveProjectInput;
-}
-function removeColonTargetDefaults(nxJson) {
-    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
-    if (!targetDefaults) {
-        return false;
-    }
-    let changed = false;
-    for (const targetName of Object.keys(targetDefaults)) {
-        if (targetName.includes(':')) {
-            delete targetDefaults[targetName];
-            changed = true;
-        }
-    }
-    return changed;
-}
-function rewriteColonTargetDependenciesInPackage(pkg, resolvedTargets) {
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets) {
-        return false;
-    }
-    const projectName = packageNxProjectName(pkg);
-    const scriptTargetAliases = scriptTargetAliasesForProject(pkg, projectName);
-    let changed = false;
-    for (const target of Object.values(targets)) {
-        if (!isRecord(target) || !Array.isArray(target.dependsOn)) {
-            continue;
-        }
-        target.dependsOn = target.dependsOn.map((dependency) => {
-            if (typeof dependency !== 'string' || !dependency.includes(':')) {
-                return dependency;
-            }
-            const next = scriptTargetAliases.get(dependency) ?? replacementTargetName(dependency, null, resolvedTargets);
-            if (!next) {
-                return dependency;
-            }
-            changed = true;
-            return next;
-        });
-    }
-    return changed;
-}
-function scriptTargetAliasesForProject(pkg, projectName) {
-    if (!projectName) {
-        return new Map();
-    }
-    const scripts = recordProperty(pkg, 'scripts');
-    if (!scripts) {
-        return new Map();
-    }
-    const aliases = new Map();
-    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
-        if (typeof rawCommand !== 'string' || !scriptName.includes(':')) {
-            continue;
-        }
-        const alias = parseNxRunAlias(rawCommand);
-        if (alias?.projectName === projectName && !alias.targetName.includes(':')) {
-            aliases.set(scriptName, alias.targetName);
-        }
-    }
-    return aliases;
-}
-function removePackageColonTargets(pkg) {
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets) {
-        return false;
-    }
-    let changed = false;
-    for (const targetName of Object.keys(targets)) {
-        if (targetName.includes(':')) {
-            delete targets[targetName];
-            changed = true;
-        }
-    }
-    return changed;
-}
-function resolvedProjectTargetNames(resolvedProject) {
-    if (!resolvedProject) {
-        return undefined;
-    }
-    return isResolvedProjectTargets(resolvedProject) ? resolvedProject.targets : resolvedProject;
-}
-function resolvedProjectBuildDependsOn(resolvedProject) {
-    if (!isResolvedProjectTargets(resolvedProject)) {
-        return undefined;
-    }
-    return resolvedProject.buildDependsOn;
-}
-function isResolvedProjectTargets(value) {
-    return isRecord(value) && value.targets instanceof Set;
-}
-function removeRedundantNoopBuildTarget(pkg, resolvedProject) {
-    const resolvedTargets = resolvedProjectTargetNames(resolvedProject);
-    const resolvedBuildDependsOn = resolvedProjectBuildDependsOn(resolvedProject);
-    if (!resolvedTargets?.has('build') || !resolvedBuildDependsOn) {
-        return false;
-    }
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    const build = targets ? recordProperty(targets, 'build') : null;
-    if (!targets ||
-        !build ||
-        !isNoopTarget(build) ||
-        !targetDependenciesMatchResolvedBuild(build, resolvedBuildDependsOn)) {
-        return false;
-    }
-    delete targets.build;
-    return true;
-}
-function isNoopTarget(target) {
-    const executor = stringProperty(target, 'executor');
-    if (executor !== null && executor !== 'nx:noop') {
-        return false;
-    }
-    const options = recordProperty(target, 'options');
-    return !options || stringProperty(options, 'command') === null;
-}
-function targetDependenciesMatchResolvedBuild(target, resolvedBuildDependsOn) {
-    if (!Array.isArray(target.dependsOn)) {
-        return false;
-    }
-    const expected = new Set(resolvedBuildDependsOn);
-    if (target.dependsOn.length !== expected.size) {
-        return false;
-    }
-    return target.dependsOn.every((dependency) => {
-        if (typeof dependency !== 'string') {
-            return false;
-        }
-        return expected.has(dependency);
-    });
-}
-function migratePackageColonTargets(pkg, resolvedTargets) {
-    const nx = recordProperty(pkg, 'nx');
-    const targets = nx ? recordProperty(nx, 'targets') : null;
-    if (!targets) {
-        return false;
-    }
-    const projectName = packageNxProjectName(pkg);
-    const scripts = recordProperty(pkg, 'scripts');
-    let changed = false;
-    const renamedTargets = new Map();
-    for (const [targetName, rawTarget] of Object.entries(targets)) {
-        if (!targetName.includes(':') || !isRecord(rawTarget)) {
-            continue;
-        }
-        const nextTargetName = replacementTargetName(targetName, targetCommand(rawTarget), resolvedTargets);
-        if (!nextTargetName || nextTargetName.includes(':')) {
-            continue;
-        }
-        if (!targetExistsInResolvedProject(nextTargetName, resolvedTargets)) {
-            targets[nextTargetName] = rawTarget;
-        }
-        delete targets[targetName];
-        renamedTargets.set(targetName, nextTargetName);
-        changed = true;
-    }
-    if (renamedTargets.size === 0) {
-        return changed;
-    }
-    for (const target of Object.values(targets)) {
-        if (isRecord(target)) {
-            changed = rewriteTargetDependencies(target, renamedTargets) || changed;
-        }
-    }
-    if (scripts && projectName) {
-        for (const [scriptName, rawCommand] of Object.entries(scripts)) {
-            if (typeof rawCommand !== 'string') {
-                continue;
-            }
-            const alias = parseNxRunAlias(rawCommand);
-            if (!alias || alias.projectName !== projectName) {
-                continue;
-            }
-            const nextTargetName = renamedTargets.get(alias.targetName);
-            if (!nextTargetName) {
-                continue;
-            }
-            scripts[scriptName] = nxRunAlias(projectName, nextTargetName, isContinuousTarget(nextTargetName, ''));
-            changed = true;
-        }
-    }
-    return changed;
-}
-function rewriteTargetDependencies(target, renamedTargets) {
-    if (!Array.isArray(target.dependsOn)) {
-        return false;
-    }
-    let changed = false;
-    target.dependsOn = target.dependsOn.map((dependency) => {
-        if (typeof dependency !== 'string') {
-            return dependency;
-        }
-        const next = renamedTargets.get(dependency);
-        if (!next) {
-            return dependency;
-        }
-        changed = true;
-        return next;
-    });
-    return changed;
-}
-function targetCommand(target) {
-    const options = recordProperty(target, 'options');
-    return options ? stringProperty(options, 'command') : null;
-}
-function replacementTargetName(targetName, command, resolvedTargets) {
-    if (command) {
-        const commandTargetName = targetNameForCommand(command);
-        if (commandTargetName) {
-            return commandTargetName;
-        }
-    }
-    const suffix = targetName.slice(targetName.lastIndexOf(':') + 1);
-    if (suffix && targetExistsInResolvedProject(suffix, resolvedTargets)) {
-        return suffix;
-    }
-    const dashed = targetName.replaceAll(':', '-');
-    if (targetExistsInResolvedProject(dashed, resolvedTargets)) {
-        return dashed;
-    }
-    return null;
-}
-function expectedNxJsTypescriptPlugin() {
-    return {
-        plugin: nxJsTypescriptPlugin,
-        options: {
-            typecheck: { targetName: 'typecheck' },
-            build: {
-                targetName: 'tsc-js',
-                configName: 'tsconfig.lib.json',
-                buildDepsName: 'build-deps',
-                watchDepsName: 'watch-deps',
-            },
-        },
-    };
-}
-function upsertNxPlugin(plugins, plugin) {
-    const pluginName = typeof plugin === 'string' ? plugin : stringProperty(plugin, 'plugin');
-    const next = plugins.filter((entry) => nxPluginName(entry) !== pluginName);
-    next.push(plugin);
-    return next;
-}
-function nxPluginName(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    return isRecord(value) ? stringProperty(value, 'plugin') : null;
-}
-function isNxJsTypescriptPlugin(value) {
-    return isRecord(value) && stringProperty(value, 'plugin') === nxJsTypescriptPlugin;
-}
-function isSmoothBricksNxPluginRecord(value) {
-    return isRecord(value) && stringProperty(value, 'plugin') === smoothBricksNxPlugin;
-}
-function nxJsBuildTargetName(plugin) {
-    const options = recordProperty(plugin, 'options');
-    const build = options ? recordProperty(options, 'build') : null;
-    return build ? stringProperty(build, 'targetName') : null;
-}
-function applyPackageNxConfig(pkg, options) {
-    const nx = getOrCreateRecord(pkg, 'nx');
-    const changed = setStringProperty(nx, 'name', options.projectName);
-    const targets = options.targets === true ? getOrCreateRecord(nx, 'targets') : null;
-    return { nx, targets, changed };
-}
-function packageNxProjectName(pkg) {
-    const nx = recordProperty(pkg, 'nx');
-    return (nx ? stringProperty(nx, 'name') : null) ?? stringProperty(pkg, 'name');
-}
-function classifyScriptRewrite(scriptName, command) {
-    if (isNxRunAlias(command) || isBlockedScriptCommand(scriptName, command)) {
-        return null;
-    }
-    const parsed = parseEnvPrefixedCommand(command);
-    const targetName = rewriteTargetName(scriptName, parsed.command);
-    if (!targetName || !isSafeNxScriptCommand(parsed.command)) {
+function suggestNxProjectName(rootPackageName, packageName) {
+    const rootScope = npmScope(rootPackageName);
+    if (!rootScope || npmScope(packageName) !== rootScope) {
         return null;
     }
-    return {
-        targetName,
-        continuous: isContinuousTarget(targetName, parsed.command),
-        command: parsed.command,
-        env: parsed.env,
-    };
-}
-function rewriteTargetName(scriptName, command) {
-    return targetNameForCommand(command) ?? (scriptName.includes(':') ? null : scriptName);
-}
-function targetNameForCommand(command) {
-    const trimmed = command.trim();
-    if (/^tsc\s+--build\s+tsconfig\.lib\.json(?:\s|$)/.test(trimmed)) {
-        return 'tsc-js';
-    }
-    const zigStep = /^zig\s+build\s+([A-Za-z0-9_-]+)(?:\s|$)/.exec(trimmed)?.[1];
-    if (zigStep) {
-        return `zig-${zigStep}`;
-    }
-    if (/^wrangler\s+build(?:\s|$)/.test(trimmed)) {
-        return 'build';
-    }
-    return null;
-}
-function nxRunAlias(projectName, targetName, continuous) {
-    const flags = continuous ? ' --tui=false --outputStyle=stream' : '';
-    return `nx run ${projectName}:${targetName}${flags}`;
-}
-function expectedTargetDependencies(targetName) {
-    return targetName === 'preview' ? ['build'] : ['^build'];
-}
-function targetExistsInResolvedProject(targetName, resolvedTargets) {
-    return resolvedTargets?.has(targetName) === true;
-}
-function setStringArrayProperty(record, key, value) {
-    const current = record[key];
-    if (stringArrayEquals(current, value)) {
-        return false;
-    }
-    record[key] = value;
-    return true;
-}
-function stringArrayEquals(value, expected) {
-    return (Array.isArray(value) && value.length === expected.length && value.every((entry, index) => entry === expected[index]));
-}
-function targetDependsOn(target, expected) {
-    const dependsOn = target.dependsOn;
-    return Array.isArray(dependsOn) && expected.every((entry) => dependsOn.includes(entry));
-}
-function hasWorkspaceDependency(pkg, workspaceNames) {
-    for (const field of workspaceDependencyFields) {
-        const dependencies = recordProperty(pkg, field);
-        if (!dependencies) {
-            continue;
-        }
-        for (const name of Object.keys(dependencies)) {
-            if (workspaceNames.has(name)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function isSafeNxScriptCommand(command) {
-    const trimmed = command.trim();
-    return (/^bun\s+test(?:\s|$)/.test(trimmed) ||
-        /^tsc-bun-test(?:\s|$)/.test(trimmed) ||
-        /^vitest(?:\s|$)/.test(trimmed) ||
-        /^tsc\s+(?:--build|--noEmit)(?:\s|$)/.test(trimmed) ||
-        /^tsdown(?:\s|$)/.test(trimmed) ||
-        /^vite\s+(?:build|dev|preview)(?:\s|$)/.test(trimmed) ||
-        /^astro\s+(?:build|dev|preview|check)(?:\s|$)/.test(trimmed) ||
-        /^zig\s+build(?:\s|$)/.test(trimmed) ||
-        /^bun\s+[./\w-]*build[\w.-]*\.ts(?:\s|$)/.test(trimmed) ||
-        /(?:^|\s)(?:bench|benchmark)(?:\s|$)/.test(trimmed) ||
-        /^wrangler\s+build(?:\s|$)/.test(trimmed));
-}
-function isBlockedScriptCommand(scriptName, command) {
-    if (/^(?:deploy|db|release|sync|subtree|publish|pack)(?::|$)/.test(scriptName)) {
-        return true;
-    }
-    const trimmed = parseEnvPrefixedCommand(command).command;
-    return /^(?:deploy|db|release|sync|subtree|publish|pack)(?:\s|$)/.test(trimmed) || trimmed === 'astro';
-}
-function parseEnvPrefixedCommand(command) {
-    const env = {};
-    let rest = command.trimStart();
-    while (true) {
-        const match = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(rest);
-        if (!match?.[1]) {
-            return { command: rest.trim(), env };
-        }
-        let index = match[0].length;
-        let value = '';
-        const quote = rest[index];
-        if (quote === '"' || quote === "'") {
-            index += 1;
-            const end = rest.indexOf(quote, index);
-            if (end === -1) {
-                return { command: command.trim(), env: {} };
-            }
-            value = rest.slice(index, end);
-            index = end + 1;
-        }
-        else {
-            const end = rest.slice(index).search(/\s/);
-            const valueEnd = end === -1 ? rest.length : index + end;
-            value = rest.slice(index, valueEnd);
-            index = valueEnd;
-        }
-        if (index < rest.length && !/\s/.test(rest[index] ?? '')) {
-            return { command: command.trim(), env: {} };
-        }
-        env[match[1]] = value;
-        rest = rest.slice(index).trimStart();
-    }
-}
-function isContinuousTarget(targetName, command) {
-    return (/(?:^|:|-)(?:dev|serve|preview|watch)(?:$|:|-)/.test(targetName) ||
-        /(?:^|\s)(?:dev|serve|preview|--watch|-w)(?:\s|$)/.test(command));
+    return unscopedPackageName(packageName);
 }
-function isNxRunAlias(command) {
-    return /^nx\s+run\s+\S+:\S+/.test(command.trim());
+function npmScope(packageName) {
+    const match = /^(@[^/]+)\//.exec(packageName);
+    return match?.[1] ?? null;
 }
-function parseNxRunAlias(command) {
-    const match = /^nx\s+run\s+([^:\s]+):([^\s]+)(?:\s|$)/.exec(command.trim());
-    if (!match?.[1] || !match[2]) {
-        return null;
-    }
-    return { projectName: match[1], targetName: match[2] };
+function unscopedPackageName(packageName) {
+    return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
 }
 function recordKeysAreSorted(record) {
     const keys = Object.keys(record);
@@ -1451,37 +418,6 @@ function sortRecordInPlace(record) {
     }
     return true;
 }
-function isScriptRunnerCommand(command, scriptName) {
-    if (!command) {
-        return false;
-    }
-    const escaped = escapeRegex(scriptName);
-    return new RegExp(`^(?:bun|npm)\\s+run\\s+${escaped}(?:\\s|$)`).test(command.trim());
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function suggestNxProjectName(rootPackageName, packageName) {
-    const rootScope = npmScope(rootPackageName);
-    if (!rootScope || npmScope(packageName) !== rootScope) {
-        return null;
-    }
-    return unscopedPackageName(packageName);
-}
-function npmScope(packageName) {
-    const match = /^(@[^/]+)\//.exec(packageName);
-    return match?.[1] ?? null;
-}
-function unscopedPackageName(packageName) {
-    return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
-}
-function setBooleanProperty(record, key, value) {
-    if (record[key] === value) {
-        return false;
-    }
-    record[key] = value;
-    return true;
-}
 function normalizeExportConditionOrder(value) {
     if (!isRecord(value)) {
         return false;