@hublo/sentinel 1.5.0 → 1.5.1-alpha.0

package/README.md

@@ -57,7 +57,8 @@ pnpm install   # fetch what --init declared, then commit
 
 With no target named, `--init` adopts every role, in the order that makes the result correct:
 the linter's autofix runs, then the formatter runs **last** and formats everything every role
-wrote. Naming one target (`--init --lint`) adopts just that role and leaves the rest alone.
+wrote. Naming a target (`--init --build`) adopts just that role and leaves the rest alone, with
+one pairing: lint and format are always adopted together, so `--init --lint` adopts oxfmt too.
 
 `--init` writes the config stubs, the `typecheck`/`lint`/... scripts, and pins the `@hublo/sentinel` devDependency into the module (no manual `pnpm add`); it scaffolds a `package.json` for a `project.json`-only module. It also applies, once, the workspace prep that module needs at the root, only when the root's own config shows it is needed (e.g. an i18next singleton override when the repo runs a second TypeScript, a release-age allow-list when the repo uses that pnpm gate). See the [adoption cheat sheet](docs/typescript-adoption.md) for the full list.
 
@@ -412,6 +413,7 @@ OPTIONS    --module <name>    from the root: scope to one module
            --ci               from the root: affected only; non-zero exit on failure
            --fix              auto-fix where applicable
            --dry-run          preview a --init without writing
+           --rehearse         with --dry-run: run the autofixes in a copy, name the source they rewrite
            --json             machine-readable output (report / inspect / status / --dry-run)
            -- <tool options>  --run only: pass the rest to the tool itself (one type)
 

package/dist/bin/sentinel.js

@@ -8,19 +8,20 @@ import {
   describeFramework,
   dispatch,
   palette,
+  presetNotInstalledYet,
   registerAdapters,
   resolve
-} from "../chunk-MOELAQPC.js";
+} from "../chunk-CL7HOHTU.js";
 import {
   resolveContext
-} from "../chunk-43HQ6BVJ.js";
+} from "../chunk-I2WDZNPR.js";
 import {
   ensureWorkspacePrep,
   findWorkspaceRoot,
   inspectWorkspacePrep,
   readOwnVersion,
   readProjectPackageJson
-} from "../chunk-IL5PPLXE.js";
+} from "../chunk-JRZI5IIN.js";
 import {
   LONG_RUNNING_TARGETS,
   OUTPUT_SHAPES,
@@ -35,15 +36,129 @@ import "../chunk-QXFCZON7.js";
 // bin/sentinel.ts
 import { program } from "commander";
 
+// src/core/rehearse.ts
+import { createHash } from "node:crypto";
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, relative, sep } from "node:path";
+var NOT_COPIED = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function contents(root) {
+  const found = /* @__PURE__ */ new Map();
+  const queue = [root];
+  while (queue.length > 0) {
+    const dir = queue.pop();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!NOT_COPIED.has(entry.name)) queue.push(path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      found.set(relative(root, path), createHash("sha1").update(readFileSync(path)).digest("hex"));
+    }
+  }
+  return found;
+}
+function stage(moduleDir, scratch) {
+  const root = findWorkspaceRoot(moduleDir);
+  const segments = root === void 0 ? [basename(moduleDir)] : relative(root, moduleDir).split(sep).filter((segment) => segment !== "");
+  let real = root ?? dirname(moduleDir);
+  let shadow = scratch;
+  for (const segment of segments) {
+    for (const entry of root === void 0 ? [] : readdirSync(real)) {
+      if (entry === segment || entry === ".git") continue;
+      symlinkSync(join(real, entry), join(shadow, entry));
+    }
+    real = join(real, segment);
+    shadow = join(shadow, segment);
+    mkdirSync(shadow);
+  }
+  rmSync(shadow, { recursive: true, force: true });
+  cpSync(moduleDir, shadow, {
+    recursive: true,
+    filter: (source) => source === moduleDir || !NOT_COPIED.has(basename(source)) && !lstatSync(source).isSymbolicLink()
+  });
+  if (existsSync(join(moduleDir, "node_modules"))) {
+    symlinkSync(join(moduleDir, "node_modules"), join(shadow, "node_modules"), "dir");
+  }
+  return shadow;
+}
+async function rehearseAfterInit(moduleDir, roles) {
+  const rehearsing = roles.filter((role) => role.adapter.rehearseAfterInit !== void 0);
+  if (rehearsing.length === 0) return [];
+  const scratch = realpathSync(mkdtempSync(join(tmpdir(), "sentinel-rehearsal-")));
+  try {
+    let copy;
+    try {
+      copy = stage(moduleDir, scratch);
+    } catch (error) {
+      const failure = error instanceof Error ? error.message : String(error);
+      return rehearsing.map((role) => ({ target: role.target, rewrites: [], failure }));
+    }
+    const planned = /* @__PURE__ */ new Set();
+    for (const role of roles) {
+      for (const file of role.files) {
+        planned.add(file.path);
+        const target = join(copy, file.path);
+        if (file.deleted) {
+          rmSync(target, { force: true });
+          continue;
+        }
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, file.after);
+      }
+    }
+    const results = [];
+    for (const role of rehearsing) {
+      const before = contents(copy);
+      const failure = await role.adapter.rehearseAfterInit?.(
+        {
+          module: basename(moduleDir),
+          cwd: copy,
+          preset: role.preset,
+          ci: false,
+          fix: true,
+          written: role.files.filter((file) => !file.deleted).map((file) => file.path)
+        },
+        moduleDir
+      );
+      const after = contents(copy);
+      const rewrites = [...after].filter(([path, hash]) => before.get(path) !== hash && !planned.has(path)).map(([path]) => path).sort();
+      results.push({
+        target: role.target,
+        rewrites,
+        // The tool names files by the path it read them from, which is the copy. Said as the
+        // module's own paths: the copy is gone by the time anyone reads this.
+        ...failure === void 0 ? {} : { failure: failure.replaceAll(`${copy}/`, "").replaceAll(copy, ".") }
+      });
+    }
+    return results;
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
 // src/roles/build/declined.ts
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 var DEPRECATED_NX_BUILDER = "@nx/webpack:webpack";
 function buildsWithDeprecatedExecutor(cwd2) {
-  const projectJson = join(cwd2, "project.json");
-  if (!existsSync(projectJson)) return false;
+  const projectJson = join2(cwd2, "project.json");
+  if (!existsSync2(projectJson)) return false;
   try {
-    const project = JSON.parse(readFileSync(projectJson, "utf8"));
+    const project = JSON.parse(readFileSync2(projectJson, "utf8"));
     return project.targets?.build?.executor === DEPRECATED_NX_BUILDER;
   } catch {
     return false;
@@ -63,6 +178,30 @@ function explainDecline(cwd2) {
 function asMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var ADOPTED_TOGETHER = ["lint", "format"];
+function pairedTargets(named, available) {
+  if (!named.some((type) => ADOPTED_TOGETHER.includes(type))) return [];
+  return ADOPTED_TOGETHER.filter((type) => available.includes(type) && !named.includes(type));
+}
+var NAMED_REWRITES = 10;
+var AUTOFIX_TOOL = { lint: "linter", format: "formatter" };
+function describeUnrehearsed(target) {
+  return `the ${target} autofix runs on adoption and can rewrite source, as moving to another ${AUTOFIX_TOOL[target] ?? "tool"} does; add --rehearse to name the files (it runs the pass in a throwaway copy, as long as the real one)`;
+}
+function describeRehearsal(target, rewrites, failure) {
+  const pass = `the ${target} autofix`;
+  const said = failure === void 0 ? "" : ` (it also reported: ${failure})`;
+  if (rewrites.length === 0) {
+    if (failure === void 0) return `${pass} would rewrite nothing beyond the files above`;
+    if (presetNotInstalledYet(failure)) {
+      return `${pass} cannot be rehearsed yet: its preset is not installed in this module, which is expected before the first \`pnpm install\`. After it, this dry-run names what it rewrites`;
+    }
+    return `could not rehearse ${pass}, so what it rewrites is not known: ${failure}`;
+  }
+  const named = rewrites.slice(0, NAMED_REWRITES).join(", ");
+  const rest = rewrites.length - NAMED_REWRITES;
+  return `${pass} would rewrite ${rewrites.length} file${rewrites.length === 1 ? "" : "s"} beyond the ones above: ${rest > 0 ? `${named} and ${rest} more` : named}${said}`;
+}
 async function runInit(ctx) {
   const { modules, scope } = resolveContext(ctx.cwd, { module: ctx.module, ci: false });
   const [module] = modules;
@@ -80,11 +219,24 @@ async function runInit(ctx) {
       );
     }
   }
-  const toRun = ctx.targets.filter((type) => available.includes(type)).sort((a, b) => Number(a === "format") - Number(b === "format"));
+  const named = ctx.targets.filter((type) => available.includes(type));
+  const paired = pairedTargets(named, available);
+  const toRun = [...named, ...paired].sort(
+    (a, b) => Number(a === "format") - Number(b === "format")
+  );
+  for (const type of paired) {
+    process.stderr.write(
+      palette(process.stderr).dim(
+        `  adopting --${type} too: lint and format are adopted together, see the lint adoption guide
+`
+      )
+    );
+  }
   const outcomes = [];
   const record = (outcome) => {
     outcomes.push(outcome);
   };
+  const planned = [];
   let worst = 0;
   for (const type of toRun) {
     try {
@@ -96,12 +248,13 @@ async function runInit(ctx) {
         preset: ctx.preset,
         dryRun: ctx.dryRun,
         json: ctx.json,
-        record
+        record,
+        planned: (role) => planned.push(role)
       });
       worst = Math.max(worst, code);
     } catch (error) {
       if (error instanceof PresetUnsupportedError) {
-        if (ctx.targetsExplicit) {
+        if (ctx.targetsExplicit && !paired.includes(type)) {
           const hint = type === "build" ? explainDecline(module.root) : ` Pass --preset if it was detected wrongly (hoisted dependencies make detection fall back to "node").`;
           process.stderr.write(
             `
@@ -124,6 +277,21 @@ sentinel (${type}): ${asMessage(error)}
       worst = Math.max(worst, 1);
     }
   }
+  if (ctx.dryRun && worst === 0 && !ctx.rehearse && !ctx.json) {
+    for (const { target } of planned.filter((role) => role.adapter.rehearseAfterInit)) {
+      process.stderr.write(`  dry run: ${describeUnrehearsed(target)}
+`);
+    }
+  }
+  if (ctx.dryRun && worst === 0 && ctx.rehearse) {
+    for (const { target, rewrites, failure } of await rehearseAfterInit(module.root, planned)) {
+      const outcome = outcomes.find((entry) => entry.role === target);
+      if (outcome !== void 0) outcome.rewrites = rewrites;
+      if (ctx.json) continue;
+      process.stderr.write(`  dry run: ${describeRehearsal(target, rewrites, failure)}
+`);
+    }
+  }
   let workspace = [];
   if (worst === 0) {
     const root = findWorkspaceRoot(module.root);
@@ -172,7 +340,7 @@ async function runValidate(ctx) {
     );
   }
   if (!ctx.targets.includes("test")) return 1;
-  const { validateModuleTests } = await import("../validate-FRMENKHM.js");
+  const { validateModuleTests } = await import("../validate-S6PIOVAH.js");
   const outcomes = modules.flatMap(
     (module) => validateModuleTests(module.name, module.root)
   );
@@ -627,7 +795,10 @@ program.name("sentinel").description("One CLI that guards code health: presets,
 ).option("--report", "deprecated: use --run --json").option("--status", "deprecated: use --inspect").option(
   "--module <name>",
   "from the workspace root: scope to one module (omit = all; inside a module dir, drop this)"
-).option("--preset <name>", `the stack preset to apply (${PRESET_NAMES.join(", ")})`).option("--flavour <name>", "deprecated: use --preset").option("--runner <tool>", "override the default runner (e.g. eslint, biome)").option("--ci", "CI mode: from the root, only the affected modules; non-zero exit on failure").option("--fix", "auto-fix where applicable").option("--dry-run", "preview the changes without writing (--init)").option("--json", "machine-readable output, for every verb").option(
+).option("--preset <name>", `the stack preset to apply (${PRESET_NAMES.join(", ")})`).option("--flavour <name>", "deprecated: use --preset").option("--runner <tool>", "override the default runner (e.g. eslint, biome)").option("--ci", "CI mode: from the root, only the affected modules; non-zero exit on failure").option("--fix", "auto-fix where applicable").option("--dry-run", "preview the changes without writing (--init)").option(
+  "--rehearse",
+  "with --init --dry-run: run the lint and format autofixes in a throwaway copy and name the source they rewrite (as slow as the real pass)"
+).option("--json", "machine-readable output, for every verb").option(
   "--output <shape>",
   "output shape for a role that writes reports (console, json, html, markdown); console by default"
 ).option(
@@ -742,6 +913,11 @@ if (!Number.isInteger(maxDiagnostics) || maxDiagnostics < 0) {
 if (opts.dryRun && verb !== "init") {
   program.error("--dry-run only applies to --init (the read verbs never write).");
 }
+if (opts.rehearse && !opts.dryRun) {
+  program.error(
+    "--rehearse only applies to --init --dry-run: the real --init runs the autofix passes themselves."
+  );
+}
 if (toolArgs.length > 0) {
   if (verb !== "run") {
     program.error(
@@ -781,6 +957,7 @@ async function main() {
     // a role that writes reports: two ways to ask for the same thing would be a trap.
     output: parseOutput(opts.output, Boolean(opts.json)) ?? (opts.json ? "json" : void 0),
     dryRun: Boolean(opts.dryRun),
+    rehearse: Boolean(opts.rehearse),
     fail: (message) => program.error(message)
   };
   const exitCode = verb === "init" ? await runInit(context) : verb === "validate" ? await runValidate(context) : await runVerb(context);

package/dist/{chunk-MOELAQPC.js → chunk-CL7HOHTU.js}

@@ -55,7 +55,7 @@ import {
   splitToolArgs,
   walk,
   writtenFileFormatter
-} from "./chunk-43HQ6BVJ.js";
+} from "./chunk-I2WDZNPR.js";
 import {
   DEFAULT_MAX_DIAGNOSTICS,
   WORKSPACE_ROOT_MARKER,
@@ -64,7 +64,7 @@ import {
   ownPackageDir,
   readOwnPackage,
   readProjectPackageJson
-} from "./chunk-IL5PPLXE.js";
+} from "./chunk-JRZI5IIN.js";
 import {
   PRESET_NAMES,
   REPORT_DIR,
@@ -1655,6 +1655,22 @@ var OxfmtAdapter = class extends BaseAdapter {
    * walks targets in order), so what the linter rewrote gets formatted rather than the
    * other way round.
    */
+  /**
+   * The same `oxfmt --write .`, in the copy `--init --dry-run` hands it, and silent. See
+   * `Adapter.rehearseAfterInit`. It runs after the lint rehearsal for the reason `afterInit` runs
+   * after the lint fix, so what the linter rewrote is what gets formatted.
+   *
+   * The copy sits where the module sits in a stand-in workspace, and that matters to this tool in
+   * particular: oxfmt reads the nearest `.editorconfig` upwards (verified: an `indent_style = tab`
+   * two levels up reindented a file), and the root of this repo has one.
+   */
+  async rehearseAfterInit(ctx, origin) {
+    const oxfmt = resolveOxfmt(origin);
+    if (!oxfmt) return "oxfmt is not installed in this module yet";
+    const pass = spawnSync3(oxfmt, ["--write", "."], { cwd: ctx.cwd, encoding: "utf8" });
+    if (pass.error) return pass.error.message;
+    return pass.status === 0 ? void 0 : oxfmtSaid(`${pass.stdout ?? ""}${pass.stderr ?? ""}`);
+  }
   async afterInit(ctx) {
     const oxfmt = resolveOxfmt(ctx.cwd);
     if (!oxfmt) return;
@@ -1967,6 +1983,9 @@ function changedSince(cwd, before, extensions) {
 }
 var NAMED_IN_REPORT = 5;
 var NOT_INSTALLED_YET = /invalid config file[\s\S]*node_modules/i;
+function presetNotInstalledYet(failure) {
+  return NOT_INSTALLED_YET.test(failure);
+}
 function describeFixOutcome(outcome, toolLabel) {
   if (outcome.failure !== void 0) {
     if (NOT_INSTALLED_YET.test(outcome.failure)) {
@@ -4788,8 +4807,13 @@ function plan2(context2) {
     ...rootIgnores.patterns
   ].filter((pattern) => !defaults2.has(bare(pattern)));
   const carried = [.../* @__PURE__ */ new Set([...DEFAULT_IGNORE_PATTERNS, ...moduleOwn])];
+  const { kept: teamRules, governed: droppedRules } = moduleOwnRules(
+    committedRules(context2.cwd),
+    lintPresetFor(variant)
+  );
   const stub = {
     extends: extendsWithPreset(committedExtends(context2.cwd), variant),
+    ...Object.keys(teamRules).length > 0 ? { rules: teamRules } : {},
     ...carried.length > 0 ? { ignorePatterns: carried } : {}
   };
   const operations = [
@@ -4838,6 +4862,16 @@ function plan2(context2) {
   if (eslintConfigs.length > 0) {
     notes.push(`removed ${eslintConfigs.join(", ")} and pointed the nx lint target at oxlint`);
   }
+  if (Object.keys(teamRules).length > 0) {
+    notes.push(
+      `kept ${Object.keys(teamRules).length} rule(s) this module set itself (${Object.keys(teamRules).join(", ")}): the preset does not configure them`
+    );
+  }
+  if (droppedRules.length > 0) {
+    notes.push(
+      `dropped ${droppedRules.length} rule(s) this module set over the preset (${droppedRules.join(", ")}): the preset governs them`
+    );
+  }
   if (rootIgnores.patterns.length > 0) {
     notes.push(
       `carried ${rootIgnores.patterns.length} ignore pattern(s) from the workspace eslint config (${rootIgnores.patterns.join(", ")}): this module is linted by that config today, so without them adoption would start linting what the repo has always excluded`
@@ -4867,7 +4901,7 @@ function plan2(context2) {
   if (keepsOtherCommands3(script)) {
     const stillPrettier = /(^|[\s/])prettier(\s|$)/.test(script);
     notes.push(
-      `kept the rest of the lint script (\`${script}\`): only the eslint part is sentinel's` + (stillPrettier ? ". Run `sentinel --init --format` to move the formatting part too" : "")
+      `kept the rest of the lint script (\`${script}\`): only the eslint part is sentinel's` + (stillPrettier ? "; the format role, adopted with it, moves the prettier part" : "")
     );
   }
   notes.push(
@@ -4910,6 +4944,31 @@ function committedExtends(cwd) {
     return [];
   }
 }
+function committedRules(cwd) {
+  try {
+    const parsed = parseJsonc(
+      readFileSync12(join15(cwd, LINT_CONFIG_FILE), "utf8"),
+      LINT_CONFIG_FILE
+    );
+    const rules = parsed.rules;
+    return typeof rules === "object" && rules !== null && !Array.isArray(rules) ? rules : {};
+  } catch {
+    return {};
+  }
+}
+function moduleOwnRules(committed, preset) {
+  const governedNames = /* @__PURE__ */ new Set([
+    ...Object.keys(preset.rules),
+    ...(preset.overrides ?? []).flatMap((override) => Object.keys(override.rules))
+  ]);
+  const kept = {};
+  const governed = [];
+  for (const [rule, value] of Object.entries(committed)) {
+    if (governedNames.has(rule)) governed.push(rule);
+    else kept[rule] = value;
+  }
+  return { kept, governed };
+}
 function committedIgnorePatterns(cwd) {
   try {
     const parsed = parseJsonc(
@@ -5041,6 +5100,16 @@ ${result.stderr ?? ""}`);
 `);
     this.writeModuleBaseline(ctx, oxlint, env);
   }
+  /**
+   * The fix pass alone, in the copy `--init --dry-run` hands it, without the baseline measurement
+   * that follows it for real. See `Adapter.rehearseAfterInit`.
+   */
+  async rehearseAfterInit(ctx, origin) {
+    const oxlint = resolveOxlint(origin);
+    if (!oxlint) return "oxlint is not installed in this module yet";
+    const env = { ...process.env, PATH: oxlintPath(origin, process.env) };
+    return this.fixPass(ctx, oxlint, env).failure;
+  }
   /**
    * Measure what THIS module already violates, and hold exactly those rules at `warn`.
    *
@@ -10221,8 +10290,8 @@ function resolveFlavour(opts) {
   }
   return detection.preset;
 }
-function previewPlan(opts, plan3) {
-  const changed = preparePlan(opts.cwd, plan3).filter((file) => file.before !== file.after);
+function previewPlan(opts, plan3, prepared) {
+  const changed = prepared.filter((file) => file.before !== file.after);
   if (opts.json) {
     opts.record?.({
       role: opts.target,
@@ -10304,7 +10373,14 @@ async function dispatch(opts) {
     return 0;
   }
   if (opts.dryRun) {
-    return previewPlan(opts, plan3);
+    const prepared = preparePlan(opts.cwd, plan3);
+    opts.planned?.({
+      target: opts.target,
+      adapter,
+      preset,
+      files: prepared.filter((file) => file.before !== file.after)
+    });
+    return previewPlan(opts, plan3, prepared);
   }
   if (adapter.beforeInit) {
     await adapter.beforeInit({
@@ -10357,6 +10433,7 @@ export {
   resolve,
   buildConfigFile,
   palette,
+  presetNotInstalledYet,
   registerAdapters,
   correctingSignal,
   describeFramework,

package/dist/{chunk-43HQ6BVJ.js → chunk-I2WDZNPR.js}

@@ -6,7 +6,7 @@ import {
   readNxProjectName,
   readOwnPackage,
   readProjectPackageJson
-} from "./chunk-IL5PPLXE.js";
+} from "./chunk-JRZI5IIN.js";
 import {
   matchesTsconfigPattern
 } from "./chunk-O7REVMOC.js";
@@ -819,42 +819,78 @@ function lineLostByTheFixer(before, after) {
 }
 
 // src/core/config/nx-target.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// src/core/config/project-json.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 import { join as join7 } from "node:path";
+function projectTargets(cwd) {
+  const path = join7(cwd, "project.json");
+  if (!existsSync7(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync6(path, "utf8")).targets;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/config/nx-target.ts
 function nxTargetMetadataOperations(options) {
   const { targets } = options;
   if (Object.keys(targets).length === 0) return [];
   return [{ kind: "merge-json", path: "package.json", value: { nx: { targets } } }];
 }
+function sameInput(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function inputsOf(target) {
+  const inputs = target?.inputs;
+  return Array.isArray(inputs) ? inputs : [];
+}
+function annotationOf(target) {
+  if (typeof target !== "object" || target === null) return void 0;
+  const { executor, command } = target;
+  return executor === void 0 && command === void 0 ? target : void 0;
+}
+function withTeamInputs(cwd, targets) {
+  const committed = manifestTargets(cwd);
+  const annotated = projectTargets(cwd) ?? {};
+  const merged = {};
+  for (const [name, metadata] of Object.entries(targets)) {
+    const ours = metadata.inputs;
+    if (!Array.isArray(ours)) {
+      merged[name] = metadata;
+      continue;
+    }
+    const inputs = [...ours];
+    for (const entry of [
+      ...inputsOf(committed[name]),
+      ...inputsOf(annotationOf(annotated[name]))
+    ]) {
+      if (!inputs.some((kept) => sameInput(kept, entry))) inputs.push(entry);
+    }
+    merged[name] = { ...metadata, inputs };
+  }
+  return merged;
+}
 function nxTargetOperations(options) {
-  const { cwd, targets } = options;
-  const names = Object.keys(targets);
+  const { cwd } = options;
+  const names = Object.keys(options.targets);
   if (names.length === 0) return [];
+  const targets = withTeamInputs(cwd, options.targets);
   const operations = [];
-  if (existsSync7(join7(cwd, "project.json"))) {
+  if (existsSync8(join8(cwd, "project.json"))) {
     operations.push({
       kind: "remove-json-keys",
       path: "project.json",
       keys: names.map((name) => ["targets", name])
     });
   }
-  operations.push(...nxTargetMetadataOperations(options));
+  operations.push(...nxTargetMetadataOperations({ cwd, targets }));
   return operations;
 }
 
-// src/core/config/project-json.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
-import { join as join8 } from "node:path";
-function projectTargets(cwd) {
-  const path = join8(cwd, "project.json");
-  if (!existsSync8(path)) return void 0;
-  try {
-    return JSON.parse(readFileSync6(path, "utf8")).targets;
-  } catch {
-    return void 0;
-  }
-}
-
 // src/core/config/rewrite-imports.ts
 import { parseSync } from "oxc-parser";
 var movedSpecifiers = (toolchain) => new Set(toolchain.owned.map((entry) => entry.specifier));

package/dist/{chunk-IL5PPLXE.js → chunk-JRZI5IIN.js}

@@ -298,4 +298,4 @@ export {
   ensureWorkspacePrep,
   inspectWorkspacePrep
 };
-//# sourceMappingURL=chunk-IL5PPLXE.js.map
+//# sourceMappingURL=chunk-JRZI5IIN.js.map