@dbx-tools/cli 0.6.39 → 0.6.41

package/index.ts

@@ -3,8 +3,8 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export * as bootstrap from "./src/bootstrap.ts";
+export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
-export * as pnpm from "./src/pnpm.ts";
 export * as root from "./src/root.ts";
-export { resolvePnpmArgv } from "./src/pnpm.ts";
+export { resolveBunArgv } from "./src/bun.ts";
 export { workspaceRoot } from "./src/root.ts";

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 export * as bootstrap from "./src/bootstrap.ts";
+export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
-export * as pnpm from "./src/pnpm.ts";
 export * as root from "./src/root.ts";
-export { resolvePnpmArgv } from "./src/pnpm.ts";
+export { resolveBunArgv } from "./src/bun.ts";
 export { workspaceRoot } from "./src/root.ts";

package/lib/index.js

@@ -2,9 +2,9 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as bootstrap from "./src/bootstrap.js";
+export * as bun from "./src/bun.js";
 export * as cli from "./src/cli.js";
-export * as pnpm from "./src/pnpm.js";
 export * as root from "./src/root.js";
-export { resolvePnpmArgv } from "./src/pnpm.js";
+export { resolveBunArgv } from "./src/bun.js";
 export { workspaceRoot } from "./src/root.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssU0FBUyxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxHQUFHLE1BQU0sY0FBYyxDQUFDO0FBQ3BDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDaEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIGJvb3RzdHJhcCBmcm9tIFwiLi9zcmMvYm9vdHN0cmFwLnRzXCI7XG5leHBvcnQgKiBhcyBjbGkgZnJvbSBcIi4vc3JjL2NsaS50c1wiO1xuZXhwb3J0ICogYXMgcG5wbSBmcm9tIFwiLi9zcmMvcG5wbS50c1wiO1xuZXhwb3J0ICogYXMgcm9vdCBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuZXhwb3J0IHsgcmVzb2x2ZVBucG1Bcmd2IH0gZnJvbSBcIi4vc3JjL3BucG0udHNcIjtcbmV4cG9ydCB7IHdvcmtzcGFjZVJvb3QgfSBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssU0FBUyxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxHQUFHLE1BQU0sY0FBYyxDQUFDO0FBQ3BDLE9BQU8sS0FBSyxHQUFHLE1BQU0sY0FBYyxDQUFDO0FBQ3BDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDOUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIGJvb3RzdHJhcCBmcm9tIFwiLi9zcmMvYm9vdHN0cmFwLnRzXCI7XG5leHBvcnQgKiBhcyBidW4gZnJvbSBcIi4vc3JjL2J1bi50c1wiO1xuZXhwb3J0ICogYXMgY2xpIGZyb20gXCIuL3NyYy9jbGkudHNcIjtcbmV4cG9ydCAqIGFzIHJvb3QgZnJvbSBcIi4vc3JjL3Jvb3QudHNcIjtcbmV4cG9ydCB7IHJlc29sdmVCdW5Bcmd2IH0gZnJvbSBcIi4vc3JjL2J1bi50c1wiO1xuZXhwb3J0IHsgd29ya3NwYWNlUm9vdCB9IGZyb20gXCIuL3NyYy9yb290LnRzXCI7XG4iXX0=

package/lib/src/bootstrap.d.ts

@@ -13,31 +13,34 @@
  */
 export declare function ensureEngineCurrent(root: string): void;
 /**
- * Turn a folder into a functioning dbx-tools workspace: `pnpm init`, seed
- * `pnpm-workspace.yaml`, add `projen`/`typescript`/`tsx` + the engine package,
- * write a minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then
- * install. Does not run barrels - run `pnpm run barrels` or a full projen synth
- * post-install to generate package barrels.
+ * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the
+ * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`
+ * from the manifest), add `projen`/`typescript` + the engine package, write a
+ * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.
+ * Does not run barrels - run `bun run barrels` or a full projen synth post-install
+ * to generate package barrels.
  *
  * Every step is idempotent and self-guarded, so this is safe to run against a
  * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed
  * `package.json`) but is missing the installed toolchain - e.g. a freshly copied
  * project whose generated files (including manifests) are gitignored. In that
- * case `pnpm init` and the `.projenrc.ts` scaffold are skipped, but the engine +
- * projen + tsx are (re)installed so the subsequent synth can regenerate
- * everything. See {@link seedToolchain}.
+ * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +
+ * projen are (re)installed so the subsequent synth can regenerate everything.
+ * See {@link seedToolchain}.
  */
 export declare function bootstrapWorkspace(root: string, projenSpecifier?: string): void;
 /**
- * Install the toolchain a synth needs (`projen`, `typescript`, `tsx`, and the
- * dbx-tools engine), seeding a `package.json` and `pnpm-workspace.yaml` first
- * when absent. Idempotent: run it whenever the engine is missing, so a copied
- * project with a `.projenrc.ts` but no `node_modules`/manifests can be brought
- * up to a synth-ready state without full bootstrapping.
+ * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools
+ * engine), seeding a `package.json` first when absent. bun reads its workspace
+ * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no
+ * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at
+ * synth for the Databricks Apps platform. Idempotent: run it whenever the engine
+ * is missing, so a copied project with a `.projenrc.ts` but no
+ * `node_modules`/manifest can be brought up to a synth-ready state.
  */
 export declare function seedToolchain(root: string, projenSpecifier?: string): void;
 /**
- * Run the initial synth by executing `.projenrc.ts` directly with tsx (with
+ * Run the initial synth by executing `.projenrc.ts` directly with bun (with
  * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a
  * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once
  * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.

package/lib/src/bootstrap.js

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import { intro, outro } from "@clack/prompts";
 import { exec, project } from "@dbx-tools/core";
 import { json, log } from "@dbx-tools/shared-core";
-import { childEnv, resolvePnpmArgv, runPnpm } from "./pnpm.js";
+import { childEnv, resolveBunArgv, runBun } from "./bun.js";
 import { rootLabel } from "./root.js";
 const logger = log.logger("dbx-tools:bootstrap");
 /** Published package name used for Node's self-reference manifest resolution. */
@@ -21,15 +21,10 @@ const FALLBACK_PROJEN_SPECIFIER = "@dbx-tools/projen@latest";
  * the root `bump`, so the matching engine always exists on the registry.
  *
  * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on
- * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. `@latest`
- * has a subtler failure: pnpm 11 applies a `minimumReleaseAge` delay, so for the
- * first day after a release it deliberately resolves a dist-tag to the newest
- * version OLDER than the threshold and merely notes the newer one
- * (`+ @dbx-tools/projen 0.1.24 (0.3.42 is available)`). A bootstrap run right
- * after a release therefore installed a months-old engine against a current CLI,
- * which is how `sync --watch` died on an engine predating its `concurrently`
- * dependency. An explicit range admits only the version we want, so the age
- * heuristic has nothing older to fall back to.
+ * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. An explicit
+ * range pinned to this CLI's own version admits only the matching engine, so the
+ * CLI and the engine it drives never drift across a release (they are cut
+ * together by the root `bump`).
  */
 function defaultProjenSpecifier() {
     const version = ownVersion();
@@ -88,7 +83,7 @@ export function ensureEngineCurrent(root) {
     const installed = installedEngineVersion(root);
     if (installed && compareVersions(installed, expected) >= 0)
         return;
-    runPnpm(["add", "-D", defaultProjenSpecifier()], root);
+    runBun(["add", "-D", defaultProjenSpecifier()], root);
 }
 // Reach the class through its module NAMESPACE. Current engines also hoist it
 // flat, but every engine ever published exports the namespace, and this template
@@ -99,25 +94,21 @@ const PROJENRC_TEMPLATE = `import { project as projectApi } from "@dbx-tools/pro
 const project = new projectApi.DBXToolsNodeProject();
 project.synth();
 `;
-/** Seed `pnpm-workspace.yaml` so the first \`pnpm add\` can allow esbuild non-interactively. */
-const WORKSPACE_SEED = `packages: []
-allowBuilds:
-  esbuild: true
-`;
 /**
- * Turn a folder into a functioning dbx-tools workspace: `pnpm init`, seed
- * `pnpm-workspace.yaml`, add `projen`/`typescript`/`tsx` + the engine package,
- * write a minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then
- * install. Does not run barrels - run `pnpm run barrels` or a full projen synth
- * post-install to generate package barrels.
+ * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the
+ * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`
+ * from the manifest), add `projen`/`typescript` + the engine package, write a
+ * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.
+ * Does not run barrels - run `bun run barrels` or a full projen synth post-install
+ * to generate package barrels.
  *
  * Every step is idempotent and self-guarded, so this is safe to run against a
  * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed
  * `package.json`) but is missing the installed toolchain - e.g. a freshly copied
  * project whose generated files (including manifests) are gitignored. In that
- * case `pnpm init` and the `.projenrc.ts` scaffold are skipped, but the engine +
- * projen + tsx are (re)installed so the subsequent synth can regenerate
- * everything. See {@link seedToolchain}.
+ * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +
+ * projen are (re)installed so the subsequent synth can regenerate everything.
+ * See {@link seedToolchain}.
  */
 export function bootstrapWorkspace(root, projenSpecifier = defaultProjenSpecifier()) {
     intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);
@@ -127,26 +118,24 @@ export function bootstrapWorkspace(root, projenSpecifier = defaultProjenSpecifie
         writeFileSync(projenrc, PROJENRC_TEMPLATE);
     }
     runInitialSynth(root);
-    runPnpm(["install", "--no-frozen-lockfile", "--force"], root);
+    runBun(["install"], root);
     outro("Workspace ready - re-run dbx-tools or add packages under packages/");
 }
 /**
- * Install the toolchain a synth needs (`projen`, `typescript`, `tsx`, and the
- * dbx-tools engine), seeding a `package.json` and `pnpm-workspace.yaml` first
- * when absent. Idempotent: run it whenever the engine is missing, so a copied
- * project with a `.projenrc.ts` but no `node_modules`/manifests can be brought
- * up to a synth-ready state without full bootstrapping.
+ * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools
+ * engine), seeding a `package.json` first when absent. bun reads its workspace
+ * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no
+ * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at
+ * synth for the Databricks Apps platform. Idempotent: run it whenever the engine
+ * is missing, so a copied project with a `.projenrc.ts` but no
+ * `node_modules`/manifest can be brought up to a synth-ready state.
  */
 export function seedToolchain(root, projenSpecifier = defaultProjenSpecifier()) {
     const manifestPath = join(root, "package.json");
     if (!existsSync(manifestPath)) {
-        runPnpm(["init"], root);
+        runBun(["init", "-y"], root);
         normalizeSeedManifest(manifestPath);
     }
-    const workspaceFile = join(root, "pnpm-workspace.yaml");
-    if (!existsSync(workspaceFile)) {
-        writeFileSync(workspaceFile, WORKSPACE_SEED);
-    }
     seedRegistry(root);
     const kernelArch = exec.spawnSync("uname", ["-m"], {
         stdin: "ignore",
@@ -155,27 +144,20 @@ export function seedToolchain(root, projenSpecifier = defaultProjenSpecifier())
     }).stdout;
     logger.info("seeding toolchain", {
         node: process.version,
+        bun: process.versions.bun,
         platform: process.platform,
         arch: process.arch,
         kernelArch: kernelArch || "unknown",
         engine: projenSpecifier,
     });
-    runPnpm([
-        "add",
-        "--reporter=append-only",
-        "-D",
-        "projen",
-        "typescript@^5.9.3",
-        "tsx@^4.23.0",
-        projenSpecifier,
-    ], root);
+    runBun(["add", "-D", "projen", "typescript@^5.9.3", "@types/bun", projenSpecifier], root);
 }
 /**
  * Pin a non-default registry into the new root's `.npmrc`.
  *
- * The CLI already forces `--registry` onto the pnpm invocations it makes itself,
- * but a bootstrapped workspace outlives this process: every later `pnpm install`
- * the developer (or projen's post-synth step) runs is on its own. pnpm ignores
+ * The CLI already forces `--registry` onto the bun invocations it makes itself,
+ * but a bootstrapped workspace outlives this process: every later `bun install`
+ * the developer (or projen's post-synth step) runs is on its own. bun ignores
  * `npm_config_registry` from the environment, so without a file on disk those
  * runs revert to `https://registry.npmjs.org/` - which is a hard failure where
  * the custom registry was the only reachable one.
@@ -193,19 +175,11 @@ function seedRegistry(root) {
     writeFileSync(npmrc, `registry=${registry}\n`);
 }
 /**
- * Make what `pnpm init` produced safe to synth against. Two corrections, both
- * because that output varies by pnpm version:
- *
- *   - drop `devEngines`, which pnpm 11 seeds as `packageManager: { name: "pnpm",
- *     onFail: "download" }`. Any npm-based tool later in the chain (an
- *     `npx`/dlx fallback) then refuses with EBADDEVENGINES, its runner being npm;
- *   - force `type: "module"`, which pnpm 11 writes and pnpm 10 does not. tsx
- *     picks the entry's format from the nearest manifest, so without it
- *     `.projenrc.ts` loads as CJS and the first dependency using top-level await
- *     dies on "not supported with the cjs output format".
- *
- * projen regenerates the whole manifest at synth, so this only has to hold the
- * seed together long enough to get there.
+ * Make what `bun init` produced safe to synth against: force `type: "module"`
+ * (bun runs `.projenrc.ts` fine either way, but projen's ESM sources and the
+ * emitted config assume module type) and drop any `packageManager`/`devEngines`
+ * field that would pin a different manager. projen regenerates the whole manifest
+ * at synth, so this only has to hold the seed together long enough to get there.
  */
 function normalizeSeedManifest(manifestPath) {
     try {
@@ -213,28 +187,28 @@ function normalizeSeedManifest(manifestPath) {
         if (!manifest)
             return;
         delete manifest.devEngines;
+        delete manifest.packageManager;
         manifest.type = "module";
         writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
     }
     catch {
-        // A malformed/absent manifest here just means the later `pnpm add` recreates it.
+        // A malformed/absent manifest here just means the later `bun add` recreates it.
     }
 }
 /**
- * Run the initial synth by executing `.projenrc.ts` directly with tsx (with
+ * Run the initial synth by executing `.projenrc.ts` directly with bun (with
  * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a
  * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once
  * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.
  */
 export function runInitialSynth(root) {
-    const [command, ...prefix] = resolvePnpmArgv();
-    // No `--registry` here: this is `pnpm exec`, whose trailing arguments belong to
-    // tsx. The registry reaches anything nested through `childEnv` and the seeded
-    // `.npmrc` instead.
-    exec.spawnSync(command, [...prefix, "exec", "tsx", ".projenrc.ts"], {
+    const [command, ...prefix] = resolveBunArgv();
+    // bun runs the `.ts` directly. The registry reaches anything nested through
+    // `childEnv` and the seeded `.npmrc`.
+    exec.spawnSync(command, [...prefix, ".projenrc.ts"], {
         cwd: root,
         env: childEnv({ PROJEN_DISABLE_POST: "true" }),
         check: true,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.\n *\n * @module\n */\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json, log } from \"@dbx-tools/shared-core\";\nimport { childEnv, resolvePnpmArgv, runPnpm } from \"./pnpm.ts\";\nimport { rootLabel } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bootstrap\");\n\n/** Published package name used for Node's self-reference manifest resolution. */\nconst CLI_PACKAGE = \"@dbx-tools/cli\";\n\n/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */\nconst FALLBACK_PROJEN_SPECIFIER = \"@dbx-tools/projen@latest\";\n\n/**\n * Install the engine at THIS CLI's own version. The two are released together by\n * the root `bump`, so the matching engine always exists on the registry.\n *\n * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on\n * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. `@latest`\n * has a subtler failure: pnpm 11 applies a `minimumReleaseAge` delay, so for the\n * first day after a release it deliberately resolves a dist-tag to the newest\n * version OLDER than the threshold and merely notes the newer one\n * (`+ @dbx-tools/projen 0.1.24 (0.3.42 is available)`). A bootstrap run right\n * after a release therefore installed a months-old engine against a current CLI,\n * which is how `sync --watch` died on an engine predating its `concurrently`\n * dependency. An explicit range admits only the version we want, so the age\n * heuristic has nothing older to fall back to.\n */\nfunction defaultProjenSpecifier(): string {\n  const version = ownVersion();\n  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;\n}\n\n/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */\nfunction ownVersion(): string | undefined {\n  try {\n    // Resolve through the package's exported `./package.json`, which works from\n    // both source (`src/bootstrap.ts`) and published output\n    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest\n    // in source but two levels away after compilation and silently fell back to\n    // `@latest` in every installed CLI.\n    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);\n    const version = json.parseRecord(readFileSync(manifestPath, \"utf8\"))?.version;\n    return typeof version === \"string\" && version !== \"0.0.0\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */\nfunction compareVersions(a: string, b: string): number {\n  const parts = (v: string) => v.split(\".\").map((p) => Number.parseInt(p, 10) || 0);\n  const [x, y] = [parts(a), parts(b)];\n  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];\n}\n\n/** Version of the engine currently installed at `root`, if any. */\nfunction installedEngineVersion(root: string): string | undefined {\n  try {\n    const manifest = join(root, \"node_modules\", \"@dbx-tools\", \"projen\", \"package.json\");\n    const version = json.parseRecord(readFileSync(manifest, \"utf8\"))?.version;\n    return typeof version === \"string\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Upgrade an established workspace whose installed engine predates this CLI.\n *\n * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a\n * workspace created months ago kept resolving its original engine no matter how\n * current the CLI invoking it was, and failed inside the OLD engine's code\n * (`sync --watch` dying on a `concurrently` that engine never declared). The two\n * are released in lockstep, so this CLI's version is exactly the engine it\n * expects.\n *\n * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so\n * an older CLI cannot downgrade a workspace.\n */\nexport function ensureEngineCurrent(root: string): void {\n  const expected = ownVersion();\n  if (!expected) return;\n  const installed = installedEngineVersion(root);\n  if (installed && compareVersions(installed, expected) >= 0) return;\n  runPnpm([\"add\", \"-D\", defaultProjenSpecifier()], root);\n}\n\n// Reach the class through its module NAMESPACE. Current engines also hoist it\n// flat, but every engine ever published exports the namespace, and this template\n// is resolved against `@latest` - a flat import dies on an older one with\n// \"does not provide an export named 'DBXToolsNodeProject'\".\nconst PROJENRC_TEMPLATE = `import { project as projectApi } from \"@dbx-tools/projen\";\n\nconst project = new projectApi.DBXToolsNodeProject();\nproject.synth();\n`;\n\n/** Seed `pnpm-workspace.yaml` so the first \\`pnpm add\\` can allow esbuild non-interactively. */\nconst WORKSPACE_SEED = `packages: []\nallowBuilds:\n  esbuild: true\n`;\n\n/**\n * Turn a folder into a functioning dbx-tools workspace: `pnpm init`, seed\n * `pnpm-workspace.yaml`, add `projen`/`typescript`/`tsx` + the engine package,\n * write a minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then\n * install. Does not run barrels - run `pnpm run barrels` or a full projen synth\n * post-install to generate package barrels.\n *\n * Every step is idempotent and self-guarded, so this is safe to run against a\n * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed\n * `package.json`) but is missing the installed toolchain - e.g. a freshly copied\n * project whose generated files (including manifests) are gitignored. In that\n * case `pnpm init` and the `.projenrc.ts` scaffold are skipped, but the engine +\n * projen + tsx are (re)installed so the subsequent synth can regenerate\n * everything. See {@link seedToolchain}.\n */\nexport function bootstrapWorkspace(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);\n\n  seedToolchain(root, projenSpecifier);\n\n  const projenrc = join(root, \".projenrc.ts\");\n  if (!existsSync(projenrc)) {\n    writeFileSync(projenrc, PROJENRC_TEMPLATE);\n  }\n\n  runInitialSynth(root);\n\n  runPnpm([\"install\", \"--no-frozen-lockfile\", \"--force\"], root);\n  outro(\"Workspace ready - re-run dbx-tools or add packages under packages/\");\n}\n\n/**\n * Install the toolchain a synth needs (`projen`, `typescript`, `tsx`, and the\n * dbx-tools engine), seeding a `package.json` and `pnpm-workspace.yaml` first\n * when absent. Idempotent: run it whenever the engine is missing, so a copied\n * project with a `.projenrc.ts` but no `node_modules`/manifests can be brought\n * up to a synth-ready state without full bootstrapping.\n */\nexport function seedToolchain(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  const manifestPath = join(root, \"package.json\");\n  if (!existsSync(manifestPath)) {\n    runPnpm([\"init\"], root);\n    normalizeSeedManifest(manifestPath);\n  }\n\n  const workspaceFile = join(root, \"pnpm-workspace.yaml\");\n  if (!existsSync(workspaceFile)) {\n    writeFileSync(workspaceFile, WORKSPACE_SEED);\n  }\n\n  seedRegistry(root);\n\n  const kernelArch = exec.spawnSync(\"uname\", [\"-m\"], {\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"ignore\",\n  }).stdout;\n  logger.info(\"seeding toolchain\", {\n    node: process.version,\n    platform: process.platform,\n    arch: process.arch,\n    kernelArch: kernelArch || \"unknown\",\n    engine: projenSpecifier,\n  });\n  runPnpm(\n    [\n      \"add\",\n      \"--reporter=append-only\",\n      \"-D\",\n      \"projen\",\n      \"typescript@^5.9.3\",\n      \"tsx@^4.23.0\",\n      projenSpecifier,\n    ],\n    root,\n  );\n}\n\n/**\n * Pin a non-default registry into the new root's `.npmrc`.\n *\n * The CLI already forces `--registry` onto the pnpm invocations it makes itself,\n * but a bootstrapped workspace outlives this process: every later `pnpm install`\n * the developer (or projen's post-synth step) runs is on its own. pnpm ignores\n * `npm_config_registry` from the environment, so without a file on disk those\n * runs revert to `https://registry.npmjs.org/` - which is a hard failure where\n * the custom registry was the only reachable one.\n *\n * Only writes for an actual override, never creates a file just to name npmjs,\n * and never overwrites an existing `.npmrc` (the developer's own wins).\n */\nfunction seedRegistry(root: string): void {\n  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();\n  if (!registry) return;\n  const npmrc = join(root, \".npmrc\");\n  if (existsSync(npmrc)) return;\n  writeFileSync(npmrc, `registry=${registry}\\n`);\n}\n\n/**\n * Make what `pnpm init` produced safe to synth against. Two corrections, both\n * because that output varies by pnpm version:\n *\n *   - drop `devEngines`, which pnpm 11 seeds as `packageManager: { name: \"pnpm\",\n *     onFail: \"download\" }`. Any npm-based tool later in the chain (an\n *     `npx`/dlx fallback) then refuses with EBADDEVENGINES, its runner being npm;\n *   - force `type: \"module\"`, which pnpm 11 writes and pnpm 10 does not. tsx\n *     picks the entry's format from the nearest manifest, so without it\n *     `.projenrc.ts` loads as CJS and the first dependency using top-level await\n *     dies on \"not supported with the cjs output format\".\n *\n * projen regenerates the whole manifest at synth, so this only has to hold the\n * seed together long enough to get there.\n */\nfunction normalizeSeedManifest(manifestPath: string): void {\n  try {\n    const manifest = json.parseRecord(readFileSync(manifestPath, \"utf8\"));\n    if (!manifest) return;\n    delete manifest.devEngines;\n    manifest.type = \"module\";\n    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\\n`);\n  } catch {\n    // A malformed/absent manifest here just means the later `pnpm add` recreates it.\n  }\n}\n\n/**\n * Run the initial synth by executing `.projenrc.ts` directly with tsx (with\n * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a\n * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once\n * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.\n */\nexport function runInitialSynth(root: string): void {\n  const [command, ...prefix] = resolvePnpmArgv();\n  // No `--registry` here: this is `pnpm exec`, whose trailing arguments belong to\n  // tsx. The registry reaches anything nested through `childEnv` and the seeded\n  // `.npmrc` instead.\n  exec.spawnSync(command, [...prefix, \"exec\", \"tsx\", \".projenrc.ts\"], {\n    cwd: root,\n    env: childEnv({ PROJEN_DISABLE_POST: \"true\" }),\n    check: true,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.\n *\n * @module\n */\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json, log } from \"@dbx-tools/shared-core\";\nimport { childEnv, resolveBunArgv, runBun } from \"./bun.ts\";\nimport { rootLabel } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bootstrap\");\n\n/** Published package name used for Node's self-reference manifest resolution. */\nconst CLI_PACKAGE = \"@dbx-tools/cli\";\n\n/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */\nconst FALLBACK_PROJEN_SPECIFIER = \"@dbx-tools/projen@latest\";\n\n/**\n * Install the engine at THIS CLI's own version. The two are released together by\n * the root `bump`, so the matching engine always exists on the registry.\n *\n * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on\n * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. An explicit\n * range pinned to this CLI's own version admits only the matching engine, so the\n * CLI and the engine it drives never drift across a release (they are cut\n * together by the root `bump`).\n */\nfunction defaultProjenSpecifier(): string {\n  const version = ownVersion();\n  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;\n}\n\n/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */\nfunction ownVersion(): string | undefined {\n  try {\n    // Resolve through the package's exported `./package.json`, which works from\n    // both source (`src/bootstrap.ts`) and published output\n    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest\n    // in source but two levels away after compilation and silently fell back to\n    // `@latest` in every installed CLI.\n    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);\n    const version = json.parseRecord(readFileSync(manifestPath, \"utf8\"))?.version;\n    return typeof version === \"string\" && version !== \"0.0.0\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */\nfunction compareVersions(a: string, b: string): number {\n  const parts = (v: string) => v.split(\".\").map((p) => Number.parseInt(p, 10) || 0);\n  const [x, y] = [parts(a), parts(b)];\n  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];\n}\n\n/** Version of the engine currently installed at `root`, if any. */\nfunction installedEngineVersion(root: string): string | undefined {\n  try {\n    const manifest = join(root, \"node_modules\", \"@dbx-tools\", \"projen\", \"package.json\");\n    const version = json.parseRecord(readFileSync(manifest, \"utf8\"))?.version;\n    return typeof version === \"string\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Upgrade an established workspace whose installed engine predates this CLI.\n *\n * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a\n * workspace created months ago kept resolving its original engine no matter how\n * current the CLI invoking it was, and failed inside the OLD engine's code\n * (`sync --watch` dying on a `concurrently` that engine never declared). The two\n * are released in lockstep, so this CLI's version is exactly the engine it\n * expects.\n *\n * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so\n * an older CLI cannot downgrade a workspace.\n */\nexport function ensureEngineCurrent(root: string): void {\n  const expected = ownVersion();\n  if (!expected) return;\n  const installed = installedEngineVersion(root);\n  if (installed && compareVersions(installed, expected) >= 0) return;\n  runBun([\"add\", \"-D\", defaultProjenSpecifier()], root);\n}\n\n// Reach the class through its module NAMESPACE. Current engines also hoist it\n// flat, but every engine ever published exports the namespace, and this template\n// is resolved against `@latest` - a flat import dies on an older one with\n// \"does not provide an export named 'DBXToolsNodeProject'\".\nconst PROJENRC_TEMPLATE = `import { project as projectApi } from \"@dbx-tools/projen\";\n\nconst project = new projectApi.DBXToolsNodeProject();\nproject.synth();\n`;\n\n/**\n * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the\n * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`\n * from the manifest), add `projen`/`typescript` + the engine package, write a\n * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.\n * Does not run barrels - run `bun run barrels` or a full projen synth post-install\n * to generate package barrels.\n *\n * Every step is idempotent and self-guarded, so this is safe to run against a\n * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed\n * `package.json`) but is missing the installed toolchain - e.g. a freshly copied\n * project whose generated files (including manifests) are gitignored. In that\n * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +\n * projen are (re)installed so the subsequent synth can regenerate everything.\n * See {@link seedToolchain}.\n */\nexport function bootstrapWorkspace(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);\n\n  seedToolchain(root, projenSpecifier);\n\n  const projenrc = join(root, \".projenrc.ts\");\n  if (!existsSync(projenrc)) {\n    writeFileSync(projenrc, PROJENRC_TEMPLATE);\n  }\n\n  runInitialSynth(root);\n\n  runBun([\"install\"], root);\n  outro(\"Workspace ready - re-run dbx-tools or add packages under packages/\");\n}\n\n/**\n * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools\n * engine), seeding a `package.json` first when absent. bun reads its workspace\n * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no\n * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at\n * synth for the Databricks Apps platform. Idempotent: run it whenever the engine\n * is missing, so a copied project with a `.projenrc.ts` but no\n * `node_modules`/manifest can be brought up to a synth-ready state.\n */\nexport function seedToolchain(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  const manifestPath = join(root, \"package.json\");\n  if (!existsSync(manifestPath)) {\n    runBun([\"init\", \"-y\"], root);\n    normalizeSeedManifest(manifestPath);\n  }\n\n  seedRegistry(root);\n\n  const kernelArch = exec.spawnSync(\"uname\", [\"-m\"], {\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"ignore\",\n  }).stdout;\n  logger.info(\"seeding toolchain\", {\n    node: process.version,\n    bun: process.versions.bun,\n    platform: process.platform,\n    arch: process.arch,\n    kernelArch: kernelArch || \"unknown\",\n    engine: projenSpecifier,\n  });\n  runBun([\"add\", \"-D\", \"projen\", \"typescript@^5.9.3\", \"@types/bun\", projenSpecifier], root);\n}\n\n/**\n * Pin a non-default registry into the new root's `.npmrc`.\n *\n * The CLI already forces `--registry` onto the bun invocations it makes itself,\n * but a bootstrapped workspace outlives this process: every later `bun install`\n * the developer (or projen's post-synth step) runs is on its own. bun ignores\n * `npm_config_registry` from the environment, so without a file on disk those\n * runs revert to `https://registry.npmjs.org/` - which is a hard failure where\n * the custom registry was the only reachable one.\n *\n * Only writes for an actual override, never creates a file just to name npmjs,\n * and never overwrites an existing `.npmrc` (the developer's own wins).\n */\nfunction seedRegistry(root: string): void {\n  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();\n  if (!registry) return;\n  const npmrc = join(root, \".npmrc\");\n  if (existsSync(npmrc)) return;\n  writeFileSync(npmrc, `registry=${registry}\\n`);\n}\n\n/**\n * Make what `bun init` produced safe to synth against: force `type: \"module\"`\n * (bun runs `.projenrc.ts` fine either way, but projen's ESM sources and the\n * emitted config assume module type) and drop any `packageManager`/`devEngines`\n * field that would pin a different manager. projen regenerates the whole manifest\n * at synth, so this only has to hold the seed together long enough to get there.\n */\nfunction normalizeSeedManifest(manifestPath: string): void {\n  try {\n    const manifest = json.parseRecord(readFileSync(manifestPath, \"utf8\"));\n    if (!manifest) return;\n    delete manifest.devEngines;\n    delete manifest.packageManager;\n    manifest.type = \"module\";\n    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\\n`);\n  } catch {\n    // A malformed/absent manifest here just means the later `bun add` recreates it.\n  }\n}\n\n/**\n * Run the initial synth by executing `.projenrc.ts` directly with bun (with\n * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a\n * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once\n * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.\n */\nexport function runInitialSynth(root: string): void {\n  const [command, ...prefix] = resolveBunArgv();\n  // bun runs the `.ts` directly. The registry reaches anything nested through\n  // `childEnv` and the seeded `.npmrc`.\n  exec.spawnSync(command, [...prefix, \".projenrc.ts\"], {\n    cwd: root,\n    env: childEnv({ PROJEN_DISABLE_POST: \"true\" }),\n    check: true,\n  });\n}\n"]}

package/lib/src/bun.d.ts

@@ -0,0 +1,24 @@
+/** `--registry <url>` for a bun invocation, or `[]` when the subcommand doesn't resolve. */
+export declare function bunRegistryArgs(args: readonly string[]): string[];
+/** Whether the first bun subcommand resolves packages and accepts `--registry`. */
+export declare function bunUsesRegistry(args: readonly string[]): boolean;
+/**
+ * `process.env` plus the runtime executable directory and registry aliases.
+ *
+ * The executable directory matters when this CLI was launched by absolute path:
+ * bun runs, but a lifecycle script that invokes `bun`/`node` by bare name would
+ * otherwise fail with `command not found`. Prepending `dirname(process.execPath)`
+ * (the running bun binary's dir) puts the runtime back on PATH.
+ */
+export declare function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv;
+/** Memoized `[command, ...prefix]` argv prefix to run bun. */
+export declare const resolveBunArgv: () => string[];
+/** Run bun with inherited stdio from `cwd`, forcing the resolved registry. */
+export declare function runBun(args: string[], cwd: string): void;
+/** Install workspace dependencies when `node_modules` or projen is missing. */
+export declare function ensureWorkspaceReady(root: string): void;
+/**
+ * Run projen with the given args from `root`. Prefers the installed `projen` bin
+ * via `bun run`, so the workspace's own engine + tasks are used.
+ */
+export declare function runProjen(args: string[], root: string): void;

package/lib/src/bun.js

@@ -0,0 +1,126 @@
+/**
+ * bun discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.
+ *
+ * ## Forcing a custom registry
+ *
+ * bun honors a `--registry <url>` flag on `bun install`/`bun add` and a project
+ * `.npmrc`, but (like pnpm) ignores the `npm_config_registry` env var for its own
+ * resolution. So a custom registry is forced through TWO channels, each where it
+ * applies:
+ *
+ *  - {@link bunRegistryArgs} passes `--registry` to the package-resolving
+ *    subcommands (`install`/`add`/`update`), never to `bun run`/`bunx`, whose
+ *    trailing args belong to the script.
+ *  - {@link childEnv} keeps `.npmrc`-style env aliases set for any nested
+ *    npm-based tool, and (critically) puts the bun/node executable dir on PATH so
+ *    a lifecycle script can invoke the runtime by bare name.
+ *
+ * `@dbx-tools/core`'s `npmRegistry({ overrideOnly: true })` returns nothing when
+ * the effective registry IS npmjs, so none of this touches a default install.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { exec, project } from "@dbx-tools/core";
+import { functionModule, log } from "@dbx-tools/shared-core";
+import { needsInstall } from "./root.js";
+const logger = log.logger("dbx-tools:bun");
+/**
+ * bun subcommands that resolve packages from a registry, and therefore accept a
+ * meaningful `--registry`. Everything else (`run`, `x`, `pm`, ...) is left alone:
+ * `run`/`x` forward trailing arguments to the script they run.
+ */
+const REGISTRY_SUBCOMMANDS = new Set(["add", "install", "i", "update", "up"]);
+/**
+ * The registry to force onto child installs, or `undefined` when the effective
+ * one is already the public default.
+ *
+ * `envVars: true` also consults `npm_config_registry` directly, because a
+ * container may export it without any `.npmrc` for lookup. Memoized: resolution
+ * shells out.
+ */
+const registryOverride = functionModule.memoize(() => project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString());
+/** `--registry <url>` for a bun invocation, or `[]` when the subcommand doesn't resolve. */
+export function bunRegistryArgs(args) {
+    const url = registryOverride();
+    if (!url)
+        return [];
+    return bunUsesRegistry(args) ? ["--registry", url] : [];
+}
+/** Whether the first bun subcommand resolves packages and accepts `--registry`. */
+export function bunUsesRegistry(args) {
+    const subcommand = args.find((arg) => !arg.startsWith("-"));
+    return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
+}
+/**
+ * `process.env` plus the runtime executable directory and registry aliases.
+ *
+ * The executable directory matters when this CLI was launched by absolute path:
+ * bun runs, but a lifecycle script that invokes `bun`/`node` by bare name would
+ * otherwise fail with `command not found`. Prepending `dirname(process.execPath)`
+ * (the running bun binary's dir) puts the runtime back on PATH.
+ */
+export function childEnv(extra) {
+    const env = { ...process.env, ...extra };
+    const runtimeBin = dirname(process.execPath);
+    const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+    if (!pathEntries.includes(runtimeBin)) {
+        env.PATH = [runtimeBin, ...pathEntries].join(delimiter);
+    }
+    const url = registryOverride();
+    if (url) {
+        // Both cases: env is case-sensitive on POSIX, and npm lowercases when reading.
+        env.npm_config_registry = url;
+        env.NPM_CONFIG_REGISTRY = url;
+    }
+    return env;
+}
+/**
+ * Resolve the argv prefix to run bun: the `bun` package's own bin when this CLI
+ * is itself running under bun (`process.execPath` is the bun binary), else a bare
+ * `bun` on PATH. No corepack/npx fallback - bun is the ambient runtime this
+ * toolchain requires.
+ */
+function resolveBunArgvImpl() {
+    // The running process IS bun in every supported path (the bin is `bun <file>`),
+    // so reuse it directly - no PATH lookup, no package-manager shim.
+    if (/\bbun\b/.test(process.execPath))
+        return [process.execPath];
+    return ["bun"];
+}
+/** Memoized `[command, ...prefix]` argv prefix to run bun. */
+export const resolveBunArgv = functionModule.memoize(resolveBunArgvImpl);
+/** Run bun with inherited stdio from `cwd`, forcing the resolved registry. */
+export function runBun(args, cwd) {
+    const [command, ...prefix] = resolveBunArgv();
+    const registryArgs = bunRegistryArgs(args);
+    if (registryArgs.length > 0) {
+        logger.info(`running bun with registry: ${registryArgs[1]}`);
+    }
+    exec.spawnSync(command, [...prefix, ...args, ...registryArgs], {
+        cwd,
+        check: true,
+        env: childEnv(),
+    });
+}
+/** Install workspace dependencies when `node_modules` or projen is missing. */
+export function ensureWorkspaceReady(root) {
+    if (needsInstall(root)) {
+        runBun(["install"], root);
+    }
+}
+/**
+ * Run projen with the given args from `root`. Prefers the installed `projen` bin
+ * via `bun run`, so the workspace's own engine + tasks are used.
+ */
+export function runProjen(args, root) {
+    const projenBin = join(root, "node_modules", ".bin", "projen");
+    if (existsSync(projenBin)) {
+        runBun([projenBin, ...args], root);
+        return;
+    }
+    // Fallback: resolve projen through bun's package runner.
+    runBun(["x", "projen", ...args], root);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bun.js","sourceRoot":"","sources":["../../src/bun.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * bun discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.\n *\n * ## Forcing a custom registry\n *\n * bun honors a `--registry <url>` flag on `bun install`/`bun add` and a project\n * `.npmrc`, but (like pnpm) ignores the `npm_config_registry` env var for its own\n * resolution. So a custom registry is forced through TWO channels, each where it\n * applies:\n *\n *  - {@link bunRegistryArgs} passes `--registry` to the package-resolving\n *    subcommands (`install`/`add`/`update`), never to `bun run`/`bunx`, whose\n *    trailing args belong to the script.\n *  - {@link childEnv} keeps `.npmrc`-style env aliases set for any nested\n *    npm-based tool, and (critically) puts the bun/node executable dir on PATH so\n *    a lifecycle script can invoke the runtime by bare name.\n *\n * `@dbx-tools/core`'s `npmRegistry({ overrideOnly: true })` returns nothing when\n * the effective registry IS npmjs, so none of this touches a default install.\n *\n * @module\n */\nimport { existsSync } from \"node:fs\";\nimport { delimiter, dirname, join } from \"node:path\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { functionModule, log } from \"@dbx-tools/shared-core\";\nimport { needsInstall } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bun\");\n\n/**\n * bun subcommands that resolve packages from a registry, and therefore accept a\n * meaningful `--registry`. Everything else (`run`, `x`, `pm`, ...) is left alone:\n * `run`/`x` forward trailing arguments to the script they run.\n */\nconst REGISTRY_SUBCOMMANDS = new Set([\"add\", \"install\", \"i\", \"update\", \"up\"]);\n\n/**\n * The registry to force onto child installs, or `undefined` when the effective\n * one is already the public default.\n *\n * `envVars: true` also consults `npm_config_registry` directly, because a\n * container may export it without any `.npmrc` for lookup. Memoized: resolution\n * shells out.\n */\nconst registryOverride = functionModule.memoize((): string | undefined =>\n  project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),\n);\n\n/** `--registry <url>` for a bun invocation, or `[]` when the subcommand doesn't resolve. */\nexport function bunRegistryArgs(args: readonly string[]): string[] {\n  const url = registryOverride();\n  if (!url) return [];\n  return bunUsesRegistry(args) ? [\"--registry\", url] : [];\n}\n\n/** Whether the first bun subcommand resolves packages and accepts `--registry`. */\nexport function bunUsesRegistry(args: readonly string[]): boolean {\n  const subcommand = args.find((arg) => !arg.startsWith(\"-\"));\n  return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);\n}\n\n/**\n * `process.env` plus the runtime executable directory and registry aliases.\n *\n * The executable directory matters when this CLI was launched by absolute path:\n * bun runs, but a lifecycle script that invokes `bun`/`node` by bare name would\n * otherwise fail with `command not found`. Prepending `dirname(process.execPath)`\n * (the running bun binary's dir) puts the runtime back on PATH.\n */\nexport function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = { ...process.env, ...extra };\n  const runtimeBin = dirname(process.execPath);\n  const pathEntries = (env.PATH ?? \"\").split(delimiter).filter(Boolean);\n  if (!pathEntries.includes(runtimeBin)) {\n    env.PATH = [runtimeBin, ...pathEntries].join(delimiter);\n  }\n  const url = registryOverride();\n  if (url) {\n    // Both cases: env is case-sensitive on POSIX, and npm lowercases when reading.\n    env.npm_config_registry = url;\n    env.NPM_CONFIG_REGISTRY = url;\n  }\n  return env;\n}\n\n/**\n * Resolve the argv prefix to run bun: the `bun` package's own bin when this CLI\n * is itself running under bun (`process.execPath` is the bun binary), else a bare\n * `bun` on PATH. No corepack/npx fallback - bun is the ambient runtime this\n * toolchain requires.\n */\nfunction resolveBunArgvImpl(): string[] {\n  // The running process IS bun in every supported path (the bin is `bun <file>`),\n  // so reuse it directly - no PATH lookup, no package-manager shim.\n  if (/\\bbun\\b/.test(process.execPath)) return [process.execPath];\n  return [\"bun\"];\n}\n\n/** Memoized `[command, ...prefix]` argv prefix to run bun. */\nexport const resolveBunArgv = functionModule.memoize(resolveBunArgvImpl);\n\n/** Run bun with inherited stdio from `cwd`, forcing the resolved registry. */\nexport function runBun(args: string[], cwd: string): void {\n  const [command, ...prefix] = resolveBunArgv();\n  const registryArgs = bunRegistryArgs(args);\n  if (registryArgs.length > 0) {\n    logger.info(`running bun with registry: ${registryArgs[1]}`);\n  }\n  exec.spawnSync(command, [...prefix, ...args, ...registryArgs], {\n    cwd,\n    check: true,\n    env: childEnv(),\n  });\n}\n\n/** Install workspace dependencies when `node_modules` or projen is missing. */\nexport function ensureWorkspaceReady(root: string): void {\n  if (needsInstall(root)) {\n    runBun([\"install\"], root);\n  }\n}\n\n/**\n * Run projen with the given args from `root`. Prefers the installed `projen` bin\n * via `bun run`, so the workspace's own engine + tasks are used.\n */\nexport function runProjen(args: string[], root: string): void {\n  const projenBin = join(root, \"node_modules\", \".bin\", \"projen\");\n  if (existsSync(projenBin)) {\n    runBun([projenBin, ...args], root);\n    return;\n  }\n  // Fallback: resolve projen through bun's package runner.\n  runBun([\"x\", \"projen\", ...args], root);\n}\n"]}

package/lib/src/cli.js

@@ -5,10 +5,10 @@
  */
 import { Command } from "commander";
 import { bootstrapWorkspace, ensureEngineCurrent, runInitialSynth, seedToolchain, } from "./bootstrap.js";
-import { ensureWorkspaceReady, runPnpm, runProjen } from "./pnpm.js";
+import { ensureWorkspaceReady, runBun, runProjen } from "./bun.js";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.js";
 /**
- * Prepare the workspace at `root`, then run `pnpm exec projen` with `projenArgs`.
+ * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.
  *
  * Three cases, in order:
  *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),
@@ -30,7 +30,7 @@ async function prepareAndRunProjen(projenArgs, startDir) {
     if (needsToolchain(root)) {
         seedToolchain(root);
         runInitialSynth(root);
-        runPnpm(["install", "--no-frozen-lockfile", "--force"], root);
+        runBun(["install"], root);
         return;
     }
     ensureWorkspaceReady(root);
@@ -49,4 +49,4 @@ export async function runCli(argv) {
     program.parse(argv);
     await prepareAndRunProjen(program.args);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bootstrap.ts","../src/cli.ts","../src/pnpm.ts","../src/root.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}
+{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}