fhir-persistence 0.6.0 → 0.7.0

package/dist/esm/index.mjs

@@ -8786,16 +8786,726 @@ var FhirRuntimeProvider = class {
 function createFhirRuntimeProvider(options) {
   return new FhirRuntimeProvider(options);
 }
+
+// src/conformance/ig-resource-map-repo.ts
+var TABLE = "ig_resource_map";
+var CREATE_TABLE_DDL = `
+CREATE TABLE IF NOT EXISTS "${TABLE}" (
+  "ig_id"           TEXT NOT NULL,
+  "resource_type"   TEXT NOT NULL,
+  "resource_id"     TEXT NOT NULL,
+  "resource_url"    TEXT,
+  "resource_name"   TEXT,
+  "base_type"       TEXT,
+  PRIMARY KEY ("ig_id", "resource_type", "resource_id")
+);
+`;
+var CREATE_INDEX_IG = `CREATE INDEX IF NOT EXISTS idx_ig_resource_map_ig ON "${TABLE}"("ig_id")`;
+var CREATE_INDEX_TYPE = `CREATE INDEX IF NOT EXISTS idx_ig_resource_map_type ON "${TABLE}"("ig_id", "resource_type")`;
+var IGResourceMapRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(CREATE_TABLE_DDL);
+    await this.adapter.execute(CREATE_INDEX_IG);
+    await this.adapter.execute(CREATE_INDEX_TYPE);
+  }
+  /** Batch insert resource map entries for an IG. */
+  async batchInsert(igId, entries) {
+    await this.ensureTable();
+    let count = 0;
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE}" ("ig_id", "resource_type", "resource_id", "resource_url", "resource_name", "base_type") VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT ("ig_id", "resource_type", "resource_id") DO UPDATE SET "resource_url" = EXCLUDED."resource_url", "resource_name" = EXCLUDED."resource_name", "base_type" = EXCLUDED."base_type"` : `INSERT OR REPLACE INTO "${TABLE}" ("ig_id", "resource_type", "resource_id", "resource_url", "resource_name", "base_type") VALUES (?, ?, ?, ?, ?, ?)`;
+    for (const e of entries) {
+      await this.adapter.execute(sql, [
+        igId,
+        e.resourceType,
+        e.resourceId,
+        e.resourceUrl ?? null,
+        e.resourceName ?? null,
+        e.baseType ?? null
+      ]);
+      count++;
+    }
+    return count;
+  }
+  /** Get grouped IG index. */
+  async getIGIndex(igId) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "ig_id", "resource_type", "resource_id", "resource_url", "resource_name", "base_type" FROM "${TABLE}" WHERE "ig_id" = ? ORDER BY "resource_type", "resource_id"`,
+      [igId]
+    );
+    const index = {
+      profiles: [],
+      extensions: [],
+      valueSets: [],
+      codeSystems: [],
+      searchParameters: []
+    };
+    for (const r of rows) {
+      const entry = {
+        igId: r.ig_id,
+        resourceType: r.resource_type,
+        resourceId: r.resource_id,
+        resourceUrl: r.resource_url ?? void 0,
+        resourceName: r.resource_name ?? void 0,
+        baseType: r.base_type ?? void 0
+      };
+      switch (r.resource_type) {
+        case "StructureDefinition":
+          if (r.base_type === "Extension") {
+            index.extensions.push(entry);
+          } else {
+            index.profiles.push(entry);
+          }
+          break;
+        case "ValueSet":
+          index.valueSets.push(entry);
+          break;
+        case "CodeSystem":
+          index.codeSystems.push(entry);
+          break;
+        case "SearchParameter":
+          index.searchParameters.push(entry);
+          break;
+        default:
+          break;
+      }
+    }
+    return index;
+  }
+  /** Get resources of a specific type within an IG. */
+  async getByType(igId, resourceType) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "ig_id", "resource_type", "resource_id", "resource_url", "resource_name", "base_type" FROM "${TABLE}" WHERE "ig_id" = ? AND "resource_type" = ? ORDER BY "resource_id"`,
+      [igId, resourceType]
+    );
+    return rows.map((r) => ({
+      igId: r.ig_id,
+      resourceType: r.resource_type,
+      resourceId: r.resource_id,
+      resourceUrl: r.resource_url ?? void 0,
+      resourceName: r.resource_name ?? void 0,
+      baseType: r.base_type ?? void 0
+    }));
+  }
+  /** Remove all resource mappings for an IG. */
+  async removeIG(igId) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE}" WHERE "ig_id" = ?`, [igId]);
+  }
+};
+
+// src/conformance/sd-index-repo.ts
+var TABLE2 = "structure_definition_index";
+var CREATE_TABLE_DDL2 = `
+CREATE TABLE IF NOT EXISTS "${TABLE2}" (
+  "id"               TEXT PRIMARY KEY,
+  "url"              TEXT,
+  "version"          TEXT,
+  "type"             TEXT,
+  "kind"             TEXT,
+  "base_definition"  TEXT,
+  "derivation"       TEXT,
+  "snapshot_hash"    TEXT
+);
+`;
+var CREATE_INDEX_TYPE2 = `CREATE INDEX IF NOT EXISTS idx_sdi_type ON "${TABLE2}"("type")`;
+var CREATE_INDEX_KIND = `CREATE INDEX IF NOT EXISTS idx_sdi_kind ON "${TABLE2}"("kind")`;
+var CREATE_INDEX_BASE = `CREATE INDEX IF NOT EXISTS idx_sdi_base ON "${TABLE2}"("base_definition")`;
+var SDIndexRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(CREATE_TABLE_DDL2);
+    await this.adapter.execute(CREATE_INDEX_TYPE2);
+    await this.adapter.execute(CREATE_INDEX_KIND);
+    await this.adapter.execute(CREATE_INDEX_BASE);
+  }
+  async upsert(entry) {
+    await this.ensureTable();
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE2}" ("id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash") VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT ("id") DO UPDATE SET "url" = EXCLUDED."url", "version" = EXCLUDED."version", "type" = EXCLUDED."type", "kind" = EXCLUDED."kind", "base_definition" = EXCLUDED."base_definition", "derivation" = EXCLUDED."derivation", "snapshot_hash" = EXCLUDED."snapshot_hash"` : `INSERT OR REPLACE INTO "${TABLE2}" ("id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash") VALUES (?, ?, ?, ?, ?, ?, ?, ?)`;
+    await this.adapter.execute(sql, [
+      entry.id,
+      entry.url ?? null,
+      entry.version ?? null,
+      entry.type ?? null,
+      entry.kind ?? null,
+      entry.baseDefinition ?? null,
+      entry.derivation ?? null,
+      entry.snapshotHash ?? null
+    ]);
+  }
+  async batchUpsert(entries) {
+    let count = 0;
+    for (const entry of entries) {
+      await this.upsert(entry);
+      count++;
+    }
+    return count;
+  }
+  async getById(id) {
+    await this.ensureTable();
+    const row = await this.adapter.queryOne(
+      `SELECT "id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash" FROM "${TABLE2}" WHERE "id" = ?`,
+      [id]
+    );
+    return row ? this.mapRow(row) : void 0;
+  }
+  async getByUrl(url) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash" FROM "${TABLE2}" WHERE "url" = ? ORDER BY "version"`,
+      [url]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  async getByType(type) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash" FROM "${TABLE2}" WHERE "type" = ? ORDER BY "id"`,
+      [type]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  async getByBaseDefinition(baseUrl) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "url", "version", "type", "kind", "base_definition", "derivation", "snapshot_hash" FROM "${TABLE2}" WHERE "base_definition" = ? ORDER BY "id"`,
+      [baseUrl]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  async remove(id) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE2}" WHERE "id" = ?`, [id]);
+  }
+  mapRow(r) {
+    return {
+      id: r.id,
+      url: r.url ?? void 0,
+      version: r.version ?? void 0,
+      type: r.type ?? void 0,
+      kind: r.kind ?? void 0,
+      baseDefinition: r.base_definition ?? void 0,
+      derivation: r.derivation ?? void 0,
+      snapshotHash: r.snapshot_hash ?? void 0
+    };
+  }
+};
+
+// src/conformance/element-index-repo.ts
+var TABLE3 = "structure_element_index";
+function createTableDDL(dialect) {
+  if (dialect === "postgres") {
+    return `
+CREATE TABLE IF NOT EXISTS "${TABLE3}" (
+  "id"                TEXT PRIMARY KEY,
+  "structure_id"      TEXT NOT NULL,
+  "path"              TEXT NOT NULL,
+  "min"               INTEGER,
+  "max"               TEXT,
+  "type_codes"        JSONB,
+  "is_slice"          BOOLEAN DEFAULT FALSE,
+  "slice_name"        TEXT,
+  "is_extension"      BOOLEAN DEFAULT FALSE,
+  "binding_value_set" TEXT,
+  "must_support"      BOOLEAN DEFAULT FALSE
+);
+`;
+  }
+  return `
+CREATE TABLE IF NOT EXISTS "${TABLE3}" (
+  "id"                TEXT PRIMARY KEY,
+  "structure_id"      TEXT NOT NULL,
+  "path"              TEXT NOT NULL,
+  "min"               INTEGER,
+  "max"               TEXT,
+  "type_codes"        TEXT,
+  "is_slice"          INTEGER DEFAULT 0,
+  "slice_name"        TEXT,
+  "is_extension"      INTEGER DEFAULT 0,
+  "binding_value_set" TEXT,
+  "must_support"      INTEGER DEFAULT 0
+);
+`;
+}
+var CREATE_INDEX_STRUCTURE = `CREATE INDEX IF NOT EXISTS idx_sei_structure ON "${TABLE3}"("structure_id")`;
+var CREATE_INDEX_PATH = `CREATE INDEX IF NOT EXISTS idx_sei_path ON "${TABLE3}"("path")`;
+var CREATE_INDEX_SLICE = `CREATE INDEX IF NOT EXISTS idx_sei_slice ON "${TABLE3}"("structure_id", "is_slice")`;
+var ElementIndexRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(createTableDDL(this.dialect));
+    await this.adapter.execute(CREATE_INDEX_STRUCTURE);
+    await this.adapter.execute(CREATE_INDEX_PATH);
+    await this.adapter.execute(CREATE_INDEX_SLICE);
+  }
+  /** Batch insert element index entries for a StructureDefinition. */
+  async batchInsert(structureId, elements) {
+    await this.ensureTable();
+    let count = 0;
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE3}" ("id", "structure_id", "path", "min", "max", "type_codes", "is_slice", "slice_name", "is_extension", "binding_value_set", "must_support") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT ("id") DO UPDATE SET "path" = EXCLUDED."path", "min" = EXCLUDED."min", "max" = EXCLUDED."max", "type_codes" = EXCLUDED."type_codes", "is_slice" = EXCLUDED."is_slice", "slice_name" = EXCLUDED."slice_name", "is_extension" = EXCLUDED."is_extension", "binding_value_set" = EXCLUDED."binding_value_set", "must_support" = EXCLUDED."must_support"` : `INSERT OR REPLACE INTO "${TABLE3}" ("id", "structure_id", "path", "min", "max", "type_codes", "is_slice", "slice_name", "is_extension", "binding_value_set", "must_support") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+    for (const e of elements) {
+      const typeCodes = e.typeCodes ? this.dialect === "postgres" ? JSON.stringify(e.typeCodes) : JSON.stringify(e.typeCodes) : null;
+      const isSlice = this.dialect === "postgres" ? e.isSlice ?? false : e.isSlice ? 1 : 0;
+      const isExtension = this.dialect === "postgres" ? e.isExtension ?? false : e.isExtension ? 1 : 0;
+      const mustSupport = this.dialect === "postgres" ? e.mustSupport ?? false : e.mustSupport ? 1 : 0;
+      await this.adapter.execute(sql, [
+        e.id,
+        structureId,
+        e.path,
+        e.min ?? null,
+        e.max ?? null,
+        typeCodes,
+        isSlice,
+        e.sliceName ?? null,
+        isExtension,
+        e.bindingValueSet ?? null,
+        mustSupport
+      ]);
+      count++;
+    }
+    return count;
+  }
+  /** Get all elements for a StructureDefinition. */
+  async getByStructureId(structureId) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "structure_id", "path", "min", "max", "type_codes", "is_slice", "slice_name", "is_extension", "binding_value_set", "must_support" FROM "${TABLE3}" WHERE "structure_id" = ? ORDER BY "id"`,
+      [structureId]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  /** Search elements by path pattern (LIKE). */
+  async searchByPath(pathPattern) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "structure_id", "path", "min", "max", "type_codes", "is_slice", "slice_name", "is_extension", "binding_value_set", "must_support" FROM "${TABLE3}" WHERE "path" LIKE ? ORDER BY "structure_id", "path"`,
+      [pathPattern]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  /** Remove all element indexes for a StructureDefinition. */
+  async removeByStructureId(structureId) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE3}" WHERE "structure_id" = ?`, [structureId]);
+  }
+  mapRow(r) {
+    const typeCodes = r.type_codes ? typeof r.type_codes === "string" ? JSON.parse(r.type_codes) : r.type_codes : void 0;
+    return {
+      id: r.id,
+      structureId: r.structure_id,
+      path: r.path,
+      min: r.min != null ? Number(r.min) : void 0,
+      max: r.max ?? void 0,
+      typeCodes,
+      isSlice: Boolean(r.is_slice),
+      sliceName: r.slice_name ?? void 0,
+      isExtension: Boolean(r.is_extension),
+      bindingValueSet: r.binding_value_set ?? void 0,
+      mustSupport: Boolean(r.must_support)
+    };
+  }
+};
+
+// src/conformance/expansion-cache-repo.ts
+var TABLE4 = "value_set_expansion";
+function createTableDDL2(dialect) {
+  const ts = dialect === "postgres" ? "TIMESTAMPTZ DEFAULT NOW()" : "TEXT DEFAULT (datetime('now'))";
+  const jsonType = dialect === "postgres" ? "JSONB NOT NULL" : "TEXT NOT NULL";
+  return `
+CREATE TABLE IF NOT EXISTS "${TABLE4}" (
+  "valueset_url"    TEXT NOT NULL,
+  "version"         TEXT NOT NULL DEFAULT '',
+  "expanded_at"     ${ts},
+  "code_count"      INTEGER,
+  "expansion_json"  ${jsonType},
+  PRIMARY KEY ("valueset_url", "version")
+);
+`;
+}
+var ExpansionCacheRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(createTableDDL2(this.dialect));
+  }
+  /** Write or update an expansion cache entry. */
+  async upsert(url, version, expansionJson, codeCount) {
+    await this.ensureTable();
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE4}" ("valueset_url", "version", "expansion_json", "code_count") VALUES (?, ?, ?, ?) ON CONFLICT ("valueset_url", "version") DO UPDATE SET "expansion_json" = EXCLUDED."expansion_json", "code_count" = EXCLUDED."code_count", "expanded_at" = NOW()` : `INSERT OR REPLACE INTO "${TABLE4}" ("valueset_url", "version", "expansion_json", "code_count") VALUES (?, ?, ?, ?)`;
+    await this.adapter.execute(sql, [url, version, expansionJson, codeCount]);
+  }
+  /** Get a cached expansion by URL and version. */
+  async get(url, version) {
+    await this.ensureTable();
+    const row = await this.adapter.queryOne(
+      `SELECT "valueset_url", "version", "expanded_at", "code_count", "expansion_json" FROM "${TABLE4}" WHERE "valueset_url" = ? AND "version" = ?`,
+      [url, version]
+    );
+    if (!row) return void 0;
+    return {
+      valuesetUrl: row.valueset_url,
+      version: row.version,
+      expandedAt: row.expanded_at,
+      codeCount: row.code_count,
+      expansionJson: row.expansion_json
+    };
+  }
+  /** Invalidate a specific expansion cache entry. */
+  async invalidate(url, version) {
+    await this.ensureTable();
+    await this.adapter.execute(
+      `DELETE FROM "${TABLE4}" WHERE "valueset_url" = ? AND "version" = ?`,
+      [url, version]
+    );
+  }
+  /** Clear all expansion caches. */
+  async clear() {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE4}"`);
+  }
+};
+
+// src/conformance/concept-hierarchy-repo.ts
+var TABLE5 = "code_system_concept";
+var CREATE_TABLE_DDL3 = `
+CREATE TABLE IF NOT EXISTS "${TABLE5}" (
+  "id"                  TEXT PRIMARY KEY,
+  "code_system_url"     TEXT NOT NULL,
+  "code_system_version" TEXT,
+  "code"                TEXT NOT NULL,
+  "display"             TEXT,
+  "parent_code"         TEXT,
+  "level"               INTEGER DEFAULT 0
+);
+`;
+var CREATE_INDEX_URL = `CREATE INDEX IF NOT EXISTS idx_csc_url ON "${TABLE5}"("code_system_url")`;
+var CREATE_INDEX_CODE = `CREATE INDEX IF NOT EXISTS idx_csc_code ON "${TABLE5}"("code_system_url", "code")`;
+var CREATE_INDEX_PARENT = `CREATE INDEX IF NOT EXISTS idx_csc_parent ON "${TABLE5}"("code_system_url", "parent_code")`;
+var ConceptHierarchyRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(CREATE_TABLE_DDL3);
+    await this.adapter.execute(CREATE_INDEX_URL);
+    await this.adapter.execute(CREATE_INDEX_CODE);
+    await this.adapter.execute(CREATE_INDEX_PARENT);
+  }
+  /** Batch insert hierarchical concept entries. */
+  async batchInsert(entries) {
+    await this.ensureTable();
+    let count = 0;
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE5}" ("id", "code_system_url", "code_system_version", "code", "display", "parent_code", "level") VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT ("id") DO UPDATE SET "display" = EXCLUDED."display", "parent_code" = EXCLUDED."parent_code", "level" = EXCLUDED."level"` : `INSERT OR REPLACE INTO "${TABLE5}" ("id", "code_system_url", "code_system_version", "code", "display", "parent_code", "level") VALUES (?, ?, ?, ?, ?, ?, ?)`;
+    for (const e of entries) {
+      await this.adapter.execute(sql, [
+        e.id,
+        e.codeSystemUrl,
+        e.codeSystemVersion ?? null,
+        e.code,
+        e.display ?? null,
+        e.parentCode ?? null,
+        e.level
+      ]);
+      count++;
+    }
+    return count;
+  }
+  /** Get all concepts for a CodeSystem (tree order by level). */
+  async getTree(codeSystemUrl) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "code_system_url", "code_system_version", "code", "display", "parent_code", "level" FROM "${TABLE5}" WHERE "code_system_url" = ? ORDER BY "level", "code"`,
+      [codeSystemUrl]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  /** Get direct children of a concept. */
+  async getChildren(codeSystemUrl, parentCode) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "code_system_url", "code_system_version", "code", "display", "parent_code", "level" FROM "${TABLE5}" WHERE "code_system_url" = ? AND "parent_code" = ? ORDER BY "code"`,
+      [codeSystemUrl, parentCode]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  /** Lookup a single concept by code. */
+  async lookup(codeSystemUrl, code) {
+    await this.ensureTable();
+    const row = await this.adapter.queryOne(
+      `SELECT "id", "code_system_url", "code_system_version", "code", "display", "parent_code", "level" FROM "${TABLE5}" WHERE "code_system_url" = ? AND "code" = ?`,
+      [codeSystemUrl, code]
+    );
+    return row ? this.mapRow(row) : void 0;
+  }
+  /** Remove all concepts for a CodeSystem. */
+  async removeByCodeSystem(codeSystemUrl) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE5}" WHERE "code_system_url" = ?`, [codeSystemUrl]);
+  }
+  mapRow(r) {
+    return {
+      id: r.id,
+      codeSystemUrl: r.code_system_url,
+      codeSystemVersion: r.code_system_version ?? void 0,
+      code: r.code,
+      display: r.display ?? void 0,
+      parentCode: r.parent_code ?? void 0,
+      level: Number(r.level)
+    };
+  }
+};
+
+// src/conformance/search-param-index-repo.ts
+var TABLE6 = "search_parameter_index";
+function createTableDDL3(dialect) {
+  const baseType = dialect === "postgres" ? "JSONB" : "TEXT";
+  return `
+CREATE TABLE IF NOT EXISTS "${TABLE6}" (
+  "id"          TEXT PRIMARY KEY,
+  "ig_id"       TEXT NOT NULL,
+  "url"         TEXT,
+  "code"        TEXT NOT NULL,
+  "type"        TEXT NOT NULL,
+  "base"        ${baseType},
+  "expression"  TEXT
+);
+`;
+}
+var CREATE_INDEX_IG2 = `CREATE INDEX IF NOT EXISTS idx_spi_ig ON "${TABLE6}"("ig_id")`;
+var CREATE_INDEX_CODE2 = `CREATE INDEX IF NOT EXISTS idx_spi_code ON "${TABLE6}"("code")`;
+var SearchParamIndexRepo = class {
+  constructor(adapter, dialect = "sqlite") {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  async ensureTable() {
+    await this.adapter.execute(createTableDDL3(this.dialect));
+    await this.adapter.execute(CREATE_INDEX_IG2);
+    await this.adapter.execute(CREATE_INDEX_CODE2);
+  }
+  async upsert(entry) {
+    await this.ensureTable();
+    const baseJson = JSON.stringify(entry.base);
+    const sql = this.dialect === "postgres" ? `INSERT INTO "${TABLE6}" ("id", "ig_id", "url", "code", "type", "base", "expression") VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT ("id") DO UPDATE SET "url" = EXCLUDED."url", "code" = EXCLUDED."code", "type" = EXCLUDED."type", "base" = EXCLUDED."base", "expression" = EXCLUDED."expression"` : `INSERT OR REPLACE INTO "${TABLE6}" ("id", "ig_id", "url", "code", "type", "base", "expression") VALUES (?, ?, ?, ?, ?, ?, ?)`;
+    await this.adapter.execute(sql, [
+      entry.id,
+      entry.igId,
+      entry.url ?? null,
+      entry.code,
+      entry.type,
+      baseJson,
+      entry.expression ?? null
+    ]);
+  }
+  async batchUpsert(entries) {
+    let count = 0;
+    for (const entry of entries) {
+      await this.upsert(entry);
+      count++;
+    }
+    return count;
+  }
+  async getByIG(igId) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "ig_id", "url", "code", "type", "base", "expression" FROM "${TABLE6}" WHERE "ig_id" = ? ORDER BY "code"`,
+      [igId]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  async getByCode(code) {
+    await this.ensureTable();
+    const rows = await this.adapter.query(
+      `SELECT "id", "ig_id", "url", "code", "type", "base", "expression" FROM "${TABLE6}" WHERE "code" = ? ORDER BY "ig_id"`,
+      [code]
+    );
+    return rows.map((r) => this.mapRow(r));
+  }
+  async remove(id) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE6}" WHERE "id" = ?`, [id]);
+  }
+  async removeByIG(igId) {
+    await this.ensureTable();
+    await this.adapter.execute(`DELETE FROM "${TABLE6}" WHERE "ig_id" = ?`, [igId]);
+  }
+  mapRow(r) {
+    const base = r.base ? typeof r.base === "string" ? JSON.parse(r.base) : r.base : [];
+    return {
+      id: r.id,
+      igId: r.ig_id,
+      url: r.url ?? void 0,
+      code: r.code,
+      type: r.type,
+      base,
+      expression: r.expression ?? void 0
+    };
+  }
+};
+
+// src/conformance/ig-import-orchestrator.ts
+var IGImportOrchestrator = class {
+  resourceMapRepo;
+  sdIndexRepo;
+  elementIndexRepo;
+  expansionCacheRepo;
+  conceptRepo;
+  spIndexRepo;
+  opts;
+  constructor(adapter, dialect = "sqlite", options) {
+    this.resourceMapRepo = new IGResourceMapRepo(adapter, dialect);
+    this.sdIndexRepo = new SDIndexRepo(adapter, dialect);
+    this.elementIndexRepo = new ElementIndexRepo(adapter, dialect);
+    this.expansionCacheRepo = new ExpansionCacheRepo(adapter, dialect);
+    this.conceptRepo = new ConceptHierarchyRepo(adapter, dialect);
+    this.spIndexRepo = new SearchParamIndexRepo(adapter, dialect);
+    this.opts = options ?? {};
+  }
+  /** Ensure all conformance tables exist. */
+  async ensureAllTables() {
+    await this.resourceMapRepo.ensureTable();
+    await this.sdIndexRepo.ensureTable();
+    await this.elementIndexRepo.ensureTable();
+    await this.expansionCacheRepo.ensureTable();
+    await this.conceptRepo.ensureTable();
+    await this.spIndexRepo.ensureTable();
+  }
+  /** Execute a complete IG import from a FHIR Bundle. */
+  async importIG(igId, bundle) {
+    await this.ensureAllTables();
+    const result = {
+      igId,
+      resourceCount: 0,
+      sdIndexCount: 0,
+      elementIndexCount: 0,
+      conceptCount: 0,
+      spIndexCount: 0,
+      errors: []
+    };
+    const entries = bundle.entry ?? [];
+    const resourceMapEntries = [];
+    const structureDefs = [];
+    const codeSystems = [];
+    const searchParams = [];
+    for (const entry of entries) {
+      const resource = entry.resource;
+      if (!resource || !resource.resourceType || !resource.id) continue;
+      const resourceType = resource.resourceType;
+      const resourceId = resource.id;
+      const mapEntry = {
+        resourceType,
+        resourceId,
+        resourceUrl: resource.url ?? void 0,
+        resourceName: resource.name ?? void 0
+      };
+      if (resourceType === "StructureDefinition") {
+        mapEntry.baseType = resource.type ?? void 0;
+        structureDefs.push(resource);
+      } else if (resourceType === "CodeSystem") {
+        codeSystems.push(resource);
+      } else if (resourceType === "SearchParameter") {
+        searchParams.push(resource);
+      }
+      resourceMapEntries.push(mapEntry);
+    }
+    try {
+      result.resourceCount = await this.resourceMapRepo.batchInsert(igId, resourceMapEntries);
+    } catch (err) {
+      result.errors.push(`Resource map insert failed: ${String(err)}`);
+    }
+    for (const sd of structureDefs) {
+      try {
+        const sdEntry = {
+          id: sd.id,
+          url: sd.url ?? void 0,
+          version: sd.version ?? void 0,
+          type: sd.type ?? void 0,
+          kind: sd.kind ?? void 0,
+          baseDefinition: sd.baseDefinition ?? void 0,
+          derivation: sd.derivation ?? void 0
+        };
+        await this.sdIndexRepo.upsert(sdEntry);
+        result.sdIndexCount++;
+        if (this.opts.extractElementIndex) {
+          const elements = this.opts.extractElementIndex(sd);
+          const count = await this.elementIndexRepo.batchInsert(sd.id, elements);
+          result.elementIndexCount += count;
+        }
+      } catch (err) {
+        result.errors.push(`SD processing failed for ${sd.id}: ${String(err)}`);
+      }
+    }
+    for (const cs of codeSystems) {
+      try {
+        if (this.opts.flattenConcepts) {
+          const concepts = this.opts.flattenConcepts(cs);
+          const count = await this.conceptRepo.batchInsert(concepts);
+          result.conceptCount += count;
+        }
+      } catch (err) {
+        result.errors.push(`CodeSystem processing failed for ${cs.id}: ${String(err)}`);
+      }
+    }
+    for (const sp of searchParams) {
+      try {
+        const spEntry = {
+          id: sp.id,
+          igId,
+          url: sp.url ?? void 0,
+          code: sp.code ?? "",
+          type: sp.type ?? "",
+          base: Array.isArray(sp.base) ? sp.base : [],
+          expression: sp.expression ?? void 0
+        };
+        await this.spIndexRepo.upsert(spEntry);
+        result.spIndexCount++;
+      } catch (err) {
+        result.errors.push(`SearchParameter processing failed for ${sp.id}: ${String(err)}`);
+      }
+    }
+    return result;
+  }
+  /** Get individual repos for direct access. */
+  get repos() {
+    return {
+      resourceMap: this.resourceMapRepo,
+      sdIndex: this.sdIndexRepo,
+      elementIndex: this.elementIndexRepo,
+      expansionCache: this.expansionCacheRepo,
+      conceptHierarchy: this.conceptRepo,
+      searchParamIndex: this.spIndexRepo
+    };
+  }
+};
 export {
   BetterSqlite3Adapter,
+  ConceptHierarchyRepo,
   DEFAULT_SEARCH_COUNT,
   DELETED_SCHEMA_VERSION,
+  ElementIndexRepo,
+  ExpansionCacheRepo,
   FhirDefinitionBridge,
   FhirPersistence,
   FhirRuntimeProvider,
   FhirStore,
   FhirSystem,
+  IGImportOrchestrator,
   IGPersistenceManager,
+  IGResourceMapRepo,
   IndexingPipeline,
   LookupTableWriter,
   MAX_SEARCH_COUNT,
@@ -8817,9 +9527,11 @@ export {
   ResourceNotFoundError,
   ResourceVersionConflictError,
   SCHEMA_VERSION,
+  SDIndexRepo,
   SEARCH_PREFIXES,
   SQLiteDialect,
   SearchLogger,
+  SearchParamIndexRepo,
   SearchParameterRegistry,
   StructureDefinitionRegistry,
   TerminologyCodeRepo,