@dbx-tools/projen 0.6.151 → 0.6.153

package/README.md

@@ -104,11 +104,26 @@ removing a crate or `setup_scaffolding!()` marker triggers a full synth. Repos
 without Rust crates start no Rust watcher. When Rust projects are detected,
 Cargo is required and the focused task fails immediately if it is unavailable.
 
-The workspace also generates a `rust-release` workflow from those discovered
-UniFFI crates. It builds Linux x64/arm64, macOS x64/arm64, and Windows x64.
-Node publishes a small facade plus optional OS/CPU packages, so npm installs
-only the matching native library. Python publishes one platform-tagged wheel
-per target, so pip follows the same thin-install model.
+The workspace also generates a `rust-release` workflow from discovered crates,
+UniFFI bindings, and release-enabled binaries. Its matrix has one row per
+target. Each row installs native dependencies and restores Cargo/sccache once,
+builds the Rust workspace once, then packages every discovered output from that
+shared build. Bun and the workspace install are present only when a Node binding
+needs TypeScript generation; uv is present only when a Python wheel is needed.
+A binary-only workspace therefore installs neither.
+
+The Node generator's Rust CLI is cached under one target directory keyed by its
+pinned UBRN version and runner architecture, then prepared before the workspace
+build. Python generation executes the already-built
+`target/<triple>/release/uniffi-bindgen` directly. Artifact packaging therefore
+does no Rust compilation after the main workspace build.
+
+Artifacts identify their crate, target, and type. Download-only publication
+jobs publish native npm platform archives before the facade and publish
+platform-tagged Python wheels without checkout, Bun, or `bun install`.
+Non-private Cargo crates publish from a source-only job with
+`cargo publish --no-verify`; GitHub Release uploads likewise consume prebuilt
+binary artifacts without reinstalling a toolchain.
 
 Set the repository variable `LOCAL_REPOSITORIES=true` to enable the generated
 self-hosted mirror job. Configure `LOCAL_NPM_REGISTRY` and
@@ -119,11 +134,13 @@ detects its OS, architecture, libc, Rust target, and Python wheel tag and builds
 only that native target. Public Cargo crates also publish directly to crates.io
 with `CARGO_REGISTRY_TOKEN`. Override `releaseTargets` only when a consumer has
 additional native runners; ordinary projects inherit the maintained matrix
-automatically.
+automatically. `bun run bump` also accepts repeatable `--os` and `--arch`
+selectors; every selected operating system is crossed with every selected
+architecture. Omit both filters to regenerate the complete maintained matrix.
 
-Private Python projects are marked with `[tool.dbx-tools] private = true`. They
-are excluded from the uv workspace, documentation, and Python release workflow
-until their native artifact publishing matrix is enabled.
+Private Python binding projects are marked with `[tool.dbx-tools] private =
+true`. They stay out of the standard uv/Python release and docs surfaces;
+`rust-release` publishes their prebuilt native wheels directly.
 
 ## Customize Packages With Mixins
 
@@ -318,10 +335,12 @@ Use `--local-registry false` or `--local-pypi false` to disable either local
 publish. An explicit `--local-pypi http://localhost:3141/user/index/` overrides
 auto-detection; `--python-root` defaults to `packages/py`.
 
-The pushed `v*` tag is also the public release boundary: it triggers npm
-publishing, stamps and publishes every Python distribution to PyPI, and rebuilds
-and deploys the documentation site. Ordinary pushes to `main` publish none of
-those surfaces.
+The pushed `v*` tag is also the public release boundary. Available workflow
+stages form the generated chain Rust -> Python -> Node -> docs: Rust builds and
+publishes native artifacts and Cargo crates, Python publishes standard
+distributions, Node publishes standard workspace packages, and docs deploys
+after publication. A stage with no corresponding outputs is omitted. Ordinary
+pushes to `main` publish none of those surfaces.
 
 Members intentionally keep only the tasks that something OTHER than a human
 invokes, so there is no second place to run the same thing:

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.151",
-    "@dbx-tools/path": "0.6.151",
-    "@dbx-tools/shared-core": "0.6.151",
+    "@dbx-tools/core": "0.6.153",
+    "@dbx-tools/path": "0.6.153",
+    "@dbx-tools/shared-core": "0.6.153",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -48,7 +48,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.151",
+  "version": "0.6.153",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_release-platform.ts

@@ -0,0 +1,14 @@
+/** Cartesian-product release target filter shared by the bump task. */
+export function releasePlatformFilter(
+  operatingSystems: readonly string[],
+  architectures: readonly string[],
+): string {
+  if ((operatingSystems.length === 0) !== (architectures.length === 0)) {
+    throw new Error("--os and --arch must be used together");
+  }
+  return operatingSystems
+    .flatMap((operatingSystem) =>
+      architectures.map((architecture) => `${operatingSystem}:${architecture}`),
+    )
+    .join(",");
+}

package/src/project-js.ts

@@ -379,6 +379,7 @@ function defaultProjectOptions(
     // provider. See {@link DBXToolsRelease}.
     ...(isRoot ? {} : { npmAccess: javascript.NpmAccess.PUBLIC }),
     buildWorkflow: false,
+    workflowPackageCache: false,
     release: false,
     // The root build validates the whole workspace and must not also pack every
     // member into unused `dist/js` tarballs. Child projects keep projen's package
@@ -518,7 +519,7 @@ export interface DBXToolsJavaScriptProjectOptions
   /** Workflow that must finish successfully before the main Node release runs. */
   readonly releaseUpstreamWorkflow?: string;
   /** Main Node release workflow name. Defaults to `node-release`. */
-  readonly releaseWorkflowName?: string | false;
+  readonly nodeReleaseWorkflowName?: string | false;
   /**
    * Extra workspace member paths (repo-relative, POSIX) to list in the workspace
    * config ALONGSIDE the discovered `packageRoots` members - for a package that
@@ -1188,7 +1189,7 @@ function initProject(
     tagPrefix: options.releaseTagPrefix,
     standaloneReleases: options.standaloneReleases,
     upstreamWorkflow: options.releaseUpstreamWorkflow,
-    workflowName: options.releaseWorkflowName,
+    workflowName: options.nodeReleaseWorkflowName ?? options.releaseWorkflowName,
   });
 }
 

package/src/project-rs.ts

@@ -1,14 +1,14 @@
 /** Filesystem-discovered Rust workspaces and UniFFI binding package wiring. */
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { string } from "@dbx-tools/shared-core";
 import { Project, TextFile, YamlFile, javascript } from "projen";
 import type { DBXToolsProject } from "./project.ts";
 import { DBXToolsTypeScriptProject } from "./project-js.ts";
 import type { PythonPackageOptions } from "./project-py.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
-import { mixin } from "../index.ts";
-import { isDBXToolsJavaScriptProject, isDBXToolsProject } from "./project-predicate.ts";
+import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 
 export interface CargoDependencyOptions {
   readonly version?: string;
@@ -139,6 +139,7 @@ const RUST_CACHE_ENV = {
   RUSTC_WRAPPER: "sccache",
   SCCACHE_GHA_ENABLED: "true",
 } as const;
+const UBRN_VERSION = "0.31.0-5";
 
 function rustCacheSteps(sharedKey: string): readonly Record<string, unknown>[] {
   return [
@@ -172,6 +173,17 @@ function releaseTargets(options: DBXToolsRustWorkspaceOptions): readonly UniFFIR
   });
 }
 
+function uniffiReleaseTaskSource(): string {
+  const sourceDirectory = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(sourceDirectory, "../tasks/uniffi-release.mjs"),
+    resolve(sourceDirectory, "../../tasks/uniffi-release.mjs"),
+  ];
+  const source = candidates.find(existsSync);
+  if (!source) throw new Error("Could not locate tasks/uniffi-release.mjs");
+  return readFileSync(source, "utf8");
+}
+
 /** Persisted mapping consumed by the focused Rust source watcher. */
 export interface RustBindingMapping {
   readonly crate: string;
@@ -462,7 +474,7 @@ export class DBXToolsRustWorkspace {
       if (binding.packageOptions.nodeDependencies?.length) {
         node.addDeps(...binding.packageOptions.nodeDependencies);
       }
-      node.addDevDeps("uniffi-bindgen-react-native@0.31.0-5");
+      node.addDevDeps(`uniffi-bindgen-react-native@${UBRN_VERSION}`);
       if (binding.packageOptions.nodeDevDependencies?.length) {
         node.addDevDeps(...binding.packageOptions.nodeDevDependencies);
       }
@@ -525,7 +537,8 @@ export class DBXToolsRustWorkspace {
     });
     if (
       (options.release ?? true) &&
-      (this.bindingMappings.length > 0 || this.packages.some((pkg) => pkg.packageOptions.release))
+      (this.bindingMappings.length > 0 ||
+        this.packages.some((pkg) => pkg.packageOptions.release || !pkg.packageOptions.private))
     ) {
       this.addReleaseWorkflow(project, options, releaseTargets(options));
     }
@@ -544,118 +557,269 @@ export class DBXToolsRustWorkspace {
       nodePackage: binding.nodePackage ?? "",
       pythonPackage: binding.pythonPackage ?? "",
     }));
-    const matrix = bindings.flatMap((binding) =>
-      targets.map((target, index) => ({
-        binding,
-        target: { ...target, facade: index === 0 },
-      })),
-    );
     const releaseBinaries = this.packages
       .filter((pkg) => pkg.packageOptions.release)
       .map((pkg) => ({
         crate: pkg.crateName,
         binary: pkg.packageOptions.binaryName ?? pkg.crateName,
       }));
-    const binaryMatrix = releaseBinaries.flatMap((pkg) =>
-      targets.map((target) => ({ package: pkg, target })),
+    const publicCrates = this.packages
+      .filter((pkg) => !pkg.packageOptions.private)
+      .map((pkg) => pkg.crateName);
+    const targetMatrix = targets.map((target, index) => ({
+      target: { ...target, facade: index === 0 },
+    }));
+    const hasNodeBindings = bindings.some((binding) => binding.node);
+    const hasPythonBindings = bindings.some((binding) => binding.python);
+    const hasTargetOutputs = bindings.length > 0 || releaseBinaries.length > 0;
+    const releaseTask = ".projen/uniffi-release.mjs";
+    if (bindings.length) {
+      new TextFile(project, releaseTask, {
+        lines: uniffiReleaseTaskSource().trimEnd().split("\n"),
+      });
+    } else {
+      project.tryRemoveFile(releaseTask);
+    }
+    const bindingCommands = bindings.map((binding) =>
+      [
+        `node ${releaseTask} build`,
+        `--crate "${binding.crate}"`,
+        `--node "${binding.node}"`,
+        `--python "${binding.python}"`,
+        `--node-package "${binding.nodePackage}"`,
+        `--python-package "${binding.pythonPackage}"`,
+        ...(binding.node
+          ? ['--node-generator "node_modules/@dbx-tools/projen/tasks/uniffi.ts"']
+          : []),
+        '--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#v}"',
+        `--output "dist/release/${binding.crate}/\${{ matrix.target.node }}"`,
+        "--skip-build",
+      ].join(" \\\n  "),
     );
+    const binaryCommands = releaseBinaries.flatMap((pkg) => [
+      `mkdir -p "dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/stage"`,
+      `SOURCE="target/\${{ matrix.target.cargo }}/release/${pkg.binary}\${{ matrix.target.os == 'win32' && '.exe' || '' }}"`,
+      `DESTINATION="dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/stage/${pkg.binary}\${{ matrix.target.os == 'win32' && '.exe' || '' }}"`,
+      'cp "$SOURCE" "$DESTINATION"',
+      'if [ "${{ matrix.target.os }}" = "win32" ]; then',
+      `  7z a "dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/${pkg.binary}-\${{ matrix.target.node }}.zip" "$DESTINATION"`,
+      "else",
+      `  tar -C "dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/stage" -czf "dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/${pkg.binary}-\${{ matrix.target.node }}.tar.gz" "${pkg.binary}"`,
+      "fi",
+      `rm -rf "dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/stage"`,
+    ]);
+    const artifactSteps = [
+      ...bindings.flatMap((binding) => [
+        ...(binding.node
+          ? [
+              {
+                name: `Upload ${binding.crate} native npm package`,
+                uses: "actions/upload-artifact@v7",
+                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`,
+                },
+              },
+            ]
+          : []),
+        ...(binding.python
+          ? [
+              {
+                name: `Upload ${binding.crate} Python wheel`,
+                uses: "actions/upload-artifact@v7",
+                with: {
+                  name: `${binding.crate}-\${{ matrix.target.python }}-python-wheel`,
+                  path: `dist/release/${binding.crate}/\${{ matrix.target.node }}/python/*.whl`,
+                },
+              },
+            ]
+          : []),
+      ]),
+      ...releaseBinaries.map((pkg) => ({
+        name: `Upload ${pkg.crate} release binary`,
+        uses: "actions/upload-artifact@v7",
+        with: {
+          name: `${pkg.crate}-\${{ matrix.target.node }}-binary`,
+          path: `dist/release/${pkg.crate}/\${{ matrix.target.node }}/binary/*`,
+        },
+      })),
+    ];
     const buildJob = {
-      name: "${{ matrix.binding.crate }} / ${{ matrix.target.node }}",
+      name: "${{ matrix.target.node }}",
       "runs-on": "${{ matrix.target.runner }}",
       env: RUST_CACHE_ENV,
       strategy: {
         "fail-fast": false,
-        matrix: { include: matrix },
+        matrix: { include: targetMatrix },
       },
       steps: [
         { name: "Checkout", uses: "actions/checkout@v6" },
-        {
-          name: "Setup Bun",
-          uses: "oven-sh/setup-bun@v2",
-          with: { "bun-version": "1.3.14" },
-        },
-        { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
+        ...(hasNodeBindings
+          ? [
+              {
+                name: "Setup Bun",
+                uses: "oven-sh/setup-bun@v2",
+                with: { "bun-version": "1.3.14" },
+              },
+            ]
+          : []),
+        ...(hasPythonBindings ? [{ name: "Setup uv", uses: "astral-sh/setup-uv@v7" }] : []),
         {
           name: "Setup Rust",
           uses: "dtolnay/rust-toolchain@stable",
           with: { targets: "${{ matrix.target.cargo }}" },
         },
         ...rustCacheSteps("release-${{ matrix.target.cargo }}"),
+        ...(hasNodeBindings
+          ? [
+              {
+                name: "Cache UBRN generator",
+                uses: "actions/cache@v5",
+                with: {
+                  path: "target/ubrn",
+                  key: `ubrn-\${{ runner.os }}-\${{ runner.arch }}-${UBRN_VERSION}`,
+                },
+              },
+            ]
+          : []),
         {
           name: "Install Linux native dependencies",
           if: "${{ matrix.target.os == 'linux' }}",
           run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
         },
-        { name: "Install", run: "bun install" },
+        ...(hasNodeBindings ? [{ name: "Install Node tooling", run: "bun install" }] : []),
+        ...(hasNodeBindings
+          ? [
+              {
+                name: "Prepare UBRN generator",
+                env: {
+                  CARGO_TARGET_DIR: "${{ github.workspace }}/target/ubrn",
+                },
+                run: "cargo build --manifest-path node_modules/uniffi-bindgen-react-native/crates/ubrn_cli/Cargo.toml",
+              },
+            ]
+          : []),
         {
-          name: "Build thin native packages",
-          shell: "bash",
-          env: {
-            VERSION: "${{ github.event_name == 'push' && github.ref_name || inputs.version }}",
-          },
-          run: 'bun node_modules/@dbx-tools/projen/tasks/uniffi-release.ts build --crate "${{ matrix.binding.crate }}" --rust "${{ matrix.binding.rust }}" --node "${{ matrix.binding.node }}" --python "${{ matrix.binding.python }}" --node-package "${{ matrix.binding.nodePackage }}" --python-package "${{ matrix.binding.pythonPackage }}" --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#v}"',
-        },
-        {
-          name: "Upload native packages",
-          uses: "actions/upload-artifact@v7",
-          with: {
-            name: "${{ matrix.binding.crate }}-${{ matrix.target.node }}",
-            path: [
-              "dist/uniffi/npm/*.tgz",
-              "dist/uniffi/npm-facade/*.tgz",
-              "dist/uniffi/python/*.whl",
-            ].join("\n"),
-          },
+          name: "Build Rust outputs",
+          run: 'cargo build --release --workspace --target "${{ matrix.target.cargo }}"',
         },
+        ...(bindingCommands.length
+          ? [
+              {
+                name: "Package UniFFI outputs",
+                shell: "bash",
+                env: {
+                  VERSION:
+                    "${{ github.event_name == 'push' && github.ref_name || inputs.version }}",
+                  ...(hasNodeBindings
+                    ? {
+                        CARGO_TARGET_DIR: "${{ github.workspace }}/target/ubrn",
+                      }
+                    : {}),
+                },
+                run: bindingCommands.join("\n"),
+              },
+            ]
+          : []),
+        ...(binaryCommands.length
+          ? [
+              {
+                name: "Package release binaries",
+                shell: "bash",
+                run: binaryCommands.join("\n"),
+              },
+            ]
+          : []),
+        ...artifactSteps,
       ],
     };
-    const binaryBuildJob = {
-      name: "${{ matrix.package.crate }} / ${{ matrix.target.node }}",
-      "runs-on": "${{ matrix.target.runner }}",
-      env: RUST_CACHE_ENV,
-      strategy: { "fail-fast": false, matrix: { include: binaryMatrix } },
-      steps: [
-        { name: "Checkout", uses: "actions/checkout@v6" },
+    const bindingPublishJobs = Object.fromEntries(
+      bindings.map((binding) => [
+        `publish-${binding.crate}`,
         {
-          name: "Setup Rust",
-          uses: "dtolnay/rust-toolchain@stable",
-          with: { targets: "${{ matrix.target.cargo }}" },
-        },
-        ...rustCacheSteps("release-${{ matrix.target.cargo }}"),
-        {
-          name: "Install Linux native dependencies",
-          if: "${{ matrix.target.os == 'linux' }}",
-          run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
-        },
-        {
-          name: "Build release binary",
-          shell: "bash",
-          run: [
-            'cargo build --release --package "${{ matrix.package.crate }}" --bin "${{ matrix.package.binary }}" --target "${{ matrix.target.cargo }}"',
-            "mkdir -p dist/rust-release/stage",
-            "SOURCE=\"target/${{ matrix.target.cargo }}/release/${{ matrix.package.binary }}${{ matrix.target.os == 'win32' && '.exe' || '' }}\"",
-            "DESTINATION=\"dist/rust-release/stage/${{ matrix.package.binary }}${{ matrix.target.os == 'win32' && '.exe' || '' }}\"",
-            'cp "$SOURCE" "$DESTINATION"',
-            'if [ "${{ matrix.target.os }}" = "win32" ]; then',
-            '  ARCHIVE="dist/rust-release/${{ matrix.package.binary }}-${{ matrix.target.node }}.zip"',
-            '  7z a "$ARCHIVE" "$DESTINATION"',
-            "else",
-            '  ARCHIVE="dist/rust-release/${{ matrix.package.binary }}-${{ matrix.target.node }}.tar.gz"',
-            '  tar -C dist/rust-release/stage -czf "$ARCHIVE" "${{ matrix.package.binary }}"',
-            "fi",
-            "rm -rf dist/rust-release/stage",
-          ].join("\n"),
-        },
-        {
-          name: "Upload release binary",
-          uses: "actions/upload-artifact@v7",
-          with: {
-            name: "release-${{ matrix.package.crate }}-${{ matrix.target.node }}",
-            path: "dist/rust-release/*",
+          if: "${{ github.event_name == 'push' }}",
+          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 workflowName = options.releaseWorkflowName ?? "rust-release";
     new YamlFile(project, `.github/workflows/${workflowName}.yml`, {
       obj: {
@@ -674,81 +838,32 @@ export class DBXToolsRustWorkspace {
         },
         permissions: { contents: "read" },
         jobs: {
-          ...(matrix.length ? { build: buildJob } : {}),
-          ...(binaryMatrix.length ? { "build-binaries": binaryBuildJob } : {}),
-          ...(bindings.length
+          ...(hasTargetOutputs && targetMatrix.length ? { build: buildJob } : {}),
+          ...bindingPublishJobs,
+          ...(publicCrates.length
             ? {
-                publish: {
+                "publish-cargo": {
                   if: "${{ github.event_name == 'push' }}",
-                  needs: ["build"],
+                  ...(hasTargetOutputs ? { needs: ["build"] } : {}),
                   "runs-on": "ubuntu-latest",
-                  strategy: { matrix: { binding: bindings } },
-                  permissions: { contents: "read", "id-token": "write" },
-                  environment: { name: "pypi-${{ matrix.binding.crate }}" },
+                  permissions: { contents: "read" },
                   steps: [
                     { name: "Checkout", uses: "actions/checkout@v6" },
+                    { name: "Setup Rust", uses: "dtolnay/rust-toolchain@stable" },
                     {
-                      name: "Setup Node.js",
-                      uses: "actions/setup-node@v6",
-                      with: { "registry-url": "https://registry.npmjs.org" },
-                    },
-                    {
-                      name: "Setup Bun",
-                      uses: "oven-sh/setup-bun@v2",
-                      with: { "bun-version": "1.3.14" },
-                    },
-                    { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
-                    { name: "Install", run: "bun install" },
-                    {
-                      name: "Download packages",
-                      uses: "actions/download-artifact@v8",
-                      with: {
-                        pattern: "${{ matrix.binding.crate }}-*",
-                        path: "dist/uniffi",
-                        "merge-multiple": true,
-                      },
-                    },
-                    {
-                      name: "Publish npm packages",
-                      env: { NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}" },
-                      run: 'for package in dist/uniffi/npm/*.tgz; do npm publish "$package" --access public; done',
-                    },
-                    {
-                      name: "Publish npm facades",
-                      if: "${{ matrix.binding.node != '' }}",
-                      env: { NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}" },
-                      run: 'for package in dist/uniffi/npm-facade/*.tgz; do npm publish "$package" --access public; done',
-                    },
-                    {
-                      name: "Publish Python wheels",
-                      if: "${{ matrix.binding.python != '' }}",
-                      run: "uv publish --trusted-publishing always dist/uniffi/python/*.whl",
+                      name: "Publish public crates",
+                      env: { CARGO_REGISTRY_TOKEN: "${{ secrets.CARGO_REGISTRY_TOKEN }}" },
+                      run: publicCrates
+                        .map(
+                          (crate) =>
+                            `cargo publish --package "${crate}" --registry crates-io --no-verify`,
+                        )
+                        .join("\n"),
                     },
                   ],
                 },
               }
             : {}),
-          "publish-cargo": {
-            if: "${{ github.event_name == 'push' }}",
-            needs: [matrix.length ? "build" : "build-binaries"],
-            "runs-on": "ubuntu-latest",
-            permissions: { contents: "read" },
-            env: RUST_CACHE_ENV,
-            steps: [
-              { name: "Checkout", uses: "actions/checkout@v6" },
-              { name: "Setup Rust", uses: "dtolnay/rust-toolchain@stable" },
-              ...rustCacheSteps("cargo-publish"),
-              {
-                name: "Install Linux native dependencies",
-                run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
-              },
-              {
-                name: "Publish public crates",
-                env: { CARGO_REGISTRY_TOKEN: "${{ secrets.CARGO_REGISTRY_TOKEN }}" },
-                run: "cargo publish --workspace --registry crates-io",
-              },
-            ],
-          },
           "publish-local": {
             if: "${{ github.event_name == 'push' && vars.LOCAL_REPOSITORIES == 'true' }}",
             "runs-on": ["self-hosted"],
@@ -780,11 +895,11 @@ export class DBXToolsRustWorkspace {
               },
             ],
           },
-          ...(binaryMatrix.length
+          ...(releaseBinaries.length
             ? {
                 "publish-github-release": {
                   if: "${{ github.event_name == 'push' }}",
-                  needs: ["build-binaries"],
+                  needs: ["build"],
                   "runs-on": "ubuntu-latest",
                   permissions: { contents: "write" },
                   steps: [
@@ -792,7 +907,7 @@ export class DBXToolsRustWorkspace {
                       name: "Download release binaries",
                       uses: "actions/download-artifact@v8",
                       with: {
-                        pattern: "release-*",
+                        pattern: "*-binary",
                         path: "dist/rust-release",
                         "merge-multiple": true,
                       },

package/tasks/bump.ts

@@ -56,6 +56,7 @@ import { log, net } from "@dbx-tools/shared-core";
 import { Command, Option } from "commander";
 import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
+import { releasePlatformFilter } from "../src/_release-platform.ts";
 import {
   type Semver,
   compareSemver,
@@ -234,9 +235,7 @@ program
     }) => {
       const pkgPath = resolve(process.cwd(), "package.json");
       if (!existsSync(pkgPath)) throw new Error(`no package.json in ${process.cwd()}`);
-      if ((opts.os.length === 0) !== (opts.arch.length === 0)) {
-        throw new Error("--os and --arch must be used together");
-      }
+      const releasePlatforms = releasePlatformFilter(opts.os, opts.arch);
 
       const siblings = opts.sibling.map((s) => ({ ...s, pkgPath: resolve(s.dir, "package.json") }));
       for (const s of siblings) {
@@ -285,9 +284,6 @@ program
 
       if (opts.synth) {
         logger.info("synthesizing (projen)");
-        const releasePlatforms = opts.os
-          .flatMap((os) => opts.arch.map((arch) => `${os}:${arch}`))
-          .join(",");
         exec.spawnSync("bun", [".projenrc.ts"], {
           cwd: process.cwd(),
           stdout: "inherit",

package/tasks/publish-uniffi-local.ts

@@ -144,19 +144,19 @@ function buildAndPublish(binding: RustBindingMapping, version: string): void {
 
   const target = nativeTarget();
   const output = resolve(repoRoot, "dist/uniffi");
-  run("bun", [
-    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi-release.ts"),
+  run("node", [
+    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi-release.mjs"),
     "build",
     "--crate",
     binding.crate,
-    "--rust",
-    binding.rust,
     "--node",
     includeNode ? binding.node! : "",
     "--python",
     includePython ? binding.python! : "",
     "--node-package",
     includeNode ? binding.nodePackage! : "",
+    "--node-generator",
+    "projen/tasks/uniffi.ts",
     "--python-package",
     includePython ? binding.pythonPackage! : "",
     "--cargo-target",
@@ -175,6 +175,8 @@ function buildAndPublish(binding: RustBindingMapping, version: string): void {
     "true",
     "--version",
     version,
+    "--output",
+    "dist/uniffi",
   ]);
 
   if (includeNode) {

package/tasks/uniffi-release.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import {
+  chmodSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { spawnSync } from "node:child_process";
+
+const parsed = parseArgs({
+  allowPositionals: true,
+  options: {
+    root: { type: "string" },
+    crate: { type: "string" },
+    node: { type: "string" },
+    python: { type: "string" },
+    "node-package": { type: "string" },
+    "node-generator": { type: "string" },
+    "python-package": { type: "string" },
+    "cargo-target": { type: "string" },
+    "node-triple": { type: "string" },
+    "python-tag": { type: "string" },
+    os: { type: "string" },
+    cpu: { type: "string" },
+    libc: { type: "string" },
+    facade: { type: "string" },
+    version: { type: "string" },
+    output: { type: "string" },
+    "skip-build": { type: "boolean" },
+  },
+});
+
+const required = (name) => {
+  const value = parsed.values[name];
+  if (!value) throw new Error(`Missing --${name}`);
+  return value;
+};
+
+const root = resolve(parsed.values.root ?? process.cwd());
+const run = (command, args, cwd = root) => {
+  const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
+};
+
+const replaceVersion = (source, version) =>
+  source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
+
+const writable = (path) => {
+  if (existsSync(path)) chmodSync(path, statSync(path).mode | 0o200);
+};
+
+const libraryPath = (crate, cargoTarget, os) => {
+  const name = crate.replaceAll("-", "_");
+  const extension = os === "darwin" ? "dylib" : os === "win32" ? "dll" : "so";
+  const prefix = os === "win32" ? "" : "lib";
+  return resolve(root, "target", cargoTarget, "release", `${prefix}${name}.${extension}`);
+};
+
+const packageNode = ({
+  crate,
+  library,
+  output,
+  nodeDirectory,
+  nodePackage,
+  nodeTriple,
+  os,
+  cpu,
+  version,
+  facade,
+  nodeGenerator,
+}) => {
+  const libraryFile = basename(library);
+  const nativePackage = resolve(output, "native-node");
+  mkdirSync(nativePackage, { recursive: true });
+  cpSync(library, join(nativePackage, libraryFile));
+  writeFileSync(
+    join(nativePackage, "package.json"),
+    `${JSON.stringify(
+      {
+        name: `${nodePackage}-${nodeTriple}`,
+        version,
+        description: `Native ${nodeTriple} library for ${nodePackage}`,
+        license: "Apache-2.0",
+        os: [os],
+        cpu: [cpu],
+        ...(parsed.values.libc ? { libc: [parsed.values.libc] } : {}),
+        files: [libraryFile],
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  mkdirSync(resolve(output, "npm"), { recursive: true });
+  run("npm", ["pack", "--pack-destination", resolve(output, "npm")], nativePackage);
+
+  if (!facade) return;
+  const facadeDirectory = resolve(output, "facade-node");
+  cpSync(resolve(root, nodeDirectory), facadeDirectory, { recursive: true });
+  rmSync(join(facadeDirectory, "src", libraryFile), { force: true });
+  const manifestPath = join(facadeDirectory, "package.json");
+  writable(manifestPath);
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  manifest.version = version;
+  manifest.private = false;
+  manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
+  manifest.optionalDependencies = Object.fromEntries(
+    Object.keys(manifest.optionalDependencies ?? {}).map((name) => [name, version]),
+  );
+  manifest.dependencies = Object.fromEntries(
+    Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
+      name,
+      typeof dependency === "string" && dependency.startsWith("workspace:") ? version : dependency,
+    ]),
+  );
+  delete manifest.scripts;
+  delete manifest.devDependencies;
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  run("bun", [
+    resolve(root, nodeGenerator),
+    "--root",
+    root,
+    "--crate",
+    crate,
+    "--node",
+    facadeDirectory,
+    "--cargo-target",
+    required("cargo-target"),
+    "--node-package-base",
+    `${nodePackage}-`,
+    "--skip-build",
+  ]);
+  mkdirSync(resolve(output, "npm-facade"), { recursive: true });
+  run("npm", ["pack", "--pack-destination", resolve(output, "npm-facade")], facadeDirectory);
+};
+
+const packagePython = ({
+  crate,
+  library,
+  output,
+  pythonDirectory,
+  pythonTag,
+  version,
+  cargoTarget,
+  os,
+}) => {
+  const pythonRoot = resolve(output, "python-root");
+  cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
+  const pyproject = join(pythonRoot, "pyproject.toml");
+  writable(pyproject);
+  writeFileSync(pyproject, replaceVersion(readFileSync(pyproject, "utf8"), version));
+
+  const packageName = crate.replace(/^dbx-tools-/, "").replaceAll("-", "_");
+  const packageDirectory = resolve(pythonRoot, "src", "dbx_tools", packageName);
+  const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
+  const generator = resolve(
+    root,
+    "target",
+    cargoTarget,
+    "release",
+    `uniffi-bindgen${os === "win32" ? ".exe" : ""}`,
+  );
+  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+  run(generator, ["generate", "--language", "python", "--out-dir", generatedDirectory, library]);
+  const bindings = join(packageDirectory, "bindings.py");
+  writable(bindings);
+  const body = readFileSync(join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`), "utf8");
+  writeFileSync(
+    bindings,
+    [
+      "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
+      `# Regenerated from the ${crate} Rust exports.`,
+      "# Hand edits are overwritten on the next watch; this file is read-only.",
+      "",
+      body,
+    ].join("\n"),
+  );
+  cpSync(library, join(packageDirectory, basename(library)));
+  rmSync(generatedDirectory, { recursive: true, force: true });
+
+  const wheelDirectory = resolve(output, "python");
+  mkdirSync(wheelDirectory, { recursive: true });
+  run("uv", ["build", "--wheel", "--out-dir", wheelDirectory], pythonRoot);
+  const wheels = readdirSync(wheelDirectory).filter((file) => file.endsWith(".whl"));
+  if (wheels.length !== 1) throw new Error(`Expected one Python wheel, found ${wheels.length}`);
+  run("uvx", [
+    "--from",
+    "wheel",
+    "wheel",
+    "tags",
+    "--remove",
+    "--platform-tag",
+    pythonTag,
+    join(wheelDirectory, wheels[0]),
+  ]);
+};
+
+const build = () => {
+  const crate = required("crate");
+  const cargoTarget = required("cargo-target");
+  const nodeTriple = required("node-triple");
+  const pythonTag = required("python-tag");
+  const version = required("version");
+  const os = required("os");
+  const cpu = required("cpu");
+  const output = resolve(root, required("output"));
+  const library = libraryPath(crate, cargoTarget, os);
+
+  rmSync(output, { recursive: true, force: true });
+  mkdirSync(output, { recursive: true });
+  if (!parsed.values["skip-build"]) {
+    run("cargo", ["build", "--release", "--package", crate, "--target", cargoTarget]);
+  }
+  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
+
+  const nodeDirectory = parsed.values.node;
+  const nodePackage = parsed.values["node-package"];
+  if (nodeDirectory && nodePackage) {
+    packageNode({
+      crate,
+      library,
+      output,
+      nodeDirectory,
+      nodePackage,
+      nodeTriple,
+      os,
+      cpu,
+      version,
+      facade: parsed.values.facade === "true",
+      nodeGenerator: required("node-generator"),
+    });
+  }
+
+  const pythonDirectory = parsed.values.python;
+  if (pythonDirectory) {
+    packagePython({
+      crate,
+      library,
+      output,
+      pythonDirectory,
+      pythonTag,
+      version,
+      cargoTarget,
+      os,
+    });
+  }
+};
+
+if (parsed.positionals[0] !== "build") throw new Error("Expected build command");
+build();

package/tasks/uniffi.ts

@@ -23,18 +23,22 @@ import {
 
 const { values } = parseArgs({
   options: {
+    root: { type: "string" },
     crate: { type: "string" },
     node: { type: "string" },
     python: { type: "string" },
     "cargo-target": { type: "string" },
     "node-package-base": { type: "string" },
+    "skip-build": { type: "boolean" },
   },
 });
 if (!values.crate || (!values.node && !values.python)) {
   throw new Error("Expected --crate and at least one of --node or --python");
 }
 
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const root = values.root
+  ? resolve(values.root)
+  : resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const crate = values.crate;
 const libraryName = crate.replaceAll("-", "_");
 const extension =
@@ -60,7 +64,8 @@ const run = (command: string, args: string[]) => {
 
 const replaceGenerated = (source: string, destination: string): void => {
   const deadline = Date.now() + 5_000;
-  while (!existsSync(source) && Date.now() < deadline) Bun.sleepSync(25);
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  while (!existsSync(source) && Date.now() < deadline) Atomics.wait(signal, 0, 0, 25);
   if (!existsSync(source)) throw new Error(`Missing generated binding: ${source}`);
   mkdirSync(dirname(destination), { recursive: true });
   makeWritable(destination);
@@ -90,13 +95,15 @@ const stampGeneratedPython = (file: string): void => {
   makeReadonly(file);
 };
 
-run("cargo", [
-  "build",
-  "--release",
-  "--package",
-  crate,
-  ...(values["cargo-target"] ? ["--target", values["cargo-target"]] : []),
-]);
+if (!values["skip-build"]) {
+  run("cargo", [
+    "build",
+    "--release",
+    "--package",
+    crate,
+    ...(values["cargo-target"] ? ["--target", values["cargo-target"]] : []),
+  ]);
+}
 if (!existsSync(library)) throw new Error(`Missing compiled UniFFI library: ${library}`);
 
 if (values.node) {

package/tasks/uniffi-release.ts

@@ -1,168 +0,0 @@
-#!/usr/bin/env -S bun
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-import { spawnSync } from "node:child_process";
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
-const parsed = parseArgs({
-  allowPositionals: true,
-  options: {
-    crate: { type: "string" },
-    rust: { type: "string" },
-    node: { type: "string" },
-    python: { type: "string" },
-    "node-package": { type: "string" },
-    "python-package": { type: "string" },
-    "cargo-target": { type: "string" },
-    "node-triple": { type: "string" },
-    "python-tag": { type: "string" },
-    os: { type: "string" },
-    cpu: { type: "string" },
-    libc: { type: "string" },
-    facade: { type: "string" },
-    version: { type: "string" },
-  },
-});
-
-const required = (name: keyof typeof parsed.values): string => {
-  const value = parsed.values[name];
-  if (!value) throw new Error(`Missing --${name}`);
-  return value;
-};
-
-const run = (command: string, args: string[], cwd = root): void => {
-  const result = spawnSync(command, args, { cwd, stdio: "inherit" });
-  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
-};
-
-const replaceVersion = (source: string, version: string): string =>
-  source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
-
-function build(): void {
-  const crate = required("crate");
-  required("rust");
-  const cargoTarget = required("cargo-target");
-  const nodeTriple = required("node-triple");
-  const pythonTag = required("python-tag");
-  const version = required("version");
-  const os = required("os");
-  const cpu = required("cpu");
-  const nodeDirectory = parsed.values.node;
-  const pythonDirectory = parsed.values.python;
-  const nodePackage = parsed.values["node-package"];
-  const pythonPackage = parsed.values["python-package"];
-  const libraryName = crate.replaceAll("-", "_");
-  const extension = os === "darwin" ? "dylib" : os === "win32" ? "dll" : "so";
-  const prefix = os === "win32" ? "" : "lib";
-  const libraryFile = `${prefix}${libraryName}.${extension}`;
-  const library = resolve(root, "target", cargoTarget, "release", libraryFile);
-  const output = resolve(root, "dist/uniffi");
-
-  rmSync(output, { recursive: true, force: true });
-  mkdirSync(join(output, "npm"), { recursive: true });
-  mkdirSync(join(output, "npm-facade"), { recursive: true });
-  mkdirSync(join(output, "python"), { recursive: true });
-  run("cargo", ["build", "--release", "--package", crate, "--target", cargoTarget]);
-  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
-
-  if (nodeDirectory && nodePackage) {
-    const nativePackage = resolve(output, "native-node");
-    mkdirSync(nativePackage, { recursive: true });
-    cpSync(library, join(nativePackage, libraryFile));
-    writeFileSync(
-      join(nativePackage, "package.json"),
-      `${JSON.stringify(
-        {
-          name: `${nodePackage}-${nodeTriple}`,
-          version,
-          description: `Native ${nodeTriple} library for ${nodePackage}`,
-          license: "Apache-2.0",
-          os: [os],
-          cpu: [cpu],
-          ...(parsed.values.libc ? { libc: [parsed.values.libc] } : {}),
-          files: [libraryFile],
-        },
-        null,
-        2,
-      )}\n`,
-    );
-    run("npm", ["pack", "--pack-destination", resolve(output, "npm")], nativePackage);
-
-    if (parsed.values.facade === "true") {
-      const facade = resolve(output, "facade-node");
-      cpSync(resolve(root, nodeDirectory), facade, { recursive: true });
-      rmSync(join(facade, "src", libraryFile), { force: true });
-      const manifestPath = join(facade, "package.json");
-      const manifestMode = statSync(manifestPath).mode;
-      chmodSync(manifestPath, manifestMode | 0o200);
-      const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-      manifest.version = version;
-      manifest.private = false;
-      manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
-      manifest.optionalDependencies = Object.fromEntries(
-        Object.keys(manifest.optionalDependencies ?? {}).map((name) => [name, version]),
-      );
-      manifest.dependencies = Object.fromEntries(
-        Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
-          name,
-          typeof dependency === "string" && dependency.startsWith("workspace:")
-            ? version
-            : dependency,
-        ]),
-      );
-      delete manifest.scripts;
-      delete manifest.devDependencies;
-      writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-      const generator = resolve(root, "node_modules/@dbx-tools/projen/tasks/uniffi.ts");
-      run("bun", [
-        generator,
-        "--crate",
-        crate,
-        "--node",
-        facade,
-        "--cargo-target",
-        cargoTarget,
-        "--node-package-base",
-        `${nodePackage}-`,
-      ]);
-      run("npm", ["pack", "--pack-destination", resolve(output, "npm-facade")], facade);
-    }
-  }
-
-  if (pythonDirectory && pythonPackage) {
-    const pythonRoot = resolve(output, "python-root");
-    cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
-    const pyproject = join(pythonRoot, "pyproject.toml");
-    const mode = statSync(pyproject).mode;
-    chmodSync(pyproject, mode | 0o200);
-    writeFileSync(pyproject, replaceVersion(readFileSync(pyproject, "utf8"), version));
-    const generator = resolve(root, "node_modules/@dbx-tools/projen/tasks/uniffi.ts");
-    run("bun", [
-      generator,
-      "--crate",
-      crate,
-      "--python",
-      pythonRoot,
-      "--cargo-target",
-      cargoTarget,
-    ]);
-    run("uv", ["build", "--wheel", "--out-dir", resolve(output, "python")], pythonRoot);
-    const wheels = [...new Bun.Glob("*.whl").scanSync(join(output, "python"))];
-    if (wheels.length !== 1) throw new Error(`Expected one Python wheel, found ${wheels.length}`);
-    run("uvx", ["--from", "wheel", "wheel", "tags", "--remove", "--platform-tag", pythonTag, join(output, "python", wheels[0]!)]);
-  }
-}
-
-if (parsed.positionals[0] !== "build") throw new Error("Expected build command");
-build();