@dbx-tools/projen 0.6.46 → 0.6.48

package/README.md

@@ -70,6 +70,19 @@ Built-in tag mixins set runtime defaults for `shared`, `node`, `cli`, `server`,
 `ui`, and `openapi`. Repo-specific mixins layer package-specific dependencies,
 scripts, and generated files on top.
 
+A tag layers over a shared compiler floor every package gets at construction:
+ES2022 plus the web-platform globals available in every runtime, and deliberately
+no DOM lib and no Node types, so agnostic code stays isomorphic. The tags are what
+add an environment on top - `node` adds Node types, `ui` adds the DOM lib. That
+floor is also where `jsx` lives, for a reason worth knowing before moving it:
+packages resolve each other to SOURCE, so a consumer type-checks its dependency's
+files under its own tsconfig. The moment any package re-exports a `.tsx` module,
+every package that imports it - however far down the graph, whatever its tag -
+fails with `TS6142: ... but '--jsx' is not set`. Setting `jsx` per consumer is the
+wrong fix, since the consumer authors no JSX and cannot know a transitive
+dependency started to. The option is inert without JSX in the graph: it selects
+how JSX syntax compiles and adds no lib, global, or type dependency.
+
 ## Work With Package Discovery
 
 ```ts
@@ -94,9 +107,18 @@ barrels.generateBarrels();
 ```
 
 `generateCodegen()` reads `package.json` `codegen.inputs` and writes generated
-schema modules. `generateBarrels()` writes package-root `index.ts` barrels with
-module namespaces and flat unique type exports, returning the number that
-actually changed. A barrel whose export surface is unchanged is left untouched,
+schema modules. They are written read-only, and the root ESLint task runs with
+`--fix` (which fails on a read-only file), so each generated module is added to
+`ignorePatterns` at synth - named individually via `codegen.codegenModulePaths()`,
+never as a blanket `<package>/src/**`. A codegen package may hold hand-written
+modules beside its generated ones, and those must stay linted.
+
+`generateBarrels()` writes package-root `index.ts` barrels with module
+namespaces and flat unique type exports, returning the number that actually
+changed. A name two modules both declare is ambiguous and stays namespace-only —
+except when one of them is generated: the hand-written module is the curated view
+of the generated shape (`shared-genie`'s `genie-model.ts` extends its own
+codegen'd `dashboards.ts`), so it owns the name and stays hoisted. A barrel whose export surface is unchanged is left untouched,
 read-only bit included, so concurrent writers never collide over it. Every
 package is attempted even if one fails; the failures are re-thrown together as an
 `AggregateError` naming each package, rather than the first one abandoning the
@@ -167,13 +189,13 @@ file contract as the CLI.
 - `barrels` / `moduleExports` - public entrypoint generation.
 - `codegen` - `.d.ts` to zod schema generation.
 - `openapi` - tsoa/OpenAPI package generation.
-- `vite` / `tsconfig` / `vscode` - generated support files/components.
+- `bunApp` / `tsconfig` / `vscode` - generated support files/components.
 - `generated` / `clean` / `watch` / `scaffold` - read-only file stamping,
   cleanup, watchers, and synth orchestration.
 - `publish` - packaging and tag-based release helpers.
 - `engineRoot` - engine package root resolution for bootstrapped repos.
 
 The engine registers its commands as projen tasks on the workspace root, so run
-them with `pnpm run <task>` - `sync` (add `--watch`), `barrels`, `openapi`, and
+them with `bun run <task>` - `sync` (add `--watch`), `barrels`, `openapi`, and
 `clean`. [`@dbx-tools/cli`](../packages/cli/dbx-tools) is only needed to
 bootstrap a folder that has no `.projenrc.ts` or toolchain yet.

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "^0.6.40",
-    "@dbx-tools/path": "^0.6.40",
-    "@dbx-tools/shared-core": "^0.6.40",
+    "@dbx-tools/core": "0.6.48",
+    "@dbx-tools/path": "0.6.48",
+    "@dbx-tools/shared-core": "0.6.48",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -37,21 +37,17 @@
     "oxc-parser": "^0.90.0",
     "projen": "^0.101.16",
     "ts-to-zod": "^5.1.0",
-    "tsx": "^4.23.0",
     "yaml": "^2.9.0"
   },
-  "pnpm": {},
   "devEngines": {
     "packageManager": {
-      "name": "pnpm",
-      "version": ">=10",
+      "name": "bun",
       "onFail": "ignore"
     }
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.46",
-  "packageManager": "pnpm@10.33.0",
+  "version": "0.6.48",
   "types": "index.ts",
   "type": "module",
   "exports": {
@@ -63,5 +59,5 @@
     "src",
     "tasks"
   ],
-  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\"."
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
 }

package/src/barrels.ts

@@ -33,6 +33,15 @@
  * name stays namespace-only. Names that collide with a generated namespace, or
  * that a hand-authored `exports.ts` declares, are never hoisted (that file wins).
  *
+ * One collision is NOT ambiguous, though: a HAND-WRITTEN module and a GENERATED
+ * one (a codegen `src/` module, recognised by its do-not-edit banner) declaring
+ * the same name. The hand-written module is by definition the curated view of the
+ * generated shape - `shared-genie`'s `genie-model.ts` extends and re-exports its
+ * own generated `dashboards.ts` - so it WINS and its name is still hoisted.
+ * Treating that pair as ambiguous is what silently dropped `GenieMessage`,
+ * `GenieSpace`, and `MessageStatus` from the barrel the moment the two modules
+ * became siblings, breaking every consumer importing them by name.
+ *
  * The result gets a do-not-edit header + read-only bit (see `./generated`).
  */
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -40,7 +49,7 @@ import { join, relative } from "node:path";
 import { find } from "@dbx-tools/path";
 import { string } from "@dbx-tools/shared-core";
 import isIdentifier from "is-identifier";
-import { header, makeReadonly, makeWritable, type HeaderOpts } from "./generated.ts";
+import { header, isGenerated, makeReadonly, makeWritable, type HeaderOpts } from "./generated.ts";
 import { moduleExports, moduleStatements, type ModuleExport } from "./module-exports.ts";
 import { isModuleFile, toPosix, recordedPackages, repoRoot } from "./packages.ts";
 
@@ -140,8 +149,10 @@ function namespaceLines(content: string): { ns: string; modulePath: string }[] {
  * package's modules - `export type { ... }` for types, `export { ... }` for
  * non-function values (classes, consts, enums, …). `export function` names are
  * never hoisted; they stay namespace-only (`posixPath.toPosix`). A name declared
- * by two or more modules is ambiguous and left namespace-only. `suppress` names
- * (a hand-authored `exports.ts` surface) are never hoisted so that file stays
+ * by two or more modules is ambiguous and left namespace-only - UNLESS exactly one
+ * of them is hand-written and the rest are generated, in which case the
+ * hand-written module owns the name (see the module doc). `suppress` names (a
+ * hand-authored `exports.ts` surface) are never hoisted so that file stays
  * authoritative.
  */
 function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<string>): string {
@@ -157,17 +168,32 @@ function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<strin
   // Uniqueness is tallied over hoistable types AND values together - name ->
   // { count, owning module }. Functions are excluded from hoisting and from
   // this tally so they do not block a same-named type/class in another module.
-  const seen = new Map<string, { count: number; modulePath: string }>();
+  //
+  // A generated module never claims a name a hand-written sibling also declares:
+  // it is counted only while no hand-written module owns the name, and it yields
+  // ownership as soon as one does. So a curated re-export
+  // (`genie-model.ts`'s `GenieMessage`, extending generated `dashboards.ts`)
+  // stays hoisted, while two HAND-WRITTEN modules claiming one name are still
+  // ambiguous and stay namespace-only.
+  const seen = new Map<string, { count: number; modulePath: string; generated: boolean }>();
   const perModule = new Map<string, ModuleExport[]>();
   for (const { modulePath } of namespaces) {
-    const exports = moduleExports(join(pkgDir, modulePath.replace(/^\.\//, ""))).filter(
-      (e) => !e.isFunction,
-    );
+    const file = join(pkgDir, modulePath.replace(/^\.\//, ""));
+    const exports = moduleExports(file).filter((e) => !e.isFunction);
     perModule.set(modulePath, exports);
+    const generated = isGenerated(file);
     for (const { name } of exports) {
       const prior = seen.get(name);
-      if (prior) prior.count += 1;
-      else seen.set(name, { count: 1, modulePath });
+      if (!prior) {
+        seen.set(name, { count: 1, modulePath, generated });
+        continue;
+      }
+      // Hand-written beats generated, either direction, without counting as a clash.
+      if (prior.generated !== generated) {
+        if (prior.generated) seen.set(name, { count: 1, modulePath, generated });
+        continue;
+      }
+      prior.count += 1;
     }
   }
 

package/src/clean.ts

@@ -1,5 +1,5 @@
 /**
- * The `clean` task (`pnpm run clean`): enumerate the workspace's generated files (plus every
+ * The `clean` task (`bun run clean`): enumerate the workspace's generated files (plus every
  * `node_modules` directory) and delete a chosen subset. This is the pure filesystem
  * half - reusable enumerate/remove helpers; the task that drives them (argv `-y`, the
  * `@clack/prompts` multiselect picker with all preselected, the TTY guard) lives in
@@ -17,8 +17,8 @@
  * `.projenrc.ts` imports the engine by SOURCE path (relative into the repo, e.g.
  * `packages/node/projen/src/...`, or from an installed package such as
  * `@dbx-tools/projen`), so even after deleting every barrel, manifest, and
- * `.projen/*`, `pnpm exec projen` still rebuilds the whole tree. Removing `node_modules` additionally requires a
- * `pnpm install` first - the engine's runtime deps live there - so a clean that takes
+ * `.projen/*`, `bun run default` still rebuilds the whole tree. Removing `node_modules` additionally requires a
+ * `bun install` first - the engine's runtime deps live there - so a clean that takes
  * `node_modules` must be followed by reinstall, then re-synth.
  */
 import { existsSync, rmSync, statSync } from "node:fs";

package/src/codegen.ts

@@ -89,6 +89,25 @@ function parseInputArg(value: string): CodegenInput {
   return { source: value.slice(0, eq), name: value.slice(eq + 1) };
 }
 
+/**
+ * The `src/` modules a set of `codegen.inputs` specs will emit, as package-relative
+ * posix paths - WITHOUT resolving or reading any input.
+ *
+ * This exists so callers that only need to know WHICH files are generated (the
+ * ESLint ignore list, above all) can ask without running codegen. The output names
+ * are derived from the specs alone, so it is safe to call during synth, before
+ * `node_modules` is resolved and before any manifest has been written to disk -
+ * hence taking the specs rather than a directory to read them from.
+ *
+ * Naming a package's generated modules is strictly better than ignoring its whole
+ * `src/`: a codegen package may also hold HAND-WRITTEN modules (shared-genie
+ * generates `dashboards.ts` next to a hand-written `genie-model.ts`), and those
+ * must stay linted.
+ */
+export function codegenModulePaths(inputs: readonly string[]): string[] {
+  return inputs.map((input) => `src/${parseInputArg(input).name}.ts`);
+}
+
 /**
  * Resolve a codegen input to an absolute path. A `node_modules/...` source is
  * searched for in each `node_modules` from the consuming package up to the

package/src/generated.ts

@@ -10,6 +10,9 @@
  */
 import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 
+/** First line of every banner {@link header} builds. */
+const MARKER = "// GENERATED by";
+
 const READONLY = 0o444;
 const WRITABLE = 0o644;
 
@@ -46,12 +49,29 @@ export interface HeaderOpts {
 
 /** Build the do-not-edit banner (line comments, for TS/JS). */
 export function header(opts: HeaderOpts): string {
-  const lines = [`// GENERATED by ${opts.tool} - DO NOT EDIT.`];
+  const lines = [`${MARKER} ${opts.tool} - DO NOT EDIT.`];
   if (opts.source) lines.push(`// Regenerated from ${opts.source}.`);
   lines.push("// Hand edits are overwritten on the next watch; this file is read-only.");
   return `${lines.join("\n")}\n`;
 }
 
+/**
+ * True if the file exists and carries the do-not-edit banner {@link header}
+ * writes - i.e. a toolchain wrote it and a hand edit would be overwritten.
+ *
+ * Prefer this over {@link isReadonly} when the answer must survive a fresh
+ * clone: git tracks no read-only bit, so a generated file checked out before the
+ * first synth looks hand-authored by mode alone, while the banner is part of the
+ * committed content.
+ */
+export function isGenerated(file: string): boolean {
+  try {
+    return readFileSync(file, "utf8").startsWith(MARKER);
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Prepend the do-not-edit header to a file some tool just wrote (e.g. a
  * generated barrel `index.ts`), then set it read-only. Idempotent.
@@ -59,7 +79,7 @@ export function header(opts: HeaderOpts): string {
 export function stampGenerated(file: string, opts: HeaderOpts): void {
   makeWritable(file);
   const body = readFileSync(file, "utf8");
-  const next = body.startsWith("// GENERATED by") ? body : `${header(opts)}\n${body}`;
+  const next = body.startsWith(MARKER) ? body : `${header(opts)}\n${body}`;
   writeFileSync(file, next);
   makeReadonly(file);
 }

package/src/openapi.ts

@@ -16,7 +16,7 @@
  * OpenAPI client generator.
  *
  * `tsoa`, `typescript`, and `openapi-typescript` are loaded lazily (heavy, and only
- * needed for `pnpm run openapi`), so importing this module stays cheap. `tsoa` and
+ * needed for `bun run openapi`), so importing this module stays cheap. `tsoa` and
  * `typescript` are not engine dependencies at all - both are resolved out of the
  * consuming workspace, which is where they already live.
  */

package/src/project.ts

@@ -14,7 +14,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { ReleaseTrigger } from "projen/lib/release";
 import { generateBarrels } from "./barrels.ts";
-import { generateCodegen } from "./codegen.ts";
+import { codegenModulePaths, generateCodegen } from "./codegen.ts";
 import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
 import { resolvePkgRoot } from "./engine-root.ts";
 import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
@@ -172,7 +172,6 @@ export function applyCompilerOptions(
     if (value === undefined) continue;
     file.addOverride(`compilerOptions.${key}`, value);
   }
-  if (compilerOptions.jsx) pkg.tsconfig?.addInclude("src/**/*.tsx");
 }
 
 /**
@@ -287,6 +286,17 @@ export function srcModuleExports(pkg: javascript.NodeProject): Record<string, st
  * only: the specifier style is a property of the SOURCE, so a `ui` package (which
  * publishes source and is excluded from the compiled surface) still has to accept
  * and rewrite it.
+ *
+ * `jsx` is here for the same reason, and it is NOT a per-tag concern even though
+ * only React packages author `.tsx`. Packages resolve each other to SOURCE
+ * (`main: index.ts`), so a consumer type-checks its dependency's files under its
+ * OWN tsconfig: the moment any package re-exports a `.tsx` module, every package
+ * that imports it - however far down the graph, whatever its tag - fails with
+ * `TS6142: ... but '--jsx' is not set`. Setting it per consumer is the wrong fix
+ * (the consumer does not author JSX and has no way to know a transitive dependency
+ * started to), so the floor carries it. The option is inert for a package with no
+ * `.tsx` in its graph: it selects how JSX syntax COMPILES and adds no lib, no
+ * global, and no type dependency on its own.
  */
 const SHARED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions & {
   rewriteRelativeImportExtensions: boolean;
@@ -296,6 +306,7 @@ const SHARED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions & {
   skipLibCheck: true,
   allowImportingTsExtensions: true,
   rewriteRelativeImportExtensions: true,
+  jsx: javascript.TypeScriptJsxMode.REACT_JSX,
 };
 
 /** Shared formatting rules, applied by projen's Prettier on whichever project is root. */
@@ -365,6 +376,13 @@ function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProject
     ...(isRoot ? {} : { npmAccess: javascript.NpmAccess.PUBLIC }),
     buildWorkflow: false,
     release: false,
+    // No `npm pack` step on any project. projen wires `package` into `build`, so
+    // `bunx projen build` would tarball all 36 manifests (root included) into
+    // gitignored `dist/js` on every CI run and never read them: publishing here
+    // is `bun publish` driving each package's own `prepack` (see
+    // {@link applyCompiledPublish} and the `publish` task), and `release: false`
+    // means no projen Publisher exists to consume the artifacts either.
+    package: false,
     jest: false,
     github: false,
     npmignoreEnabled: false,
@@ -570,8 +588,8 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
 /**
  * A single package (usually created by a root's scan), or a standalone
  * compiling root. The agnostic tsconfig floor is applied at construction; the
- * source-first package fields (`main`/`types`/`exports` -> `index.ts`) and an
- * optional `vite.config.ts` are applied after. Per-tag deps/tsconfig arrive later
+ * source-first package fields (`main`/`types`/`exports` -> `index.ts`) and optional
+ * Bun app scaffolding are applied after. Per-tag deps/tsconfig arrive later
  * via the {@link PACKAGE_TAG_MIXINS} the root applies.
  */
 export class DBXToolsTypeScriptProject
@@ -608,6 +626,11 @@ export class DBXToolsTypeScriptProject
       },
     });
     this.scope = scope;
+    // Pairs with `jsx` in SHARED_COMPILER_OPTIONS: projen's default `include` is
+    // `src/**/*.ts` only, which silently omits a `.tsx` file from the program
+    // instead of failing, so authoring a React component would otherwise need
+    // per-package tsconfig config to be compiled at all.
+    this.tsconfig?.addInclude("src/**/*.tsx");
     this.dbxToolsConfig = new DBXToolsConfig(this, options);
     // Source-first entry: point the package at its package-ROOT `index.ts` barrel
     // so packages resolve each other's `@scope/pkg` imports to source.
@@ -624,9 +647,9 @@ export class DBXToolsTypeScriptProject
     // 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',
-    );
+    this.testTask.exec("bun test test", {
+      condition: 'find test -name "*.test.ts" 2>/dev/null | grep -q .',
+    });
     if (options.bunApp ?? false) {
       new BunfigFile(this);
       new BunDevServerFile(this);
@@ -661,6 +684,37 @@ class GeneratedSource extends Component {
   }
 }
 
+/**
+ * Make the ROOT `compile` / `test` tasks actually validate the workspace.
+ *
+ * projen gives a monorepo root empty `compile`/`test` tasks - a child's tasks
+ * are the child's business - so `bun run build` at the root type-checked nothing
+ * and ran no package tests. The fan-out is delegated to bun's own workspace
+ * filter rather than one `exec` per member, which matters three ways: bun runs
+ * the members in PARALLEL (measured ~2.5x faster across this repo than the
+ * sequential per-`cwd` form), a member that does not define the script is
+ * skipped instead of needing a guard, and the filter reads the workspace from
+ * `package.json` - so it stays correct when a package is added without a
+ * re-synth. A non-zero member exit still fails the run.
+ *
+ * `*` matches every workspace MEMBER and never the root itself, so the root
+ * task delegating to it cannot recurse. Members declared outside the scanned
+ * package roots (`extraWorkspaceMembers`) are workspace members too, so they are
+ * covered by the same filter.
+ */
+class WorkspaceValidationTasks extends Component {
+  private configured = false;
+
+  public override preSynthesize(): void {
+    if (this.configured) return;
+    this.configured = true;
+    const project = this.project as javascript.NodeProject;
+    for (const task of [project.compileTask, project.testTask]) {
+      task.exec(`bun run --filter '*' ${task.name}`);
+    }
+  }
+}
+
 /**
  * Ignore each `codegen`-declaring package's `src/` from the root ESLint config.
  * Those modules are read-only (ts-to-zod); lint `--fix` otherwise EACCES-crashes
@@ -673,10 +727,17 @@ class EslintIgnoreCodegen extends Component {
     const rootAbs = resolve(this.project.outdir);
     for (const sub of this.project.subprojects) {
       if (!(sub instanceof javascript.NodeProject)) continue;
-      const codegen = sub.package.manifest.codegen as { inputs?: unknown[] } | undefined;
+      const codegen = sub.package.manifest.codegen as { inputs?: string[] } | undefined;
       if (!codegen?.inputs?.length) continue;
       const rel = toPosix(relative(rootAbs, sub.outdir));
-      eslint.addIgnorePattern(`${rel}/src/**`);
+      // Ignore the generated MODULES, not the package's whole `src/`. A codegen
+      // package may hold hand-written modules next to its generated ones
+      // (shared-genie generates `dashboards.ts` beside a hand-written
+      // `genie-model.ts`), and a blanket `src/**` would silently stop linting
+      // them - the failure mode being invisible, since ESLint just reports less.
+      for (const module of codegenModulePaths(codegen.inputs)) {
+        eslint.addIgnorePattern(`${rel}/${module}`);
+      }
     }
   }
 }
@@ -781,7 +842,7 @@ function registerRootTasks(project: javascript.NodeProject): void {
     barrels: { exec: taskScript(project, "barrels.ts") },
     openapi: { exec: taskScript(project, "openapi.ts") },
     clean: { exec: taskScript(project, "clean.ts"), receiveArgs: true },
-    // `receiveArgs` forwards `--watch`, so `pnpm exec projen sync --watch` syncs once
+    // `receiveArgs` forwards `--watch`, so `bun run sync -- --watch` syncs once
     // then starts the single node-path watcher loop.
     sync: { exec: taskScript(project, "sync.ts"), receiveArgs: true },
   });
@@ -901,7 +962,7 @@ function initProject(
     prettier: Boolean(project.prettier),
     tsconfigPath: "./tsconfig.json",
   });
-  // Generated read-only outputs (barrels, openapi clients, vite configs, codegen).
+  // Generated read-only outputs (barrels, openapi clients, app scripts, codegen).
   // ESLint --fix cannot rewrite them; they are stamped by the barrel generator /
   // openapi / codegen / projen.
   for (const root of roots) {
@@ -995,6 +1056,8 @@ function initProject(
     project.with(...enabledTagMixins.map((t) => PACKAGE_TAG_MIXINS[t]));
   }
 
+  new WorkspaceValidationTasks(project);
+
   new GeneratedSource(project);
   // The `bump` task (compute next version + commit + tag + push) is useful on
   // any root; the actual publish is a tag-triggered GitHub workflow the caller

package/src/publish.ts

@@ -148,7 +148,7 @@ export function applyCompiledPublish(pkg: javascript.NodeProject): void {
   const config = publishConfig(pkg);
   if (config) pkg.package.addField("publishConfig", config);
 
-  // The release workflow publishes straight after `pnpm install`, with no build
+  // The release workflow publishes straight after `bun install`, with no build
   // in between, so the compiled output has to be produced by the pack itself
   // rather than assumed present. This also covers a bare `pnpm pack` and the
   // bump task's local-registry publish.

package/src/release.ts

@@ -88,7 +88,7 @@ function publishSetupSteps(): JobStep[] {
  *
  * Declaring one also enlists it in the root's `bump`, which cuts BOTH tags at one
  * shared version. The separate tag namespace still lets it be released alone
- * (`cd <directory> && pnpm run bump`) for a consumer who wants only this package -
+ * (`cd <directory> && bun run bump`) for a consumer who wants only this package -
  * but a routine root bump no longer leaves it behind, which is how the engine
  * drifted to 0.1.24 while the packages reached 0.3.41.
  */

package/src/scaffold.ts

@@ -9,7 +9,7 @@ import { repoRoot } from "./packages.ts";
  * Re-run projen synth by executing `.projenrc.ts` with `node --import tsx` (no
  * projen network re-exec).
  *
- * `post: true` runs the full flow - projen's post-synth `pnpm install` AND the
+ * `post: true` runs the full flow - projen's post-synth `bun install` AND the
  * post-synth barrels component - which is what the one-shot `sync` task
  * wants. The default (`post: false`) sets `PROJEN_DISABLE_POST`, skipping both so
  * the watch loop stays fast; there the caller rebuilds barrels explicitly.

package/src/tags.ts

@@ -1,7 +1,7 @@
 /**
  * Tags, expressed as MIXINS (`constructs` `IMixin`).
  *
- * A tag names a target environment (React/Vite, Node, agnostic, ...) - modeled on
+ * A tag names a target environment (React/Bun, Node, agnostic, ...) - modeled on
  * `databricks apps init` (AppKit): `ui`, `server`, `shared`. Any `src`-bearing folder
  * under a package root is discovered automatically; path-derived tag
  * candidates plus `packageTagPaths` decide which mixins apply. ("Scope" is
@@ -61,15 +61,18 @@ export const AGNOSTIC_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
 export const PACKAGE_TAG_MIXINS = {
   // `ui`: a React COMPONENT LIBRARY (source-first, consumed by apps) - modeled
   // on `@databricks/appkit-ui`. React + DOM lib + JSX, and the default `tsc`
-  // compile (typecheck). No vite app build / index.html: a full browser app is an
-  // `app`-tagged package (see below) that layers vite on top.
+  // compile (typecheck). No app build / index.html: a full browser app is an
+  // `app`-tagged package (see below) that layers Bun's build tooling on top.
   ui: create(projectPredicate.hasTag("ui"), (p) => {
     p.addDeps("react@catalog:", "react-dom@catalog:");
     p.addDevDeps("@types/react@catalog:", "@types/react-dom@catalog:");
+    // `jsx` is not set here: it is in the shared floor for EVERY package, because
+    // packages resolve each other to source and so every consumer of a `.tsx`
+    // module needs it too (see SHARED_COMPILER_OPTIONS). What this tag adds is the
+    // browser part - the DOM lib and React's types.
     applyCompilerOptions(p, {
       target: "ES2022",
       lib: [...DOM_LIB],
-      jsx: javascript.TypeScriptJsxMode.REACT_JSX,
     });
     // A component library's standard subpath surface: `./react` (components),
     // `./styles.css` (Tailwind entry), and `./package.json`. A package that
@@ -98,7 +101,6 @@ export const PACKAGE_TAG_MIXINS = {
     applyCompilerOptions(p, {
       target: "ES2022",
       lib: [...DOM_LIB],
-      jsx: javascript.TypeScriptJsxMode.REACT_JSX,
       // `@types/bun` (a root/subproject devDep) supplies the `Bun.*` globals the
       // generated `dev.ts`/`build.ts` use; no `vite/client`.
       types: ["bun"],
@@ -109,10 +111,14 @@ export const PACKAGE_TAG_MIXINS = {
     });
     // bun runs the generated scripts directly. `build` resets the compile task so
     // `compile` bundles with `Bun.build` rather than `tsc`.
+    //
+    // No `preview` task: that pairing is Vite's, where `dev` runs the dev server
+    // and `preview` serves the already-built bundle. `Bun.serve` builds on request,
+    // so `preview` could only be spelled the same as `dev` - two names for one
+    // command, and a reader would reasonably assume the second one served `dist/`.
     applyTasks(p, {
       dev: { exec: "bun dev.ts" },
       build: { exec: "bun build.ts" },
-      preview: { exec: "bun dev.ts" },
     });
     new BunfigFile(p);
     new BunDevServerFile(p);

package/src/vscode.ts

@@ -45,7 +45,7 @@ export class DBXToolsVsCode extends Component {
             detail:
               "projen sync --watch - projenrc (.projenrc.ts + syncResynthPaths re-synth) + barrels + openapi watchers",
             type: "shell",
-            command: "pnpm exec projen sync --watch",
+            command: "bun run sync -- --watch",
             isBackground: true,
             problemMatcher: [],
             runOptions: { runOn: "folderOpen" },
@@ -59,7 +59,7 @@ export class DBXToolsVsCode extends Component {
             label: "synth",
             detail: "projen - synthesize all generated config",
             type: "shell",
-            command: "pnpm exec projen",
+            command: "bun run default",
             problemMatcher: [],
           },
         ],

package/tasks/barrels.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env -S bun
 import { sep } from "node:path";
 import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
@@ -35,7 +35,7 @@ if (process.argv.includes("--watch")) {
       if (unowned.length) {
         logger.warn(
           `no recorded package owns ${string.pluralize(unowned.length, "change")}; ` +
-            "run `pnpm exec projen` (or touch .projenrc.ts) to pick up a new package folder",
+            "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
         );
       }
       return;

package/tasks/clean.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env -S bun
 import { relative } from "node:path";
 import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { log, string } from "@dbx-tools/shared-core";
@@ -18,8 +18,8 @@ if (targets.length === 0) {
 
 const regenHint = (removedNodeModules: boolean): string =>
   removedNodeModules
-    ? "reinstall with `pnpm install`, then `pnpm exec projen`"
-    : "regenerate with `pnpm exec projen`";
+    ? "reinstall with `bun install`, then `bun run default`"
+    : "regenerate with `bun run default`";
 
 if (yes) {
   const n = removePaths(targets);

package/tasks/openapi.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env -S bun
 import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
 import { generateOpenapi, isTsoaController } from "../src/openapi.ts";

package/tasks/projenrc.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env -S bun
 import { resolve } from "node:path";
 import { log } from "@dbx-tools/shared-core";
 import { runSynth } from "../src/scaffold.ts";
@@ -25,7 +25,7 @@ const WATCH_PATHS = resynthWatchPaths();
 // scoping re-synth (the one expensive, install-bearing step) to those manifests is what
 // makes the watch intelligent vs stock `projen --watch`, which re-synths on any tree
 // change. `{ dot: false }` keeps the default dotfile ignore group from pruning dotfile
-// targets. (A one-shot "projenrc" is just a synth, i.e. `pnpm exec projen`.)
+// targets. (A one-shot "projenrc" is just a synth, i.e. `bun run default`.)
 watchLoop(
   "projenrc",
   WATCH_PATHS,

package/tasks/sync.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env -S bun
 import { fileURLToPath } from "node:url";
 import concurrently from "concurrently";
 import { log } from "@dbx-tools/shared-core";
@@ -54,9 +54,9 @@ if (!process.argv.includes("--watch")) {
 
   const { result } = concurrently(
     [
-      { command: `tsx "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
-      { command: `tsx "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
-      { command: `tsx "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
+      { command: `bun "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
+      { command: `bun "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
+      { command: `bun "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
     ],
     {
       prefix: "name",