@dbx-tools/appkit 0.6.69 → 0.6.70

package/lib/src/interceptor.js

@@ -5,17 +5,17 @@
  * unit - concurrently-style, where any death takes the whole set down.
  *
  * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
- * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
- * one AFTER auto-configuration has populated `process.env` but as part of booting
- * the app, so an interceptor sees the resolved connection and can bind processes
- * before or during setup.
+ * `appkit.createApp`'s `interceptor` option ("one or many"). `appkit.createApp`
+ * runs each one AFTER auto-configuration has populated `process.env` but as part
+ * of booting the app, so an interceptor sees the resolved connection and can bind
+ * processes before or during setup.
  *
  * The names here mirror AppKit's own vocabulary rather than inventing parallel
  * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
  * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
  * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
  * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
- * {@link createApp} injects to capture `this.context` and relay its events.
+ * `appkit.createApp` injects to capture `this.context` and relay its events.
  *
  * @module
  */
@@ -107,7 +107,7 @@ function hasOnLifecycle(context) {
     return typeof context?.onLifecycle === "function";
 }
 /**
- * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * The internal plugin `appkit.createApp` injects to make AppKit's lifecycle
  * reachable from interceptor code. On `setup()` it reads its own `this.context`
  * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
  * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine
@@ -138,4 +138,4 @@ export class LifecycleBridgePlugin extends Plugin {
 }
 /** Factory for the injected {@link LifecycleBridgePlugin}. */
 export const lifecycleBridge = toPlugin(LifecycleBridgePlugin);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The `createApp` INTERCEPTOR context: an in-process handle an app hands to\n * add-ons (the tunnel, chiefly) so they can read the env auto-configuration\n * computed, hook AppKit's lifecycle, and supervise sibling child processes as one\n * unit - concurrently-style, where any death takes the whole set down.\n *\n * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to\n * {@link CreateAppConfig.interceptor} (\"one or many\"). {@link createApp} runs each\n * one AFTER auto-configuration has populated `process.env` but as part of booting\n * the app, so an interceptor sees the resolved connection and can bind processes\n * before or during setup.\n *\n * The names here mirror AppKit's own vocabulary rather than inventing parallel\n * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the\n * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /\n * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -\n * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin\n * {@link createApp} injects to capture `this.context` and relay its events.\n *\n * @module\n */\n\nimport type { ChildProcess } from \"node:child_process\";\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { LakebaseConnection } from \"./lakebase-resolver.ts\";\n\nconst logger = log.logger(\"interceptor\");\n\n/**\n * AppKit's plugin-lifecycle events, verbatim from `PluginContext`\n * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared\n * structurally rather than imported because `PluginContext` is not in the\n * package's `exports` map (the same reason {@link PluginContextLike} exists in\n * `./plugin`).\n *\n * - `setup:complete` - every plugin's `setup()` has resolved.\n * - `server:ready` - the `server()` plugin is listening (never fires for a\n *   serverless app, e.g. the tunnel gate).\n * - `shutdown` - the app is tearing down.\n */\nexport type LifecycleEvent = \"setup:complete\" | \"server:ready\" | \"shutdown\";\n\n/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */\nexport type LifecycleHandler = () => void | Promise<void>;\n\n/**\n * The env auto-configuration resolved before boot, exposed to interceptors so\n * they read COMPUTED values instead of re-reading `process.env` themselves.\n *\n * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran\n * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the\n * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the\n * tunnel interceptor both reads and, when it must, sets.\n */\nexport interface ResolvedAppEnv {\n  /** Resolved Lakebase connection, when auto-config resolved one. */\n  readonly lakebase?: LakebaseConnection;\n  /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */\n  readonly databricksHost?: string;\n}\n\n/**\n * A process {@link InterceptorContext.bindProcess} can supervise. A bare\n * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does\n * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a\n * `ChildProcess`) - one code path handles both.\n */\nexport type BindableProcess = Pick<ChildProcess, \"pid\" | \"kill\" | \"killed\" | \"once\">;\n\n/**\n * The handle passed to each interceptor.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n *\n * await createApp({\n *   plugins: [server()],\n *   interceptor: (ctx) => {\n *     const portr = spawnPortr(ctx.env.databricksHost);\n *     ctx.bindProcess(portr);            // app <-> portr live/die together\n *     ctx.onLifecycle(\"shutdown\", () => portr.kill(\"SIGTERM\"));\n *   },\n * });\n */\nexport interface InterceptorContext {\n  /** The env auto-configuration computed before boot. */\n  readonly env: ResolvedAppEnv;\n  /**\n   * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;\n   * the injected {@link lifecycleBridge} relays the real events here once the app\n   * boots. A handler registered for an event that already fired is NOT called\n   * retroactively (same semantics as AppKit).\n   */\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n  /**\n   * Broadcast a termination signal from the main app to every bound process.\n   * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;\n   * exposed so an interceptor can trigger teardown itself.\n   */\n  broadcastSignal(signal: NodeJS.Signals): void;\n  /**\n   * Supervise a child process alongside the app, concurrently-style: signals pass\n   * through, and if EITHER the child or the app dies the whole set comes down.\n   * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for\n   * several children; teardown is idempotent.\n   */\n  bindProcess(child: BindableProcess): void;\n}\n\n/** A single interceptor, or several. The `createApp` `interceptor?:` option. */\nexport type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;\n\n/** How long bound children get to exit on `SIGTERM` before the app force-exits. */\nconst TEARDOWN_GRACE_MS = 3000;\n\n/** The signals that trigger teardown when the MAIN process receives them. */\nconst TEARDOWN_SIGNALS = [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const;\n\n/**\n * The mutable machinery behind an {@link InterceptorContext}. Split out so\n * {@link createInterceptorContext} can hand the public context to interceptors\n * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.\n */\nexport interface InterceptorRuntime {\n  /** The context handed to each interceptor. */\n  readonly context: InterceptorContext;\n  /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */\n  emitLifecycle(event: LifecycleEvent): Promise<void>;\n}\n\n/**\n * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.\n *\n * Teardown is the generalized `superviseExit`: the first child exit or main-process\n * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,\n * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it\n * never itself holds the loop open). The process-signal listeners are installed\n * lazily on the first `bindProcess` so an app that binds nothing is untouched.\n */\nexport function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime {\n  const handlers = new Map<LifecycleEvent, LifecycleHandler[]>();\n  const children = new Set<BindableProcess>();\n  let shuttingDown = false;\n  let signalsBound = false;\n\n  const teardown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();\n  };\n\n  const broadcastSignal = (signal: NodeJS.Signals): void => {\n    for (const child of children) {\n      if (!child.killed) child.kill(signal);\n    }\n    teardown(0);\n  };\n\n  const bindProcessSignals = (): void => {\n    if (signalsBound) return;\n    signalsBound = true;\n    for (const signal of TEARDOWN_SIGNALS) {\n      process.on(signal, () => broadcastSignal(signal));\n    }\n  };\n\n  const bindProcess = (child: BindableProcess): void => {\n    bindProcessSignals();\n    children.add(child);\n    child.once(\"exit\", (code) => {\n      logger.warn(\"bound process exited; tearing down the app\", { code });\n      teardown(typeof code === \"number\" ? code : 1);\n    });\n  };\n\n  const onLifecycle = (event: LifecycleEvent, fn: LifecycleHandler): void => {\n    const list = handlers.get(event);\n    if (list) list.push(fn);\n    else handlers.set(event, [fn]);\n  };\n\n  const emitLifecycle = async (event: LifecycleEvent): Promise<void> => {\n    const list = handlers.get(event);\n    if (!list) return;\n    for (const fn of list) {\n      try {\n        await fn();\n      } catch (error) {\n        // Match AppKit: a failing lifecycle handler is logged, never fatal, and\n        // never blocks its siblings.\n        logger.warn(\"lifecycle handler failed\", { event, error });\n      }\n    }\n  };\n\n  const context: InterceptorContext = {\n    env,\n    onLifecycle,\n    broadcastSignal,\n    bindProcess,\n  };\n\n  return { context, emitLifecycle };\n}\n\n/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */\ninterface LifecycleBridgeConfig extends BasePluginConfig {\n  /** The runtime whose `emitLifecycle` receives the real AppKit events. */\n  runtime?: InterceptorRuntime;\n}\n\n/**\n * Structural shape of the `PluginContext.onLifecycle` we bridge. Mirrors only the\n * one method we touch (like {@link PluginContextLike} in `./plugin`), since\n * AppKit's `PluginContext` is not importable from the package's `exports`.\n */\ninterface LifecycleContextLike {\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n}\n\nfunction hasOnLifecycle(context: unknown): context is LifecycleContextLike {\n  return typeof (context as LifecycleContextLike | undefined)?.onLifecycle === \"function\";\n}\n\n/**\n * The internal plugin {@link createApp} injects to make AppKit's lifecycle\n * reachable from interceptor code. On `setup()` it reads its own `this.context`\n * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the\n * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine\n * events. It owns no routes, config surface, or exports.\n */\nexport class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {\n  static manifest = {\n    name: \"dbxToolsLifecycleBridge\",\n    displayName: \"Lifecycle Bridge\",\n    description: \"Relays AppKit lifecycle events to the createApp interceptor context.\",\n    stability: \"beta\",\n    hidden: true,\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"dbxToolsLifecycleBridge\">;\n\n  override async setup(): Promise<void> {\n    const runtime = this.config.runtime;\n    if (!runtime) return;\n    if (!hasOnLifecycle(this.context)) {\n      logger.debug(\"no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert\");\n      return;\n    }\n    const events: LifecycleEvent[] = [\"setup:complete\", \"server:ready\", \"shutdown\"];\n    for (const event of events) {\n      this.context.onLifecycle(event, () => runtime.emitLifecycle(event));\n    }\n  }\n}\n\n/** Factory for the injected {@link LifecycleBridgePlugin}. */\nexport const lifecycleBridge = toPlugin(LifecycleBridgePlugin);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The `createApp` INTERCEPTOR context: an in-process handle an app hands to\n * add-ons (the tunnel, chiefly) so they can read the env auto-configuration\n * computed, hook AppKit's lifecycle, and supervise sibling child processes as one\n * unit - concurrently-style, where any death takes the whole set down.\n *\n * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to\n * `appkit.createApp`'s `interceptor` option (\"one or many\"). `appkit.createApp`\n * runs each one AFTER auto-configuration has populated `process.env` but as part\n * of booting the app, so an interceptor sees the resolved connection and can bind\n * processes before or during setup.\n *\n * The names here mirror AppKit's own vocabulary rather than inventing parallel\n * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the\n * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /\n * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -\n * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin\n * `appkit.createApp` injects to capture `this.context` and relay its events.\n *\n * @module\n */\n\nimport type { ChildProcess } from \"node:child_process\";\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { LakebaseConnection } from \"./lakebase-resolver.ts\";\n\nconst logger = log.logger(\"interceptor\");\n\n/**\n * AppKit's plugin-lifecycle events, verbatim from `PluginContext`\n * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared\n * structurally rather than imported because `PluginContext` is not in the\n * package's `exports` map (the same reason {@link PluginContextLike} exists in\n * `./plugin`).\n *\n * - `setup:complete` - every plugin's `setup()` has resolved.\n * - `server:ready` - the `server()` plugin is listening (never fires for a\n *   serverless app, e.g. the tunnel gate).\n * - `shutdown` - the app is tearing down.\n */\nexport type LifecycleEvent = \"setup:complete\" | \"server:ready\" | \"shutdown\";\n\n/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */\nexport type LifecycleHandler = () => void | Promise<void>;\n\n/**\n * The env auto-configuration resolved before boot, exposed to interceptors so\n * they read COMPUTED values instead of re-reading `process.env` themselves.\n *\n * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran\n * (see `appkit.autoConfigure`), else `undefined`. `databricksHost` is the\n * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the\n * tunnel interceptor both reads and, when it must, sets.\n */\nexport interface ResolvedAppEnv {\n  /** Resolved Lakebase connection, when auto-config resolved one. */\n  readonly lakebase?: LakebaseConnection;\n  /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */\n  readonly databricksHost?: string;\n}\n\n/**\n * A process {@link InterceptorContext.bindProcess} can supervise. A bare\n * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does\n * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a\n * `ChildProcess`) - one code path handles both.\n */\nexport type BindableProcess = Pick<ChildProcess, \"pid\" | \"kill\" | \"killed\" | \"once\">;\n\n/**\n * The handle passed to each interceptor.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * await appkit.createApp({\n *   plugins: [server()],\n *   interceptor: (ctx) => {\n *     const portr = spawnPortr(ctx.env.databricksHost);\n *     ctx.bindProcess(portr);            // app <-> portr live/die together\n *     ctx.onLifecycle(\"shutdown\", () => portr.kill(\"SIGTERM\"));\n *   },\n * });\n */\nexport interface InterceptorContext {\n  /** The env auto-configuration computed before boot. */\n  readonly env: ResolvedAppEnv;\n  /**\n   * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;\n   * the injected {@link lifecycleBridge} relays the real events here once the app\n   * boots. A handler registered for an event that already fired is NOT called\n   * retroactively (same semantics as AppKit).\n   */\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n  /**\n   * Broadcast a termination signal from the main app to every bound process.\n   * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;\n   * exposed so an interceptor can trigger teardown itself.\n   */\n  broadcastSignal(signal: NodeJS.Signals): void;\n  /**\n   * Supervise a child process alongside the app, concurrently-style: signals pass\n   * through, and if EITHER the child or the app dies the whole set comes down.\n   * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for\n   * several children; teardown is idempotent.\n   */\n  bindProcess(child: BindableProcess): void;\n}\n\n/** A single interceptor, or several. The `createApp` `interceptor?:` option. */\nexport type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;\n\n/** How long bound children get to exit on `SIGTERM` before the app force-exits. */\nconst TEARDOWN_GRACE_MS = 3000;\n\n/** The signals that trigger teardown when the MAIN process receives them. */\nconst TEARDOWN_SIGNALS = [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const;\n\n/**\n * The mutable machinery behind an {@link InterceptorContext}. Split out so\n * {@link createInterceptorContext} can hand the public context to interceptors\n * while `appkit.createApp` retains the `emitLifecycle` side-channel the bridge drives.\n */\nexport interface InterceptorRuntime {\n  /** The context handed to each interceptor. */\n  readonly context: InterceptorContext;\n  /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */\n  emitLifecycle(event: LifecycleEvent): Promise<void>;\n}\n\n/**\n * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.\n *\n * Teardown is the generalized `superviseExit`: the first child exit or main-process\n * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,\n * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it\n * never itself holds the loop open). The process-signal listeners are installed\n * lazily on the first `bindProcess` so an app that binds nothing is untouched.\n */\nexport function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime {\n  const handlers = new Map<LifecycleEvent, LifecycleHandler[]>();\n  const children = new Set<BindableProcess>();\n  let shuttingDown = false;\n  let signalsBound = false;\n\n  const teardown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();\n  };\n\n  const broadcastSignal = (signal: NodeJS.Signals): void => {\n    for (const child of children) {\n      if (!child.killed) child.kill(signal);\n    }\n    teardown(0);\n  };\n\n  const bindProcessSignals = (): void => {\n    if (signalsBound) return;\n    signalsBound = true;\n    for (const signal of TEARDOWN_SIGNALS) {\n      process.on(signal, () => broadcastSignal(signal));\n    }\n  };\n\n  const bindProcess = (child: BindableProcess): void => {\n    bindProcessSignals();\n    children.add(child);\n    child.once(\"exit\", (code) => {\n      logger.warn(\"bound process exited; tearing down the app\", { code });\n      teardown(typeof code === \"number\" ? code : 1);\n    });\n  };\n\n  const onLifecycle = (event: LifecycleEvent, fn: LifecycleHandler): void => {\n    const list = handlers.get(event);\n    if (list) list.push(fn);\n    else handlers.set(event, [fn]);\n  };\n\n  const emitLifecycle = async (event: LifecycleEvent): Promise<void> => {\n    const list = handlers.get(event);\n    if (!list) return;\n    for (const fn of list) {\n      try {\n        await fn();\n      } catch (error) {\n        // Match AppKit: a failing lifecycle handler is logged, never fatal, and\n        // never blocks its siblings.\n        logger.warn(\"lifecycle handler failed\", { event, error });\n      }\n    }\n  };\n\n  const context: InterceptorContext = {\n    env,\n    onLifecycle,\n    broadcastSignal,\n    bindProcess,\n  };\n\n  return { context, emitLifecycle };\n}\n\n/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */\ninterface LifecycleBridgeConfig extends BasePluginConfig {\n  /** The runtime whose `emitLifecycle` receives the real AppKit events. */\n  runtime?: InterceptorRuntime;\n}\n\n/**\n * Structural shape of the `PluginContext.onLifecycle` we bridge. Mirrors only the\n * one method we touch (like {@link PluginContextLike} in `./plugin`), since\n * AppKit's `PluginContext` is not importable from the package's `exports`.\n */\ninterface LifecycleContextLike {\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n}\n\nfunction hasOnLifecycle(context: unknown): context is LifecycleContextLike {\n  return typeof (context as LifecycleContextLike | undefined)?.onLifecycle === \"function\";\n}\n\n/**\n * The internal plugin `appkit.createApp` injects to make AppKit's lifecycle\n * reachable from interceptor code. On `setup()` it reads its own `this.context`\n * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the\n * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine\n * events. It owns no routes, config surface, or exports.\n */\nexport class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {\n  static manifest = {\n    name: \"dbxToolsLifecycleBridge\",\n    displayName: \"Lifecycle Bridge\",\n    description: \"Relays AppKit lifecycle events to the createApp interceptor context.\",\n    stability: \"beta\",\n    hidden: true,\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"dbxToolsLifecycleBridge\">;\n\n  override async setup(): Promise<void> {\n    const runtime = this.config.runtime;\n    if (!runtime) return;\n    if (!hasOnLifecycle(this.context)) {\n      logger.debug(\"no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert\");\n      return;\n    }\n    const events: LifecycleEvent[] = [\"setup:complete\", \"server:ready\", \"shutdown\"];\n    for (const event of events) {\n      this.context.onLifecycle(event, () => runtime.emitLifecycle(event));\n    }\n  }\n}\n\n/** Factory for the injected {@link LifecycleBridgePlugin}. */\nexport const lifecycleBridge = toPlugin(LifecycleBridgePlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/appkit.ts","../src/config.ts","../src/create-app.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/appkit.ts","../src/config.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/core": "0.6.69",
-    "@dbx-tools/shared-core": "0.6.69",
+    "@dbx-tools/core": "0.6.70",
+    "@dbx-tools/shared-core": "0.6.70",
     "yaml": "^2.9.0",
     "zod": "4.3.6"
   },
@@ -47,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.69",
+  "version": "0.6.70",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/appkit.ts

@@ -1,6 +1,22 @@
 /**
- * Generic AppKit runtime glue: the per-request execution context and the types
- * derived from it. Not plugin-specific - that lives in `./plugin`.
+ * AppKit runtime glue: the auto-configuring `createApp` drop-in, plus the
+ * per-request execution context helpers and types derived from it.
+ *
+ * `createApp` runs dbx-tools auto-configuration, then delegates to AppKit's own
+ * `createApp` with the same arguments and the same typed plugin-export map.
+ * Drop it in as a one-for-one replacement:
+ *
+ * ```ts
+ * import { lakebase, server } from "@databricks/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * await appkit.createApp({ plugins: [server(), lakebase()] });
+ * ```
+ *
+ * Auto-configuration runs BEFORE delegating so plugins see a fully populated
+ * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when
+ * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set
+ * explicitly on the config object.
  *
  * `getExecutionContext()` is AppKit's own accessor for the OBO-scoped workspace
  * client + request metadata; the wrappers here make it safe to call outside a
@@ -11,11 +27,295 @@
  * @module
  */
 
-import { createApp, getExecutionContext, InitializationError } from "@databricks/appkit";
-import { log } from "@dbx-tools/shared-core";
+import {
+  createApp as appkitCreateApp,
+  getExecutionContext,
+  InitializationError,
+} from "@databricks/appkit";
+// AppKit's root barrel re-exports `PluginData` but not `PluginMap`; the package
+// publishes this subpath for exactly that type.
+import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
+import { async, log } from "@dbx-tools/shared-core";
+
+import {
+  createInterceptorContext,
+  type Interceptor,
+  type InterceptorRuntime,
+  lifecycleBridge,
+  type ResolvedAppEnv,
+} from "./interceptor.ts";
+import { applyLakebaseEnv, type LakebaseConnection } from "./lakebase-resolver.ts";
+import { provisionCacheSchema } from "./provision.ts";
 
 const logger = log.logger("appkit");
 
+type AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;
+type AppKitPlugins = NonNullable<AppKitCreateAppConfig["plugins"]>;
+
+/**
+ * What auto-configuration does before AppKit boots.
+ *
+ * - `"provision"`: resolve the Lakebase connection into `process.env`, then
+ *   grant the AppKit cache schema to the connecting role.
+ * - `"env"`: resolve the Lakebase connection into `process.env` only.
+ *
+ * Omit it to get `"provision"` gated on a `lakebase` plugin being registered;
+ * set it explicitly to run regardless of the plugin list, or pass `false` to
+ * skip auto-configuration entirely.
+ *
+ * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants
+ * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when
+ * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /
+ * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the
+ * cache silently falls back to in-memory, and anything it holds (a session
+ * signing key, a one-time code) is lost on restart. `"env"` is the right mode
+ * there: the app SP cannot grant on the cache schema anyway.
+ */
+export type AutoConfigureMode = "env" | "provision";
+
+/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */
+export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<
+  AppKitCreateAppConfig,
+  "plugins" | "onPluginsReady"
+> & {
+  plugins?: T;
+  onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
+  /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
+  autoConfigure?: AutoConfigureMode | false;
+  /**
+   * One or many {@link Interceptor}s handed an {@link InterceptorContext} once
+   * auto-configuration has computed the env. Each receives the resolved env, an
+   * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -
+   * see `./interceptor`. The tunnel is the primary consumer.
+   */
+  interceptor?: Interceptor | Interceptor[];
+};
+
+const LAKEBASE_PLUGIN = "lakebase";
+const DEFAULT_AUTO_CONFIGURE: AutoConfigureMode = "provision";
+
+/**
+ * Upper bound on boot-time auto-configuration. It runs as the service principal
+ * before any plugin is constructed, so it sits outside AppKit's interceptor
+ * chain and inherits no timeout, retry, or telemetry from it. The budget covers
+ * the resolver's own worst case (create a project, then wait for its endpoint)
+ * plus the cache-schema grants.
+ */
+const AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;
+
+function usesPlugin<T extends AppKitPlugins>(
+  config: CreateAppConfig<T> | undefined,
+  name: string,
+): boolean {
+  return Boolean(config?.plugins?.some((entry) => entry.name === name));
+}
+
+/** Plugin names for boot logs (order preserved). */
+function pluginNames(config: CreateAppConfig | undefined): string[] {
+  return (config?.plugins ?? []).map((entry) => entry.name);
+}
+
+/**
+ * Run enabled auto-configuration steps without calling AppKit's `createApp`.
+ *
+ * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set
+ * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`
+ * cancels the resolution; it is combined with an internal boot timeout either
+ * way.
+ *
+ * @example
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
+ * await appkit.autoConfigure({ autoConfigure: "env" });
+ */
+export async function autoConfigure<T extends AppKitPlugins>(
+  config?: CreateAppConfig<T>,
+  signal?: AbortSignal,
+): Promise<LakebaseConnection | undefined> {
+  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;
+  const explicit = config?.autoConfigure !== undefined;
+  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);
+  const plugins = pluginNames(config);
+  logger.debug("autoConfigure: start", {
+    mode,
+    explicit,
+    lakebasePluginPresent,
+    plugins,
+    timeoutMs: AUTO_CONFIGURE_TIMEOUT_MS,
+    callerSignal: Boolean(signal),
+  });
+
+  if (mode === false || !(explicit || lakebasePluginPresent)) {
+    const skippedReason = mode === false ? "disabled" : "no lakebase plugin";
+    logger.debug("autoConfigure: skip", { skippedReason, mode, lakebasePluginPresent, plugins });
+    logger.info("ready", {
+      autoConfigure: mode,
+      lakebasePluginPresent,
+      provisioned: false,
+      skippedReason,
+    });
+    return undefined;
+  }
+
+  const controller = new AbortController();
+  async.tieAbortSignal(controller, signal);
+  async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));
+
+  const provision = mode === "provision";
+  logger.debug("autoConfigure: resolve lakebase", { provision, mode });
+  const resolved = await autoConfigureLakebase(provision, controller.signal);
+  logger.debug("autoConfigure: done", {
+    mode,
+    lakebasePluginPresent,
+    provisioned: provision,
+    ...redactLakebaseConnection(resolved),
+  });
+  logger.info("ready", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });
+  return resolved;
+}
+
+/**
+ * Resolve Lakebase Postgres connection info, write the resolved values to
+ * `process.env`, and return the record. Used by {@link autoConfigure}; call
+ * {@link applyLakebaseEnv} directly when finer control is needed (a different
+ * `autoCreate` policy, or a caller that wants the env without booting AppKit).
+ */
+async function autoConfigureLakebase(
+  provision: boolean,
+  signal: AbortSignal,
+): Promise<LakebaseConnection> {
+  logger.debug("autoConfigureLakebase: applyLakebaseEnv");
+  const { resolved, user } = await applyLakebaseEnv(undefined, signal);
+  logger.debug("autoConfigureLakebase: env applied", {
+    ...redactLakebaseConnection(resolved),
+    user,
+    env: {
+      LAKEBASE_ENDPOINT: process.env.LAKEBASE_ENDPOINT,
+      PGHOST: process.env.PGHOST,
+      PGPORT: process.env.PGPORT,
+      PGDATABASE: process.env.PGDATABASE,
+      PGUSER: process.env.PGUSER,
+      PGSSLMODE: process.env.PGSSLMODE,
+    },
+  });
+  logger.info("env updated", { ...redactLakebaseConnection(resolved), user });
+  if (provision) {
+    logger.debug("autoConfigureLakebase: provisionCacheSchema", { user });
+    await provisionCacheSchema(user, logger);
+    logger.debug("autoConfigureLakebase: provisionCacheSchema done");
+  } else {
+    logger.debug("autoConfigureLakebase: skip provision (mode=env)");
+  }
+  return resolved;
+}
+
+function redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {
+  return {
+    project: resolved.project,
+    branch: resolved.branch,
+    endpoint: resolved.endpoint,
+    database: resolved.database,
+    host: resolved.host,
+    port: resolved.port,
+    sslMode: resolved.sslMode,
+  };
+}
+
+/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */
+function resolvedAppEnv(lakebase: LakebaseConnection | undefined): ResolvedAppEnv {
+  return {
+    ...(lakebase ? { lakebase } : {}),
+    ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),
+  };
+}
+
+/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */
+function interceptorList(interceptor: CreateAppConfig["interceptor"]): Interceptor[] {
+  if (!interceptor) return [];
+  return Array.isArray(interceptor) ? interceptor : [interceptor];
+}
+
+/**
+ * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
+ * plugin-export map, with {@link autoConfigure} run first.
+ *
+ * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
+ * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
+ * AppKit boots - so an interceptor can read the resolved connection, register
+ * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
+ * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
+ * events; it has no exports, so the returned {@link PluginMap} is unchanged.
+ *
+ * @example
+ * import { lakebase, server } from "@databricks/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * const app = await appkit.createApp({ plugins: [server(), lakebase()] });
+ */
+export async function createApp<T extends AppKitPlugins>(
+  config?: CreateAppConfig<T>,
+): Promise<PluginMap<T>> {
+  const plugins = pluginNames(config);
+  const interceptors = interceptorList(config?.interceptor);
+  logger.debug("createApp: start", {
+    plugins,
+    pluginCount: plugins.length,
+    interceptorCount: interceptors.length,
+    autoConfigure: config?.autoConfigure ?? "(default)",
+    hasOnPluginsReady: typeof config?.onPluginsReady === "function",
+  });
+
+  logger.debug("createApp: autoConfigure");
+  const lakebase = await autoConfigure(config);
+  logger.debug("createApp: autoConfigure returned", {
+    lakebase: lakebase ? redactLakebaseConnection(lakebase) : undefined,
+  });
+
+  const appConfig = { ...config };
+  delete appConfig.autoConfigure;
+  delete appConfig.interceptor;
+
+  if (interceptors.length === 0) {
+    logger.debug("createApp: no interceptors; delegating to AppKit createApp", {
+      plugins: pluginNames(appConfig),
+    });
+    const result = await appkitCreateApp<T>(appConfig);
+    logger.debug("createApp: AppKit createApp returned", {
+      exportKeys: Object.keys(result ?? {}),
+    });
+    return result;
+  }
+
+  // Build the context from the computed env, run each interceptor (they register
+  // lifecycle handlers + bind processes), then inject the bridge that relays the
+  // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.
+  const env = resolvedAppEnv(lakebase);
+  logger.debug("createApp: interceptor context", {
+    hasLakebase: Boolean(env.lakebase),
+    databricksHost: env.databricksHost,
+    interceptorCount: interceptors.length,
+  });
+  const runtime: InterceptorRuntime = createInterceptorContext(env);
+  for (let i = 0; i < interceptors.length; i++) {
+    logger.debug("createApp: run interceptor", { index: i, of: interceptors.length });
+    await interceptors[i]!(runtime.context);
+    logger.debug("createApp: interceptor done", { index: i });
+  }
+  // Append the bridge to the plugins tuple. It is hidden and exports nothing, so
+  // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is
+  // only because appending widens the tuple type beyond `T`.
+  appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })] as unknown as T;
+  logger.debug("createApp: lifecycle bridge injected; delegating to AppKit createApp", {
+    plugins: pluginNames(appConfig),
+  });
+  const result = await appkitCreateApp<T>(appConfig);
+  logger.debug("createApp: AppKit createApp returned", {
+    exportKeys: Object.keys(result ?? {}),
+  });
+  return result;
+}
+
 /**
  * The AppKit per-request execution context returned by `getExecutionContext()`
  * - the OBO-scoped workspace client plus the surrounding request metadata.
@@ -69,8 +369,11 @@ export function tryGetExecutionContext(): ExecutionContextLike | undefined {
  * const client = appkit.tryGetExecutionContext()?.client;
  */
 export async function ensureInitialized(): Promise<void> {
-  if (!tryGetExecutionContext()) {
-    logger.debug("initializing a bare AppKit app");
-    await createApp({ plugins: [] });
+  if (tryGetExecutionContext()) {
+    logger.debug("ensureInitialized: already initialized");
+    return;
   }
+  logger.debug("ensureInitialized: booting bare AppKit app");
+  await createApp({ plugins: [], autoConfigure: false });
+  logger.debug("ensureInitialized: done");
 }

package/src/interceptor.ts

@@ -5,17 +5,17 @@
  * unit - concurrently-style, where any death takes the whole set down.
  *
  * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
- * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
- * one AFTER auto-configuration has populated `process.env` but as part of booting
- * the app, so an interceptor sees the resolved connection and can bind processes
- * before or during setup.
+ * `appkit.createApp`'s `interceptor` option ("one or many"). `appkit.createApp`
+ * runs each one AFTER auto-configuration has populated `process.env` but as part
+ * of booting the app, so an interceptor sees the resolved connection and can bind
+ * processes before or during setup.
  *
  * The names here mirror AppKit's own vocabulary rather than inventing parallel
  * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
  * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
  * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
  * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
- * {@link createApp} injects to capture `this.context` and relay its events.
+ * `appkit.createApp` injects to capture `this.context` and relay its events.
  *
  * @module
  */
@@ -49,7 +49,7 @@ export type LifecycleHandler = () => void | Promise<void>;
  * they read COMPUTED values instead of re-reading `process.env` themselves.
  *
  * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran
- * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the
+ * (see `appkit.autoConfigure`), else `undefined`. `databricksHost` is the
  * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the
  * tunnel interceptor both reads and, when it must, sets.
  */
@@ -72,9 +72,9 @@ export type BindableProcess = Pick<ChildProcess, "pid" | "kill" | "killed" | "on
  * The handle passed to each interceptor.
  *
  * @example
- * import { createApp } from "@dbx-tools/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
  *
- * await createApp({
+ * await appkit.createApp({
  *   plugins: [server()],
  *   interceptor: (ctx) => {
  *     const portr = spawnPortr(ctx.env.databricksHost);
@@ -120,7 +120,7 @@ const TEARDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
 /**
  * The mutable machinery behind an {@link InterceptorContext}. Split out so
  * {@link createInterceptorContext} can hand the public context to interceptors
- * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.
+ * while `appkit.createApp` retains the `emitLifecycle` side-channel the bridge drives.
  */
 export interface InterceptorRuntime {
   /** The context handed to each interceptor. */
@@ -227,7 +227,7 @@ function hasOnLifecycle(context: unknown): context is LifecycleContextLike {
 }
 
 /**
- * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * The internal plugin `appkit.createApp` injects to make AppKit's lifecycle
  * reachable from interceptor code. On `setup()` it reads its own `this.context`
  * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
  * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine

package/lib/src/create-app.d.ts

@@ -1,96 +0,0 @@
-/**
- * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to
- * AppKit's own `createApp` with the exact same arguments.
- *
- * Drop it in as a one-for-one replacement for `@databricks/appkit`'s
- * `createApp` - same parameters, same return type, full plugin-export inference
- * preserved:
- *
- * ```ts
- * import { createApp } from "@dbx-tools/appkit";
- * import { lakebase, server } from "@databricks/appkit";
- *
- * await createApp.createApp({ plugins: [server(), lakebase()] });
- * ```
- *
- * Auto-configuration runs BEFORE delegating so plugins see a fully populated
- * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when
- * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set
- * explicitly on the config object.
- *
- * @module
- */
-import { createApp as appkitCreateApp } from "@databricks/appkit";
-import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
-import { type Interceptor } from "./interceptor.ts";
-import { type LakebaseConnection } from "./lakebase-resolver.ts";
-type AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;
-type AppKitPlugins = NonNullable<AppKitCreateAppConfig["plugins"]>;
-/**
- * What auto-configuration does before AppKit boots.
- *
- * - `"provision"`: resolve the Lakebase connection into `process.env`, then
- *   grant the AppKit cache schema to the connecting role.
- * - `"env"`: resolve the Lakebase connection into `process.env` only.
- *
- * Omit it to get `"provision"` gated on a `lakebase` plugin being registered;
- * set it explicitly to run regardless of the plugin list, or pass `false` to
- * skip auto-configuration entirely.
- *
- * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants
- * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when
- * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /
- * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the
- * cache silently falls back to in-memory, and anything it holds (a session
- * signing key, a one-time code) is lost on restart. `"env"` is the right mode
- * there: the app SP cannot grant on the cache schema anyway.
- */
-export type AutoConfigureMode = "env" | "provision";
-/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */
-export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<AppKitCreateAppConfig, "plugins" | "onPluginsReady"> & {
-    plugins?: T;
-    onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
-    /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
-    autoConfigure?: AutoConfigureMode | false;
-    /**
-     * One or many {@link Interceptor}s handed an {@link InterceptorContext} once
-     * auto-configuration has computed the env. Each receives the resolved env, an
-     * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -
-     * see `./interceptor`. The tunnel is the primary consumer.
-     */
-    interceptor?: Interceptor | Interceptor[];
-};
-/**
- * Run enabled auto-configuration steps without calling AppKit's `createApp`.
- *
- * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set
- * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`
- * cancels the resolution; it is combined with an internal boot timeout either
- * way.
- *
- * @example
- * import { createApp } from "@dbx-tools/appkit";
- *
- * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
- * await createApp.autoConfigure({ autoConfigure: "env" });
- */
-export declare function autoConfigure<T extends AppKitPlugins>(config?: CreateAppConfig<T>, signal?: AbortSignal): Promise<LakebaseConnection | undefined>;
-/**
- * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
- * plugin-export map, with {@link autoConfigure} run first.
- *
- * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
- * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
- * AppKit boots - so an interceptor can read the resolved connection, register
- * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
- * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
- * events; it has no exports, so the returned {@link PluginMap} is unchanged.
- *
- * @example
- * import { createApp } from "@dbx-tools/appkit";
- * import { lakebase, server } from "@databricks/appkit";
- *
- * const app = await createApp.createApp({ plugins: [server(), lakebase()] });
- */
-export declare function createApp<T extends AppKitPlugins>(config?: CreateAppConfig<T>): Promise<PluginMap<T>>;
-export {};