@dbx-tools/projen 0.9.18 → 0.9.21

package/src/_task-command.ts

@@ -12,6 +12,13 @@ export interface CaptureTaskCommandOptions extends TaskCommandOptions {
   readonly check?: boolean;
 }
 
+export type ProbeTaskCommandOptions = TaskCommandOptions;
+
+export interface LoggedTaskCommandOptions extends TaskCommandOptions {
+  /** Receive normalized stdout and stderr lines after the command exits. */
+  readonly onLine: (line: string) => void;
+}
+
 function executable(command: string): string {
   return command === "bun" && process.versions.bun ? process.execPath : command;
 }
@@ -69,6 +76,47 @@ export function captureTaskCommand(
   return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : "";
 }
 
+/** Capture trimmed stdout while preserving command failure as `undefined`. */
+export function probeTaskCommand(
+  cwd: string,
+  command: string,
+  args: readonly string[],
+  options: ProbeTaskCommandOptions = {},
+): string | undefined {
+  const result = exec.spawnSync(executable(command), [...args], {
+    cwd,
+    env: options.env,
+    stdout: "capture",
+    stderr: options.stderr ?? "ignore",
+    stdin: "ignore",
+    check: false,
+  });
+  return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : undefined;
+}
+
+/** Run a checked command while routing captured output through one line policy. */
+export function runLoggedTaskCommand(
+  cwd: string,
+  command: string,
+  args: readonly string[],
+  options: LoggedTaskCommandOptions,
+): void {
+  const result = exec.spawnSync(executable(command), [...args], {
+    cwd,
+    env: options.env,
+    stdout: "capture",
+    stderr: "capture",
+    stdin: "ignore",
+    check: false,
+  });
+  for (const line of [...result.stdoutLines, ...result.stderrLines]) {
+    if (line) options.onLine(line);
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(`${command} exited with ${result.exitCode}`);
+  }
+}
+
 /** Whether a quiet, non-interactive command exits successfully. */
 export function taskCommandSucceeds(
   cwd: string,
@@ -87,3 +135,30 @@ export function taskCommandSucceeds(
     }).exitCode === 0
   );
 }
+
+/** Run Git with the shared non-interactive checked command policy. */
+export function runGitTaskCommand(
+  cwd: string,
+  args: readonly string[],
+  options: TaskCommandOptions = {},
+): void {
+  runTaskCommand(cwd, "git", args, options);
+}
+
+/** Capture Git output, returning an empty string for optional offline probes. */
+export function captureGitTaskCommand(
+  cwd: string,
+  args: readonly string[],
+  options: CaptureTaskCommandOptions = {},
+): string {
+  return captureTaskCommand(cwd, "git", args, options);
+}
+
+/** Whether a quiet Git command succeeds. */
+export function gitTaskCommandSucceeds(
+  cwd: string,
+  args: readonly string[],
+  options: Pick<TaskCommandOptions, "env"> = {},
+): boolean {
+  return taskCommandSucceeds(cwd, "git", args, options);
+}

package/src/project-js.ts

@@ -15,7 +15,7 @@ import { type IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { BuildWorkflow } from "projen/lib/build";
 import { AutoMerge } from "projen/lib/github";
-import { JobPermission, type JobStep, type Triggers } from "projen/lib/github/workflows-model";
+import { JobPermission, type JobStep } from "projen/lib/github/workflows-model";
 import type { ReleaseProjectOptions } from "projen/lib/release";
 import { mixin } from "..";
 import { generateBarrels } from "./barrels.ts";
@@ -44,7 +44,6 @@ import { PROJEN_VERSION } from "./projen-version.ts";
 import { applyCompiledPublish } from "./publish.ts";
 import {
   DBXToolsReleaseCatalog,
-  type DBXToolsVersioningMode,
   type ExternalReleaseProjectRegistration,
   type ReleaseDependencyInput,
   type ReleaseUnitRule,
@@ -628,18 +627,12 @@ export type DBXToolsJavaScriptProjectOptions = CommonProjectOptions &
     readonly releaseValidationTasks?: readonly string[];
     /** Optional AI-generated release summary. Defaults to enabled. */
     readonly releaseSummary?: boolean | ReleaseSummaryOptions;
-    /** Existing source branch safely fast-forwarded after an independent release. */
-    readonly releaseSyncBranch?: string | false;
     /** Set to `false` to omit normal npm workspace publication. */
     readonly nodeRelease?: boolean;
     /** Unified dbx-tools release workflow, or no release surface. Defaults to `dbx-tools`. */
     readonly releaseMode?: DBXToolsReleaseMode;
-    /** Package version ownership mode. Defaults to `fixed`. */
-    readonly versioningMode?: DBXToolsVersioningMode;
     /** Explicit stable release-unit grouping rules. */
     readonly releaseUnits?: readonly ReleaseUnitRule[];
-    /** Commit before the first independent Release Please history. */
-    readonly releaseBootstrapSha?: string;
     /** Publishable workspace members synthesized outside the attached project tree. */
     readonly externalReleaseProjects?: readonly ExternalReleaseProjectRegistration[];
     /** Prefix for generated release tags. Defaults to `v`. */
@@ -723,10 +716,8 @@ export class DBXToolsNodeProject
     // (its build phase installs with pnpm and reads catalog + `allowBuilds`).
     pnpmWorkspace.attachWorkspaceFile(this);
     this.releaseCatalog = new DBXToolsReleaseCatalog(this, {
-      mode: options.versioningMode,
       units: options.releaseUnits,
       externalProjects: options.externalReleaseProjects,
-      bootstrapSha: options.releaseBootstrapSha,
     });
     registerJavaScriptReleaseProject(this);
     this.package.addField("version", () => this.releaseCatalog.versionFor(this));
@@ -862,10 +853,8 @@ export class DBXToolsTypeScriptProject
       (parent instanceof DBXToolsNodeProject || parent instanceof DBXToolsTypeScriptProject)
         ? parent.releaseCatalog
         : new DBXToolsReleaseCatalog(this, {
-            mode: options.versioningMode,
             units: options.releaseUnits,
             externalProjects: options.externalReleaseProjects,
-            bootstrapSha: options.releaseBootstrapSha,
           });
     // Pairs with `jsx` in SHARED_COMPILER_OPTIONS: projen's default `include` is
     // `src/**/*.ts` only, which silently omits a `.tsx` file from the program
@@ -937,35 +926,7 @@ function configureBuildWorkflow(
   });
   validation.exec("bunx projen default");
   validation.exec("bun run compile");
-  const configured = {
-    ...options.buildWorkflowOptions,
-    ...(!options.buildWorkflowOptions?.workflowTriggers &&
-    project.releaseCatalog.mode === "independent"
-      ? {
-          workflowTriggers: {
-            pullRequest: {
-              types: ["opened", "synchronize", "reopened", "closed"],
-              paths: [
-                "**",
-                "!.projen/release-units.json",
-                "!.release-please-manifest.json",
-                "!.release-units/**",
-                "!.release-notes/**",
-                "!docs/releases/**",
-                "!Cargo.lock",
-                "!**/Cargo.toml",
-                "!**/package.json",
-                "!**/pyproject.toml",
-                "!**/index.ts",
-                "!packages/js/node/rust-binary/src/_release-binaries.ts",
-                "!packages/js/node/appkit-graphiti/src/_python-runtime.ts",
-              ],
-            },
-            workflowDispatch: {},
-          } satisfies Triggers,
-        }
-      : {}),
-  };
+  const configured = { ...options.buildWorkflowOptions };
   const compatibility = nodeWorkflowCompatibility(project);
   const configuredRunner = configured.runsOn !== undefined || configured.runsOnGroup !== undefined;
   const workflow = new BuildWorkflow(project, {
@@ -1620,7 +1581,6 @@ function initProject(
       pythonRoot: options.releasePythonRoot,
       validationTasks: options.releaseValidationTasks,
       summary: options.releaseSummary,
-      syncBranch: options.releaseSyncBranch,
     });
   }
 }

package/src/project-py.ts

@@ -4,14 +4,17 @@ import { stringUtils } from "@dbx-tools/shared-core";
 import { Component, License, TextFile, type Project, javascript, python, vscode } from "projen";
 import { JobPermission } from "projen/lib/github/workflows-model";
 import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
-import { DBX_TOOLS_LICENSE, projectReleaseBranch, projectRepositoryUrl } from "./project-js.ts";
+import { DBX_TOOLS_LICENSE, projectRepositoryUrl } from "./project-js.ts";
 import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
-import { RELEASE_TAG, RELEASE_VERSION, releaseSourceSteps } from "./release-dispatch.ts";
 import {
-  independentReleaseSetupSteps,
-  registerIndependentPublicationJob,
-  releaseArtifactSteps,
+  RELEASE_SHA,
+  RELEASE_TAG,
+  RELEASE_VERSION,
+  releaseSourceSteps,
+} from "./release-dispatch.ts";
+import {
+  releaseTagPattern,
   releasePublishCondition,
   releaseStageCondition,
   tryReleaseWorkflow,
@@ -109,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}`;
@@ -274,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) =>
@@ -457,100 +455,15 @@ 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: usesRustArtifacts
-        ? "${{ always() && needs.verify-context.result == 'success' && needs.rust-assets.result == 'success' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
-        : releaseStageCondition("python"),
-      needs: ["verify-context", ...(usesRustArtifacts ? ["rust-assets"] : [])],
+      if: releaseStageCondition("python", ["needs.verify-context.result == 'success'"]),
+      needs: ["verify-context"],
       runsOn: ["ubuntu-latest"],
-      permissions: { actions: JobPermission.READ, contents: JobPermission.READ },
+      permissions: { contents: JobPermission.READ },
       timeoutMinutes: 20,
       env: { BUN_VERSION },
       steps: [
@@ -561,76 +474,60 @@ export class DBXToolsPythonWorkspace extends Component {
         { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
         { name: "Install release helpers", run: "bun install" },
         bunCacheSaveStep(),
-        ...uniffiPublications.flatMap((publication) =>
-          releaseArtifactSteps({
-            currentName: `Download ${publication.distribution} native wheels`,
-            recoveredName: `Download recovered ${publication.distribution} native wheels`,
-            pattern: `${publication.distribution}--*--python-wheel`,
-            path: `dist/${publication.directory}`,
-            condition: "needs.verify-context.outputs.build_mode == 'remote'",
-          }),
-        ),
-        ...(uniffiPublications.length
-          ? [
-              {
-                name: "Download locally built native wheels",
-                if: "${{ needs.verify-context.outputs.build_mode == 'local' }}",
-                env: { GH_TOKEN: "${{ github.token }}", RELEASE_TAG },
-                shell: "bash",
-                run: [
-                  "mkdir -p dist/local-wheels",
-                  'gh release download "$RELEASE_TAG" --pattern "*.whl" --dir dist/local-wheels',
-                  ...uniffiPublications.flatMap((publication) => [
-                    `mkdir -p dist/${publication.directory}`,
-                    `cp dist/local-wheels/${publication.distribution.replaceAll("-", "_")}-*.whl dist/${publication.directory}/`,
-                  ]),
-                ].join("\n"),
-              },
-            ]
-          : []),
-        {
-          name: "Stamp workspace versions",
-          env: { VERSION: RELEASE_VERSION },
-          run: `bun node_modules/@dbx-tools/projen/tasks/stamp-python.ts "$VERSION" --root ${quote(this.repository.root)}`,
-        },
         {
-          name: "Build distributions",
-          run: publications
-            .map(
-              (publication) =>
-                `uv build --package ${publication.distribution} --out-dir dist/${publication.directory}`,
-            )
-            .join("\n"),
+          name: "Download approved Python distributions",
+          env: { GH_TOKEN: "${{ github.token }}", RELEASE_TAG },
+          run: [
+            "rm -rf dist/release-download",
+            "mkdir -p dist/release-download",
+            'gh release download "$RELEASE_TAG" --pattern release-manifest.json --pattern SHA256SUMS --pattern "*.whl" --pattern "*.tar.gz" --dir dist/release-download',
+          ].join("\n"),
         },
-        {
-          name: "Validate distributions",
+        ...allPublications.map((publication) => ({
+          name: `Select ${publication.distribution} distributions`,
+          env: {
+            PACKAGE_NAME: publication.distribution.replaceAll("_", "-").toLowerCase(),
+            RELEASE_SHA,
+            RELEASE_TAG,
+            RELEASE_VERSION,
+          },
           run: [
-            ...publications.map(
-              (publication) =>
-                `test "$(find dist/${publication.directory} -maxdepth 1 -type f \\( -name '*.whl' -o -name '*.tar.gz' \\) | wc -l | tr -d ' ')" -eq 2`,
-            ),
-            ...uniffiPublications.map(
-              (publication) =>
-                `find dist/${publication.directory} -maxdepth 1 -name '*.whl' -print -quit | grep -q .`,
-            ),
-            "find dist -type f \\( -name '*.whl' -o -name '*.tar.gz' \\) -print0 | xargs -0 uvx twine check",
+            "bun node_modules/@dbx-tools/projen/tasks/release-manifest.ts verify \\",
+            "  --directory dist/release-download \\",
+            '  --tag "$RELEASE_TAG" \\',
+            '  --sha "$RELEASE_SHA" \\',
+            '  --version "$RELEASE_VERSION" \\',
+            "  --kind pypi \\",
+            '  --package "$PACKAGE_NAME" \\',
+            `  --output dist/${publication.directory}`,
           ].join("\n"),
+        })),
+        {
+          name: "Validate approved distributions",
+          run: `find ${allPublications.map((publication) => `dist/${publication.directory}`).join(" ")} -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 },
+          with: {
+            name: "python-distributions",
+            path: allPublications.map((publication) => `dist/${publication.directory}`).join("\n"),
+            "retention-days": 7,
+          },
         },
       ],
     });
     for (const publication of allPublications) {
+      const dependencyJobs = (publication.dependencies ?? []).map(
+        (dependency) => `publish-pypi-${dependency}`,
+      );
       workflow.addJob(`publish-pypi-${publication.directory}`, {
-        if: releasePublishCondition("python"),
-        needs: [
-          "verify-context",
-          "build-python",
-          ...(publication.dependencies ?? []).map((dependency) => `publish-pypi-${dependency}`),
-        ],
+        if: releasePublishCondition("python", [
+          "needs.verify-context.result == 'success'",
+          "needs.build-python.result == 'success'",
+          ...dependencyJobs.map((job) => `needs['${job}'].result == 'success'`),
+        ]),
+        needs: ["verify-context", "build-python", ...dependencyJobs],
         environment: {
           name: publication.environment,
           url:
@@ -710,15 +607,16 @@ export class DBXToolsPythonWorkspace extends Component {
   ): void {
     const repository = this.githubRepository();
     const publications = this.trustedPublisherPublications(options);
-    const releaseBranch = isDBXToolsJavaScriptProject()(project)
-      ? projectReleaseBranch(project)
-      : "main";
+    const releaseTag =
+      isDBXToolsJavaScriptProject()(project) && tryReleaseWorkflow(project)
+        ? releaseTagPattern(project)
+        : "v*";
     const linesBeforeAuthentication = [
       "# PyPI Trusted Publisher Setup Instructions",
       "",
       "Use the system browser to audit and configure the PyPI trusted publishers below.",
       "Do not use an in-app browser or embedded webview.",
-      "Do not visit GitHub or use the GitHub API or CLI. Every required GitHub owner, repository, workflow, environment, and branch value is provided below and is authoritative.",
+      "Do not visit GitHub or use the GitHub API or CLI. Every required GitHub owner, repository, workflow, environment, and tag value is provided below and is authoritative.",
       "Use only PyPI pages for this task.",
       "",
       "## Audit and confirmation",
@@ -736,7 +634,7 @@ export class DBXToolsPythonWorkspace extends Component {
       "",
       "## GitHub environment policy",
       "",
-      `- The supplied branch policy value is ${releaseBranch}.`,
+      `- The supplied deployment tag policy value is ${releaseTag}.`,
       "- Do not inspect or configure GitHub environments during this task.",
       "- GitHub environment administration is a separate task; use the supplied values only when comparing PyPI publisher entries.",
       "",
@@ -777,7 +675,7 @@ export class DBXToolsPythonWorkspace extends Component {
           `- Repository name: ${repository.name}`,
           "- Workflow name: release.yml",
           `- Environment name: ${publication.environment}`,
-          `- GitHub environment branch: ${releaseBranch}`,
+          `- GitHub environment tag: ${releaseTag}`,
           ...(publication.artifacts ? [`- Artifacts: ${publication.artifacts}`] : []),
           "",
         ];

package/src/project-rs.ts

@@ -19,19 +19,10 @@ import {
   type RustOpenApiOptions as RustOpenApiConfiguration,
 } from "./_rust-project.ts";
 import {
-  rustAssetsJob,
   configureRustReleaseTask,
-  independentRustCargoPublishJob,
-  independentRustGitHubReleaseJob,
-  independentRustNativeNpmPublishJob,
-  independentRustNodeFacadePublishJob,
   orderRustBindings,
   planRustRelease,
-  rustBuildJob,
   rustCargoPublishJob,
-  rustGitHubReleaseJob,
-  rustNativeNpmPublishJob,
-  rustNodeFacadePublishJob,
 } from "./_rust-release-workflow.ts";
 import { toPosix } from "./packages.ts";
 import {
@@ -43,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";
@@ -458,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,
@@ -670,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}`,
@@ -686,7 +661,6 @@ function createRustPackages(
       workspaceRoot: resolved.root,
       workspace: true,
       scope: resolved.scope,
-      ...(version ? { version } : {}),
       ...configured,
     });
   });
@@ -832,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,
@@ -919,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[];
@@ -989,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);
@@ -1101,50 +1047,8 @@ 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.targets.length) {
-      workflow.addJob("rust-build", rustBuildJob(plan));
-      workflow.addJob("rust-assets", rustAssetsJob());
-    }
     if (plan.publicCrates.length) {
-      workflow.addJob("publish-cargo", rustCargoPublishJob(plan, false));
-      workflow.addJob("publish-local-cargo", rustCargoPublishJob(plan, true));
-    }
-    if (plan.hasTargetOutputs) {
-      workflow.addJob("publish-github-release", rustGitHubReleaseJob(plan));
-    }
-    if (plan.nodeBindings.length && hasNodeRelease(project)) {
-      workflow.addJob("publish-native-npm", rustNativeNpmPublishJob(project));
-      const nodeJob = workflow.getJob("publish-node");
-      if ("uses" in nodeJob) throw new Error("publish-node must be a workflow job");
-      workflow.updateJob("publish-node", {
-        ...nodeJob,
-        if: "${{ always() && needs.verify-context.result == 'success' && needs.publish-native-npm.result == 'success' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'node') }}",
-        needs: ["verify-context", "publish-native-npm"],
-      });
-      workflow.addJob("publish-node-facades", rustNodeFacadePublishJob(project, plan.nodeBindings));
+      workflow.addJob("publish-cargo", rustCargoPublishJob(plan));
     }
   }
 }