@dbx-tools/projen 0.6.40 → 0.6.41

package/index.ts

@@ -3,6 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export * as barrels from "./src/barrels.ts";
+export * as bunApp from "./src/bun-app.ts";
 export * as clean from "./src/clean.ts";
 export * as codegen from "./src/codegen.ts";
 export * as dbxToolsConfig from "./src/dbx-tools-config.ts";
@@ -20,7 +21,6 @@ export * as release from "./src/release.ts";
 export * as scaffold from "./src/scaffold.ts";
 export * as tags from "./src/tags.ts";
 export * as tsconfig from "./src/tsconfig.ts";
-export * as vite from "./src/vite.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
 export { DBXToolsConfig } from "./src/dbx-tools-config.ts";
@@ -41,6 +41,6 @@ export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.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 { DEFAULT_VITE_OVERRIDES, ViteConfigFile } from "./src/vite.ts";
+export { BUN_DEV_OVERRIDE, BUN_BUILD_OVERRIDE, BUN_APP_OVERRIDES, BunfigFile, BunDevServerFile, BunBuildFile } from "./src/bun-app.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
 export type { IgnoreGroupOptions } from "./src/watch.ts";

package/package.json

@@ -1,5 +1,22 @@
 {
   "name": "@dbx-tools/projen",
+  "scripts": {
+    "build": "projen build",
+    "bump": "projen bump",
+    "clobber": "projen clobber",
+    "compile": "projen compile",
+    "default": "projen default",
+    "demo": "projen demo",
+    "eject": "projen eject",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "test": "projen test",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
   "devDependencies": {
     "@types/node": "^24.6.0",
     "constructs": "^10.0.0",
@@ -23,6 +40,7 @@
     "tsx": "^4.23.0",
     "yaml": "^2.9.0"
   },
+  "pnpm": {},
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
@@ -32,7 +50,8 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.40",
+  "version": "0.6.41",
+  "packageManager": "pnpm@10.33.0",
   "types": "index.ts",
   "type": "module",
   "exports": {
@@ -44,22 +63,5 @@
     "src",
     "tasks"
   ],
-  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\".",
-  "scripts": {
-    "build": "projen build",
-    "bump": "projen bump",
-    "clobber": "projen clobber",
-    "compile": "projen compile",
-    "default": "projen default",
-    "demo": "projen demo",
-    "eject": "projen eject",
-    "package": "projen package",
-    "post-compile": "projen post-compile",
-    "post-upgrade": "projen post-upgrade",
-    "pre-compile": "projen pre-compile",
-    "test": "projen test",
-    "upgrade": "projen upgrade",
-    "watch": "projen watch",
-    "projen": "projen"
-  }
-}
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\"."
+}

package/src/bun-app.ts

@@ -0,0 +1,164 @@
+/**
+ * Bun browser-app scaffolding as first-class projen file components.
+ *
+ * Replaces the old Vite toolchain (`vite.ts`). An `app`-tagged package gets three
+ * generated, read-only files that stand in for `vite dev` / `vite build`:
+ *
+ * - {@link BunfigFile} - `bunfig.toml` wiring `bun-plugin-tailwind` into both the
+ *   dev server (`[serve.static]`) and `Bun.build` (`[build]`) so Tailwind v4's
+ *   `@import "tailwindcss"` + `@source` directives compile with no separate CLI.
+ * - {@link BunDevServerFile} - `dev.ts`: a `Bun.serve()` fullstack dev server that
+ *   imports `index.html` and serves the SPA with React hot module reloading.
+ * - {@link BunBuildFile} - `build.ts`: a `Bun.build()` production bundle of
+ *   `index.html` (the `bun-plugin-tailwind` plugin must run through the JS API,
+ *   NOT the `bun build` CLI, which does not load it).
+ *
+ * Each file supports an unmanaged OVERRIDE beside it (`bunfig.override.toml`,
+ * `bun-dev.override.ts`, `bun-build.override.ts`): the dev/build scripts import
+ * the override's default export and merge it over the generated options, so a
+ * package tweaks its server/bundle WITHOUT editing the projen-owned file - the
+ * same escape hatch the Vite generator offered via `vite.config.override.*`.
+ *
+ * bun runs these `.ts` files directly. Being package-ROOT files (not under
+ * `src/`), they are outside the package's `tsconfig` include, so their `Bun.*`
+ * usage never trips the `app` package's DOM-only `compile`.
+ */
+import { type Project, TextFile } from "projen";
+
+/** Unmanaged dev-server override module, merged over the generated options if present. */
+export const BUN_DEV_OVERRIDE = "bun-dev.override.ts";
+/** Unmanaged build override module, merged over the generated options if present. */
+export const BUN_BUILD_OVERRIDE = "bun-build.override.ts";
+/** Unmanaged bunfig override (documented; merging TOML is left to the user). */
+export const BUN_APP_OVERRIDES = ["bunfig.override.toml", BUN_DEV_OVERRIDE, BUN_BUILD_OVERRIDE];
+
+/**
+ * Root `bunfig.toml`: pin bun's HOISTED linker workspace-wide.
+ *
+ * bun's default (isolated) linker instantiates a peer dependency once PER
+ * distinct peer context, so a package with many peers (`@mastra/*`) resolves to
+ * two peer-hash variants of the SAME `@mastra/core` version - and TypeScript then
+ * rejects passing a value built against one to an API typed by the other
+ * ("separate declarations of a private property"). The hoisted linker de-dupes to
+ * a single flat copy (npm-style), which is what keeps identity-based singletons
+ * (AppKit `CacheManager`, Mastra classes, one React) coherent - the same coherence
+ * the old cross-workspace `.pnpmfile.cjs` bridge used to guarantee.
+ */
+export class RootBunfigFile extends TextFile {
+  constructor(project: Project) {
+    super(project, "bunfig.toml", {
+      marker: false,
+      readonly: true,
+      lines: [
+        '# ~~ Generated by projen. To modify, edit .projenrc.ts and run "bunx projen".',
+        "# Hoisted (flat) node_modules so a peer dep like @mastra/core resolves to ONE",
+        "# copy - the isolated default splits it into peer-hash variants and breaks",
+        "# identity-based singletons + cross-package types.",
+        "[install]",
+        'linker = "hoisted"',
+        "",
+      ],
+    });
+  }
+}
+
+/**
+ * `bunfig.toml`: wire `bun-plugin-tailwind` into the DEV SERVER.
+ *
+ * Only `[serve.static]` is set - that is the one config bun reads for plugins. The
+ * `bun build` CLI does NOT load `bunfig.toml` plugins (a documented limitation),
+ * so the production build goes through `Bun.build()`'s JS API in `build.ts`, which
+ * passes the plugin directly. A `[build]` section here would be dead config that
+ * falsely implies `bun build ./index.html` applies Tailwind, so it is omitted.
+ */
+export class BunfigFile extends TextFile {
+  constructor(project: Project) {
+    super(project, "bunfig.toml", {
+      marker: true,
+      readonly: true,
+      lines: [
+        "# Tailwind v4 for the dev server (Bun.serve reads [serve.static] plugins).",
+        "# Production build applies the plugin via Bun.build's API in build.ts - the",
+        "# `bun build` CLI does not load bunfig plugins, so there is no [build] here.",
+        "[serve.static]",
+        'plugins = ["bun-plugin-tailwind"]',
+        "",
+      ],
+    });
+  }
+}
+
+/** `dev.ts`: a `Bun.serve()` fullstack dev server with React HMR. */
+export class BunDevServerFile extends TextFile {
+  constructor(project: Project) {
+    super(project, "dev.ts", {
+      marker: true,
+      readonly: true,
+      lines: String.raw`
+import { existsSync } from "node:fs";
+import index from "./index.html";
+
+// Unmanaged override (${BUN_DEV_OVERRIDE}): its default export is merged over the
+// generated serve options - later wins - so a package tweaks the dev server
+// without editing this generated file.
+let options: Bun.ServeFunctionOptions<unknown, {}> = {
+  port: Number(process.env.PORT ?? 5173),
+  development: { hmr: true, console: true },
+  routes: { "/*": index },
+};
+
+const overrideUrl = new URL("./${BUN_DEV_OVERRIDE}", import.meta.url);
+if (existsSync(overrideUrl)) {
+  const mod = await import(overrideUrl.href);
+  const override = typeof mod.default === "function" ? await mod.default() : mod.default;
+  options = { ...options, ...override };
+}
+
+const server = Bun.serve(options);
+console.log("dev server running at " + server.url.href);
+`
+        .trimStart()
+        .split("\n"),
+    });
+  }
+}
+
+/** `build.ts`: a `Bun.build()` production bundle (Tailwind via the plugin API). */
+export class BunBuildFile extends TextFile {
+  constructor(project: Project) {
+    super(project, "build.ts", {
+      marker: true,
+      readonly: true,
+      lines: String.raw`
+import { existsSync } from "node:fs";
+import tailwind from "bun-plugin-tailwind";
+
+// Unmanaged override (${BUN_BUILD_OVERRIDE}): its default export is merged over
+// the generated build options - later wins.
+let options: Bun.BuildConfig = {
+  entrypoints: ["./index.html"],
+  outdir: "./dist",
+  minify: true,
+  sourcemap: "linked",
+  plugins: [tailwind],
+};
+
+const overrideUrl = new URL("./${BUN_BUILD_OVERRIDE}", import.meta.url);
+if (existsSync(overrideUrl)) {
+  const mod = await import(overrideUrl.href);
+  const override = typeof mod.default === "function" ? await mod.default() : mod.default;
+  options = { ...options, ...override, plugins: [...(options.plugins ?? []), ...(override.plugins ?? [])] };
+}
+
+const result = await Bun.build(options);
+if (!result.success) {
+  for (const message of result.logs) console.error(message);
+  process.exit(1);
+}
+console.log("built " + result.outputs.length + " files to " + options.outdir);
+`
+        .trimStart()
+        .split("\n"),
+    });
+  }
+}

package/src/packages.ts

@@ -85,18 +85,20 @@ function nestingTagsFromSegments(segments: readonly string[]): string[] {
 /** Matches a barrel `index.<ext>` (as a basename or a posix path tail). */
 const BARREL_RE = /(^|\/)index\.(ts|tsx|js|jsx|mjs|cjs)$/;
 
-/** Basenames this toolchain generates (projen manifests/tsconfigs + vite config). */
+/** Basenames this toolchain generates (projen manifests/tsconfigs + bun app scaffolding). */
 const GENERATED_BASENAMES = new Set([
   "package.json",
   "tsconfig.json",
   "tsconfig.dev.json",
-  "vite.config.ts",
+  "bunfig.toml",
+  "dev.ts",
+  "build.ts",
 ]);
 
 /**
  * True if the file matches the watcher's generated-file heuristic: projen manifest
- * basenames, package-root barrels (`index.ts`), vite config, or declaration files.
- * Other read-only toolchain output (e.g. openapi artifacts) is not covered here.
+ * basenames, package-root barrels (`index.ts`), bun app scaffolding, or declaration
+ * files. Other read-only toolchain output (e.g. openapi artifacts) is not covered here.
  */
 export function isGeneratedFile(file: string): boolean {
   const base = file.split(sep).pop() ?? "";

package/src/pnpm-workspace.ts

@@ -67,8 +67,8 @@ const DEFAULT_CATALOG: Catalog = {
   "react-dom": "^19.2.4",
   "@types/react": "^19.2.2",
   "@types/react-dom": "^19.2.2",
-  vite: "^7.1.14",
-  "@vitejs/plugin-react": "^5.0.4",
+  // Tailwind v4 compiler for bun's dev server + `Bun.build` (the `app` tag).
+  "bun-plugin-tailwind": "^0.1.2",
   "@types/node": "^24.6.0",
   "@types/express": "^5.0.5",
   express: "^5.1.0",
@@ -95,14 +95,26 @@ const DEFAULT_CATALOG: Catalog = {
 };
 
 /**
- * Build allowances every workspace needs, because the engine itself is what
- * drags each one in: `esbuild` arrives with tsx (so it has to be built for any
- * task to run at all), and `unrs-resolver` is the native binding behind
- * `eslint-import-resolver-typescript`, which projen's eslint component adds to
- * every generated project. Leaving either unlisted greets a freshly bootstrapped
- * workspace with pnpm's "Ignored build scripts" warning on its first install.
+ * Build allowances every workspace needs. These matter for the Databricks Apps
+ * pnpm install (which reads `pnpm-workspace.yaml`) and for bun (mirrored into the
+ * root `package.json` `trustedDependencies`): `unrs-resolver` is the native
+ * binding behind `eslint-import-resolver-typescript`, which projen's eslint
+ * component adds to every generated project, and `esbuild` is still pulled in by
+ * parts of the toolchain. Leaving either unlisted greets a freshly bootstrapped
+ * workspace with an "Ignored build scripts" warning on its first install.
  */
-const DEFAULT_ALLOW_BUILDS: AllowBuilds = { esbuild: true, "unrs-resolver": true };
+const DEFAULT_ALLOW_BUILDS: AllowBuilds = {
+  esbuild: true,
+  "unrs-resolver": true,
+  // The `bun` npm package (a peer of `bun-plugin-tailwind`) ships a `bun.exe`
+  // placeholder and downloads the real platform binary in its postinstall. Left
+  // unbuilt, that `.exe` shim lands in `node_modules/.bin/bun` and makes projen's
+  // dax PATH walk `spawn ENOEXEC` on macOS/Linux, breaking EVERY task. Building it
+  // replaces the shim with a runnable binary.
+  bun: true,
+  // fastembed's native ONNX runtime (via `@mastra/fastembed`).
+  "onnxruntime-node": true,
+};
 
 /**
  * pnpm settings this engine applies to every workspace, beyond members, catalog,
@@ -207,17 +219,66 @@ export class PnpmWorkspaceState {
   }
 
   /**
-   * Fill `packages` from the project's attached subprojects.
+   * Emit `pnpm-workspace.yaml` directly.
+   *
+   * Under bun, projen's base `NodePackage` never runs `configurePnpm` (that call
+   * site is gated to `packageManager === PNPM`), so no `PnpmWorkspaceYaml`
+   * component is created. This engine still needs the file for the Databricks
+   * Apps platform, whose build phase installs with pnpm and reads the catalog +
+   * `allowBuilds`. The native component is just a `YamlFile` fed by a lazy
+   * `toJson(options)`, so constructing it directly (with the same options object
+   * whose arrays/objects are mutated in place up to synth) produces the identical
+   * file. Idempotent: skips if a `pnpm-workspace.yaml` component already exists
+   * (e.g. a future projen that DOES create it under bun).
+   */
+  public attachWorkspaceFile(project: Project): void {
+    const exists = project.files.some((file) => file.path === "pnpm-workspace.yaml");
+    if (!exists) new javascript.PnpmWorkspaceYaml(project, this.options);
+  }
+
+  /**
+   * Fill `packages` from the project's attached subprojects, then mirror the
+   * workspace shape into the root `package.json` so bun (which reads
+   * `workspaces`/`catalog` from the manifest, not `pnpm-workspace.yaml`) resolves
+   * the same members + catalog. `trustedDependencies` (bun's `allowBuilds` analog)
+   * is rendered by projen from its own allowlist, so the build allowances are
+   * routed there via `addAllowedScripts`.
    *
    * Called from the root's `preSynthesize`, which is the earliest point every
    * discovered package is attached - the list cannot be captured at
    * construction, since the root's scan runs after it.
    */
-  public resolveMembers(project: Project): void {
+  public resolveMembers(project: Project, extraMembers: readonly string[] = []): void {
     const members = project.subprojects
       .map((sub) => toPosix(relative(project.outdir, sub.outdir)))
       .filter(Boolean);
+    // `extraMembers` are workspace siblings NOT attached as subprojects (e.g. the
+    // self-synthesizing `projen/` engine), so they must be added explicitly.
+    const all = [...members, ...extraMembers.map((m) => toPosix(m)).filter(Boolean)];
     // Replaces the array's CONTENTS, keeping the reference projen captured.
-    this.packages.splice(0, this.packages.length, ...new Set(members.sort()));
+    this.packages.splice(0, this.packages.length, ...new Set(all.sort()));
+    this.mirrorToPackageJson(project);
+  }
+
+  /**
+   * Write `workspaces` / `catalog` / `overrides` into the root `package.json`
+   * (bun's source of truth) and feed the build allowances into projen's
+   * allowlist so bun's native `trustedDependencies` renders them.
+   */
+  private mirrorToPackageJson(project: Project): void {
+    const pkg = (project as { package?: javascript.NodePackage }).package;
+    if (!pkg) return;
+    pkg.addField("workspaces", [...this.packages]);
+    if (Object.keys(this.catalog).length > 0) {
+      pkg.addField("catalog", { ...this.catalog });
+    }
+    if (Object.keys(this.overrides).length > 0) {
+      pkg.addField("overrides", { ...this.overrides });
+    }
+    // projen renders bun's `trustedDependencies` from `allowedScripts`.
+    const allowed = Object.entries(this.allowBuilds)
+      .filter(([, on]) => on)
+      .map(([name]) => name);
+    if (allowed.length > 0) pkg.addAllowedScripts(...allowed);
   }
 }

package/src/project.ts

@@ -22,7 +22,13 @@ import { applyCompiledPublish } from "./publish.ts";
 import { DBXToolsRelease, type StandaloneRelease } from "./release.ts";
 import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
 import { DBXToolsRootTsconfig } from "./tsconfig.ts";
-import { DEFAULT_VITE_OVERRIDES, ViteConfigFile } from "./vite.ts";
+import {
+  BUN_APP_OVERRIDES,
+  BunBuildFile,
+  BunDevServerFile,
+  BunfigFile,
+  RootBunfigFile,
+} from "./bun-app.ts";
 import { DBXToolsVsCode } from "./vscode.ts";
 import {
   DEFAULT_PACKAGE_ROOTS,
@@ -147,11 +153,11 @@ function applyRepository(project: javascript.NodeProject, override?: string): vo
   });
 }
 
-/** Inherit a parent's package manager, else pnpm. */
+/** Inherit a parent's package manager, else bun. */
 function inheritedPackageManager(
   parent: javascript.NodeProject | undefined,
 ): javascript.NodePackageManager {
-  return parent?.package.packageManager ?? javascript.NodePackageManager.PNPM;
+  return parent?.package.packageManager ?? javascript.NodePackageManager.BUN;
 }
 
 /** Override a package's generated tsconfig `compilerOptions` (later-wins per key). */
@@ -328,12 +334,19 @@ export const PROJEN_VERSION = "^0.101.16";
 function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProjectOptions {
   const isRoot = options.parent === undefined;
   return {
-    packageManager: javascript.NodePackageManager.PNPM,
+    // Bun owns install/run/build/test locally and in CI. projen renders
+    // `bun install`/`bunx` and a native `trustedDependencies` field from this.
+    // The engine still emits `pnpm-workspace.yaml` itself (see
+    // {@link PnpmWorkspaceState}) for the Databricks Apps platform, whose build
+    // phase installs with pnpm - so a deployed app keeps its catalog + build
+    // allowances even though the local/CI manager is bun.
+    packageManager: javascript.NodePackageManager.BUN,
     // Pinned rather than left to projen's "latest": 0.101.16 is the first release
-    // whose `NodePackage` owns `pnpm-workspace.yaml` natively, and this engine
-    // writes that file itself ({@link DBXToolsPNPMWorkspace}). Floating would let
-    // an install cross that boundary silently, so the version the engine is known
-    // to co-exist with is stated here and bumped deliberately.
+    // whose `NodePackage` renders bun's `trustedDependencies` natively. Under bun,
+    // projen does NOT create the `pnpm-workspace.yaml` component itself (that call
+    // site is gated to pnpm), so the engine constructs it directly ({@link
+    // PnpmWorkspaceState}). Floating would let an install cross that boundary
+    // silently, so the co-tested version is stated here and bumped deliberately.
     projenVersion: PROJEN_VERSION,
     defaultReleaseBranch: "main",
     projenrcJs: false,
@@ -403,8 +416,8 @@ function copiedGitIgnoreOptions(
 /**
  * The engine's `TypeScriptProject` defaults - a superset of {@link defaultProjectOptions}.
  * A DBXTools TS project can itself be the ROOT (a standalone compiling root), so the
- * same parent-based root/child logic applies; this just layers on tsx/typescript and
- * disables sample code.
+ * same parent-based root/child logic applies; this just layers on typescript +
+ * bun types and disables sample code. No `tsx`: bun runs `.ts` directly.
  */
 function defaultTypeScriptProjectOptions(
   options: DBXToolsTypeScriptProjectOptions,
@@ -417,15 +430,16 @@ function defaultTypeScriptProjectOptions(
     // ESLint is configured once on the ROOT (see initProject) and lints the whole
     // tree, so packages don't emit their own config. A caller can still override.
     eslint: false,
-    devDeps: [...(base.devDeps ?? []), "tsx@^4.23.0", "typescript@^5.9.3"],
+    devDeps: [...(base.devDeps ?? []), "typescript@^5.9.3", "@types/bun@^1.3.14"],
     ...options,
     ...copiedGitIgnoreOptions(options),
   };
 }
 
-// Pinned to match the subproject defaults so pnpm resolves a single tsx/typescript
+// Pinned to match the subproject defaults so bun resolves a single typescript
 // across the workspace (a bare name -> `*` could pull a second, newer major).
-const DEV_DEPS_ROOT: string[] = ["tsx@^4.23.0", "typescript@^5.9.3"];
+// `@types/bun` gives the `Bun.*` globals the server/app tags now use.
+const DEV_DEPS_ROOT: string[] = ["typescript@^5.9.3", "@types/bun@^1.3.14"];
 
 /** Options for {@link DBXToolsNodeProject} (the monorepo root). */
 export interface DBXToolsProjectOptions
@@ -478,13 +492,22 @@ export interface DBXToolsProjectOptions
    * `@dbx-tools/projen` engine in `projen/`, tagged `projen-v*`).
    */
   readonly standaloneReleases?: readonly StandaloneRelease[];
+  /**
+   * Extra workspace member paths (repo-relative, POSIX) to list in the workspace
+   * config ALONGSIDE the discovered `packageRoots` members - for a package that
+   * is synthesized by its OWN `.projenrc.ts` (so it isn't a root subproject) but
+   * should still resolve as a workspace sibling. The `@dbx-tools/projen` engine in
+   * `projen/` is the case: it synthesizes itself (avoiding a dogfooding cycle) yet
+   * is a member of the single bun workspace, so the root links it from source.
+   */
+  readonly extraWorkspaceMembers?: readonly string[];
 }
 
 /** Options for {@link DBXToolsTypeScriptProject} (a package, or a compiling root). */
 export interface DBXToolsTypeScriptProjectOptions
   extends Partial<typescript.TypeScriptProjectOptions>, DBXToolsProjectOptions {
-  /** Emit a projen-owned `vite.config.ts`. */
-  readonly viteConfig?: boolean;
+  /** Emit the projen-owned bun app scaffolding (`bunfig.toml`/`dev.ts`/`build.ts`). */
+  readonly bunApp?: boolean;
 }
 
 /**
@@ -498,6 +521,7 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
   pnpmWorkspace?: PnpmWorkspaceState;
   rootTsconfig?: DBXToolsRootTsconfig;
   vsCode?: DBXToolsVsCode;
+  private readonly extraWorkspaceMembers: readonly string[];
 
   constructor(options: DBXToolsProjectOptions = {}) {
     const { name, scope } = resolveIdentity(options);
@@ -505,11 +529,12 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
       options.release && options.releaseTrigger === undefined
         ? { releaseTrigger: ReleaseTrigger.tagged({ tags: ["v*"] }) }
         : {};
-    // Before `super`, since `NodePackage` creates the native
-    // `javascript.PnpmWorkspaceYaml` from these options inside the base
-    // constructor and `this` is unreachable until it returns. Given nothing,
-    // projen writes no workspace file at all - it never derives members from
-    // `project.subprojects` (see `pnpm-workspace.ts`).
+    // Holds the workspace state (members/catalog/allowBuilds/overrides). Under
+    // bun, projen's base constructor does NOT create the `PnpmWorkspaceYaml`
+    // component (its `configurePnpm` call site is gated to pnpm), so this state's
+    // options are wired into a directly-constructed component below - AND mirrored
+    // into `package.json` (`workspaces`/`catalog`) for bun to read. The
+    // `pnpm-workspace.yaml` is still emitted for the Databricks Apps pnpm install.
     const pnpmWorkspace = new PnpmWorkspaceState(options);
     super({
       ...defaultProjectOptions(options),
@@ -522,7 +547,12 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
     });
 
     this.pnpmWorkspace = pnpmWorkspace;
+    // Emit `pnpm-workspace.yaml` ourselves: under bun projen skips the native
+    // component, but the file is still required by the Databricks Apps platform
+    // (its build phase installs with pnpm and reads catalog + `allowBuilds`).
+    pnpmWorkspace.attachWorkspaceFile(this);
     this.scope = scope;
+    this.extraWorkspaceMembers = options.extraWorkspaceMembers ?? [];
     this.dbxToolsConfig = new DBXToolsConfig(this, options);
     initProject(this, options);
   }
@@ -531,7 +561,8 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
     super.preSynthesize();
     // Members come from the attached subprojects, which the root's scan appends
     // after construction - so the list is filled here, not in the constructor.
-    this.pnpmWorkspace?.resolveMembers(this);
+    // `extraWorkspaceMembers` adds self-synthesizing siblings (e.g. `projen/`).
+    this.pnpmWorkspace?.resolveMembers(this, this.extraWorkspaceMembers);
     preSynthesizeProject(this);
   }
 }
@@ -588,8 +619,19 @@ export class DBXToolsTypeScriptProject
       "./package.json": "./package.json",
     });
     addPackageFiles(this, "index.ts", "src");
-    this.testTask.exec("tsx --test 'test/**/*.test.ts'");
-    if (options.viteConfig ?? false) new ViteConfigFile(this);
+    // `bun test` intercepts `node:test` (the suites keep using node:test) and
+    // runs it with bun's own fast runner. Args are FILTERS, not globs; a bare
+    // directory auto-discovers `*.test.ts` recursively. But `bun test` EXITS 1
+    // when it matches no files (unlike the old `tsx --test 'glob'`, which was a
+    // no-op), so guard it: only invoke when a `*.test.ts` exists, else succeed.
+    this.testTask.exec(
+      'find test -name "*.test.ts" 2>/dev/null | grep -q . && bun test test || true',
+    );
+    if (options.bunApp ?? false) {
+      new BunfigFile(this);
+      new BunDevServerFile(this);
+      new BunBuildFile(this);
+    }
     initProject(this, options);
   }
 
@@ -746,16 +788,17 @@ function registerRootTasks(project: javascript.NodeProject): void {
 }
 
 /**
- * `tsx node_modules/@dbx-tools/projen/tasks/<script>` command for a projen task.
+ * `bun node_modules/@dbx-tools/projen/tasks/<script>` command for a projen task.
  *
- * Use the stable package symlink, never `require.resolve()`'s physical pnpm
- * store path. A later install can change the peer-hash directory while leaving
- * the package symlink valid; persisting the physical path made every generated
- * task fail with ERR_MODULE_NOT_FOUND after such an update.
+ * Use the stable package symlink, never `require.resolve()`'s physical store
+ * path. A later install can change the peer-hash directory while leaving the
+ * package symlink valid; persisting the physical path made every generated task
+ * 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 {
   const scriptPath = toPosix(join("node_modules", "@dbx-tools", "projen", "tasks", script));
-  return args ? `tsx ${scriptPath} ${args}` : `tsx ${scriptPath}`;
+  return args ? `bun ${scriptPath} ${args}` : `bun ${scriptPath}`;
 }
 
 /**
@@ -788,20 +831,21 @@ function initProject(
   project.package.file.readonly = false;
 
   // NodeProject has no built-in TS projenrc support (unlike TypeScriptProject), so
-  // wire `.projenrc.ts` through the tsx runner - this also populates the `default`
-  // task that `pnpm exec projen` runs (and that the `sync` watcher invokes to re-synth).
+  // wire `.projenrc.ts` through a runner - this also populates the `default` task
+  // that `bunx projen` runs (and that the `sync` watcher invokes to re-synth).
+  // The runner choice is immaterial since the exec is reset to plain `bun` below;
+  // `nodejs()` avoids declaring a `ts-node`/`tsx` dependency.
   new typescript.ProjenrcTs(project, {
-    runner: typescript.TypeScriptRunner.tsx(),
+    runner: typescript.TypeScriptRunner.nodejs(),
   });
-  // ProjenrcTs wraps that step in `npx -y -p tsx -c "tsx .projenrc.ts"` because the
-  // tsx runner declares a `tsx` dependency (so it runs even uninstalled). tsx IS a
-  // devDep here, so that wrapper is not merely redundant but harmful: `npx -c` exports
-  // `npm_config_call="tsx .projenrc.ts"` into the environment, which every nested
-  // `pnpm` inherits and then dies on ("Failed parsing JSON config key call"), failing
-  // each subproject's post-synth install; the same `npx`/`npm` process also emits the
-  // "Unknown env config" warnings for pnpm's `catalog`/`@jsr:registry`/etc. Reset to a
-  // plain exec (tsx resolves from `node_modules/.bin`, which pnpm puts on PATH).
-  project.defaultTask?.reset("tsx .projenrc.ts");
+  // bun runs `.projenrc.ts` directly (native TS, no loader to register). Reset to
+  // a plain `bun` exec rather than any wrapper: the default task is spawned by
+  // nested installs/synths, and a wrapper that exported `npm_config_*` broke them.
+  project.defaultTask?.reset("bun .projenrc.ts");
+
+  // Pin bun's hoisted linker workspace-wide (see RootBunfigFile) so a peer dep
+  // resolves to one copy and singletons/types stay coherent.
+  new RootBunfigFile(project);
 
   // Only reached on a ROOT (early-returned above otherwise), so the root devDeps
   // always apply; the self-dep is added only when the engine is an installed pkg.
@@ -864,11 +908,12 @@ function initProject(
     eslint.addIgnorePattern(`${root}/openapi/**`);
     eslint.addIgnorePattern(`${root}/**/index.ts`);
   }
-  eslint.addIgnorePattern("**/vite.config.ts");
-  // The unmanaged vite overrides live at the package root, outside any `src/**`
-  // tsconfig include, so the type-aware parser cannot resolve them to a project.
-  // They are hand-authored (not generated), but ESLint still cannot parse them.
-  for (const override of DEFAULT_VITE_OVERRIDES) {
+  // The generated bun app scripts + unmanaged overrides live at the package root,
+  // outside any `src/**` tsconfig include, so the type-aware parser cannot resolve
+  // them to a project. ESLint still cannot parse them.
+  eslint.addIgnorePattern("**/dev.ts");
+  eslint.addIgnorePattern("**/build.ts");
+  for (const override of BUN_APP_OVERRIDES) {
     eslint.addIgnorePattern(`**/${override}`);
   }
   // Codegen packages declare `codegen.inputs` via mixins after construction; ignore