@dbx-tools/projen 0.6.186 → 0.6.191

package/README.md

@@ -94,19 +94,20 @@ configurable `root` (default `packages/rs`), generates its Cargo manifest, and
 derives the crate name and repository from the parent project. A crate containing
 `uniffi::setup_scaffolding!()`
 automatically wires matching public Node and Python binding packages using the
-same capability name. Repository-specific dependencies and features remain
+`<name>-rs` folder suffix. Node packages are named `@<scope>/<name>-rs`;
+Python distributions are named `<scope>-<name>-rs` and import generated values
+from `<scope>.<name>_rs.bindings`. Binding packages are always dedicated and
+never merge generated code into handwritten Node or Python packages.
+Repository-specific dependencies and features remain
 declarative options in `.projenrc.ts`; generated bindings are built separately
 from projen synthesis. Target-independent Node binding TypeScript is committed
 and remains generated/read-only, while native libraries stay ignored. Node
 facades compile to `lib/` and publish JavaScript entry points that plain Node
 can load from `node_modules`. A complete `bindings.ts` / `_bindings.ts` /
 `_bindings-ffi.ts` triplet is exported directly from the generated package
-barrel. Python keeps `bindings.py` as the generated implementation and exports
-its public names from a fully generated `__init__.py` with no editable marker
-blocks. Node generation fails when direct binding names conflict with another
-package-root export; Python generation refuses to overwrite a non-generated
-package root. Do not create a `nodeExports` binding subpath or a handwritten
-type facade.
+barrel. Python keeps `bindings.py` as the generated implementation and leaves
+`__init__.py` empty. Node generation fails when direct binding names conflict.
+Do not create a `nodeExports` binding subpath or a handwritten type facade.
 
 Rust dependencies between binding-enabled workspace crates become Node
 `workspace:*` and Python `internalDependencies` automatically. Python generation
@@ -158,6 +159,12 @@ release-enabled binary's `releaseExcludeOs` package option to omit it from
 incompatible rows through Cargo `--exclude`. Release binary packaging and
 artifact upload are skipped in those rows. UniFFI crates cannot use this option
 because every configured target must produce their artifacts.
+Set a release binary's `cli` package option and the workspace
+`cliRegistryPath` to generate a typed `dbx` command registry from the same
+selected targets. The generated entries carry only the archives that the
+release matrix publishes, so an excluded operating system fails locally before
+any download is attempted. The runtime command uses `@dbx-tools/core`
+`bin.ensure`; the core installer itself contains no product registry.
 Rust rows prepare native npm
 archives and Python wheels; they do not install Bun or UBRN and do not build
 Node facades. A binary-only row therefore installs no language package tool.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.6.185";
+export const PACKAGE_VERSION = "0.6.190";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -51,7 +51,7 @@ export type { DBXToolsJavaScriptProject, DBXToolsJavaScriptProjectOptions, DBXTo
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
 export { RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustProject, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependencyOptions, CargoDependency, RustPackageOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping } from "./src/project-rs.ts";
+export type { CargoDependencyOptions, CargoDependency, RustCliOptions, RustPackageOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { ReleaseStage, ReleaseDocsOptions, DBXToolsReleaseOptions } from "./src/release.ts";

package/package.json

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

package/src/project-js.ts

@@ -446,13 +446,13 @@ function defaultProjectOptions(
     devDeps: ["@types/node@^24.6.0"],
     ...(isRoot
       ? {
-        prettier: true,
-        prettierOptions: {
-          settings: PRETTIER_SETTINGS,
-          ignoreFile: true,
-          ignoreFileOptions: { ignorePatterns: [...ignore.ignorePatterns({ test: false })] },
-        },
-      }
+          prettier: true,
+          prettierOptions: {
+            settings: PRETTIER_SETTINGS,
+            ignoreFile: true,
+            ignoreFileOptions: { ignorePatterns: [...ignore.ignorePatterns({ test: false })] },
+          },
+        }
       : {}),
     ...options,
     ...copiedGitIgnoreOptions(options),
@@ -508,10 +508,10 @@ const DEV_DEPS_ROOT: string[] = ["typescript@^5.9.3", `@types/bun@${BUN_VERSION}
 /** Options for {@link DBXToolsNodeProject} (the monorepo root). */
 export interface DBXToolsJavaScriptProjectOptions
   extends
-  CommonProjectOptions,
-  Partial<javascript.NodeProjectOptions>,
-  DBXToolsConfigOptions,
-  DBXToolsPNPMWorkspaceOptions {
+    CommonProjectOptions,
+    Partial<javascript.NodeProjectOptions>,
+    DBXToolsConfigOptions,
+    DBXToolsPNPMWorkspaceOptions {
   /**
    * The npm scope for generated package names (`@<scope>/<seg-...>`). Defaults to
    * the (resolved) project name; a leading `@` is optional.
@@ -584,7 +584,8 @@ export interface DBXToolsTypeScriptProjectOptions
  */
 export class DBXToolsNodeProject
   extends javascript.NodeProject
-  implements DBXToolsJavaScriptProject {
+  implements DBXToolsJavaScriptProject
+{
   readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
@@ -684,8 +685,8 @@ export const ROOT_INSTALL_ONLY_MIXIN = mixin.create(
       installDependencies(trigger: unknown): void;
       logInstallTrigger(trigger: unknown): void;
     };
-    nodePackage.installDependencies = () => { };
-    nodePackage.logInstallTrigger = () => { };
+    nodePackage.installDependencies = () => {};
+    nodePackage.logInstallTrigger = () => {};
   },
 );
 
@@ -698,7 +699,8 @@ export const ROOT_INSTALL_ONLY_MIXIN = mixin.create(
  */
 export class DBXToolsTypeScriptProject
   extends typescript.TypeScriptProject
-  implements DBXToolsJavaScriptProject {
+  implements DBXToolsJavaScriptProject
+{
   readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;

package/src/project-rs.ts

@@ -39,6 +39,13 @@ export interface CargoDependencyOptions {
 
 export type CargoDependency = string | CargoDependencyOptions;
 
+export interface RustCliOptions {
+  /** `dbx` subcommand. Defaults to the Rust package directory. */
+  readonly command?: string;
+  /** Root CLI help text. Defaults to the Rust package description. */
+  readonly description?: string;
+}
+
 export interface RustPackageOptions {
   readonly directory: string;
   readonly description?: string;
@@ -54,9 +61,9 @@ export interface RustPackageOptions {
   readonly defaultFeatures?: readonly string[];
   /** Cargo and release executable name. Defaults to the generated package name. */
   readonly binaryName?: string;
+  /** Publish this release binary through the generated `dbx` command registry. */
+  readonly cli?: boolean | RustCliOptions;
   readonly bindings?: readonly ("node" | "python")[];
-  readonly nodeDependencies?: readonly string[];
-  readonly nodeDevDependencies?: readonly string[];
   readonly uniffiConfig?: Readonly<Record<string, unknown>>;
 }
 
@@ -82,6 +89,8 @@ export interface DBXToolsRustWorkspaceOptions {
   readonly releaseTargets?: readonly UniFFIReleaseTarget[];
   /** Maintained OS/CPU combinations to release. Defaults to every supported target. */
   readonly releasePlatforms?: readonly RustReleasePlatform[];
+  /** Optional generated TypeScript registry for `cli`-enabled release binaries. */
+  readonly cliRegistryPath?: string;
 }
 
 export enum RustReleaseOs {
@@ -154,6 +163,14 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     os: RustReleaseOs.WINDOWS,
     cpu: RustReleaseCpu.X64,
   },
+  {
+    runner: "windows-11-vs2026-arm",
+    cargo: "aarch64-pc-windows-msvc",
+    node: "win32-arm64-msvc",
+    python: "win_arm64",
+    os: RustReleaseOs.WINDOWS,
+    cpu: RustReleaseCpu.ARM64,
+  },
 ] as const;
 
 const RUST_CACHE_ENV = {
@@ -230,6 +247,21 @@ function releasePlatformsFromEnvironment(
   });
 }
 
+function releaseBinaryAssetName(binaryName: string, nodeTarget: string, os: RustReleaseOs): string {
+  const extension = os === RustReleaseOs.WINDOWS ? "zip" : "tar.gz";
+  return `${binaryName}-${nodeTarget}.${extension}`;
+}
+
+function rustCliRegistrySource(binaries: readonly RustReleaseBinaryMapping[]): string {
+  return [
+    "// GENERATED by projen - DO NOT EDIT.",
+    "// Rust release package options are the source of truth.",
+    "",
+    `export const RUST_RELEASE_BINARY_COMMANDS = ${JSON.stringify(binaries, null, 2)} as const;`,
+    "",
+  ].join("\n");
+}
+
 function uniffiReleaseTaskSource(): string {
   const sourceDirectory = dirname(fileURLToPath(import.meta.url));
   const candidates = [
@@ -259,6 +291,23 @@ export interface RustWorkspaceMapping {
   readonly root: string;
   readonly crates: readonly string[];
   readonly bindings: readonly RustBindingMapping[];
+  readonly binaries: readonly RustReleaseBinaryMapping[];
+}
+
+/** One platform archive published for a Rust CLI binary. */
+export interface RustReleaseBinaryAssetMapping {
+  readonly os: RustReleaseOs;
+  readonly cpu: RustReleaseCpu;
+  readonly name: string;
+}
+
+/** Runtime metadata for one lazily installed Rust CLI binary. */
+export interface RustReleaseBinaryMapping {
+  readonly command: string;
+  readonly description: string;
+  readonly binaryName: string;
+  readonly repository: string;
+  readonly assets: readonly RustReleaseBinaryAssetMapping[];
 }
 
 export function orderRustBindings(bindings: readonly RustBindingMapping[]): RustBindingMapping[] {
@@ -474,12 +523,13 @@ function rustPackageDependencies(
   );
 }
 
-/** Generated Rust workspace plus convention-derived UniFFI facade packages. */
+/** Generated Rust workspace plus convention-derived UniFFI binding packages. */
 export class DBXToolsRustWorkspace {
   readonly packages: readonly DBXToolsRustProject[];
   readonly nodePackages: readonly DBXToolsTypeScriptProject[];
   readonly pythonPackages: readonly PythonPackageOptions[];
   readonly bindingMappings: readonly RustBindingMapping[];
+  readonly releaseBinaries: readonly RustReleaseBinaryMapping[];
   readonly workspaceMapping: RustWorkspaceMapping;
 
   constructor(project: javascript.NodeProject, options: DBXToolsRustWorkspaceOptions) {
@@ -492,6 +542,7 @@ export class DBXToolsRustWorkspace {
       projectRepositoryUrl(project) ??
       coreProject.repositoryUrl(project.outdir) ??
       "";
+    const nativeTargets = releaseTargets(options);
     const pythonModulePrefix = options.pythonModulePrefix ?? scope.replaceAll("-", "_");
     const packageOptions = options.packages ?? {};
     this.packages = discoverRustCrates(resolve(project.outdir, root)).map(
@@ -501,6 +552,56 @@ export class DBXToolsRustWorkspace {
           ...packageOptions[directory],
         }),
     );
+    const commands = new Set<string>();
+    this.releaseBinaries = this.packages
+      .filter((pkg) => Boolean(pkg.packageOptions.cli))
+      .map((pkg) => {
+        if (!pkg.packageOptions.release) {
+          throw new Error(`${pkg.crateName} must set release when cli is configured`);
+        }
+        const configured = pkg.packageOptions.cli;
+        const command =
+          typeof configured === "object" && configured.command
+            ? configured.command
+            : pkg.packageOptions.directory;
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(command)) {
+          throw new Error(`Invalid Rust CLI command: ${command}`);
+        }
+        if (commands.has(command)) {
+          throw new Error(`Duplicate Rust CLI command: ${command}`);
+        }
+        commands.add(command);
+        const description =
+          (typeof configured === "object" ? configured.description : undefined) ??
+          pkg.packageOptions.description ??
+          pkg.crateName;
+        const excludedOs = new Set(pkg.packageOptions.releaseExcludeOs ?? []);
+        const binaryName = pkg.packageOptions.binaryName ?? pkg.crateName;
+        return {
+          command,
+          description,
+          binaryName,
+          repository,
+          assets: nativeTargets
+            .filter((target) => !excludedOs.has(target.os))
+            .map((target) => ({
+              os: target.os,
+              cpu: target.cpu,
+              name: releaseBinaryAssetName(binaryName, target.node, target.os),
+            })),
+        };
+      });
+    if (this.releaseBinaries.length && !repository) {
+      throw new Error("A repository URL is required when Rust CLI commands are configured");
+    }
+    if (this.releaseBinaries.length && !options.cliRegistryPath) {
+      throw new Error("cliRegistryPath is required when Rust CLI commands are configured");
+    }
+    if (options.cliRegistryPath) {
+      new TextFile(project, options.cliRegistryPath, {
+        lines: rustCliRegistrySource(this.releaseBinaries).trimEnd().split("\n"),
+      });
+    }
 
     const bindings = this.packages.filter((pkg) => pkg.uniffi);
     const packageDependencies = (pkg: DBXToolsRustProject) =>
@@ -531,7 +632,7 @@ export class DBXToolsRustWorkspace {
     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 packageDirectory = `${string.toSlug(pkg.packageOptions.directory)}-rs`;
         const dependencies = [
           ...new Set([...bindingDependencies(pkg, "node"), ...bindingDependencies(pkg, "python")]),
         ].map((dependency) => dependency.crateName);
@@ -541,15 +642,15 @@ export class DBXToolsRustWorkspace {
           rust: `${root}/${pkg.packageOptions.directory}`,
           ...(targets.includes("node")
             ? {
-                node: `${nodeRoot}/${pkg.packageOptions.directory}`,
-                nodePackage: `@${scope}/${packageName}`,
+                node: `${nodeRoot}/${packageDirectory}`,
+                nodePackage: `@${scope}/${packageDirectory}`,
               }
             : {}),
           ...(targets.includes("python")
             ? {
-                python: `${options.pythonRoot ?? "packages/py"}/${pkg.packageOptions.directory}`,
-                pythonPackage: pkg.crateName,
-                pythonModule: pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory),
+                python: `${options.pythonRoot ?? "packages/py"}/${packageDirectory}`,
+                pythonPackage: `${scope}-${packageDirectory}`,
+                pythonModule: pythonModuleName(pythonModulePrefix, packageDirectory),
               }
             : {}),
         };
@@ -567,7 +668,10 @@ export class DBXToolsRustWorkspace {
           "bindings.python.external_packages": Object.fromEntries(
             dependencies.map((dependency) => [
               dependency.crateName.replaceAll("-", "_"),
-              `${pythonModuleName(pythonModulePrefix, dependency.packageOptions.directory)}.bindings`,
+              `${pythonModuleName(
+                pythonModulePrefix,
+                `${string.toSlug(dependency.packageOptions.directory)}-rs`,
+              )}.bindings`,
             ]),
           ),
         })
@@ -583,6 +687,7 @@ export class DBXToolsRustWorkspace {
       root,
       crates: this.packages.map((pkg) => `${root}/${pkg.packageOptions.directory}`),
       bindings: this.bindingMappings,
+      binaries: this.releaseBinaries,
     };
     if (dbxToolsProject) {
       dbxToolsProject.dbxToolsConfig.rust = this.workspaceMapping;
@@ -609,23 +714,25 @@ export class DBXToolsRustWorkspace {
     this.pythonPackages = bindings
       .filter((pkg) => (pkg.packageOptions.bindings ?? ["node", "python"]).includes("python"))
       .map((pkg) => {
-        const module = pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory);
+        const directory = `${string.toSlug(pkg.packageOptions.directory)}-rs`;
+        const module = pythonModuleName(pythonModulePrefix, directory);
+        const name = `${scope}-${directory}`;
         return {
-          directory: pkg.packageOptions.directory,
-          name: pkg.crateName,
+          directory,
+          name,
           module,
           description: `Python bindings for ${pkg.crateName}`,
           uniffi: true,
           internalDependencies: bindingDependencies(pkg, "python").map(
-            (dependency) => dependency.packageOptions.directory,
+            (dependency) => `${string.toSlug(dependency.packageOptions.directory)}-rs`,
           ),
           generatedSources: [
             `src/${module.replaceAll(".", "/")}/bindings.py`,
             `src/${module.replaceAll(".", "/")}/__init__.py`,
           ],
           trustedPublisher: {
-            environment: `pypi-${pkg.crateName}`,
-            artifacts: `platform-specific wheels for ${releaseTargets(options)
+            environment: `pypi-${name}`,
+            artifacts: `platform-specific wheels for ${nativeTargets
               .map((target) => `${target.os}-${target.cpu}`)
               .join(", ")}; all architectures publish to this one PyPI project`,
           },
@@ -639,7 +746,7 @@ export class DBXToolsRustWorkspace {
     for (const binding of bindings.filter((pkg) =>
       (pkg.packageOptions.bindings ?? ["node", "python"]).includes("node"),
     )) {
-      const directory = binding.packageOptions.directory;
+      const directory = `${string.toSlug(binding.packageOptions.directory)}-rs`;
       const memberPath = `${nodeRoot}/${directory}`;
       const found = existing.get(memberPath);
       const existingNode = found instanceof DBXToolsTypeScriptProject ? found : undefined;
@@ -656,10 +763,7 @@ export class DBXToolsRustWorkspace {
         `@${scope}/${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`,
       );
       node.dbxToolsConfig.uniffi = true;
-      if (!existingNode) {
-        node.package.addField("description", `Node bindings for ${binding.crateName}`);
-      }
-      const nativeTargets = releaseTargets(options);
+      node.package.addField("description", `Node bindings for ${binding.crateName}`);
       if (options.release ?? true) {
         node.package.addField(
           "optionalDependencies",
@@ -674,16 +778,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:*`,
+          (dependency) =>
+            `@${scope}/${string.toSlug(dependency.packageOptions.directory)}-rs@workspace:*`,
         ),
       );
-      if (binding.packageOptions.nodeDependencies?.length) {
-        node.addDeps(...binding.packageOptions.nodeDependencies);
-      }
       node.addDevDeps(`uniffi-bindgen-react-native@${UBRN_VERSION}`);
-      if (binding.packageOptions.nodeDevDependencies?.length) {
-        node.addDevDeps(...binding.packageOptions.nodeDevDependencies);
-      }
       nodePackages.push(node);
     }
     this.nodePackages = nodePackages;
@@ -728,20 +827,9 @@ export class DBXToolsRustWorkspace {
     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: [
-        "bun run rs:bindings",
-        ...this.bindingMappings.flatMap((binding) => [
-          ...(binding.node ? [`bun ${binding.node}/test/cli.ts`] : []),
-          ...(binding.python
-            ? [`uv run --project ${binding.python} ${binding.python}/test/cli.py`]
-            : []),
-        ]),
-      ].join(" && "),
-    });
+    project.removeTask("rs:bindings:demo");
     if (releaseEnabled) {
-      this.addReleaseWorkflow(project, options, releaseTargets(options));
+      this.addReleaseWorkflow(project, options, nativeTargets);
     }
   }
 
@@ -813,6 +901,7 @@ export class DBXToolsRustWorkspace {
         `--python "${binding.python}"`,
         `--node-package "${binding.nodePackage}"`,
         `--python-package "${binding.pythonPackage}"`,
+        `--python-module "${binding.pythonModule}"`,
         '--cargo-target "${{ matrix.cargo }}"',
         '--node-triple "${{ matrix.node }}"',
         '--python-tag "${{ matrix.python }}"',
@@ -829,15 +918,25 @@ export class DBXToolsRustWorkspace {
         ? `\${{ ${excludedOs.map((os) => `matrix.os != '${os}'`).join(" && ")} }}`
         : undefined;
     const binaryCommands = releaseBinaries.flatMap((pkg) => {
+      const windowsAsset = releaseBinaryAssetName(
+        pkg.binary,
+        "${{ matrix.node }}",
+        RustReleaseOs.WINDOWS,
+      );
+      const unixAsset = releaseBinaryAssetName(
+        pkg.binary,
+        "${{ matrix.node }}",
+        RustReleaseOs.LINUX,
+      );
       const commands = [
         `mkdir -p "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage"`,
         `SOURCE="target/\${{ matrix.cargo }}/release/${pkg.binary}\${{ matrix.os == 'win32' && '.exe' || '' }}"`,
         `DESTINATION="dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage/${pkg.binary}\${{ matrix.os == 'win32' && '.exe' || '' }}"`,
         'cp "$SOURCE" "$DESTINATION"',
         'if [ "${{ matrix.os }}" = "win32" ]; then',
-        `  7z a "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/${pkg.binary}-\${{ matrix.node }}.zip" "$DESTINATION"`,
+        `  7z a "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/${windowsAsset}" "$DESTINATION"`,
         "else",
-        `  tar -C "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage" -czf "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/${pkg.binary}-\${{ matrix.node }}.tar.gz" "${pkg.binary}"`,
+        `  tar -C "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage" -czf "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/${unixAsset}" "${pkg.binary}"`,
         "fi",
         `rm -rf "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage"`,
       ];
@@ -869,7 +968,7 @@ export class DBXToolsRustWorkspace {
                 name: `Upload ${binding.crate} Python wheel`,
                 uses: "actions/upload-artifact@v7",
                 with: {
-                  name: `${binding.crate}--\${{ matrix.python }}--python-wheel`,
+                  name: `${binding.pythonPackage}--\${{ matrix.python }}--python-wheel`,
                   path: `dist/release/${binding.crate}/\${{ matrix.node }}/python/*.whl`,
                   "retention-days": 7,
                 },
@@ -942,7 +1041,11 @@ export class DBXToolsRustWorkspace {
         {
           name: "Install Linux native dependencies",
           if: "${{ matrix.os == 'linux' }}",
-          run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
+          run: [
+            "sudo rm -f /etc/apt/sources.list.d/google-chrome.list",
+            "sudo apt-get update",
+            "sudo apt-get install --yes libdbus-1-dev pkg-config",
+          ].join("\n"),
         },
         {
           name: "Build Rust outputs",

package/src/release.ts

@@ -247,16 +247,16 @@ function addDocsJobs(
       { name: "Configure Pages", uses: "actions/configure-pages@v5" },
       { name: "Install dependencies", run: "bun install" },
       { name: "Generate docs from READMEs", run: "bun docs/scripts/sync-readmes.mjs" },
-      {
-        name: "Check generated titles",
-        run: "bun docs/scripts/check-generated-titles.mjs",
-      },
       { name: "Install docs dependencies", run: "bun install --cwd .docs-build/site" },
       bunCacheSaveStep(),
       {
         name: "Generate TypeScript API docs",
         run: "bun docs/scripts/generate-api-docs.mjs",
       },
+      {
+        name: "Check generated titles",
+        run: "bun docs/scripts/check-generated-titles.mjs",
+      },
       { name: "Build docs", run: "bun run --cwd .docs-build/site build" },
       {
         name: "Check generated links",

package/src/tags.ts

@@ -182,6 +182,7 @@ export const PACKAGE_TAG_MIXINS = {
   openapi: create(projectPredicate.hasTag("openapi"), (p) => {
     p.addDeps("openapi-fetch@catalog:");
     applyCompilerOptions(p, { target: "ES2022", lib: [...DOM_LIB], types: [] });
+    addPackageFiles(p, "openapi.json");
   }),
 } satisfies Record<string, ConstructsMixin>;
 

package/src/uniffi.ts

@@ -56,40 +56,3 @@ export const addExplicitInterfaceReexports = (
   if (exports.length === 0) return facade;
   return `${facade.trimEnd()}\n${exports.join("\n")}\n`;
 };
-
-const GENERATED_BINDINGS_HEADER = "GENERATED by UniFFI binding generation";
-
-function pythonAllNames(source: string, file: string): string[] {
-  const body = /^__all__\s*=\s*\[([\s\S]*?)\]/m.exec(source)?.[1];
-  if (body === undefined) {
-    throw new Error(`Python exports must define a literal __all__ list: ${file}`);
-  }
-  return [...body.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]!);
-}
-
-/** Generate one package root from the binding module's explicit exports. */
-export function mergePythonBindingExports(
-  initSource: string,
-  bindingsSource: string,
-  options: { readonly crate: string; readonly file: string },
-): string {
-  if (initSource.trim() && !initSource.includes(GENERATED_BINDINGS_HEADER)) {
-    throw new Error(`Cannot replace non-generated Python package exports: ${options.file}`);
-  }
-  const bindingNames = pythonAllNames(bindingsSource, options.file);
-  const publicNames = [...bindingNames].sort((left, right) =>
-    left < right ? -1 : left > right ? 1 : 0,
-  );
-  return [
-    "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
-    `# Regenerated from the ${options.crate} Rust exports.`,
-    "# Hand edits are overwritten on the next watch; this file is read-only.",
-    "",
-    "from .bindings import *",
-    "",
-    "__all__ = [",
-    ...publicNames.map((name) => `    ${JSON.stringify(name)},`),
-    "]",
-    "",
-  ].join("\n");
-}

package/tasks/bump.ts

@@ -55,8 +55,8 @@ import { exec, project } from "@dbx-tools/core";
 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 { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import {
   type Semver,
   compareSemver,

package/tasks/publish-uniffi-local.ts

@@ -157,6 +157,8 @@ function buildAndPublish(binding: RustBindingMapping, version: string): void {
     includeNode ? binding.nodePackage! : "",
     "--python-package",
     includePython ? binding.pythonPackage! : "",
+    "--python-module",
+    includePython ? binding.pythonModule! : "",
     "--cargo-target",
     rustHost(),
     "--node-triple",

package/tasks/rust.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
+import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
-import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { log } from "@dbx-tools/shared-core";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
@@ -40,7 +40,7 @@ function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
     const binding = recorded.get(rust);
     return binding ? [binding] : [{ crate: "", rust }];
   });
-  return { root: config.root, crates, bindings };
+  return { root: config.root, crates, bindings, binaries: config.binaries ?? [] };
 }
 
 /** Whether discovered crate membership or UniFFI marker membership changed. */
@@ -70,7 +70,9 @@ function ownerBinding(
 function generate(binding: RustBindingMapping): void {
   const targets = [
     ...(binding.node ? ["--node", binding.node] : []),
-    ...(binding.python ? ["--python", binding.python] : []),
+    ...(binding.python
+      ? ["--python", binding.python, "--python-module", binding.pythonModule ?? ""]
+      : []),
   ];
   const result = spawnSync(
     process.execPath,
@@ -92,8 +94,9 @@ export function affectedRustBindings(
   const affected = new Set(changed);
   const ordered = orderRustBindings(bindings);
   for (const binding of ordered) {
-    if (binding.dependencies?.some((dependency) => affected.has(dependency)))
+    if (binding.dependencies?.some((dependency) => affected.has(dependency))) {
       affected.add(binding.crate);
+    }
   }
   return ordered.filter((binding) => affected.has(binding.crate));
 }

package/tasks/uniffi-release.mjs

@@ -27,6 +27,7 @@ const parsed = parseArgs({
     "node-package": { type: "string" },
     "native-package": { type: "string" },
     "python-package": { type: "string" },
+    "python-module": { type: "string" },
     "cargo-target": { type: "string" },
     "node-triple": { type: "string" },
     "python-tag": { type: "string" },
@@ -231,11 +232,28 @@ const writable = (path) => {
   if (existsSync(path)) chmodSync(path, statSync(path).mode | 0o200);
 };
 
+const cargoMetadata = spawnSync("cargo", ["metadata", "--format-version", "1", "--no-deps"], {
+  cwd: root,
+  encoding: "utf8",
+});
+if (cargoMetadata.error) {
+  throw new Error(`cargo metadata failed: ${cargoMetadata.error.message}`, {
+    cause: cargoMetadata.error,
+  });
+}
+if (cargoMetadata.status !== 0) {
+  throw new Error(`cargo metadata exited with ${cargoMetadata.status}`);
+}
+const cargoTargetRoot = JSON.parse(cargoMetadata.stdout).target_directory;
+if (typeof cargoTargetRoot !== "string" || !cargoTargetRoot) {
+  throw new Error("cargo metadata returned no target_directory");
+}
+
 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}`);
+  return resolve(cargoTargetRoot, cargoTarget, "release", `${prefix}${name}.${extension}`);
 };
 
 const packageNode = ({
@@ -387,6 +405,7 @@ const packagePython = ({
   version,
   cargoTarget,
   os,
+  pythonModule,
 }) => {
   const pythonRoot = resolve(output, "python-root");
   cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
@@ -407,12 +426,12 @@ const packagePython = ({
   }
   writeFileSync(pyproject, metadata);
 
-  const packageName = crate.replace(/^dbx-tools-/, "").replaceAll("-", "_");
-  const packageDirectory = resolve(pythonRoot, "src", "dbx_tools", packageName);
+  const packageName = pythonModule.split(".").at(-1);
+  if (!packageName) throw new Error(`Invalid Python module ${pythonModule}`);
+  const packageDirectory = resolve(pythonRoot, "src", ...pythonModule.split("."));
   const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
   const generator = resolve(
-    root,
-    "target",
+    cargoTargetRoot,
     cargoTarget,
     "release",
     `${crate}-uniffi-bindgen${os === "win32" ? ".exe" : ""}`,
@@ -506,6 +525,7 @@ const build = () => {
       version,
       cargoTarget,
       os,
+      pythonModule: required("python-module"),
     });
   }
 };

package/tasks/uniffi.ts

@@ -21,7 +21,6 @@ import {
   addExplicitInterfaceReexports,
   addTypeScriptExtensionsToBindingImports,
   makeDefaultedInterfaceParametersOptional,
-  mergePythonBindingExports,
 } from "../src/uniffi.ts";
 
 const { values } = parseArgs({
@@ -30,6 +29,7 @@ const { values } = parseArgs({
     crate: { type: "string" },
     node: { type: "string" },
     python: { type: "string" },
+    "python-module": { type: "string" },
     "cargo-target": { type: "string" },
     "node-package-base": { type: "string" },
     ubrn: { type: "string" },
@@ -54,10 +54,6 @@ const dependencies =
 const extension =
   process.platform === "darwin" ? "dylib" : process.platform === "win32" ? "dll" : "so";
 const prefix = process.platform === "win32" ? "" : "lib";
-const targetDirectory = values["cargo-target"]
-  ? join(root, "target", values["cargo-target"], "release")
-  : join(root, "target", "release");
-const library = join(targetDirectory, `${prefix}${libraryName}.${extension}`);
 const normalizedOutput = (value: string): string =>
   value
     .replace(/[\p{Extended_Pictographic}\uFE0F]/gu, "")
@@ -75,6 +71,28 @@ const run = (command: string, args: string[]) => {
   if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
 };
 
+const cargoMetadata = spawnSync("cargo", ["metadata", "--format-version", "1", "--no-deps"], {
+  cwd: root,
+  encoding: "utf8",
+});
+if (cargoMetadata.error) {
+  throw new Error(`cargo metadata failed: ${cargoMetadata.error.message}`, {
+    cause: cargoMetadata.error,
+  });
+}
+if (cargoMetadata.status !== 0) {
+  throw new Error(`cargo metadata exited with ${cargoMetadata.status}`);
+}
+const cargoTargetRoot = (JSON.parse(cargoMetadata.stdout) as { target_directory?: unknown })
+  .target_directory;
+if (typeof cargoTargetRoot !== "string" || !cargoTargetRoot) {
+  throw new Error("cargo metadata returned no target_directory");
+}
+const targetDirectory = values["cargo-target"]
+  ? join(cargoTargetRoot, values["cargo-target"], "release")
+  : join(cargoTargetRoot, "release");
+const library = join(targetDirectory, `${prefix}${libraryName}.${extension}`);
+
 const replaceGenerated = (source: string, destination: string): void => {
   const deadline = Date.now() + 5_000;
   const signal = new Int32Array(new SharedArrayBuffer(4));
@@ -243,12 +261,10 @@ if (values.node) {
 }
 
 if (values.python) {
-  const pythonPackage = resolve(
-    root,
-    values.python,
-    "src/dbx_tools",
-    crate.replace(/^dbx-tools-/, "").replaceAll("-", "_"),
-  );
+  if (!values["python-module"]) {
+    throw new Error("Expected --python-module with --python");
+  }
+  const pythonPackage = resolve(root, values.python, "src", ...values["python-module"].split("."));
   const pythonOutput = mkdtempSync(join(tmpdir(), `${libraryName}-python-`));
   run(
     join(targetDirectory, `${crate}-uniffi-bindgen${process.platform === "win32" ? ".exe" : ""}`),
@@ -269,14 +285,7 @@ if (values.python) {
   stampGeneratedPython(pythonBindings);
   const pythonInit = join(pythonPackage, "__init__.py");
   makeWritable(pythonInit);
-  writeFileSync(
-    pythonInit,
-    mergePythonBindingExports(
-      existsSync(pythonInit) ? readFileSync(pythonInit, "utf8") : "",
-      readFileSync(pythonBindings, "utf8"),
-      { crate, file: pythonInit },
-    ),
-  );
+  writeFileSync(pythonInit, "");
   makeReadonly(pythonInit);
   const pythonLibrary = join(pythonPackage, basename(library));
   makeWritable(pythonLibrary);