@nicia-ai/typegraph 0.24.1 → 0.25.1

package/dist/{chunk-EY4LBX3F.js → chunk-PSKUWVCB.js}

@@ -1,10 +1,16 @@
-import { DatabaseOperationError, UniquenessError } from './chunk-WFMTAEEN.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders } from './chunk-3PPEHLGK.js';
-import { tsvectorStrategy, fts5Strategy, MAX_PG_IDENTIFIER_LENGTH, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-753F33CV.js';
-import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, getTableConfig as getTableConfig$1 } from 'drizzle-orm/pg-core';
-import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, blob, getTableConfig } from 'drizzle-orm/sqlite-core';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders, tsvectorStrategy, fts5Strategy, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-YZZBDCLV.js';
+import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-EJCDOA37.js';
+import { DatabaseOperationError, MigrationError, SchemaContentConflictError, UniquenessError, StaleVersionError } from './chunk-DOTEN2FG.js';
 import { sql, getTableName } from 'drizzle-orm';
+import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1 } from 'drizzle-orm/pg-core';
+import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, uniqueIndex as uniqueIndex$1, blob, getTableConfig } from 'drizzle-orm/sqlite-core';
 
+var regconfig = customType({
+  dataType: () => "regconfig"
+});
+var tsvector = customType({
+  dataType: () => "tsvector"
+});
 var vector = customType({
   dataType(config) {
     return config?.dimensions ? `vector(${config.dimensions})` : "vector";
@@ -31,7 +37,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 };
@@ -153,7 +162,13 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey({ columns: [t.graphId, t.version] }),
-      index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+      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`.
+      uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = TRUE`)
     ]
   );
   const embeddings3 = pgTable(
@@ -188,33 +203,99 @@ function createPostgresTables(names = {}, options = {}) {
       )
     ]
   );
+  const indexMaterializations = pgTable(
+    n.indexMaterializations,
+    {
+      indexName: text("index_name").notNull(),
+      graphId: text("graph_id").notNull(),
+      entity: text("entity").notNull(),
+      kind: text("kind").notNull(),
+      signature: text("signature").notNull(),
+      schemaVersion: integer("schema_version").notNull(),
+      materializedAt: timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: text("last_error")
+    },
+    (t) => [primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = pgTable(
+    n.kindRemovals,
+    {
+      graphId: text("graph_id").notNull(),
+      kindName: text("kind_name").notNull(),
+      entity: text("entity").notNull(),
+      schemaVersion: integer("schema_version").notNull(),
+      removedAt: timestamp("removed_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: text("last_error")
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = pgTable(
+    n.reconciliationMarkers,
+    {
+      graphId: text("graph_id").notNull(),
+      reconciledToVersion: integer("reconciled_to_version").notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
+  const fulltext2 = pgTable(
+    n.fulltext,
+    {
+      graphId: text("graph_id").notNull(),
+      nodeKind: text("node_kind").notNull(),
+      nodeId: text("node_id").notNull(),
+      content: text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      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 };
@@ -336,7 +417,13 @@ function createSqliteTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey$1({ columns: [t.graphId, t.version] }),
-      index$1(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+      index$1(`${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`.
+      uniqueIndex$1(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = 1`)
     ]
   );
   const embeddings3 = sqliteTable(
@@ -375,12 +462,55 @@ function createSqliteTables(names = {}, options = {}) {
       )
     ]
   );
+  const indexMaterializations = sqliteTable(
+    n.indexMaterializations,
+    {
+      indexName: text$1("index_name").notNull(),
+      graphId: text$1("graph_id").notNull(),
+      entity: text$1("entity").notNull(),
+      kind: text$1("kind").notNull(),
+      signature: text$1("signature").notNull(),
+      schemaVersion: integer$1("schema_version").notNull(),
+      materializedAt: text$1("materialized_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [primaryKey$1({ columns: [t.indexName] })]
+  );
+  const kindRemovals = sqliteTable(
+    n.kindRemovals,
+    {
+      graphId: text$1("graph_id").notNull(),
+      kindName: text$1("kind_name").notNull(),
+      entity: text$1("entity").notNull(),
+      schemaVersion: integer$1("schema_version").notNull(),
+      removedAt: text$1("removed_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [
+      primaryKey$1({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = sqliteTable(
+    n.reconciliationMarkers,
+    {
+      graphId: text$1("graph_id").notNull(),
+      reconciledToVersion: integer$1("reconciled_to_version").notNull()
+    },
+    (t) => [primaryKey$1({ 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
@@ -446,9 +576,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";
 }
@@ -624,10 +754,12 @@ function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrate
   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));
@@ -770,6 +902,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 ? sql`COALESCE(excluded.${sql.identifier("materialized_at")}, ${materializedAtColumn})` : sql`excluded.${sql.identifier("materialized_at")}`;
+  return {
+    graphId: sql`excluded.${sql.identifier("graph_id")}`,
+    entity: sql`excluded.${sql.identifier("entity")}`,
+    kind: sql`excluded.${sql.identifier("kind")}`,
+    signature: sql`excluded.${sql.identifier("signature")}`,
+    schemaVersion: sql`excluded.${sql.identifier("schema_version")}`,
+    materializedAt: materializedAtSet,
+    lastAttemptedAt: sql`excluded.${sql.identifier("last_attempted_at")}`,
+    lastError: sql`excluded.${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 ? sql`COALESCE(excluded.${sql.identifier("removed_at")}, ${removedAtColumn})` : sql`excluded.${sql.identifier("removed_at")}`;
+  return {
+    entity: sql`excluded.${sql.identifier("entity")}`,
+    schemaVersion: sql`excluded.${sql.identifier("schema_version")}`,
+    removedAt: removedAtSet,
+    lastAttemptedAt: sql`excluded.${sql.identifier("last_attempted_at")}`,
+    lastError: sql`excluded.${sql.identifier("last_error")}`
+  };
+}
 
 // src/backend/drizzle/operation-backend-core.ts
 function chunkArray(values, size) {
@@ -782,9 +1013,25 @@ function chunkArray(values, size) {
   }
   return chunks;
 }
+function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
+  const expectedVersion = expected.kind === "active" ? expected.version : 0;
+  if (actualActiveVersion !== expectedVersion) {
+    throw new 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();
@@ -1018,20 +1265,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 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 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 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 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);
     },
@@ -1044,13 +1375,16 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
-  const fulltext = quotedTableName(tables3.fulltextTableName);
+  const fulltext2 = quotedTableName(tables3.fulltextTableName);
   return [
-    sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}`,
+    sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
     sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
+    sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`,
+    sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`,
+    sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
   ];
 }
@@ -2229,9 +2563,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 = 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})
@@ -2241,7 +2576,7 @@ async function createPostgresVectorIndex(db, options) {
     `);
   } else if (indexType === "ivfflat") {
     indexSql = 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})
@@ -2338,6 +2673,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-export { POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG, compileQueryWithDialect, createCommonOperationBackend, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, getOrCreateLru, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
-//# sourceMappingURL=chunk-EY4LBX3F.js.map
-//# sourceMappingURL=chunk-EY4LBX3F.js.map
+export { POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, SQLITE_ROW_MAPPER_CONFIG, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCommonOperationBackend, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, fulltext, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, getOrCreateLru, mapKindRemovalRow, mapMaterializationRow, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
+//# sourceMappingURL=chunk-PSKUWVCB.js.map
+//# sourceMappingURL=chunk-PSKUWVCB.js.map