@dbx-tools/core 0.6.90 → 0.6.91

package/README.md

@@ -15,6 +15,8 @@ Key features:
   arrays.
 - Workspace/project root discovery from package-manager files, git metadata, and
   the current working directory.
+- Asynchronous Databricks bundle App-resource streaming with native filesystem
+  traversal and CLI-resolved configuration.
 - Safe filesystem stat and project naming helpers for CLIs and projen synth.
 - Layered config from process env, environment-specific `.env` files, and the
   Databricks bundle's App `config.env`.
@@ -155,6 +157,29 @@ through one rule. `config.port()` accepts only TCP ports from 1 through 65535;
 `config.flattenBundleEnv()`, `flattenAppEnv()`, and `getBundlePath()` expose the
 same parsing logic for callers that already have parsed configuration data.
 
+## Discover Bundle App Resources
+
+```ts
+import { bundle } from "@dbx-tools/core";
+
+for await (const resource of bundle.appResources(projectRoot, cwd)) {
+  consume(resource);
+}
+```
+
+`appResources()` returns an async generator. It checks bundle files in the
+optional working directory's ancestor chain first, then traverses the project
+boundary with Node's asynchronous native filesystem APIs. It yields each `resources.apps` entry from
+`databricks bundle validate --output json`, so includes, targets, variables,
+and relative source paths are resolved by the Databricks CLI. It does not
+require `app.yml` or `app.yaml`. Each resource includes its App `config` and the
+complete resolved bundle `data`.
+
+A failed validation that still returns partial App resources attaches
+`bundleFailure` to those resources. Failed bundles with no App resources yield
+nothing. Missing, invalid, or out-of-bound project paths also yield nothing.
+Malformed successful CLI output throws while the generator is consumed.
+
 ## Run Commands
 
 ```ts
@@ -294,6 +319,7 @@ cached too.
 - `exec` - async/sync process spawning, stdio handling, abort wiring, and shlex.
 - `bin` - executable download, optional archive extraction, selection, and
   atomic installation.
+- `bundle` - asynchronous streaming of CLI-resolved Databricks bundle App resources.
 - `project` - cwd normalization, root discovery, project naming, and git-remote
   parsing.
 - `file` - best-effort stat and parsed-record caching by caller-defined source key.

package/index.ts

@@ -2,8 +2,10 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 
+export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
 export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
+export * as bundle from "./src/bundle.ts";
 export * as config from "./src/config.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";

package/lib/index.d.ts

@@ -1,5 +1,7 @@
+export declare const PACKAGE_IDENTIFIER = "@dbx-tools/core";
 export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
+export * as bundle from "./src/bundle.ts";
 export * as config from "./src/config.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";

package/lib/index.js

@@ -1,8 +1,10 @@
 // GENERATED by projen watch - DO NOT EDIT.
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
+export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
 export * as bin from "./src/bin.js";
 export * as brand from "./src/brand.js";
+export * as bundle from "./src/bundle.js";
 export * as config from "./src/config.js";
 export * as exec from "./src/exec.js";
 export * as file from "./src/file.js";
@@ -12,4 +14,4 @@ export * as project from "./src/project.js";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.js";
 export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config.js";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/bundle.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+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 declare function appResources(projectBoundary: string, cwd?: string): AsyncGenerator<AppResource, void, void>;
+export {};

package/lib/src/bundle.js

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