@dbx-tools/projen 0.9.19 → 0.9.21

package/src/project-py.ts

@@ -14,8 +14,6 @@ import {
   releaseSourceSteps,
 } from "./release-dispatch.ts";
 import {
-  independentReleaseSetupSteps,
-  registerIndependentPublicationJob,
   releaseTagPattern,
   releasePublishCondition,
   releaseStageCondition,
@@ -114,8 +112,6 @@ const DEFAULT_DEV_DEPENDENCIES = [
   "ruff>=0.12,<1",
 ] as const;
 
-const quote = (value: string): string => JSON.stringify(value);
-
 /** Repository-relative path for a Python package directory. */
 export function pythonPackagePath(repository: PythonRepositoryOptions, directory: string): string {
   return `${repository.root ?? "packages/py"}/${directory}`;
@@ -279,10 +275,7 @@ export class DBXToolsPythonWorkspace extends Component {
     }));
     const resolvedOptions = { ...options, packages };
     this.requiresPython = options.requiresPython ?? ">=3.10";
-    this.version =
-      isDBXToolsJavaScriptProject()(project) && project.releaseCatalog.mode === "independent"
-        ? "0.0.0"
-        : readWorkspaceVersion(project.outdir);
+    this.version = readWorkspaceVersion(project.outdir);
     this.file = this.emitWorkspace(project, resolvedOptions, scope);
     this.packages = packages.map(
       (pkg) =>
@@ -462,93 +455,10 @@ export class DBXToolsPythonWorkspace extends Component {
     const uniffiPublications = this.uniffiPublications(options);
     const allPublications = [...publications, ...uniffiPublications];
     if (allPublications.length === 0) return;
-    const usesRustArtifacts = uniffiPublications.length > 0;
     const workflow = tryReleaseWorkflow(project);
     if (!workflow) {
       throw new Error("Python release requires the root dbx-tools release mode");
     }
-    if (project.releaseCatalog.mode === "independent") {
-      workflow.addJob("build-python", {
-        if: usesRustArtifacts
-          ? "${{ always() && needs.release-plan.outputs.python == 'true' && needs.rust-build.result != 'failure' && needs.rust-build.result != 'cancelled' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
-          : "${{ needs.release-plan.outputs.python == 'true' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}",
-        needs: ["release-plan", ...(usesRustArtifacts ? ["rust-build"] : [])],
-        runsOn: ["ubuntu-latest"],
-        permissions: { actions: JobPermission.READ, contents: JobPermission.READ },
-        timeoutMinutes: 20,
-        env: { BUN_VERSION },
-        steps: [
-          ...independentReleaseSetupSteps(project),
-          { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
-          ...uniffiPublications.map((publication) => ({
-            name: `Download ${publication.distribution} native wheels`,
-            uses: "actions/download-artifact@v8",
-            with: {
-              pattern: `${publication.distribution}--*--python-wheel`,
-              path: `dist/${publication.directory}`,
-              "merge-multiple": true,
-            },
-          })),
-          {
-            name: "Build affected distributions",
-            shell: "bash",
-            run: publications
-              .map(
-                (publication) =>
-                  `if jq -e --arg package ${quote(publication.distribution)} '.pythonPackages[] | select(.identity == $package)' dist/release-plan.json >/dev/null; then uv build --package ${quote(publication.distribution)} --out-dir dist/${publication.directory}; fi`,
-              )
-              .join("\n"),
-          },
-          {
-            name: "Validate affected distributions",
-            run: "find dist -type f \\( -name '*.whl' -o -name '*.tar.gz' \\) -print0 | xargs -0 uvx twine check",
-          },
-          {
-            name: "Upload distributions",
-            uses: "actions/upload-artifact@v7",
-            with: { name: "python-distributions", path: "dist", "retention-days": 7 },
-          },
-        ],
-      });
-      for (const publication of allPublications) {
-        const dependencyJobs = (publication.dependencies ?? []).map(
-          (dependency) => `publish-pypi-${dependency}`,
-        );
-        const dependencyCondition = dependencyJobs
-          .map((job) => `needs.${job}.result != 'failure' && needs.${job}.result != 'cancelled'`)
-          .join(" && ");
-        workflow.addJob(`publish-pypi-${publication.directory}`, {
-          if: `\${{ always() && needs.build-python.result == 'success' && contains(needs.release-plan.outputs.python_packages, '"identity":"${publication.distribution}"') && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python')${dependencyCondition ? ` && ${dependencyCondition}` : ""} }}`,
-          needs: ["release-plan", "build-python", ...dependencyJobs],
-          environment: {
-            name: publication.environment,
-            url:
-              options.environmentUrl ??
-              `https://pypi.org/project/${publication.distribution.replaceAll("_", "-")}/`,
-          },
-          runsOn: ["ubuntu-latest"],
-          permissions: { idToken: JobPermission.WRITE },
-          timeoutMinutes: 10,
-          steps: [
-            {
-              name: "Download distributions",
-              uses: "actions/download-artifact@v8",
-              with: { name: "python-distributions", path: "dist" },
-            },
-            {
-              name: `Publish ${publication.distribution} to PyPI`,
-              uses: "pypa/gh-action-pypi-publish@release/v1",
-              with: {
-                "packages-dir": `dist/${publication.directory}`,
-                "skip-existing": true,
-              },
-            },
-          ],
-        });
-        registerIndependentPublicationJob(workflow, `publish-pypi-${publication.directory}`);
-      }
-      return;
-    }
     workflow.addJob("build-python", {
       if: releaseStageCondition("python", ["needs.verify-context.result == 'success'"]),
       needs: ["verify-context"],
@@ -697,11 +607,10 @@ export class DBXToolsPythonWorkspace extends Component {
   ): void {
     const repository = this.githubRepository();
     const publications = this.trustedPublisherPublications(options);
-    const releaseTag = isDBXToolsJavaScriptProject()(project)
-      ? project.releaseCatalog.mode === "independent"
-        ? "*-v*"
-        : releaseTagPattern(project)
-      : "v*";
+    const releaseTag =
+      isDBXToolsJavaScriptProject()(project) && tryReleaseWorkflow(project)
+        ? releaseTagPattern(project)
+        : "v*";
     const linesBeforeAuthentication = [
       "# PyPI Trusted Publisher Setup Instructions",
       "",

package/src/project-rs.ts

@@ -20,13 +20,8 @@ import {
 } from "./_rust-project.ts";
 import {
   configureRustReleaseTask,
-  independentRustCargoPublishJob,
-  independentRustGitHubReleaseJob,
-  independentRustNativeNpmPublishJob,
-  independentRustNodeFacadePublishJob,
   orderRustBindings,
   planRustRelease,
-  rustBuildJob,
   rustCargoPublishJob,
 } from "./_rust-release-workflow.ts";
 import { toPosix } from "./packages.ts";
@@ -39,12 +34,7 @@ import {
 import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import { pythonModuleName, type PythonPackageOptions } from "./project-py.ts";
 import { defaultReleaseUnitId, type ReleaseDependencyInput } from "./release-catalog.ts";
-import {
-  hasNodeRelease,
-  independentReleaseSetupSteps,
-  registerIndependentPublicationJob,
-  tryReleaseWorkflow,
-} from "./release.ts";
+import { tryReleaseWorkflow } from "./release.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 export { discoverRustCrates, hasUniFFIBindings } from "./_rust-project.ts";
 export { orderRustBindings } from "./_rust-release-workflow.ts";
@@ -454,10 +444,7 @@ function planRustReleaseBinaries(
             component: defaultReleaseUnitId("rust", pkg.crateName),
             version: readWorkspaceVersion(project.outdir),
           };
-      const tagPrefix =
-        isDBXToolsJavaScriptProject()(project) && project.releaseCatalog.mode === "independent"
-          ? `${identity.component}-v`
-          : "v";
+      const tagPrefix = "v";
       return {
         command,
         description,
@@ -666,14 +653,6 @@ function createRustPackages(
       ...resolved.packageOptions[directory],
     };
     const name = `${resolved.scope}-${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`;
-    const version =
-      isDBXToolsJavaScriptProject()(project) && project.releaseCatalog.mode === "independent"
-        ? project.releaseCatalog.versionForRegistration(
-            "rust",
-            name,
-            `${resolved.root}/${directory}`,
-          )
-        : undefined;
     return new DBXToolsRustProject({
       parent: project,
       outdir: `${resolved.root}/${directory}`,
@@ -682,7 +661,6 @@ function createRustPackages(
       workspaceRoot: resolved.root,
       workspace: true,
       scope: resolved.scope,
-      ...(version ? { version } : {}),
       ...configured,
     });
   });
@@ -828,9 +806,7 @@ function configureRustWorkspaceFiles(
         .map((pkg) => `${resolved.root}/${pkg.packageOptions.directory}`),
       resolver: "2",
       package: {
-        ...(!isDBXToolsJavaScriptProject()(project) || project.releaseCatalog.mode === "fixed"
-          ? { version: readWorkspaceVersion(project.outdir) }
-          : {}),
+        version: readWorkspaceVersion(project.outdir),
         edition: options.edition ?? "2021",
         "rust-version": options.rustVersion ?? "1.82",
         license: options.license ?? DBX_TOOLS_LICENSE,
@@ -915,29 +891,6 @@ function rustReleaseDependencies(
   });
 }
 
-function configureIndependentRustVersions(
-  project: DBXToolsJavaScriptProject,
-  packages: readonly DBXToolsRustProject[],
-): void {
-  for (const pkg of packages) {
-    for (const [section, dependencies] of [
-      ["dependencies", pkg.packageOptions.dependencies],
-      ["dev-dependencies", pkg.packageOptions.devDependencies],
-    ] as const) {
-      for (const [name, dependency] of Object.entries(dependencies ?? {})) {
-        if (typeof dependency === "string" || !dependency.path) continue;
-        const dependencyPath = resolve(pkg.outdir, dependency.path);
-        const target = packages.find((candidate) => resolve(candidate.outdir) === dependencyPath);
-        if (!target) continue;
-        pkg.manifestFile.addOverride(
-          `${section}.${name}.version`,
-          project.releaseCatalog.versionFor(target),
-        );
-      }
-    }
-  }
-}
-
 /** Generated Rust workspace plus convention-derived UniFFI binding packages. */
 export class DBXToolsRustWorkspace extends Component {
   readonly packages: readonly DBXToolsRustProject[];
@@ -985,9 +938,6 @@ export class DBXToolsRustWorkspace extends Component {
           ],
         });
       }
-      if (project.releaseCatalog.mode === "independent") {
-        configureIndependentRustVersions(project, this.packages);
-      }
     }
     this.releaseBinaries = planRustReleaseBinaries(project, this.packages, resolved);
     configureRustCliRegistry(project, options.cliRegistryPath, this.releaseBinaries);
@@ -1097,29 +1047,6 @@ export class DBXToolsRustWorkspace extends Component {
       throw new Error("Rust release requires the root dbx-tools release mode");
     }
     configureRustReleaseTask(project, plan);
-    if (project.releaseCatalog.mode === "independent") {
-      if (plan.targets.length) {
-        workflow.addJob("rust-build", rustBuildJob(plan, independentReleaseSetupSteps(project)));
-      }
-      if (plan.publicCrates.length) {
-        workflow.addJob("publish-cargo", independentRustCargoPublishJob(project, plan));
-        registerIndependentPublicationJob(workflow, "publish-cargo");
-      }
-      if (plan.releaseBinaries.length) {
-        workflow.addJob("publish-github-release", independentRustGitHubReleaseJob(project, plan));
-        registerIndependentPublicationJob(workflow, "publish-github-release");
-      }
-      if (plan.nodeBindings.length && hasNodeRelease(project)) {
-        workflow.addJob("publish-native-npm", independentRustNativeNpmPublishJob(project));
-        registerIndependentPublicationJob(workflow, "publish-native-npm");
-        workflow.addJob(
-          "publish-node-facades",
-          independentRustNodeFacadePublishJob(project, plan.nodeBindings),
-        );
-        registerIndependentPublicationJob(workflow, "publish-node-facades");
-      }
-      return;
-    }
     if (plan.publicCrates.length) {
       workflow.addJob("publish-cargo", rustCargoPublishJob(plan));
     }

package/src/release-catalog.ts

@@ -1,25 +1,21 @@
 /**
  * Cross-language release-unit ownership and dependency graph.
  *
- * The catalog is the version lookup and release-planning seam shared by every
- * generated project. Fixed mode preserves the root VERSION contract while the
- * same registrations and graph are exercised before independent versions are
- * enabled.
+ * The catalog owns cross-language package identity, release grouping, and
+ * publication order. Every registered project reads its version from the root
+ * VERSION file.
  *
  * @module
  */
 
-import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
-import { Component, JsonFile, type Project } from "projen";
+import { Component, type Project } from "projen";
+import { probeTaskCommand } from "./_task-command.ts";
 import { toPosix } from "./packages.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 
-/** Version source used by the generated workspace. */
-export type DBXToolsVersioningMode = "fixed" | "independent";
-
 /** Runtime family represented by a release project. */
 export type ReleaseProjectLanguage = "javascript" | "python" | "rust";
 
@@ -51,11 +47,6 @@ export interface ReleaseUnitRule {
 
 /** Root catalog configuration. */
 export interface DBXToolsReleaseCatalogOptions {
-  readonly mode?: DBXToolsVersioningMode;
-  readonly manifestFile?: string;
-  readonly graphFile?: string;
-  readonly releasePleaseConfigFile?: string;
-  readonly bootstrapSha?: string;
   readonly units?: readonly ReleaseUnitRule[];
   readonly externalProjects?: readonly ExternalReleaseProjectRegistration[];
 }
@@ -151,7 +142,6 @@ export interface ReleaseUnit {
 /** Generated execution graph consumed by validation and release tasks. */
 export interface ReleaseUnitGraph {
   readonly schemaVersion: 1;
-  readonly mode: DBXToolsVersioningMode;
   readonly units: readonly ReleaseUnit[];
   readonly projects: readonly ReleaseProjectNode[];
   readonly artifacts: readonly ReleaseArtifact[];
@@ -219,22 +209,6 @@ export function defaultPublishOrder(kind: ReleaseEdgeKind): boolean {
   return !["test", "development"].includes(kind);
 }
 
-/** Read one component version, falling back to fixed workspace compatibility. */
-export function readReleaseUnitVersion(
-  root: string,
-  component: string,
-  manifestFile = ".release-please-manifest.json",
-): string {
-  const path = resolve(root, manifestFile);
-  if (!existsSync(path)) return readWorkspaceVersion(root);
-  const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
-  const version = parsed[`.release-units/${component}`];
-  if (typeof version !== "string") {
-    throw new Error(`Release Please manifest is missing .release-units/${component}`);
-  }
-  return version;
-}
-
 /**
  * Root release catalog shared by every generated language project.
  *
@@ -243,12 +217,6 @@ export function readReleaseUnitVersion(
  * after project construction.
  */
 export class DBXToolsReleaseCatalog extends Component {
-  readonly mode: DBXToolsVersioningMode;
-  readonly manifestFile: string;
-  readonly graphFile: string;
-  readonly releasePleaseConfigFile: string;
-  readonly bootstrapSha?: string;
-
   private readonly projects = new Map<Project, RegisteredProject>();
   private readonly externalProjects = new Map<string, ExternalReleaseProjectRegistration>();
   private readonly artifacts = new Map<string, RegisteredArtifact>();
@@ -257,37 +225,11 @@ export class DBXToolsReleaseCatalog extends Component {
     dependency: ReleaseDependencyInput;
   }> = [];
   private readonly rules: ReleaseUnitRule[];
-  private readonly markerFiles = new Set<string>();
 
   constructor(project: Project, options: DBXToolsReleaseCatalogOptions = {}) {
     super(project);
-    this.mode = options.mode ?? "fixed";
-    this.manifestFile = options.manifestFile ?? ".release-please-manifest.json";
-    this.graphFile = options.graphFile ?? ".projen/release-units.json";
-    this.releasePleaseConfigFile = options.releasePleaseConfigFile ?? "release-please-config.json";
-    this.bootstrapSha = options.bootstrapSha;
     this.rules = [...(options.units ?? [])];
     for (const external of options.externalProjects ?? []) this.registerExternalProject(external);
-    if (this.mode === "independent") {
-      new JsonFile(project, this.graphFile, {
-        marker: false,
-        readonly: true,
-        obj: () => this.graph(),
-      });
-      new JsonFile(project, this.releasePleaseConfigFile, {
-        marker: false,
-        readonly: true,
-        obj: () => this.releasePleaseConfig(),
-      });
-      project
-        .addTask("release:bootstrap", {
-          description: "Bootstrap Release Please state from release units",
-        })
-        .exec("bun node_modules/@dbx-tools/projen/tasks/release-bootstrap.ts");
-    } else {
-      project.tryRemoveFile(this.graphFile);
-      project.tryRemoveFile(this.releasePleaseConfigFile);
-    }
   }
 
   /** Register one attached Projen project. */
@@ -349,10 +291,7 @@ export class DBXToolsReleaseCatalog extends Component {
   versionFor(project: Project): string {
     const registered = this.projects.get(project);
     if (!registered) throw new Error(`Release project is not registered: ${project.outdir}`);
-    if (!resolveValue(registered.registration.publish ?? true)) {
-      return this.mode === "independent" ? "0.0.0" : readWorkspaceVersion(this.project.outdir);
-    }
-    return this.versionForUnit(this.unitFor(registered));
+    return this.workspaceVersion();
   }
 
   /** Stable unit, component, and version identity for a registered project. */
@@ -372,58 +311,23 @@ export class DBXToolsReleaseCatalog extends Component {
   }
 
   /** Current version for a project selected by its repository-relative path. */
-  versionForPath(path: string): string {
-    const normalized = toPosix(path).replace(/^\.\//, "") || ".";
-    const attached = [...this.projects.values()].find(
-      (registered) => this.projectId(registered.project) === normalized,
-    );
-    if (attached) return this.versionFor(attached.project);
-    const external = this.externalProjects.get(normalized);
-    if (!external) {
-      if (this.mode === "fixed") return readWorkspaceVersion(this.project.outdir);
-      throw new Error(`Release project path is not registered: ${normalized}`);
-    }
-    if (external.publish === false) {
-      return this.mode === "independent" ? "0.0.0" : readWorkspaceVersion(this.project.outdir);
-    }
-    const unit =
-      external.unit ??
-      this.rules.find(
-        (rule) =>
-          rule.projectPaths?.includes(normalized) ||
-          rule.projectIdentities?.includes(external.identity),
-      )?.id ??
-      defaultReleaseUnitId(external.language, external.identity);
-    return this.versionForUnit(unit);
+  versionForPath(_path: string): string {
+    return this.workspaceVersion();
   }
 
   /** Resolve a version before the corresponding Projen project is constructed. */
   versionForRegistration(
-    language: ReleaseProjectLanguage,
-    identity: string,
-    path: string,
-    unit?: string,
+    _language: ReleaseProjectLanguage,
+    _identity: string,
+    _path: string,
+    _unit?: string,
   ): string {
-    const normalized = toPosix(path).replace(/^\.\//, "") || ".";
-    const resolvedUnit =
-      unit ??
-      this.rules.find(
-        (rule) =>
-          rule.projectPaths?.includes(normalized) || rule.projectIdentities?.includes(identity),
-      )?.id ??
-      defaultReleaseUnitId(language, identity);
-    return this.versionForUnit(resolvedUnit);
+    return this.workspaceVersion();
   }
 
   /** Current version for a release unit. */
-  versionForUnit(unit: string): string {
-    if (this.mode === "fixed") return readWorkspaceVersion(this.project.outdir);
-    const component = this.rules.find((rule) => rule.id === unit)?.component ?? unit;
-    const versions = this.readIndependentVersions();
-    const key = `.release-units/${component}`;
-    const version = versions[key];
-    if (!version) throw new Error(`Release Please manifest is missing ${key}`);
-    return version;
+  versionForUnit(_unit: string): string {
+    return this.workspaceVersion();
   }
 
   /** Build and validate the normalized release graph. */
@@ -510,7 +414,7 @@ export class DBXToolsReleaseCatalog extends Component {
         return {
           id,
           component: unit.component,
-          version: this.versionForResolvedUnit(id, unit.component),
+          version: this.workspaceVersion(),
           projects: [...unit.projects].sort(),
           artifacts: [...unit.artifacts].sort(),
           sourceHash: hashStrings(hashes),
@@ -520,7 +424,6 @@ export class DBXToolsReleaseCatalog extends Component {
 
     return {
       schemaVersion: 1,
-      mode: this.mode,
       units: serializedUnits,
       projects,
       artifacts,
@@ -529,55 +432,6 @@ export class DBXToolsReleaseCatalog extends Component {
     };
   }
 
-  /** Generated Release Please manifest-mode configuration. */
-  releasePleaseConfig(): Record<string, unknown> {
-    return {
-      $schema:
-        "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
-      "release-type": "simple",
-      "separate-pull-requests": false,
-      "include-component-in-tag": true,
-      "include-v-in-tag": true,
-      ...(this.bootstrapSha ? { "bootstrap-sha": this.bootstrapSha } : {}),
-      packages: Object.fromEntries(
-        this.graph().units.map((unit) => [
-          `.release-units/${unit.component}`,
-          {
-            "release-type": "simple",
-            "package-name": unit.id,
-            component: unit.component,
-            "changelog-path": "CHANGELOG.md",
-            "version-file": "version.txt",
-          },
-        ]),
-      ),
-    };
-  }
-
-  public override preSynthesize(): void {
-    const graph = this.graph();
-    if (this.mode === "fixed") return;
-    for (const unit of graph.units) {
-      const path = `.release-units/${unit.component}/source.json`;
-      if (this.markerFiles.has(path)) continue;
-      this.markerFiles.add(path);
-      new JsonFile(this.project, path, {
-        marker: false,
-        readonly: true,
-        obj: () => {
-          const current = this.graph().units.find((candidate) => candidate.id === unit.id);
-          if (!current) throw new Error(`Release unit disappeared during synthesis: ${unit.id}`);
-          return {
-            schemaVersion: 1,
-            unit: current.id,
-            component: current.component,
-            sourceHash: current.sourceHash,
-          };
-        },
-      });
-    }
-  }
-
   private projectNode(registered: RegisteredProject): ReleaseProjectNode {
     const identity = resolveValue(registered.registration.identity);
     const publish = resolveValue(registered.registration.publish ?? true);
@@ -651,6 +505,10 @@ export class DBXToolsReleaseCatalog extends Component {
     return toPosix(relative(this.project.outdir, project.outdir)) || ".";
   }
 
+  private workspaceVersion(): string {
+    return readWorkspaceVersion(this.project.outdir);
+  }
+
   private dependencies(
     byIdentity: ReadonlyMap<string, readonly ReleaseProjectNode[]>,
     byId: ReadonlyMap<string, ReleaseProjectNode>,
@@ -719,31 +577,6 @@ export class DBXToolsReleaseCatalog extends Component {
       [a.from, a.to, a.kind].join("\0").localeCompare([b.from, b.to, b.kind].join("\0")),
     );
   }
-
-  private versionForResolvedUnit(unit: string, component: string): string {
-    if (this.mode === "fixed") return readWorkspaceVersion(this.project.outdir);
-    const key = `.release-units/${component}`;
-    const version = this.readIndependentVersions()[key];
-    if (!version) throw new Error(`Release Please manifest is missing ${key} for ${unit}`);
-    return version;
-  }
-
-  private readIndependentVersions(): Record<string, string> {
-    const path = resolve(this.project.outdir, this.manifestFile);
-    if (!existsSync(path)) throw new Error(`Independent version manifest not found: ${path}`);
-    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error(`Independent version manifest must contain an object: ${path}`);
-    }
-    return Object.fromEntries(
-      Object.entries(parsed).map(([key, value]) => {
-        if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) {
-          throw new Error(`Invalid independent version for ${key}: ${String(value)}`);
-        }
-        return [key, value];
-      }),
-    );
-  }
 }
 
 /** Publish dependency batches ordered with dependencies before dependents. */
@@ -795,22 +628,23 @@ function hashPaths(root: string, paths: readonly string[]): string {
 
 function gitReleaseFiles(root: string, paths: readonly string[]): string[] | undefined {
   const relativePaths = paths.map((path) => toPosix(relative(root, path)));
-  try {
-    const output = execFileSync(
-      "git",
-      ["ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", ...relativePaths],
-      { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
-    );
-    return output
-      .split("\0")
-      .filter(Boolean)
-      .map((path) => resolve(root, path))
-      .filter((path) => existsSync(path))
-      .filter((path) => paths.some((sourcePath) => trackedReleaseFile(sourcePath, path)))
-      .sort();
-  } catch {
-    return undefined;
-  }
+  const output = probeTaskCommand(root, "git", [
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    ...relativePaths,
+  ]);
+  if (output === undefined) return undefined;
+  return output
+    .split("\0")
+    .filter(Boolean)
+    .map((path) => resolve(root, path))
+    .filter((path) => existsSync(path))
+    .filter((path) => paths.some((sourcePath) => trackedReleaseFile(sourcePath, path)))
+    .sort();
 }
 
 function trackedReleaseFile(sourcePath: string, path: string): boolean {