@dbx-tools/projen 0.9.5 → 0.9.7

package/README.md

@@ -1,6 +1,6 @@
 # @dbx-tools/projen
 
-Projen engine for dbx-tools pnpm workspaces.
+Projen engine for Bun-first dbx-tools workspaces.
 
 Import this package from `.projenrc.ts` when a repository should discover
 packages from the filesystem and generate manifests, tsconfigs,
@@ -11,9 +11,10 @@ Key features:
 - Filesystem package discovery: every `src`-bearing folder under configured
   workspace roots becomes a TypeScript package.
 - Tag-driven runtime defaults for shared libraries, Node packages, CLIs,
-  servers, OpenAPI clients, and React/Vite UI packages.
-- Generated package manifests, tsconfigs, package-root barrels, Vite configs,
-  pnpm workspace/catalog files, and VS Code settings.
+  servers, OpenAPI clients, and React/browser UI packages.
+- Generated package manifests, tsconfigs, package-root barrels, Bun app configs,
+  VS Code settings, and a committed `pnpm-workspace.yaml` retained for
+  Databricks Apps deployment.
 - Extensible mixin system so repositories can add deps, tasks, or generated
   files based on package predicates.
 - OpenAPI client generation from tsoa controllers and zod schema generation from
@@ -23,15 +24,15 @@ Key features:
 ## Define A Workspace Root
 
 ```ts
-import { project as projenProject } from "@dbx-tools/projen";
+import { project } from "@dbx-tools/projen";
 
-const project = new projenProject.DBXToolsNodeProject({
+const rootProject = new project.DBXToolsNodeProject({
   name: "my-apps",
   scope: "my-apps",
   packageRoots: ["packages", "examples"],
 });
 
-project.synth();
+rootProject.synth();
 ```
 
 Every `src`-bearing folder under the configured roots becomes a
@@ -130,8 +131,8 @@ derives the crate name and repository from the parent project. A crate containin
 `uniffi::setup_scaffolding!()`
 automatically wires matching public Node and Python binding packages using the
 `<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
+Python distributions are named `<scope>-<name>-rs` and export generated values
+from `<scope>.<name>_rs`. 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
@@ -141,9 +142,38 @@ 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 leaves
-`__init__.py` empty. Node generation fails when direct binding names conflict.
+`__init__.py` as its generated package-root export. Node generation fails when
+direct binding names conflict.
 Do not create a `nodeExports` binding subpath or a handwritten type facade.
 
+Each discovered member is a native Projen `Project`, exposed as
+`DBXToolsRustProject`. The same class also owns standalone Cargo projects with
+the flat object-style options used by the Node and Python project classes:
+
+```ts
+import { project } from "@dbx-tools/projen";
+
+new project.DBXToolsRustProject({
+  name: "my-apps-core",
+  outdir: "native/core",
+  version: "0.1.0",
+  description: "Shared native runtime",
+  repository: "https://github.com/example/my-apps",
+});
+```
+
+The project emits concrete standalone Cargo metadata plus `compile`, `test`,
+`package`, `lint`, `format`, and `format:check` tasks. A nested standalone
+project declares its own empty Cargo workspace so a surrounding repository
+workspace does not absorb it accidentally. The `examples` option emits explicit
+Cargo example targets and `required-features`, so an optional code generator is
+excluded from ordinary workspace tests until its feature is enabled.
+`DBXToolsRustWorkspace` constructs the same class with workspace-owned metadata
+and keeps aggregate binding and release coordination.
+`DBXToolsRustWorkspaceOptions.private` supplies the default Cargo publication
+policy for every discovered crate; a package-level `private` value overrides it.
+Cargo projects use the flat object-style constructor exclusively.
+
 Rust dependencies between binding-enabled workspace crates become Node
 `workspace:*` and Python `internalDependencies` automatically. Python generation
 selects the owning crate and supplies `external_packages` imports. UBRN currently
@@ -159,7 +189,8 @@ build has no colliding binary outputs. 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
-names, generated headers, empty `__init__.py`, and native-library placement.
+names, generated headers, generated package-root exports, and native-library
+placement.
 
 `sync --watch` runs a focused Rust watcher beside the OpenAPI watcher. Changes
 inside an existing UniFFI crate regenerate that crate and its dependent bindings
@@ -173,6 +204,12 @@ a host Rust build. Regenerate bindings through the focused watcher or explicit
 task while changing a UniFFI API. Release preparation runs Cargo workspace tests
 without invoking UBRN.
 
+Rust fingerprinting and binary version stamping use the dependency-free Node
+helper generated at `.projen/rust-release.mjs`. The implementation ships with
+`@dbx-tools/projen`, so consumers do not need a repository-specific helper
+crate, a crates.io publication, or an extra Cargo build before release
+orchestration can start.
+
 The workspace generates one `release.yml` workflow for every ecosystem. One
 root `VERSION` drives every Node, Python, Cargo, native, and GitHub artifact.
 `bun run release` prepares one reviewed PR into `main`; it enables automatic
@@ -217,7 +254,11 @@ 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. Phase timings are written to each build log. Python generation executes the already-built
+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.
 
@@ -253,18 +294,28 @@ from the same workflow. When a conventional Node binding path already belongs
 to a root subproject, Rust mapping reuses that project and adds binding
 dependencies and metadata to its existing manifest.
 
+The workspace npm publisher owns compilation for normal release publication. It
+selects every publishable package with compiled entry points, invokes one
+root-level filtered compile, then packs each package exactly once with lifecycle
+scripts disabled. It validates the archive identity, configured access,
+integrity, and repository metadata before publishing those same bytes. Local
+release preparation passes `--skip-compile` only after its immediately preceding
+validation compile and verifies every expected output exists before reuse.
+Package `prepack` tasks remain available for standalone publishes without
+multiplying `tsc --build` across the monorepo release flow.
+
 ## Customize Packages With Mixins
 
 ```ts
-import { project as projenProject } from "@dbx-tools/projen";
+import { project } from "@dbx-tools/projen";
 
-const project = new projenProject.DBXToolsNodeProject();
+const rootProject = new project.DBXToolsNodeProject();
 
-projenProject.applyToProjects(project, { tags: "shared" }, (pkg) => {
+project.applyToProjects(rootProject, { tags: "shared" }, (pkg) => {
   pkg.addDeps("zod@catalog:");
 });
 
-project.synth();
+rootProject.synth();
 ```
 
 Use `projectJs.addOptionalPeer(pkg, specifier)` for an optional peer that must
@@ -482,7 +533,8 @@ invokes, so there is no second place to run the same thing:
   edit/compile loop to one package.
 - `build` / `package` - a complete compile/test/pack lifecycle when invoked in
   one package. Release preparation validates through the root's filtered tasks,
-  and publication uses concurrent `bun publish --ignore-scripts`. The package phase also packs
+  and publication concurrently uploads archives that were each packed and
+  validated once with lifecycle scripts disabled. The package phase also packs
   with `--ignore-scripts` because its build already compiled; `prepack` remains
   available for a standalone publish that did not run `build` first.
 - `install` / `install:ci` / `default` / `pre-compile` / `post-compile` -

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.5";
+export const PACKAGE_VERSION = "0.9.7";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -22,6 +22,7 @@ export * as projectJs from "./src/project-js.ts";
 export * as projectPredicate from "./src/project-predicate.ts";
 export * as projectPy from "./src/project-py.ts";
 export * as projectRs from "./src/project-rs.ts";
+export * as projenVersion from "./src/projen-version.ts";
 export * as publish from "./src/publish.ts";
 export * as release from "./src/release.ts";
 export * as releaseCatalog from "./src/release-catalog.ts";
@@ -50,12 +51,13 @@ export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
 export type { Catalog, AllowBuilds, DBXToolsPNPMWorkspaceOptions } from "./src/pnpm-workspace.ts";
 export type { DBXToolsProjectLanguage, DBXToolsProjectOptions, DBXToolsProject, ApplyToProjectsOptions } from "./src/project.ts";
-export { PackageIdentifier, PROJEN_VERSION, DBX_TOOLS_LICENSE, DBXToolsNodeProject, ROOT_INSTALL_ONLY_MIXIN, DBXToolsTypeScriptProject } from "./src/project-js.ts";
+export { PackageIdentifier, DBX_TOOLS_LICENSE, DBXToolsNodeProject, ROOT_INSTALL_ONLY_MIXIN, DBXToolsTypeScriptProject } from "./src/project-js.ts";
 export type { DBXToolsJavaScriptProject, DBXToolsReleaseMode, PullRequestTitlePolicyOptions, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
 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, RustCliOptions, RustPackageOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.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 { PROJEN_VERSION } from "./src/projen-version.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { ReleaseStage, ReleaseDocsOptions, ReleaseSummaryOptions, DBXToolsReleaseOptions } from "./src/release.ts";
@@ -70,7 +72,7 @@ export type { ReleaseUnitWorkspacePluginOptions } from "./src/release-please.ts"
 export { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS } from "./src/tags.ts";
 export type { PackageTag } from "./src/tags.ts";
 export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
-export { makeDefaultedInterfaceParametersOptional, addTypeScriptExtensionsToBindingImports, addExplicitInterfaceReexports } from "./src/uniffi.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";

package/package.json

@@ -2,6 +2,7 @@
   "name": "@dbx-tools/projen",
   "scripts": {
     "build": "projen build",
+    "bundle:rust-release": "projen bundle:rust-release",
     "clobber": "projen clobber",
     "compile": "projen compile",
     "default": "projen default",
@@ -20,22 +21,24 @@
     "@types/node": "^24.6.0",
     "@types/semver": "^7.7.1",
     "constructs": "^10.0.0",
-    "projen": "^0.101.6",
+    "projen": "0.103.27",
     "tsoa": "^6.6.0",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "projen": "^0.103.27"
+  },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "^0.9.5",
-    "@dbx-tools/path": "^0.9.5",
-    "@dbx-tools/shared-core": "^0.9.5",
+    "@dbx-tools/core": "^0.9.7",
+    "@dbx-tools/path": "^0.9.7",
+    "@dbx-tools/shared-core": "^0.9.7",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
     "is-identifier": "^1",
     "openapi-typescript": "^7.13.0",
     "oxc-parser": "^0.90.0",
-    "projen": "^0.101.16",
     "release-please": "17.11.2",
     "semver": "^7.7.3",
     "smol-toml": "1.8.0",
@@ -50,7 +53,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_rust-project.ts

@@ -0,0 +1,356 @@
+/** Projen-native standalone and workspace-owned Rust project implementation. */
+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 { 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 interface CargoDependencyOptions {
+  readonly version?: string;
+  readonly workspace?: boolean;
+  readonly path?: string;
+  readonly optional?: boolean;
+  readonly package?: string;
+  readonly defaultFeatures?: boolean;
+  readonly features?: readonly string[];
+}
+
+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;
+}
+
+/** Explicit Cargo example target and the feature gate required to compile it. */
+export interface CargoExampleOptions {
+  readonly name: string;
+  /** Source path relative to the crate root. Defaults to Cargo's conventional path. */
+  readonly path?: string;
+  /** Features Cargo must enable before compiling this example. */
+  readonly requiredFeatures?: readonly string[];
+}
+
+/** Cargo package, target, binding, and release behavior shared by every Rust project. */
+export interface RustCrateOptions {
+  readonly description?: string;
+  /** Keep this crate unpublished and out of public docs. */
+  readonly private?: boolean;
+  /** Build this crate's binary for each target and attach it to the GitHub release. */
+  readonly release?: boolean;
+  /** 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>>;
+  readonly features?: Readonly<Record<string, readonly string[]>>;
+  readonly defaultFeatures?: readonly string[];
+  /** Explicit example targets, including optional Cargo feature gates. */
+  readonly examples?: readonly CargoExampleOptions[];
+  /** 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 uniffiConfig?: Readonly<Record<string, unknown>>;
+}
+
+/** Options for a standalone or workspace-owned Projen-native Cargo project. */
+export interface DBXToolsRustProjectOptions extends DBXToolsProjectOptions, RustCrateOptions {
+  /** Cargo package name. */
+  readonly name: string;
+  readonly parent?: Project;
+  /** Package directory relative to its workspace root; inferred from `outdir` when omitted. */
+  readonly directory?: string;
+  /** Cargo workspace root used for generated workspace mappings. Defaults to `.`. */
+  readonly workspaceRoot?: string;
+  /** Inherit unspecified Cargo package metadata from `[workspace.package]`. */
+  readonly workspace?: boolean;
+  /** Crate-name scope retained for workspace package and binding naming. */
+  readonly scope?: string;
+  /** Concrete standalone package version. Defaults to `0.1.0`. */
+  readonly version?: string;
+  /** Rust edition. Defaults to `2021` for standalone projects. */
+  readonly edition?: string;
+  /** Minimum supported Rust version. Defaults to `1.82` for standalone projects. */
+  readonly rustVersion?: string;
+  /** SPDX license identifier. Defaults to Apache-2.0 for standalone projects. */
+  readonly license?: string;
+  /** Copyright owner written to a standalone license file. Defaults to the package name. */
+  readonly copyrightOwner?: string;
+  /** Source repository URL. Auto-detected for standalone projects when possible. */
+  readonly repository?: string;
+}
+
+function rustSources(directory: string): string[] {
+  if (!existsSync(directory)) return [];
+  const files: string[] = [];
+  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);
+  }
+  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")),
+  );
+}
+
+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)
+    .map((entry) => entry.name)
+    .sort();
+}
+
+export function cargoDependency(
+  value: CargoDependency,
+  workspaceVersion?: string,
+): string | Record<string, unknown> {
+  if (typeof value === "string") return value;
+  return {
+    ...(value.version ? { version: value.version } : {}),
+    ...(!value.version && value.path && workspaceVersion ? { version: workspaceVersion } : {}),
+    ...(value.workspace ? { workspace: true } : {}),
+    ...(value.path ? { path: value.path } : {}),
+    ...(value.package ? { package: value.package } : {}),
+    ...(value.optional ? { optional: true } : {}),
+    ...(value.defaultFeatures === false ? { "default-features": false } : {}),
+    ...(value.features?.length ? { features: [...value.features] } : {}),
+  };
+}
+
+export function structuredTomlSections(
+  value: Readonly<Record<string, unknown>>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [section, contents] of Object.entries(value)) {
+    const path = section.split(".");
+    let target = result;
+    for (const part of path.slice(0, -1)) {
+      const current = target[part];
+      if (current === undefined) {
+        target[part] = {};
+      } else if (!current || typeof current !== "object" || Array.isArray(current)) {
+        throw new Error(`Conflicting TOML section ${section}`);
+      }
+      target = target[part] as Record<string, unknown>;
+    }
+    target[path.at(-1)!] = contents;
+  }
+  return result;
+}
+
+interface ResolvedRustProjectOptions extends DBXToolsRustProjectOptions {
+  readonly directory: string;
+  readonly outdir: string;
+  readonly workspaceRoot: string;
+}
+
+function resolveRustProjectOptions(
+  options: DBXToolsRustProjectOptions,
+): ResolvedRustProjectOptions {
+  if (!/^[A-Za-z0-9_][A-Za-z0-9_-]*$/.test(options.name)) {
+    throw new Error(`Invalid Cargo package name: ${options.name}`);
+  }
+  const directory =
+    options.directory ??
+    (options.outdir && options.outdir !== "."
+      ? basename(options.outdir)
+      : stringUtils.toSlug(options.name));
+  return {
+    ...options,
+    directory,
+    outdir: options.outdir ?? (options.parent ? directory : "."),
+    workspaceRoot: options.workspaceRoot ?? ".",
+  };
+}
+
+function packageOptions(
+  options: ResolvedRustProjectOptions,
+): RustCrateOptions & { readonly directory: string } {
+  return {
+    directory: options.directory,
+    ...(options.description !== undefined ? { description: options.description } : {}),
+    ...(options.private !== undefined ? { private: options.private } : {}),
+    ...(options.release !== undefined ? { release: options.release } : {}),
+    ...(options.releaseExcludeOs ? { releaseExcludeOs: options.releaseExcludeOs } : {}),
+    ...(options.dependencies ? { dependencies: options.dependencies } : {}),
+    ...(options.devDependencies ? { devDependencies: options.devDependencies } : {}),
+    ...(options.features ? { features: options.features } : {}),
+    ...(options.defaultFeatures ? { defaultFeatures: options.defaultFeatures } : {}),
+    ...(options.binaryName ? { binaryName: options.binaryName } : {}),
+    ...(options.cli !== undefined ? { cli: options.cli } : {}),
+    ...(options.bindings ? { bindings: options.bindings } : {}),
+    ...(options.uniffiConfig ? { uniffiConfig: options.uniffiConfig } : {}),
+  };
+}
+
+function inheritedCargoValue(
+  workspace: boolean,
+  configured: string | undefined,
+  fallback: string,
+): string | { workspace: true } {
+  return workspace && configured === undefined ? { workspace: true } : (configured ?? fallback);
+}
+
+/** One standalone or workspace-owned Cargo project. */
+export class RustProject extends Project implements DBXToolsProject {
+  readonly language = "rust" as const;
+  readonly crateName: string;
+  readonly workspaceRoot: string;
+  readonly scope: string;
+  readonly packageOptions: RustCrateOptions & { readonly directory: string };
+  readonly uniffi: boolean;
+  readonly manifestFile: TomlFile;
+  readonly lintTask: Task;
+  readonly formatTask: Task;
+  readonly formatCheckTask: Task;
+
+  constructor(projectOptions: DBXToolsRustProjectOptions) {
+    const options = resolveRustProjectOptions(projectOptions);
+    super({ parent: options.parent, outdir: options.outdir, name: options.name });
+    this.crateName = options.name;
+    this.workspaceRoot = options.workspaceRoot;
+    this.scope = stringUtils.toSlug(options.scope ?? options.name.split("-")[0]!);
+    this.packageOptions = packageOptions(options);
+    this.uniffi = hasUniFFIBindings(this.outdir);
+    const library = existsSync(join(this.outdir, "src/lib.rs"));
+    const binary = existsSync(join(this.outdir, "src/main.rs"));
+    const binaryName = options.binaryName ?? this.crateName;
+    const workspace = options.workspace === true;
+    const projectDirectory = options.parent
+      ? resolve(options.parent.outdir, options.outdir)
+      : resolve(options.outdir);
+    const repository =
+      options.repository ??
+      (options.parent instanceof javascript.NodeProject
+        ? projectRepositoryUrl(options.parent)
+        : projectUtils.repositoryUrl(projectDirectory));
+    const dependencyVersion =
+      options.version ?? (options.parent ? readWorkspaceVersion(options.parent.outdir) : "0.1.0");
+    const manifest: Record<string, unknown> = {
+      ...(!workspace ? { workspace: {} } : {}),
+      package: {
+        name: this.crateName,
+        version: inheritedCargoValue(workspace, options.version, "0.1.0"),
+        edition: inheritedCargoValue(workspace, options.edition, "2021"),
+        "rust-version": inheritedCargoValue(workspace, options.rustVersion, "1.82"),
+        description: options.description ?? this.crateName,
+        license: inheritedCargoValue(workspace, options.license, DBX_TOOLS_LICENSE),
+        ...(workspace && options.repository === undefined
+          ? { repository: { workspace: true } }
+          : repository
+            ? { repository }
+            : {}),
+        ...(options.private ? { publish: false } : {}),
+      },
+      ...(library
+        ? {
+            lib: {
+              name: this.crateName.replaceAll("-", "_"),
+              path: "src/lib.rs",
+              ...(this.uniffi ? { "crate-type": ["lib", "cdylib"] } : {}),
+            },
+          }
+        : {}),
+      ...(this.uniffi || binary
+        ? {
+            bin: [
+              ...(this.uniffi
+                ? [{ name: `${this.crateName}-uniffi-bindgen`, path: "uniffi-bindgen.rs" }]
+                : []),
+              ...(binary ? [{ name: binaryName, path: "src/main.rs" }] : []),
+            ],
+          }
+        : {}),
+      ...(options.features || options.defaultFeatures
+        ? {
+            features: {
+              ...(options.defaultFeatures ? { default: [...options.defaultFeatures] } : {}),
+              ...options.features,
+            },
+          }
+        : {}),
+      ...(options.examples?.length
+        ? {
+            example: options.examples.map((example) => ({
+              name: example.name,
+              ...(example.path ? { path: example.path } : {}),
+              ...(example.requiredFeatures?.length
+                ? { "required-features": [...example.requiredFeatures] }
+                : {}),
+            })),
+          }
+        : {}),
+      ...(options.dependencies
+        ? {
+            dependencies: Object.fromEntries(
+              Object.entries(options.dependencies).map(([name, value]) => [
+                name,
+                cargoDependency(value, dependencyVersion),
+              ]),
+            ),
+          }
+        : {}),
+      ...(options.devDependencies
+        ? {
+            "dev-dependencies": Object.fromEntries(
+              Object.entries(options.devDependencies).map(([name, value]) => [
+                name,
+                cargoDependency(value, dependencyVersion),
+              ]),
+            ),
+          }
+        : {}),
+    };
+    this.manifestFile = new TomlFile(this, "Cargo.toml", { marker: false, obj: manifest });
+    if (this.uniffi) {
+      new TextFile(this, "uniffi-bindgen.rs", {
+        lines: ["fn main() {", "    uniffi::uniffi_bindgen_main();", "}", ""],
+      });
+      new TomlFile(this, "uniffi.toml", {
+        marker: false,
+        obj: structuredTomlSections(
+          options.uniffiConfig ?? {
+            "bindings.python": { cdylib_name: this.crateName.replaceAll("-", "_") },
+            "bindings.typescript": { strictTypeChecking: true },
+          },
+        ),
+      });
+    }
+    this.compileTask.reset("cargo build");
+    this.testTask.reset("cargo test");
+    this.packageTask.reset("cargo package");
+    this.lintTask = this.addTask("lint", {
+      description: "Lint every Rust target and feature",
+      exec: "cargo clippy --all-targets --all-features",
+    });
+    this.formatTask = this.addTask("format", {
+      description: "Format Rust sources",
+      exec: "cargo fmt",
+    });
+    this.formatCheckTask = this.addTask("format:check", {
+      description: "Check Rust source formatting",
+      exec: "cargo fmt -- --check",
+    });
+    if (!workspace) {
+      new License(this, {
+        spdx: options.license ?? DBX_TOOLS_LICENSE,
+        copyrightOwner: options.copyrightOwner ?? options.name,
+      });
+      this.gitignore.addPatterns("target/");
+    }
+  }
+}