@nicia-ai/typegraph 0.24.1 → 0.25.1

package/dist/{chunk-5HVDOPZU.cjs → chunk-CQVNGKU7.cjs}

@@ -1,12 +1,18 @@
 'use strict';
 
-var chunkO5PST6TB_cjs = require('./chunk-O5PST6TB.cjs');
-var chunkPEE4EWXZ_cjs = require('./chunk-PEE4EWXZ.cjs');
-var chunk3JK66E3I_cjs = require('./chunk-3JK66E3I.cjs');
+var chunkJTI5WT4P_cjs = require('./chunk-JTI5WT4P.cjs');
+var chunkCTHNVU6K_cjs = require('./chunk-CTHNVU6K.cjs');
+var chunkW5MTHMTE_cjs = require('./chunk-W5MTHMTE.cjs');
+var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
-var drizzleOrm = require('drizzle-orm');
 
+var regconfig = pgCore.customType({
+  dataType: () => "regconfig"
+});
+var tsvector = pgCore.customType({
+  dataType: () => "tsvector"
+});
 var vector = pgCore.customType({
   dataType(config) {
     return config?.dimensions ? `vector(${config.dimensions})` : "vector";
@@ -33,7 +39,10 @@ var DEFAULT_TABLE_NAMES = {
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
   embeddings: "typegraph_node_embeddings",
-  fulltext: "typegraph_node_fulltext"
+  fulltext: "typegraph_node_fulltext",
+  indexMaterializations: "typegraph_index_materializations",
+  kindRemovals: "typegraph_kind_removals",
+  reconciliationMarkers: "typegraph_reconciliation_markers"
 };
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
@@ -63,7 +72,7 @@ function createPostgresTables(names = {}, options = {}) {
       ),
       pgCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       pgCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkPEE4EWXZ_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+      ...chunkJTI5WT4P_cjs.buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = pgCore.pgTable(
@@ -122,7 +131,7 @@ function createPostgresTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkPEE4EWXZ_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+      ...chunkJTI5WT4P_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = pgCore.pgTable(
@@ -155,7 +164,13 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       pgCore.primaryKey({ columns: [t.graphId, t.version] }),
-      pgCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+      pgCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      pgCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = TRUE`)
     ]
   );
   const embeddings3 = pgCore.pgTable(
@@ -190,33 +205,99 @@ function createPostgresTables(names = {}, options = {}) {
       )
     ]
   );
+  const indexMaterializations = pgCore.pgTable(
+    n.indexMaterializations,
+    {
+      indexName: pgCore.text("index_name").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = pgCore.pgTable(
+    n.kindRemovals,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      kindName: pgCore.text("kind_name").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      removedAt: pgCore.timestamp("removed_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = pgCore.pgTable(
+    n.reconciliationMarkers,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      reconciledToVersion: pgCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const fulltext2 = pgCore.pgTable(
+    n.fulltext,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      content: pgCore.text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(drizzleOrm.sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      pgCore.index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      pgCore.index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
+    ]
+  );
   return {
     nodes: nodes3,
     edges: edges3,
     uniques: uniques3,
     schemaVersions: schemaVersions3,
     embeddings: embeddings3,
-    /**
-     * The fulltext storage table is owned by the active `FulltextStrategy`,
-     * not Drizzle. Shapes vary across strategies — the default `tsvectorStrategy`
-     * uses a `regconfig` language column, a GENERATED STORED `tsv` column,
-     * and a GIN index; alternate strategies (ParadeDB, pg_trgm, pgroonga)
-     * pick their own column types and index methods. DDL is emitted as
-     * raw SQL via `strategy.generateDdl()`; reads and writes are composed
-     * from the strategy's fragment helpers.
-     */
+    indexMaterializations,
+    kindRemovals,
+    reconciliationMarkers,
+    fulltext: fulltext2,
     fulltextTableName: n.fulltext
   };
 }
 var tables = createPostgresTables();
-var { nodes, edges, uniques, schemaVersions, embeddings } = tables;
+var {
+  nodes,
+  edges,
+  uniques,
+  schemaVersions,
+  embeddings,
+  fulltext
+} = tables;
 var DEFAULT_TABLE_NAMES2 = {
   nodes: "typegraph_nodes",
   edges: "typegraph_edges",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
   embeddings: "typegraph_node_embeddings",
-  fulltext: "typegraph_node_fulltext"
+  fulltext: "typegraph_node_fulltext",
+  indexMaterializations: "typegraph_index_materializations",
+  kindRemovals: "typegraph_kind_removals",
+  reconciliationMarkers: "typegraph_reconciliation_markers"
 };
 function createSqliteTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES2, ...names };
@@ -246,7 +327,7 @@ function createSqliteTables(names = {}, options = {}) {
       ),
       sqliteCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       sqliteCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkPEE4EWXZ_cjs.buildSqliteNodeIndexBuilders(t, indexes)
+      ...chunkJTI5WT4P_cjs.buildSqliteNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = sqliteCore.sqliteTable(
@@ -305,7 +386,7 @@ function createSqliteTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkPEE4EWXZ_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
+      ...chunkJTI5WT4P_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = sqliteCore.sqliteTable(
@@ -338,7 +419,13 @@ function createSqliteTables(names = {}, options = {}) {
     },
     (t) => [
       sqliteCore.primaryKey({ columns: [t.graphId, t.version] }),
-      sqliteCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+      sqliteCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      sqliteCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = 1`)
     ]
   );
   const embeddings3 = sqliteCore.sqliteTable(
@@ -377,12 +464,55 @@ function createSqliteTables(names = {}, options = {}) {
       )
     ]
   );
+  const indexMaterializations = sqliteCore.sqliteTable(
+    n.indexMaterializations,
+    {
+      indexName: sqliteCore.text("index_name").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = sqliteCore.sqliteTable(
+    n.kindRemovals,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kindName: sqliteCore.text("kind_name").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      removedAt: sqliteCore.text("removed_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = sqliteCore.sqliteTable(
+    n.reconciliationMarkers,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      reconciledToVersion: sqliteCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
   return {
     nodes: nodes3,
     edges: edges3,
     uniques: uniques3,
     schemaVersions: schemaVersions3,
     embeddings: embeddings3,
+    indexMaterializations,
+    kindRemovals,
+    reconciliationMarkers,
     /**
      * The fulltext storage is a FTS5 virtual table which Drizzle cannot
      * represent. DDL is emitted as raw SQL and operations query it via
@@ -448,9 +578,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql10 = tryInlineSql(col);
-  if (sql10 !== void 0) {
-    return sql10;
+  const sql14 = tryInlineSql(col);
+  if (sql14 !== void 0) {
+    return sql14;
   }
   return "unknown";
 }
@@ -524,7 +654,7 @@ function isSqliteTable(value) {
   return typeof value === "object" && value !== null && // Drizzle tables are always objects; strings are our escape hatch.
   typeof value !== "string";
 }
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunk3JK66E3I_cjs.fts5Strategy) {
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkJTI5WT4P_cjs.fts5Strategy) {
   const statements = [];
   for (const table of Object.values(tables3)) {
     if (!isSqliteTable(table)) continue;
@@ -537,7 +667,7 @@ function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunk3JK66E3I_c
   statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
   return statements;
 }
-function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunk3JK66E3I_cjs.fts5Strategy) {
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkJTI5WT4P_cjs.fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -622,20 +752,22 @@ function generatePgCreateIndexSQL(table) {
 function isPgTable(value) {
   return typeof value === "object" && value !== null && typeof value !== "string";
 }
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunk3JK66E3I_cjs.tsvectorStrategy) {
+function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunkJTI5WT4P_cjs.tsvectorStrategy) {
   const statements = [];
   for (const table of Object.values(tables3)) {
     if (!isPgTable(table)) continue;
+    if (table === tables3.fulltext) continue;
     statements.push(generatePgCreateTableSQL(table));
   }
   for (const table of Object.values(tables3)) {
     if (!isPgTable(table)) continue;
+    if (table === tables3.fulltext) continue;
     statements.push(...generatePgCreateIndexSQL(table));
   }
   statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
   return statements;
 }
-function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunk3JK66E3I_cjs.tsvectorStrategy) {
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkJTI5WT4P_cjs.tsvectorStrategy) {
   const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
   const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
   return `${extensionSql}
@@ -646,7 +778,7 @@ ${ddlSql}`;
 // src/backend/drizzle/row-mappers.ts
 function requireTimestamp(value, field) {
   if (value === void 0) {
-    throw new chunkO5PST6TB_cjs.DatabaseOperationError(
+    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
       `Expected non-null ${field} timestamp`,
       { operation: "select", entity: "row" }
     );
@@ -655,7 +787,7 @@ function requireTimestamp(value, field) {
 }
 function asString(value, field) {
   if (typeof value !== "string") {
-    throw new chunkO5PST6TB_cjs.DatabaseOperationError(
+    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
       `Expected ${field} to be string, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -664,7 +796,7 @@ function asString(value, field) {
 }
 function asNumber(value, field) {
   if (typeof value !== "number") {
-    throw new chunkO5PST6TB_cjs.DatabaseOperationError(
+    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
       `Expected ${field} to be number, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -695,7 +827,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   formatTimestamp: (value) => {
     if (value === null || value === void 0) return;
     if (typeof value !== "string") {
-      throw new chunkO5PST6TB_cjs.DatabaseOperationError(
+      throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
         `Expected timestamp to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -704,7 +836,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   },
   normalizeJson: (value) => {
     if (typeof value !== "string") {
-      throw new chunkO5PST6TB_cjs.DatabaseOperationError(
+      throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
         `Expected JSON column to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -772,6 +904,105 @@ function createSchemaVersionRowMapper(config) {
     };
   };
 }
+var SQLITE_INDEX_MAT_TIMESTAMPS = {
+  decode: (value) => typeof value === "string" ? value : void 0,
+  encode: (value) => value
+};
+var POSTGRES_INDEX_MAT_TIMESTAMPS = {
+  decode: formatPostgresTimestamp,
+  encode: (value) => new Date(value)
+};
+function mapMaterializationRow(row, decode) {
+  const lastAttemptedAt = decode(row.lastAttemptedAt);
+  if (lastAttemptedAt === void 0) {
+    throw new Error(
+      `materialization row missing required last_attempted_at: ${row.indexName}`
+    );
+  }
+  return {
+    indexName: row.indexName,
+    graphId: row.graphId,
+    entity: row.entity,
+    kind: row.kind,
+    signature: row.signature,
+    schemaVersion: row.schemaVersion,
+    materializedAt: decode(row.materializedAt),
+    lastAttemptedAt,
+    lastError: row.lastError ?? void 0
+  };
+}
+function buildMaterializationInsertValues(params, encode) {
+  return {
+    indexName: params.indexName,
+    graphId: params.graphId,
+    entity: params.entity,
+    kind: params.kind,
+    signature: params.signature,
+    schemaVersion: params.schemaVersion,
+    materializedAt: params.materializedAt === void 0 ? void 0 : encode(params.materializedAt),
+    lastAttemptedAt: encode(params.attemptedAt),
+    lastError: params.error
+  };
+}
+function buildMaterializationOnConflictSet(materializedAtColumn, paramsMaterializedAt) {
+  const materializedAtSet = paramsMaterializedAt === void 0 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("materialized_at")}, ${materializedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`;
+  return {
+    graphId: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("graph_id")}`,
+    entity: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("entity")}`,
+    kind: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("kind")}`,
+    signature: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("signature")}`,
+    schemaVersion: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("schema_version")}`,
+    materializedAt: materializedAtSet,
+    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
+    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
+  };
+}
+var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
+  decode: (value) => typeof value === "string" ? value : void 0,
+  encode: (value) => value
+};
+var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
+  decode: formatPostgresTimestamp,
+  encode: (value) => new Date(value)
+};
+function mapKindRemovalRow(row, decode) {
+  const lastAttemptedAt = decode(row.lastAttemptedAt);
+  if (lastAttemptedAt === void 0) {
+    throw new Error(
+      `kind removal row missing required last_attempted_at: ${row.kindName}`
+    );
+  }
+  return {
+    graphId: row.graphId,
+    kindName: row.kindName,
+    entity: row.entity,
+    schemaVersion: row.schemaVersion,
+    removedAt: decode(row.removedAt),
+    lastAttemptedAt,
+    lastError: row.lastError ?? void 0
+  };
+}
+function buildKindRemovalInsertValues(params, encode) {
+  return {
+    graphId: params.graphId,
+    kindName: params.kindName,
+    entity: params.entity,
+    schemaVersion: params.schemaVersion,
+    removedAt: params.removedAt === void 0 ? void 0 : encode(params.removedAt),
+    lastAttemptedAt: encode(params.attemptedAt),
+    lastError: params.error
+  };
+}
+function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
+  const removedAtSet = paramsRemovedAt === void 0 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("removed_at")}, ${removedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("removed_at")}`;
+  return {
+    entity: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("entity")}`,
+    schemaVersion: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("schema_version")}`,
+    removedAt: removedAtSet,
+    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
+    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
+  };
+}
 
 // src/backend/drizzle/operation-backend-core.ts
 function chunkArray(values, size) {
@@ -784,15 +1015,31 @@ function chunkArray(values, size) {
   }
   return chunks;
 }
+function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
+  const expectedVersion = expected.kind === "active" ? expected.version : 0;
+  if (actualActiveVersion !== expectedVersion) {
+    throw new chunkW5MTHMTE_cjs.StaleVersionError({
+      graphId,
+      expected: expectedVersion,
+      actual: actualActiveVersion
+    });
+  }
+}
 function createCommonOperationBackend(options) {
   const { batchConfig, execution, operationStrategy, rowMappers } = options;
   const nowIso2 = options.nowIso ?? nowIso;
+  async function readActiveVersion(graphId) {
+    const row = await execution.execGet(
+      operationStrategy.buildGetActiveSchema(graphId)
+    );
+    return row === void 0 ? 0 : rowMappers.toSchemaVersionRow(row).version;
+  }
   return {
     async insertNode(params) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkO5PST6TB_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
@@ -842,7 +1089,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkO5PST6TB_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
@@ -885,7 +1132,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkO5PST6TB_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
@@ -935,7 +1182,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkO5PST6TB_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
@@ -986,7 +1233,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkO5PST6TB_cjs.UniquenessError({
+        throw new chunkW5MTHMTE_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -1020,20 +1267,104 @@ function createCommonOperationBackend(options) {
       const row = await execution.execGet(query);
       return row ? rowMappers.toSchemaVersionRow(row) : void 0;
     },
-    async insertSchema(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertSchema(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunkO5PST6TB_cjs.DatabaseOperationError("Insert schema failed: no row returned", { operation: "insert", entity: "schema" });
-      return rowMappers.toSchemaVersionRow(row);
-    },
     async getSchemaVersion(graphId, version) {
       const query = operationStrategy.buildGetSchemaVersion(graphId, version);
       const row = await execution.execGet(query);
       return row ? rowMappers.toSchemaVersionRow(row) : void 0;
     },
-    async setActiveSchema(graphId, version) {
-      const queries = operationStrategy.buildSetActiveSchema(graphId, version);
+    async commitSchemaVersion(params) {
+      const existingRaw = await execution.execGet(
+        operationStrategy.buildGetSchemaVersion(
+          params.graphId,
+          params.version
+        )
+      );
+      const actualActiveVersion = await readActiveVersion(params.graphId);
+      if (existingRaw !== void 0) {
+        const existing = rowMappers.toSchemaVersionRow(existingRaw);
+        if (existing.schema_hash !== params.schemaHash) {
+          throw new chunkW5MTHMTE_cjs.SchemaContentConflictError({
+            graphId: params.graphId,
+            version: params.version,
+            existingHash: existing.schema_hash,
+            incomingHash: params.schemaHash
+          });
+        }
+        if (existing.is_active) {
+          return existing;
+        }
+        verifyExpectedActiveVersion(
+          params.graphId,
+          params.expected,
+          actualActiveVersion
+        );
+        const reactivate = operationStrategy.buildSetActiveSchema(
+          params.graphId,
+          params.version
+        );
+        await execution.execRun(reactivate.deactivateAll);
+        await execution.execRun(reactivate.activateVersion);
+        return { ...existing, is_active: true };
+      }
+      verifyExpectedActiveVersion(
+        params.graphId,
+        params.expected,
+        actualActiveVersion
+      );
+      if (params.expected.kind === "active") {
+        const flip = operationStrategy.buildSetActiveSchema(
+          params.graphId,
+          params.version
+        );
+        await execution.execRun(flip.deactivateAll);
+      }
+      const timestamp2 = nowIso2();
+      const insertQuery = operationStrategy.buildInsertSchema(
+        {
+          graphId: params.graphId,
+          version: params.version,
+          schemaHash: params.schemaHash,
+          schemaDoc: params.schemaDoc,
+          isActive: true
+        },
+        timestamp2
+      );
+      const insertedRaw = await execution.execGet(insertQuery);
+      if (!insertedRaw) {
+        throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+          "Insert schema failed: no row returned",
+          { operation: "insert", entity: "schema" }
+        );
+      }
+      return rowMappers.toSchemaVersionRow(insertedRaw);
+    },
+    async setActiveVersion(params) {
+      const actualActiveVersion = await readActiveVersion(params.graphId);
+      verifyExpectedActiveVersion(
+        params.graphId,
+        params.expected,
+        actualActiveVersion
+      );
+      const targetRaw = await execution.execGet(
+        operationStrategy.buildGetSchemaVersion(
+          params.graphId,
+          params.version
+        )
+      );
+      if (!targetRaw) {
+        throw new chunkW5MTHMTE_cjs.MigrationError(
+          `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
+          {
+            graphId: params.graphId,
+            fromVersion: actualActiveVersion,
+            toVersion: params.version
+          }
+        );
+      }
+      const queries = operationStrategy.buildSetActiveSchema(
+        params.graphId,
+        params.version
+      );
       await execution.execRun(queries.deactivateAll);
       await execution.execRun(queries.activateVersion);
     },
@@ -1046,13 +1377,16 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
-  const fulltext = chunk3JK66E3I_cjs.quotedTableName(tables3.fulltextTableName);
+  const fulltext2 = chunkJTI5WT4P_cjs.quotedTableName(tables3.fulltextTableName);
   return [
-    drizzleOrm.sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}`,
+    drizzleOrm.sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
+    drizzleOrm.sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`,
+    drizzleOrm.sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`,
+    drizzleOrm.sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
   ];
 }
@@ -1193,13 +1527,13 @@ function buildCountEdgesByKind(tables3, params) {
 function buildInsertEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunk3JK66E3I_cjs.edgeColumnList(edges3);
+  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunk3JK66E3I_cjs.sqlNull(params.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1208,23 +1542,23 @@ function buildInsertEdge(tables3, params, timestamp2) {
 function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunk3JK66E3I_cjs.edgeColumnList(edges3);
+  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunk3JK66E3I_cjs.sqlNull(params.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertEdgesBatch(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = chunk3JK66E3I_cjs.edgeColumnList(edges3);
+  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunk3JK66E3I_cjs.sqlNull(edgeParams.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1233,10 +1567,10 @@ function buildInsertEdgesBatch(tables3, params, timestamp2) {
 }
 function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = chunk3JK66E3I_cjs.edgeColumnList(edges3);
+  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunk3JK66E3I_cjs.sqlNull(edgeParams.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1268,14 +1602,14 @@ function buildUpdateEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1300,7 +1634,7 @@ function buildDeleteEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${edges3}
-    SET ${chunk3JK66E3I_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    SET ${chunkJTI5WT4P_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
     WHERE ${edges3.graphId} = ${params.graphId}
       AND ${edges3.id} = ${params.id}
       AND ${edges3.deletedAt} IS NULL
@@ -1387,7 +1721,7 @@ function resolveMode(mode) {
 function buildFulltextSearch(tableName, params, strategy) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
-  const table = chunk3JK66E3I_cjs.quotedTableName(tableName);
+  const table = chunkJTI5WT4P_cjs.quotedTableName(tableName);
   const matchCondition = strategy.matchCondition(
     tableName,
     params.query,
@@ -1438,12 +1772,12 @@ function assertValidSearchParams(params) {
 function buildInsertNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunk3JK66E3I_cjs.nodeColumnList(nodes3);
+  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunk3JK66E3I_cjs.sqlNull(params.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(params.validTo)},
+      1, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1452,22 +1786,22 @@ function buildInsertNode(tables3, params, timestamp2) {
 function buildInsertNodeNoReturn(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunk3JK66E3I_cjs.nodeColumnList(nodes3);
+  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunk3JK66E3I_cjs.sqlNull(params.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(params.validTo)},
+      1, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertNodesBatch(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = chunk3JK66E3I_cjs.nodeColumnList(nodes3);
+  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunk3JK66E3I_cjs.sqlNull(nodeParams.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1476,10 +1810,10 @@ function buildInsertNodesBatch(tables3, params, timestamp2) {
 }
 function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = chunk3JK66E3I_cjs.nodeColumnList(nodes3);
+  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunk3JK66E3I_cjs.sqlNull(nodeParams.validFrom)}, ${chunk3JK66E3I_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1513,19 +1847,19 @@ function buildUpdateNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(nodes3.version)} = ${chunk3JK66E3I_cjs.quotedColumn(nodes3.version)} + 1`
+      drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.version)} = ${chunkJTI5WT4P_cjs.quotedColumn(nodes3.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunk3JK66E3I_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1552,7 +1886,7 @@ function buildDeleteNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${nodes3}
-    SET ${chunk3JK66E3I_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
+    SET ${chunkJTI5WT4P_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
     WHERE ${nodes3.graphId} = ${params.graphId}
       AND ${nodes3.kind} = ${params.kind}
       AND ${nodes3.id} = ${params.id}
@@ -1619,12 +1953,12 @@ function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${chunk3JK66E3I_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
+    SET ${chunkJTI5WT4P_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${chunk3JK66E3I_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
+    SET ${chunkJTI5WT4P_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
       AND ${schemaVersions3.version} = ${version}
   `;
@@ -1642,22 +1976,22 @@ function buildInsertUniqueSqlite(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} = CASE
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)}
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)}
       END,
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.concreteKind)} = CASE
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${chunk3JK66E3I_cjs.quotedColumn(uniques3.concreteKind)}
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)}
       END,
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} = CASE
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)}
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)}
       END
-    RETURNING ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 function buildInsertUniquePostgres(tables3, params) {
@@ -1674,22 +2008,22 @@ function buildInsertUniquePostgres(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} = CASE
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
         ELSE ${existingColumn(uniques3.nodeId)}
       END,
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.concreteKind)} = CASE
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
         ELSE ${existingColumn(uniques3.concreteKind)}
       END,
-      ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} = CASE
+      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
         ELSE ${existingColumn(uniques3.deletedAt)}
       END
-    RETURNING ${chunk3JK66E3I_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
@@ -1704,7 +2038,7 @@ function buildDeleteUnique(tables3, params, timestamp2) {
   const { uniques: uniques3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${uniques3}
-    SET ${chunk3JK66E3I_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
+    SET ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
     WHERE ${uniques3.graphId} = ${params.graphId}
       AND ${uniques3.nodeKind} = ${params.nodeKind}
       AND ${uniques3.constraintName} = ${params.constraintName}
@@ -2178,11 +2512,11 @@ function generateVectorIndexName(graphId, nodeKind, fieldPath, metric = "cosine"
     metric
   ];
   const name = parts.join("_");
-  if (name.length <= chunk3JK66E3I_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+  if (name.length <= chunkCTHNVU6K_cjs.MAX_PG_IDENTIFIER_LENGTH) {
     return name;
   }
   const hash = shortHash(name);
-  const truncated = name.slice(0, chunk3JK66E3I_cjs.MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length);
+  const truncated = name.slice(0, chunkCTHNVU6K_cjs.MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length);
   return `${truncated}_${hash}`;
 }
 function getOperatorClass(metric) {
@@ -2231,9 +2565,10 @@ async function createPostgresVectorIndex(db, options) {
   const safeNodeKind = escapeSqlString(nodeKind);
   const safeFieldPath = escapeSqlString(fieldPath);
   let indexSql;
+  const concurrentClause = options.concurrent === true ? "CONCURRENTLY " : "";
   if (indexType === "hnsw") {
     indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX IF NOT EXISTS ${indexName}
+      CREATE INDEX ${concurrentClause}IF NOT EXISTS ${indexName}
       ON ${quotedEmbeddingsTableName}
       USING hnsw ((embedding::vector(${dimensions})) ${operatorClass})
       WITH (m = ${hnswM}, ef_construction = ${hnswEfConstruction})
@@ -2243,7 +2578,7 @@ async function createPostgresVectorIndex(db, options) {
     `);
   } else if (indexType === "ivfflat") {
     indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX IF NOT EXISTS ${indexName}
+      CREATE INDEX ${concurrentClause}IF NOT EXISTS ${indexName}
       ON ${quotedEmbeddingsTableName}
       USING ivfflat ((embedding::vector(${dimensions})) ${operatorClass})
       WITH (lists = ${ivfflatLists})
@@ -2340,8 +2675,16 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
+exports.POSTGRES_INDEX_MAT_TIMESTAMPS = POSTGRES_INDEX_MAT_TIMESTAMPS;
+exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
 exports.POSTGRES_ROW_MAPPER_CONFIG = POSTGRES_ROW_MAPPER_CONFIG;
+exports.SQLITE_INDEX_MAT_TIMESTAMPS = SQLITE_INDEX_MAT_TIMESTAMPS;
+exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
 exports.SQLITE_ROW_MAPPER_CONFIG = SQLITE_ROW_MAPPER_CONFIG;
+exports.buildKindRemovalInsertValues = buildKindRemovalInsertValues;
+exports.buildKindRemovalOnConflictSet = buildKindRemovalOnConflictSet;
+exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
+exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
 exports.compileQueryWithDialect = compileQueryWithDialect;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createEdgeRowMapper = createEdgeRowMapper;
@@ -2361,12 +2704,17 @@ exports.edges2 = edges2;
 exports.embeddings = embeddings;
 exports.embeddings2 = embeddings2;
 exports.formatPostgresTimestamp = formatPostgresTimestamp;
+exports.fulltext = fulltext;
+exports.generatePgCreateTableSQL = generatePgCreateTableSQL;
 exports.generatePostgresDDL = generatePostgresDDL;
 exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
+exports.generateSqliteCreateTableSQL = generateSqliteCreateTableSQL;
 exports.generateSqliteDDL = generateSqliteDDL;
 exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
 exports.generateVectorIndexName = generateVectorIndexName;
 exports.getOrCreateLru = getOrCreateLru;
+exports.mapKindRemovalRow = mapKindRemovalRow;
+exports.mapMaterializationRow = mapMaterializationRow;
 exports.nodes = nodes;
 exports.nodes2 = nodes2;
 exports.nowIso = nowIso;
@@ -2376,5 +2724,5 @@ exports.tables = tables;
 exports.tables2 = tables2;
 exports.uniques = uniques;
 exports.uniques2 = uniques2;
-//# sourceMappingURL=chunk-5HVDOPZU.cjs.map
-//# sourceMappingURL=chunk-5HVDOPZU.cjs.map
+//# sourceMappingURL=chunk-CQVNGKU7.cjs.map
+//# sourceMappingURL=chunk-CQVNGKU7.cjs.map