fhir-engine 0.1.0

package/dist/cjs/index.d.ts

@@ -0,0 +1,193 @@
+import { DefinitionProvider } from 'fhir-definition';
+import { DefinitionRegistry } from 'fhir-definition';
+import { FhirPersistence } from 'fhir-persistence';
+import { FhirRuntimeInstance } from 'fhir-runtime';
+import type { FhirSystemReady } from 'fhir-persistence';
+import type { SearchParameterRegistry } from 'fhir-persistence';
+import { StorageAdapter } from 'fhir-persistence';
+import type { StructureDefinitionRegistry } from 'fhir-persistence';
+
+/**
+ * Create a StorageAdapter from the database configuration.
+ *
+ * Supported adapters:
+ * - `sqlite`      → BetterSqlite3Adapter (native, Node.js / Electron)
+ * - `sqlite-wasm` → SQLiteAdapter (sql.js WASM, browser / cross-platform)
+ * - `postgres`    → not yet available (PostgresAdapter not exported from fhir-persistence)
+ */
+export declare function createAdapter(config: DatabaseConfig, logger: Logger): StorageAdapter;
+
+/**
+ * Default console-based logger.
+ */
+export declare function createConsoleLogger(): Logger;
+
+/**
+ * Create and bootstrap a fully initialized FHIR engine.
+ *
+ * This is the single entry point for all FHIR applications.
+ * It assembles fhir-definition, fhir-runtime, and fhir-persistence
+ * into a running system from a single configuration object.
+ *
+ * @example
+ * ```ts
+ * const engine = await createFhirEngine({
+ *   database: { type: 'sqlite', path: ':memory:' },
+ *   packages: { path: './fhir-packages' },
+ * });
+ *
+ * const patient = await engine.persistence.createResource('Patient', {
+ *   resourceType: 'Patient',
+ *   name: [{ family: 'Smith', given: ['John'] }],
+ * });
+ *
+ * await engine.stop();
+ * ```
+ */
+export declare function createFhirEngine(config?: FhirEngineConfig): Promise<FhirEngine>;
+
+export declare type DatabaseConfig = SqliteDatabaseConfig | SqliteWasmDatabaseConfig | PostgresDatabaseConfig;
+
+/**
+ * Type-safe config helper for `fhir.config.ts` / `fhir.config.js`.
+ *
+ * @example
+ * ```ts
+ * // fhir.config.ts
+ * import { defineConfig } from 'fhir-engine';
+ *
+ * export default defineConfig({
+ *   database: { type: 'sqlite', path: './fhir.db' },
+ *   packages: { path: './fhir-packages' },
+ * });
+ * ```
+ */
+export declare function defineConfig(config: FhirEngineConfig): FhirEngineConfig;
+
+export { DefinitionProvider }
+
+export { DefinitionRegistry }
+
+export declare interface EngineContext {
+    /** The resolved engine configuration. */
+    readonly config: FhirEngineConfig;
+    /** DefinitionRegistry from fhir-definition (always available). */
+    readonly definitions: DefinitionRegistry;
+    /** FhirRuntimeInstance from fhir-runtime (always available). */
+    readonly runtime: FhirRuntimeInstance;
+    /** StorageAdapter from fhir-persistence (always available). */
+    readonly adapter: StorageAdapter;
+    /** FhirPersistence facade — undefined during init(), available from start() onward. */
+    readonly persistence: FhirPersistence | undefined;
+    /** Logger instance. */
+    readonly logger: Logger;
+}
+
+export declare interface FhirEngine {
+    /** The loaded DefinitionRegistry from fhir-definition. */
+    readonly definitions: DefinitionRegistry;
+    /** The FhirRuntimeInstance from fhir-runtime. */
+    readonly runtime: FhirRuntimeInstance;
+    /** The StorageAdapter from fhir-persistence. */
+    readonly adapter: StorageAdapter;
+    /** The FhirPersistence facade (CRUD + Search + Indexing). */
+    readonly persistence: FhirPersistence;
+    /** StructureDefinition registry (populated from IG). */
+    readonly sdRegistry: StructureDefinitionRegistry;
+    /** SearchParameter registry (populated from IG). */
+    readonly spRegistry: SearchParameterRegistry;
+    /** IG initialization result. */
+    readonly igResult: FhirSystemReady['igResult'];
+    /** Resource types with database tables. */
+    readonly resourceTypes: string[];
+    /** Logger in use. */
+    readonly logger: Logger;
+    /** Shared context (same object plugins receive). */
+    readonly context: EngineContext;
+    /** Gracefully shut down the engine (closes adapter). */
+    stop(): Promise<void>;
+}
+
+export declare interface FhirEngineConfig {
+    /** Database configuration. */
+    database: DatabaseConfig;
+    /** FHIR package loading configuration. */
+    packages: PackagesConfig;
+    /** IG migration label (default: package.json name or 'fhir-engine.default'). */
+    packageName?: string;
+    /** IG migration version (default: package.json version or '1.0.0'). */
+    packageVersion?: string;
+    /** Logger instance (default: console-based logger). */
+    logger?: Logger;
+    /** Plugins to register (executed in registration order). */
+    plugins?: FhirEnginePlugin[];
+}
+
+export declare interface FhirEnginePlugin {
+    /** Unique plugin name (used in logs and error messages). */
+    name: string;
+    /** Called before FhirSystem.initialize(). ctx.persistence is undefined. */
+    init?(ctx: EngineContext): Promise<void>;
+    /** Called after FhirSystem.initialize(). ctx.persistence is available. */
+    start?(ctx: EngineContext): Promise<void>;
+    /** Called after all plugins have started. System is fully operational. */
+    ready?(ctx: EngineContext): Promise<void>;
+    /** Called on shutdown, in reverse registration order. */
+    stop?(ctx: EngineContext): Promise<void>;
+}
+
+export { FhirPersistence }
+
+export { FhirRuntimeInstance }
+
+/**
+ * Load engine configuration from a file.
+ *
+ * If `configPath` is provided, loads that exact file.
+ * Otherwise, searches the current working directory for config files
+ * in this order: `fhir.config.ts` → `fhir.config.js` → `fhir.config.mjs` → `fhir.config.json`.
+ *
+ * Environment variable overrides are applied on top of the loaded config.
+ *
+ * @param configPath - Explicit path to a config file (optional).
+ * @returns The resolved `FhirEngineConfig`.
+ */
+export declare function loadFhirConfig(configPath?: string): Promise<FhirEngineConfig>;
+
+export declare interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+
+export declare interface PackagesConfig {
+    /** Local directory containing FHIR packages (NPM tarballs or extracted). */
+    path: string;
+}
+
+export declare interface PostgresDatabaseConfig {
+    type: 'postgres';
+    /** PostgreSQL connection string. */
+    url: string;
+}
+
+export declare interface SqliteDatabaseConfig {
+    type: 'sqlite';
+    /** File path or ':memory:' for in-memory database. */
+    path: string;
+    /** Enable WAL journal mode (default: true). */
+    wal?: boolean;
+    /** Busy timeout in milliseconds (default: 5000). */
+    busyTimeout?: number;
+}
+
+export declare interface SqliteWasmDatabaseConfig {
+    type: 'sqlite-wasm';
+    /** File path or ':memory:'. */
+    path: string;
+}
+
+export { StorageAdapter }
+
+export { }

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "commonjs",
+  "main": "index.cjs",
+  "types": "index.d.ts"
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,193 @@
+import { DefinitionProvider } from 'fhir-definition';
+import { DefinitionRegistry } from 'fhir-definition';
+import { FhirPersistence } from 'fhir-persistence';
+import { FhirRuntimeInstance } from 'fhir-runtime';
+import type { FhirSystemReady } from 'fhir-persistence';
+import type { SearchParameterRegistry } from 'fhir-persistence';
+import { StorageAdapter } from 'fhir-persistence';
+import type { StructureDefinitionRegistry } from 'fhir-persistence';
+
+/**
+ * Create a StorageAdapter from the database configuration.
+ *
+ * Supported adapters:
+ * - `sqlite`      → BetterSqlite3Adapter (native, Node.js / Electron)
+ * - `sqlite-wasm` → SQLiteAdapter (sql.js WASM, browser / cross-platform)
+ * - `postgres`    → not yet available (PostgresAdapter not exported from fhir-persistence)
+ */
+export declare function createAdapter(config: DatabaseConfig, logger: Logger): StorageAdapter;
+
+/**
+ * Default console-based logger.
+ */
+export declare function createConsoleLogger(): Logger;
+
+/**
+ * Create and bootstrap a fully initialized FHIR engine.
+ *
+ * This is the single entry point for all FHIR applications.
+ * It assembles fhir-definition, fhir-runtime, and fhir-persistence
+ * into a running system from a single configuration object.
+ *
+ * @example
+ * ```ts
+ * const engine = await createFhirEngine({
+ *   database: { type: 'sqlite', path: ':memory:' },
+ *   packages: { path: './fhir-packages' },
+ * });
+ *
+ * const patient = await engine.persistence.createResource('Patient', {
+ *   resourceType: 'Patient',
+ *   name: [{ family: 'Smith', given: ['John'] }],
+ * });
+ *
+ * await engine.stop();
+ * ```
+ */
+export declare function createFhirEngine(config?: FhirEngineConfig): Promise<FhirEngine>;
+
+export declare type DatabaseConfig = SqliteDatabaseConfig | SqliteWasmDatabaseConfig | PostgresDatabaseConfig;
+
+/**
+ * Type-safe config helper for `fhir.config.ts` / `fhir.config.js`.
+ *
+ * @example
+ * ```ts
+ * // fhir.config.ts
+ * import { defineConfig } from 'fhir-engine';
+ *
+ * export default defineConfig({
+ *   database: { type: 'sqlite', path: './fhir.db' },
+ *   packages: { path: './fhir-packages' },
+ * });
+ * ```
+ */
+export declare function defineConfig(config: FhirEngineConfig): FhirEngineConfig;
+
+export { DefinitionProvider }
+
+export { DefinitionRegistry }
+
+export declare interface EngineContext {
+    /** The resolved engine configuration. */
+    readonly config: FhirEngineConfig;
+    /** DefinitionRegistry from fhir-definition (always available). */
+    readonly definitions: DefinitionRegistry;
+    /** FhirRuntimeInstance from fhir-runtime (always available). */
+    readonly runtime: FhirRuntimeInstance;
+    /** StorageAdapter from fhir-persistence (always available). */
+    readonly adapter: StorageAdapter;
+    /** FhirPersistence facade — undefined during init(), available from start() onward. */
+    readonly persistence: FhirPersistence | undefined;
+    /** Logger instance. */
+    readonly logger: Logger;
+}
+
+export declare interface FhirEngine {
+    /** The loaded DefinitionRegistry from fhir-definition. */
+    readonly definitions: DefinitionRegistry;
+    /** The FhirRuntimeInstance from fhir-runtime. */
+    readonly runtime: FhirRuntimeInstance;
+    /** The StorageAdapter from fhir-persistence. */
+    readonly adapter: StorageAdapter;
+    /** The FhirPersistence facade (CRUD + Search + Indexing). */
+    readonly persistence: FhirPersistence;
+    /** StructureDefinition registry (populated from IG). */
+    readonly sdRegistry: StructureDefinitionRegistry;
+    /** SearchParameter registry (populated from IG). */
+    readonly spRegistry: SearchParameterRegistry;
+    /** IG initialization result. */
+    readonly igResult: FhirSystemReady['igResult'];
+    /** Resource types with database tables. */
+    readonly resourceTypes: string[];
+    /** Logger in use. */
+    readonly logger: Logger;
+    /** Shared context (same object plugins receive). */
+    readonly context: EngineContext;
+    /** Gracefully shut down the engine (closes adapter). */
+    stop(): Promise<void>;
+}
+
+export declare interface FhirEngineConfig {
+    /** Database configuration. */
+    database: DatabaseConfig;
+    /** FHIR package loading configuration. */
+    packages: PackagesConfig;
+    /** IG migration label (default: package.json name or 'fhir-engine.default'). */
+    packageName?: string;
+    /** IG migration version (default: package.json version or '1.0.0'). */
+    packageVersion?: string;
+    /** Logger instance (default: console-based logger). */
+    logger?: Logger;
+    /** Plugins to register (executed in registration order). */
+    plugins?: FhirEnginePlugin[];
+}
+
+export declare interface FhirEnginePlugin {
+    /** Unique plugin name (used in logs and error messages). */
+    name: string;
+    /** Called before FhirSystem.initialize(). ctx.persistence is undefined. */
+    init?(ctx: EngineContext): Promise<void>;
+    /** Called after FhirSystem.initialize(). ctx.persistence is available. */
+    start?(ctx: EngineContext): Promise<void>;
+    /** Called after all plugins have started. System is fully operational. */
+    ready?(ctx: EngineContext): Promise<void>;
+    /** Called on shutdown, in reverse registration order. */
+    stop?(ctx: EngineContext): Promise<void>;
+}
+
+export { FhirPersistence }
+
+export { FhirRuntimeInstance }
+
+/**
+ * Load engine configuration from a file.
+ *
+ * If `configPath` is provided, loads that exact file.
+ * Otherwise, searches the current working directory for config files
+ * in this order: `fhir.config.ts` → `fhir.config.js` → `fhir.config.mjs` → `fhir.config.json`.
+ *
+ * Environment variable overrides are applied on top of the loaded config.
+ *
+ * @param configPath - Explicit path to a config file (optional).
+ * @returns The resolved `FhirEngineConfig`.
+ */
+export declare function loadFhirConfig(configPath?: string): Promise<FhirEngineConfig>;
+
+export declare interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+
+export declare interface PackagesConfig {
+    /** Local directory containing FHIR packages (NPM tarballs or extracted). */
+    path: string;
+}
+
+export declare interface PostgresDatabaseConfig {
+    type: 'postgres';
+    /** PostgreSQL connection string. */
+    url: string;
+}
+
+export declare interface SqliteDatabaseConfig {
+    type: 'sqlite';
+    /** File path or ':memory:' for in-memory database. */
+    path: string;
+    /** Enable WAL journal mode (default: true). */
+    wal?: boolean;
+    /** Busy timeout in milliseconds (default: 5000). */
+    busyTimeout?: number;
+}
+
+export declare interface SqliteWasmDatabaseConfig {
+    type: 'sqlite-wasm';
+    /** File path or ':memory:'. */
+    path: string;
+}
+
+export { StorageAdapter }
+
+export { }

package/dist/esm/index.mjs

@@ -0,0 +1,288 @@
+// src/engine.ts
+import { loadDefinitionPackages } from "fhir-definition";
+import { createRuntime, extractSearchValues, extractAllSearchValues, extractReferences } from "fhir-runtime";
+import { FhirDefinitionBridge, FhirRuntimeProvider, FhirSystem } from "fhir-persistence";
+
+// src/adapter-factory.ts
+import { BetterSqlite3Adapter, SQLiteAdapter } from "fhir-persistence";
+function createAdapter(config, logger) {
+  switch (config.type) {
+    case "sqlite": {
+      logger.info(`Creating BetterSqlite3Adapter (path: ${config.path})`);
+      return new BetterSqlite3Adapter({
+        path: config.path,
+        wal: config.wal ?? true,
+        busyTimeout: config.busyTimeout ?? 5e3
+      });
+    }
+    case "sqlite-wasm": {
+      logger.info(`Creating SQLiteAdapter (WASM, path: ${config.path})`);
+      return new SQLiteAdapter(config.path);
+    }
+    case "postgres": {
+      throw new Error(
+        'fhir-engine: PostgreSQL adapter is not yet available. PostgresAdapter is not exported from fhir-persistence v0.1.0. Use database.type = "sqlite" for now.'
+      );
+    }
+    default: {
+      const _exhaustive = config;
+      throw new Error(`fhir-engine: unknown database type: ${_exhaustive.type}`);
+    }
+  }
+}
+
+// src/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, extname } from "node:path";
+import { pathToFileURL } from "node:url";
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_FILENAMES = [
+  "fhir.config.ts",
+  "fhir.config.js",
+  "fhir.config.mjs",
+  "fhir.config.json"
+];
+async function loadFhirConfig(configPath) {
+  let resolvedPath;
+  if (configPath) {
+    resolvedPath = resolve(configPath);
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`fhir-engine: config file not found: ${resolvedPath}`);
+    }
+  } else {
+    const cwd = process.cwd();
+    const found = CONFIG_FILENAMES.map((name) => resolve(cwd, name)).find((p) => existsSync(p));
+    if (!found) {
+      throw new Error(
+        `fhir-engine: no config file found in ${cwd}. Expected one of: ${CONFIG_FILENAMES.join(", ")}`
+      );
+    }
+    resolvedPath = found;
+  }
+  const config = await loadConfigFile(resolvedPath);
+  return applyEnvOverrides(config);
+}
+async function loadConfigFile(filePath) {
+  const ext = extname(filePath);
+  if (ext === ".json") {
+    return loadJsonConfig(filePath);
+  }
+  if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+    return loadModuleConfig(filePath);
+  }
+  throw new Error(`fhir-engine: unsupported config file extension: ${ext}`);
+}
+function loadJsonConfig(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `fhir-engine: failed to parse config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+async function loadModuleConfig(filePath) {
+  try {
+    const fileUrl = pathToFileURL(filePath).href;
+    const mod = await import(fileUrl);
+    const config = mod.default ?? mod;
+    if (!config || typeof config !== "object") {
+      throw new Error("config file must export a FhirEngineConfig object as default export");
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("must export")) {
+      throw err;
+    }
+    throw new Error(
+      `fhir-engine: failed to load config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+var VALID_DB_TYPES = ["sqlite", "sqlite-wasm", "postgres"];
+function applyEnvOverrides(config) {
+  const result = structuredClone(config);
+  const dbType = process.env.FHIR_DATABASE_TYPE;
+  const dbUrl = process.env.FHIR_DATABASE_URL;
+  const pkgPath = process.env.FHIR_PACKAGES_PATH;
+  if (dbType) {
+    if (!VALID_DB_TYPES.includes(dbType)) {
+      throw new Error(
+        `fhir-engine: FHIR_DATABASE_TYPE must be one of: ${VALID_DB_TYPES.join(", ")}. Got: "${dbType}"`
+      );
+    }
+    const validType = dbType;
+    if (validType === "postgres") {
+      result.database = { type: "postgres", url: result.database.url ?? "" };
+    } else if (validType === "sqlite-wasm") {
+      result.database = { type: "sqlite-wasm", path: result.database.path ?? "" };
+    } else {
+      result.database = { type: "sqlite", path: result.database.path ?? "" };
+    }
+  }
+  if (dbUrl) {
+    const type = result.database?.type;
+    if (type === "postgres") {
+      result.database = { ...result.database, type: "postgres", url: dbUrl };
+    } else if (type === "sqlite-wasm") {
+      result.database = { ...result.database, type: "sqlite-wasm", path: dbUrl };
+    } else {
+      result.database = { ...result.database, type: "sqlite", path: dbUrl };
+    }
+  }
+  if (pkgPath) {
+    result.packages = { ...result.packages, path: pkgPath };
+  }
+  return result;
+}
+
+// src/logger.ts
+function createConsoleLogger() {
+  return {
+    debug: (message, ...args) => console.debug(`[fhir-engine] ${message}`, ...args),
+    info: (message, ...args) => console.info(`[fhir-engine] ${message}`, ...args),
+    warn: (message, ...args) => console.warn(`[fhir-engine] ${message}`, ...args),
+    error: (message, ...args) => console.error(`[fhir-engine] ${message}`, ...args)
+  };
+}
+
+// src/engine.ts
+function resolveDialect(type) {
+  switch (type) {
+    case "sqlite":
+    case "sqlite-wasm":
+      return "sqlite";
+    case "postgres":
+      return "postgres";
+  }
+}
+function validateConfig(config) {
+  if (!config.database) {
+    throw new Error("fhir-engine: config.database is required");
+  }
+  if (!config.database.type) {
+    throw new Error("fhir-engine: config.database.type is required (sqlite | sqlite-wasm | postgres)");
+  }
+  if (!config.packages) {
+    throw new Error("fhir-engine: config.packages is required");
+  }
+  if (!config.packages.path) {
+    throw new Error("fhir-engine: config.packages.path is required");
+  }
+}
+async function runPluginHook(plugins, hook, ctx) {
+  for (const plugin of plugins) {
+    const fn = plugin[hook];
+    if (fn) {
+      try {
+        await fn.call(plugin, ctx);
+      } catch (err) {
+        throw new Error(
+          `fhir-engine: plugin "${plugin.name}" failed during ${hook}: ${err instanceof Error ? err.message : String(err)}`,
+          { cause: err }
+        );
+      }
+    }
+  }
+}
+async function createFhirEngine(config) {
+  if (!config) {
+    config = await loadFhirConfig();
+  }
+  validateConfig(config);
+  const logger = config.logger ?? createConsoleLogger();
+  const plugins = config.plugins ?? [];
+  logger.info("Initializing fhir-engine...");
+  logger.info(`Loading FHIR packages from: ${config.packages.path}`);
+  const { registry, result } = loadDefinitionPackages(config.packages.path);
+  logger.info(
+    `Loaded ${result.packages.length} package(s): ${result.packages.map((p) => `${p.name}@${p.version}`).join(", ")}`
+  );
+  logger.info("Creating fhir-runtime instance...");
+  const runtime = await createRuntime({ definitions: registry, preloadCore: false });
+  const definitionBridge = new FhirDefinitionBridge(registry);
+  const runtimeProvider = new FhirRuntimeProvider({
+    extractSearchValues,
+    extractAllSearchValues,
+    extractReferences
+  });
+  const adapter = createAdapter(config.database, logger);
+  const ctx = {
+    config,
+    definitions: registry,
+    runtime,
+    adapter,
+    persistence: void 0,
+    logger
+  };
+  if (plugins.length > 0) {
+    logger.info(`Running init for ${plugins.length} plugin(s): ${plugins.map((p) => p.name).join(", ")}`);
+    await runPluginHook(plugins, "init", ctx);
+  }
+  const dialect = resolveDialect(config.database.type);
+  const system = new FhirSystem(adapter, {
+    dialect,
+    runtimeProvider,
+    packageName: config.packageName ?? "fhir-engine.default",
+    packageVersion: config.packageVersion ?? "1.0.0"
+  });
+  logger.info("Initializing persistence system (schema + migration)...");
+  const { persistence, sdRegistry, spRegistry, igResult, resourceTypes } = await system.initialize(definitionBridge);
+  logger.info(`Persistence ready \u2014 IG action: ${igResult.action}, ${resourceTypes.length} resource type(s)`);
+  ctx.persistence = persistence;
+  if (plugins.length > 0) {
+    logger.info(`Running start for ${plugins.length} plugin(s)...`);
+    await runPluginHook(plugins, "start", ctx);
+  }
+  if (plugins.length > 0) {
+    logger.info(`Running ready for ${plugins.length} plugin(s)...`);
+    await runPluginHook(plugins, "ready", ctx);
+  }
+  let stopped = false;
+  const engine = {
+    definitions: registry,
+    runtime,
+    adapter,
+    persistence,
+    sdRegistry,
+    spRegistry,
+    igResult,
+    resourceTypes,
+    logger,
+    context: ctx,
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      logger.info("Stopping fhir-engine...");
+      for (let i = plugins.length - 1; i >= 0; i--) {
+        const plugin = plugins[i];
+        if (plugin.stop) {
+          try {
+            await plugin.stop.call(plugin, ctx);
+          } catch (err) {
+            logger.error(
+              `Plugin "${plugin.name}" failed during stop: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+      await adapter.close();
+      logger.info("fhir-engine stopped.");
+    }
+  };
+  logger.info("fhir-engine ready.");
+  return engine;
+}
+export {
+  createAdapter,
+  createConsoleLogger,
+  createFhirEngine,
+  defineConfig,
+  loadFhirConfig
+};
+//# sourceMappingURL=index.mjs.map