@dbx-tools/projen 0.9.12 → 0.9.18

package/README.md

@@ -184,8 +184,10 @@ Foreign callback adapters must first be wrapped in an object created by their
 own native library (`createStorageHandle` for auth), because callback registries
 are library-local. Release wheels replace sibling Git requirements with matching
 native-wheel versions, and dependent publishers wait for their dependencies.
-Each crate builds its own `<crate>-uniffi-bindgen` executable so a workspace
-build has no colliding binary outputs. Packaging runs that prebuilt executable.
+Each crate builds its own `<crate>-uniffi-bindgen` executable so one target row
+has no colliding binary outputs. The executable requires the generated
+`uniffi-bindgen` feature, which enables `uniffi/cli` only in the UniFFI matrix.
+Packaging runs that prebuilt executable.
 Cargo manifests, target config, and UniFFI config are generated from structured
 Projen `TomlFile` objects. Local and release Python generation share one
 dependency-free helper for generator arguments, target-specific executable
@@ -231,13 +233,14 @@ branch that already contains released `main`, and merges `main` into a diverged
 branch when the merge is conflict-free. Missing branches and conflicted merges
 are left untouched.
 
-The Rust matrix has one row per target. Each row installs native dependencies,
-builds the Cargo workspace once, then packages 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.
+Rust release generation creates one uncached matrix with one row per target.
+Each row builds all discovered bindings and selected release binaries together
+with the union of their required features, then packages every native artifact
+from that one Cargo output. Set a source-only crate's or release-enabled
+binary's `releaseExcludeOs` package option to omit it from incompatible rows.
+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
@@ -249,18 +252,12 @@ 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.
 `rustVersion` remains the MSRV recorded in package manifests, while
 `releaseRustVersion` independently defaults release compilation to `stable`.
-Stable Windows rows verify and use the hosted runner's installed Rust toolchain
-and select `rust-lld` for the workspace build. Rust release rows restore and
-update dependency-only Cargo caches in the release branch's cache scope. The
-cache key excludes workspace version changes, and manual tag recovery restores
-without saving a tag-scoped copy. There is no separate cache workflow or
-sccache layer. After publishing the current raw Rust bundles and build manifests,
-the GitHub release job deletes those internal assets from published
-`vMAJOR.MINOR.PATCH` releases strictly lower than the current version while
-leaving versioned consumer binaries in place. Phase timings are written to each
-build log. Python generation executes the already-built
-`target/<triple>/release/<crate>-uniffi-bindgen` directly. Artifact packaging therefore
-does no Rust compilation after the main workspace build.
+Rows use the target runner's standard Rust toolchain without sccache, Cargo
+cache actions, source fingerprints, or reusable raw bundles. Phase timings are
+written to each build log. GitHub-hosted Python generation executes the
+already-built `target/<triple>/release/<crate>-uniffi-bindgen` directly. A local
+macOS build compiles one host generator and reuses it while packaging the
+Darwin, Linux, and Windows libraries.
 
 Artifacts identify their crate, target, and type. Rust jobs publish non-private
 Cargo crates with `cargo publish --no-verify` and upload requested binary assets
@@ -277,6 +274,16 @@ architecture. Omit both filters to regenerate the complete maintained matrix.
 `DBX_TOOLS_RELEASE_PLATFORMS` can select the generated matrix without repeating
 environment parsing in a consumer.
 
+`bun run release --build auto` is the default. It selects a local build when
+the chosen GitHub CLI account has maintain/admin access, the host is macOS, and
+Cargo, Zig, cargo-zigbuild, cargo-xwin, LLVM, uv, and zip are available.
+Otherwise it selects the GitHub matrix. `--build local` and `--build remote`
+force the choice. Local mode builds the exact merged release SHA and uploads
+the archives plus a checksum manifest to the draft GitHub Release before
+registry publication continues. A manager can rerun an interrupted upload with
+`bun run release:assets --version <version> --tag <tag> --upload` from the
+matching release source.
+
 Public UniFFI facades are marked with `dbxToolsConfig.uniffi = true` in Node
 manifests and `[tool.dbx_tools.config] uniffi = true` in Python manifests. The
 Node jobs consume same-run artifacts, publish native archives first with npm
@@ -478,14 +485,15 @@ bootstrap a folder that has no `.projenrc.ts` or toolchain yet.
 
 ## Run Tasks From The ROOT
 
-Every repo-wide task lives on the root, and the root's `compile` / `test`
-delegate with `bun run --filter '*'` rather than emitting a step per member - so
-a new package is covered without a re-synth. Work from the root:
+Every repo-wide task lives on the root. `compile` batches ordinary TypeScript
+packages in up to four `tsc --build` processes and runs custom compile tasks alongside them;
+`test` delegates with `bun run --filter '*'`. Both read the current workspace
+list, so a new package is covered without a re-synth. Work from the root:
 
 | Task                           | What it does                                         |
 | ------------------------------ | ---------------------------------------------------- |
 | `bun run build`                | synth + workspace compile and tests                  |
-| `bun run compile`              | `tsc --build` in each member, in parallel            |
+| `bun run compile`              | Batched `tsc --build` plus custom member compiles    |
 | `bun run test`                 | `eslint` once, then each member's tests              |
 | `bun run sync`                 | re-synth (`--watch` to keep synthing)                |
 | `bun run barrels`              | regenerate the read-only `index.ts` barrels          |

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.9.12";
+export const PACKAGE_VERSION = "0.9.18";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -57,7 +57,7 @@ export type { DBXToolsJavaScriptProject, DBXToolsReleaseMode, PullRequestTitlePo
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
 export { DBXToolsRustProject, RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
+export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, RustOpenApiOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustOpenApiMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
 export { PROJEN_VERSION } from "./src/projen-version.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
@@ -66,7 +66,7 @@ export { DBXToolsReleaseCatalog } from "./src/release-catalog.ts";
 export type { DBXToolsVersioningMode, ReleaseProjectLanguage, ReleaseArtifactKind, ReleaseEdgeKind, ReleasePropagation, ReleaseUnitRule, DBXToolsReleaseCatalogOptions, ReleaseDependencyInput, ReleaseProjectRegistration, ExternalReleaseProjectRegistration, ReleaseArtifactRegistration, ReleaseProjectNode, ReleaseArtifact, ReleaseDependencyEdge, ReleaseUnit, ReleaseUnitGraph } from "./src/release-catalog.ts";
 export { RELEASE_TAG, RELEASE_SHA, RELEASE_VERSION, RELEASE_SUMMARY_DIRECTORY, RELEASE_SUMMARY_PROVIDER_NAMES, RELEASE_SUMMARY_FILE } from "./src/release-dispatch.ts";
 export type { ReleaseSummaryProviderName } from "./src/release-dispatch.ts";
-export type { GithubRepositoryIdentity, GithubAuthenticatedAccount } from "./src/release-github.ts";
+export type { GithubRepositoryIdentity, GithubAuthenticatedAccount, GithubRepositoryPermissions } from "./src/release-github.ts";
 export type { ReleaseReason, PlannedReleaseUnit, PlannedPackage, PlannedArtifact, PlannedRustTarget, ReleasePlan } from "./src/release-plan.ts";
 export { ReleaseUnitWorkspacePlugin } from "./src/release-please.ts";
 export type { ReleaseUnitWorkspacePluginOptions } from "./src/release-please.ts";
@@ -76,6 +76,7 @@ export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
 export { makeDefaultedInterfaceParametersOptional, removeObsoleteInterfaceAliases, addTypeScriptExtensionsToBindingImports, addExplicitInterfaceReexports } from "./src/uniffi.ts";
 export type { TypeScriptBindingModule } from "./src/uniffi.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
-export type { IgnoreGroupOptions } from "./src/watch.ts";
+export type { IgnoreGroupOptions, WatchLoopOptions } from "./src/watch.ts";
+export type { WorkspaceMutationLockOptions } from "./src/workspace-lock.ts";
 export { VERSION_FILE, DEFAULT_VERSION } from "./src/workspace-version.ts";
 export type { Semver, VersionLevel } from "./src/workspace-version.ts";

package/package.json

@@ -2,7 +2,6 @@
   "name": "@dbx-tools/projen",
   "scripts": {
     "build": "projen build",
-    "bundle:rust-release": "projen bundle:rust-release",
     "clobber": "projen clobber",
     "compile": "projen compile",
     "default": "projen default",
@@ -30,9 +29,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "^0.9.12",
-    "@dbx-tools/path": "^0.9.12",
-    "@dbx-tools/shared-core": "^0.9.12",
+    "@dbx-tools/core": "^0.9.18",
+    "@dbx-tools/path": "^0.9.18",
+    "@dbx-tools/shared-core": "^0.9.18",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -53,7 +52,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.12",
+  "version": "0.9.18",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_release-platform.ts

@@ -22,6 +22,16 @@ export type ReleaseArch = (typeof RELEASE_ARCHES)[number];
 
 export type { VersionLevel } from "./workspace-version.ts";
 
+/** Stable archive name for one native release binary. */
+export function releaseBinaryAssetName(
+  binaryName: string,
+  nodeTarget: string,
+  operatingSystem: ReleaseOs,
+): string {
+  const extension = operatingSystem === "win32" ? "zip" : "tar.gz";
+  return `${binaryName}-${nodeTarget}.${extension}`;
+}
+
 function collectValue<T extends string>(value: T, previous: T[]): T[] {
   return [...previous, value];
 }

package/src/_rust-project.ts

@@ -2,13 +2,15 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
-import { stringUtils } from "@dbx-tools/shared-core";
+import { object, stringUtils } from "@dbx-tools/shared-core";
 import { License, Project, TextFile, TomlFile, javascript, type Task } from "projen";
 import { DBX_TOOLS_LICENSE, projectRepositoryUrl } from "./project-js.ts";
 import type { RustReleaseOs } from "./project-rs.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 
+export const UNIFFI_BINDGEN_FEATURE = "uniffi-bindgen";
+
 export interface CargoDependencyOptions {
   readonly version?: string;
   readonly workspace?: boolean;
@@ -50,6 +52,16 @@ export interface CargoExampleOptions {
   readonly requiredFeatures?: readonly string[];
 }
 
+/** Rust code-first OpenAPI producer consumed by the shared generator. */
+export interface RustOpenApiOptions {
+  /** Cargo binary that handles `--generate-spec` when the package has multiple binaries. */
+  readonly binary?: string;
+  /** Features enabled while running the OpenAPI export command. */
+  readonly features?: readonly string[];
+  /** Disable the crate's default features while running the export command. */
+  readonly noDefaultFeatures?: boolean;
+}
+
 /** Cargo package, target, binding, and release behavior shared by every Rust project. */
 export interface RustCrateOptions {
   readonly description?: string;
@@ -59,6 +71,8 @@ export interface RustCrateOptions {
   readonly release?: boolean;
   /** Omit this crate and any release binary artifact from these operating systems. */
   readonly releaseExcludeOs?: readonly RustReleaseOs[];
+  /** Cargo features used only by the macOS cross-platform release builder. */
+  readonly releaseLocalFeatures?: readonly string[];
   readonly dependencies?: Readonly<Record<string, CargoDependency>>;
   /** Cargo dependencies scoped by a target cfg expression. */
   readonly targetDependencies?: Readonly<Record<string, Readonly<Record<string, CargoDependency>>>>;
@@ -67,6 +81,8 @@ export interface RustCrateOptions {
   readonly defaultFeatures?: readonly string[];
   /** Explicit example targets, including optional Cargo feature gates. */
   readonly examples?: readonly CargoExampleOptions[];
+  /** Generate an OpenAPI client package from this crate's aide document. */
+  readonly openapi?: boolean | RustOpenApiOptions;
   /** Cargo and release executable name. Defaults to the generated package name. */
   readonly binaryName?: string;
   /** Additional Cargo binary targets owned by this crate. */
@@ -106,29 +122,31 @@ export interface DBXToolsRustProjectOptions extends DBXToolsProjectOptions, Rust
   readonly repository?: string;
 }
 
-function rustSources(directory: string): string[] {
-  if (!existsSync(directory)) return [];
-  const files: string[] = [];
+function* rustSources(directory: string): Generator<string> {
+  if (!existsSync(directory)) return;
   for (const entry of readdirSync(directory, { withFileTypes: true })) {
     const path = join(directory, entry.name);
-    if (entry.isDirectory()) files.push(...rustSources(path));
-    else if (entry.isFile() && entry.name.endsWith(".rs")) files.push(path);
+    if (entry.isDirectory()) yield* rustSources(path);
+    else if (entry.isFile() && entry.name.endsWith(".rs")) yield path;
   }
-  return files;
 }
 
 /** Whether a Rust crate embeds the UniFFI proc-macro scaffolding marker. */
 export function hasUniFFIBindings(directory: string): boolean {
-  return rustSources(join(directory, "src")).some((path) =>
-    /\buniffi\s*::\s*setup_scaffolding\s*!\s*\(/.test(readFileSync(path, "utf8")),
-  );
+  return object
+    .sequence(rustSources(join(directory, "src")))
+    .some((path) => /\buniffi\s*::\s*setup_scaffolding\s*!\s*\(/.test(readFileSync(path, "utf8")));
+}
+
+function hasRustSources(directory: string): boolean {
+  return object.sequence(rustSources(directory)).some(() => true);
 }
 
 export function discoverRustCrates(root: string): string[] {
   if (!existsSync(root)) return [];
   return readdirSync(root, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
-    .filter((entry) => rustSources(join(root, entry.name, "src")).length > 0)
+    .filter((entry) => hasRustSources(join(root, entry.name, "src")))
     .map((entry) => entry.name)
     .sort();
 }
@@ -205,11 +223,13 @@ function packageOptions(
     ...(options.private !== undefined ? { private: options.private } : {}),
     ...(options.release !== undefined ? { release: options.release } : {}),
     ...(options.releaseExcludeOs ? { releaseExcludeOs: options.releaseExcludeOs } : {}),
+    ...(options.releaseLocalFeatures ? { releaseLocalFeatures: options.releaseLocalFeatures } : {}),
     ...(options.dependencies ? { dependencies: options.dependencies } : {}),
     ...(options.targetDependencies ? { targetDependencies: options.targetDependencies } : {}),
     ...(options.devDependencies ? { devDependencies: options.devDependencies } : {}),
     ...(options.features ? { features: options.features } : {}),
     ...(options.defaultFeatures ? { defaultFeatures: options.defaultFeatures } : {}),
+    ...(options.openapi !== undefined ? { openapi: options.openapi } : {}),
     ...(options.binaryName ? { binaryName: options.binaryName } : {}),
     ...(options.binaries ? { binaries: options.binaries } : {}),
     ...(options.cli !== undefined ? { cli: options.cli } : {}),
@@ -291,7 +311,13 @@ export class RustProject extends Project implements DBXToolsProject {
         ? {
             bin: [
               ...(this.uniffi
-                ? [{ name: `${this.crateName}-uniffi-bindgen`, path: "uniffi-bindgen.rs" }]
+                ? [
+                    {
+                      name: `${this.crateName}-uniffi-bindgen`,
+                      path: "uniffi-bindgen.rs",
+                      "required-features": [UNIFFI_BINDGEN_FEATURE],
+                    },
+                  ]
                 : []),
               ...(binary ? [{ name: binaryName, path: "src/main.rs" }] : []),
               ...(options.binaries ?? []).map((target) => ({
@@ -304,11 +330,12 @@ export class RustProject extends Project implements DBXToolsProject {
             ],
           }
         : {}),
-      ...(options.features || options.defaultFeatures
+      ...(this.uniffi || options.features || options.defaultFeatures
         ? {
             features: {
               ...(options.defaultFeatures ? { default: [...options.defaultFeatures] } : {}),
               ...options.features,
+              ...(this.uniffi ? { [UNIFFI_BINDGEN_FEATURE]: ["uniffi/cli"] } : {}),
             },
           }
         : {}),