@gobing-ai/ts-infra 0.3.3 → 0.3.5

package/README.md

@@ -419,6 +419,119 @@ bun add @opentelemetry/sdk-trace-node @opentelemetry/sdk-metrics \
         @opentelemetry/exporter-metrics-otlp-http
 ```
 
+
+### Application Bootstrap
+
+The application bootstrap API provides a deterministic lifecycle for wiring
+infrastructure services. Two layers:
+
+1. **Portable DI bootstrap** (`@gobing-ai/ts-infra/application`) — orchestrates
+   injected dependencies. Never opens files, creates DB connections, or wires
+   runtime-specific exporters.
+2. **Node/Bun convenience** (`@gobing-ai/ts-infra/application-node`) — composes
+   the portable bootstrap with runtime-specific adapters: YAML config loading,
+   file log sink, Bun SQLite DB creation, Node OTel export, Node scheduler.
+
+#### Portable DI bootstrap
+
+```ts
+import { runApplication } from '@gobing-ai/ts-infra/application';
+
+const app = await runApplication({
+    config: {
+        logging: { level: 'info', console: true },
+        telemetry: { enabled: true, serviceName: 'my-api' },
+    },
+    appConfig: { port: 3000 },
+    async start(app) {
+        app.logger.info('started', { port: app.appConfig.port });
+    },
+});
+
+// Graceful shutdown — idempotent
+await app.stop();
+```
+
+The portable `runApplication` accepts pre-built services via `services` and
+never reads files. All services are created with defaults; feature flags
+control what gets initialized. Startup order is deterministic:
+
+1. Resolve bootstrap config + app config
+2. Initialize logger
+3. Initialize telemetry
+4. Create lifecycle bus + EventBus
+5. Register injected DB adapter
+6. Initialize scheduler + register entries
+7. Call user `start(app)` callback
+8. Start scheduler if `autoStart`
+
+Shutdown runs in reverse order. `stop()` is idempotent — safe to call from
+multiple signal handlers.
+
+#### Node/Bun convenience bootstrap
+
+```ts
+import { runNodeApplication } from '@gobing-ai/ts-infra/application-node';
+
+await runNodeApplication({
+    configLoader: {
+        configFile: 'config/app.yaml',
+        bootstrapSection: 'bootstrap',
+        appSection: 'billing',
+        appConfig: {
+            // Structural safeParse adapter — works with Zod or any validator
+            safeParse(raw) {
+                return billingSchema.safeParse(raw);
+            },
+        },
+    },
+    async start(app) {
+        app.logger.info('billing app started', {
+            settlementWindowMinutes: app.appConfig.settlementWindowMinutes,
+        });
+    },
+});
+```
+
+Example YAML config file:
+
+```yaml
+app:
+  name: billing-api
+  env: production
+
+bootstrap:
+  logging:
+    level: info
+    console: true
+    filePath: ./logs/app.jsonl
+  telemetry:
+    enabled: true
+    serviceName: billing-api
+    endpoint: http://otel-collector:4318
+  database:
+    enabled: true
+    driver: bun-sqlite
+    url: ./data/app.db
+
+billing:
+  settlementWindowMinutes: 15
+  riskLimit: 100000
+```
+
+Config validators accept four shapes:
+- `{ safeParse(raw) → { success, data?, errors? } }` — Zod-compatible
+- `(raw) => TAppConfig` — bare function
+- `{ validate(raw) => TAppConfig }` — method form
+- `{ parse(raw) => TAppConfig }` — method form
+
+Validation errors include the config file path and section name for diagnostics.
+
+**What is intentionally NOT in the main barrel:** `runApplication` and
+`runNodeApplication` live behind explicit subpaths so the main
+`@gobing-ai/ts-infra` import stays portable and adapter-light. A future ADR
+may decide whether type-only re-exports are acceptable.
+
 ## Usage
 
 ### Install

package/dist/application/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Portable `runApplication` — DI bootstrap over existing ts-infra primitives.
+ *
+ * Orchestrates logger, telemetry, event bus, (optional) DB adapter, and
+ * (optional) scheduler into a deterministic startup/shutdown lifecycle.
+ * The portable subpath never opens files, creates DB connections, or wires
+ * runtime-specific exporters — those are injected or handled by the
+ * Node/Bun convenience subpath.
+ *
+ * @module application
+ */
+import type { EventMap } from '../event-bus/types';
+import type { InfraEvents } from '../events';
+import type { ApplicationBootstrapOptions, ApplicationRuntime } from './types';
+/**
+ * Portable application bootstrap.
+ *
+ * Orchestrates logger, telemetry, events, optional DB, and optional scheduler.
+ * Accepts injected dependencies; never opens files, reads config from disk,
+ * or wires runtime-specific exporters.
+ *
+ * Startup order (deterministic, per R5):
+ * 1. Resolve bootstrap config + app config
+ * 2. Initialize logger
+ * 3. Initialize telemetry
+ * 4. Create lifecycle bus + application EventBus
+ * 5. Register DB adapter (injected only)
+ * 6. Initialize scheduler + register entries
+ * 7. Call user `start(app)` callback
+ * 8. Start scheduler if `autoStart`
+ *
+ * Shutdown order (reverse, per R5):
+ * 1. User `stop(app, reason)` callback
+ * 2. Stop scheduler
+ * 3. Close DB adapter
+ * 4. Shut down telemetry
+ *
+ * If any startup step fails, already-started services are cleaned up in reverse
+ * order before rethrowing. `stop()` is idempotent.
+ *
+ * @example
+ * ```ts
+ * import { runApplication } from '@gobing-ai/ts-infra/application';
+ *
+ * const app = await runApplication({
+ *     config: { logging: { level: 'debug' } },
+ *     async start(app) {
+ *         app.logger.info('started');
+ *     },
+ * });
+ * ```
+ */
+export declare function runApplication<TAppConfig = unknown, TEvents extends EventMap = InfraEvents>(options: ApplicationBootstrapOptions<TAppConfig, TEvents>): Promise<ApplicationRuntime<TAppConfig, TEvents>>;
+export type { BusLifecycleEvents, EventMap } from '../event-bus/types';
+export type { InfraEvents } from '../events';
+export type { ApplicationBootstrapConfig, ApplicationBootstrapOptions, ApplicationConfigLoader, ApplicationConfigValidator, ApplicationRuntime, ApplicationServices, ApplicationStopReason, ConfigValidationResult, DbAdapterLike, EventsOptions, LoggingOptions, SchedulerOptions, TelemetryOptions, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/application/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/application/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAsB,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAK7C,OAAO,KAAK,EAER,2BAA2B,EAC3B,kBAAkB,EAGrB,MAAM,SAAS,CAAC;AAuDjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,cAAc,CAAC,UAAU,GAAG,OAAO,EAAE,OAAO,SAAS,QAAQ,GAAG,WAAW,EAC7F,OAAO,EAAE,2BAA2B,CAAC,UAAU,EAAE,OAAO,CAAC,GAC1D,OAAO,CAAC,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAyIlD;AAED,YAAY,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACvE,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,YAAY,EACR,0BAA0B,EAC1B,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GACnB,MAAM,SAAS,CAAC"}

package/dist/application/index.js

@@ -0,0 +1,210 @@
+/**
+ * Portable `runApplication` — DI bootstrap over existing ts-infra primitives.
+ *
+ * Orchestrates logger, telemetry, event bus, (optional) DB adapter, and
+ * (optional) scheduler into a deterministic startup/shutdown lifecycle.
+ * The portable subpath never opens files, creates DB connections, or wires
+ * runtime-specific exporters — those are injected or handled by the
+ * Node/Bun convenience subpath.
+ *
+ * @module application
+ */
+import { attachDefaultObservers, createLifecycleBus } from '../event-bus/default-observers.js';
+import { EventBus } from '../event-bus/event-bus.js';
+import { getLogger, initializeLogger } from '../logger.js';
+import { initScheduler, setSchedulerAdapter } from '../scheduler/factory.js';
+import { initTelemetry, shutdownTelemetry } from '../telemetry/sdk.js';
+// ── Shutdown (deterministic reverse order per R5) ─────────────────────────
+async function performShutdown(state, reason) {
+    if (state.stopped)
+        return;
+    state.stopped = true;
+    const app = state.app;
+    if (!app)
+        return;
+    // 1. User stop callback
+    if (state.userStop) {
+        await state.userStop(app, reason);
+    }
+    // 2. Stop scheduler
+    if (state.schedulerStarted && state.schedulerAdapter) {
+        await state.schedulerAdapter.stop().catch(() => { });
+        state.schedulerStarted = false;
+    }
+    // 3. Close DB adapter
+    if (app.db) {
+        try {
+            app.db.close();
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    // 4. Shutdown telemetry
+    if (state.telemetryInitialized) {
+        await shutdownTelemetry();
+        state.telemetryInitialized = false;
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────
+/**
+ * Portable application bootstrap.
+ *
+ * Orchestrates logger, telemetry, events, optional DB, and optional scheduler.
+ * Accepts injected dependencies; never opens files, reads config from disk,
+ * or wires runtime-specific exporters.
+ *
+ * Startup order (deterministic, per R5):
+ * 1. Resolve bootstrap config + app config
+ * 2. Initialize logger
+ * 3. Initialize telemetry
+ * 4. Create lifecycle bus + application EventBus
+ * 5. Register DB adapter (injected only)
+ * 6. Initialize scheduler + register entries
+ * 7. Call user `start(app)` callback
+ * 8. Start scheduler if `autoStart`
+ *
+ * Shutdown order (reverse, per R5):
+ * 1. User `stop(app, reason)` callback
+ * 2. Stop scheduler
+ * 3. Close DB adapter
+ * 4. Shut down telemetry
+ *
+ * If any startup step fails, already-started services are cleaned up in reverse
+ * order before rethrowing. `stop()` is idempotent.
+ *
+ * @example
+ * ```ts
+ * import { runApplication } from '@gobing-ai/ts-infra/application';
+ *
+ * const app = await runApplication({
+ *     config: { logging: { level: 'debug' } },
+ *     async start(app) {
+ *         app.logger.info('started');
+ *     },
+ * });
+ * ```
+ */
+export async function runApplication(options) {
+    // ── Resolve config ─────────────────────────────────────────────────
+    const logOpts = options.config?.logging;
+    const loggingConfig = {
+        enabled: logOpts?.enabled ?? true,
+        level: logOpts?.level ?? 'info',
+        console: logOpts?.console ?? true,
+        json: logOpts?.json ?? true,
+        ...(logOpts?.fileSink ? { fileSink: logOpts.fileSink } : {}),
+    };
+    const telOpts = options.config?.telemetry;
+    const telemetryConfig = {
+        enabled: telOpts?.enabled ?? true,
+        serviceName: telOpts?.serviceName ?? 'ts-libs',
+        environment: telOpts?.environment ?? 'development',
+        dbStatementDebug: telOpts?.dbStatementDebug ?? false,
+    };
+    const schedOpts = options.config?.scheduler;
+    const schedulerConfig = {
+        enabled: schedOpts?.enabled ?? false,
+        autoStart: schedOpts?.autoStart ?? true,
+    };
+    const eventsEnabled = options.config?.events?.enabled ?? true;
+    const eventsLifecycle = options.config?.events?.lifecycle ?? true;
+    const eventsDefaultObservers = options.config?.events?.defaultObservers ?? true;
+    const state = {
+        app: undefined,
+        userStop: options.stop,
+        schedulerAdapter: undefined,
+        schedulerStarted: false,
+        loggerInitialized: false,
+        telemetryInitialized: false,
+        stopped: false,
+    };
+    try {
+        // ── 1. Initialize logger ────────────────────────────────────────
+        let logger;
+        if (options.services?.logger) {
+            logger = options.services.logger;
+        }
+        else if (loggingConfig.enabled) {
+            await initializeLogger({
+                level: loggingConfig.level,
+                console: loggingConfig.console,
+                fileSink: loggingConfig.fileSink,
+                json: loggingConfig.json,
+            });
+            logger = getLogger('bootstrap');
+        }
+        else {
+            logger = getLogger('bootstrap');
+        }
+        // ── 2. Initialize telemetry ────────────────────────────────────
+        if (telemetryConfig.enabled) {
+            initTelemetry({
+                enabled: telemetryConfig.enabled,
+                serviceName: telemetryConfig.serviceName,
+                environment: telemetryConfig.environment,
+                dbStatementDebug: telemetryConfig.dbStatementDebug,
+            });
+            state.telemetryInitialized = true;
+        }
+        // ── 3. Create lifecycle bus + EventBus ─────────────────────────
+        const lifecycleBus = eventsEnabled && eventsLifecycle ? (options.services?.lifecycleBus ?? createLifecycleBus()) : undefined;
+        if (lifecycleBus && eventsDefaultObservers) {
+            attachDefaultObservers(lifecycleBus);
+        }
+        const events = options.services?.events
+            ? options.services.events
+            : new EventBus({ lifecycleBus: lifecycleBus });
+        // ── 4. Database (injected only) ────────────────────────────────
+        const db = options.services?.db;
+        // ── 5. Scheduler ───────────────────────────────────────────────
+        let scheduler;
+        if (schedulerConfig.enabled) {
+            const adapter = options.services?.scheduler ?? schedOpts?.adapter;
+            if (adapter) {
+                setSchedulerAdapter(adapter);
+            }
+            scheduler = initScheduler(schedOpts?.entries);
+            state.schedulerAdapter = scheduler;
+        }
+        // ── Build resolved config ──────────────────────────────────────
+        const resolvedConfig = {
+            logging: loggingConfig,
+            events: { enabled: eventsEnabled, lifecycle: eventsLifecycle, defaultObservers: eventsDefaultObservers },
+            telemetry: telemetryConfig,
+            scheduler: schedulerConfig,
+        };
+        // ── Build runtime handle ───────────────────────────────────────
+        const app = {
+            config: resolvedConfig,
+            appConfig: options.appConfig,
+            logger,
+            events,
+            lifecycleBus,
+            db,
+            scheduler,
+            stop: (reason) => performShutdown(state, reason ?? 'manual'),
+        };
+        state.app = app;
+        // ── 6. User start callback ─────────────────────────────────────
+        await options.start(app);
+        // ── 7. Start scheduler ─────────────────────────────────────────
+        if (schedulerConfig.enabled && schedulerConfig.autoStart && scheduler) {
+            await scheduler.start();
+            state.schedulerStarted = true;
+        }
+        return app;
+    }
+    catch (error) {
+        // Reverse-order cleanup of services this bootstrap owns.
+        // Scheduler: start() is the last async op before return; if it throws,
+        // schedulerStarted is still false, so there is nothing started to stop.
+        // DB: injected by the caller (portable bootstrap never creates one), so
+        // its lifecycle is caller-owned and not closed here.
+        // Telemetry: owned by the bootstrap — shut it down if it was initialized.
+        if (state.telemetryInitialized) {
+            await shutdownTelemetry();
+        }
+        throw error;
+    }
+}

package/dist/application/types.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Portable application bootstrap types.
+ *
+ * These types define the DI contract for `runApplication` — a thin orchestration
+ * layer over existing ts-infra primitives. The portable subpath does not import
+ * any runtime-specific adapters; everything injectable comes through the options.
+ *
+ * @module application/types
+ */
+import type { EventBus } from '../event-bus/event-bus';
+import type { BusLifecycleEvents, EventMap } from '../event-bus/types';
+import type { InfraEvents } from '../events';
+import type { Logger, LogLevel } from '../logger';
+import type { SchedulerAdapter } from '../scheduler/types';
+/** Logging feature flags. */
+export interface LoggingOptions {
+    /** Enable logging. Default `true`. */
+    enabled?: boolean;
+    /** Minimum log level. Default `'info'`. */
+    level?: LogLevel;
+    /** Enable console output. Default `true`. */
+    console?: boolean;
+    /**
+     * File sink writer. The portable bootstrap never opens files — the caller
+     * (or Node convenience subpath) provides a writer.
+     */
+    fileSink?: (line: string) => void;
+    /** JSON Lines format. Default `true`. */
+    json?: boolean;
+}
+/** Event bus feature flags. */
+export interface EventsOptions<TEvents extends EventMap = InfraEvents> {
+    /** Enable event bus. Default `true`. */
+    enabled?: boolean;
+    /** Create and attach a lifecycle bus. Default `true`. */
+    lifecycle?: boolean;
+    /** Attach default observers (log + telemetry). Default `true`. */
+    defaultObservers?: boolean;
+    /** Pre-built event bus (skips creation when provided). */
+    bus?: EventBus<TEvents>;
+}
+/** Telemetry feature flags. */
+export interface TelemetryOptions {
+    /** Enable telemetry instrumentation. Default `true`. */
+    enabled?: boolean;
+    /** Service name for spans. Default `'ts-libs'`. */
+    serviceName?: string;
+    /** Deployment environment. Default `'development'`. */
+    environment?: string;
+    /** Capture sanitized SQL in DB spans. Default `false`. */
+    dbStatementDebug?: boolean;
+}
+/** Scheduler feature flags. */
+export interface SchedulerOptions {
+    /** Enable scheduler. Default `false`. */
+    enabled?: boolean;
+    /** Injected adapter (skips noop default when provided). */
+    adapter?: SchedulerAdapter;
+    /** Cron entries to register: `[cron, action][]`. */
+    entries?: Array<[string, () => Promise<void>]>;
+    /** Start scheduler immediately after registration. Default `true` when enabled. */
+    autoStart?: boolean;
+}
+/**
+ * Fully-resolved bootstrap config (all optionals filled with defaults).
+ * Constructed internally by `resolveBootstrapConfig`.
+ */
+export interface ApplicationBootstrapConfig {
+    readonly logging: Readonly<Required<Pick<LoggingOptions, 'enabled' | 'level' | 'console' | 'json'>> & {
+        fileSink?: (line: string) => void;
+    }>;
+    readonly events: {
+        enabled: boolean;
+        lifecycle: boolean;
+        defaultObservers: boolean;
+    };
+    readonly telemetry: {
+        enabled: boolean;
+        serviceName: string;
+        environment: string;
+        dbStatementDebug: boolean;
+    };
+    readonly scheduler: {
+        enabled: boolean;
+        autoStart: boolean;
+    };
+}
+/** Services that may be pre-injected instead of created by the bootstrap. */
+export interface ApplicationServices<TEvents extends EventMap = InfraEvents> {
+    logger?: Logger;
+    events?: EventBus<TEvents>;
+    lifecycleBus?: EventBus<BusLifecycleEvents>;
+    db?: DbAdapterLike;
+    scheduler?: SchedulerAdapter;
+}
+/**
+ * Minimal DB adapter shape the bootstrap cares about: `close()` for lifecycle.
+ * This avoids importing `ts-db` (an optional peer) from the portable subpath.
+ */
+export interface DbAdapterLike {
+    close(): void;
+}
+/** Why the application is stopping. */
+export type ApplicationStopReason = 'manual' | 'signal' | 'error' | 'shutdown';
+/**
+ * Runtime handle returned by `runApplication`.
+ *
+ * Exposes all resolved services and a `stop()` method for graceful shutdown.
+ */
+export interface ApplicationRuntime<TAppConfig = unknown, TEvents extends EventMap = InfraEvents> {
+    /** Fully-resolved bootstrap config (feature flags + defaults). */
+    readonly config: ApplicationBootstrapConfig;
+    /** Caller-provided application config, or `undefined`. */
+    readonly appConfig: TAppConfig;
+    /** Structured logger. */
+    readonly logger: Logger;
+    /** Application event bus. */
+    readonly events: EventBus<TEvents>;
+    /** Lifecycle bus (when enabled). */
+    readonly lifecycleBus?: EventBus<BusLifecycleEvents>;
+    /** DB adapter (when enabled and injected). */
+    readonly db?: DbAdapterLike;
+    /** Scheduler adapter (when enabled). */
+    readonly scheduler?: SchedulerAdapter;
+    /** Graceful shutdown. Idempotent — safe to call multiple times. */
+    stop(reason?: ApplicationStopReason): Promise<void>;
+}
+/**
+ * Options for the portable `runApplication`.
+ */
+export interface ApplicationBootstrapOptions<TAppConfig = unknown, TEvents extends EventMap = InfraEvents> {
+    /** Bootstrap feature flags (partial — defaults applied internally). */
+    readonly config?: {
+        logging?: LoggingOptions;
+        events?: EventsOptions<TEvents>;
+        telemetry?: TelemetryOptions;
+        scheduler?: SchedulerOptions;
+    };
+    /** Already-resolved application config. Portable — no file reads. */
+    readonly appConfig?: TAppConfig;
+    /** Pre-built services to inject instead of creating defaults. */
+    readonly services?: Partial<ApplicationServices<TEvents>>;
+    /** User callback: application logic. Called after all services are ready. */
+    readonly start: (app: ApplicationRuntime<TAppConfig, TEvents>) => Promise<void> | void;
+    /** User callback: cleanup before services shut down. */
+    readonly stop?: (app: ApplicationRuntime<TAppConfig, TEvents>, reason: ApplicationStopReason) => Promise<void> | void;
+}
+/**
+ * Validation result matching the structural `safeParse` pattern.
+ * Avoids hard-coupling to a specific validation library.
+ */
+export interface ConfigValidationResult<T> {
+    readonly success: boolean;
+    readonly data?: T;
+    readonly errors?: ReadonlyArray<{
+        path: string;
+        message: string;
+    }>;
+}
+/**
+ * Config validator: structural `safeParse`-compatible adapter.
+ * Accepts any validation library that produces `{ success, data?, errors? }`.
+ */
+export type ApplicationConfigValidator<TAppConfig> = {
+    safeParse(raw: unknown): ConfigValidationResult<TAppConfig>;
+} | ((raw: unknown) => TAppConfig) | {
+    validate(raw: unknown): TAppConfig;
+} | {
+    parse(raw: unknown): TAppConfig;
+};
+/**
+ * Config loader options for the Node/Bun convenience subpath.
+ */
+export interface ApplicationConfigLoader<TAppConfig = unknown> {
+    /** Path to the YAML config file. */
+    readonly configFile?: string;
+    /** YAML section name for bootstrap config. Default `'bootstrap'`. */
+    readonly bootstrapSection?: string;
+    /** YAML section name for app-specific config. Default: remaining object. */
+    readonly appSection?: string;
+    /** Caller-provided validator for the app config section. */
+    readonly appConfig?: ApplicationConfigValidator<TAppConfig>;
+    /** Override values merged after loading. */
+    readonly overrides?: Record<string, unknown>;
+}
+export type { BusLifecycleEvents, EventMap } from '../event-bus/types';
+export type { InfraEvents } from '../events';
+//# sourceMappingURL=types.d.ts.map

package/dist/application/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/application/types.ts"],"names":[],"mappings":"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"}

package/dist/application/types.js

@@ -0,0 +1,9 @@
+/**
+ * Portable application bootstrap types.
+ *
+ * These types define the DI contract for `runApplication` — a thin orchestration
+ * layer over existing ts-infra primitives. The portable subpath does not import
+ * any runtime-specific adapters; everything injectable comes through the options.
+ *
+ * @module application/types
+ */

package/dist/application-node.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Node/Bun convenience bootstrap for `@gobing-ai/ts-infra`.
+ *
+ * Composes the portable `runApplication` with runtime-specific wiring:
+ * - YAML config loading via `@gobing-ai/ts-runtime`
+ * - Application-specific config validation with caller-provided validator
+ * - File log sink via `node:fs`
+ * - Bun SQLite DB adapter creation from config
+ * - Optional Node OTel exporter initialization
+ * - Optional Node scheduler adapter
+ *
+ * This subpath may import runtime-specific adapters. The portable bootstrap
+ * subpath (`@gobing-ai/ts-infra/application`) must not.
+ *
+ * @module application-node
+ */
+import type { ApplicationBootstrapOptions, ApplicationConfigLoader, ApplicationRuntime, ApplicationStopReason, EventMap, InfraEvents } from './application/types';
+/** Error thrown when application config validation fails. Includes file path and section name. */
+export declare class ConfigValidationError extends Error {
+    constructor(message: string);
+}
+/** Options for the Node/Bun convenience {@link runNodeApplication}. */
+export interface NodeApplicationOptions<TAppConfig = unknown, TEvents extends EventMap = InfraEvents> {
+    /** YAML config loading options. When omitted, uses defaults. */
+    readonly configLoader?: ApplicationConfigLoader<TAppConfig>;
+    /** Inline bootstrap config (overrides YAML-loaded config). */
+    readonly config?: ApplicationBootstrapOptions<TAppConfig, TEvents>['config'];
+    /** Pre-built services to inject. */
+    readonly services?: ApplicationBootstrapOptions<TAppConfig, TEvents>['services'];
+    /** User callback: application logic. */
+    readonly start: (app: ApplicationRuntime<TAppConfig, TEvents>) => Promise<void> | void;
+    /** User callback: cleanup before services shut down. */
+    readonly stop?: (app: ApplicationRuntime<TAppConfig, TEvents>, reason: ApplicationStopReason) => Promise<void> | void;
+}
+/**
+ * Node/Bun convenience application bootstrap.
+ *
+ * Extends the portable `runApplication` with:
+ * - YAML config file loading with section splitting
+ * - Application-specific config validation
+ * - File log sink creation from `logging.filePath`
+ * - Bun SQLite DB adapter creation when `database.enabled` + `database.driver`
+ * - Optional Node OTel telemetry exporter
+ * - Optional Node scheduler adapter
+ *
+ * @example
+ * ```ts
+ * import { runNodeApplication } from '@gobing-ai/ts-infra/application-node';
+ *
+ * await runNodeApplication({
+ *     configLoader: {
+ *         configFile: 'config/app.yaml',
+ *         bootstrapSection: 'bootstrap',
+ *         appSection: 'billing',
+ *         appConfig: {
+ *             safeParse(raw) {
+ *                 return billingSchema.safeParse(raw);
+ *             },
+ *         },
+ *     },
+ *     async start(app) {
+ *         app.logger.info('started');
+ *     },
+ * });
+ * ```
+ */
+export declare function runNodeApplication<TAppConfig = unknown, TEvents extends EventMap = InfraEvents>(options: NodeApplicationOptions<TAppConfig, TEvents>): Promise<ApplicationRuntime<TAppConfig, TEvents>>;
+//# sourceMappingURL=application-node.d.ts.map

package/dist/application-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-node.d.ts","sourceRoot":"","sources":["../src/application-node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,KAAK,EACR,2BAA2B,EAC3B,uBAAuB,EAEvB,kBAAkB,EAClB,qBAAqB,EAGrB,QAAQ,EACR,WAAW,EAId,MAAM,qBAAqB,CAAC;AAM7B,kGAAkG;AAClG,qBAAa,qBAAsB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI9B;AAgHD,uEAAuE;AACvE,MAAM,WAAW,sBAAsB,CAAC,UAAU,GAAG,OAAO,EAAE,OAAO,SAAS,QAAQ,GAAG,WAAW;IAChG,gEAAgE;IAChE,QAAQ,CAAC,YAAY,CAAC,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC5D,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,2BAA2B,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC7E,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,2BAA2B,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC;IACjF,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvF,wDAAwD;IACxD,QAAQ,CAAC,IAAI,CAAC,EAAE,CACZ,GAAG,EAAE,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,EAC5C,MAAM,EAAE,qBAAqB,KAC5B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC7B;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,GAAG,OAAO,EAAE,OAAO,SAAS,QAAQ,GAAG,WAAW,EACjG,OAAO,EAAE,sBAAsB,CAAC,UAAU,EAAE,OAAO,CAAC,GACrD,OAAO,CAAC,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAkHlD"}