@dbx-tools/projen 0.6.185 → 0.6.188

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
@@ -153,10 +154,17 @@ skips matching files and fails when an existing filename has different content.
 
 The Rust matrix has one row per target. Each row installs native dependencies,
 restores Cargo and sccache once, builds the Cargo workspace once, then packages
-every discovered output from that shared build. Set a source-only crate's
-`releaseExcludeOs` package option to omit it from incompatible rows through
-Cargo `--exclude`; crates that produce UniFFI or release-binary artifacts cannot
-use this option because every configured target must produce their artifacts.
+every discovered output from that shared build. Set a source-only crate's or
+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.184";
+export const PACKAGE_VERSION = "0.6.187";
 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.185",
-    "@dbx-tools/path": "0.6.185",
-    "@dbx-tools/shared-core": "0.6.185",
+    "@dbx-tools/core": "0.6.188",
+    "@dbx-tools/path": "0.6.188",
+    "@dbx-tools/shared-core": "0.6.188",
     "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.185",
+  "version": "0.6.188",
   "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;
@@ -46,7 +53,7 @@ export interface RustPackageOptions {
   readonly private?: boolean;
   /** Build this crate's binary for each target and attach it to the GitHub release. */
   readonly release?: boolean;
-  /** Omit this source-only crate from release workspace builds on these operating systems. */
+  /** Omit this crate and any release binary artifact from these operating systems. */
   readonly releaseExcludeOs?: readonly RustReleaseOs[];
   readonly dependencies?: Readonly<Record<string, CargoDependency>>;
   readonly devDependencies?: Readonly<Record<string, CargoDependency>>;
@@ -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 {
@@ -230,6 +239,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 +283,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 +515,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 +534,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,15 +544,65 @@ 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) =>
       rustPackageDependencies(this.packages, pkg, project.outdir, options.workspaceDependencies);
     for (const pkg of this.packages) {
       const excludedOs = new Set(pkg.packageOptions.releaseExcludeOs ?? []);
-      if (excludedOs.size && (pkg.uniffi || pkg.packageOptions.release)) {
+      if (excludedOs.size && pkg.uniffi) {
         throw new Error(
-          `${pkg.crateName} cannot set releaseExcludeOs because it produces target-specific release artifacts`,
+          `${pkg.crateName} cannot set releaseExcludeOs because UniFFI requires every configured target`,
         );
       }
       for (const dependency of packageDependencies(pkg)) {
@@ -531,7 +624,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 +634,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 +660,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 +679,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 +706,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 +738,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 +755,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 +770,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 +819,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);
     }
   }
 
@@ -764,6 +844,7 @@ export class DBXToolsRustWorkspace {
       .map((pkg) => ({
         crate: pkg.crateName,
         binary: pkg.packageOptions.binaryName ?? pkg.crateName,
+        excludedOs: pkg.packageOptions.releaseExcludeOs ?? [],
       }));
     const publicCrates = orderRustBindings(
       this.packages
@@ -812,6 +893,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 }}"',
@@ -823,18 +905,40 @@ export class DBXToolsRustWorkspace {
         "--skip-build",
       ].join(" \\\n  "),
     );
-    const binaryCommands = releaseBinaries.flatMap((pkg) => [
-      `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"`,
-      "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}"`,
-      "fi",
-      `rm -rf "dist/release/${pkg.crate}/\${{ matrix.node }}/binary/stage"`,
-    ]);
+    const releaseBinaryCondition = (excludedOs: readonly RustReleaseOs[]) =>
+      excludedOs.length
+        ? `\${{ ${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/${windowsAsset}" "$DESTINATION"`,
+        "else",
+        `  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"`,
+      ];
+      const excludedCondition = pkg.excludedOs
+        .map((os) => `[ "\${{ matrix.os }}" != "${os}" ]`)
+        .join(" && ");
+      return excludedCondition
+        ? [`if ${excludedCondition}; then`, ...commands.map((command) => `  ${command}`), "fi"]
+        : commands;
+    });
     const artifactSteps: JobStep[] = [
       ...bindings.flatMap((binding) => [
         ...(binding.node
@@ -856,7 +960,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,
                 },
@@ -867,6 +971,9 @@ export class DBXToolsRustWorkspace {
       ...releaseBinaries.map((pkg) => ({
         name: `Upload ${pkg.crate} release binary`,
         uses: "actions/upload-artifact@v7",
+        ...(releaseBinaryCondition(pkg.excludedOs)
+          ? { if: releaseBinaryCondition(pkg.excludedOs) }
+          : {}),
         with: {
           name: `${pkg.crate}-\${{ matrix.node }}-binary`,
           path: `dist/release/${pkg.crate}/\${{ matrix.node }}/binary/*`,
@@ -926,7 +1033,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,
@@ -330,7 +330,7 @@ program
             "-m",
             "🌸 Shipped with Kanna — https://kanna.sh",
             "-m",
-            "Co-Authored-By: Kanna <noreply@kanna.sh>\nKanna-Agent: codex/gpt",
+            "Co-Authored-By: Kanna <noreply@kanna.sh>\nKanna-Agent: codex/databricks-gpt-5-6-sol",
           ]);
         } else {
           logger.info("nothing to commit");

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);