@dbx-tools/projen 0.9.19 → 0.9.28

package/src/barrels.ts

@@ -16,11 +16,6 @@
  * takes priority. This keeps the barrel auto-generated while letting you add or
  * override individual exports.
  *
- * A UniFFI source triplet (`bindings.ts`, `_bindings.ts`, and
- * `_bindings-ffi.ts`) is one special case: the internal underscore modules stay
- * private, while `bindings.ts` is re-exported directly instead of under a
- * `bindings` namespace. Generation fails when one of those direct binding names
- * conflicts with another top-level package export.
  *
  * Each eligible module becomes `export * as <name> from "./src/x.ts"` (camelCase
  * namespace from its path segments; invalid identifiers suffixed with `Module`),
@@ -121,9 +116,6 @@ const PACKAGE_IDENTIFIER_LINE = `export const ${PACKAGE_IDENTIFIER_EXPORT} = "";
 const PACKAGE_VERSION_LINE = `export const ${PACKAGE_VERSION_EXPORT} = "";`;
 const PACKAGE_IDENTIFIER_LINE_RE = /^export const PACKAGE_IDENTIFIER = .*;$/m;
 const PACKAGE_VERSION_LINE_RE = /^export const PACKAGE_VERSION = .*;$/m;
-const UNIFFI_BINDINGS_FILE = "bindings.ts";
-const UNIFFI_GENERATED_FILE = "_bindings.ts";
-const UNIFFI_FFI_FILE = "_bindings-ffi.ts";
 
 /** `config-tools` / `config_tools` -> `configTools`; `local-fs` -> `localFS`. */
 function moduleSegmentToCamel(segment: string): string {
@@ -295,61 +287,6 @@ function isLegacyBindingsExport(file: string): boolean {
   return readFileSync(file, "utf8").trim() === 'export * from "./src/bindings.ts";';
 }
 
-function hasUniFFIBindings(srcDir: string): boolean {
-  return [UNIFFI_BINDINGS_FILE, UNIFFI_GENERATED_FILE, UNIFFI_FFI_FILE].every((file) =>
-    existsSync(join(srcDir, file)),
-  );
-}
-
-function bindingExportNames(srcDir: string): Set<string> {
-  return new Set(
-    [UNIFFI_BINDINGS_FILE, UNIFFI_GENERATED_FILE].flatMap((file) =>
-      moduleExports(join(srcDir, file)).map((entry) => entry.name),
-    ),
-  );
-}
-
-function barrelExportNames(content: string, customPath: string): Set<string> {
-  const names = new Set<string>([PACKAGE_IDENTIFIER_EXPORT, PACKAGE_VERSION_EXPORT]);
-  for (const match of content.matchAll(/^export \* as (\w+) from /gm)) {
-    names.add(match[1]!);
-  }
-  for (const match of content.matchAll(/^export(?: type)? \{([^}]+)\} from /gm)) {
-    for (const specifier of match[1]!.split(",")) {
-      const parts = specifier.trim().split(/\s+as\s+/);
-      const name = parts.at(-1);
-      if (name) names.add(name);
-    }
-  }
-  if (existsSync(customPath) && !isLegacyBindingsExport(customPath)) {
-    const statements = moduleStatements(customPath) as ReadonlyArray<{
-      type: string;
-      exported?: unknown;
-    }>;
-    if (
-      statements.some(
-        (statement) => statement.type === "ExportAllDeclaration" && !statement.exported,
-      )
-    ) {
-      throw new Error(
-        `Cannot verify UniFFI export conflicts through a bare export in ${customPath}`,
-      );
-    }
-    for (const name of customExportNames(customPath)) names.add(name);
-  }
-  return names;
-}
-
-function assertNoBindingExportConflicts(srcDir: string, content: string, customPath: string): void {
-  const other = barrelExportNames(content, customPath);
-  const conflicts = [...bindingExportNames(srcDir)].filter((name) => other.has(name)).sort();
-  if (conflicts.length > 0) {
-    throw new Error(
-      `UniFFI binding exports conflict with package exports in ${srcDir}: ${conflicts.join(", ")}`,
-    );
-  }
-}
-
 /** Read the authoritative npm package name and version emitted by the package project. */
 function packageMetadata(pkgDir: string): { identifier: string; version: string } {
   const manifestPath = join(pkgDir, "package.json");
@@ -441,10 +378,7 @@ function generateForPackage(pkgDir: string): number {
     if (!existing || (!isSourceExt(existing) && isSourceExt(f))) byModulePath.set(stem, f);
   }
   const modulePaths = [...byModulePath.keys()].sort((a, b) => a.localeCompare(b));
-  const uniffiBindings = hasUniFFIBindings(srcDir);
-  const namespacedModulePaths = uniffiBindings
-    ? modulePaths.filter((modulePath) => modulePath !== "bindings")
-    : modulePaths;
+  const namespacedModulePaths = modulePaths;
 
   // No eligible modules -> no barrel: drop any stale root barrel and bail.
   if (modulePaths.length === 0) {
@@ -479,13 +413,6 @@ function generateForPackage(pkgDir: string): number {
   content = hoistUniqueExports(content, pkgDir, suppress);
   // A sibling `exports.ts` overrides/extends the generated barrel and wins on conflict.
   content = mergeCustomExports(content, pkgDir);
-  if (uniffiBindings) {
-    assertNoBindingExportConflicts(srcDir, content, customPath);
-    content = content.replace(
-      PACKAGE_VERSION_LINE,
-      `${PACKAGE_VERSION_LINE}\nexport * from "./src/bindings.ts";`,
-    );
-  }
 
   // Package metadata is blanked for the structural comparison, then restored
   // from package.json so a version-only change still rewrites the barrel.

package/src/module-exports.ts

@@ -19,8 +19,9 @@
  * `export { ... }` is a hard error (TS1205). `export function` names are marked
  * `isFunction` so the barrel leaves them namespace-only.
  */
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { dirname, extname, resolve } from "node:path";
 import type { parseSync as OxcParseSync } from "oxc-parser";
 
 const require = createRequire(import.meta.url);
@@ -63,6 +64,13 @@ export interface ModuleExport {
   readonly isFunction: boolean;
 }
 
+/** Plain public function reachable through a module's re-export graph. */
+export interface PublicFunctionExport {
+  readonly name: string;
+  readonly sourceFile: string;
+  readonly sourceName: string;
+}
+
 /** Declaration node types that are inherently type-only. */
 const TYPE_DECLARATIONS = new Set(["TSInterfaceDeclaration", "TSTypeAliasDeclaration"]);
 
@@ -132,3 +140,169 @@ export function moduleExports(file: string): ModuleExport[] {
   }
   return [...byName.values()];
 }
+
+/**
+ * Resolve every plain named function exported by `file`, following relative
+ * named and star re-exports. Non-function values and types are ignored. A
+ * generator, declaration-only overload, or conflicting function definition is
+ * rejected because a generic runtime bridge cannot preserve those semantics.
+ */
+export function publicFunctionExports(file: string): PublicFunctionExport[] {
+  return [...collectPublicFunctions(resolve(file), new Set()).values()]
+    .map(({ name, sourceFile, sourceName }) => ({ name, sourceFile, sourceName }))
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+interface ResolvedFunctionExport extends PublicFunctionExport {
+  readonly source: string;
+}
+
+function collectPublicFunctions(
+  file: string,
+  visiting: Set<string>,
+): Map<string, ResolvedFunctionExport> {
+  if (visiting.has(file)) return new Map();
+  visiting.add(file);
+  const source = readFileSync(file, "utf8");
+  const body = parseSync(file, source).program.body;
+  const functions = new Map<string, ResolvedFunctionExport>();
+  const localFunctions = new Map<string, FunctionNode>();
+
+  for (const statement of body) {
+    const node = statement as FunctionNode & { declaration?: FunctionNode | null };
+    const declaration =
+      node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction"
+        ? node
+        : node.declaration;
+    if (declaration?.type === "FunctionDeclaration" || declaration?.type === "TSDeclareFunction") {
+      const name = declaration.id?.name;
+      if (name) localFunctions.set(name, declaration);
+    }
+  }
+
+  const add = (exported: ResolvedFunctionExport): void => {
+    const existing = functions.get(exported.name);
+    if (existing && existing.source !== exported.source) {
+      throw new Error(
+        `Conflicting function export ${exported.name} from ${existing.source} and ${exported.source}`,
+      );
+    }
+    functions.set(exported.name, exported);
+  };
+
+  for (const statement of body) {
+    if (statement.type === "ExportAllDeclaration") {
+      const node = statement as { exported?: unknown; source?: { value?: string } };
+      if (node.exported || !node.source?.value) continue;
+      for (const exported of collectPublicFunctions(
+        resolveModuleSpecifier(file, node.source.value),
+        visiting,
+      ).values()) {
+        add(exported);
+      }
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const node = statement as {
+      declaration?: FunctionNode | null;
+      source?: { value?: string } | null;
+      specifiers?: {
+        local?: { name?: string; value?: string };
+        exported?: { name?: string; value?: string };
+        exportKind?: "value" | "type";
+      }[];
+      exportKind?: "value" | "type";
+    };
+    if (
+      node.declaration?.type === "FunctionDeclaration" ||
+      node.declaration?.type === "TSDeclareFunction"
+    ) {
+      add(parseFunctionNode(file, node.declaration));
+    }
+    if (node.exportKind === "type") continue;
+    if (node.source?.value) {
+      const available = collectPublicFunctions(
+        resolveModuleSpecifier(file, node.source.value),
+        visiting,
+      );
+      for (const specifier of node.specifiers ?? []) {
+        if (specifier.exportKind === "type") continue;
+        const local = specifier.local?.name ?? specifier.local?.value;
+        const exportedName = specifier.exported?.name ?? specifier.exported?.value;
+        const target = local ? available.get(local) : undefined;
+        if (target && exportedName)
+          add({
+            name: exportedName,
+            source: target.source,
+            sourceFile: target.sourceFile,
+            sourceName: target.sourceName,
+          });
+      }
+      continue;
+    }
+    for (const specifier of node.specifiers ?? []) {
+      if (specifier.exportKind === "type") continue;
+      const local = specifier.local?.name ?? specifier.local?.value;
+      const exportedName = specifier.exported?.name ?? specifier.exported?.value;
+      const target = local ? localFunctions.get(local) : undefined;
+      if (target && exportedName) {
+        const parsed = parseFunctionNode(file, target);
+        add({
+          name: exportedName,
+          source: parsed.source,
+          sourceFile: parsed.sourceFile,
+          sourceName: parsed.sourceName,
+        });
+      }
+    }
+  }
+
+  visiting.delete(file);
+  return functions;
+}
+
+interface FunctionNode {
+  readonly type: string;
+  readonly id?: { readonly name?: string } | null;
+  readonly generator?: boolean;
+  readonly declare?: boolean;
+  readonly body?: unknown;
+}
+
+function parseFunctionNode(file: string, node: FunctionNode): ResolvedFunctionExport {
+  const name = node.id?.name;
+  if (!name) throw new Error(`Anonymous exported function is not supported in ${file}`);
+  if (node.generator) throw new Error(`Generator export ${name} is not supported in ${file}`);
+  if (node.type === "TSDeclareFunction" || node.declare || !node.body) {
+    throw new Error(`Declaration-only function export ${name} is not supported in ${file}`);
+  }
+  return { name, source: `${file}#${name}`, sourceFile: file, sourceName: name };
+}
+
+function resolveModuleSpecifier(importer: string, specifier: string): string {
+  if (!specifier.startsWith(".")) return createRequire(importer).resolve(specifier);
+  const base = resolve(dirname(importer), specifier);
+  const extension = extname(base);
+  const candidates = extension
+    ? [
+        base,
+        ...(extension === ".js" || extension === ".jsx"
+          ? [`${base.slice(0, -extension.length)}.ts`, `${base.slice(0, -extension.length)}.tsx`]
+          : []),
+      ]
+    : [
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        resolve(base, "index.ts"),
+        resolve(base, "index.tsx"),
+        resolve(base, "index.js"),
+      ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not resolve ${specifier} from ${importer}`);
+}

package/src/openapi.ts

@@ -1,9 +1,7 @@
 /**
- * OpenAPI generator for tsoa controllers and code-first Rust producers.
+ * OpenAPI generator for tsoa controllers.
  *
- * TypeScript packages are discovered from tsoa imports. Rust producers are
- * recorded by `DBXToolsRustWorkspace`. Both feed the same optimized generated
- * package:
+ * TypeScript packages are discovered from tsoa imports and feed the optimized generated package:
  *
  *   - `openapi.json`   - the OpenAPI 3 spec (tsoa `generateSpec`, then Speakeasy
  *     optimization to extract duplicate inline schemas into components).
@@ -48,7 +46,6 @@ import {
   toPosix,
   recordedPackages,
 } from "./packages.ts";
-import type { RustOpenApiMapping, RustWorkspaceMapping } from "./project-rs.ts";
 import type { ReleaseUnitGraph } from "./release-catalog.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 
@@ -100,15 +97,6 @@ function controllerPackages(): object.Sequence<RecordedPackage> {
   return object.sequence(recordedPackages()).filter(isTsoaCandidate).filter(hasTsoaControllers);
 }
 
-function rustOpenapiMappings(): RustOpenApiMapping[] {
-  const manifest = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8")) as unknown;
-  if (!object.isRecord(manifest)) return [];
-  const config = manifest.dbxToolsConfig;
-  if (!object.isRecord(config) || !object.isRecord(config.rust)) return [];
-  const mapping = config.rust as unknown as Partial<RustWorkspaceMapping>;
-  return Array.isArray(mapping.openapi) ? [...mapping.openapi] : [];
-}
-
 function inside(path: string, directory: string): boolean {
   const child = relative(resolve(directory), resolve(path));
   return child === "" || (!child.startsWith("..") && !isAbsolute(child));
@@ -120,16 +108,11 @@ export function isOpenapiProducerSource(path: string, producers: readonly string
   return object.sequence(producers).some((producer) => inside(absolute, producer));
 }
 
-function rustOpenapiSources(mapping: RustOpenApiMapping): string[] {
-  return [resolve(repoRoot, mapping.rust, "src"), resolve(repoRoot, mapping.rust, "Cargo.toml")];
-}
-
-/** Source roots consumed by TypeScript and Rust OpenAPI producers. */
+/** Source roots consumed by TypeScript OpenAPI producers. */
 export function openapiWatchRoots(): string[] {
   return [
     ...controllerPackages()
       .map((pkg) => resolve(tsoaSource(pkg)))
-      .join(object.sequence(rustOpenapiMappings()).flatMap(rustOpenapiSources))
       .distinct(),
   ];
 }
@@ -139,14 +122,6 @@ export function isOpenapiSource(path: string): boolean {
   const absolute = resolve(path);
   const segments = toPosix(relative(repoRoot, absolute)).split("/");
   if (segments.includes(OPENAPI_TAG)) return false;
-  if (
-    object
-      .sequence(rustOpenapiMappings())
-      .flatMap(rustOpenapiSources)
-      .some((source) => inside(absolute, source))
-  ) {
-    return true;
-  }
   return object
     .sequence(recordedPackages())
     .filter(isTsoaCandidate)
@@ -196,28 +171,6 @@ export async function optimizeOpenapiSpec(specPath: string, executable?: string)
   await execFileAsync(openapi, ["spec", "optimize", specPath, "--write", "--non-interactive"]);
 }
 
-/** Cargo arguments that export one Rust producer's aide document. */
-export function rustOpenapiArgs(
-  mapping: RustOpenApiMapping,
-  output: string,
-  targetDir = join(repoRoot, "target/openapi"),
-): string[] {
-  return [
-    "run",
-    "--quiet",
-    "--target-dir",
-    targetDir,
-    "--package",
-    mapping.crate,
-    ...(mapping.noDefaultFeatures ? ["--no-default-features"] : []),
-    ...(mapping.features.length ? ["--features", mapping.features.join(",")] : []),
-    ...(mapping.binary ? ["--bin", mapping.binary] : []),
-    "--",
-    "--generate-spec",
-    output,
-  ];
-}
-
 type OpenApiTypeTools = {
   openapiTS: typeof import("openapi-typescript").default;
   astToString: typeof import("openapi-typescript").astToString;
@@ -257,11 +210,10 @@ async function writeClientPackage(
  */
 export async function generateOpenapi(): Promise<string[]> {
   const pkgs = controllerPackages().toArray();
-  const rustMappings = rustOpenapiMappings();
   // Same reasoning as codegen's empty case: a workspace with no tsoa controllers
   // is not a condition worth a line on every synth.
-  if (pkgs.length === 0 && rustMappings.length === 0) {
-    logger.debug("no TypeScript or Rust OpenAPI producers found");
+  if (pkgs.length === 0) {
+    logger.debug("no TypeScript OpenAPI producers found");
     return [];
   }
 
@@ -341,24 +293,5 @@ export async function generateOpenapi(): Promise<string[]> {
     written.push(outDir);
     logger.success(`openapi/${leaf} (from ${p.relPath})`);
   }
-  for (const mapping of rustMappings) {
-    const outDir = resolve(repoRoot, mapping.output);
-    mkdirSync(outDir, { recursive: true });
-    const specPath = join(outDir, "openapi.json");
-    const tempDir = mkdtempSync(join(outDir, ".openapi-"));
-    const tempSpecPath = join(tempDir, "openapi.json");
-    try {
-      await execFileAsync("cargo", rustOpenapiArgs(mapping, tempSpecPath), { cwd: repoRoot });
-      await optimizeOpenapiSpec(tempSpecPath);
-      makeWritable(specPath);
-      renameSync(tempSpecPath, specPath);
-    } finally {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    makeReadonly(specPath);
-    await writeClientPackage(outDir, `the aide routes in ${mapping.rust}`, tools);
-    written.push(outDir);
-    logger.success(`${mapping.output} (from ${mapping.rust})`);
-  }
   return written;
 }

package/src/packages.ts

@@ -291,6 +291,19 @@ export function syncResynthPaths(projectRoot: string = resolveRepoRoot()): strin
   return Array.isArray(paths) ? stringUtils.parseList(paths.map((p) => String(p))) : [];
 }
 
+/** Python projects with Node bindings registered for the root sync watcher. */
+export function pythonNodeBindingProjects(projectRoot: string = resolveRepoRoot()): string[] {
+  const configured = readDbxToolsConfig(projectRoot)?.pythonNodeBindings;
+  if (!Array.isArray(configured)) return [];
+  return [
+    ...new Set(
+      configured.flatMap((value) =>
+        typeof value === "string" && value.trim() ? [value.trim()] : [],
+      ),
+    ),
+  ].sort();
+}
+
 /**
  * The recorded workspace members from `pnpm-workspace.yaml` (the source of truth),
  * each augmented with the `tags` read back from its `package.json`. This is what
@@ -314,6 +327,38 @@ export function recordedPackages(projectRoot: string = resolveRepoRoot()): Recor
   return out.sort((a, b) => a.path.localeCompare(b.path));
 }
 
+/**
+ * Absolute directories for a workspace package and its transitive runtime
+ * workspace dependencies. Dependency edges come from package manifests; external
+ * packages are ignored. Returns `[]` when `packageName` is not a workspace member.
+ */
+export function workspaceDependencyDirectories(
+  packageName: string,
+  projectRoot: string = resolveRepoRoot(),
+): string[] {
+  const packages = new Map<string, { dir: string; manifest: Record<string, unknown> }>();
+  for (const pkg of recordedPackages(projectRoot)) {
+    const manifest = readPackageManifest(pkg.dir);
+    if (!manifest || typeof manifest.name !== "string") continue;
+    packages.set(manifest.name, { dir: pkg.dir, manifest });
+  }
+  if (!packages.has(packageName)) return [];
+
+  const directories = new Set<string>();
+  const visit = (name: string): void => {
+    const pkg = packages.get(name);
+    if (!pkg || directories.has(pkg.dir)) return;
+    directories.add(pkg.dir);
+    for (const field of ["dependencies", "optionalDependencies", "peerDependencies"] as const) {
+      const dependencies = pkg.manifest[field];
+      if (!object.isRecord(dependencies)) continue;
+      for (const dependency of Object.keys(dependencies)) visit(dependency);
+    }
+  };
+  visit(packageName);
+  return [...directories].sort();
+}
+
 /**
  * The configured roots recorded in the root manifest. Older workspaces without
  * that field fall back to the distinct first segment of every recorded member,

package/src/project-js.ts

@@ -15,7 +15,7 @@ import { type IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { BuildWorkflow } from "projen/lib/build";
 import { AutoMerge } from "projen/lib/github";
-import { JobPermission, type JobStep, type Triggers } from "projen/lib/github/workflows-model";
+import { JobPermission, type JobStep } from "projen/lib/github/workflows-model";
 import type { ReleaseProjectOptions } from "projen/lib/release";
 import { mixin } from "..";
 import { generateBarrels } from "./barrels.ts";
@@ -44,12 +44,11 @@ import { PROJEN_VERSION } from "./projen-version.ts";
 import { applyCompiledPublish } from "./publish.ts";
 import {
   DBXToolsReleaseCatalog,
-  type DBXToolsVersioningMode,
   type ExternalReleaseProjectRegistration,
   type ReleaseDependencyInput,
   type ReleaseUnitRule,
 } from "./release-catalog.ts";
-import { DBXToolsRelease, type ReleaseDocsOptions, type ReleaseSummaryOptions } from "./release.ts";
+import { DBXToolsRelease, type ReleaseDocsOptions } from "./release.ts";
 import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
 import { DBXToolsRootTsconfig } from "./tsconfig.ts";
 import { DBXToolsVsCode } from "./vscode.ts";
@@ -385,7 +384,7 @@ const PRETTIER_SETTINGS: javascript.PrettierSettings = {
 
 export { PROJEN_VERSION } from "./projen-version.ts";
 
-/** SPDX license shared by generated JavaScript, Python, and Rust packages. */
+/** SPDX license shared by generated JavaScript and Python packages. */
 export const DBX_TOOLS_LICENSE = "Apache-2.0";
 
 /**
@@ -626,20 +625,12 @@ export type DBXToolsJavaScriptProjectOptions = CommonProjectOptions &
     readonly releasePythonRoot?: string;
     /** Repository task names run during local release preparation before publication. */
     readonly releaseValidationTasks?: readonly string[];
-    /** Optional AI-generated release summary. Defaults to enabled. */
-    readonly releaseSummary?: boolean | ReleaseSummaryOptions;
-    /** Existing source branch safely fast-forwarded after an independent release. */
-    readonly releaseSyncBranch?: string | false;
     /** Set to `false` to omit normal npm workspace publication. */
     readonly nodeRelease?: boolean;
     /** Unified dbx-tools release workflow, or no release surface. Defaults to `dbx-tools`. */
     readonly releaseMode?: DBXToolsReleaseMode;
-    /** Package version ownership mode. Defaults to `fixed`. */
-    readonly versioningMode?: DBXToolsVersioningMode;
     /** Explicit stable release-unit grouping rules. */
     readonly releaseUnits?: readonly ReleaseUnitRule[];
-    /** Commit before the first independent Release Please history. */
-    readonly releaseBootstrapSha?: string;
     /** Publishable workspace members synthesized outside the attached project tree. */
     readonly externalReleaseProjects?: readonly ExternalReleaseProjectRegistration[];
     /** Prefix for generated release tags. Defaults to `v`. */
@@ -723,10 +714,8 @@ export class DBXToolsNodeProject
     // (its build phase installs with pnpm and reads catalog + `allowBuilds`).
     pnpmWorkspace.attachWorkspaceFile(this);
     this.releaseCatalog = new DBXToolsReleaseCatalog(this, {
-      mode: options.versioningMode,
       units: options.releaseUnits,
       externalProjects: options.externalReleaseProjects,
-      bootstrapSha: options.releaseBootstrapSha,
     });
     registerJavaScriptReleaseProject(this);
     this.package.addField("version", () => this.releaseCatalog.versionFor(this));
@@ -862,10 +851,8 @@ export class DBXToolsTypeScriptProject
       (parent instanceof DBXToolsNodeProject || parent instanceof DBXToolsTypeScriptProject)
         ? parent.releaseCatalog
         : new DBXToolsReleaseCatalog(this, {
-            mode: options.versioningMode,
             units: options.releaseUnits,
             externalProjects: options.externalReleaseProjects,
-            bootstrapSha: options.releaseBootstrapSha,
           });
     // Pairs with `jsx` in SHARED_COMPILER_OPTIONS: projen's default `include` is
     // `src/**/*.ts` only, which silently omits a `.tsx` file from the program
@@ -937,35 +924,7 @@ function configureBuildWorkflow(
   });
   validation.exec("bunx projen default");
   validation.exec("bun run compile");
-  const configured = {
-    ...options.buildWorkflowOptions,
-    ...(!options.buildWorkflowOptions?.workflowTriggers &&
-    project.releaseCatalog.mode === "independent"
-      ? {
-          workflowTriggers: {
-            pullRequest: {
-              types: ["opened", "synchronize", "reopened", "closed"],
-              paths: [
-                "**",
-                "!.projen/release-units.json",
-                "!.release-please-manifest.json",
-                "!.release-units/**",
-                "!.release-notes/**",
-                "!docs/releases/**",
-                "!Cargo.lock",
-                "!**/Cargo.toml",
-                "!**/package.json",
-                "!**/pyproject.toml",
-                "!**/index.ts",
-                "!packages/js/node/rust-binary/src/_release-binaries.ts",
-                "!packages/js/node/appkit-graphiti/src/_python-runtime.ts",
-              ],
-            },
-            workflowDispatch: {},
-          } satisfies Triggers,
-        }
-      : {}),
-  };
+  const configured = { ...options.buildWorkflowOptions };
   const compatibility = nodeWorkflowCompatibility(project);
   const configuredRunner = configured.runsOn !== undefined || configured.runsOnGroup !== undefined;
   const workflow = new BuildWorkflow(project, {
@@ -1363,7 +1322,7 @@ class PublishedPackageDescriptionValidation extends Component {
  * fail with ERR_MODULE_NOT_FOUND after such an update. bun runs the `.ts`
  * directly (no tsx, no build step).
  */
-export function taskScript(_project: javascript.NodeProject, script: string, args = ""): string {
+export function taskScript(_project: Project, script: string, args = ""): string {
   const scriptPath = toPosix(join("node_modules", "@dbx-tools", "projen", "tasks", script));
   return args ? `bun ${scriptPath} ${args}` : `bun ${scriptPath}`;
 }
@@ -1619,8 +1578,6 @@ function initProject(
       docs: options.releaseDocs,
       pythonRoot: options.releasePythonRoot,
       validationTasks: options.releaseValidationTasks,
-      summary: options.releaseSummary,
-      syncBranch: options.releaseSyncBranch,
     });
   }
 }

package/src/project-predicate.ts

@@ -33,8 +33,7 @@ export function isDBXToolsProject(): Predicate<IConstruct, DBXToolsProject> {
   return isProject().and(
     (project): project is DBXToolsProject =>
       (project as Partial<DBXToolsProject>).language === "javascript" ||
-      (project as Partial<DBXToolsProject>).language === "python" ||
-      (project as Partial<DBXToolsProject>).language === "rust",
+      (project as Partial<DBXToolsProject>).language === "python",
   );
 }