@nicia-ai/typegraph 0.25.0 → 0.26.0

package/dist/{chunk-WI5VRP3X.js → chunk-RF5EUQWS.js}

@@ -1,10 +1,17 @@
-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';
+import { isMissingTableError, sortedReplacer } from './chunk-5H3BAMTB.js';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders, tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-ZTREJOGB.js';
+import { MAX_PG_IDENTIFIER_LENGTH, sha256Hex } from './chunk-EJCDOA37.js';
+import { DatabaseOperationError, ConfigurationError, MigrationError, SchemaContentConflictError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-U5ROKVRF.js';
+import { sql, is, getTableName } from 'drizzle-orm';
+import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1, PgTable } 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, SQLiteTable } 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";
@@ -33,6 +40,7 @@ var DEFAULT_TABLE_NAMES = {
   embeddings: "typegraph_node_embeddings",
   fulltext: "typegraph_node_fulltext",
   indexMaterializations: "typegraph_index_materializations",
+  contributionMaterializations: "typegraph_contribution_materializations",
   kindRemovals: "typegraph_kind_removals",
   reconciliationMarkers: "typegraph_reconciliation_markers"
 };
@@ -241,6 +249,43 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [primaryKey({ columns: [t.graphId] })]
   );
+  const contributionMaterializations = pgTable(
+    n.contributionMaterializations,
+    {
+      graphId: text("graph_id").notNull(),
+      logicalName: text("logical_name").notNull(),
+      owner: text("owner").notNull(),
+      tableName: text("table_name").notNull(),
+      signature: text("signature").notNull(),
+      materializedAt: timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: text("last_error")
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  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,
@@ -248,22 +293,22 @@ function createPostgresTables(names = {}, options = {}) {
     schemaVersions: schemaVersions3,
     embeddings: embeddings3,
     indexMaterializations,
+    contributionMaterializations,
     kindRemovals,
     reconciliationMarkers,
-    /**
-     * 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.
-     */
+    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",
@@ -272,6 +317,7 @@ var DEFAULT_TABLE_NAMES2 = {
   embeddings: "typegraph_node_embeddings",
   fulltext: "typegraph_node_fulltext",
   indexMaterializations: "typegraph_index_materializations",
+  contributionMaterializations: "typegraph_contribution_materializations",
   kindRemovals: "typegraph_kind_removals",
   reconciliationMarkers: "typegraph_reconciliation_markers"
 };
@@ -480,6 +526,24 @@ function createSqliteTables(names = {}, options = {}) {
     },
     (t) => [primaryKey$1({ columns: [t.graphId] })]
   );
+  const contributionMaterializations = sqliteTable(
+    n.contributionMaterializations,
+    {
+      graphId: text$1("graph_id").notNull(),
+      logicalName: text$1("logical_name").notNull(),
+      owner: text$1("owner").notNull(),
+      tableName: text$1("table_name").notNull(),
+      signature: text$1("signature").notNull(),
+      materializedAt: text$1("materialized_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [
+      primaryKey$1({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
   return {
     nodes: nodes3,
     edges: edges3,
@@ -487,6 +551,7 @@ function createSqliteTables(names = {}, options = {}) {
     schemaVersions: schemaVersions3,
     embeddings: embeddings3,
     indexMaterializations,
+    contributionMaterializations,
     kindRemovals,
     reconciliationMarkers,
     /**
@@ -554,9 +619,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql14 = tryInlineSql(col);
-  if (sql14 !== void 0) {
-    return sql14;
+  const sql15 = tryInlineSql(col);
+  if (sql15 !== void 0) {
+    return sql15;
   }
   return "unknown";
 }
@@ -627,21 +692,35 @@ function generateSqliteCreateIndexSQL(table) {
   return statements;
 }
 function isSqliteTable(value) {
-  return typeof value === "object" && value !== null && // Drizzle tables are always objects; strings are our escape hatch.
-  typeof value !== "string";
+  return is(value, SQLiteTable);
 }
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
-  const statements = [];
-  for (const table of Object.values(tables3)) {
+function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
+  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
+}
+function sqliteContributions(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
-    statements.push(generateSqliteCreateTableSQL(table));
+    contributions.push({
+      logicalName: key,
+      owner: BASE_CONTRIBUTION_OWNER,
+      tableName: getTableConfig(table).name,
+      createDdl: [
+        generateSqliteCreateTableSQL(table),
+        ...generateSqliteCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
   }
-  for (const table of Object.values(tables3)) {
-    if (!isSqliteTable(table)) continue;
-    statements.push(...generateSqliteCreateIndexSQL(table));
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
   }
-  statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
-  return statements;
+  return contributions;
+}
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
 }
 function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
@@ -726,20 +805,33 @@ function generatePgCreateIndexSQL(table) {
   return statements;
 }
 function isPgTable(value) {
-  return typeof value === "object" && value !== null && typeof value !== "string";
+  return is(value, PgTable);
 }
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
-  const statements = [];
-  for (const table of Object.values(tables3)) {
+function postgresContributions(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
     if (!isPgTable(table)) continue;
-    statements.push(generatePgCreateTableSQL(table));
+    if (table === tables3.fulltext) continue;
+    contributions.push({
+      logicalName: key,
+      owner: BASE_CONTRIBUTION_OWNER,
+      tableName: getTableConfig$1(table).name,
+      createDdl: [
+        generatePgCreateTableSQL(table),
+        ...generatePgCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
   }
-  for (const table of Object.values(tables3)) {
-    if (!isPgTable(table)) continue;
-    statements.push(...generatePgCreateIndexSQL(table));
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
   }
-  statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
-  return statements;
+  return contributions;
+}
+function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
 }
 function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
   const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
@@ -794,6 +886,16 @@ function formatPostgresTimestamp(value) {
   }
   return void 0;
 }
+function coerceNumericScore(value) {
+  if (typeof value === "number") return value;
+  const parsed = Number.parseFloat(value);
+  if (Number.isNaN(parsed)) {
+    throw new TypeError(
+      `Backend returned non-numeric fulltext score: ${JSON.stringify(value)}`
+    );
+  }
+  return parsed;
+}
 function normalizeJsonColumn(value) {
   return typeof value === "string" ? value : JSON.stringify(value ?? {});
 }
@@ -878,6 +980,222 @@ function createSchemaVersionRowMapper(config) {
     };
   };
 }
+var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
+  decode: (value) => typeof value === "string" ? value : void 0,
+  encode: (value) => value
+};
+var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
+  decode: formatPostgresTimestamp,
+  encode: (value) => new Date(value)
+};
+function mapContributionMaterializationRow(row, decode) {
+  const lastAttemptedAt = decode(row.lastAttemptedAt);
+  if (lastAttemptedAt === void 0) {
+    throw new Error(
+      `contribution materialization row missing required last_attempted_at: ${row.graphId}/${row.logicalName}`
+    );
+  }
+  return {
+    graphId: row.graphId,
+    logicalName: row.logicalName,
+    owner: row.owner,
+    tableName: row.tableName,
+    signature: row.signature,
+    materializedAt: decode(row.materializedAt),
+    lastAttemptedAt,
+    lastError: row.lastError ?? void 0
+  };
+}
+function buildContributionInsertValues(params, encode) {
+  return {
+    graphId: params.graphId,
+    logicalName: params.logicalName,
+    owner: params.owner,
+    tableName: params.tableName,
+    signature: params.signature,
+    materializedAt: params.materializedAt === void 0 ? void 0 : encode(params.materializedAt),
+    lastAttemptedAt: encode(params.attemptedAt),
+    lastError: params.error
+  };
+}
+function buildContributionOnConflictSet(materializedAtColumn, paramsMaterializedAt) {
+  const materializedAtSet = paramsMaterializedAt === void 0 ? sql`COALESCE(excluded.${sql.identifier("materialized_at")}, ${materializedAtColumn})` : sql`excluded.${sql.identifier("materialized_at")}`;
+  return {
+    signature: sql`excluded.${sql.identifier("signature")}`,
+    materializedAt: materializedAtSet,
+    lastAttemptedAt: sql`excluded.${sql.identifier("last_attempted_at")}`,
+    lastError: sql`excluded.${sql.identifier("last_error")}`
+  };
+}
+async function computeContributionSignature(dialect, identity, createDdl) {
+  const hashable = {
+    dialect,
+    owner: identity.owner,
+    logicalName: identity.logicalName,
+    tableName: identity.tableName,
+    createDdl
+  };
+  return sha256Hex(JSON.stringify(hashable, sortedReplacer), 16);
+}
+function evaluateContributionState(row, signature) {
+  if (row === void 0) return "missing";
+  if (row.lastError !== void 0) return "failed";
+  if (row.signature !== signature) return "stale";
+  if (row.materializedAt === void 0) return "missing";
+  return "initialized";
+}
+function identityOf(graphId, contribution) {
+  return {
+    graphId,
+    logicalName: contribution.logicalName,
+    owner: contribution.owner,
+    tableName: contribution.tableName
+  };
+}
+function gateFulltextMethods(source, assert) {
+  const gated = {};
+  if (source.upsertFulltext) {
+    const raw = source.upsertFulltext;
+    gated.upsertFulltext = async (params) => {
+      await assert(params.graphId);
+      await raw(params);
+    };
+  }
+  if (source.deleteFulltext) {
+    const raw = source.deleteFulltext;
+    gated.deleteFulltext = async (params) => {
+      await assert(params.graphId);
+      await raw(params);
+    };
+  }
+  if (source.upsertFulltextBatch) {
+    const raw = source.upsertFulltextBatch;
+    gated.upsertFulltextBatch = async (params) => {
+      if (params.rows.length === 0) return;
+      await assert(params.graphId);
+      await raw(params);
+    };
+  }
+  if (source.deleteFulltextBatch) {
+    const raw = source.deleteFulltextBatch;
+    gated.deleteFulltextBatch = async (params) => {
+      if (params.nodeIds.length === 0) return;
+      await assert(params.graphId);
+      await raw(params);
+    };
+  }
+  if (source.fulltextSearch) {
+    const raw = source.fulltextSearch;
+    gated.fulltextSearch = async (params) => {
+      await assert(params.graphId);
+      return raw(params);
+    };
+  }
+  const rawHardDelete = source.hardDeleteNode;
+  gated.hardDeleteNode = async (params) => {
+    await assert(params.graphId);
+    await rawHardDelete(params);
+  };
+  return gated;
+}
+function gateFulltext(tx, assert) {
+  return { ...tx, ...gateFulltextMethods(tx, assert) };
+}
+function createContributionMaterializer(deps) {
+  const { dialect, fulltextStrategy, fulltextTableName } = deps;
+  const initializedGraphIds = /* @__PURE__ */ new Set();
+  function runtimeContributions() {
+    return runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+  }
+  async function materializeOne(graphId, contribution) {
+    const signature = await computeContributionSignature(
+      dialect,
+      contribution,
+      contribution.createDdl
+    );
+    const identity = identityOf(graphId, contribution);
+    const existing = await deps.getMarker(identity);
+    if (evaluateContributionState(existing, signature) === "initialized") {
+      return;
+    }
+    const priorSuccess = existing?.materializedAt !== void 0;
+    if (priorSuccess && existing.signature !== signature) {
+      const error = new Error(
+        `Contribution "${contribution.logicalName}" (owner "${contribution.owner}", table "${contribution.tableName}") was already materialized with a different signature. The recorded physical shape is stale relative to the current strategy/DDL \u2014 migrate or drop the table and retry, or restore the original strategy.`
+      );
+      await deps.recordMarker({
+        ...identity,
+        signature,
+        attemptedAt: nowIso(),
+        materializedAt: void 0,
+        error: error.message
+      });
+      throw error;
+    }
+    const attemptedAt = nowIso();
+    try {
+      for (const statement of contribution.createDdl) {
+        await deps.execDdl(statement);
+      }
+    } catch (error) {
+      await deps.recordMarker({
+        ...identity,
+        signature,
+        attemptedAt,
+        materializedAt: void 0,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    await deps.recordMarker({
+      ...identity,
+      signature,
+      attemptedAt,
+      materializedAt: attemptedAt,
+      error: void 0
+    });
+  }
+  async function ensureRuntimeContributions(graphId) {
+    if (initializedGraphIds.has(graphId)) return;
+    const contributions = runtimeContributions();
+    if (contributions.length > 0) {
+      await deps.ensureMarkerTable();
+      for (const contribution of contributions) {
+        await materializeOne(graphId, contribution);
+      }
+    }
+    initializedGraphIds.add(graphId);
+  }
+  async function assertInitialized(graphId) {
+    if (initializedGraphIds.has(graphId)) return;
+    for (const contribution of runtimeContributions()) {
+      const signature = await computeContributionSignature(
+        dialect,
+        contribution,
+        contribution.createDdl
+      );
+      const identity = identityOf(graphId, contribution);
+      let existing;
+      try {
+        existing = await deps.getMarker(identity);
+      } catch (error) {
+        if (!isMissingTableError(error)) throw error;
+        throw new StoreNotInitializedError(graphId, "missing", {
+          cause: error,
+          details: { logicalName: contribution.logicalName }
+        });
+      }
+      const state = evaluateContributionState(existing, signature);
+      if (state !== "initialized") {
+        throw new StoreNotInitializedError(graphId, state, {
+          details: { logicalName: contribution.logicalName }
+        });
+      }
+    }
+    initializedGraphIds.add(graphId);
+  }
+  return { ensureRuntimeContributions, assertInitialized };
+}
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
   decode: (value) => typeof value === "string" ? value : void 0,
   encode: (value) => value
@@ -977,8 +1295,14 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
-
-// src/backend/drizzle/operation-backend-core.ts
+function assertAdoptedDialect(externalTx, brand, backend) {
+  if (is(externalTx, brand)) return;
+  const label = backend === "postgres" ? "Postgres" : "SQLite";
+  throw new ConfigurationError(
+    `adoptTransaction received a handle that is not a ${label} Drizzle transaction. Pass the \`tx\` from a ${label} \`db.transaction(...)\` opened on this backend's connection.`,
+    { backend, capability: "adoptTransaction" }
+  );
+}
 function chunkArray(values, size) {
   if (values.length <= size) {
     return [values];
@@ -1351,9 +1675,9 @@ 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}`,
@@ -2649,6 +2973,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-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, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, getOrCreateLru, mapKindRemovalRow, mapMaterializationRow, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
-//# sourceMappingURL=chunk-WI5VRP3X.js.map
-//# sourceMappingURL=chunk-WI5VRP3X.js.map
+export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, SQLITE_ROW_MAPPER_CONFIG, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, coerceNumericScore, compileQueryWithDialect, createCommonOperationBackend, createContributionMaterializer, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
+//# sourceMappingURL=chunk-RF5EUQWS.js.map
+//# sourceMappingURL=chunk-RF5EUQWS.js.map