@dbx-tools/projen 0.9.12 → 0.9.17

package/src/project-rs.ts

@@ -1,6 +1,6 @@
 /** Filesystem-discovered Rust workspaces and UniFFI binding package wiring. */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { stringUtils } from "@dbx-tools/shared-core";
 import { Component, Project, TextFile, TomlFile, javascript } from "projen";
@@ -15,6 +15,7 @@ import {
   type DBXToolsRustProjectOptions as RustProjectOptions,
   type RustCrateOptions as RustCrateConfiguration,
   type RustCliOptions as RustCliConfiguration,
+  type RustOpenApiOptions as RustOpenApiConfiguration,
 } from "./_rust-project.ts";
 import {
   configureRustReleaseTask,
@@ -57,6 +58,7 @@ export type CargoExampleOptions = RustCargoExampleOptions;
 export type DBXToolsRustProjectOptions = RustProjectOptions;
 export type RustCrateOptions = RustCrateConfiguration;
 export type RustCliOptions = RustCliConfiguration;
+export type RustOpenApiOptions = RustOpenApiConfiguration;
 
 /** Public Rust project facade; implementation lives apart from workspace/release coordination. */
 export class DBXToolsRustProject extends RustProject {
@@ -269,12 +271,23 @@ export interface RustBindingMapping {
   readonly dependencies?: readonly string[];
 }
 
+/** Persisted Rust OpenAPI producer consumed by the shared OpenAPI task. */
+export interface RustOpenApiMapping {
+  readonly crate: string;
+  readonly rust: string;
+  readonly output: string;
+  readonly binary?: string;
+  readonly features: readonly string[];
+  readonly noDefaultFeatures: boolean;
+}
+
 /** Persisted Rust workspace state consumed by `sync --watch`. */
 export interface RustWorkspaceMapping {
   readonly root: string;
   readonly crates: readonly string[];
   readonly bindings: readonly RustBindingMapping[];
   readonly binaries: readonly RustReleaseBinaryMapping[];
+  readonly openapi: readonly RustOpenApiMapping[];
 }
 
 /** One platform archive published for a Rust CLI binary. */
@@ -296,6 +309,10 @@ export interface RustReleaseBinaryMapping {
   readonly tagPrefix: string;
   readonly tag: string;
   readonly repository: string;
+  /** Cargo crate published or mirrored for `cargo install` when GitHub has no archive. */
+  readonly crateName: string;
+  /** Feature flags passed to `cargo install --features` for this binary target. */
+  readonly cargoFeatures: readonly string[];
   readonly assets: readonly RustReleaseBinaryAssetMapping[];
 }
 
@@ -392,6 +409,7 @@ function planRustReleaseBinaries(
               release: pkg.packageOptions.release,
               excludedOs: pkg.packageOptions.releaseExcludeOs,
               cli: pkg.packageOptions.cli,
+              requiredFeatures: undefined,
             },
           ]
         : []),
@@ -404,6 +422,7 @@ function planRustReleaseBinaries(
           release: binary.release,
           excludedOs: binary.releaseExcludeOs,
           cli: binary.cli!,
+          requiredFeatures: binary.requiredFeatures,
         })),
     ];
     return configuredBinaries.map((binary) => {
@@ -450,6 +469,8 @@ function planRustReleaseBinaries(
         tagPrefix,
         tag: `${tagPrefix}${identity.version}`,
         repository: resolved.repository,
+        crateName: pkg.crateName,
+        cargoFeatures: [...(binary.requiredFeatures ?? [])],
         assets: resolved.nativeTargets
           .filter((target) => !excludedOs.has(target.os))
           .map((target) => ({
@@ -770,11 +791,26 @@ function createRustWorkspaceMapping(
   binaries: readonly RustReleaseBinaryMapping[],
   resolved: ResolvedRustWorkspaceOptions,
 ): RustWorkspaceMapping {
+  const openapiRoot = join(dirname(resolved.nodeRoot), "openapi");
   return {
     root: resolved.root,
     crates: packages.map((pkg) => `${resolved.root}/${pkg.packageOptions.directory}`),
     bindings,
     binaries,
+    openapi: packages.flatMap((pkg) => {
+      if (!pkg.packageOptions.openapi) return [];
+      const options = pkg.packageOptions.openapi === true ? {} : pkg.packageOptions.openapi;
+      return [
+        {
+          crate: pkg.crateName,
+          rust: `${resolved.root}/${pkg.packageOptions.directory}`,
+          output: toPosix(join(openapiRoot, pkg.packageOptions.directory)),
+          ...(options.binary ? { binary: options.binary } : {}),
+          features: [...(options.features ?? [])],
+          noDefaultFeatures: options.noDefaultFeatures ?? false,
+        },
+      ];
+    }),
   };
 }
 
@@ -963,6 +999,9 @@ export class DBXToolsRustWorkspace extends Component {
           name: binary.binaryName,
           generated: true,
           data: {
+            binary: binary.binaryName,
+            crate: binary.crateName,
+            features: binary.cargoFeatures,
             targets: resolved.nativeTargets.filter((target) =>
               binary.assets.some((asset) => asset.os === target.os && asset.cpu === target.cpu),
             ),
@@ -1059,8 +1098,17 @@ export class DBXToolsRustWorkspace extends Component {
     }
     configureRustReleaseTask(project, plan);
     if (project.releaseCatalog.mode === "independent") {
-      if (plan.hasTargetOutputs && plan.targets.length) {
-        workflow.addJob("rust-build", rustBuildJob(plan, independentReleaseSetupSteps(project)));
+      if (plan.uniffiTargets.length) {
+        workflow.addJob(
+          "rust-uniffi",
+          rustBuildJob(plan, "uniffi", independentReleaseSetupSteps(project)),
+        );
+      }
+      if (plan.binaryTargets.length) {
+        workflow.addJob(
+          "rust-binaries",
+          rustBuildJob(plan, "binaries", independentReleaseSetupSteps(project)),
+        );
       }
       if (plan.publicCrates.length) {
         workflow.addJob("publish-cargo", independentRustCargoPublishJob(project, plan));
@@ -1081,15 +1129,18 @@ export class DBXToolsRustWorkspace extends Component {
       }
       return;
     }
-    if (plan.hasTargetOutputs && plan.targets.length) {
-      workflow.addJob("rust-build", rustBuildJob(plan));
+    if (plan.uniffiTargets.length) {
+      workflow.addJob("rust-uniffi", rustBuildJob(plan, "uniffi"));
+    }
+    if (plan.binaryTargets.length) {
+      workflow.addJob("rust-binaries", rustBuildJob(plan, "binaries"));
     }
     if (plan.publicCrates.length) {
       workflow.addJob("publish-cargo", rustCargoPublishJob(plan, false));
       workflow.addJob("publish-local-cargo", rustCargoPublishJob(plan, true));
     }
     if (plan.releaseBinaries.length) {
-      workflow.addJob("publish-github-release", rustGitHubReleaseJob());
+      workflow.addJob("publish-github-release", rustGitHubReleaseJob(plan));
     }
     if (plan.nodeBindings.length && hasNodeRelease(project)) {
       workflow.addJob("publish-native-npm", rustNativeNpmPublishJob(project));

package/src/release-plan.ts

@@ -47,20 +47,23 @@ export interface PlannedRustTarget {
   readonly runner: string;
   readonly python: string;
   readonly libc: string;
-  readonly cargoExcludes: string;
   readonly packages: readonly string[];
+  readonly binaries: readonly string[];
+  readonly features: readonly string[];
+  readonly fingerprintConfig: string;
 }
 
 /** Complete plan persisted as a workflow artifact and used for recovery. */
 export interface ReleasePlan {
-  readonly schemaVersion: 1;
+  readonly schemaVersion: 2;
   readonly units: readonly PlannedReleaseUnit[];
   readonly publishBatches: readonly (readonly string[])[];
   readonly nodePackages: readonly PlannedPackage[];
   readonly pythonPackages: readonly PlannedPackage[];
   readonly rustPackages: readonly PlannedPackage[];
   readonly artifacts: readonly PlannedArtifact[];
-  readonly rustTargets: readonly PlannedRustTarget[];
+  readonly rustUniffiTargets: readonly PlannedRustTarget[];
+  readonly rustBinaryTargets: readonly PlannedRustTarget[];
   readonly stages: {
     readonly rust: boolean;
     readonly python: boolean;
@@ -130,18 +133,53 @@ export function buildReleasePlan(
       ]);
     }
   }
-  const rustTargetsByKey = new Map<string, PlannedRustTarget>();
+  const rustTargetsByKind = {
+    uniffi: new Map<string, PlannedRustTarget>(),
+    binaries: new Map<string, PlannedRustTarget>(),
+  };
   for (const artifact of artifacts) {
     const targets = artifact.data?.targets;
     if (!Array.isArray(targets)) continue;
+    const kind = artifact.kind === "github-binary" ? "binaries" : "uniffi";
     for (const value of targets) {
       if (!value || typeof value !== "object" || Array.isArray(value)) continue;
       const target = value as Record<string, unknown>;
       const required = ["os", "cpu", "node", "cargo", "runner", "python"] as const;
       if (!required.every((field) => typeof target[field] === "string")) continue;
       const key = String(target.node);
-      const currentTarget = rustTargetsByKey.get(key);
-      rustTargetsByKey.set(key, {
+      const targetsByKey = rustTargetsByKind[kind];
+      const currentTarget = targetsByKey.get(key);
+      const packages = [
+        ...new Set([
+          ...(currentTarget?.packages ?? []),
+          ...(rustPackagesByUnit.get(artifact.unit) ?? []),
+        ]),
+      ].sort();
+      const binaries =
+        kind === "binaries"
+          ? [
+              ...new Set([
+                ...(currentTarget?.binaries ?? []),
+                ...(typeof artifact.data?.binary === "string" ? [artifact.data.binary] : []),
+              ]),
+            ].sort()
+          : [];
+      const configuredFeatures = Array.isArray(artifact.data?.features)
+        ? artifact.data.features.filter((feature): feature is string => typeof feature === "string")
+        : [];
+      const crate = typeof artifact.data?.crate === "string" ? artifact.data.crate : undefined;
+      const features =
+        kind === "uniffi"
+          ? packages.map((pkg) => `${pkg}/uniffi-bindgen`)
+          : [
+              ...new Set([
+                ...(currentTarget?.features ?? []),
+                ...(crate
+                  ? configuredFeatures.map((feature) => `${crate}/${feature}`)
+                  : configuredFeatures),
+              ]),
+            ].sort();
+      targetsByKey.set(key, {
         os: String(target.os),
         cpu: String(target.cpu),
         node: String(target.node),
@@ -149,17 +187,19 @@ export function buildReleasePlan(
         runner: String(target.runner),
         python: String(target.python),
         libc: typeof target.libc === "string" ? target.libc : "",
-        cargoExcludes: typeof target.cargoExcludes === "string" ? target.cargoExcludes : "",
-        packages: [
-          ...new Set([
-            ...(currentTarget?.packages ?? []),
-            ...(rustPackagesByUnit.get(artifact.unit) ?? []),
-          ]),
-        ].sort(),
+        packages,
+        binaries,
+        features,
+        fingerprintConfig: JSON.stringify({ packages, binaries, features }),
       });
     }
   }
-  const rustTargets = [...rustTargetsByKey.values()].sort((a, b) => a.node.localeCompare(b.node));
+  const rustUniffiTargets = [...rustTargetsByKind.uniffi.values()].sort((a, b) =>
+    a.node.localeCompare(b.node),
+  );
+  const rustBinaryTargets = [...rustTargetsByKind.binaries.values()].sort((a, b) =>
+    a.node.localeCompare(b.node),
+  );
   const publishBatches = current.publishBatches
     .map((batch) => batch.filter((unit) => selected.has(unit)))
     .filter((batch) => batch.length > 0);
@@ -179,14 +219,15 @@ export function buildReleasePlan(
     .filter(([, enabled]) => !enabled)
     .map(([name]) => name);
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     units,
     publishBatches,
     nodePackages,
     pythonPackages,
     rustPackages,
     artifacts,
-    rustTargets,
+    rustUniffiTargets,
+    rustBinaryTargets,
     stages,
     omittedStages,
   };

package/src/release.ts

@@ -591,7 +591,8 @@ function independentReleasePlanJob(project: DBXToolsJavaScriptProject): Job {
       python_packages: { stepId: "plan", outputName: "python_packages" },
       rust_packages: { stepId: "plan", outputName: "rust_packages" },
       artifacts: { stepId: "plan", outputName: "artifacts" },
-      rust_targets: { stepId: "plan", outputName: "rust_targets" },
+      rust_uniffi_targets: { stepId: "plan", outputName: "rust_uniffi_targets" },
+      rust_binary_targets: { stepId: "plan", outputName: "rust_binary_targets" },
     },
     steps: [
       {

package/src/watch.ts

@@ -81,13 +81,28 @@ function ignoredPath(path: string): boolean {
  * (e.g. the projenrc watcher passes `{ dot: false }` so its lone dotfile target,
  * `.projenrc.ts`, isn't pruned by the default dotfile group and left with nothing to
  * watch - which would let the process exit immediately).
+ *
+ * `check` is forwarded to the workspace mutation lock so a watcher that can tell
+ * the batch is a no-op never waits on an unrelated holder.
  */
+export interface WatchLoopOptions {
+  ignoreOptions?: IgnoreGroupOptions;
+  check?: (changed: string[]) => boolean | Promise<boolean>;
+}
+
+function resolveWatchLoopOptions(config?: IgnoreGroupOptions | WatchLoopOptions): WatchLoopOptions {
+  if (!config) return {};
+  if ("check" in config || "ignoreOptions" in config) return config as WatchLoopOptions;
+  return { ignoreOptions: config as IgnoreGroupOptions };
+}
+
 export function watchLoop(
   tag: string,
   paths: string[],
   onBatch: (changed: string[]) => void | Promise<void>,
-  ignoreOptions?: IgnoreGroupOptions,
+  config?: IgnoreGroupOptions | WatchLoopOptions,
 ): void {
+  const { ignoreOptions, check } = resolveWatchLoopOptions(config);
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | undefined;
   let running = false;
@@ -105,7 +120,9 @@ export function watchLoop(
     pending.clear();
     try {
       if (relevant.length) {
-        await withWorkspaceMutationLock(repoRoot, () => onBatch(relevant));
+        await withWorkspaceMutationLock(repoRoot, () => onBatch(relevant), {
+          check: check ? () => check(relevant) : undefined,
+        });
       }
     } catch (err) {
       logger.error(`${tag} cycle failed:`, err instanceof Error ? err.message : err);

package/src/workspace-lock.ts

@@ -6,17 +6,43 @@ import { log } from "@dbx-tools/shared-core";
 const MUTATION_LOCK_SCOPE = "dbx-tools-workspace-mutation";
 const logger = log.logger("projen:workspace-lock");
 
+export interface WorkspaceMutationLockOptions {
+  /**
+   * When this returns false, skip both the lock and the callback. After the
+   * lock is held it runs again so a completed holder can make the work a no-op
+   * without taking the critical section only to return.
+   */
+  check?: () => boolean | Promise<boolean>;
+}
+
 /**
  * Serialize synthesis, generated-file watchers, and release preparation for one
  * repository without coordinating unrelated worktrees or repositories.
+ *
+ * `check` is check-lock-check: a false result before acquire never waits, and a
+ * false result after acquire releases immediately without running `callback`.
  */
-export function withWorkspaceMutationLock<T>(
+export async function withWorkspaceMutationLock<T>(
   root: string,
   callback: () => T | Promise<T>,
-): Promise<T> {
+  options?: WorkspaceMutationLockOptions,
+): Promise<T | undefined> {
   const repository = resolve(root);
-  return fileLock.withFileLock([MUTATION_LOCK_SCOPE, repository], callback, {
-    backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
-    onWait: () => logger.info("waiting for workspace mutation lock", { repository }),
-  });
+  const check = options?.check;
+  if (check && !(await check())) {
+    return undefined;
+  }
+  return fileLock.withFileLock(
+    [MUTATION_LOCK_SCOPE, repository],
+    async () => {
+      if (check && !(await check())) {
+        return undefined;
+      }
+      return callback();
+    },
+    {
+      backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
+      onWait: () => logger.info("waiting for workspace mutation lock", { repository }),
+    },
+  );
 }

package/tasks/barrels.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { sep } from "node:path";
 import { parseArgs } from "node:util";
-import { log, stringUtils } from "@dbx-tools/shared-core";
+import { log, object, stringUtils } from "@dbx-tools/shared-core";
 import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";
@@ -17,41 +17,58 @@ const { values } = parseArgs({
 });
 
 /** The recorded package dir that owns `abs`, if any (for a targeted barrel rebuild). */
-function ownerPackageDir(abs: string, pkgDirs: string[]): string | undefined {
-  return pkgDirs.find((dir) => abs === dir || abs.startsWith(dir + sep));
+function ownerPackageDir(
+  abs: string,
+  packages: readonly { readonly dir: string; readonly tags: readonly string[] }[],
+): string | undefined {
+  // The OpenAPI task rebuilds generated-client barrels after writing its files.
+  return packages.find(
+    ({ dir, tags }) => !tags.includes("openapi") && (abs === dir || abs.startsWith(dir + sep)),
+  )?.dir;
+}
+
+function changedBarrelTargets(changed: readonly string[]): object.Sequence<string> {
+  const packages = recordedPackages();
+  return object
+    .sequence(changed)
+    .map((path) => ownerPackageDir(path, packages))
+    .nonNull()
+    .distinct();
+}
+
+function warnUnownedChanges(changed: readonly string[]): void {
+  if (changed.length) {
+    logger.warn(
+      `no recorded package owns ${stringUtils.pluralize(changed.length, "change")}; ` +
+        "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
+    );
+  }
 }
 
 if (values.watch) {
   // Watch the package roots; a source edit inside a package rebuilds just that
   // package's `index.ts` barrel (no re-synth - the projenrc watcher owns that).
   // watchLoop already drops generated paths, so a barrel write never re-triggers us.
-  watchLoop("barrels", watchRoots(), (changed) => {
-    const pkgDirs = recordedPackages().map((p) => p.dir);
-    const dirs = new Set<string>();
-    const unowned: string[] = [];
-    for (const p of changed) {
-      const owner = ownerPackageDir(p, pkgDirs);
-      if (owner) dirs.add(owner);
-      else unowned.push(p);
-    }
-    // A change under a package root that no RECORDED package owns is almost always a
-    // NEW package folder: it has no `pnpm-workspace.yaml` member yet, so there is no
-    // barrel for this watcher to target and only a re-synth can create one. Say so,
-    // rather than rebuilding every barrel in the repo - the previous fallback, which
-    // did a full-repo sweep on behalf of a file it could not barrel anyway, and in
-    // doing so raced the projenrc watcher's own post-synth sweep.
-    if (dirs.size === 0) {
-      if (unowned.length) {
-        logger.warn(
-          `no recorded package owns ${stringUtils.pluralize(unowned.length, "change")}; ` +
-            "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
-        );
-      }
-      return;
-    }
-    const n = generateBarrels({ dirs: [...dirs] });
-    if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
-  });
+  watchLoop(
+    "barrels",
+    watchRoots(),
+    (changed) => {
+      const n = generateBarrels({ dirs: [...changedBarrelTargets(changed)] });
+      if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
+    },
+    {
+      check: (changed) => {
+        const targets = changedBarrelTargets(changed);
+        // A change under a package root that no recorded package owns is a new
+        // folder: only a re-synth can create its barrel, so this watcher skips.
+        if (!targets.some(() => true)) {
+          warnUnownedChanges(changed);
+          return false;
+        }
+        return true;
+      },
+    },
+  );
 } else {
   const dirs = Array.isArray(values.dir)
     ? values.dir.filter((value): value is string => typeof value === "string")

package/tasks/openapi.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
-import { log, stringUtils } from "@dbx-tools/shared-core";
+import { log, object, stringUtils } from "@dbx-tools/shared-core";
 import { generateBarrels } from "../src/barrels.ts";
-import { generateOpenapi, isTsoaController } from "../src/openapi.ts";
+import { generateOpenapi, isOpenapiSource, openapiWatchRoots } from "../src/openapi.ts";
 import { runSynth } from "../src/scaffold.ts";
-import { watchLoop, watchRoots } from "../src/watch.ts";
+import { watchLoop } from "../src/watch.ts";
 
 const logger = log.logger("projen:openapi");
 
@@ -11,14 +11,18 @@ if (process.argv.includes("--watch")) {
   // Watch the package roots; a changed tsoa controller regenerates the openapi
   // packages (spec + client) and rebuilds just their barrels. The projenrc watcher
   // (alongside under `concurrently`) owns full re-synth, so no re-synth here.
-  watchLoop("openapi", watchRoots(), async (changed) => {
-    if (!changed.some(isTsoaController)) return;
-    const dirs = await generateOpenapi();
-    if (dirs.length) {
-      generateBarrels({ dirs });
-      logger.success(`regenerated openapi (${stringUtils.pluralize(dirs.length, "package")})`);
-    }
-  });
+  watchLoop(
+    "openapi",
+    openapiWatchRoots(),
+    async () => {
+      const dirs = await generateOpenapi();
+      if (dirs.length) {
+        generateBarrels({ dirs });
+        logger.success(`regenerated openapi (${stringUtils.pluralize(dirs.length, "package")})`);
+      }
+    },
+    { check: (changed) => object.sequence(changed).some(isOpenapiSource) },
+  );
 } else {
   // One-shot: regenerate, then re-synth so any newly created openapi folder becomes a
   // workspace member (a new package needs install + linking, which the watch path skips).

package/tasks/release-plan.ts

@@ -75,7 +75,8 @@ new Command()
       writeOutput("python_packages", plan.pythonPackages);
       writeOutput("rust_packages", plan.rustPackages);
       writeOutput("artifacts", plan.artifacts);
-      writeOutput("rust_targets", plan.rustTargets);
+      writeOutput("rust_uniffi_targets", plan.rustUniffiTargets);
+      writeOutput("rust_binary_targets", plan.rustBinaryTargets);
       writeOutput("stages", plan.stages);
       for (const [stage, enabled] of Object.entries(plan.stages)) {
         writeOutput(stage, enabled);

package/tasks/release-pr.ts

@@ -43,12 +43,12 @@ import {
   githubTokenArguments,
   githubTokenEnvironmentName,
 } from "../src/release-github.ts";
+import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 import {
   readWorkspaceVersion,
   resolveBaseVersion,
   resolveNextVersion,
 } from "../src/workspace-version.ts";
-import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 
 const logger = log.logger("projen:release");
 

package/tasks/rust-release.d.ts

@@ -1,21 +1,22 @@
-export declare const FINGERPRINT_SCHEMA = 3;
+export declare const FINGERPRINT_SCHEMA = 4;
 export declare const VERSION_SLOT_SCHEMA = 1;
 export declare const VERSION_CAPACITY = 64;
 /** Canonical TOML representation with workspace-owned release versions removed. */
 export declare function normalizeManifest(text: string): string;
 /** Canonical Cargo.lock representation with local package versions normalized. */
 export declare function normalizeLockfile(text: string, workspaceVersion: string, packageNames?: ReadonlySet<string>): string;
-/** Hash Cargo-discovered members and every tracked or unignored file beneath them. */
-export declare function sourceHash(root: string, sources?: readonly string[]): string;
+/** Hash shared Cargo inputs plus selected or Cargo-discovered workspace sources. */
+export declare function sourceHash(root: string, sources?: readonly string[], includeWorkspace?: boolean): string;
 export declare function linkerIdentity(target: string): string;
 export interface TargetKeyOptions {
     readonly rustSourceHash: string;
+    readonly namespace?: string;
     readonly target: string;
     readonly targetConfig?: string;
     readonly toolchain?: string;
     readonly rustc?: string;
 }
-export declare function targetKey({ rustSourceHash, target, targetConfig, toolchain, rustc, }: TargetKeyOptions): string;
+export declare function targetKey({ rustSourceHash, namespace, target, targetConfig, toolchain, rustc, }: TargetKeyOptions): string;
 export interface FingerprintOptions {
     readonly root?: string;
     readonly output?: string;
@@ -24,14 +25,17 @@ export interface FingerprintOptions {
     readonly toolchain?: string;
     readonly portable?: boolean;
     readonly sources?: readonly string[];
+    readonly sourceOnly?: boolean;
+    readonly namespace?: string;
 }
 export interface RustBuildFingerprint {
     readonly schemaVersion: number;
     readonly versionSlotSchema: number;
+    readonly namespace: string;
     readonly rustSourceHash: string;
     readonly targets: Readonly<Record<string, string>>;
 }
-export declare function fingerprint({ root, output, check, targets, toolchain, portable, sources, }: FingerprintOptions): RustBuildFingerprint;
+export declare function fingerprint({ root, output, check, targets, toolchain, portable, sources, sourceOnly, namespace, }: FingerprintOptions): RustBuildFingerprint;
 export interface StampOptions {
     readonly objcopy?: string;
     readonly codesign?: string;