@dbx-tools/core 0.6.86 → 0.6.88

package/README.md

@@ -16,8 +16,8 @@ Key features:
 - Workspace/project root discovery from package-manager files, git metadata, and
   the current working directory.
 - Safe filesystem stat and project naming helpers for CLIs and projen synth.
-- Layered config from process env, environment-specific `.env` files, and
-  Databricks bundle App config or variables.
+- Layered config from process env, environment-specific `.env` files, and the
+  Databricks bundle's App `config.env`.
 - YAML/JSON brand-context discovery and loading with shared Zod validation.
 - Idempotent executable downloads with zip/tar extraction and atomic installs.
 - Cross-process file locks with a Bun `flock(2)` fast path and a portable,
@@ -98,10 +98,27 @@ are checked before `.env` when `NODE_ENV=production`; development uses
 `.env.development` and `.env.dev`.
 
 Bundle lookup runs `databricks bundle validate --output json` only after earlier
-sources miss. It reads literal values from the single App's `config.env` first,
-then root bundle variables, 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.
+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
+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
+one.
+
+Because validation is a process spawn, it is gated on this being an AppKit
+project at all, in three steps. `@databricks/appkit` must be RESOLVABLE - it is
+an optional peer, the probe resolves the path without evaluating the module, and
+a consumer that never installed it never spawns the CLI. The bundle must then
+describe exactly ONE app carrying `config.env`, since nothing in this package
+says which of several apps a process is. Finally AppKit's execution context
+confirms the process really is that app; that context does not exist until AppKit
+boots, so only the affirmative is remembered and a lookup during boot still
+resolves from the bundle instead of being permanently denied. Setting
+`DBX_TOOLS_CONFIG_BUNDLE=true` skips this gate for a tool that wants the bundle
+without being the App.
+
 Deployed Apps skip dotenv and bundle 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

package/lib/src/config.d.ts

@@ -20,6 +20,29 @@
  * CLI is not on the image. Boolean environment overrides can force either file
  * source on or off when a tool needs different behavior.
  *
+ * The bundle is gated on this being an AppKit project at all. `databricks bundle
+ * validate` is a process spawn measured in seconds, and a plain library or CLI
+ * consumer has no bundle to find, so the gate runs in three steps before the
+ * spawn is allowed - see {@link bundleFile}:
+ *
+ *   1. `@databricks/appkit` is resolved WITHOUT evaluating it. It is an optional
+ *      peer, so a consumer that never installed it is not an AppKit project and
+ *      the bundle is never loaded. The probe is cached, so this costs one
+ *      resolution for the life of the process.
+ *   2. The bundle is read (once per context) and must describe EXACTLY ONE app
+ *      with `config.env`. Nothing here says which of several apps this process
+ *      is, so an ambiguous bundle contributes nothing rather than a guess.
+ *   3. AppKit's execution context confirms this process really is that app. The
+ *      context does not exist until AppKit boots and `getExecutionContext()`
+ *      THROWS until then, so the probe is caught and only the affirmative is
+ *      remembered - a lookup before boot still resolves, and re-confirms later
+ *      once the context is available.
+ *
+ * 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.
+ *
  * Node-only (`child_process`, `fs`, `process`).
  *
  * @module
@@ -147,9 +170,17 @@ export declare function list(configured: string | readonly string[] | undefined
 /**
  * The Databricks bundle output for `cwd` - `databricks bundle validate --output
  * json` run from the directory holding `databricks.yml`, with the config file's
- * path. A non-zero validation may still return partial JSON with usable
- * variables. `undefined` when bundle reads are disabled, there is no bundle, or
- * the CLI produces no JSON.
+ * path. A non-zero validation may still return partial JSON with usable App
+ * config. `undefined` when bundle reads are disabled, this is not an AppKit
+ * project, the bundle does not describe exactly one app with `config.env`, there
+ * is no bundle, or the CLI produces no JSON.
+ *
+ * The spawn is guarded because it is expensive and usually pointless. In order:
+ * `@databricks/appkit` must be RESOLVABLE (no AppKit, no bundle - and the probe
+ * never evaluates the module); the bundle must describe exactly ONE app carrying
+ * `config.env`; and AppKit's execution context must confirm this process is that
+ * app. Only the confirmation is remembered, so a lookup during boot - before any
+ * context exists - still resolves from the bundle and re-confirms later.
  *
  * Cached once per resolved working-directory context and
  * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated

package/lib/src/config.js

@@ -20,15 +20,47 @@
  * CLI is not on the image. Boolean environment overrides can force either file
  * source on or off when a tool needs different behavior.
  *
+ * The bundle is gated on this being an AppKit project at all. `databricks bundle
+ * validate` is a process spawn measured in seconds, and a plain library or CLI
+ * consumer has no bundle to find, so the gate runs in three steps before the
+ * spawn is allowed - see {@link bundleFile}:
+ *
+ *   1. `@databricks/appkit` is resolved WITHOUT evaluating it. It is an optional
+ *      peer, so a consumer that never installed it is not an AppKit project and
+ *      the bundle is never loaded. The probe is cached, so this costs one
+ *      resolution for the life of the process.
+ *   2. The bundle is read (once per context) and must describe EXACTLY ONE app
+ *      with `config.env`. Nothing here says which of several apps this process
+ *      is, so an ambiguous bundle contributes nothing rather than a guess.
+ *   3. AppKit's execution context confirms this process really is that app. The
+ *      context does not exist until AppKit boots and `getExecutionContext()`
+ *      THROWS until then, so the probe is caught and only the affirmative is
+ *      remembered - a lookup before boot still resolves, and re-confirms later
+ *      once the context is available.
+ *
+ * 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.
+ *
  * Node-only (`child_process`, `fs`, `process`).
  *
  * @module
  */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { parseEnv } from "node:util";
-import { context, json, log, object, string as stringModule } from "@dbx-tools/shared-core";
+import { context, functionModule, json, log, object, string as stringModule, } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { statSync } from "./file.js";
 import { root as resolveProjectRoot } from "./project.js";
@@ -49,6 +81,20 @@ export const DATABRICKS_APP_ENV_KEY = "DBX_TOOLS_DATABRICKS_APP_ENV";
 export const CONFIG_DOTENV_KEY = "DBX_TOOLS_CONFIG_DOTENV";
 /** Boolean environment override for Databricks bundle reads. */
 export const CONFIG_BUNDLE_KEY = "DBX_TOOLS_CONFIG_BUNDLE";
+/**
+ * The OPTIONAL AppKit peer whose presence marks this as a Databricks App
+ * project. Held as a constant so the resolve probe and the lazy import name it
+ * once, and so neither site carries a literal a bundler would try to follow.
+ */
+const APPKIT_MODULE = "@databricks/appkit";
+/**
+ * Whether AppKit's execution context has EVER been observed. Latching is the
+ * point: a context confirms this process is the bundle's app, and that fact does
+ * not stop being true when a later lookup happens outside a request scope.
+ */
+let appKitContext = false;
+/** Flattened App `config.env` per parsed bundle - see {@link bundleApp}. */
+const BUNDLE_APP_CACHE = new WeakMap();
 /** Exact process-environment lookup for callers that do not read local config files. */
 export const ENV_ONLY = { scope: [], sources: "env" };
 export const bundleValue = z
@@ -71,10 +117,6 @@ export const bundleEnvEntrySchema = z.object({
     value: z.string().optional(),
     value_from: bundleValue.optional(),
 });
-const bundleVariableSchema = z.object({
-    default: z.string().optional(),
-    value: z.string().optional(),
-});
 export const bundleAppSchema = z.object({
     name: bundleValue.optional(),
     source_code_path: z.string().optional(),
@@ -84,9 +126,6 @@ export const bundleAppSchema = z.object({
 const bundleAppsSchema = z.object({
     resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),
 });
-const bundleVariablesSchema = z.object({
-    variables: z.record(z.string(), bundleVariableSchema).optional(),
-});
 /**
  * Detect a Databricks App runtime from its required name, host, and port.
  *
@@ -254,9 +293,17 @@ function toPositiveNumber(value) {
 /**
  * The Databricks bundle output for `cwd` - `databricks bundle validate --output
  * json` run from the directory holding `databricks.yml`, with the config file's
- * path. A non-zero validation may still return partial JSON with usable
- * variables. `undefined` when bundle reads are disabled, there is no bundle, or
- * the CLI produces no JSON.
+ * path. A non-zero validation may still return partial JSON with usable App
+ * config. `undefined` when bundle reads are disabled, this is not an AppKit
+ * project, the bundle does not describe exactly one app with `config.env`, there
+ * is no bundle, or the CLI produces no JSON.
+ *
+ * The spawn is guarded because it is expensive and usually pointless. In order:
+ * `@databricks/appkit` must be RESOLVABLE (no AppKit, no bundle - and the probe
+ * never evaluates the module); the bundle must describe exactly ONE app carrying
+ * `config.env`; and AppKit's execution context must confirm this process is that
+ * app. Only the confirmation is remembered, so a lookup during boot - before any
+ * context exists - still resolves from the bundle and re-confirms later.
  *
  * Cached once per resolved working-directory context and
  * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated
@@ -265,10 +312,33 @@ function toPositiveNumber(value) {
  */
 export function bundleFile(cwd) {
     const production = process.env.NODE_ENV?.trim().toLowerCase() === "production";
-    if (!fileSourceEnabled(CONFIG_BUNDLE_KEY, !production && !isDatabricksAppEnv()))
+    const override = object.toBoolean(process.env[CONFIG_BUNDLE_KEY]);
+    if (override === false)
         return undefined;
+    // An explicit `true` is the escape hatch for a tool that wants the bundle
+    // without being the app (`dbx` commands, tests), so it skips the AppKit gate
+    // entirely - but not the App/production defaults, which it also overrides.
+    if (override === undefined) {
+        if (production || isDatabricksAppEnv())
+            return undefined;
+        if (!appKitInstalled())
+            return undefined;
+    }
     const profile = stringModule.trimToNull(process.env.DATABRICKS_CONFIG_PROFILE);
-    return cachedConfig(["bundle", profile ?? ""], cwd, (resolved) => loadBundleFile(resolved, profile));
+    const file = cachedConfig(["bundle", profile ?? ""], cwd, (resolved) => loadBundleFile(resolved, profile));
+    if (override !== undefined || file === undefined)
+        return file;
+    // Already confirmed: this process is the app, and that does not stop being
+    // true, so skip re-deriving the gate on every lookup.
+    if (appKitContext)
+        return file;
+    // The app must be unambiguous. `bundleApp` is what decides "exactly one app
+    // with `config.env`", so an empty map IS the ambiguous or app-less bundle and
+    // needs no separate check.
+    if (Object.keys(bundleApp(file.data)).length === 0)
+        return undefined;
+    confirmAppKitContext();
+    return file;
 }
 /**
  * The single App's literal `config.env` entries, flattened to `name -> value`.
@@ -279,8 +349,24 @@ export function bundleFile(cwd) {
  * {@link bundleResourceSchema}. An `apps` block with more than one app is
  * ambiguous (nothing here says which app this process is), so it yields nothing
  * rather than a guess.
+ *
+ * Memoized against the parsed bundle it came from, because both the gate in
+ * {@link bundleFile} and the lookup in {@link read} ask the same question of the
+ * same cached object - validating that payload twice per lookup would be pure
+ * waste. A `WeakMap` keeps the entry alive exactly as long as the bundle is.
  */
 function bundleApp(input) {
+    if (!object.isRecord(input))
+        return bundleAppEntries(input);
+    const cached = BUNDLE_APP_CACHE.get(input);
+    if (cached)
+        return cached;
+    const result = bundleAppEntries(input);
+    BUNDLE_APP_CACHE.set(input, result);
+    return result;
+}
+/** {@link bundleApp} without the memoization, so the cache has one filler. */
+function bundleAppEntries(input) {
     const parsed = bundleAppsSchema.safeParse(input);
     if (!parsed.success)
         return {};
@@ -302,25 +388,71 @@ function bundleApp(input) {
     return result;
 }
 /**
- * Root bundle variables flattened to environment-style `NAME -> value` entries.
+ * Whether `@databricks/appkit` can be RESOLVED from this process, cached for its
+ * lifetime.
  *
- * `databricks bundle validate` resolves each variable to `value`; `default` is
- * retained as a fallback for parsed bundle data that has not been fully
- * resolved. Names are normalized so a bundle variable such as
- * `tunnel_public_domain` answers a lookup for `TUNNEL_PUBLIC_DOMAIN`.
+ * Resolution, not import: this answers "is this an AppKit project" without
+ * evaluating the module, so the cheap negative (a plain library or CLI consumer
+ * that never installed the optional peer) costs one path lookup and never boots
+ * AppKit as a side effect of reading config. A runtime with no `createRequire`
+ * (a browser bundle that reached this Node-only module anyway) reports absent.
  */
-function bundleVariables(input) {
-    const parsed = bundleVariablesSchema.safeParse(input);
-    if (!parsed.success)
-        return {};
-    const result = {};
-    for (const [name, variable] of Object.entries(parsed.data.variables ?? {})) {
-        const key = [...stringModule.tokenize(name)].join("_").toUpperCase();
-        const value = resolvedString(variable.value) ?? resolvedString(variable.default);
-        if (key && value !== null)
-            result[key] = value;
+const appKitInstalled = functionModule.memoize(() => {
+    try {
+        // Indirect specifier: a bundler must not try to follow an OPTIONAL peer that
+        // a browser build has no way to resolve.
+        const specifier = APPKIT_MODULE;
+        createRequire(import.meta.url).resolve(specifier);
+        return true;
     }
-    return result;
+    catch {
+        return false;
+    }
+});
+/**
+ * AppKit's execution context once it exists, or `undefined`.
+ *
+ * Lazily imported (and `@vite-ignore`d) because `@databricks/appkit` is an
+ * OPTIONAL peer this module must never make required. The import is only
+ * attempted once {@link appKitInstalled} says there is something to import, and a
+ * failure resolves to `undefined` rather than rejecting - a missing peer is the
+ * expected path, not an error.
+ *
+ * `getExecutionContext()` THROWS until AppKit has booted, so the call is caught
+ * and only a real context is reported. The module handle is memoized; the
+ * context lookup is not, so a call before boot answers "not yet" and a later one
+ * still sees the context.
+ */
+const appKitModule = functionModule.memoize(async () => {
+    if (!appKitInstalled())
+        return undefined;
+    const specifier = APPKIT_MODULE;
+    return (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ specifier)).catch(() => undefined));
+});
+/**
+ * Latch {@link appKitContext} once AppKit's execution context exists.
+ *
+ * Fire-and-forget, because the caller is a SYNCHRONOUS lookup and the check
+ * needs a lazy import. The affirmative is all that is stored: AppKit's context
+ * does not exist until it boots, and `getExecutionContext()` throws until then,
+ * so remembering a negative would permanently disable the bundle for a process
+ * that is seconds away from having one. Every call before the latch closes
+ * re-attempts, which is what makes "not available yet" retry rather than stick.
+ */
+function confirmAppKitContext() {
+    void appKitModule()
+        .then((appkit) => {
+        if (!appkit)
+            return;
+        try {
+            if (appkit.getExecutionContext()?.client)
+                appKitContext = true;
+        }
+        catch {
+            // AppKit has not booted yet; a later call re-checks.
+        }
+    })
+        .catch(() => undefined);
 }
 /** A non-empty bundle value with every `${...}` interpolation resolved. */
 function resolvedString(value) {
@@ -357,10 +489,8 @@ function read(source, cwd) {
                     break;
                 case "bundle": {
                     const bundle = bundleFile(cwd);
-                    if (bundle) {
+                    if (bundle)
                         yield bundleApp(bundle.data);
-                        yield bundleVariables(bundle.data);
-                    }
                     break;
                 }
             }
@@ -442,4 +572,4 @@ function loadBundleFile(cwd, profile) {
     }
     return { path, data };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Layered configuration lookup: environment, `.env`, Databricks bundle.\n *\n * Every package resolves settings the same way: take the caller's value, else\n * an environment variable, else a default. Local development adds two fallback\n * locations: `.env` files and `resources.apps.<app>.config.env` or root\n * `variables` in `databricks.yml`.\n *\n * Two things make it cheap to call from a hot path:\n *\n *   - {@link values} is LAZY (an `object.Sequence`), so `databricks bundle\n *     validate` is only spawned when the environment and `.env` both missed.\n *   - the parsed `.env` and bundle are cached through {@link context.cached}, so\n *     the spawn happens once per working directory and a `cwd` change misses\n *     rather than returning another project's config.\n *\n * Inside a deployed Databricks App both file sources are skipped by default\n * ({@link isDatabricksAppEnv}): the platform has already turned them into real\n * environment variables, there is no bundle to validate, and the `databricks`\n * CLI is not on the image. Boolean environment overrides can force either file\n * source on or off when a tool needs different behavior.\n *\n * Node-only (`child_process`, `fs`, `process`).\n *\n * @module\n */\n\nimport { spawnSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { dirname, isAbsolute, relative, resolve, sep } from \"node:path\";\nimport { parseEnv } from \"node:util\";\nimport { context, json, log, object, string as stringModule } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { statSync } from \"./file.ts\";\nimport { root as resolveProjectRoot } from \"./project.ts\";\n\nconst logger = log.logger(\"config\");\n\nexport type ConfigKey = string | readonly string[];\n\n/** Where a value may come from, consulted in the order given. */\nexport type ConfigSource = \"env\" | \"dotenv\" | \"bundle\";\n\nexport interface ConfigOptions {\n  /**\n   * Outermost namespaces tried before each key. Defaults to `DBX_TOOLS`.\n   */\n  scope?: string | readonly string[];\n  /** Capability namespaces inserted after the scope and before each key. */\n  prefix?: string | readonly string[];\n  /** Directory to resolve `.env` and the bundle from. Default: `process.cwd()`. */\n  cwd?: string;\n  /** Sources in precedence order. Default: `env`, `dotenv`, `bundle`. */\n  sources?: ConfigSource | readonly ConfigSource[];\n}\n\n/** One resolved value, tagged with the key and source it came from. */\ninterface ConfigValue {\n  key: string;\n  source: ConfigSource;\n  value: string;\n}\n\n/** A config file found on disk, with its parsed contents. */\nexport interface ConfigFile {\n  path: string;\n  data: Record<string, unknown>;\n}\n\nconst DEFAULT_SCOPE = \"DBX_TOOLS\";\nconst DEFAULT_SOURCES: readonly ConfigSource[] = [\"env\", \"dotenv\", \"bundle\"];\nconst BUNDLE_FILE_NAMES = [\"databricks.yml\", \"databricks.yaml\"] as const;\nconst DOTENV_FILE_NAME = \".env\";\nconst NODE_ENV_ALTERNATIVES = {\n  production: [\"prod\"],\n  development: [\"dev\"],\n} as const satisfies Record<string, readonly string[]>;\n\n/** Highest valid TCP port number. */\nexport const MAX_TCP_PORT = 65_535;\n\n/** Boolean environment override for {@link isDatabricksAppEnv}. */\nexport const DATABRICKS_APP_ENV_KEY = \"DBX_TOOLS_DATABRICKS_APP_ENV\";\n\n/** Boolean environment override for project `.env` reads. */\nexport const CONFIG_DOTENV_KEY = \"DBX_TOOLS_CONFIG_DOTENV\";\n\n/** Boolean environment override for Databricks bundle reads. */\nexport const CONFIG_BUNDLE_KEY = \"DBX_TOOLS_CONFIG_BUNDLE\";\n\n/** Exact process-environment lookup for callers that do not read local config files. */\nexport const ENV_ONLY = { scope: [] as const, sources: \"env\" as const };\n\nexport const bundleValue = z\n  .string()\n  .transform((value: string) => value.trim())\n  .refine((value: string) => value.length > 0)\n  .refine((value: string) => !/\\$\\{[^}]+\\}/.test(value), {\n    message: \"Interpolated values are not allowed\",\n  });\n\n/**\n * The GENERIC shape of a bundle resource: a name, and whatever else the resource\n * type carries. Deliberately unopinionated and `passthrough()` - the concrete\n * resource kinds (`sql_warehouse`, `genie_space`, `postgres`, ...) are\n * Databricks-App concepts that belong to the package that resolves them, so\n * node-appkit `.extend()`s this rather than this module knowing about them.\n */\nexport const bundleResourceSchema = z.object({ name: bundleValue.optional() }).passthrough();\n\nexport const bundleEnvEntrySchema = z.object({\n  name: bundleValue.optional(),\n  value: z.string().optional(),\n  value_from: bundleValue.optional(),\n});\n\nconst bundleVariableSchema = z.object({\n  default: z.string().optional(),\n  value: z.string().optional(),\n});\n\nexport const bundleAppSchema = z.object({\n  name: bundleValue.optional(),\n  source_code_path: z.string().optional(),\n  config: z.object({ env: z.array(bundleEnvEntrySchema).optional() }).optional(),\n  resources: z.array(bundleResourceSchema).optional(),\n});\n\nconst bundleAppsSchema = z.object({\n  resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),\n});\n\nconst bundleVariablesSchema = z.object({\n  variables: z.record(z.string(), bundleVariableSchema).optional(),\n});\n\n/**\n * Detect a Databricks App runtime from its required name, host, and port.\n *\n * `DBX_TOOLS_DATABRICKS_APP_ENV` takes precedence when it contains a recognized\n * boolean value. This lets local tools emulate the deployed runtime (`true`) or\n * lets unusual deployed processes retain local config lookup (`false`). An\n * absent or unrecognized override falls back to structural detection.\n */\nexport function isDatabricksAppEnv(\n  source: Record<string, string | undefined> = process.env,\n): boolean {\n  const override = object.toBoolean(source[DATABRICKS_APP_ENV_KEY]);\n  if (override !== undefined) return override;\n  const appName = source.DATABRICKS_APP_NAME?.trim();\n  const host = source.DATABRICKS_HOST?.trim();\n  const port = source.DATABRICKS_APP_PORT?.trim();\n  if (!appName || !host || !port) return false;\n  try {\n    if (![\"http:\", \"https:\"].includes(new URL(host).protocol)) return false;\n  } catch {\n    return false;\n  }\n  const portNumber = object.toNumber(port);\n  return (\n    portNumber !== undefined &&\n    Number.isInteger(portNumber) &&\n    portNumber >= 1 &&\n    portNumber <= MAX_TCP_PORT\n  );\n}\n\n/** Candidate names in scope, prefix, and input precedence order. */\nfunction keys(input: ConfigKey, options: Pick<ConfigOptions, \"scope\" | \"prefix\"> = {}): string[] {\n  const scopes = object.sequence(options.scope ?? DEFAULT_SCOPE).toArray();\n  const prefixes = options.prefix === undefined ? [] : object.sequence(options.prefix).toArray();\n  return [\n    ...object\n      .sequence(input)\n      .flatMap((key) => {\n        const prefixed = prefixes.length > 0 ? prefixes.map((prefix) => join(prefix, key)) : [key];\n        return [\n          ...scopes.flatMap((scope) => prefixed.map((key) => join(scope, key))),\n          ...prefixed,\n          key,\n        ];\n      })\n      .filter((key) => key.length > 0)\n      .distinct(),\n  ];\n}\n\n/**\n * Every value that resolves for `input`, in source-then-key precedence order,\n * as a LAZY sequence: nothing past the first consumed element is read, so\n * `values(key).first()` never spawns the Databricks CLI when the environment\n * already answered.\n *\n */\nfunction values(input: ConfigKey, options: ConfigOptions = {}): object.Sequence<ConfigValue> {\n  const candidates = keys(input, options);\n  const sources = object.sequence<ConfigSource>(options.sources ?? DEFAULT_SOURCES);\n  return object.sequence({\n    *[Symbol.iterator](): Generator<ConfigValue> {\n      for (const source of sources) {\n        for (const map of read(source, options.cwd)) {\n          for (const key of candidates) {\n            const value = stringModule.trimToNull(map[key]);\n            if (value !== null) yield { key, source, value };\n          }\n        }\n      }\n    },\n  });\n}\n\n/**\n * The first value that resolves for `input`, or `undefined`.\n *\n * @example\n * const domain = config.text([\"TUNNEL_PUBLIC_DOMAIN\", \"PUBLIC_DOMAIN\"]);\n */\nexport function text(input: ConfigKey, options: ConfigOptions = {}): string | undefined {\n  return values(input, options).at(0)?.value;\n}\n\n/**\n * The PRIMARY (fully-scoped) name for `input` - what to print in a log line or an\n * error, so the message names the variable a reader should set. Do not index\n * `keys(...)[0]` for this if `input` may be a bare string.\n *\n * @example\n * logger.warn(`${config.name(JWT_SECRET_ENV)} is not set`);\n */\nexport function name(\n  input: ConfigKey,\n  options: Pick<ConfigOptions, \"scope\" | \"prefix\"> = {},\n): string {\n  return keys(input, options)[0] ?? \"\";\n}\n\n/**\n * Safe `.env.<name>` suffixes for a Node environment, exact spelling first.\n * Known long and short names are interchangeable; unknown names pass through.\n */\nfunction nodeEnvNames(nodeEnv: unknown): string[] {\n  const name = stringModule.trimToNull(nodeEnv)?.toLowerCase();\n  if (!name || !/^[a-z0-9_-]+$/.test(name)) return [];\n  for (const [canonical, alternatives] of Object.entries(NODE_ENV_ALTERNATIVES)) {\n    const names: readonly string[] = alternatives;\n    if (name === canonical || names.includes(name)) {\n      return [...object.sequence(name, canonical, alternatives).distinct()];\n    }\n  }\n  return [name];\n}\n\nfunction join(...parts: string[]): string {\n  return parts\n    .map((part) => part.trim())\n    .filter(Boolean)\n    .join(\"_\");\n}\n\n/**\n * Resolve a string: `configured` when non-empty, else {@link text}, else `undefined`.\n *\n * The coercion rules are deliberately loose (`on` / `yes` / `1` are all\n * `true`) because values may come from a file a human typed.\n *\n * @example\n * config.string(options.host, \"SMTP_HOST\");\n */\nexport function string(\n  configured: unknown,\n  input: ConfigKey,\n  options?: ConfigOptions,\n): string | undefined {\n  return stringModule.trimToNull(configured) ?? text(input, options);\n}\n\n/**\n * Resolve a boolean through `object.toBoolean`. `undefined` when neither source\n * is interpretable, so the caller picks a default with `??`.\n */\nexport function boolean(\n  configured: unknown,\n  input: ConfigKey,\n  options?: ConfigOptions,\n): boolean | undefined {\n  return object.toBoolean(configured) ?? object.toBoolean(text(input, options));\n}\n\n/**\n * Resolve a positive number that may be fractional (a score threshold, a ratio).\n * Use {@link positiveInt} for a count, port, or timeout.\n */\nexport function positiveNumber(\n  configured: unknown,\n  input: ConfigKey,\n  fallback: number,\n  options?: ConfigOptions,\n): number {\n  return toPositiveNumber(configured) ?? toPositiveNumber(text(input, options)) ?? fallback;\n}\n\n/**\n * Resolve a positive integer (a port, a timeout, a page size), floored. A\n * non-numeric or non-positive value is treated as ABSENT rather than fatal -\n * these are ceilings where a sane default beats a boot failure.\n */\nexport function positiveInt(\n  configured: unknown,\n  input: ConfigKey,\n  fallback: number,\n  options?: ConfigOptions,\n): number {\n  const resolved = positiveNumber(configured, input, fallback, options);\n  return Math.floor(resolved);\n}\n\n/**\n * Resolve a list through `string.parseList`, so an array from typed config and a\n * `\"a, b c\"` string normalize identically. `[]` when neither source has entries.\n */\nexport function list(\n  configured: string | readonly string[] | undefined | null,\n  input: ConfigKey,\n  transform?: (entry: string) => string,\n  options?: ConfigOptions,\n): string[] {\n  const fromConfig = stringModule.parseList(configured, transform);\n  return fromConfig.length > 0\n    ? fromConfig\n    : stringModule.parseList(text(input, options), transform);\n}\n\nfunction toPositiveNumber(value: unknown): number | undefined {\n  const parsed = object.toNumber(value);\n  return parsed !== undefined && parsed > 0 ? parsed : undefined;\n}\n\n/**\n * The Databricks bundle output for `cwd` - `databricks bundle validate --output\n * json` run from the directory holding `databricks.yml`, with the config file's\n * path. A non-zero validation may still return partial JSON with usable\n * variables. `undefined` when bundle reads are disabled, there is no bundle, or\n * the CLI produces no JSON.\n *\n * Cached once per resolved working-directory context and\n * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated\n * lookups do not rerun validation and changing either cannot return another\n * context's bundle.\n */\nexport function bundleFile(cwd?: string | null): ConfigFile | undefined {\n  const production = process.env.NODE_ENV?.trim().toLowerCase() === \"production\";\n  if (!fileSourceEnabled(CONFIG_BUNDLE_KEY, !production && !isDatabricksAppEnv())) return undefined;\n  const profile = stringModule.trimToNull(process.env.DATABRICKS_CONFIG_PROFILE);\n  return cachedConfig([\"bundle\", profile ?? \"\"], cwd, (resolved) =>\n    loadBundleFile(resolved, profile),\n  );\n}\n\n/**\n * The single App's literal `config.env` entries, flattened to `name -> value`.\n *\n * A `value_from` entry names a bundle resource whose id is known after\n * deployment, and reading it needs the resource vocabulary this module\n * deliberately does not have - node-appkit resolves those against its extended\n * {@link bundleResourceSchema}. An `apps` block with more than one app is\n * ambiguous (nothing here says which app this process is), so it yields nothing\n * rather than a guess.\n */\nfunction bundleApp(input: unknown): Record<string, string> {\n  const parsed = bundleAppsSchema.safeParse(input);\n  if (!parsed.success) return {};\n  const apps = parsed.data.resources?.apps;\n  if (!apps) return {};\n  const names = Object.keys(apps);\n  if (names.length !== 1) return {};\n  const entries = apps[names[0]!]?.config?.env ?? [];\n  const result: Record<string, string> = {};\n  for (const entry of entries) {\n    if (!entry.name) continue;\n    const value = resolvedString(entry.value);\n    if (value !== null) result[entry.name] = value;\n  }\n  return result;\n}\n\n/**\n * Root bundle variables flattened to environment-style `NAME -> value` entries.\n *\n * `databricks bundle validate` resolves each variable to `value`; `default` is\n * retained as a fallback for parsed bundle data that has not been fully\n * resolved. Names are normalized so a bundle variable such as\n * `tunnel_public_domain` answers a lookup for `TUNNEL_PUBLIC_DOMAIN`.\n */\nfunction bundleVariables(input: unknown): Record<string, string> {\n  const parsed = bundleVariablesSchema.safeParse(input);\n  if (!parsed.success) return {};\n  const result: Record<string, string> = {};\n  for (const [name, variable] of Object.entries(parsed.data.variables ?? {})) {\n    const key = [...stringModule.tokenize(name)].join(\"_\").toUpperCase();\n    const value = resolvedString(variable.value) ?? resolvedString(variable.default);\n    if (key && value !== null) result[key] = value;\n  }\n  return result;\n}\n\n/** A non-empty bundle value with every `${...}` interpolation resolved. */\nfunction resolvedString(value: unknown): string | null {\n  const parsed = bundleValue.safeParse(value);\n  return parsed.success ? parsed.data : null;\n}\n\n/** Parsed `.env` for `cwd`, or `{}`. Read once per resolved context. */\nfunction dotenv(cwd?: string | null): Record<string, string | undefined> {\n  if (!fileSourceEnabled(CONFIG_DOTENV_KEY)) return {};\n  const environments = nodeEnvNames(process.env.NODE_ENV);\n  return cachedConfig([\"dotenv\", ...environments], cwd, (resolved) =>\n    loadDotenv(resolved, environments),\n  );\n}\n\n/** Cache every target directory separately within the active process context. */\nfunction cachedConfig<T>(\n  name: readonly string[],\n  cwd: string | null | undefined,\n  loader: (resolved: string) => T,\n): T {\n  const active = context.getContext() ?? \"\";\n  const resolved = resolve(cwd ?? \".\");\n  return context.cached([\"config\", active, resolved, ...name], () => loader(resolved));\n}\n\n/**\n * Maps for one source in precedence order. Bundle App config and root variables\n * stay separate so a first-match lookup does not parse variables after an App\n * value resolves.\n */\nfunction read(\n  source: ConfigSource,\n  cwd?: string,\n): object.Sequence<Record<string, string | undefined>> {\n  return object.sequence({\n    *[Symbol.iterator](): Generator<Record<string, string | undefined>> {\n      switch (source) {\n        case \"env\":\n          yield process.env;\n          break;\n        case \"dotenv\":\n          yield dotenv(cwd);\n          break;\n        case \"bundle\": {\n          const bundle = bundleFile(cwd);\n          if (bundle) {\n            yield bundleApp(bundle.data);\n            yield bundleVariables(bundle.data);\n          }\n          break;\n        }\n      }\n    },\n  });\n}\n\n/**\n * Locate `names` from `cwd` outward. `cwd` itself is checked before the\n * discovered project roots so a package-local file wins over the workspace's.\n */\nfunction findConfigFile(cwd: string, names: readonly string[]): string | undefined {\n  const start = resolve(cwd);\n  const root = resolveProjectRoot(start);\n  const pathFromRoot = root ? relative(root, start) : undefined;\n  const boundary =\n    root &&\n    pathFromRoot !== undefined &&\n    !isAbsolute(pathFromRoot) &&\n    pathFromRoot !== \"..\" &&\n    !pathFromRoot.startsWith(`..${sep}`)\n      ? root\n      : undefined;\n  for (let dir = start; ; dir = dirname(dir)) {\n    for (const name of names) {\n      const path = resolve(dir, name);\n      if (statSync(path)?.isFile()) return path;\n    }\n    if (boundary === undefined || dir === boundary) break;\n  }\n  return undefined;\n}\n\n/** A recognized source override, else the caller's automatic default. */\nfunction fileSourceEnabled(key: string, fallback: boolean = !isDatabricksAppEnv()): boolean {\n  return object.toBoolean(process.env[key]) ?? fallback;\n}\n\nfunction loadDotenv(\n  cwd: string,\n  environments: readonly string[],\n): Record<string, string | undefined> {\n  const names = [...environments.map((name) => `${DOTENV_FILE_NAME}.${name}`), DOTENV_FILE_NAME];\n  const path = findConfigFile(cwd, names);\n  if (!path) return {};\n  try {\n    return parseEnv(readFileSync(path, \"utf8\"));\n  } catch {\n    logger.warn(\"failed to read dotenv file\", { path });\n    return {};\n  }\n}\n\nfunction loadBundleFile(cwd: string, profile: string | null): ConfigFile | undefined {\n  const path = findConfigFile(cwd, BUNDLE_FILE_NAMES);\n  if (!path) return undefined;\n  const args = [\n    \"bundle\",\n    \"validate\",\n    \"--output\",\n    \"json\",\n    ...(profile === null ? [] : [\"--profile\", profile]),\n  ];\n  const result = spawnSync(\"databricks\", args, {\n    cwd: resolve(path, \"..\"),\n    encoding: \"utf8\",\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n  });\n  const output = stringModule.trimToNull(result.stdout);\n  const error = stringModule.trimToNull(result.stderr);\n  if (output === null) {\n    logger.debug(\"bundle validate produced no JSON\", { path, status: result.status, error });\n    return undefined;\n  }\n  const data = json.parseRecord(output);\n  if (!data) {\n    logger.warn(\"failed to parse bundle validate output\", { path, status: result.status });\n    return undefined;\n  }\n  if (result.status !== 0) {\n    logger.debug(\"using partial bundle output\", { path, status: result.status, error });\n  }\n  return { path, data };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Layered configuration lookup: environment, `.env`, Databricks bundle.\n *\n * Every package resolves settings the same way: take the caller's value, else\n * an environment variable, else a default. Local development adds two fallback\n * locations: `.env` files and `resources.apps.<app>.config.env` or root\n * `variables` in `databricks.yml`.\n *\n * Two things make it cheap to call from a hot path:\n *\n *   - {@link values} is LAZY (an `object.Sequence`), so `databricks bundle\n *     validate` is only spawned when the environment and `.env` both missed.\n *   - the parsed `.env` and bundle are cached through {@link context.cached}, so\n *     the spawn happens once per working directory and a `cwd` change misses\n *     rather than returning another project's config.\n *\n * Inside a deployed Databricks App both file sources are skipped by default\n * ({@link isDatabricksAppEnv}): the platform has already turned them into real\n * environment variables, there is no bundle to validate, and the `databricks`\n * CLI is not on the image. Boolean environment overrides can force either file\n * source on or off when a tool needs different behavior.\n *\n * The bundle is gated on this being an AppKit project at all. `databricks bundle\n * validate` is a process spawn measured in seconds, and a plain library or CLI\n * consumer has no bundle to find, so the gate runs in three steps before the\n * spawn is allowed - see {@link bundleFile}:\n *\n *   1. `@databricks/appkit` is resolved WITHOUT evaluating it. It is an optional\n *      peer, so a consumer that never installed it is not an AppKit project and\n *      the bundle is never loaded. The probe is cached, so this costs one\n *      resolution for the life of the process.\n *   2. The bundle is read (once per context) and must describe EXACTLY ONE app\n *      with `config.env`. Nothing here says which of several apps this process\n *      is, so an ambiguous bundle contributes nothing rather than a guess.\n *   3. AppKit's execution context confirms this process really is that app. The\n *      context does not exist until AppKit boots and `getExecutionContext()`\n *      THROWS until then, so the probe is caught and only the affirmative is\n *      remembered - a lookup before boot still resolves, and re-confirms later\n *      once the context is available.\n *\n * Only the single app's `config.env` is consulted. Root bundle `variables` are\n * not: they are authoring inputs for the bundle itself (interpolated into\n * targets, resources, and paths), so treating one as a process setting resolves\n * names the deployed app never sees.\n *\n * Node-only (`child_process`, `fs`, `process`).\n *\n * @module\n */\n\nimport { spawnSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { dirname, isAbsolute, relative, resolve, sep } from \"node:path\";\nimport { parseEnv } from \"node:util\";\nimport {\n  context,\n  functionModule,\n  json,\n  log,\n  object,\n  string as stringModule,\n} from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { statSync } from \"./file.ts\";\nimport { root as resolveProjectRoot } from \"./project.ts\";\n\nconst logger = log.logger(\"config\");\n\nexport type ConfigKey = string | readonly string[];\n\n/** Where a value may come from, consulted in the order given. */\nexport type ConfigSource = \"env\" | \"dotenv\" | \"bundle\";\n\nexport interface ConfigOptions {\n  /**\n   * Outermost namespaces tried before each key. Defaults to `DBX_TOOLS`.\n   */\n  scope?: string | readonly string[];\n  /** Capability namespaces inserted after the scope and before each key. */\n  prefix?: string | readonly string[];\n  /** Directory to resolve `.env` and the bundle from. Default: `process.cwd()`. */\n  cwd?: string;\n  /** Sources in precedence order. Default: `env`, `dotenv`, `bundle`. */\n  sources?: ConfigSource | readonly ConfigSource[];\n}\n\n/** One resolved value, tagged with the key and source it came from. */\ninterface ConfigValue {\n  key: string;\n  source: ConfigSource;\n  value: string;\n}\n\n/** A config file found on disk, with its parsed contents. */\nexport interface ConfigFile {\n  path: string;\n  data: Record<string, unknown>;\n}\n\nconst DEFAULT_SCOPE = \"DBX_TOOLS\";\nconst DEFAULT_SOURCES: readonly ConfigSource[] = [\"env\", \"dotenv\", \"bundle\"];\nconst BUNDLE_FILE_NAMES = [\"databricks.yml\", \"databricks.yaml\"] as const;\nconst DOTENV_FILE_NAME = \".env\";\nconst NODE_ENV_ALTERNATIVES = {\n  production: [\"prod\"],\n  development: [\"dev\"],\n} as const satisfies Record<string, readonly string[]>;\n\n/** Highest valid TCP port number. */\nexport const MAX_TCP_PORT = 65_535;\n\n/** Boolean environment override for {@link isDatabricksAppEnv}. */\nexport const DATABRICKS_APP_ENV_KEY = \"DBX_TOOLS_DATABRICKS_APP_ENV\";\n\n/** Boolean environment override for project `.env` reads. */\nexport const CONFIG_DOTENV_KEY = \"DBX_TOOLS_CONFIG_DOTENV\";\n\n/** Boolean environment override for Databricks bundle reads. */\nexport const CONFIG_BUNDLE_KEY = \"DBX_TOOLS_CONFIG_BUNDLE\";\n\n/**\n * The OPTIONAL AppKit peer whose presence marks this as a Databricks App\n * project. Held as a constant so the resolve probe and the lazy import name it\n * once, and so neither site carries a literal a bundler would try to follow.\n */\nconst APPKIT_MODULE = \"@databricks/appkit\";\n\n/**\n * The one thing this module needs from AppKit: whether a real execution context\n * is active. Typed structurally so an OPTIONAL peer never becomes a type\n * dependency, and `client` is `unknown` because its presence is all that is read.\n */\ntype AppKitModule = {\n  getExecutionContext(): { client?: unknown } | undefined;\n};\n\n/**\n * Whether AppKit's execution context has EVER been observed. Latching is the\n * point: a context confirms this process is the bundle's app, and that fact does\n * not stop being true when a later lookup happens outside a request scope.\n */\nlet appKitContext = false;\n\n/** Flattened App `config.env` per parsed bundle - see {@link bundleApp}. */\nconst BUNDLE_APP_CACHE = new WeakMap<object, Record<string, string>>();\n\n/** Exact process-environment lookup for callers that do not read local config files. */\nexport const ENV_ONLY = { scope: [] as const, sources: \"env\" as const };\n\nexport const bundleValue = z\n  .string()\n  .transform((value: string) => value.trim())\n  .refine((value: string) => value.length > 0)\n  .refine((value: string) => !/\\$\\{[^}]+\\}/.test(value), {\n    message: \"Interpolated values are not allowed\",\n  });\n\n/**\n * The GENERIC shape of a bundle resource: a name, and whatever else the resource\n * type carries. Deliberately unopinionated and `passthrough()` - the concrete\n * resource kinds (`sql_warehouse`, `genie_space`, `postgres`, ...) are\n * Databricks-App concepts that belong to the package that resolves them, so\n * node-appkit `.extend()`s this rather than this module knowing about them.\n */\nexport const bundleResourceSchema = z.object({ name: bundleValue.optional() }).passthrough();\n\nexport const bundleEnvEntrySchema = z.object({\n  name: bundleValue.optional(),\n  value: z.string().optional(),\n  value_from: bundleValue.optional(),\n});\n\nexport const bundleAppSchema = z.object({\n  name: bundleValue.optional(),\n  source_code_path: z.string().optional(),\n  config: z.object({ env: z.array(bundleEnvEntrySchema).optional() }).optional(),\n  resources: z.array(bundleResourceSchema).optional(),\n});\n\nconst bundleAppsSchema = z.object({\n  resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),\n});\n\n/**\n * Detect a Databricks App runtime from its required name, host, and port.\n *\n * `DBX_TOOLS_DATABRICKS_APP_ENV` takes precedence when it contains a recognized\n * boolean value. This lets local tools emulate the deployed runtime (`true`) or\n * lets unusual deployed processes retain local config lookup (`false`). An\n * absent or unrecognized override falls back to structural detection.\n */\nexport function isDatabricksAppEnv(\n  source: Record<string, string | undefined> = process.env,\n): boolean {\n  const override = object.toBoolean(source[DATABRICKS_APP_ENV_KEY]);\n  if (override !== undefined) return override;\n  const appName = source.DATABRICKS_APP_NAME?.trim();\n  const host = source.DATABRICKS_HOST?.trim();\n  const port = source.DATABRICKS_APP_PORT?.trim();\n  if (!appName || !host || !port) return false;\n  try {\n    if (![\"http:\", \"https:\"].includes(new URL(host).protocol)) return false;\n  } catch {\n    return false;\n  }\n  const portNumber = object.toNumber(port);\n  return (\n    portNumber !== undefined &&\n    Number.isInteger(portNumber) &&\n    portNumber >= 1 &&\n    portNumber <= MAX_TCP_PORT\n  );\n}\n\n/** Candidate names in scope, prefix, and input precedence order. */\nfunction keys(input: ConfigKey, options: Pick<ConfigOptions, \"scope\" | \"prefix\"> = {}): string[] {\n  const scopes = object.sequence(options.scope ?? DEFAULT_SCOPE).toArray();\n  const prefixes = options.prefix === undefined ? [] : object.sequence(options.prefix).toArray();\n  return [\n    ...object\n      .sequence(input)\n      .flatMap((key) => {\n        const prefixed = prefixes.length > 0 ? prefixes.map((prefix) => join(prefix, key)) : [key];\n        return [\n          ...scopes.flatMap((scope) => prefixed.map((key) => join(scope, key))),\n          ...prefixed,\n          key,\n        ];\n      })\n      .filter((key) => key.length > 0)\n      .distinct(),\n  ];\n}\n\n/**\n * Every value that resolves for `input`, in source-then-key precedence order,\n * as a LAZY sequence: nothing past the first consumed element is read, so\n * `values(key).first()` never spawns the Databricks CLI when the environment\n * already answered.\n *\n */\nfunction values(input: ConfigKey, options: ConfigOptions = {}): object.Sequence<ConfigValue> {\n  const candidates = keys(input, options);\n  const sources = object.sequence<ConfigSource>(options.sources ?? DEFAULT_SOURCES);\n  return object.sequence({\n    *[Symbol.iterator](): Generator<ConfigValue> {\n      for (const source of sources) {\n        for (const map of read(source, options.cwd)) {\n          for (const key of candidates) {\n            const value = stringModule.trimToNull(map[key]);\n            if (value !== null) yield { key, source, value };\n          }\n        }\n      }\n    },\n  });\n}\n\n/**\n * The first value that resolves for `input`, or `undefined`.\n *\n * @example\n * const domain = config.text([\"TUNNEL_PUBLIC_DOMAIN\", \"PUBLIC_DOMAIN\"]);\n */\nexport function text(input: ConfigKey, options: ConfigOptions = {}): string | undefined {\n  return values(input, options).at(0)?.value;\n}\n\n/**\n * The PRIMARY (fully-scoped) name for `input` - what to print in a log line or an\n * error, so the message names the variable a reader should set. Do not index\n * `keys(...)[0]` for this if `input` may be a bare string.\n *\n * @example\n * logger.warn(`${config.name(JWT_SECRET_ENV)} is not set`);\n */\nexport function name(\n  input: ConfigKey,\n  options: Pick<ConfigOptions, \"scope\" | \"prefix\"> = {},\n): string {\n  return keys(input, options)[0] ?? \"\";\n}\n\n/**\n * Safe `.env.<name>` suffixes for a Node environment, exact spelling first.\n * Known long and short names are interchangeable; unknown names pass through.\n */\nfunction nodeEnvNames(nodeEnv: unknown): string[] {\n  const name = stringModule.trimToNull(nodeEnv)?.toLowerCase();\n  if (!name || !/^[a-z0-9_-]+$/.test(name)) return [];\n  for (const [canonical, alternatives] of Object.entries(NODE_ENV_ALTERNATIVES)) {\n    const names: readonly string[] = alternatives;\n    if (name === canonical || names.includes(name)) {\n      return [...object.sequence(name, canonical, alternatives).distinct()];\n    }\n  }\n  return [name];\n}\n\nfunction join(...parts: string[]): string {\n  return parts\n    .map((part) => part.trim())\n    .filter(Boolean)\n    .join(\"_\");\n}\n\n/**\n * Resolve a string: `configured` when non-empty, else {@link text}, else `undefined`.\n *\n * The coercion rules are deliberately loose (`on` / `yes` / `1` are all\n * `true`) because values may come from a file a human typed.\n *\n * @example\n * config.string(options.host, \"SMTP_HOST\");\n */\nexport function string(\n  configured: unknown,\n  input: ConfigKey,\n  options?: ConfigOptions,\n): string | undefined {\n  return stringModule.trimToNull(configured) ?? text(input, options);\n}\n\n/**\n * Resolve a boolean through `object.toBoolean`. `undefined` when neither source\n * is interpretable, so the caller picks a default with `??`.\n */\nexport function boolean(\n  configured: unknown,\n  input: ConfigKey,\n  options?: ConfigOptions,\n): boolean | undefined {\n  return object.toBoolean(configured) ?? object.toBoolean(text(input, options));\n}\n\n/**\n * Resolve a positive number that may be fractional (a score threshold, a ratio).\n * Use {@link positiveInt} for a count, port, or timeout.\n */\nexport function positiveNumber(\n  configured: unknown,\n  input: ConfigKey,\n  fallback: number,\n  options?: ConfigOptions,\n): number {\n  return toPositiveNumber(configured) ?? toPositiveNumber(text(input, options)) ?? fallback;\n}\n\n/**\n * Resolve a positive integer (a port, a timeout, a page size), floored. A\n * non-numeric or non-positive value is treated as ABSENT rather than fatal -\n * these are ceilings where a sane default beats a boot failure.\n */\nexport function positiveInt(\n  configured: unknown,\n  input: ConfigKey,\n  fallback: number,\n  options?: ConfigOptions,\n): number {\n  const resolved = positiveNumber(configured, input, fallback, options);\n  return Math.floor(resolved);\n}\n\n/**\n * Resolve a list through `string.parseList`, so an array from typed config and a\n * `\"a, b c\"` string normalize identically. `[]` when neither source has entries.\n */\nexport function list(\n  configured: string | readonly string[] | undefined | null,\n  input: ConfigKey,\n  transform?: (entry: string) => string,\n  options?: ConfigOptions,\n): string[] {\n  const fromConfig = stringModule.parseList(configured, transform);\n  return fromConfig.length > 0\n    ? fromConfig\n    : stringModule.parseList(text(input, options), transform);\n}\n\nfunction toPositiveNumber(value: unknown): number | undefined {\n  const parsed = object.toNumber(value);\n  return parsed !== undefined && parsed > 0 ? parsed : undefined;\n}\n\n/**\n * The Databricks bundle output for `cwd` - `databricks bundle validate --output\n * json` run from the directory holding `databricks.yml`, with the config file's\n * path. A non-zero validation may still return partial JSON with usable App\n * config. `undefined` when bundle reads are disabled, this is not an AppKit\n * project, the bundle does not describe exactly one app with `config.env`, there\n * is no bundle, or the CLI produces no JSON.\n *\n * The spawn is guarded because it is expensive and usually pointless. In order:\n * `@databricks/appkit` must be RESOLVABLE (no AppKit, no bundle - and the probe\n * never evaluates the module); the bundle must describe exactly ONE app carrying\n * `config.env`; and AppKit's execution context must confirm this process is that\n * app. Only the confirmation is remembered, so a lookup during boot - before any\n * context exists - still resolves from the bundle and re-confirms later.\n *\n * Cached once per resolved working-directory context and\n * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated\n * lookups do not rerun validation and changing either cannot return another\n * context's bundle.\n */\nexport function bundleFile(cwd?: string | null): ConfigFile | undefined {\n  const production = process.env.NODE_ENV?.trim().toLowerCase() === \"production\";\n  const override = object.toBoolean(process.env[CONFIG_BUNDLE_KEY]);\n  if (override === false) return undefined;\n  // An explicit `true` is the escape hatch for a tool that wants the bundle\n  // without being the app (`dbx` commands, tests), so it skips the AppKit gate\n  // entirely - but not the App/production defaults, which it also overrides.\n  if (override === undefined) {\n    if (production || isDatabricksAppEnv()) return undefined;\n    if (!appKitInstalled()) return undefined;\n  }\n  const profile = stringModule.trimToNull(process.env.DATABRICKS_CONFIG_PROFILE);\n  const file = cachedConfig([\"bundle\", profile ?? \"\"], cwd, (resolved) =>\n    loadBundleFile(resolved, profile),\n  );\n  if (override !== undefined || file === undefined) return file;\n  // Already confirmed: this process is the app, and that does not stop being\n  // true, so skip re-deriving the gate on every lookup.\n  if (appKitContext) return file;\n  // The app must be unambiguous. `bundleApp` is what decides \"exactly one app\n  // with `config.env`\", so an empty map IS the ambiguous or app-less bundle and\n  // needs no separate check.\n  if (Object.keys(bundleApp(file.data)).length === 0) return undefined;\n  confirmAppKitContext();\n  return file;\n}\n\n/**\n * The single App's literal `config.env` entries, flattened to `name -> value`.\n *\n * A `value_from` entry names a bundle resource whose id is known after\n * deployment, and reading it needs the resource vocabulary this module\n * deliberately does not have - node-appkit resolves those against its extended\n * {@link bundleResourceSchema}. An `apps` block with more than one app is\n * ambiguous (nothing here says which app this process is), so it yields nothing\n * rather than a guess.\n *\n * Memoized against the parsed bundle it came from, because both the gate in\n * {@link bundleFile} and the lookup in {@link read} ask the same question of the\n * same cached object - validating that payload twice per lookup would be pure\n * waste. A `WeakMap` keeps the entry alive exactly as long as the bundle is.\n */\nfunction bundleApp(input: unknown): Record<string, string> {\n  if (!object.isRecord(input)) return bundleAppEntries(input);\n  const cached = BUNDLE_APP_CACHE.get(input);\n  if (cached) return cached;\n  const result = bundleAppEntries(input);\n  BUNDLE_APP_CACHE.set(input, result);\n  return result;\n}\n\n/** {@link bundleApp} without the memoization, so the cache has one filler. */\nfunction bundleAppEntries(input: unknown): Record<string, string> {\n  const parsed = bundleAppsSchema.safeParse(input);\n  if (!parsed.success) return {};\n  const apps = parsed.data.resources?.apps;\n  if (!apps) return {};\n  const names = Object.keys(apps);\n  if (names.length !== 1) return {};\n  const entries = apps[names[0]!]?.config?.env ?? [];\n  const result: Record<string, string> = {};\n  for (const entry of entries) {\n    if (!entry.name) continue;\n    const value = resolvedString(entry.value);\n    if (value !== null) result[entry.name] = value;\n  }\n  return result;\n}\n\n/**\n * Whether `@databricks/appkit` can be RESOLVED from this process, cached for its\n * lifetime.\n *\n * Resolution, not import: this answers \"is this an AppKit project\" without\n * evaluating the module, so the cheap negative (a plain library or CLI consumer\n * that never installed the optional peer) costs one path lookup and never boots\n * AppKit as a side effect of reading config. A runtime with no `createRequire`\n * (a browser bundle that reached this Node-only module anyway) reports absent.\n */\nconst appKitInstalled = functionModule.memoize((): boolean => {\n  try {\n    // Indirect specifier: a bundler must not try to follow an OPTIONAL peer that\n    // a browser build has no way to resolve.\n    const specifier = APPKIT_MODULE;\n    createRequire(import.meta.url).resolve(specifier);\n    return true;\n  } catch {\n    return false;\n  }\n});\n\n/**\n * AppKit's execution context once it exists, or `undefined`.\n *\n * Lazily imported (and `@vite-ignore`d) because `@databricks/appkit` is an\n * OPTIONAL peer this module must never make required. The import is only\n * attempted once {@link appKitInstalled} says there is something to import, and a\n * failure resolves to `undefined` rather than rejecting - a missing peer is the\n * expected path, not an error.\n *\n * `getExecutionContext()` THROWS until AppKit has booted, so the call is caught\n * and only a real context is reported. The module handle is memoized; the\n * context lookup is not, so a call before boot answers \"not yet\" and a later one\n * still sees the context.\n */\nconst appKitModule = functionModule.memoize(async (): Promise<AppKitModule | undefined> => {\n  if (!appKitInstalled()) return undefined;\n  const specifier = APPKIT_MODULE;\n  return (await import(/* @vite-ignore */ specifier).catch(() => undefined)) as\n    AppKitModule | undefined;\n});\n\n/**\n * Latch {@link appKitContext} once AppKit's execution context exists.\n *\n * Fire-and-forget, because the caller is a SYNCHRONOUS lookup and the check\n * needs a lazy import. The affirmative is all that is stored: AppKit's context\n * does not exist until it boots, and `getExecutionContext()` throws until then,\n * so remembering a negative would permanently disable the bundle for a process\n * that is seconds away from having one. Every call before the latch closes\n * re-attempts, which is what makes \"not available yet\" retry rather than stick.\n */\nfunction confirmAppKitContext(): void {\n  void appKitModule()\n    .then((appkit) => {\n      if (!appkit) return;\n      try {\n        if (appkit.getExecutionContext()?.client) appKitContext = true;\n      } catch {\n        // AppKit has not booted yet; a later call re-checks.\n      }\n    })\n    .catch(() => undefined);\n}\n\n/** A non-empty bundle value with every `${...}` interpolation resolved. */\nfunction resolvedString(value: unknown): string | null {\n  const parsed = bundleValue.safeParse(value);\n  return parsed.success ? parsed.data : null;\n}\n\n/** Parsed `.env` for `cwd`, or `{}`. Read once per resolved context. */\nfunction dotenv(cwd?: string | null): Record<string, string | undefined> {\n  if (!fileSourceEnabled(CONFIG_DOTENV_KEY)) return {};\n  const environments = nodeEnvNames(process.env.NODE_ENV);\n  return cachedConfig([\"dotenv\", ...environments], cwd, (resolved) =>\n    loadDotenv(resolved, environments),\n  );\n}\n\n/** Cache every target directory separately within the active process context. */\nfunction cachedConfig<T>(\n  name: readonly string[],\n  cwd: string | null | undefined,\n  loader: (resolved: string) => T,\n): T {\n  const active = context.getContext() ?? \"\";\n  const resolved = resolve(cwd ?? \".\");\n  return context.cached([\"config\", active, resolved, ...name], () => loader(resolved));\n}\n\n/**\n * Maps for one source in precedence order. Bundle App config and root variables\n * stay separate so a first-match lookup does not parse variables after an App\n * value resolves.\n */\nfunction read(\n  source: ConfigSource,\n  cwd?: string,\n): object.Sequence<Record<string, string | undefined>> {\n  return object.sequence({\n    *[Symbol.iterator](): Generator<Record<string, string | undefined>> {\n      switch (source) {\n        case \"env\":\n          yield process.env;\n          break;\n        case \"dotenv\":\n          yield dotenv(cwd);\n          break;\n        case \"bundle\": {\n          const bundle = bundleFile(cwd);\n          if (bundle) yield bundleApp(bundle.data);\n          break;\n        }\n      }\n    },\n  });\n}\n\n/**\n * Locate `names` from `cwd` outward. `cwd` itself is checked before the\n * discovered project roots so a package-local file wins over the workspace's.\n */\nfunction findConfigFile(cwd: string, names: readonly string[]): string | undefined {\n  const start = resolve(cwd);\n  const root = resolveProjectRoot(start);\n  const pathFromRoot = root ? relative(root, start) : undefined;\n  const boundary =\n    root &&\n    pathFromRoot !== undefined &&\n    !isAbsolute(pathFromRoot) &&\n    pathFromRoot !== \"..\" &&\n    !pathFromRoot.startsWith(`..${sep}`)\n      ? root\n      : undefined;\n  for (let dir = start; ; dir = dirname(dir)) {\n    for (const name of names) {\n      const path = resolve(dir, name);\n      if (statSync(path)?.isFile()) return path;\n    }\n    if (boundary === undefined || dir === boundary) break;\n  }\n  return undefined;\n}\n\n/** A recognized source override, else the caller's automatic default. */\nfunction fileSourceEnabled(key: string, fallback: boolean = !isDatabricksAppEnv()): boolean {\n  return object.toBoolean(process.env[key]) ?? fallback;\n}\n\nfunction loadDotenv(\n  cwd: string,\n  environments: readonly string[],\n): Record<string, string | undefined> {\n  const names = [...environments.map((name) => `${DOTENV_FILE_NAME}.${name}`), DOTENV_FILE_NAME];\n  const path = findConfigFile(cwd, names);\n  if (!path) return {};\n  try {\n    return parseEnv(readFileSync(path, \"utf8\"));\n  } catch {\n    logger.warn(\"failed to read dotenv file\", { path });\n    return {};\n  }\n}\n\nfunction loadBundleFile(cwd: string, profile: string | null): ConfigFile | undefined {\n  const path = findConfigFile(cwd, BUNDLE_FILE_NAMES);\n  if (!path) return undefined;\n  const args = [\n    \"bundle\",\n    \"validate\",\n    \"--output\",\n    \"json\",\n    ...(profile === null ? [] : [\"--profile\", profile]),\n  ];\n  const result = spawnSync(\"databricks\", args, {\n    cwd: resolve(path, \"..\"),\n    encoding: \"utf8\",\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n  });\n  const output = stringModule.trimToNull(result.stdout);\n  const error = stringModule.trimToNull(result.stderr);\n  if (output === null) {\n    logger.debug(\"bundle validate produced no JSON\", { path, status: result.status, error });\n    return undefined;\n  }\n  const data = json.parseRecord(output);\n  if (!data) {\n    logger.warn(\"failed to parse bundle validate output\", { path, status: result.status });\n    return undefined;\n  }\n  if (result.status !== 0) {\n    logger.debug(\"using partial bundle output\", { path, status: result.status, error });\n  }\n  return { path, data };\n}\n"]}

package/package.json

@@ -18,12 +18,16 @@
     "projen": "projen"
   },
   "devDependencies": {
+    "@databricks/appkit": "^0.43.0",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "@databricks/appkit": "^0.43.0"
+  },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.86",
+    "@dbx-tools/shared-core": "0.6.88",
     "extract-zip": "^2.0.1",
     "tar": "^7.5.22",
     "yaml": "^2.9.0",
@@ -43,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.86",
+  "version": "0.6.88",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -58,6 +62,11 @@
     "src",
     "lib"
   ],
+  "peerDependenciesMeta": {
+    "@databricks/appkit": {
+      "optional": true
+    }
+  },
   "dbxToolsConfig": {
     "tags": [
       "node"

package/src/config.ts

@@ -20,6 +20,29 @@
  * CLI is not on the image. Boolean environment overrides can force either file
  * source on or off when a tool needs different behavior.
  *
+ * The bundle is gated on this being an AppKit project at all. `databricks bundle
+ * validate` is a process spawn measured in seconds, and a plain library or CLI
+ * consumer has no bundle to find, so the gate runs in three steps before the
+ * spawn is allowed - see {@link bundleFile}:
+ *
+ *   1. `@databricks/appkit` is resolved WITHOUT evaluating it. It is an optional
+ *      peer, so a consumer that never installed it is not an AppKit project and
+ *      the bundle is never loaded. The probe is cached, so this costs one
+ *      resolution for the life of the process.
+ *   2. The bundle is read (once per context) and must describe EXACTLY ONE app
+ *      with `config.env`. Nothing here says which of several apps this process
+ *      is, so an ambiguous bundle contributes nothing rather than a guess.
+ *   3. AppKit's execution context confirms this process really is that app. The
+ *      context does not exist until AppKit boots and `getExecutionContext()`
+ *      THROWS until then, so the probe is caught and only the affirmative is
+ *      remembered - a lookup before boot still resolves, and re-confirms later
+ *      once the context is available.
+ *
+ * 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.
+ *
  * Node-only (`child_process`, `fs`, `process`).
  *
  * @module
@@ -27,9 +50,17 @@
 
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { parseEnv } from "node:util";
-import { context, json, log, object, string as stringModule } from "@dbx-tools/shared-core";
+import {
+  context,
+  functionModule,
+  json,
+  log,
+  object,
+  string as stringModule,
+} from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { statSync } from "./file.ts";
 import { root as resolveProjectRoot } from "./project.ts";
@@ -88,6 +119,32 @@ export const CONFIG_DOTENV_KEY = "DBX_TOOLS_CONFIG_DOTENV";
 /** Boolean environment override for Databricks bundle reads. */
 export const CONFIG_BUNDLE_KEY = "DBX_TOOLS_CONFIG_BUNDLE";
 
+/**
+ * The OPTIONAL AppKit peer whose presence marks this as a Databricks App
+ * project. Held as a constant so the resolve probe and the lazy import name it
+ * once, and so neither site carries a literal a bundler would try to follow.
+ */
+const APPKIT_MODULE = "@databricks/appkit";
+
+/**
+ * The one thing this module needs from AppKit: whether a real execution context
+ * is active. Typed structurally so an OPTIONAL peer never becomes a type
+ * dependency, and `client` is `unknown` because its presence is all that is read.
+ */
+type AppKitModule = {
+  getExecutionContext(): { client?: unknown } | undefined;
+};
+
+/**
+ * Whether AppKit's execution context has EVER been observed. Latching is the
+ * point: a context confirms this process is the bundle's app, and that fact does
+ * not stop being true when a later lookup happens outside a request scope.
+ */
+let appKitContext = false;
+
+/** Flattened App `config.env` per parsed bundle - see {@link bundleApp}. */
+const BUNDLE_APP_CACHE = new WeakMap<object, Record<string, string>>();
+
 /** Exact process-environment lookup for callers that do not read local config files. */
 export const ENV_ONLY = { scope: [] as const, sources: "env" as const };
 
@@ -114,11 +171,6 @@ export const bundleEnvEntrySchema = z.object({
   value_from: bundleValue.optional(),
 });
 
-const bundleVariableSchema = z.object({
-  default: z.string().optional(),
-  value: z.string().optional(),
-});
-
 export const bundleAppSchema = z.object({
   name: bundleValue.optional(),
   source_code_path: z.string().optional(),
@@ -130,10 +182,6 @@ const bundleAppsSchema = z.object({
   resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),
 });
 
-const bundleVariablesSchema = z.object({
-  variables: z.record(z.string(), bundleVariableSchema).optional(),
-});
-
 /**
  * Detect a Databricks App runtime from its required name, host, and port.
  *
@@ -338,9 +386,17 @@ function toPositiveNumber(value: unknown): number | undefined {
 /**
  * The Databricks bundle output for `cwd` - `databricks bundle validate --output
  * json` run from the directory holding `databricks.yml`, with the config file's
- * path. A non-zero validation may still return partial JSON with usable
- * variables. `undefined` when bundle reads are disabled, there is no bundle, or
- * the CLI produces no JSON.
+ * path. A non-zero validation may still return partial JSON with usable App
+ * config. `undefined` when bundle reads are disabled, this is not an AppKit
+ * project, the bundle does not describe exactly one app with `config.env`, there
+ * is no bundle, or the CLI produces no JSON.
+ *
+ * The spawn is guarded because it is expensive and usually pointless. In order:
+ * `@databricks/appkit` must be RESOLVABLE (no AppKit, no bundle - and the probe
+ * never evaluates the module); the bundle must describe exactly ONE app carrying
+ * `config.env`; and AppKit's execution context must confirm this process is that
+ * app. Only the confirmation is remembered, so a lookup during boot - before any
+ * context exists - still resolves from the bundle and re-confirms later.
  *
  * Cached once per resolved working-directory context and
  * `DATABRICKS_CONFIG_PROFILE` through {@link context.cached}, so repeated
@@ -349,11 +405,29 @@ function toPositiveNumber(value: unknown): number | undefined {
  */
 export function bundleFile(cwd?: string | null): ConfigFile | undefined {
   const production = process.env.NODE_ENV?.trim().toLowerCase() === "production";
-  if (!fileSourceEnabled(CONFIG_BUNDLE_KEY, !production && !isDatabricksAppEnv())) return undefined;
+  const override = object.toBoolean(process.env[CONFIG_BUNDLE_KEY]);
+  if (override === false) return undefined;
+  // An explicit `true` is the escape hatch for a tool that wants the bundle
+  // without being the app (`dbx` commands, tests), so it skips the AppKit gate
+  // entirely - but not the App/production defaults, which it also overrides.
+  if (override === undefined) {
+    if (production || isDatabricksAppEnv()) return undefined;
+    if (!appKitInstalled()) return undefined;
+  }
   const profile = stringModule.trimToNull(process.env.DATABRICKS_CONFIG_PROFILE);
-  return cachedConfig(["bundle", profile ?? ""], cwd, (resolved) =>
+  const file = cachedConfig(["bundle", profile ?? ""], cwd, (resolved) =>
     loadBundleFile(resolved, profile),
   );
+  if (override !== undefined || file === undefined) return file;
+  // Already confirmed: this process is the app, and that does not stop being
+  // true, so skip re-deriving the gate on every lookup.
+  if (appKitContext) return file;
+  // The app must be unambiguous. `bundleApp` is what decides "exactly one app
+  // with `config.env`", so an empty map IS the ambiguous or app-less bundle and
+  // needs no separate check.
+  if (Object.keys(bundleApp(file.data)).length === 0) return undefined;
+  confirmAppKitContext();
+  return file;
 }
 
 /**
@@ -365,8 +439,23 @@ export function bundleFile(cwd?: string | null): ConfigFile | undefined {
  * {@link bundleResourceSchema}. An `apps` block with more than one app is
  * ambiguous (nothing here says which app this process is), so it yields nothing
  * rather than a guess.
+ *
+ * Memoized against the parsed bundle it came from, because both the gate in
+ * {@link bundleFile} and the lookup in {@link read} ask the same question of the
+ * same cached object - validating that payload twice per lookup would be pure
+ * waste. A `WeakMap` keeps the entry alive exactly as long as the bundle is.
  */
 function bundleApp(input: unknown): Record<string, string> {
+  if (!object.isRecord(input)) return bundleAppEntries(input);
+  const cached = BUNDLE_APP_CACHE.get(input);
+  if (cached) return cached;
+  const result = bundleAppEntries(input);
+  BUNDLE_APP_CACHE.set(input, result);
+  return result;
+}
+
+/** {@link bundleApp} without the memoization, so the cache has one filler. */
+function bundleAppEntries(input: unknown): Record<string, string> {
   const parsed = bundleAppsSchema.safeParse(input);
   if (!parsed.success) return {};
   const apps = parsed.data.resources?.apps;
@@ -384,23 +473,69 @@ function bundleApp(input: unknown): Record<string, string> {
 }
 
 /**
- * Root bundle variables flattened to environment-style `NAME -> value` entries.
+ * Whether `@databricks/appkit` can be RESOLVED from this process, cached for its
+ * lifetime.
  *
- * `databricks bundle validate` resolves each variable to `value`; `default` is
- * retained as a fallback for parsed bundle data that has not been fully
- * resolved. Names are normalized so a bundle variable such as
- * `tunnel_public_domain` answers a lookup for `TUNNEL_PUBLIC_DOMAIN`.
+ * Resolution, not import: this answers "is this an AppKit project" without
+ * evaluating the module, so the cheap negative (a plain library or CLI consumer
+ * that never installed the optional peer) costs one path lookup and never boots
+ * AppKit as a side effect of reading config. A runtime with no `createRequire`
+ * (a browser bundle that reached this Node-only module anyway) reports absent.
  */
-function bundleVariables(input: unknown): Record<string, string> {
-  const parsed = bundleVariablesSchema.safeParse(input);
-  if (!parsed.success) return {};
-  const result: Record<string, string> = {};
-  for (const [name, variable] of Object.entries(parsed.data.variables ?? {})) {
-    const key = [...stringModule.tokenize(name)].join("_").toUpperCase();
-    const value = resolvedString(variable.value) ?? resolvedString(variable.default);
-    if (key && value !== null) result[key] = value;
+const appKitInstalled = functionModule.memoize((): boolean => {
+  try {
+    // Indirect specifier: a bundler must not try to follow an OPTIONAL peer that
+    // a browser build has no way to resolve.
+    const specifier = APPKIT_MODULE;
+    createRequire(import.meta.url).resolve(specifier);
+    return true;
+  } catch {
+    return false;
   }
-  return result;
+});
+
+/**
+ * AppKit's execution context once it exists, or `undefined`.
+ *
+ * Lazily imported (and `@vite-ignore`d) because `@databricks/appkit` is an
+ * OPTIONAL peer this module must never make required. The import is only
+ * attempted once {@link appKitInstalled} says there is something to import, and a
+ * failure resolves to `undefined` rather than rejecting - a missing peer is the
+ * expected path, not an error.
+ *
+ * `getExecutionContext()` THROWS until AppKit has booted, so the call is caught
+ * and only a real context is reported. The module handle is memoized; the
+ * context lookup is not, so a call before boot answers "not yet" and a later one
+ * still sees the context.
+ */
+const appKitModule = functionModule.memoize(async (): Promise<AppKitModule | undefined> => {
+  if (!appKitInstalled()) return undefined;
+  const specifier = APPKIT_MODULE;
+  return (await import(/* @vite-ignore */ specifier).catch(() => undefined)) as
+    AppKitModule | undefined;
+});
+
+/**
+ * Latch {@link appKitContext} once AppKit's execution context exists.
+ *
+ * Fire-and-forget, because the caller is a SYNCHRONOUS lookup and the check
+ * needs a lazy import. The affirmative is all that is stored: AppKit's context
+ * does not exist until it boots, and `getExecutionContext()` throws until then,
+ * so remembering a negative would permanently disable the bundle for a process
+ * that is seconds away from having one. Every call before the latch closes
+ * re-attempts, which is what makes "not available yet" retry rather than stick.
+ */
+function confirmAppKitContext(): void {
+  void appKitModule()
+    .then((appkit) => {
+      if (!appkit) return;
+      try {
+        if (appkit.getExecutionContext()?.client) appKitContext = true;
+      } catch {
+        // AppKit has not booted yet; a later call re-checks.
+      }
+    })
+    .catch(() => undefined);
 }
 
 /** A non-empty bundle value with every `${...}` interpolation resolved. */
@@ -449,10 +584,7 @@ function read(
           break;
         case "bundle": {
           const bundle = bundleFile(cwd);
-          if (bundle) {
-            yield bundleApp(bundle.data);
-            yield bundleVariables(bundle.data);
-          }
+          if (bundle) yield bundleApp(bundle.data);
           break;
         }
       }