@dbx-tools/appkit 0.6.81 → 0.6.85

package/README.md

@@ -42,7 +42,7 @@ Use this package when the friction is around bootstrapping and reuse:
 - AppKit plugin instances are generic; the lookup helpers keep sibling-plugin
   access typed and errors actionable.
 - AppKit does not own your local CLI flags, bundle validation output, or
-  `app.yaml`; `config.resolveConfigValue()` gives setup scripts one resolution
+  `app.yaml`; `bundle.resolveConfigValue()` gives setup scripts one resolution
   path across those sources.
 - AppKit's `asUser(req)` throws outside `NODE_ENV=development` when a request
   carries no OBO token; `identity` makes falling back to the service principal a
@@ -158,22 +158,22 @@ await; `lakebaseResolver.applyLakebaseEnv()` resolves and applies the full set.
 
 ## Resolve Local And Bundle Config
 
-`config.resolveConfigValue()` checks explicit options, CLI overrides, env vars,
+`bundle.resolveConfigValue()` checks explicit options, CLI overrides, env vars,
 Databricks Asset Bundle validation output, and `app.yaml` env entries, in AppKit's
 precedence order: explicit config, then environment variable, then the app or
 bundle definition.
 
 ```ts
-import { config } from "@dbx-tools/appkit";
+import { bundle } from "@dbx-tools/appkit";
 
-const warehouseId = await config.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
+const warehouseId = await bundle.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },
-  sources: config.withCliSources(),
+  sources: bundle.withCliSources(),
 });
 ```
 
 Use this in CLIs and setup scripts that should behave the same locally and in a
-Databricks App deployment. `config.bundle()` and `config.appYaml()` expose the
+Databricks App deployment. `bundle.bundle()` and `bundle.appYaml()` expose the
 parsed files when you need to diagnose which source won.
 
 ## Parse Lakebase Addresses
@@ -228,9 +228,6 @@ await client.apiClient.request(
 );
 ```
 
-`databricks.isAppEnv()` checks the Databricks App environment shape for setup
-code that should skip local-only filesystem or bundle discovery.
-
 ## Look Up Sibling Plugins
 
 AppKit's plugin map is intentionally generic. `plugin.data()`,

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export * as appkit from "./src/appkit.ts";
-export * as config from "./src/config.ts";
+export * as bundle from "./src/bundle.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -12,8 +12,8 @@ export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
 export * as provision from "./src/provision.ts";
 export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
-export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/config.ts";
-export { MAX_TCP_PORT } from "./src/databricks.ts";
+export { bundleAppResourceSchema } from "./src/bundle.ts";
+export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/bundle.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export * as appkit from "./src/appkit.ts";
-export * as config from "./src/config.ts";
+export * as bundle from "./src/bundle.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -8,8 +8,8 @@ export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
 export * as provision from "./src/provision.ts";
 export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
-export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/config.ts";
-export { MAX_TCP_PORT } from "./src/databricks.ts";
+export { bundleAppResourceSchema } from "./src/bundle.ts";
+export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/bundle.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as appkit from "./src/appkit.js";
-export * as config from "./src/config.js";
+export * as bundle from "./src/bundle.js";
 export * as databricks from "./src/databricks.js";
 export * as identity from "./src/identity.js";
 export * as interceptor from "./src/interceptor.js";
@@ -10,8 +10,8 @@ export * as lakebaseResolver from "./src/lakebase-resolver.js";
 export * as pgaddress from "./src/pgaddress.js";
 export * as plugin from "./src/plugin.js";
 export * as provision from "./src/provision.js";
-export { MAX_TCP_PORT } from "./src/databricks.js";
+export { bundleAppResourceSchema } from "./src/bundle.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.js";
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.js";
 export { SSL_MODES } from "./src/pgaddress.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/{config.d.ts → bundle.d.ts}

@@ -1,25 +1,46 @@
 /**
- * Layered configuration resolution for local development against a Databricks
- * App / Asset Bundle.
+ * DATABRICKS-APP configuration resolution: the bundle and `app.yaml` vocabulary.
+ *
+ * node-core's `config` module owns the generic lookup - environment, `.env`,
+ * `databricks bundle validate` - and knows nothing about what a bundle resource
+ * IS. That last part is this module: `sql_warehouse`, `genie_space`, and
+ * `postgres` are Databricks-App concepts, and an `app.yaml` / bundle
+ * `value_from` entry is a REFERENCE to one of them whose real value is the
+ * warehouse id or Genie space id sitting on the named resource. So this module
+ * extends node-core's resource schema, adds `app.yaml` (which the bundle CLI
+ * never sees), and resolves those references.
  *
  * Default sources: `explicit`, then `env`, then Databricks App `config.env`
  * (from {@link bundle}) and hard-coded `app.yaml` env entries (from
  * {@link appYaml}). Opt in to `cli` when a dev command wants flag overrides.
  *
- * Server-only (`node:child_process`, bundle root discovery). Databricks-app
- * specific, so it lives in node-appkit rather than shared-core.
+ * Server-only, and Databricks-app specific, so it lives in node-appkit rather
+ * than node-core.
  *
  * @module
  */
+import { config as coreConfig } from "@dbx-tools/core";
+import { z } from "zod";
 /** Parsed payload from `databricks bundle validate --output json`. */
 export type BundleValidateJson = Record<string, unknown>;
 /** A config file discovered on disk with its parsed contents. */
-export interface ConfigFile {
-    path: string;
-    data: Record<string, unknown>;
-}
+export type ConfigFile = coreConfig.ConfigFile;
 /** Supported configuration sources, consulted in array order. */
 export type ConfigSource = "explicit" | "cli" | "env" | "bundle";
+export declare const bundleAppResourceSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    sql_warehouse: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strip>>;
+    genie_space: z.ZodOptional<z.ZodObject<{
+        space_id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strip>>;
+    postgres: z.ZodOptional<z.ZodObject<{
+        database: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        branch: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        endpoint: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
 /** Single config map entry (string or repeated values, like headers). */
 export type ConfigMapValue = string | string[] | undefined;
 export interface ResolveConfigValueOptions {
@@ -49,15 +70,17 @@ export declare function flattenAppYamlEnv(data: unknown): Record<string, string>
  */
 export declare function flattenAppEnv(data: unknown): Record<string, string>;
 /**
- * Locate the bundle root and run `databricks bundle validate --output json`.
- * When `cwd` is omitted or equals `process.cwd()`, the result is memoized for
- * the process lifetime. Returns `undefined` inside a Databricks App.
+ * The validated bundle for `cwd` - {@link coreConfig.bundleFile}, which caches it
+ * per working directory. Returns `undefined` inside a Databricks App, where the
+ * platform has already turned `config.env` into real environment variables and
+ * there is no bundle to validate.
  */
 export declare function bundle(cwd?: string): Promise<ConfigFile | undefined>;
 /**
- * Locate and parse `app.yaml` / `app.yml` from the bundle or project root. When
- * `cwd` is omitted or equals `process.cwd()`, the result is memoized for the
- * process lifetime. Returns `undefined` inside a Databricks App.
+ * Locate and parse `app.yaml` / `app.yml` from the bundle or project root.
+ * Cached per working directory through {@link context.cached}, so a `cwd` change
+ * re-reads instead of returning another project's file. Returns `undefined`
+ * inside a Databricks App.
  */
 export declare function appYaml(cwd?: string): Promise<ConfigFile | undefined>;
 /**
@@ -74,11 +97,11 @@ export declare function getBundlePath(data: BundleValidateJson, path: string): s
  * whatever the Databricks App / bundle definition supplies.
  *
  * @example
- * import { config } from "@dbx-tools/appkit";
+ * import { bundle } from "@dbx-tools/appkit";
  *
- * const warehouseId = await config.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
+ * const warehouseId = await bundle.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
  *   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },
- *   sources: config.withCliSources(),
+ *   sources: bundle.withCliSources(),
  * });
  */
 export declare function resolveConfigValue(name: string, options?: ResolveConfigValueOptions): Promise<string | undefined>;

package/lib/src/bundle.js

@@ -0,0 +1,359 @@
+/**
+ * DATABRICKS-APP configuration resolution: the bundle and `app.yaml` vocabulary.
+ *
+ * node-core's `config` module owns the generic lookup - environment, `.env`,
+ * `databricks bundle validate` - and knows nothing about what a bundle resource
+ * IS. That last part is this module: `sql_warehouse`, `genie_space`, and
+ * `postgres` are Databricks-App concepts, and an `app.yaml` / bundle
+ * `value_from` entry is a REFERENCE to one of them whose real value is the
+ * warehouse id or Genie space id sitting on the named resource. So this module
+ * extends node-core's resource schema, adds `app.yaml` (which the bundle CLI
+ * never sees), and resolves those references.
+ *
+ * Default sources: `explicit`, then `env`, then Databricks App `config.env`
+ * (from {@link bundle}) and hard-coded `app.yaml` env entries (from
+ * {@link appYaml}). Opt in to `cli` when a dev command wants flag overrides.
+ *
+ * Server-only, and Databricks-app specific, so it lives in node-appkit rather
+ * than node-core.
+ *
+ * @module
+ */
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { ValidationError } from "@databricks/appkit";
+import { config as coreConfig, file, project } from "@dbx-tools/core";
+import { context, object, log, string } from "@dbx-tools/shared-core";
+import { parse as parseYamlText } from "yaml";
+import { z } from "zod";
+const logger = log.logger("config");
+const defaultConfigSources = ["explicit", "env", "bundle"];
+const APP_YAML_NAMES = ["app.yaml", "app.yml"];
+export const bundleAppResourceSchema = coreConfig.bundleResourceSchema.extend({
+    sql_warehouse: z.object({ id: coreConfig.bundleValue.optional() }).optional(),
+    genie_space: z.object({ space_id: coreConfig.bundleValue.optional() }).optional(),
+    postgres: z
+        .object({
+        database: coreConfig.bundleValue.optional(),
+        branch: coreConfig.bundleValue.optional(),
+        endpoint: coreConfig.bundleValue.optional(),
+    })
+        .optional(),
+});
+const bundleAppSchema = coreConfig.bundleAppSchema.extend({
+    resources: z.array(bundleAppResourceSchema).optional(),
+});
+const bundleValidateAppsSchema = z.object({
+    resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),
+});
+const appYamlEnvEntrySchema = coreConfig.bundleEnvEntrySchema.omit({ value_from: true }).extend({
+    name: coreConfig.bundleValue,
+    valueFrom: coreConfig.bundleValue.optional(),
+});
+const appYamlResourceSchema = coreConfig.bundleResourceSchema
+    .extend({
+    name: coreConfig.bundleValue,
+    sql_warehouse: z.object({ id: coreConfig.bundleValue.optional() }).optional(),
+    genie_space: z.object({ space_id: coreConfig.bundleValue.optional() }).optional(),
+    postgres: z
+        .object({
+        database: coreConfig.bundleValue.optional(),
+        branch: coreConfig.bundleValue.optional(),
+        endpoint: coreConfig.bundleValue.optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const appYamlSchema = z.object({
+    env: z.array(appYamlEnvEntrySchema).optional(),
+    resources: z.array(appYamlResourceSchema).optional(),
+});
+function envKeysForName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return object.sequence();
+    }
+    const keys = (function* () {
+        const modifiers = [
+            null,
+            () => trimmed.toUpperCase(),
+            () => Array.from(string.tokenize(trimmed)).join("_").toUpperCase(),
+        ];
+        for (const modifier of modifiers) {
+            yield modifier ? modifier(trimmed) : trimmed;
+        }
+    })();
+    return object.sequence(keys).cache().filter(Boolean).distinct();
+}
+function readEnv(keys) {
+    for (const key of keys) {
+        const value = process.env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readConfigMapValue(value) {
+    if (value == null)
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const trimmed = item?.trim();
+            if (trimmed)
+                return trimmed;
+        }
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function readMap(keys, map) {
+    if (!map)
+        return undefined;
+    for (const key of keys) {
+        const value = readConfigMapValue(map[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readAppEnv(keys, envMap) {
+    for (const key of keys) {
+        const value = envMap[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function parseYaml(text) {
+    return parseYamlText(text);
+}
+function pickAppResourceId(apps) {
+    const keys = Object.keys(apps);
+    return keys.length === 1 ? keys[0] : undefined;
+}
+/**
+ * Resolve the effective value a `value_from`/`valueFrom` entry points at:
+ * the first present of the warehouse id, Genie space id, or Postgres
+ * endpoint/database/branch on the named resource. Shared by both the
+ * `app.yaml` and `bundle validate` flatteners, whose resource shapes match.
+ */
+function resolveResourceValue(resource) {
+    return (resource?.sql_warehouse?.id ??
+        resource?.genie_space?.space_id ??
+        resource?.postgres?.endpoint ??
+        resource?.postgres?.database ??
+        resource?.postgres?.branch);
+}
+/**
+ * Flatten `env` entries from parsed `app.yaml` content. Literal `value` entries
+ * are returned as-is; `valueFrom` entries resolve against the sibling
+ * `resources` array when possible.
+ */
+export function flattenAppYamlEnv(data) {
+    const parsed = appYamlSchema.safeParse(data);
+    if (!parsed.success || !parsed.data.env?.length) {
+        return {};
+    }
+    const resourceByName = new Map((parsed.data.resources ?? []).map((resource) => [resource.name, resource]));
+    const out = {};
+    for (const entry of parsed.data.env) {
+        const value = coreConfig.bundleValue.safeParse(entry.value);
+        if (value.success) {
+            out[entry.name] = value.data;
+            continue;
+        }
+        if (!entry.valueFrom)
+            continue;
+        const resolved = resolveResourceValue(resourceByName.get(entry.valueFrom));
+        if (resolved)
+            out[entry.name] = resolved;
+    }
+    return out;
+}
+/**
+ * Flatten `resources.apps.<key>.config.env` into a `name -> value` map.
+ * Auto-picks the app only when the bundle defines exactly one.
+ */
+export function flattenAppEnv(data) {
+    const parsed = bundleValidateAppsSchema.safeParse(data);
+    if (!parsed.success)
+        return {};
+    const apps = parsed.data.resources?.apps;
+    if (!apps || Object.keys(apps).length === 0)
+        return {};
+    const key = pickAppResourceId(apps);
+    if (!key)
+        return {};
+    const app = apps[key];
+    if (!app?.config?.env?.length)
+        return {};
+    const resourceByName = new Map((app.resources ?? [])
+        .filter((resource) => resource.name)
+        .map((resource) => [resource.name, resource]));
+    const out = {};
+    for (const entry of app.config.env) {
+        if (!entry.name)
+            continue;
+        const value = coreConfig.bundleValue.safeParse(entry.value);
+        if (value.success) {
+            out[entry.name] = value.data;
+            continue;
+        }
+        if (!entry.value_from)
+            continue;
+        const resolved = resolveResourceValue(resourceByName.get(entry.value_from));
+        if (resolved)
+            out[entry.name] = resolved;
+    }
+    return out;
+}
+async function loadAppYaml(cwd) {
+    for (const fileName of APP_YAML_NAMES) {
+        const configFile = resolveConfigFile(cwd, fileName);
+        if (!configFile)
+            continue;
+        try {
+            const text = await readFile(configFile, "utf8");
+            const data = parseYaml(text);
+            if (!object.isRecord(data)) {
+                return undefined;
+            }
+            return { path: configFile, data };
+        }
+        catch {
+            logger.warn("failed to parse app yaml", { path: configFile });
+        }
+    }
+    return undefined;
+}
+function resolveConfigFile(cwd, configFile) {
+    if (coreConfig.isDatabricksAppEnv())
+        return undefined;
+    for (const rootDir of project.resolveProjectRoots(cwd)) {
+        const bundlePath = resolve(rootDir, configFile);
+        if (file.statSync(bundlePath)?.isFile())
+            return bundlePath;
+    }
+    return undefined;
+}
+/**
+ * The validated bundle for `cwd` - {@link coreConfig.bundleFile}, which caches it
+ * per working directory. Returns `undefined` inside a Databricks App, where the
+ * platform has already turned `config.env` into real environment variables and
+ * there is no bundle to validate.
+ */
+export function bundle(cwd) {
+    return Promise.resolve(coreConfig.isDatabricksAppEnv() ? undefined : coreConfig.bundleFile(cwd));
+}
+/**
+ * Locate and parse `app.yaml` / `app.yml` from the bundle or project root.
+ * Cached per working directory through {@link context.cached}, so a `cwd` change
+ * re-reads instead of returning another project's file. Returns `undefined`
+ * inside a Databricks App.
+ */
+export function appYaml(cwd) {
+    if (coreConfig.isDatabricksAppEnv())
+        return Promise.resolve(undefined);
+    return context.cached(["appkit", "appYaml"], (resolved) => loadAppYaml(resolved ?? "."), cwd);
+}
+/**
+ * Walk a dot-separated path through bundle validate JSON. When the terminal
+ * node is a bundle variable object (`{ value: "..." }`), the `value` field is
+ * returned.
+ */
+export function getBundlePath(data, path) {
+    const parts = path.split(".").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    let current = data;
+    for (let i = 0; i < parts.length; i++) {
+        if (!object.isRecord(current))
+            return undefined;
+        const part = parts[i];
+        const next = current[part];
+        if (i === parts.length - 1) {
+            if (typeof next === "string" && next)
+                return next;
+            if (object.isRecord(next)) {
+                const value = next.value;
+                return typeof value === "string" && value ? value : undefined;
+            }
+            return undefined;
+        }
+        current = next;
+    }
+    return undefined;
+}
+async function resolveAppEnvMap(options) {
+    const appData = options.appData ?? (await appYaml());
+    const bundleData = options.bundleData ?? (await bundle());
+    const fromYaml = appData ? flattenAppYamlEnv(appData.data) : {};
+    const fromBundle = bundleData ? flattenAppEnv(bundleData.data) : {};
+    return { ...fromYaml, ...fromBundle };
+}
+function resolveSources(options) {
+    const sources = [...(options.sources ?? defaultConfigSources)];
+    if (options.explicit !== undefined && !sources.includes("explicit")) {
+        sources.unshift("explicit");
+    }
+    return sources;
+}
+/**
+ * Resolve a configuration string from the configured sources. Returns the first
+ * non-empty value, or `undefined` when nothing matches.
+ *
+ * Precedence follows AppKit's: explicit config, then environment variable, then
+ * whatever the Databricks App / bundle definition supplies.
+ *
+ * @example
+ * import { bundle } from "@dbx-tools/appkit";
+ *
+ * const warehouseId = await bundle.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
+ *   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },
+ *   sources: bundle.withCliSources(),
+ * });
+ */
+export async function resolveConfigValue(name, options = {}) {
+    const keys = envKeysForName(name).toArray();
+    if (keys.length === 0)
+        return undefined;
+    const sources = resolveSources(options);
+    let appEnvMap;
+    const values = (async function* () {
+        for (const source of sources) {
+            switch (source) {
+                case "explicit":
+                    yield readMap(keys, options.explicit);
+                    break;
+                case "cli":
+                    yield readMap(keys, options.cli);
+                    break;
+                case "env":
+                    yield readEnv(keys);
+                    break;
+                case "bundle":
+                    if (appEnvMap === undefined)
+                        appEnvMap = await resolveAppEnvMap(options);
+                    yield readAppEnv(keys, appEnvMap);
+                    break;
+                default:
+                    throw ValidationError.invalidValue("sources", source, "one of: explicit, cli, env, bundle");
+            }
+        }
+    })();
+    for await (const value of values) {
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Sources with `cli` included, in CLI-first order. Use for dev commands that
+ * accept flag overrides.
+ */
+export function withCliSources(sources = defaultConfigSources) {
+    const rest = sources.filter((source) => source !== "cli" && source !== "explicit");
+    return ["cli", "explicit", ...rest];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../../src/bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAWpC,MAAM,oBAAoB,GAAmB,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AAE3E,MAAM,cAAc,GAAG,CAAC,UAAU,EAAE,SAAS,CAAU,CAAC;AAExD,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC,oBAAoB,CAAC,MAAM,CAAC;IAC5E,aAAa,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC7E,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE;IACjF,QAAQ,EAAE,CAAC;SACR,MAAM,CAAC;QACN,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;QAC3C,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;QACzC,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;KAC5C,CAAC;SACD,QAAQ,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC;IACxD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,QAAQ,EAAE;CACvD,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,eAAe,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC3F,CAAC,CAAC;AAEH,MAAM,qBAAqB,GAAG,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAC9F,IAAI,EAAE,UAAU,CAAC,WAAW;IAC5B,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;CAC7C,CAAC,CAAC;AAEH,MAAM,qBAAqB,GAAG,UAAU,CAAC,oBAAoB;KAC1D,MAAM,CAAC;IACN,IAAI,EAAE,UAAU,CAAC,WAAW;IAC5B,aAAa,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC7E,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE;IACjF,QAAQ,EAAE,CAAC;SACR,MAAM,CAAC;QACN,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;QAC3C,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;QACzC,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE;KAC5C,CAAC;SACD,QAAQ,EAAE;CACd,CAAC;KACD,WAAW,EAAE,CAAC;AAEjB,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7B,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,QAAQ,EAAE;IAC9C,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,QAAQ,EAAE;CACrD,CAAC,CAAC;AAuBH,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC;QACrB,MAAM,SAAS,GAA2C;YACxD,IAAI;YACJ,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE;YAC3B,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE;SACnE,CAAC;QACF,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,MAAM,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IACL,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AAClE,CAAC;AAED,SAAS,OAAO,CAAC,IAAsB;IACrC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC;QACvC,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAqB;IAC/C,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,OAAO,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC;YAC7B,IAAI,OAAO;gBAAE,OAAO,OAAO,CAAC;QAC9B,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,OAAO,IAAI,SAAS,CAAC;AAC9B,CAAC;AAED,SAAS,OAAO,CACd,IAAsB,EACtB,GAA+C;IAE/C,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAC3B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,UAAU,CAAC,IAAsB,EAAE,MAA8B;IACxE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC;QAClC,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,SAAS,iBAAiB,CAAC,IAA+B;IACxD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAC3B,QAA6D;IAE7D,OAAO,CACL,QAAQ,EAAE,aAAa,EAAE,EAAE;QAC3B,QAAQ,EAAE,WAAW,EAAE,QAAQ;QAC/B,QAAQ,EAAE,QAAQ,EAAE,QAAQ;QAC5B,QAAQ,EAAE,QAAQ,EAAE,QAAQ;QAC5B,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAC3B,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAa;IAC7C,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAChD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,GAAG,CAC5B,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAC3E,CAAC;IAEF,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC;YAC7B,SAAS;QACX,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,SAAS;YAAE,SAAS;QAC/B,MAAM,QAAQ,GAAG,oBAAoB,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;QAC3E,IAAI,QAAQ;YAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;IAC3C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa;IACzC,MAAM,MAAM,GAAG,wBAAwB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACxD,IAAI,CAAC,MAAM,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IAE/B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC;IACzC,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEvD,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IAEpB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;IACtB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;QAAE,OAAO,EAAE,CAAC;IAEzC,MAAM,cAAc,GAAG,IAAI,GAAG,CAC5B,CAAC,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;SAClB,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC;SACnC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAK,EAAE,QAAQ,CAAC,CAAC,CACjD,CAAC;IAEF,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,IAAI;YAAE,SAAS;QAC1B,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC;YAC7B,SAAS;QACX,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,UAAU;YAAE,SAAS;QAChC,MAAM,QAAQ,GAAG,oBAAoB,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QAC5E,IAAI,QAAQ;YAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;IAC3C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,WAAW,CAAC,GAAW;IACpC,KAAK,MAAM,QAAQ,IAAI,cAAc,EAAE,CAAC;QACtC,MAAM,UAAU,GAAG,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU;YAAE,SAAS;QAC1B,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YAChD,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC3B,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;QACpC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,iBAAiB,CAAC,GAAW,EAAE,UAAkB;IACxD,IAAI,UAAU,CAAC,kBAAkB,EAAE;QAAE,OAAO,SAAS,CAAC;IACtD,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAChD,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE;YAAE,OAAO,UAAU,CAAC;IAC7D,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,GAAY;IACjC,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;AACnG,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,GAAY;IAClC,IAAI,UAAU,CAAC,kBAAkB,EAAE;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACvE,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAChG,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,IAAwB,EAAE,IAAY;IAClE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAEzC,IAAI,OAAO,GAAY,IAAI,CAAC;IAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;YAAE,OAAO,SAAS,CAAC;QAChD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QACvB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI;gBAAE,OAAO,IAAI,CAAC;YAClD,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;gBACzB,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;YAChE,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,KAAK,UAAU,gBAAgB,CAC7B,OAAkC;IAElC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,MAAM,OAAO,EAAE,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC;IAC1D,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAChE,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACpE,OAAO,EAAE,GAAG,QAAQ,EAAE,GAAG,UAAU,EAAE,CAAC;AACxC,CAAC;AAED,SAAS,cAAc,CAAC,OAAkC;IACxD,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,oBAAoB,CAAC,CAAC,CAAC;IAC/D,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QACpE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,IAAY,EACZ,UAAqC,EAAE;IAEvC,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC;IAC5C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACxC,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IACxC,IAAI,SAA6C,CAAC;IAClD,MAAM,MAAM,GAAG,CAAC,KAAK,SAAS,CAAC;QAC7B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,QAAQ,MAAM,EAAE,CAAC;gBACf,KAAK,UAAU;oBACb,MAAM,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;oBACtC,MAAM;gBACR,KAAK,KAAK;oBACR,MAAM,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;oBACjC,MAAM;gBACR,KAAK,KAAK;oBACR,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;oBACpB,MAAM;gBACR,KAAK,QAAQ;oBACX,IAAI,SAAS,KAAK,SAAS;wBAAE,SAAS,GAAG,MAAM,gBAAgB,CAAC,OAAO,CAAC,CAAC;oBACzE,MAAM,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;oBAClC,MAAM;gBACR;oBACE,MAAM,eAAe,CAAC,YAAY,CAChC,SAAS,EACT,MAAM,EACN,oCAAoC,CACrC,CAAC;YACN,CAAC;QACH,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IACL,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,UAA0B,oBAAoB;IAC3E,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,UAAU,CAAC,CAAC;IACnF,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;AACtC,CAAC","sourcesContent":["/**\n * DATABRICKS-APP configuration resolution: the bundle and `app.yaml` vocabulary.\n *\n * node-core's `config` module owns the generic lookup - environment, `.env`,\n * `databricks bundle validate` - and knows nothing about what a bundle resource\n * IS. That last part is this module: `sql_warehouse`, `genie_space`, and\n * `postgres` are Databricks-App concepts, and an `app.yaml` / bundle\n * `value_from` entry is a REFERENCE to one of them whose real value is the\n * warehouse id or Genie space id sitting on the named resource. So this module\n * extends node-core's resource schema, adds `app.yaml` (which the bundle CLI\n * never sees), and resolves those references.\n *\n * Default sources: `explicit`, then `env`, then Databricks App `config.env`\n * (from {@link bundle}) and hard-coded `app.yaml` env entries (from\n * {@link appYaml}). Opt in to `cli` when a dev command wants flag overrides.\n *\n * Server-only, and Databricks-app specific, so it lives in node-appkit rather\n * than node-core.\n *\n * @module\n */\n\nimport { readFile } from \"node:fs/promises\";\nimport { resolve } from \"node:path\";\nimport { ValidationError } from \"@databricks/appkit\";\nimport { config as coreConfig, file, project } from \"@dbx-tools/core\";\nimport { context, object, log, string } from \"@dbx-tools/shared-core\";\nimport { parse as parseYamlText } from \"yaml\";\nimport { z } from \"zod\";\n\nconst logger = log.logger(\"config\");\n\n/** Parsed payload from `databricks bundle validate --output json`. */\nexport type BundleValidateJson = Record<string, unknown>;\n\n/** A config file discovered on disk with its parsed contents. */\nexport type ConfigFile = coreConfig.ConfigFile;\n\n/** Supported configuration sources, consulted in array order. */\nexport type ConfigSource = \"explicit\" | \"cli\" | \"env\" | \"bundle\";\n\nconst defaultConfigSources: ConfigSource[] = [\"explicit\", \"env\", \"bundle\"];\n\nconst APP_YAML_NAMES = [\"app.yaml\", \"app.yml\"] as const;\n\nexport const bundleAppResourceSchema = coreConfig.bundleResourceSchema.extend({\n  sql_warehouse: z.object({ id: coreConfig.bundleValue.optional() }).optional(),\n  genie_space: z.object({ space_id: coreConfig.bundleValue.optional() }).optional(),\n  postgres: z\n    .object({\n      database: coreConfig.bundleValue.optional(),\n      branch: coreConfig.bundleValue.optional(),\n      endpoint: coreConfig.bundleValue.optional(),\n    })\n    .optional(),\n});\n\nconst bundleAppSchema = coreConfig.bundleAppSchema.extend({\n  resources: z.array(bundleAppResourceSchema).optional(),\n});\n\nconst bundleValidateAppsSchema = z.object({\n  resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),\n});\n\nconst appYamlEnvEntrySchema = coreConfig.bundleEnvEntrySchema.omit({ value_from: true }).extend({\n  name: coreConfig.bundleValue,\n  valueFrom: coreConfig.bundleValue.optional(),\n});\n\nconst appYamlResourceSchema = coreConfig.bundleResourceSchema\n  .extend({\n    name: coreConfig.bundleValue,\n    sql_warehouse: z.object({ id: coreConfig.bundleValue.optional() }).optional(),\n    genie_space: z.object({ space_id: coreConfig.bundleValue.optional() }).optional(),\n    postgres: z\n      .object({\n        database: coreConfig.bundleValue.optional(),\n        branch: coreConfig.bundleValue.optional(),\n        endpoint: coreConfig.bundleValue.optional(),\n      })\n      .optional(),\n  })\n  .passthrough();\n\nconst appYamlSchema = z.object({\n  env: z.array(appYamlEnvEntrySchema).optional(),\n  resources: z.array(appYamlResourceSchema).optional(),\n});\n\ntype BundleApp = z.infer<typeof bundleAppSchema>;\n\n/** Single config map entry (string or repeated values, like headers). */\nexport type ConfigMapValue = string | string[] | undefined;\n\nexport interface ResolveConfigValueOptions {\n  /** Bundle validate JSON. Defaults to {@link bundle} (skipped inside a Databricks App). */\n  bundleData?: ConfigFile;\n  /** Parsed `app.yaml` contents. Defaults to {@link appYaml} (skipped inside a Databricks App). */\n  appData?: ConfigFile;\n  /**\n   * Sources to consult, first truthy string wins. Defaults to `explicit`, then\n   * `env`, then `bundle`.\n   */\n  sources?: ConfigSource[];\n  /** Programmatic overrides. When set, `explicit` is prepended to `sources` unless already listed. */\n  explicit?: Record<string, ConfigMapValue>;\n  /** CLI flag values (when `cli` is listed in `sources`). */\n  cli?: Record<string, ConfigMapValue>;\n}\n\nfunction envKeysForName(name: string): object.Sequence<string> {\n  const trimmed = name.trim();\n  if (!trimmed) {\n    return object.sequence();\n  }\n  const keys = (function* () {\n    const modifiers: (((value: string) => string) | null)[] = [\n      null,\n      () => trimmed.toUpperCase(),\n      () => Array.from(string.tokenize(trimmed)).join(\"_\").toUpperCase(),\n    ];\n    for (const modifier of modifiers) {\n      yield modifier ? modifier(trimmed) : trimmed;\n    }\n  })();\n  return object.sequence(keys).cache().filter(Boolean).distinct();\n}\n\nfunction readEnv(keys: Iterable<string>): string | undefined {\n  for (const key of keys) {\n    const value = process.env[key]?.trim();\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction readConfigMapValue(value: ConfigMapValue): string | undefined {\n  if (value == null) return undefined;\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      const trimmed = item?.trim();\n      if (trimmed) return trimmed;\n    }\n    return undefined;\n  }\n  const trimmed = value.trim();\n  return trimmed || undefined;\n}\n\nfunction readMap(\n  keys: Iterable<string>,\n  map: Record<string, ConfigMapValue> | undefined,\n): string | undefined {\n  if (!map) return undefined;\n  for (const key of keys) {\n    const value = readConfigMapValue(map[key]);\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction readAppEnv(keys: Iterable<string>, envMap: Record<string, string>): string | undefined {\n  for (const key of keys) {\n    const value = envMap[key]?.trim();\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction parseYaml(text: string): unknown {\n  return parseYamlText(text);\n}\n\nfunction pickAppResourceId(apps: Record<string, BundleApp>): string | undefined {\n  const keys = Object.keys(apps);\n  return keys.length === 1 ? keys[0] : undefined;\n}\n\n/**\n * Resolve the effective value a `value_from`/`valueFrom` entry points at:\n * the first present of the warehouse id, Genie space id, or Postgres\n * endpoint/database/branch on the named resource. Shared by both the\n * `app.yaml` and `bundle validate` flatteners, whose resource shapes match.\n */\nfunction resolveResourceValue(\n  resource: z.infer<typeof bundleAppResourceSchema> | undefined,\n): string | undefined {\n  return (\n    resource?.sql_warehouse?.id ??\n    resource?.genie_space?.space_id ??\n    resource?.postgres?.endpoint ??\n    resource?.postgres?.database ??\n    resource?.postgres?.branch\n  );\n}\n\n/**\n * Flatten `env` entries from parsed `app.yaml` content. Literal `value` entries\n * are returned as-is; `valueFrom` entries resolve against the sibling\n * `resources` array when possible.\n */\nexport function flattenAppYamlEnv(data: unknown): Record<string, string> {\n  const parsed = appYamlSchema.safeParse(data);\n  if (!parsed.success || !parsed.data.env?.length) {\n    return {};\n  }\n\n  const resourceByName = new Map(\n    (parsed.data.resources ?? []).map((resource) => [resource.name, resource]),\n  );\n\n  const out: Record<string, string> = {};\n  for (const entry of parsed.data.env) {\n    const value = coreConfig.bundleValue.safeParse(entry.value);\n    if (value.success) {\n      out[entry.name] = value.data;\n      continue;\n    }\n    if (!entry.valueFrom) continue;\n    const resolved = resolveResourceValue(resourceByName.get(entry.valueFrom));\n    if (resolved) out[entry.name] = resolved;\n  }\n  return out;\n}\n\n/**\n * Flatten `resources.apps.<key>.config.env` into a `name -> value` map.\n * Auto-picks the app only when the bundle defines exactly one.\n */\nexport function flattenAppEnv(data: unknown): Record<string, string> {\n  const parsed = bundleValidateAppsSchema.safeParse(data);\n  if (!parsed.success) return {};\n\n  const apps = parsed.data.resources?.apps;\n  if (!apps || Object.keys(apps).length === 0) return {};\n\n  const key = pickAppResourceId(apps);\n  if (!key) return {};\n\n  const app = apps[key];\n  if (!app?.config?.env?.length) return {};\n\n  const resourceByName = new Map(\n    (app.resources ?? [])\n      .filter((resource) => resource.name)\n      .map((resource) => [resource.name!, resource]),\n  );\n\n  const out: Record<string, string> = {};\n  for (const entry of app.config.env) {\n    if (!entry.name) continue;\n    const value = coreConfig.bundleValue.safeParse(entry.value);\n    if (value.success) {\n      out[entry.name] = value.data;\n      continue;\n    }\n    if (!entry.value_from) continue;\n    const resolved = resolveResourceValue(resourceByName.get(entry.value_from));\n    if (resolved) out[entry.name] = resolved;\n  }\n  return out;\n}\n\nasync function loadAppYaml(cwd: string): Promise<ConfigFile | undefined> {\n  for (const fileName of APP_YAML_NAMES) {\n    const configFile = resolveConfigFile(cwd, fileName);\n    if (!configFile) continue;\n    try {\n      const text = await readFile(configFile, \"utf8\");\n      const data = parseYaml(text);\n      if (!object.isRecord(data)) {\n        return undefined;\n      }\n      return { path: configFile, data };\n    } catch {\n      logger.warn(\"failed to parse app yaml\", { path: configFile });\n    }\n  }\n  return undefined;\n}\n\nfunction resolveConfigFile(cwd: string, configFile: string): string | undefined {\n  if (coreConfig.isDatabricksAppEnv()) return undefined;\n  for (const rootDir of project.resolveProjectRoots(cwd)) {\n    const bundlePath = resolve(rootDir, configFile);\n    if (file.statSync(bundlePath)?.isFile()) return bundlePath;\n  }\n  return undefined;\n}\n\n/**\n * The validated bundle for `cwd` - {@link coreConfig.bundleFile}, which caches it\n * per working directory. Returns `undefined` inside a Databricks App, where the\n * platform has already turned `config.env` into real environment variables and\n * there is no bundle to validate.\n */\nexport function bundle(cwd?: string): Promise<ConfigFile | undefined> {\n  return Promise.resolve(coreConfig.isDatabricksAppEnv() ? undefined : coreConfig.bundleFile(cwd));\n}\n\n/**\n * Locate and parse `app.yaml` / `app.yml` from the bundle or project root.\n * Cached per working directory through {@link context.cached}, so a `cwd` change\n * re-reads instead of returning another project's file. Returns `undefined`\n * inside a Databricks App.\n */\nexport function appYaml(cwd?: string): Promise<ConfigFile | undefined> {\n  if (coreConfig.isDatabricksAppEnv()) return Promise.resolve(undefined);\n  return context.cached([\"appkit\", \"appYaml\"], (resolved) => loadAppYaml(resolved ?? \".\"), cwd);\n}\n\n/**\n * Walk a dot-separated path through bundle validate JSON. When the terminal\n * node is a bundle variable object (`{ value: \"...\" }`), the `value` field is\n * returned.\n */\nexport function getBundlePath(data: BundleValidateJson, path: string): string | undefined {\n  const parts = path.split(\".\").filter(Boolean);\n  if (parts.length === 0) return undefined;\n\n  let current: unknown = data;\n  for (let i = 0; i < parts.length; i++) {\n    if (!object.isRecord(current)) return undefined;\n    const part = parts[i]!;\n    const next = current[part];\n    if (i === parts.length - 1) {\n      if (typeof next === \"string\" && next) return next;\n      if (object.isRecord(next)) {\n        const value = next.value;\n        return typeof value === \"string\" && value ? value : undefined;\n      }\n      return undefined;\n    }\n    current = next;\n  }\n  return undefined;\n}\n\nasync function resolveAppEnvMap(\n  options: ResolveConfigValueOptions,\n): Promise<Record<string, string>> {\n  const appData = options.appData ?? (await appYaml());\n  const bundleData = options.bundleData ?? (await bundle());\n  const fromYaml = appData ? flattenAppYamlEnv(appData.data) : {};\n  const fromBundle = bundleData ? flattenAppEnv(bundleData.data) : {};\n  return { ...fromYaml, ...fromBundle };\n}\n\nfunction resolveSources(options: ResolveConfigValueOptions): ConfigSource[] {\n  const sources = [...(options.sources ?? defaultConfigSources)];\n  if (options.explicit !== undefined && !sources.includes(\"explicit\")) {\n    sources.unshift(\"explicit\");\n  }\n  return sources;\n}\n\n/**\n * Resolve a configuration string from the configured sources. Returns the first\n * non-empty value, or `undefined` when nothing matches.\n *\n * Precedence follows AppKit's: explicit config, then environment variable, then\n * whatever the Databricks App / bundle definition supplies.\n *\n * @example\n * import { bundle } from \"@dbx-tools/appkit\";\n *\n * const warehouseId = await bundle.resolveConfigValue(\"DATABRICKS_WAREHOUSE_ID\", {\n *   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },\n *   sources: bundle.withCliSources(),\n * });\n */\nexport async function resolveConfigValue(\n  name: string,\n  options: ResolveConfigValueOptions = {},\n): Promise<string | undefined> {\n  const keys = envKeysForName(name).toArray();\n  if (keys.length === 0) return undefined;\n  const sources = resolveSources(options);\n  let appEnvMap: Record<string, string> | undefined;\n  const values = (async function* () {\n    for (const source of sources) {\n      switch (source) {\n        case \"explicit\":\n          yield readMap(keys, options.explicit);\n          break;\n        case \"cli\":\n          yield readMap(keys, options.cli);\n          break;\n        case \"env\":\n          yield readEnv(keys);\n          break;\n        case \"bundle\":\n          if (appEnvMap === undefined) appEnvMap = await resolveAppEnvMap(options);\n          yield readAppEnv(keys, appEnvMap);\n          break;\n        default:\n          throw ValidationError.invalidValue(\n            \"sources\",\n            source,\n            \"one of: explicit, cli, env, bundle\",\n          );\n      }\n    }\n  })();\n  for await (const value of values) {\n    if (value) return value;\n  }\n  return undefined;\n}\n\n/**\n * Sources with `cli` included, in CLI-first order. Use for dev commands that\n * accept flag overrides.\n */\nexport function withCliSources(sources: ConfigSource[] = defaultConfigSources): ConfigSource[] {\n  const rest = sources.filter((source) => source !== \"cli\" && source !== \"explicit\");\n  return [\"cli\", \"explicit\", ...rest];\n}\n"]}