@dbx-tools/core 0.6.89 → 0.6.91

package/lib/src/file.d.ts

@@ -10,3 +10,11 @@ import { Stats } from "node:fs";
  * "not there" and "not accessible" the same and never handle an exception.
  */
 export declare function statSync(path: string): Stats | undefined;
+/**
+ * Load and cache a parsed record by caller-defined source identity.
+ *
+ * Every result is cached, including empty records and `undefined`. Include every
+ * input that affects parsing in `key`, such as a file path plus a Databricks
+ * profile.
+ */
+export declare function cachedRecord<T extends Record<string, unknown>>(key: string, loader: () => T | undefined): T | undefined;

package/lib/src/file.js

@@ -4,6 +4,7 @@
  * @module
  */
 import { statSync as nodeStatSync } from "node:fs";
+const recordCache = new Map();
 /**
  * Best-effort `fs.stat` (sync). Returns `undefined` for a blank path or when the
  * path can't be stat'd (missing, permission denied, ...), so callers can treat
@@ -18,4 +19,18 @@ export function statSync(path) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxPQUFPLEVBQVMsUUFBUSxJQUFJLFlBQVksRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUUxRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBQyxJQUFZO0lBQ25DLElBQUksSUFBSSxFQUFFLENBQUM7UUFDVCxJQUFJLENBQUM7WUFDSCxPQUFPLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM1QixDQUFDO1FBQUMsTUFBTSxDQUFDLENBQUEsQ0FBQztJQUNaLENBQUM7SUFDRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGaWxlc3lzdGVtIHV0aWxpdGllczogYmVzdC1lZmZvcnQgYGZzLnN0YXRgIGhlbHBlcnMgdGhhdCBuZXZlciB0aHJvdy5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cbmltcG9ydCB7IFN0YXRzLCBzdGF0U3luYyBhcyBub2RlU3RhdFN5bmMgfSBmcm9tIFwibm9kZTpmc1wiO1xuXG4vKipcbiAqIEJlc3QtZWZmb3J0IGBmcy5zdGF0YCAoc3luYykuIFJldHVybnMgYHVuZGVmaW5lZGAgZm9yIGEgYmxhbmsgcGF0aCBvciB3aGVuIHRoZVxuICogcGF0aCBjYW4ndCBiZSBzdGF0J2QgKG1pc3NpbmcsIHBlcm1pc3Npb24gZGVuaWVkLCAuLi4pLCBzbyBjYWxsZXJzIGNhbiB0cmVhdFxuICogXCJub3QgdGhlcmVcIiBhbmQgXCJub3QgYWNjZXNzaWJsZVwiIHRoZSBzYW1lIGFuZCBuZXZlciBoYW5kbGUgYW4gZXhjZXB0aW9uLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc3RhdFN5bmMocGF0aDogc3RyaW5nKTogU3RhdHMgfCB1bmRlZmluZWQge1xuICBpZiAocGF0aCkge1xuICAgIHRyeSB7XG4gICAgICByZXR1cm4gbm9kZVN0YXRTeW5jKHBhdGgpO1xuICAgIH0gY2F0Y2gge31cbiAgfVxuICByZXR1cm4gdW5kZWZpbmVkO1xufVxuIl19
+/**
+ * Load and cache a parsed record by caller-defined source identity.
+ *
+ * Every result is cached, including empty records and `undefined`. Include every
+ * input that affects parsing in `key`, such as a file path plus a Databricks
+ * profile.
+ */
+export function cachedRecord(key, loader) {
+    if (recordCache.has(key))
+        return recordCache.get(key);
+    const value = loader();
+    recordCache.set(key, value);
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/project.d.ts

@@ -1,8 +1,9 @@
 import { Stats } from "node:fs";
 import { net } from "@dbx-tools/shared-core";
+/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */
+export declare function resolveWorkingDirectory(cwd?: string | null): string;
 /** A command's stdout, classified as a filesystem path and/or a URL. */
 export interface ProjectContext {
-    readonly cwd: string;
     readonly output: string;
     /** `output` when it names something on disk. */
     readonly path?: string;
@@ -37,8 +38,8 @@ export declare function name(cwd?: string): string;
 /**
  * The repo's canonical remote URL, or `undefined` when there is no git remote.
  * Tries `gh repo view` first (host-accurate, no parsing), then normalizes
- * `git remote get-url origin`. Both underlying commands are cached per `cwd` via
- * {@link projectContextCommand}.
+ * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`
+ * reuses cached command probes; another resolved directory executes directly.
  *
  * @param cwd - directory to resolve from (defaults to `process.cwd()`).
  * @param format - `"https"` (default) yields `https://host/owner/repo`;
@@ -49,7 +50,9 @@ export declare function repositoryUrl(cwd?: string, format?: "https" | "npm"): s
 /**
  * The active npm registry (`npm config get registry`) as a chainable
  * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.
- * Cached per `cwd` via {@link projectContextCommand}.
+ * A blank, null, omitted, or explicitly current `cwd` reuses the cached npm
+ * command; another resolved directory executes it directly. Environment options
+ * are evaluated on every call.
  */
 export declare function npmRegistry(cwd?: string | null, options?: {
     overrideOnly?: boolean;

package/lib/src/project.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { context, json, net, string } from "@dbx-tools/shared-core";
+import { json, net, string } from "@dbx-tools/shared-core";
 import { statSync as fileStatSync } from "./file.js";
 const ROOT_MARKERS = [
     ".projenrc.ts",
@@ -10,6 +10,10 @@ const ROOT_MARKERS = [
     ".projenrc.cjs",
     "package.json",
 ];
+/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */
+export function resolveWorkingDirectory(cwd) {
+    return resolve(string.trimToNull(cwd) ?? process.cwd());
+}
 /**
  * because this is crucial do not use exec.spawnSync
  *
@@ -28,38 +32,43 @@ function projectContextCommandOutput(command, args, cwd) {
         // `http://localhost/…`), which would mislabel directory outputs and bare
         // tokens - so gate on the raw output already carrying a scheme + authority.
         const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(output) ? net.urlBuilder(output) : undefined;
-        return { cwd, output, path: pathStats ? output : undefined, pathStats, url };
+        return { output, path: pathStats ? output : undefined, pathStats, url };
     }
-    return { cwd, output };
+    return { output };
 }
-/**
- * {@link projectContextCommandOutput} through the process-context cache.
- *
- * These commands (`npm prefix`, `git rev-parse`, `gh repo view`) are pure
- * functions of the directory they run in, so their output is worth keeping - but
- * only while the process is still IN that directory. {@link context.cached}
- * owns that rule: the slot remembers the `cwd` it was loaded under and misses
- * once the process moves, and a lookup for some OTHER directory runs the command
- * without caching, so it can't evict the hot entry. The slot name carries the
- * command and its arguments (order-sensitive), so two commands never share one.
- */
+const projectCommandCache = new Map();
 function projectContextCommand(command, args, cwd) {
-    return context.cached(["project", command, ...args], (resolved) => projectContextCommandOutput(command, args, resolved ?? resolve(cwd ?? ".")), cwd ? resolve(cwd) : undefined);
+    const resolved = resolveWorkingDirectory(cwd);
+    const key = resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;
+    if (key !== undefined) {
+        const cached = projectCommandCache.get(key);
+        if (cached !== undefined)
+            return cached;
+    }
+    const value = projectContextCommandOutput(command, args, resolved);
+    if (key !== undefined)
+        projectCommandCache.set(key, value);
+    return value;
 }
-function npmRoot(cwd) {
-    const parsed = projectContextCommand("npm", ["prefix"], cwd);
+function commandRoot(command, args, cwd) {
+    const parsed = projectContextCommand(command, args, cwd);
     return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
 }
+function npmRoot(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    return commandRoot("npm", ["prefix"], resolved);
+}
 function gitRoot(cwd) {
-    const parsed = projectContextCommand("git", ["rev-parse", "--show-toplevel"], cwd);
-    return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+    const resolved = resolveWorkingDirectory(cwd);
+    return commandRoot("git", ["rev-parse", "--show-toplevel"], resolved);
 }
-export function root(cwd = process.cwd()) {
-    let current = resolve(cwd);
+export function root(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    let current = resolved;
     if (!fileStatSync(current)?.isDirectory()) {
         current = dirname(current);
     }
-    const boundaries = new Set([npmRoot(cwd), gitRoot(cwd)]
+    const boundaries = new Set([npmRoot(resolved), gitRoot(resolved)]
         .filter((path) => path !== undefined)
         .map((path) => resolve(path)));
     const hasBoundary = boundaries.size > 0;
@@ -119,8 +128,8 @@ function lastPathSegment(path) {
  * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;
  * only existing directories are yielded (except the final `cwd` fallback).
  */
-export function* resolveProjectRoots(cwd = process.cwd()) {
-    const base = resolve(cwd);
+export function* resolveProjectRoots(cwd) {
+    const base = resolveWorkingDirectory(cwd);
     const seen = new Set();
     for (const candidate of [npmRoot(base), gitRoot(base)]) {
         if (!candidate)
@@ -136,22 +145,23 @@ export function* resolveProjectRoots(cwd = process.cwd()) {
         yield base;
 }
 /** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */
-function workspaceRoot(cwd = process.cwd()) {
+function workspaceRoot(cwd) {
     let last;
     for (const dir of resolveProjectRoots(cwd)) {
         if (fileStatSync(resolve(dir, "package.json"))?.isFile())
             return dir;
         last = dir;
     }
-    return last ?? resolve(cwd);
+    return last ?? resolveWorkingDirectory(cwd);
 }
 /**
  * Resolve a human-friendly project name for the repo rooted at `cwd`:
  * `package.json` `name`, then the git remote's repo name, then the root
  * directory's basename.
  */
-export function name(cwd = process.cwd()) {
-    const rootDir = workspaceRoot(cwd);
+export function name(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    const rootDir = workspaceRoot(resolved);
     const fromPackage = readPackageName(resolve(rootDir, "package.json"));
     if (fromPackage)
         return fromPackage;
@@ -214,16 +224,17 @@ function repositoryUrlFromGit(cwd) {
 /**
  * The repo's canonical remote URL, or `undefined` when there is no git remote.
  * Tries `gh repo view` first (host-accurate, no parsing), then normalizes
- * `git remote get-url origin`. Both underlying commands are cached per `cwd` via
- * {@link projectContextCommand}.
+ * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`
+ * reuses cached command probes; another resolved directory executes directly.
  *
  * @param cwd - directory to resolve from (defaults to `process.cwd()`).
  * @param format - `"https"` (default) yields `https://host/owner/repo`;
  *   `"npm"` yields npm's `git+https://host/owner/repo.git` form (for a
  *   `package.json` `repository.url` that passes npm provenance).
  */
-export function repositoryUrl(cwd = process.cwd(), format = "https") {
-    const https = repositoryUrlFromGh(cwd) ?? repositoryUrlFromGit(cwd);
+export function repositoryUrl(cwd, format = "https") {
+    const resolved = resolveWorkingDirectory(cwd);
+    const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);
     if (!https)
         return undefined;
     return format === "npm" ? `git+${https.replace(/\.git$/, "")}.git` : https;
@@ -231,9 +242,15 @@ export function repositoryUrl(cwd = process.cwd(), format = "https") {
 /**
  * The active npm registry (`npm config get registry`) as a chainable
  * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.
- * Cached per `cwd` via {@link projectContextCommand}.
+ * A blank, null, omitted, or explicitly current `cwd` reuses the cached npm
+ * command; another resolved directory executes it directly. Environment options
+ * are evaluated on every call.
  */
 export function npmRegistry(cwd, options) {
+    const resolved = resolveWorkingDirectory(cwd);
+    return resolveNpmRegistry(resolved, options);
+}
+function resolveNpmRegistry(cwd, options) {
     const candidates = (function* () {
         yield projectContextCommand("npm", ["config", "get", "registry"], cwd ?? undefined).output?.trim();
         if (typeof process !== "undefined" && process?.env) {
@@ -273,6 +290,6 @@ if (import.meta.main) {
     console.log("package root:", root());
     console.log("project name:", name());
     console.log("repository url:", repositoryUrl());
-    console.log("repository url (npm):", repositoryUrl(process.cwd(), "npm"));
+    console.log("repository url (npm):", repositoryUrl(undefined, "npm"));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/project.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { context, json, net, string } from \"@dbx-tools/shared-core\";\nimport { statSync as fileStatSync } from \"./file.ts\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly cwd: string;\n  readonly output: string;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `file.statSync` of {@link path}, when it exists. */\n  readonly pathStats?: Stats;\n  /**\n   * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real\n   * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.\n   * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.\n   */\n  readonly url?: net.UrlBuilder;\n}\n\n/**\n * because this is crucial do not use exec.spawnSync\n *\n * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when\n * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it\n * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit\n * or empty output.\n */\nfunction projectContextCommandOutput(command: string, args: string[], cwd: string): ProjectContext {\n  const result = spawnSync(command, args, { cwd, stdio: [\"ignore\", \"pipe\", \"ignore\"] });\n  const output = result?.stdout?.toString()?.trim();\n  if (result.status === 0 && output) {\n    const pathStats = fileStatSync(output);\n    // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise\n    // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->\n    // `http://localhost/…`), which would mislabel directory outputs and bare\n    // tokens - so gate on the raw output already carrying a scheme + authority.\n    const url = /^[a-z][a-z0-9+.-]*:\\/\\//i.test(output) ? net.urlBuilder(output) : undefined;\n    return { cwd, output, path: pathStats ? output : undefined, pathStats, url };\n  }\n  return { cwd, output };\n}\n\n/**\n * {@link projectContextCommandOutput} through the process-context cache.\n *\n * These commands (`npm prefix`, `git rev-parse`, `gh repo view`) are pure\n * functions of the directory they run in, so their output is worth keeping - but\n * only while the process is still IN that directory. {@link context.cached}\n * owns that rule: the slot remembers the `cwd` it was loaded under and misses\n * once the process moves, and a lookup for some OTHER directory runs the command\n * without caching, so it can't evict the hot entry. The slot name carries the\n * command and its arguments (order-sensitive), so two commands never share one.\n */\nfunction projectContextCommand(command: string, args: string[], cwd?: string): ProjectContext {\n  return context.cached(\n    [\"project\", command, ...args],\n    (resolved) => projectContextCommandOutput(command, args, resolved ?? resolve(cwd ?? \".\")),\n    cwd ? resolve(cwd) : undefined,\n  );\n}\n\nfunction npmRoot(cwd?: string): string | undefined {\n  const parsed = projectContextCommand(\"npm\", [\"prefix\"], cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const parsed = projectContextCommand(\"git\", [\"rev-parse\", \"--show-toplevel\"], cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nexport function root(cwd: string = process.cwd()): string | undefined {\n  let current = resolve(cwd);\n\n  if (!fileStatSync(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmRoot(cwd), gitRoot(cwd)]\n      .filter((path): path is string => path !== undefined)\n      .map((path) => resolve(path)),\n  );\n  const hasBoundary = boundaries.size > 0;\n  let best: { dir: string; priority: number } | undefined;\n  while (true) {\n    for (const [priority, marker] of ROOT_MARKERS.entries()) {\n      if (fileStatSync(join(current, marker))?.isFile()) {\n        if (\n          best === undefined ||\n          priority < best.priority ||\n          (priority === best.priority && current.length < best.dir.length)\n        ) {\n          best = { dir: current, priority };\n        }\n        break;\n      }\n    }\n    if (!hasBoundary && best) {\n      return best.dir;\n    }\n    if (boundaries.has(current)) {\n      return best?.dir;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      return best?.dir;\n    }\n    current = parent;\n  }\n}\n\n/**\n * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and\n * return the repo segment, stripping any `.git` suffix. Returns `undefined` for\n * empty or unparsable input.\n */\nexport function parseGitRemote(url: string): string | undefined {\n  const trimmed = url.trim();\n  if (!trimmed) return undefined;\n\n  const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);\n  if (scp) return lastPathSegment(scp[1] ?? \"\");\n\n  try {\n    const normalized = trimmed.replace(/\\.git$/i, \"\");\n    const pathname = new URL(normalized).pathname;\n    const segment = pathname.split(\"/\").filter(Boolean).at(-1);\n    return segment ? lastPathSegment(segment) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction lastPathSegment(path: string): string {\n  const segment = path.split(\"/\").filter(Boolean).at(-1) ?? path;\n  return segment.replace(/\\.git$/i, \"\");\n}\n\n/**\n * Yield candidate project-root directories for `cwd`, in priority order: the\n * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;\n * only existing directories are yielded (except the final `cwd` fallback).\n */\nexport function* resolveProjectRoots(cwd: string = process.cwd()): Generator<string> {\n  const base = resolve(cwd);\n  const seen = new Set<string>();\n  for (const candidate of [npmRoot(base), gitRoot(base)]) {\n    if (!candidate) continue;\n    const dir = resolve(candidate);\n    if (seen.has(dir)) continue;\n    seen.add(dir);\n    if (fileStatSync(dir)?.isDirectory()) yield dir;\n  }\n  if (!seen.has(base)) yield base;\n}\n\n/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */\nfunction workspaceRoot(cwd: string = process.cwd()): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (fileStatSync(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolve(cwd);\n}\n\n/**\n * Resolve a human-friendly project name for the repo rooted at `cwd`:\n * `package.json` `name`, then the git remote's repo name, then the root\n * directory's basename.\n */\nexport function name(cwd: string = process.cwd()): string {\n  const rootDir = workspaceRoot(cwd);\n\n  const fromPackage = readPackageName(resolve(rootDir, \"package.json\"));\n  if (fromPackage) return fromPackage;\n\n  const remote = projectContextCommand(\n    \"git\",\n    [\"-C\", rootDir, \"remote\", \"get-url\", \"origin\"],\n    rootDir,\n  ).output;\n  const fromGit = remote ? parseGitRemote(remote) : undefined;\n  if (fromGit) return fromGit;\n\n  return basename(rootDir);\n}\n\n/**\n * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the\n * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.\n * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.\n */\nfunction repositoryUrlFromGh(cwd?: string): string | undefined {\n  const out = projectContextCommand(\"gh\", [\"repo\", \"view\", \"--json\", \"url\"], cwd).output;\n  return string.trimToNull(json.parseRecord(out)?.url) ?? undefined;\n}\n\n/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */\nfunction resolveSshHostName(host: string, cwd?: string): string | undefined {\n  const line = projectContextCommand(\"ssh\", [\"-G\", host], cwd)\n    .output?.split(\"\\n\")\n    .find((l) => /^hostname\\s/i.test(l.trim()));\n  const name = line?.trim().split(/\\s+/)[1];\n  return name && name !== host ? name : undefined;\n}\n\n/**\n * Fallback: normalize `git remote get-url origin` to a plain\n * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /\n * embedded-credential forms are rewritten to https, and an ssh host alias is\n * followed to its real hostname.\n */\nfunction repositoryUrlFromGit(cwd?: string): string | undefined {\n  const raw = projectContextCommand(\"git\", [\"remote\", \"get-url\", \"origin\"], cwd).output;\n  if (!raw) return undefined;\n\n  // Normalize the scheme to https at the string level first: the WHATWG `URL`\n  // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the\n  // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at\n  // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}\n  // own the structured edits (strip credentials, swap the host).\n  let https = raw.replace(/^git\\+/, \"\");\n  const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);\n  if (scp) https = `https://${scp[1]}/${scp[2]}`;\n  https = https.replace(/^(ssh|git):\\/\\//, \"https://\");\n\n  let builder = net.urlBuilder(https);\n  if (!builder) return undefined;\n  // Drop any embedded `user[:pass]@` credentials.\n  if (builder.username || builder.password) {\n    builder = builder.with(\"username\", \"\").with(\"password\", \"\");\n  }\n  // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).\n  const realHost = resolveSshHostName(builder.hostname, cwd);\n  if (realHost) builder = builder.with(\"hostname\", realHost);\n\n  return `${builder.origin}${builder.pathname.replace(/\\.git$/, \"\")}`;\n}\n\n/**\n * The repo's canonical remote URL, or `undefined` when there is no git remote.\n * Tries `gh repo view` first (host-accurate, no parsing), then normalizes\n * `git remote get-url origin`. Both underlying commands are cached per `cwd` via\n * {@link projectContextCommand}.\n *\n * @param cwd - directory to resolve from (defaults to `process.cwd()`).\n * @param format - `\"https\"` (default) yields `https://host/owner/repo`;\n *   `\"npm\"` yields npm's `git+https://host/owner/repo.git` form (for a\n *   `package.json` `repository.url` that passes npm provenance).\n */\nexport function repositoryUrl(\n  cwd: string = process.cwd(),\n  format: \"https\" | \"npm\" = \"https\",\n): string | undefined {\n  const https = repositoryUrlFromGh(cwd) ?? repositoryUrlFromGit(cwd);\n  if (!https) return undefined;\n  return format === \"npm\" ? `git+${https.replace(/\\.git$/, \"\")}.git` : https;\n}\n\n/**\n * The active npm registry (`npm config get registry`) as a chainable\n * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.\n * Cached per `cwd` via {@link projectContextCommand}.\n */\nexport function npmRegistry(\n  cwd?: string | null,\n  options?: { overrideOnly?: boolean; envVars?: boolean },\n): net.UrlBuilder | undefined {\n  const candidates = (function* () {\n    yield projectContextCommand(\n      \"npm\",\n      [\"config\", \"get\", \"registry\"],\n      cwd ?? undefined,\n    ).output?.trim();\n    if (typeof process !== \"undefined\" && process?.env) {\n      const envKey = \"npm_config_registry\";\n      if (options?.envVars) {\n        yield process.env[envKey];\n        yield process.env[envKey.toUpperCase()];\n      }\n    }\n  })();\n  for (const candidate of candidates) {\n    if (candidate) {\n      const url = net.urlBuilder(candidate);\n      if (!url) {\n        continue;\n      } else if (options?.overrideOnly) {\n        const npmjsRegistryUrl = \"https://registry.npmjs.org\";\n        const registryUrl = url.toString();\n        if (registryUrl === npmjsRegistryUrl || registryUrl.startsWith(npmjsRegistryUrl + \"/\")) {\n          continue;\n        }\n      }\n      return url;\n    }\n  }\n  return undefined;\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!fileStatSync(pkgPath)?.isFile()) return undefined;\n  return string.trimToNull(json.parseRecord(readFileSync(pkgPath, \"utf8\"))?.name) ?? undefined;\n}\n\nif (import.meta.main) {\n  console.log(\"npm root:\", npmRoot());\n  console.log(\"repo root:\", gitRoot());\n  console.log(\"package root:\", root());\n  console.log(\"project name:\", name());\n  console.log(\"repository url:\", repositoryUrl());\n  console.log(\"repository url (npm):\", repositoryUrl(process.cwd(), \"npm\"));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/project.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { json, net, string } from \"@dbx-tools/shared-core\";\nimport { statSync as fileStatSync } from \"./file.ts\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */\nexport function resolveWorkingDirectory(cwd?: string | null): string {\n  return resolve(string.trimToNull(cwd) ?? process.cwd());\n}\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly output: string;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `file.statSync` of {@link path}, when it exists. */\n  readonly pathStats?: Stats;\n  /**\n   * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real\n   * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.\n   * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.\n   */\n  readonly url?: net.UrlBuilder;\n}\n\n/**\n * because this is crucial do not use exec.spawnSync\n *\n * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when\n * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it\n * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit\n * or empty output.\n */\nfunction projectContextCommandOutput(command: string, args: string[], cwd: string): ProjectContext {\n  const result = spawnSync(command, args, { cwd, stdio: [\"ignore\", \"pipe\", \"ignore\"] });\n  const output = result?.stdout?.toString()?.trim();\n  if (result.status === 0 && output) {\n    const pathStats = fileStatSync(output);\n    // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise\n    // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->\n    // `http://localhost/…`), which would mislabel directory outputs and bare\n    // tokens - so gate on the raw output already carrying a scheme + authority.\n    const url = /^[a-z][a-z0-9+.-]*:\\/\\//i.test(output) ? net.urlBuilder(output) : undefined;\n    return { output, path: pathStats ? output : undefined, pathStats, url };\n  }\n  return { output };\n}\n\nconst projectCommandCache = new Map<string, ProjectContext>();\n\nfunction projectContextCommand(command: string, args: string[], cwd?: string): ProjectContext {\n  const resolved = resolveWorkingDirectory(cwd);\n  const key =\n    resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;\n  if (key !== undefined) {\n    const cached = projectCommandCache.get(key);\n    if (cached !== undefined) return cached;\n  }\n  const value = projectContextCommandOutput(command, args, resolved);\n  if (key !== undefined) projectCommandCache.set(key, value);\n  return value;\n}\n\nfunction commandRoot(command: string, args: string[], cwd: string): string | undefined {\n  const parsed = projectContextCommand(command, args, cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nfunction npmRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return commandRoot(\"npm\", [\"prefix\"], resolved);\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return commandRoot(\"git\", [\"rev-parse\", \"--show-toplevel\"], resolved);\n}\n\nexport function root(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  let current = resolved;\n\n  if (!fileStatSync(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmRoot(resolved), gitRoot(resolved)]\n      .filter((path): path is string => path !== undefined)\n      .map((path) => resolve(path)),\n  );\n  const hasBoundary = boundaries.size > 0;\n  let best: { dir: string; priority: number } | undefined;\n  while (true) {\n    for (const [priority, marker] of ROOT_MARKERS.entries()) {\n      if (fileStatSync(join(current, marker))?.isFile()) {\n        if (\n          best === undefined ||\n          priority < best.priority ||\n          (priority === best.priority && current.length < best.dir.length)\n        ) {\n          best = { dir: current, priority };\n        }\n        break;\n      }\n    }\n    if (!hasBoundary && best) {\n      return best.dir;\n    }\n    if (boundaries.has(current)) {\n      return best?.dir;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      return best?.dir;\n    }\n    current = parent;\n  }\n}\n\n/**\n * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and\n * return the repo segment, stripping any `.git` suffix. Returns `undefined` for\n * empty or unparsable input.\n */\nexport function parseGitRemote(url: string): string | undefined {\n  const trimmed = url.trim();\n  if (!trimmed) return undefined;\n\n  const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);\n  if (scp) return lastPathSegment(scp[1] ?? \"\");\n\n  try {\n    const normalized = trimmed.replace(/\\.git$/i, \"\");\n    const pathname = new URL(normalized).pathname;\n    const segment = pathname.split(\"/\").filter(Boolean).at(-1);\n    return segment ? lastPathSegment(segment) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction lastPathSegment(path: string): string {\n  const segment = path.split(\"/\").filter(Boolean).at(-1) ?? path;\n  return segment.replace(/\\.git$/i, \"\");\n}\n\n/**\n * Yield candidate project-root directories for `cwd`, in priority order: the\n * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;\n * only existing directories are yielded (except the final `cwd` fallback).\n */\nexport function* resolveProjectRoots(cwd?: string): Generator<string> {\n  const base = resolveWorkingDirectory(cwd);\n  const seen = new Set<string>();\n  for (const candidate of [npmRoot(base), gitRoot(base)]) {\n    if (!candidate) continue;\n    const dir = resolve(candidate);\n    if (seen.has(dir)) continue;\n    seen.add(dir);\n    if (fileStatSync(dir)?.isDirectory()) yield dir;\n  }\n  if (!seen.has(base)) yield base;\n}\n\n/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */\nfunction workspaceRoot(cwd?: string): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (fileStatSync(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolveWorkingDirectory(cwd);\n}\n\n/**\n * Resolve a human-friendly project name for the repo rooted at `cwd`:\n * `package.json` `name`, then the git remote's repo name, then the root\n * directory's basename.\n */\nexport function name(cwd?: string): string {\n  const resolved = resolveWorkingDirectory(cwd);\n  const rootDir = workspaceRoot(resolved);\n\n  const fromPackage = readPackageName(resolve(rootDir, \"package.json\"));\n  if (fromPackage) return fromPackage;\n\n  const remote = projectContextCommand(\n    \"git\",\n    [\"-C\", rootDir, \"remote\", \"get-url\", \"origin\"],\n    rootDir,\n  ).output;\n  const fromGit = remote ? parseGitRemote(remote) : undefined;\n  if (fromGit) return fromGit;\n\n  return basename(rootDir);\n}\n\n/**\n * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the\n * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.\n * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.\n */\nfunction repositoryUrlFromGh(cwd?: string): string | undefined {\n  const out = projectContextCommand(\"gh\", [\"repo\", \"view\", \"--json\", \"url\"], cwd).output;\n  return string.trimToNull(json.parseRecord(out)?.url) ?? undefined;\n}\n\n/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */\nfunction resolveSshHostName(host: string, cwd?: string): string | undefined {\n  const line = projectContextCommand(\"ssh\", [\"-G\", host], cwd)\n    .output?.split(\"\\n\")\n    .find((l) => /^hostname\\s/i.test(l.trim()));\n  const name = line?.trim().split(/\\s+/)[1];\n  return name && name !== host ? name : undefined;\n}\n\n/**\n * Fallback: normalize `git remote get-url origin` to a plain\n * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /\n * embedded-credential forms are rewritten to https, and an ssh host alias is\n * followed to its real hostname.\n */\nfunction repositoryUrlFromGit(cwd?: string): string | undefined {\n  const raw = projectContextCommand(\"git\", [\"remote\", \"get-url\", \"origin\"], cwd).output;\n  if (!raw) return undefined;\n\n  // Normalize the scheme to https at the string level first: the WHATWG `URL`\n  // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the\n  // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at\n  // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}\n  // own the structured edits (strip credentials, swap the host).\n  let https = raw.replace(/^git\\+/, \"\");\n  const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);\n  if (scp) https = `https://${scp[1]}/${scp[2]}`;\n  https = https.replace(/^(ssh|git):\\/\\//, \"https://\");\n\n  let builder = net.urlBuilder(https);\n  if (!builder) return undefined;\n  // Drop any embedded `user[:pass]@` credentials.\n  if (builder.username || builder.password) {\n    builder = builder.with(\"username\", \"\").with(\"password\", \"\");\n  }\n  // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).\n  const realHost = resolveSshHostName(builder.hostname, cwd);\n  if (realHost) builder = builder.with(\"hostname\", realHost);\n\n  return `${builder.origin}${builder.pathname.replace(/\\.git$/, \"\")}`;\n}\n\n/**\n * The repo's canonical remote URL, or `undefined` when there is no git remote.\n * Tries `gh repo view` first (host-accurate, no parsing), then normalizes\n * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`\n * reuses cached command probes; another resolved directory executes directly.\n *\n * @param cwd - directory to resolve from (defaults to `process.cwd()`).\n * @param format - `\"https\"` (default) yields `https://host/owner/repo`;\n *   `\"npm\"` yields npm's `git+https://host/owner/repo.git` form (for a\n *   `package.json` `repository.url` that passes npm provenance).\n */\nexport function repositoryUrl(cwd?: string, format: \"https\" | \"npm\" = \"https\"): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);\n  if (!https) return undefined;\n  return format === \"npm\" ? `git+${https.replace(/\\.git$/, \"\")}.git` : https;\n}\n\n/**\n * The active npm registry (`npm config get registry`) as a chainable\n * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.\n * A blank, null, omitted, or explicitly current `cwd` reuses the cached npm\n * command; another resolved directory executes it directly. Environment options\n * are evaluated on every call.\n */\nexport function npmRegistry(\n  cwd?: string | null,\n  options?: { overrideOnly?: boolean; envVars?: boolean },\n): net.UrlBuilder | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return resolveNpmRegistry(resolved, options);\n}\n\nfunction resolveNpmRegistry(\n  cwd: string | null | undefined,\n  options: { overrideOnly?: boolean; envVars?: boolean } | undefined,\n): net.UrlBuilder | undefined {\n  const candidates = (function* () {\n    yield projectContextCommand(\n      \"npm\",\n      [\"config\", \"get\", \"registry\"],\n      cwd ?? undefined,\n    ).output?.trim();\n    if (typeof process !== \"undefined\" && process?.env) {\n      const envKey = \"npm_config_registry\";\n      if (options?.envVars) {\n        yield process.env[envKey];\n        yield process.env[envKey.toUpperCase()];\n      }\n    }\n  })();\n  for (const candidate of candidates) {\n    if (candidate) {\n      const url = net.urlBuilder(candidate);\n      if (!url) {\n        continue;\n      } else if (options?.overrideOnly) {\n        const npmjsRegistryUrl = \"https://registry.npmjs.org\";\n        const registryUrl = url.toString();\n        if (registryUrl === npmjsRegistryUrl || registryUrl.startsWith(npmjsRegistryUrl + \"/\")) {\n          continue;\n        }\n      }\n      return url;\n    }\n  }\n  return undefined;\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!fileStatSync(pkgPath)?.isFile()) return undefined;\n  return string.trimToNull(json.parseRecord(readFileSync(pkgPath, \"utf8\"))?.name) ?? undefined;\n}\n\nif (import.meta.main) {\n  console.log(\"npm root:\", npmRoot());\n  console.log(\"repo root:\", gitRoot());\n  console.log(\"package root:\", root());\n  console.log(\"project name:\", name());\n  console.log(\"repository url:\", repositoryUrl());\n  console.log(\"repository url (npm):\", repositoryUrl(undefined, \"npm\"));\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bin.ts","../src/brand.ts","../src/config.ts","../src/exec.ts","../src/file-lock.ts","../src/file.ts","../src/process-lock.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/bin.ts","../src/brand.ts","../src/bundle.ts","../src/config.ts","../src/exec.ts","../src/file-lock.ts","../src/file.ts","../src/process-lock.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -23,7 +23,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.89",
+    "@dbx-tools/shared-core": "0.6.91",
     "extract-zip": "^2.0.1",
     "tar": "^7.5.22",
     "yaml": "^2.9.0",
@@ -43,7 +43,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.89",
+  "version": "0.6.91",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/bundle.ts

@@ -0,0 +1,211 @@
+/**
+ * Streaming discovery of Databricks bundle App resources.
+ *
+ * Bundle files are found with native filesystem traversal inside a hard project
+ * boundary. Each candidate is resolved through `databricks bundle validate
+ * --output json` so includes, targets, variables, and App configuration follow
+ * the Databricks CLI's semantics.
+ *
+ * @module
+ */
+
+import { opendir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { json, object, string } from "@dbx-tools/shared-core";
+import { spawn } from "./exec.ts";
+import { resolveWorkingDirectory } from "./project.ts";
+import { project } from "../index.ts";
+
+const BUNDLE_FILE_NAMES = new Set(["databricks.yml", "databricks.yaml"]);
+const IGNORED_DIRECTORIES = [
+  /^\..*/,
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "target",
+  "tmp",
+  "vendor",
+] as const;
+
+type AppResource = {
+  /** Absolute path to the bundle's root configuration file. */
+  bundlePath: string;
+  /** Resource key under `resources.apps`. */
+  key: string;
+  /** Absolute source directory resolved from `source_code_path`. */
+  sourceCodePath?: string;
+  /** App resource returned by `databricks bundle validate`. */
+  config: Record<string, unknown>;
+  /** Complete resolved bundle returned by `databricks bundle validate`. */
+  data: Record<string, unknown>;
+  /** Validation failure associated with partial bundle output. */
+  bundleFailure?: Error;
+};
+
+/**
+ * Stream every App resource in bundles under `projectBoundary`.
+ *
+ * `cwd` defaults to the current directory and may name a file or directory.
+ * Bundle files in its ancestor chain are checked before the rest of the project
+ * boundary. No App YAML file is required.
+ *
+ * A missing or invalid boundary/cwd, or a cwd outside the boundary, yields
+ * nothing. A non-zero validation with partial JSON attaches
+ * `bundleFailure` to each App resource parsed from that bundle. A failed
+ * validation with no App resources yields nothing.
+ */
+export async function* appResources(
+  projectBoundary: string,
+  cwd?: string,
+): AsyncGenerator<AppResource, void, void> {
+  const boundary = await resolveDirectory(projectBoundary);
+  const startDirectory = await resolveStartDirectory(cwd);
+  if (!boundary || !startDirectory || !isWithinOrEqual(startDirectory, boundary)) {
+    return;
+  }
+
+  for await (const bundlePath of bundlePaths(boundary, startDirectory)) {
+    const validated = await validateBundle(bundlePath);
+    for (const [key, config] of Object.entries(bundleApps(validated.data))) {
+      if (!object.isRecord(config)) continue;
+      yield {
+        bundlePath,
+        key,
+        config,
+        data: validated.data,
+        ...object.optional(
+          "sourceCodePath",
+          resolveSourceCodePath(bundlePath, config.source_code_path),
+        ),
+        ...object.optional("bundleFailure", validated.bundleFailure),
+      };
+    }
+  }
+}
+
+async function resolveDirectory(value: string): Promise<string | undefined> {
+  try {
+    const resolved = await realpath(resolve(value));
+    return (await stat(resolved)).isDirectory() ? resolved : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveStartDirectory(cwd?: string): Promise<string | undefined> {
+  try {
+    const resolved = await realpath(resolveWorkingDirectory(cwd));
+    const info = await stat(resolved);
+    if (info.isDirectory()) return resolved;
+    if (info.isFile()) return dirname(resolved);
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveSourceCodePath(bundlePath: string, sourceCodePath: unknown): string | undefined {
+  if (typeof sourceCodePath !== "string") return undefined;
+  return isAbsolute(sourceCodePath) ? sourceCodePath : resolve(dirname(bundlePath), sourceCodePath);
+}
+
+async function* bundlePaths(
+  boundary: string,
+  startDirectory: string,
+): AsyncGenerator<string, void, void> {
+  const seen = new Set<string>();
+  let current = startDirectory;
+  while (isWithinOrEqual(current, boundary)) {
+    for (const filename of BUNDLE_FILE_NAMES) {
+      const candidate = join(current, filename);
+      if (!(await isFile(candidate))) continue;
+      const resolved = await realpath(candidate);
+      if (seen.has(resolved)) continue;
+      seen.add(resolved);
+      yield resolved;
+    }
+    if (current === boundary) break;
+    current = dirname(current);
+  }
+
+  yield* descendBundlePaths(boundary, seen);
+}
+
+async function* descendBundlePaths(
+  directory: string,
+  seen: Set<string>,
+): AsyncGenerator<string, void, void> {
+  const entries = await opendir(directory);
+  for await (const entry of entries) {
+    const candidate = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      const ignored = IGNORED_DIRECTORIES.some((ignore) => {
+        if (ignore instanceof RegExp) return ignore.test(entry.name);
+        return ignore === entry.name;
+      });
+      if (!ignored) {
+        yield* descendBundlePaths(candidate, seen);
+      }
+      continue;
+    }
+    if (!entry.isFile() || !BUNDLE_FILE_NAMES.has(entry.name)) continue;
+    const resolved = await realpath(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    yield resolved;
+  }
+}
+
+async function validateBundle(
+  bundlePath: string,
+): Promise<Pick<AppResource, "data" | "bundleFailure">> {
+  const result = await spawn("databricks", ["bundle", "validate", "--output", "json"], {
+    cwd: dirname(bundlePath),
+    stdin: "ignore",
+    stdout: "capture",
+    stderr: "capture",
+  });
+  const detail = string.trimToNull(result.stderr) ?? string.trimToNull(result.stdout);
+  const bundleFailure =
+    result.exitCode === 0
+      ? undefined
+      : new Error(
+          `databricks bundle validate failed for ${bundlePath} (exit ${result.exitCode})${
+            detail ? `: ${detail}` : ""
+          }`,
+        );
+
+  const parsed = json.parseRecord(result.stdout);
+  if (!parsed) {
+    if (bundleFailure) return { data: {}, bundleFailure };
+    throw new Error(`Databricks CLI returned invalid bundle JSON for ${bundlePath}`);
+  }
+  return { data: parsed, ...object.optional("bundleFailure", bundleFailure) };
+}
+
+function bundleApps(bundle: Record<string, unknown>): Record<string, unknown> {
+  const resources = object.isRecord(bundle.resources) ? bundle.resources : undefined;
+  return object.isRecord(resources?.apps) ? resources.apps : {};
+}
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isWithinOrEqual(candidate: string, parent: string): boolean {
+  const path = relative(parent, candidate);
+  return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+
+if (import.meta.main) {
+  const path = process.argv[2];
+  if (!path) throw new Error("Usage: bun bundle.ts <path>");
+  for await (const resource of appResources(project.root()!, path)) {
+    console.dir(resource, { depth: null });
+  }
+}