@dbx-tools/projen 0.6.168 → 0.6.174

package/src/release.ts

@@ -6,11 +6,16 @@
  */
 import { existsSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
+import { object } from "@dbx-tools/shared-core";
 import { Component, YamlFile } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission, type JobStep } from "projen/lib/github/workflows-model";
-import { object } from "@dbx-tools/shared-core";
 import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
+import {
+  orderRustBindings,
+  type RustBindingMapping,
+  type RustWorkspaceMapping,
+} from "./project-rs.ts";
 import { applyTasks, taskScript, type DBXToolsNodeProject } from "./project.ts";
 import {
   DOWNSTREAM_RELEASE_EVENT,
@@ -70,6 +75,7 @@ interface PublishWorkflow {
   readonly steps: readonly JobStep[];
   readonly workingDirectory?: string;
   readonly upstreamWorkflow?: string;
+  readonly rustArtifacts?: boolean;
 }
 
 /** Shared checkout and toolchain setup for every npm publish workflow. */
@@ -300,7 +306,7 @@ export class DBXToolsRelease extends Component {
   /** Author the common tag trigger, concurrency policy, permissions, and publish job. */
   private authorPublishWorkflow(
     project: DBXToolsNodeProject,
-    { name, tagPrefix, steps, workingDirectory, upstreamWorkflow }: PublishWorkflow,
+    { name, tagPrefix, steps, workingDirectory, upstreamWorkflow, rustArtifacts }: PublishWorkflow,
   ): void {
     const setupSteps = publishSetupSteps(project);
     const branchDispatch = upstreamWorkflow === undefined;
@@ -314,7 +320,7 @@ export class DBXToolsRelease extends Component {
     // the publish job below overrides it with the `id-token` it needs.
     workflow.file?.addOverride("permissions", {
       contents: "read",
-      ...(upstreamWorkflow ? { actions: "read" } : {}),
+      ...(upstreamWorkflow || rustArtifacts ? { actions: "read" } : {}),
     });
     if (upstreamWorkflow) {
       workflow.file?.addOverride("on.workflow_run", {
@@ -362,7 +368,7 @@ export class DBXToolsRelease extends Component {
       runsOn: ["ubuntu-latest"],
       // `id-token: write` lets npm mint the OIDC token for provenance attestation.
       permissions: {
-        ...(upstreamWorkflow ? { actions: JobPermission.READ } : {}),
+        ...(upstreamWorkflow || rustArtifacts ? { actions: JobPermission.READ } : {}),
         contents: JobPermission.READ,
         idToken: JobPermission.WRITE,
       },
@@ -483,14 +489,112 @@ export class DBXToolsRelease extends Component {
    * version on every package first makes the pushed tag the published version
    * (no bump math).
    */
+  private nodeBindingReleaseSteps(project: DBXToolsNodeProject): {
+    before: JobStep[];
+    after: JobStep[];
+  } {
+    const config = project.dbxToolsConfig.rust;
+    if (!object.isRecord(config) || !Array.isArray(config.bindings)) {
+      return { before: [], after: [] };
+    }
+    const bindings = orderRustBindings(config.bindings as RustWorkspaceMapping["bindings"]).filter(
+      (binding): binding is RustBindingMapping & { node: string; nodePackage: string } =>
+        Boolean(binding.node && binding.nodePackage),
+    );
+    if (bindings.length === 0) return { before: [], after: [] };
+
+    const before: JobStep[] = [
+      {
+        name: "Require Rust artifact handoff",
+        if: "${{ github.event_name == 'repository_dispatch' }}",
+        shell: "bash",
+        env: {
+          RUST_RUN_ID: "${{ github.event.client_payload.rust_run_id }}",
+          RUST_RUN_ATTEMPT: "${{ github.event.client_payload.rust_run_attempt }}",
+        },
+        run: ['test -n "$RUST_RUN_ID"', 'test -n "$RUST_RUN_ATTEMPT"'].join("\n"),
+      },
+      {
+        name: "Download native npm packages",
+        if: "${{ github.event_name == 'repository_dispatch' }}",
+        uses: "actions/download-artifact@v8",
+        with: {
+          pattern: "*-npm",
+          path: "dist/uniffi/native",
+          "merge-multiple": true,
+          "run-id": "${{ github.event.client_payload.rust_run_id }}",
+          "github-token": "${{ github.token }}",
+        },
+      },
+      {
+        name: "Publish native npm packages",
+        if: "${{ github.event_name == 'repository_dispatch' }}",
+        env: {
+          NPM_CONFIG_PROVENANCE: "true",
+          NPM_CONFIG_TOKEN: "${{ secrets.NPM_TOKEN }}",
+          NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}",
+        },
+        run: [
+          "test \"$(find dist/uniffi/native -name '*.tgz' | wc -l | tr -d ' ')\" -gt 0",
+          'for package in dist/uniffi/native/*.tgz; do npm publish "$package" --access public; done',
+        ].join("\n"),
+      },
+      {
+        name: "Refresh workspace after native publication",
+        if: "${{ github.event_name == 'repository_dispatch' }}",
+        run: "bun install --force",
+      },
+    ];
+
+    const facadeCommands = [
+      'if [ "$GITHUB_EVENT_NAME" = "workflow_dispatch" ]; then',
+      '  VERSION="0.0.0-dry.${GITHUB_RUN_NUMBER}"',
+      "  DRY_RUN=--dry-run",
+      "else",
+      '  VERSION="$RELEASE_VERSION"',
+      "  DRY_RUN=",
+      "fi",
+      ...bindings.flatMap((binding) => {
+        const output = `dist/uniffi/facades/${binding.crate}`;
+        return [
+          `NATIVE_ARG=""`,
+          'if [ "$GITHUB_EVENT_NAME" = "repository_dispatch" ]; then',
+          `  NATIVE_PACKAGE="$(find dist/uniffi/native -name '${binding.crate}-linux-x64-gnu-*.tgz' -print -quit)"`,
+          '  test -n "$NATIVE_PACKAGE"',
+          '  NATIVE_ARG="--native-package $NATIVE_PACKAGE"',
+          "fi",
+          `node .projen/uniffi-release.mjs facade --node "${binding.node}" --node-package "${binding.nodePackage}" --node-triple "linux-x64-gnu" --version "$VERSION" --output "${output}" $NATIVE_ARG`,
+          `for package in ${output}/npm-facade/*.tgz; do npm publish "$package" --access public $DRY_RUN; done`,
+        ];
+      }),
+    ];
+    return {
+      before,
+      after: [
+        {
+          name: "Build and publish UniFFI npm facades",
+          env: {
+            NPM_CONFIG_PROVENANCE: "true",
+            NPM_CONFIG_TOKEN: "${{ secrets.NPM_TOKEN }}",
+            NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}",
+          },
+          run: facadeCommands.join("\n"),
+        },
+      ],
+    };
+  }
+
   private authorReleaseWorkflow(project: DBXToolsNodeProject): void {
     if (!this.workflowName) return;
     if (this.workflowName !== "release") project.tryRemoveFile(".github/workflows/release.yml");
+    const bindingSteps = this.nodeBindingReleaseSteps(project);
     this.authorPublishWorkflow(project, {
       name: this.workflowName,
       tagPrefix: this.tagPrefix,
       upstreamWorkflow: this.upstreamWorkflow,
+      rustArtifacts: bindingSteps.before.length > 0,
       steps: [
+        ...bindingSteps.before,
         // The pushed tag is the version: `<prefix>1.2.3` -> `1.2.3`. Stamp it on
         // every workspace package (manifests are projen-readonly, so unlock
         // first), rewriting `workspace:*` sibling deps to `^<version>` so the
@@ -512,6 +616,7 @@ export class DBXToolsRelease extends Component {
             NPM_CONFIG_PROVENANCE: "true",
           },
         },
+        ...bindingSteps.after,
       ],
     });
   }

package/src/uniffi.ts

@@ -56,3 +56,40 @@ 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

@@ -135,8 +135,8 @@ function assertReleaseTagsPointToHead(tags: readonly string[]): void {
  * (not-yet-published) version into the COMMITTED manifest breaks the release
  * workflow's initial `bun install`, which checks out that commit before anything
  * is published. Sibling versions are resolved transiently at publish time instead:
- * `projen-release` runs `tasks/publish.ts --stamp-only` (set versions + refresh
- * lockfile), then `bun publish` in `projen/` strips `workspace:*` to those versions.
+ * The bump stamps every workspace member before committing so independently
+ * synthesized members and the Bun lock resolve the same release version.
  */
 function writeManifestVersion(pkgPath: string, version: string): void {
   const { mode } = statSync(pkgPath);
@@ -306,6 +306,16 @@ program
           },
         });
       }
+      if (opts.version) {
+        const publishScript = fileURLToPath(new URL("./publish.ts", import.meta.url));
+        exec.spawnSync("bun", [publishScript, version, "--stamp-only"], {
+          cwd: process.cwd(),
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "ignore",
+          check: true,
+        });
+      }
 
       if (opts.commit) {
         // Stage the whole tree so the release commit captures the version bump

package/tasks/publish-uniffi-local.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env -S bun
+import { spawnSync } from "node:child_process";
 import { chmodSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { arch, platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
-import { spawnSync } from "node:child_process";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import type { RustBindingMapping, RustWorkspaceMapping } from "../src/project-rs.ts";
 
@@ -155,8 +155,6 @@ function buildAndPublish(binding: RustBindingMapping, version: string): void {
     includePython ? binding.python! : "",
     "--node-package",
     includeNode ? binding.nodePackage! : "",
-    "--node-generator",
-    "projen/tasks/uniffi.ts",
     "--python-package",
     includePython ? binding.pythonPackage! : "",
     "--cargo-target",
@@ -184,8 +182,9 @@ function buildAndPublish(binding: RustBindingMapping, version: string): void {
       ...artifacts(join(output, "npm"), ".tgz"),
       ...artifacts(join(output, "npm-facade"), ".tgz"),
     ];
-    for (const packageFile of packages)
+    for (const packageFile of packages) {
       run("npm", ["publish", packageFile, "--registry", registry!]);
+    }
   }
   if (includePython) {
     const wheels = artifacts(join(output, "python"), ".whl");

package/tasks/publish.ts

@@ -2,7 +2,7 @@
 /**
  * `bun tasks/publish.ts <version> [--registry <url>] [--exclude <dir>] [--dry-run]`
  * - ensure every workspace member and the Bun lock carry the release version,
- * then publish each non-private one with `bun publish`.
+ * then publish each package owned by the standard Node release with `bun publish`.
  *
  * Bun has no `pnpm -r publish`, so this loop is the recursive-publish stand-in.
  * It leans on native bun for everything bun already does:
@@ -41,8 +41,7 @@
  * but uploads nothing, so the `release` workflow is testable end-to-end via a
  * `workflow_dispatch` run without anything reaching npm. `--registry` targets a
  * non-default registry (a local verdaccio); `--exclude <dir>` (repeatable,
- * repo-relative) skips a member that releases on its OWN tag namespace (e.g.
- * `projen`, published by `projen-release`, not the main `release`).
+ * repo-relative) skips a member owned by another publication flow.
  *
  * `--no-restore` keeps the edits on disk instead of undoing them at exit. Only
  * needed when a LATER process must still see them - `--stamp-only` implies it,
@@ -140,7 +139,8 @@ function lockfileMatchesVersion(
 
 /** Spawn `command` in `cwd` with `PATH` overridden, failing the task on non-zero. */
 function run(cwd: string, command: string, args: string[], path: string): void {
-  exec.spawnSync(command, args, {
+  const executable = command === "bun" && process.versions.bun ? process.execPath : command;
+  exec.spawnSync(executable, args, {
     cwd,
     stdout: "inherit",
     stderr: "inherit",
@@ -152,7 +152,8 @@ function run(cwd: string, command: string, args: string[], path: string): void {
 
 /** Asynchronous counterpart used for bounded parallel stamping and publishing. */
 async function runAsync(cwd: string, command: string, args: string[], path: string): Promise<void> {
-  await exec.spawn(command, args, {
+  const executable = command === "bun" && process.versions.bun ? process.execPath : command;
+  await exec.spawn(executable, args, {
     cwd,
     stdout: "inherit",
     stderr: "inherit",
@@ -274,9 +275,8 @@ if (!Number.isInteger(parsedConcurrency) || parsedConcurrency < 1) {
 }
 const concurrency = parsedConcurrency;
 // `--stamp-only`: set versions + refresh the lockfile, then STOP (no publish).
-// The standalone `projen-release` uses this to version-stamp the workspace so its
-// own `bun publish` (run separately, in `projen/`) resolves `workspace:*` siblings
-// to the release version; publishing every member here would double-publish them.
+// A separate package command can use this when its own publish process needs
+// workspace sibling versions resolved before it starts.
 const stampOnly = rest.includes("--stamp-only");
 // Undo the manifest edits at exit unless a later process still needs them. Implied
 // off by `--stamp-only`, whose stamps exist precisely for a subsequent `bun publish`.
@@ -338,17 +338,17 @@ for (const dir of members) {
   const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as {
     name?: string;
     private?: boolean;
+    dbxToolsConfig?: { uniffi?: boolean };
     scripts?: Record<string, string>;
   };
   if (pkg.private) {
     logger.info(`skip private ${pkg.name ?? dirname(dir)}`);
     continue;
   }
-  // bun won't fold publishConfig into the packed manifest, so do it ourselves -
-  // otherwise the tarball's `bin`/`main`/`exports` stay pointed at `.ts` source.
-  const manifestPath = join(dir, "package.json");
-  unlockManifest(manifestPath);
-  applyPublishConfig(manifestPath);
+  if (pkg.dbxToolsConfig?.uniffi === true) {
+    logger.info(`skip UniFFI ${pkg.name ?? dirname(dir)}`);
+    continue;
+  }
   publishable.push({
     dir,
     name: pkg.name ?? dirname(dir),
@@ -362,6 +362,15 @@ if (compiled.length > 0) {
   run(root, "bun", ["run", ...compiled.flatMap((pkg) => ["--filter", pkg.name]), "compile"], path);
 }
 
+// Compile against workspace source exports first. Switching manifests to their
+// publishConfig entries before compilation makes consumers resolve sibling
+// `lib/*.d.ts` files that have not been emitted yet in a clean checkout.
+for (const { dir } of publishable) {
+  const manifestPath = join(dir, "package.json");
+  unlockManifest(manifestPath);
+  applyPublishConfig(manifestPath);
+}
+
 logger.info(
   `${dryRun ? "dry-run packing" : "publishing"} ${publishable.length} packages with concurrency ${concurrency}`,
 );

package/tasks/uniffi-release.mjs

@@ -25,8 +25,7 @@ const parsed = parseArgs({
     node: { type: "string" },
     python: { type: "string" },
     "node-package": { type: "string" },
-    "node-generator": { type: "string" },
-    ubrn: { type: "string" },
+    "native-package": { type: "string" },
     "python-package": { type: "string" },
     "cargo-target": { type: "string" },
     "node-triple": { type: "string" },
@@ -88,10 +87,42 @@ const localWorkspacePackages = () => {
   );
 };
 
-const testNodeFacade = ({ facadePackage, manifest, nativePackage, nodePackage }) => {
+/**
+ * Read one bundled facade's static imports so local workspace dependency stubs
+ * expose every requested ESM name. Callable proxy values support module helpers
+ * and base classes that execute while the facade is imported.
+ */
+const importedNames = (source, packageName) => {
+  const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(?:^|\\n)import\\s+([^;]+?)\\s+from\\s+["']${escaped}["'];`, "g");
+  const names = new Set();
+  let hasDefault = false;
+  for (const match of source.matchAll(pattern)) {
+    const clause = match[1].trim();
+    const named = /\{([\s\S]*?)\}/.exec(clause)?.[1];
+    if (named) {
+      for (const specifier of named.split(",")) {
+        const name = specifier.trim().split(/\s+as\s+/)[0];
+        if (name) names.add(name);
+      }
+    }
+    const beforeNamed = clause.split(/[,{\s]/, 1)[0];
+    if (beforeNamed && beforeNamed !== "*" && !clause.startsWith("{")) hasDefault = true;
+  }
+  return { names: [...names].sort(), hasDefault };
+};
+
+const testNodeFacade = ({
+  facadeDirectory,
+  facadePackage,
+  manifest,
+  nativePackage,
+  nodePackage,
+}) => {
   const installDirectory = mkdtempSync(join(tmpdir(), "uniffi-facade-install-"));
   try {
     const workspacePackages = localWorkspacePackages();
+    const facadeSource = readFileSync(join(facadeDirectory, "lib", "index.js"), "utf8");
     const bindings =
       JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig?.rust?.bindings ??
       [];
@@ -101,7 +132,10 @@ const testNodeFacade = ({ facadePackage, manifest, nativePackage, nodePackage })
       const binding = bindings.find((binding) => binding.nodePackage === name);
       if (binding) {
         const output = resolve(root, "dist/release", binding.crate, required("node-triple"));
-        return [singlePackage(join(output, "npm-facade")), singlePackage(join(output, "npm"))];
+        if (existsSync(join(output, "npm-facade")) && existsSync(join(output, "npm"))) {
+          return [singlePackage(join(output, "npm-facade")), singlePackage(join(output, "npm"))];
+        }
+        return [];
       }
       const directory = join(installDirectory, "local-dependencies", String(index));
       mkdirSync(directory, { recursive: true });
@@ -114,7 +148,16 @@ const testNodeFacade = ({ facadePackage, manifest, nativePackage, nodePackage })
           exports: "./index.js",
         })}\n`,
       );
-      writeFileSync(join(directory, "index.js"), "export {};\n");
+      const imports = importedNames(facadeSource, name);
+      writeFileSync(
+        join(directory, "index.js"),
+        [
+          "const stub = new Proxy(function () {}, { get: () => stub, apply: () => stub });",
+          ...imports.names.map((name) => `export const ${name} = stub;`),
+          ...(imports.hasDefault ? ["export default stub;"] : []),
+          "",
+        ].join("\n"),
+      );
       return [directory];
     });
     writeFileSync(
@@ -144,6 +187,16 @@ const testNodeFacade = ({ facadePackage, manifest, nativePackage, nodePackage })
 const replaceVersion = (source, version) =>
   source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
 
+/** Resolve workspace and generated catalog protocols for a publishable facade. */
+const facadeDependency = (name, dependency, version, catalog) => {
+  if (typeof dependency !== "string") return dependency;
+  if (dependency.startsWith("workspace:")) return version;
+  if (!dependency.startsWith("catalog:")) return dependency;
+  const resolved = catalog[name];
+  if (!resolved) throw new Error(`Missing root catalog entry for ${name}`);
+  return resolved;
+};
+
 const writable = (path) => {
   if (existsSync(path)) chmodSync(path, statSync(path).mode | 0o200);
 };
@@ -156,7 +209,6 @@ const libraryPath = (crate, cargoTarget, os) => {
 };
 
 const packageNode = ({
-  crate,
   library,
   output,
   nodeDirectory,
@@ -166,9 +218,11 @@ const packageNode = ({
   cpu,
   version,
   facade,
-  nodeGenerator,
 }) => {
   const libraryFile = basename(library);
+  const sourceManifest = JSON.parse(
+    readFileSync(resolve(root, nodeDirectory, "package.json"), "utf8"),
+  );
   const nativePackage = resolve(output, "native-node");
   mkdirSync(nativePackage, { recursive: true });
   cpSync(library, join(nativePackage, libraryFile));
@@ -179,6 +233,7 @@ const packageNode = ({
         name: `${nodePackage}-${nodeTriple}`,
         version,
         description: `Native ${nodeTriple} library for ${nodePackage}`,
+        repository: sourceManifest.repository,
         license: "Apache-2.0",
         os: [os],
         cpu: [cpu],
@@ -193,12 +248,40 @@ const packageNode = ({
   run("npm", ["pack", "--pack-destination", resolve(output, "npm")], nativePackage);
 
   if (!facade) return;
+  packageNodeFacade({
+    output,
+    nodeDirectory,
+    nodePackage,
+    version,
+    nativePackage: singlePackage(resolve(output, "npm")),
+  });
+};
+
+const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, nativePackage }) => {
   const facadeDirectory = resolve(output, "facade-node");
+  rmSync(facadeDirectory, { recursive: true, force: true });
+  rmSync(resolve(output, "npm-facade"), { recursive: true, force: true });
+  mkdirSync(output, { recursive: true });
   cpSync(resolve(root, nodeDirectory), facadeDirectory, { recursive: true });
-  rmSync(join(facadeDirectory, "src", libraryFile), { force: true });
+  const barrel = join(facadeDirectory, "index.ts");
+  writable(barrel);
+  writeFileSync(
+    barrel,
+    readFileSync(barrel, "utf8").replace(
+      /^export const PACKAGE_VERSION = .*;$/m,
+      `export const PACKAGE_VERSION = ${JSON.stringify(version)};`,
+    ),
+  );
+  for (const file of readdirSync(join(facadeDirectory, "src"))) {
+    if (/\.(dll|dylib|so)$/.test(file)) {
+      rmSync(join(facadeDirectory, "src", file), { force: true });
+    }
+  }
   const manifestPath = join(facadeDirectory, "package.json");
   writable(manifestPath);
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const workspaceManifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const catalog = workspaceManifest.catalog ?? {};
   manifest.version = version;
   manifest.private = false;
   manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
@@ -208,28 +291,12 @@ const packageNode = ({
   manifest.dependencies = Object.fromEntries(
     Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
       name,
-      typeof dependency === "string" && dependency.startsWith("workspace:") ? version : dependency,
+      facadeDependency(name, dependency, version, catalog),
     ]),
   );
   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}-`,
-    ...(parsed.values.ubrn ? ["--ubrn", parsed.values.ubrn, "--skip-barrels"] : []),
-    "--skip-build",
-  ]);
   // Node loads the facade from node_modules, so every TypeScript entry point
-  // must be emitted and advertised as JavaScript. Bun is always available in
-  // the facade row, including when the UBRN cache skips the workspace install.
+  // must be emitted and advertised as JavaScript.
   rmSync(join(facadeDirectory, "lib"), { recursive: true, force: true });
   run(
     "bun",
@@ -259,12 +326,15 @@ const packageNode = ({
   const facadeOutput = resolve(output, "npm-facade");
   mkdirSync(facadeOutput, { recursive: true });
   run("npm", ["pack", "--pack-destination", facadeOutput], facadeDirectory);
-  testNodeFacade({
-    facadePackage: singlePackage(facadeOutput),
-    manifest,
-    nativePackage: singlePackage(resolve(output, "npm")),
-    nodePackage,
-  });
+  if (nativePackage) {
+    testNodeFacade({
+      facadeDirectory,
+      facadePackage: singlePackage(facadeOutput),
+      manifest,
+      nativePackage,
+      nodePackage,
+    });
+  }
 };
 
 const packagePython = ({
@@ -372,7 +442,6 @@ const build = () => {
   const nodePackage = parsed.values["node-package"];
   if (nodeDirectory && nodePackage) {
     packageNode({
-      crate,
       library,
       output,
       nodeDirectory,
@@ -382,7 +451,6 @@ const build = () => {
       cpu,
       version,
       facade: parsed.values.facade === "true",
-      nodeGenerator: required("node-generator"),
     });
   }
 
@@ -401,5 +469,18 @@ const build = () => {
   }
 };
 
-if (parsed.positionals[0] !== "build") throw new Error("Expected build command");
-build();
+if (parsed.positionals[0] === "build") {
+  build();
+} else if (parsed.positionals[0] === "facade") {
+  packageNodeFacade({
+    output: resolve(root, required("output")),
+    nodeDirectory: required("node"),
+    nodePackage: required("node-package"),
+    version: required("version"),
+    nativePackage: parsed.values["native-package"]
+      ? resolve(root, parsed.values["native-package"])
+      : undefined,
+  });
+} else {
+  throw new Error("Expected build or facade command");
+}

package/tasks/uniffi.ts

@@ -21,6 +21,7 @@ import {
   addExplicitInterfaceReexports,
   addTypeScriptExtensionsToBindingImports,
   makeDefaultedInterfaceParametersOptional,
+  mergePythonBindingExports,
 } from "../src/uniffi.ts";
 
 const { values } = parseArgs({
@@ -176,6 +177,14 @@ if (values.node) {
   );
   const nodeBindings = join(nodeSource, "bindings.ts");
   const generatedFiles = [join(nodeSource, "_bindings.ts"), join(nodeSource, "_bindings-ffi.ts")];
+  const legacyExports = resolve(root, values.node, "exports.ts");
+  if (
+    existsSync(legacyExports) &&
+    readFileSync(legacyExports, "utf8").trim() === 'export * from "./src/bindings.ts";'
+  ) {
+    makeWritable(legacyExports);
+    rmSync(legacyExports, { force: true });
+  }
   replaceGenerated(join(nodeOutput, "index.ts"), nodeBindings);
   replaceGenerated(join(nodeOutput, libraryName + ".ts"), generatedFiles[0]);
   replaceGenerated(join(nodeOutput, libraryName + "-ffi.ts"), generatedFiles[1]);
@@ -259,9 +268,16 @@ if (values.python) {
   replaceGenerated(generated, pythonBindings);
   stampGeneratedPython(pythonBindings);
   const pythonInit = join(pythonPackage, "__init__.py");
-  if (!existsSync(pythonInit)) {
-    writeFileSync(pythonInit, "");
-  }
+  makeWritable(pythonInit);
+  writeFileSync(
+    pythonInit,
+    mergePythonBindingExports(
+      existsSync(pythonInit) ? readFileSync(pythonInit, "utf8") : "",
+      readFileSync(pythonBindings, "utf8"),
+      { crate, file: pythonInit },
+    ),
+  );
+  makeReadonly(pythonInit);
   const pythonLibrary = join(pythonPackage, basename(library));
   makeWritable(pythonLibrary);
   cpSync(library, pythonLibrary);