@dbx-tools/projen 0.6.163 → 0.6.174

package/src/project-rs.ts

@@ -5,14 +5,14 @@ import { fileURLToPath } from "node:url";
 import { project as coreProject } from "@dbx-tools/core";
 import { string } from "@dbx-tools/shared-core";
 import { Project, TextFile, YamlFile, javascript } from "projen";
-import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
-import type { DBXToolsProject } from "./project.ts";
 import {
   DBXToolsTypeScriptProject,
   projectReleaseBranch,
   projectRepositoryUrl,
 } from "./project-js.ts";
+import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import { pythonModuleName, type PythonPackageOptions } from "./project-py.ts";
+import type { DBXToolsProject } from "./project.ts";
 import {
   DOWNSTREAM_RELEASE_EVENT,
   RELEASE_SHA,
@@ -21,13 +21,13 @@ import {
   releaseSourceSteps,
 } from "./release-dispatch.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
-import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 
 export interface CargoDependencyOptions {
   readonly version?: string;
   readonly workspace?: boolean;
   readonly path?: string;
   readonly optional?: boolean;
+  readonly package?: string;
   readonly defaultFeatures?: boolean;
   readonly features?: readonly string[];
 }
@@ -61,8 +61,6 @@ export interface DBXToolsRustWorkspaceOptions {
   readonly rustVersion?: string;
   /** Rust toolchain used by release builds. Defaults to `stable`. */
   readonly releaseRustVersion?: string;
-  /** Rust toolchain used to compile the host-side UBRN generator. Defaults to releaseRustVersion. */
-  readonly ubrnRustVersion?: string;
   readonly license?: string;
   readonly repository?: string;
   readonly workspaceDependencies?: Readonly<Record<string, CargoDependency>>;
@@ -79,6 +77,8 @@ export interface DBXToolsRustWorkspaceOptions {
   readonly releasePlatforms?: readonly RustReleasePlatform[];
   /** Workflow name used by downstream release stages. Defaults to `rust-release`. */
   readonly releaseWorkflowName?: string;
+  /** Workflow that publishes generated Python wheels. Defaults to `python-release`. */
+  readonly pythonReleaseWorkflowName?: string;
   /** Tag prefix dispatched into the branch-scoped release workflow. Defaults to `v`. */
   readonly releaseTagPrefix?: string;
 }
@@ -156,6 +156,8 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
 ] as const;
 
 const RUST_CACHE_ENV = {
+  CARGO_INCREMENTAL: "0",
+  CARGO_TERM_COLOR: "always",
   RUSTC_WRAPPER: "sccache",
   SCCACHE_GHA_ENABLED: "true",
 } as const;
@@ -203,8 +205,9 @@ function releaseTargets(options: DBXToolsRustWorkspaceOptions): readonly UniFFIR
     const target = UNIFFI_RELEASE_TARGETS.find(
       (candidate) => candidate.os === platform.os && candidate.cpu === platform.cpu,
     );
-    if (!target)
+    if (!target) {
       throw new Error(`Unsupported Rust release platform: ${platform.os}-${platform.cpu}`);
+    }
     return target;
   });
 }
@@ -247,6 +250,7 @@ export interface RustBindingMapping {
   readonly pythonPackage?: string;
   readonly pythonModule?: string;
   readonly facadeTarget?: boolean;
+  readonly dependencies?: readonly string[];
 }
 
 /** Persisted Rust workspace state consumed by `sync --watch`. */
@@ -257,6 +261,29 @@ export interface RustWorkspaceMapping {
   readonly releaseWorkflow?: string;
 }
 
+export function orderRustBindings(bindings: readonly RustBindingMapping[]): RustBindingMapping[] {
+  const ordered: RustBindingMapping[] = [];
+  const visiting = new Set<string>();
+  const completed = new Set<string>();
+  const visit = (binding: RustBindingMapping): void => {
+    if (completed.has(binding.crate)) return;
+    if (visiting.has(binding.crate)) {
+      throw new Error(`Cyclic Rust binding dependency: ${binding.crate}`);
+    }
+    visiting.add(binding.crate);
+    for (const name of binding.dependencies ?? []) {
+      const dependency = bindings.find((candidate) => candidate.crate === name);
+      if (!dependency) throw new Error(`Missing Rust binding dependency: ${name}`);
+      visit(dependency);
+    }
+    visiting.delete(binding.crate);
+    completed.add(binding.crate);
+    ordered.push(binding);
+  };
+  for (const binding of bindings) visit(binding);
+  return ordered;
+}
+
 function rustSources(directory: string): string[] {
   if (!existsSync(directory)) return [];
   const files: string[] = [];
@@ -294,6 +321,7 @@ function cargoDependency(
     ...(!value.version && value.path && workspaceVersion ? { version: workspaceVersion } : {}),
     ...(value.workspace ? { workspace: true } : {}),
     ...(value.path ? { path: value.path } : {}),
+    ...(value.package ? { package: value.package } : {}),
     ...(value.optional ? { optional: true } : {}),
     ...(value.defaultFeatures === false ? { "default-features": false } : {}),
     ...(value.features?.length ? { features: [...value.features] } : {}),
@@ -366,7 +394,7 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
       ...(this.uniffi || binary
         ? {
             bin: this.uniffi
-              ? { name: "uniffi-bindgen", path: "uniffi-bindgen.rs" }
+              ? { name: `${crateName}-uniffi-bindgen`, path: "uniffi-bindgen.rs" }
               : { name: binaryName, path: "src/main.rs" },
           }
         : {}),
@@ -418,7 +446,7 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
   }
 }
 
-/** Generated Rust workspace plus convention-derived private UniFFI packages. */
+/** Generated Rust workspace plus convention-derived UniFFI facade packages. */
 export class DBXToolsRustWorkspace {
   readonly packages: readonly DBXToolsRustProject[];
   readonly nodePackages: readonly DBXToolsTypeScriptProject[];
@@ -447,27 +475,75 @@ export class DBXToolsRustWorkspace {
     );
 
     const bindings = this.packages.filter((pkg) => pkg.uniffi);
-    this.bindingMappings = bindings.map((pkg) => {
-      const targets = pkg.packageOptions.bindings ?? ["node", "python"];
-      const packageName = pkg.packageOptions.directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
-      return {
-        crate: pkg.crateName,
-        rust: `${root}/${pkg.packageOptions.directory}`,
-        ...(targets.includes("node")
-          ? {
-              node: `${nodeRoot}/${pkg.packageOptions.directory}`,
-              nodePackage: `@${scope}/${packageName}`,
-            }
-          : {}),
-        ...(targets.includes("python")
-          ? {
-              python: `${options.pythonRoot ?? "packages/py"}/${pkg.packageOptions.directory}`,
-              pythonPackage: pkg.crateName,
-              pythonModule: pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory),
-            }
-          : {}),
-      };
-    });
+    const bindingDependencies = (pkg: DBXToolsRustProject, language: "node" | "python") =>
+      bindings.filter(
+        (dependency) =>
+          dependency !== pkg &&
+          (dependency.packageOptions.bindings ?? ["node", "python"]).includes(language) &&
+          Object.entries(pkg.packageOptions.dependencies ?? {}).some(([name, value]) => {
+            const resolved =
+              typeof value === "object" && value.workspace
+                ? (options.workspaceDependencies?.[name] ?? value)
+                : value;
+            return (
+              name === dependency.crateName ||
+              (typeof resolved === "object" &&
+                (resolved.package === dependency.crateName ||
+                  (resolved.path !== undefined &&
+                    resolve(
+                      typeof value === "object" && value.workspace ? project.outdir : pkg.outdir,
+                      resolved.path,
+                    ) === dependency.outdir)))
+            );
+          }),
+      );
+    this.bindingMappings = orderRustBindings(
+      bindings.map((pkg) => {
+        const targets = pkg.packageOptions.bindings ?? ["node", "python"];
+        const packageName = pkg.packageOptions.directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+        const dependencies = [
+          ...new Set([...bindingDependencies(pkg, "node"), ...bindingDependencies(pkg, "python")]),
+        ].map((dependency) => dependency.crateName);
+        return {
+          crate: pkg.crateName,
+          ...(dependencies.length ? { dependencies } : {}),
+          rust: `${root}/${pkg.packageOptions.directory}`,
+          ...(targets.includes("node")
+            ? {
+                node: `${nodeRoot}/${pkg.packageOptions.directory}`,
+                nodePackage: `@${scope}/${packageName}`,
+              }
+            : {}),
+          ...(targets.includes("python")
+            ? {
+                python: `${options.pythonRoot ?? "packages/py"}/${pkg.packageOptions.directory}`,
+                pythonPackage: pkg.crateName,
+                pythonModule: pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory),
+              }
+            : {}),
+        };
+      }),
+    );
+    for (const pkg of bindings) {
+      const dependencies = bindingDependencies(pkg, "python");
+      if (dependencies.length === 0) continue;
+      pkg.tryRemoveFile("uniffi.toml");
+      new TextFile(pkg, "uniffi.toml", {
+        lines: renderToml({
+          "bindings.python": { cdylib_name: pkg.crateName.replaceAll("-", "_") },
+          "bindings.typescript": { strictTypeChecking: true },
+          ...pkg.packageOptions.uniffiConfig,
+          "bindings.python.external_packages": Object.fromEntries(
+            dependencies.map((dependency) => [
+              dependency.crateName.replaceAll("-", "_"),
+              `${pythonModuleName(pythonModulePrefix, dependency.packageOptions.directory)}.bindings`,
+            ]),
+          ),
+        })
+          .trimEnd()
+          .split("\n"),
+      });
+    }
     const releaseEnabled =
       (options.release ?? true) &&
       (this.bindingMappings.length > 0 ||
@@ -484,13 +560,7 @@ export class DBXToolsRustWorkspace {
     project.gitignore.addPatterns(
       "target/",
       ...this.bindingMappings.flatMap((binding) => [
-        ...(binding.node
-          ? [
-              `${binding.node}/src/bindings.ts`,
-              `${binding.node}/src/_bindings*.ts`,
-              `${binding.node}/src/*${binding.crate.replaceAll("-", "_")}.*`,
-            ]
-          : []),
+        ...(binding.node ? [`${binding.node}/src/*${binding.crate.replaceAll("-", "_")}.*`] : []),
         ...(binding.python && binding.pythonModule
           ? [
               `${binding.python}/src/${binding.pythonModule.replaceAll(".", "/")}/bindings.py`,
@@ -499,6 +569,13 @@ export class DBXToolsRustWorkspace {
           : []),
       ]),
     );
+    for (const binding of this.bindingMappings) {
+      if (!binding.node) {
+        continue;
+      }
+      project.prettier?.addIgnorePattern(`${binding.node}/src/bindings.ts`);
+      project.prettier?.addIgnorePattern(`${binding.node}/src/_bindings*.ts`);
+    }
     this.pythonPackages = bindings
       .filter((pkg) => (pkg.packageOptions.bindings ?? ["node", "python"]).includes("python"))
       .map((pkg) => {
@@ -508,10 +585,16 @@ export class DBXToolsRustWorkspace {
           name: pkg.crateName,
           module,
           description: `Python bindings for ${pkg.crateName}`,
-          private: true,
-          generatedSources: [`src/${module.replaceAll(".", "/")}/bindings.py`],
+          uniffi: true,
+          internalDependencies: bindingDependencies(pkg, "python").map(
+            (dependency) => dependency.packageOptions.directory,
+          ),
+          generatedSources: [
+            `src/${module.replaceAll(".", "/")}/bindings.py`,
+            `src/${module.replaceAll(".", "/")}/__init__.py`,
+          ],
           trustedPublisher: {
-            workflowName: options.releaseWorkflowName ?? "rust-release",
+            workflowName: options.pythonReleaseWorkflowName ?? "python-release",
             environment: `pypi-${pkg.crateName}`,
             artifacts: `platform-specific wheels for ${releaseTargets(options)
               .map((target) => `${target.os}-${target.cpu}`)
@@ -530,22 +613,23 @@ export class DBXToolsRustWorkspace {
       const directory = binding.packageOptions.directory;
       const memberPath = `${nodeRoot}/${directory}`;
       const found = existing.get(memberPath);
-      const node =
-        found instanceof DBXToolsTypeScriptProject
-          ? found
-          : new DBXToolsTypeScriptProject({
-              parent: project,
-              outdir: memberPath,
-              name: `@${scope}/${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`,
-              tags: ["node"],
-            });
+      const existingNode = found instanceof DBXToolsTypeScriptProject ? found : undefined;
+      const node = existingNode
+        ? existingNode
+        : new DBXToolsTypeScriptProject({
+            parent: project,
+            outdir: memberPath,
+            name: `@${scope}/${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`,
+            tags: ["node"],
+          });
       node.package.addField(
         "name",
         `@${scope}/${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`,
       );
-      node.package.addField("private", true);
-      node.package.file.addDeletionOverride("publishConfig");
-      node.package.addField("description", `Node bindings for ${binding.crateName}`);
+      node.dbxToolsConfig.uniffi = true;
+      if (!existingNode) {
+        node.package.addField("description", `Node bindings for ${binding.crateName}`);
+      }
       const nativeTargets = releaseTargets(options);
       if (options.release ?? true) {
         node.package.addField(
@@ -559,6 +643,11 @@ export class DBXToolsRustWorkspace {
         );
       }
       node.addDeps("@ubjs/core@0.31.0-5", "@ubjs/node@0.31.0-5");
+      node.addDeps(
+        ...bindingDependencies(binding, "node").map(
+          (dependency) => `@${scope}/${dependency.packageOptions.directory}@workspace:*`,
+        ),
+      );
       if (binding.packageOptions.nodeDependencies?.length) {
         node.addDeps(...binding.packageOptions.nodeDependencies);
       }
@@ -566,10 +655,6 @@ export class DBXToolsRustWorkspace {
       if (binding.packageOptions.nodeDevDependencies?.length) {
         node.addDevDeps(...binding.packageOptions.nodeDevDependencies);
       }
-      node.compileTask.reset();
-      new TextFile(node, "exports.ts", {
-        lines: ['export * from "./src/bindings.ts";', ""],
-      });
       nodePackages.push(node);
     }
     this.nodePackages = nodePackages;
@@ -607,10 +692,13 @@ export class DBXToolsRustWorkspace {
     project.addTask("rs:lint", { exec: "cargo clippy --workspace --all-targets --all-features" });
     project.addTask("rs:test", { exec: "cargo test --workspace" });
     project.addTask("rs:build", { exec: "cargo build --workspace" });
-    project.addTask("rs:bindings", {
+    const bindingsTask = project.addTask("rs:bindings", {
       exec: "bun node_modules/@dbx-tools/projen/tasks/rust.ts",
       description: "Generate language bindings for UniFFI-enabled Rust crates",
     });
+    if (this.bindingMappings.some((binding) => binding.node)) {
+      project.tasks.tryFind("pre-compile")?.spawn(bindingsTask);
+    }
     project.addTask("rs:bindings:demo", {
       description: "Generate and run UniFFI Node and Python example CLIs",
       exec: [
@@ -637,15 +725,6 @@ export class DBXToolsRustWorkspace {
     const workflowName = options.releaseWorkflowName ?? "rust-release";
     const releaseTagPrefix = options.releaseTagPrefix ?? "v";
     const releaseRustVersion = options.releaseRustVersion ?? "stable";
-    const ubrnRustVersion = options.ubrnRustVersion ?? releaseRustVersion;
-    const ubrnToolchainInstall =
-      ubrnRustVersion === releaseRustVersion
-        ? ""
-        : `rustup toolchain install ${ubrnRustVersion} --profile minimal\n`;
-    const ubrnExecutable =
-      "${{ github.workspace }}/.cache/ubrn/uniffi-bindgen-react-native${{ matrix.target.os == 'win32' && '.exe' || '' }}";
-    const builtUbrnExecutable =
-      "target/ubrn/debug/uniffi-bindgen-react-native${{ matrix.target.os == 'win32' && '.exe' || '' }}";
     const releaseBranch = projectReleaseBranch(project);
     const bindings = this.bindingMappings.map((binding) => ({
       ...binding,
@@ -662,12 +741,14 @@ export class DBXToolsRustWorkspace {
       }));
     const publicCrates = this.packages
       .filter((pkg) => !pkg.packageOptions.private)
+      .sort((first, second) => {
+        const order = this.bindingMappings.map((binding) => binding.crate);
+        return order.indexOf(first.crateName) - order.indexOf(second.crateName);
+      })
       .map((pkg) => pkg.crateName);
-    const targetMatrix = targets.map((target, index) => ({
-      target: { ...target, facade: index === 0 },
-    }));
-    const hasNodeBindings = bindings.some((binding) => binding.node);
+    const targetMatrix = targets.map((target) => ({ target }));
     const hasPythonBindings = bindings.some((binding) => binding.python);
+    const usePreinstalledWindowsRust = releaseRustVersion === "stable";
     const hasTargetOutputs =
       bindings.length > 0 || releaseBinaries.length > 0 || publicCrates.length > 0;
     if (hasTargetOutputs && targetMatrix.length === 0) {
@@ -689,16 +770,12 @@ export class DBXToolsRustWorkspace {
         `--python "${binding.python}"`,
         `--node-package "${binding.nodePackage}"`,
         `--python-package "${binding.pythonPackage}"`,
-        ...(binding.node
-          ? ['--node-generator "projen/tasks/uniffi.ts"', '--ubrn "$UBRN_EXECUTABLE"']
-          : []),
         '--cargo-target "${{ matrix.target.cargo }}"',
         '--node-triple "${{ matrix.target.node }}"',
         '--python-tag "${{ matrix.target.python }}"',
         '--os "${{ matrix.target.os }}"',
         '--cpu "${{ matrix.target.cpu }}"',
         '--libc "${{ matrix.target.libc }}"',
-        '--facade "${{ matrix.target.facade }}"',
         `--version "\${VERSION#${releaseTagPrefix}}"`,
         `--output "dist/release/${binding.crate}/\${{ matrix.target.node }}"`,
         "--skip-build",
@@ -726,15 +803,7 @@ export class DBXToolsRustWorkspace {
                 with: {
                   name: `${binding.crate}-\${{ matrix.target.node }}-npm`,
                   path: `dist/release/${binding.crate}/\${{ matrix.target.node }}/npm/*.tgz`,
-                },
-              },
-              {
-                name: `Upload ${binding.crate} npm facade`,
-                if: "${{ matrix.target.facade }}",
-                uses: "actions/upload-artifact@v7",
-                with: {
-                  name: `${binding.crate}-npm-facade`,
-                  path: `dist/release/${binding.crate}/\${{ matrix.target.node }}/npm-facade/*.tgz`,
+                  "retention-days": 7,
                 },
               },
             ]
@@ -745,8 +814,9 @@ export class DBXToolsRustWorkspace {
                 name: `Upload ${binding.crate} Python wheel`,
                 uses: "actions/upload-artifact@v7",
                 with: {
-                  name: `${binding.crate}-\${{ matrix.target.python }}-python-wheel`,
+                  name: `${binding.crate}--\${{ matrix.target.python }}--python-wheel`,
                   path: `dist/release/${binding.crate}/\${{ matrix.target.node }}/python/*.whl`,
+                  "retention-days": 7,
                 },
               },
             ]
@@ -758,6 +828,7 @@ export class DBXToolsRustWorkspace {
         with: {
           name: `${pkg.crate}-\${{ matrix.target.node }}-binary`,
           path: `dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/*`,
+          "retention-days": 7,
         },
       })),
     ];
@@ -767,7 +838,6 @@ export class DBXToolsRustWorkspace {
       "runs-on": "${{ matrix.target.runner }}",
       env: {
         ...RUST_CACHE_ENV,
-        BUN_VERSION,
         SCCACHE_GHA_VERSION: `release-\${{ matrix.target.cargo }}-rust-${releaseRustVersion}`,
       },
       strategy: {
@@ -779,28 +849,26 @@ export class DBXToolsRustWorkspace {
         ...(hasPythonBindings ? [{ name: "Setup uv", uses: "astral-sh/setup-uv@v7" }] : []),
         {
           name: "Setup Rust",
+          ...(usePreinstalledWindowsRust ? { if: "${{ matrix.target.os != 'win32' }}" } : {}),
           uses: `dtolnay/rust-toolchain@${releaseRustVersion}`,
           with: { targets: "${{ matrix.target.cargo }}" },
         },
-        ...rustCacheSteps(`release-\${{ matrix.target.cargo }}-rust-${releaseRustVersion}`),
-        ...(hasNodeBindings
+        ...(usePreinstalledWindowsRust
           ? [
               {
-                name: "Restore UBRN executable",
-                id: "ubrn_cache",
-                uses: "actions/cache/restore@v5",
-                with: {
-                  path: ".cache/ubrn",
-                  key: `ubrn-executable-\${{ runner.os }}-\${{ runner.arch }}-rust-${ubrnRustVersion}-${UBRN_VERSION}`,
-                },
+                name: "Verify preinstalled Windows Rust",
+                if: "${{ matrix.target.os == 'win32' }}",
+                shell: "bash",
+                run: [
+                  "rustc --version --verbose",
+                  "cargo --version",
+                  'rustup target list --installed | grep -Fx "${{ matrix.target.cargo }}"',
+                  'test -f "$(rustc --print sysroot)/lib/rustlib/${{ matrix.target.cargo }}/bin/rust-lld.exe"',
+                ].join("\n"),
               },
             ]
           : []),
-        ...(hasNodeBindings
-          ? bunCacheRestoreSteps(project, {
-              condition: "steps.ubrn_cache.outputs.cache-hit != 'true'",
-            })
-          : []),
+        ...rustCacheSteps(`release-\${{ matrix.target.cargo }}-rust-${releaseRustVersion}`),
         {
           name: "Log cache configuration",
           shell: "bash",
@@ -809,13 +877,6 @@ export class DBXToolsRustWorkspace {
             'echo "cargo_cache_hit=${{ steps.cargo_cache.outputs.cache-hit }}"',
             'echo "sccache_scope=${{ github.ref }}"',
             'echo "sccache_namespace=${SCCACHE_GHA_VERSION}"',
-            `echo "ubrn_rust_toolchain=${ubrnRustVersion}"`,
-            ...(hasNodeBindings
-              ? [
-                  `echo "ubrn_executable_cache_key=ubrn-executable-\${{ runner.os }}-\${{ runner.arch }}-rust-${ubrnRustVersion}-${UBRN_VERSION}"`,
-                  'echo "ubrn_executable_cache_hit=${{ steps.ubrn_cache.outputs.cache-hit }}"',
-                ]
-              : []),
           ].join("\n"),
         },
         {
@@ -823,59 +884,13 @@ export class DBXToolsRustWorkspace {
           if: "${{ matrix.target.os == 'linux' }}",
           run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
         },
-        ...(hasNodeBindings
-          ? [
-              {
-                name: "Install Node tooling",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
-                shell: "bash",
-                run: timedBash("node_tooling", "bun install"),
-              },
-              bunCacheSaveStep({
-                condition: "steps.ubrn_cache.outputs.cache-hit != 'true'",
-              }),
-            ]
-          : []),
-        ...(hasNodeBindings
-          ? [
-              {
-                name: "Prepare UBRN generator",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
-                env: {
-                  CARGO_TARGET_DIR: "${{ github.workspace }}/target/ubrn",
-                  UBRN_EXECUTABLE: ubrnExecutable,
-                },
-                shell: "bash",
-                run: timedBash(
-                  "ubrn_generator",
-                  [
-                    `${ubrnToolchainInstall}cargo +${ubrnRustVersion} build --manifest-path node_modules/uniffi-bindgen-react-native/crates/ubrn_cli/Cargo.toml`,
-                    'mkdir -p "$(dirname "$UBRN_EXECUTABLE")"',
-                    `cp "${builtUbrnExecutable}" "$UBRN_EXECUTABLE"`,
-                    'chmod +x "$UBRN_EXECUTABLE"',
-                  ].join("\n"),
-                ),
-              },
-              {
-                name: "Verify UBRN executable",
-                env: { UBRN_EXECUTABLE: ubrnExecutable },
-                shell: "bash",
-                run: 'test -f "$UBRN_EXECUTABLE"',
-              },
-              {
-                name: "Save UBRN executable",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
-                uses: "actions/cache/save@v5",
-                with: {
-                  path: ".cache/ubrn",
-                  key: "${{ steps.ubrn_cache.outputs.cache-primary-key }}",
-                },
-              },
-            ]
-          : []),
         {
           name: "Build Rust outputs",
           shell: "bash",
+          env: {
+            CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER:
+              "${{ matrix.target.os == 'win32' && 'rust-lld' || '' }}",
+          },
           run: timedBash(
             "rust_workspace",
             'cargo build --release --workspace --target "${{ matrix.target.cargo }}"',
@@ -886,14 +901,7 @@ export class DBXToolsRustWorkspace {
               {
                 name: "Package UniFFI outputs",
                 shell: "bash",
-                env: {
-                  VERSION: RELEASE_TAG,
-                  ...(hasNodeBindings
-                    ? {
-                        UBRN_EXECUTABLE: ubrnExecutable,
-                      }
-                    : {}),
-                },
+                env: { VERSION: RELEASE_TAG },
                 run: timedBash("uniffi_packaging", bindingCommands.join("\n")),
               },
             ]
@@ -916,80 +924,8 @@ export class DBXToolsRustWorkspace {
         },
       ],
     };
-    const bindingPublishJobs = Object.fromEntries(
-      bindings.map((binding) => [
-        `publish-${binding.crate}`,
-        {
-          if: "${{ github.event_name == 'repository_dispatch' }}",
-          needs: ["build"],
-          "runs-on": "ubuntu-latest",
-          permissions: {
-            contents: "read",
-            ...(binding.python ? { "id-token": "write" } : {}),
-          },
-          ...(binding.python ? { environment: { name: `pypi-${binding.crate}` } } : {}),
-          steps: [
-            ...(binding.node
-              ? [
-                  {
-                    name: "Setup Node.js",
-                    uses: "actions/setup-node@v6",
-                    with: { "registry-url": "https://registry.npmjs.org" },
-                  },
-                  {
-                    name: "Download native npm packages",
-                    uses: "actions/download-artifact@v8",
-                    with: {
-                      pattern: `${binding.crate}-*-npm`,
-                      path: "dist/npm",
-                      "merge-multiple": true,
-                    },
-                  },
-                  {
-                    name: "Download npm facade",
-                    uses: "actions/download-artifact@v8",
-                    with: {
-                      name: `${binding.crate}-npm-facade`,
-                      path: "dist/npm-facade",
-                    },
-                  },
-                  {
-                    name: "Publish native npm packages",
-                    env: { NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}" },
-                    run: 'for package in dist/npm/*.tgz; do npm publish "$package" --access public; done',
-                  },
-                  {
-                    name: "Publish npm facade",
-                    env: { NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}" },
-                    run: 'for package in dist/npm-facade/*.tgz; do npm publish "$package" --access public; done',
-                  },
-                ]
-              : []),
-            ...(binding.python
-              ? [
-                  { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
-                  {
-                    name: "Download Python wheels",
-                    uses: "actions/download-artifact@v8",
-                    with: {
-                      pattern: `${binding.crate}-*-python-wheel`,
-                      path: "dist/python",
-                      "merge-multiple": true,
-                    },
-                  },
-                  {
-                    name: "Publish Python wheels",
-                    run: "uv publish --trusted-publishing always dist/python/*.whl",
-                  },
-                ]
-              : []),
-          ],
-        },
-      ]),
-    );
     const releaseCompletionJobs = [
       "build",
-      ...bindings.map((binding) => `publish-${binding.crate}`),
       ...(publicCrates.length ? ["publish-cargo"] : []),
       ...(releaseBinaries.length ? ["publish-github-release"] : []),
     ];
@@ -1057,7 +993,6 @@ export class DBXToolsRustWorkspace {
             ],
           },
           ...(hasTargetOutputs && targetMatrix.length ? { build: buildJob } : {}),
-          ...bindingPublishJobs,
           ...(publicCrates.length
             ? {
                 "publish-cargo": {
@@ -1085,79 +1020,6 @@ export class DBXToolsRustWorkspace {
                 },
               }
             : {}),
-          ...(bindings.length
-            ? {
-                "publish-local-bindings": {
-                  if: "${{ github.event_name == 'repository_dispatch' && vars.LOCAL_REPOSITORIES == 'true' }}",
-                  needs: ["build"],
-                  "runs-on": ["self-hosted"],
-                  permissions: { contents: "read" },
-                  steps: [
-                    ...(hasNodeBindings
-                      ? [
-                          {
-                            name: "Setup Node.js",
-                            uses: "actions/setup-node@v6",
-                            with: {
-                              "registry-url": "${{ vars.LOCAL_NPM_REGISTRY }}",
-                            },
-                          },
-                          {
-                            name: "Download native npm packages",
-                            uses: "actions/download-artifact@v8",
-                            with: {
-                              pattern: "*-npm",
-                              path: "dist/npm",
-                              "merge-multiple": true,
-                            },
-                          },
-                          {
-                            name: "Download npm facades",
-                            uses: "actions/download-artifact@v8",
-                            with: {
-                              pattern: "*-npm-facade",
-                              path: "dist/npm-facade",
-                              "merge-multiple": true,
-                            },
-                          },
-                          {
-                            name: "Publish npm packages locally",
-                            env: {
-                              NODE_AUTH_TOKEN: "${{ secrets.LOCAL_NPM_TOKEN }}",
-                            },
-                            run: [
-                              'for package in dist/npm/*.tgz; do npm publish "$package" --access public; done',
-                              'for package in dist/npm-facade/*.tgz; do npm publish "$package" --access public; done',
-                            ].join("\n"),
-                          },
-                        ]
-                      : []),
-                    ...(hasPythonBindings
-                      ? [
-                          { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
-                          {
-                            name: "Download Python wheels",
-                            uses: "actions/download-artifact@v8",
-                            with: {
-                              pattern: "*-python-wheel",
-                              path: "dist/python",
-                              "merge-multiple": true,
-                            },
-                          },
-                          {
-                            name: "Publish Python wheels locally",
-                            env: {
-                              UV_PUBLISH_USERNAME: "${{ secrets.LOCAL_PYPI_USERNAME }}",
-                              UV_PUBLISH_PASSWORD: "${{ secrets.LOCAL_PYPI_PASSWORD }}",
-                            },
-                            run: 'uv publish --publish-url "${{ vars.LOCAL_PYPI_PUBLISH_URL }}" dist/python/*.whl',
-                          },
-                        ]
-                      : []),
-                  ],
-                },
-              }
-            : {}),
           ...(publicCrates.length
             ? {
                 "publish-local-cargo": {
@@ -1232,6 +1094,8 @@ export class DBXToolsRustWorkspace {
                   RELEASE_TAG,
                   EXPECTED_SHA: RELEASE_SHA,
                   RELEASE_EVENT: DOWNSTREAM_RELEASE_EVENT,
+                  RUST_RUN_ID: "${{ github.run_id }}",
+                  RUST_RUN_ATTEMPT: "${{ github.run_attempt }}",
                 },
                 run: [
                   [
@@ -1239,6 +1103,8 @@ export class DBXToolsRustWorkspace {
                     '--raw-field event_type="$RELEASE_EVENT"',
                     '--raw-field "client_payload[release_tag]=$RELEASE_TAG"',
                     '--raw-field "client_payload[expected_sha]=$EXPECTED_SHA"',
+                    '--raw-field "client_payload[rust_run_id]=$RUST_RUN_ID"',
+                    '--raw-field "client_payload[rust_run_attempt]=$RUST_RUN_ATTEMPT"',
                   ].join(" \\\n  "),
                 ].join("\n"),
               },