@dbx-tools/core 0.6.89 → 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`.
@@ -90,18 +92,39 @@ const timeoutMs = config.positiveInt(undefined, "TIMEOUT_MS", 30_000, {
 });
 ```
 
-Resolution is lazy and follows process env, `.env`, then Databricks bundle
-configuration. The default `DBX_TOOLS` scope and an optional capability prefix
-produce names such as `DBX_TOOLS_TUNNEL_PUBLIC_DOMAIN`, then
+Resolution is lazy and follows constant `data`, process env, `.env`, Databricks
+bundle configuration, then `app.yaml` / `app.yml` env values. The default
+`DBX_TOOLS` scope and an optional capability prefix produce names such as
+`DBX_TOOLS_TUNNEL_PUBLIC_DOMAIN`, then
 `TUNNEL_PUBLIC_DOMAIN`, then `PUBLIC_DOMAIN`. `.env.production` and `.env.prod`
 are checked before `.env` when `NODE_ENV=production`; development uses
 `.env.development` and `.env.dev`.
 
+Pass one config map or an array of maps through `data`; the first matching value
+wins before environment lookup by default. When a custom `sources` order omits
+`config`, passed data is still read and is appended last. This lets a caller put
+env first without accidentally discarding its fallback config:
+
+```ts
+const endpoint = config.resolveValue("lakebaseEndpoint", {
+  data: { LAKEBASE_ENDPOINT: flags.endpoint },
+  sources: ["env", "dotenv", "bundle", "app"],
+});
+```
+
+`resolveValue()` tries the exact, uppercase, and tokenized-uppercase forms from
+`environmentKeys()` before applying normal scope and prefix expansion.
+
 Bundle lookup runs `databricks bundle validate --output json` only after earlier
 sources miss. It reads literal values from the single App's `config.env`, accepts
-usable partial JSON from a failed validation, and caches each dotenv file or
-validated bundle once per resolved working-directory context. Bundle cache
-entries also include the Databricks profile. Root bundle `variables` are NOT a
+usable partial JSON from a failed validation, and honors the active Databricks
+profile. Parsed dotenv records are cached by file path; parsed bundle output is
+cached by bundle path plus profile. App YAML lookup runs only if the bundle did
+not resolve the key and reads `env[].value` entries. Bundle `value_from` and App
+YAML `valueFrom` references resolve supported fields from their named
+`sql_warehouse`, `genie_space`, or `postgres` resource. Config-file discovery and parsed results
+are single-attempt per source key: found paths, missing files, empty records,
+invalid records, and `undefined` results all cache. Root bundle `variables` are NOT a
 config source: they are authoring inputs interpolated into the bundle's own
 targets, resources, and paths, so reading one as a process setting resolves names
 the deployed App never sees. Reference a variable from `config.env` to make it
@@ -113,13 +136,14 @@ contains a bundle, and bundle reads are enabled, validation runs. This keeps
 pre-boot callers such as `@dbx-tools/appkit` auto-configuration on the same
 deterministic path as CLIs and ordinary Node consumers.
 
-Deployed Apps skip dotenv and bundle lookup after `isDatabricksAppEnv()`
+Deployed Apps skip dotenv, bundle, and app YAML lookup after `isDatabricksAppEnv()`
 recognizes the required App name, HTTP(S) host, and valid port. Set
 `DBX_TOOLS_DATABRICKS_APP_ENV=true` or `false` to force that result; unrecognized
 values leave automatic detection in place.
 
-`DBX_TOOLS_CONFIG_DOTENV` and `DBX_TOOLS_CONFIG_BUNDLE` independently force
-those file sources on or off. A recognized boolean takes precedence over App
+`DBX_TOOLS_CONFIG_DOTENV`, `DBX_TOOLS_CONFIG_BUNDLE`, and
+`DBX_TOOLS_CONFIG_APP` independently force those file sources on or off. A
+recognized boolean takes precedence over App
 runtime detection, so `true` can enable a local source inside an App and `false`
 can suppress it during local development. Absent or unrecognized values keep
 the default: read files outside an App and skip them inside one. Bundle reads
@@ -130,6 +154,31 @@ Use `config.string()`, `boolean()`, `positiveNumber()`, `positiveInt()`,
 `port()`, and `list()` to normalize typed options and text-based configuration
 through one rule. `config.port()` accepts only TCP ports from 1 through 65535;
 `config.ENV_ONLY` disables file fallbacks for exact environment reads.
+`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
 
@@ -254,19 +303,26 @@ import { project } from "@dbx-tools/core";
 const root = project.root();
 const name = project.name();
 const origins = [...project.resolveProjectRoots(process.cwd())];
+const cwd = project.resolveWorkingDirectory("");
 ```
 
 `project.root()` checks npm/pnpm workspace roots, git top-level, and cwd.
 `project.name()` prefers package metadata, then git remote name, then directory
-basename. `project.stat()` returns `undefined` instead of throwing.
+basename. `project.resolveWorkingDirectory()` normalizes blank, null, omitted,
+relative, and absolute cwd values for cache decisions. Project subprocess probes
+share a command/argument result cache only when that resolved path is the live
+process cwd; another directory executes directly. Empty command results are
+cached too.
 
 ## Modules
 
 - `exec` - async/sync process spawning, stdio handling, abort wiring, and shlex.
 - `bin` - executable download, optional archive extraction, selection, and
   atomic installation.
-- `project` - root discovery, project naming, git-remote parsing, and safe
-  filesystem stat.
+- `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.
 - `brand` - YAML/JSON discovery, parsing, validation, and asset path resolution.
 - `config` - scoped environment, dotenv, and validated Databricks bundle lookup,
   including runtime detection and typed coercion helpers.

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";
@@ -13,7 +15,8 @@ export * as project from "./src/project.ts";
 export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
-export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema } from "./src/config.ts";
+export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config.ts";
+export type { ConfigMapValue, ConfigData, ConfigSource, ConfigOptions, ConfigFile } from "./src/config.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";
 export type { ExecStdio, LineHandler, StdioOption, ExecResult, ChildProcessResult, ExecOptions, SyncExecStdio, SyncExecOptions, SpawnArgs } from "./src/exec.ts";
 export type { FileLockBackend, FileLockAcquisition, FileLockOptions } from "./src/file-lock.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";
@@ -9,7 +11,8 @@ export * as project from "./src/project.ts";
 export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
-export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema } from "./src/config.ts";
+export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config.ts";
+export type { ConfigMapValue, ConfigData, ConfigSource, ConfigOptions, ConfigFile } from "./src/config.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";
 export type { ExecStdio, LineHandler, StdioOption, ExecResult, ChildProcessResult, ExecOptions, SyncExecStdio, SyncExecOptions, SpawnArgs } from "./src/exec.ts";
 export type { FileLockBackend, FileLockAcquisition, FileLockOptions } from "./src/file-lock.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";
@@ -10,6 +12,6 @@ export * as fileLock from "./src/file-lock.js";
 export * as processLock from "./src/process-lock.js";
 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 } from "./src/config.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxpQkFBaUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssR0FBRyxNQUFNLGNBQWMsQ0FBQztBQUNwQyxPQUFPLEtBQUssS0FBSyxNQUFNLGdCQUFnQixDQUFDO0FBQ3hDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxLQUFLLE1BQU0sTUFBTSxpQkFBaUIsQ0FBQztBQUMxQyxPQUFPLEtBQUssSUFBSSxNQUFNLGVBQWUsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLGVBQWUsQ0FBQztBQUN0QyxPQUFPLEtBQUssUUFBUSxNQUFNLG9CQUFvQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxXQUFXLE1BQU0sdUJBQXVCLENBQUM7QUFDckQsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsbUJBQW1CLEVBQUUsaUJBQWlCLEVBQUUsc0JBQXNCLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV4SSxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsb0JBQW9CLEVBQUUsb0JBQW9CLEVBQUUsZUFBZSxFQUFFLGlCQUFpQixFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWpLLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCBjb25zdCBQQUNLQUdFX0lERU5USUZJRVIgPSBcIkBkYngtdG9vbHMvY29yZVwiO1xuZXhwb3J0ICogYXMgYmluIGZyb20gXCIuL3NyYy9iaW4udHNcIjtcbmV4cG9ydCAqIGFzIGJyYW5kIGZyb20gXCIuL3NyYy9icmFuZC50c1wiO1xuZXhwb3J0ICogYXMgYnVuZGxlIGZyb20gXCIuL3NyYy9idW5kbGUudHNcIjtcbmV4cG9ydCAqIGFzIGNvbmZpZyBmcm9tIFwiLi9zcmMvY29uZmlnLnRzXCI7XG5leHBvcnQgKiBhcyBleGVjIGZyb20gXCIuL3NyYy9leGVjLnRzXCI7XG5leHBvcnQgKiBhcyBmaWxlIGZyb20gXCIuL3NyYy9maWxlLnRzXCI7XG5leHBvcnQgKiBhcyBmaWxlTG9jayBmcm9tIFwiLi9zcmMvZmlsZS1sb2NrLnRzXCI7XG5leHBvcnQgKiBhcyBwcm9jZXNzTG9jayBmcm9tIFwiLi9zcmMvcHJvY2Vzcy1sb2NrLnRzXCI7XG5leHBvcnQgKiBhcyBwcm9qZWN0IGZyb20gXCIuL3NyYy9wcm9qZWN0LnRzXCI7XG5leHBvcnQgdHlwZSB7IEJpbkNvbnRleHQsIEJpblNlbGVjdGlvbkNvbnRleHQsIEJpblNlbGVjdG9yLCBCaW5WZXJzaW9uT3V0cHV0LCBCaW5WZXJzaW9uUGFyc2VyLCBCaW5PcHRpb25zLCBCaW5VcmwgfSBmcm9tIFwiLi9zcmMvYmluLnRzXCI7XG5leHBvcnQgeyBCcmFuZENvbnRleHRTY2hlbWEsIGRlZmF1bHRCcmFuZENvbnRleHQsIHBhcnNlQnJhbmRDb250ZXh0LCBicmFuZENvbnRleHRKc29uU2NoZW1hLCBicmFuZENvbnRleHRQcm9tcHQgfSBmcm9tIFwiLi9zcmMvYnJhbmQudHNcIjtcbmV4cG9ydCB0eXBlIHsgQnJhbmRDb250ZXh0LCBCcmFuZENvbnRleHRJbnB1dCB9IGZyb20gXCIuL3NyYy9icmFuZC50c1wiO1xuZXhwb3J0IHsgTUFYX1RDUF9QT1JULCBFTlZfT05MWSwgdmFsdWVTY2hlbWEsIGJ1bmRsZVJlc291cmNlU2NoZW1hLCBidW5kbGVFbnZFbnRyeVNjaGVtYSwgYnVuZGxlQXBwU2NoZW1hLCBhcHBFbnZFbnRyeVNjaGVtYSwgYXBwU2NoZW1hIH0gZnJvbSBcIi4vc3JjL2NvbmZpZy50c1wiO1xuZXhwb3J0IHR5cGUgeyBDb25maWdNYXBWYWx1ZSwgQ29uZmlnRGF0YSwgQ29uZmlnU291cmNlLCBDb25maWdPcHRpb25zLCBDb25maWdGaWxlIH0gZnJvbSBcIi4vc3JjL2NvbmZpZy50c1wiO1xuZXhwb3J0IHsgQ09NTUFORF9OT1RfRk9VTkRfRVhJVF9DT0RFIH0gZnJvbSBcIi4vc3JjL2V4ZWMudHNcIjtcbmV4cG9ydCB0eXBlIHsgRXhlY1N0ZGlvLCBMaW5lSGFuZGxlciwgU3RkaW9PcHRpb24sIEV4ZWNSZXN1bHQsIENoaWxkUHJvY2Vzc1Jlc3VsdCwgRXhlY09wdGlvbnMsIFN5bmNFeGVjU3RkaW8sIFN5bmNFeGVjT3B0aW9ucywgU3Bhd25BcmdzIH0gZnJvbSBcIi4vc3JjL2V4ZWMudHNcIjtcbmV4cG9ydCB0eXBlIHsgRmlsZUxvY2tCYWNrZW5kLCBGaWxlTG9ja0FjcXVpc2l0aW9uLCBGaWxlTG9ja09wdGlvbnMgfSBmcm9tIFwiLi9zcmMvZmlsZS1sb2NrLnRzXCI7XG5leHBvcnQgdHlwZSB7IFByb2plY3RDb250ZXh0IH0gZnJvbSBcIi4vc3JjL3Byb2plY3QudHNcIjtcbiJdfQ==

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/src/config.d.ts

@@ -1,29 +1,25 @@
 /**
- * Layered configuration lookup: environment, `.env`, Databricks bundle.
+ * Layered configuration lookup: environment, `.env`, bundle, and `app.yaml`.
  *
  * Every package resolves settings the same way: take the caller's value, else
  * an environment variable, else a default. Local development adds two fallback
- * locations: `.env` files and one App's `resources.apps.<app>.config.env` in
- * `databricks.yml`.
+ * locations: `.env` files, one App's `resources.apps.<app>.config.env` in
+ * `databricks.yml`, and literal env values in `app.yaml` / `app.yml`.
  *
- * Two things make it cheap to call from a hot path:
+ * {@link values} is LAZY (an `object.Sequence`), so `databricks bundle validate`
+ * is only spawned when the environment and `.env` both missed; app YAML is only
+ * read after the bundle source also missed.
  *
- *   - {@link values} is LAZY (an `object.Sequence`), so `databricks bundle
- *     validate` is only spawned when the environment and `.env` both missed.
- *   - the parsed `.env` and bundle are cached through {@link context.cached}, so
- *     the spawn happens once per working directory and a `cwd` change misses
- *     rather than returning another project's config.
- *
- * Inside a deployed Databricks App both file sources are skipped by default
+ * Inside a deployed Databricks App all three file sources are skipped by default
  * ({@link isDatabricksAppEnv}): the platform has already turned them into real
  * environment variables, there is no bundle to validate, and the `databricks`
  * CLI is not on the image. Boolean environment overrides can force either file
  * source on or off when a tool needs different behavior.
  *
- * Only the single app's `config.env` is consulted. Root bundle `variables` are
- * not: they are authoring inputs for the bundle itself (interpolated into
- * targets, resources, and paths), so treating one as a process setting resolves
- * names the deployed app never sees.
+ * Only the single bundle app's `config.env` and literal app YAML `env[].value`
+ * entries are consulted. Root bundle `variables` are not: they are authoring
+ * inputs for the bundle itself (interpolated into targets, resources, and paths),
+ * so treating one as a process setting resolves names the deployed app never sees.
  *
  * Node-only (`child_process`, `fs`, `process`).
  *
@@ -31,22 +27,30 @@
  */
 import { z } from "zod";
 type ConfigKey = string | readonly string[];
+export type ConfigMapValue = string | readonly string[] | null | undefined;
+export type ConfigData = Readonly<Record<string, ConfigMapValue>>;
 /** Where a value may come from, consulted in the order given. */
-type ConfigSource = "env" | "dotenv" | "bundle";
-interface ConfigOptions {
+export type ConfigSource = "config" | "env" | "dotenv" | "bundle" | "app";
+export interface ConfigOptions {
     /**
      * Outermost namespaces tried before each key. Defaults to `DBX_TOOLS`.
      */
     scope?: string | readonly string[];
     /** Capability namespaces inserted after the scope and before each key. */
     prefix?: string | readonly string[];
-    /** Sources in precedence order. Default: `env`, `dotenv`, `bundle`. */
+    /** Constant config maps read by the `config` source. */
+    data?: ConfigData | readonly ConfigData[];
+    /** Parsed bundle data used instead of loading `databricks.yml`. */
+    bundleData?: ConfigFile | Record<string, unknown>;
+    /** Parsed app YAML data used instead of loading `app.yaml`. */
+    appData?: ConfigFile | Record<string, unknown>;
+    /** Sources in precedence order. Default: `config`, `env`, `dotenv`, `bundle`, `app`. */
     sources?: ConfigSource | readonly ConfigSource[];
     /** Directory to resolve `.env` and the bundle from. Default: `process.cwd()`. */
     cwd?: string;
 }
 /** A config file found on disk, with its parsed contents. */
-interface ConfigFile {
+export interface ConfigFile {
     path: string;
     data: Record<string, unknown>;
 }
@@ -58,13 +62,7 @@ export declare const ENV_ONLY: {
     sources: "env";
 };
 export declare const valueSchema: z.ZodString;
-/**
- * The GENERIC shape of a bundle resource: a name, and whatever else the resource
- * type carries. Deliberately unopinionated and `passthrough()` - the concrete
- * resource kinds (`sql_warehouse`, `genie_space`, `postgres`, ...) are
- * Databricks-App concepts that belong to the package that resolves them, so
- * node-appkit `.extend()`s this rather than this module knowing about them.
- */
+/** A named bundle or App resource; concrete resource fields pass through. */
 export declare const bundleResourceSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
@@ -86,6 +84,27 @@ export declare const bundleAppSchema: z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
 }, z.core.$strip>;
+export declare const appEnvEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    valueFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const appSchema: z.ZodObject<{
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        valueFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$strip>;
+/** Flatten the single bundle App's `config.env`, resolving resource references. */
+export declare function flattenBundleEnv(data: unknown): Record<string, string>;
+/** Flatten `app.yaml` env entries, resolving `valueFrom` resource references. */
+export declare function flattenAppEnv(data: unknown): Record<string, string>;
+/** Walk a dot-separated path through parsed bundle data. */
+export declare function getBundlePath(data: Record<string, unknown>, path: string): string | undefined;
 /**
  * Detect a Databricks App runtime from its required name, host, and port.
  *
@@ -95,6 +114,8 @@ export declare const bundleAppSchema: z.ZodObject<{
  * absent or unrecognized override falls back to structural detection.
  */
 export declare function isDatabricksAppEnv(source?: Record<string, string | undefined>): boolean;
+/** Exact, uppercase, and tokenized-uppercase names for a human-friendly key. */
+export declare function environmentKeys(name: string): readonly string[];
 /**
  * The first value that resolves for `input`, or `undefined`.
  *
@@ -102,6 +123,8 @@ export declare function isDatabricksAppEnv(source?: Record<string, string | unde
  * const domain = config.text(["TUNNEL_PUBLIC_DOMAIN", "PUBLIC_DOMAIN"]);
  */
 export declare function text(input: ConfigKey, options?: ConfigOptions): string | undefined;
+/** Resolve a human-friendly name through {@link environmentKeys} and {@link text}. */
+export declare function resolveValue(name: string, options?: ConfigOptions): string | undefined;
 /**
  * The PRIMARY (fully-scoped) name for `input` - what to print in a log line or an
  * error, so the message names the variable a reader should set. Do not index
@@ -156,10 +179,10 @@ export declare function list(configured: string | readonly string[] | undefined
  * or a deployed App without an explicit override, there is no bundle, or the
  * CLI produces no JSON.
  *
- * Cached once per resolved working-directory context and
- * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated
- * lookups do not rerun validation and changing either cannot return another
- * context's bundle.
+ * Parsed validation output is cached by bundle path and Databricks profile.
+ *
  */
 export declare function bundleFile(cwd?: string | null): ConfigFile | undefined;
+/** The parsed `app.yaml` / `app.yml` for `cwd`, when local App config reads are enabled. */
+export declare function appFile(cwd?: string | null): ConfigFile | undefined;
 export {};