@nicia-ai/typegraph 0.37.0 → 0.38.0

package/dist/{chunk-K3Q3LJY3.js → chunk-G32AO634.js}

@@ -1,14 +1,16 @@
-import { tables } from './chunk-UXLSNRYL.js';
-import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-QERAIDRJ.js';
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-M6VES7V6.js';
+import { tables } from './chunk-MTNEGGM2.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-AOL64O4Z.js';
+import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, toDrizzleSql } from './chunk-Z2PPIVOO.js';
+import { chunk } from './chunk-35S6P5ZU.js';
+import { createBackendOverlay } from './chunk-PZHC5GCD.js';
 import { sortedReplacer } from './chunk-UR7W5YQK.js';
-import { assertNoSystemIndexNameCollision } from './chunk-YTSN73ND.js';
-import { sha256Hex } from './chunk-W63OVYY4.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-EXU3RASM.js';
-import { createBackendOverlay, chunk, asCompiledStatementSql, isPresent, sqlValueList } from './chunk-44TA22QT.js';
-import { parseDimensionMismatch, isMissingTableError } from './chunk-XGPUQ56G.js';
-import { liveNodeIdsSubquery, quotedTableName, quotedColumn, codePointOrderKey, edgeColumnList, sqlNull, resolveValidFrom, nodeColumnList } from './chunk-OHMP6N2J.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, StaleVersionError, StoreNotInitializedError } from './chunk-5PNMDJ7J.js';
+import { parseDimensionMismatch, isMissingTableError } from './chunk-KFLXWVUJ.js';
+import { assertNoSystemIndexNameCollision } from './chunk-BQITNFQJ.js';
+import { sha256Hex } from './chunk-K34OPSJK.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-Y7M44XEK.js';
+import { sql as sql$1, asCompiledStatementSql, isSqlFragment } from './chunk-6XDBRDZE.js';
+import { isPresent } from './chunk-QMQLUA66.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, StaleVersionError, StoreNotInitializedError } from './chunk-DPNA466P.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 { getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
@@ -99,7 +101,9 @@ function createPostgresTables(names = {}, options = {}) {
       createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
       updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
       deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedFrom: timestamp("recorded_from", {
+        withTimezone: true
+      }).notNull(),
       recordedTo: timestamp("recorded_to", { withTimezone: true }).notNull(),
       op: text("op").notNull(),
       schemaVersion: integer("schema_version"),
@@ -128,7 +132,9 @@ function createPostgresTables(names = {}, options = {}) {
       createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
       updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
       deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedFrom: timestamp("recorded_from", {
+        withTimezone: true
+      }).notNull(),
       recordedTo: timestamp("recorded_to", { withTimezone: true }).notNull(),
       op: text("op").notNull(),
       schemaVersion: integer("schema_version"),
@@ -366,9 +372,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql15 = tryInlineSql(col);
-  if (sql15 !== void 0) {
-    return sql15;
+  const sql16 = tryInlineSql(col);
+  if (sql16 !== void 0) {
+    return sql16;
   }
   return "unknown";
 }
@@ -589,6 +595,20 @@ function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = tsve
 ${ddlSql}`;
 }
 
+// src/backend/live-node-candidates.ts
+function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
+  const nodes2 = sql$1.identifier(nodesTableName);
+  return sql$1`
+    SELECT "id" AS node_id
+    FROM ${nodes2}
+    WHERE "graph_id" = ${graphId}
+      AND "kind" = ${nodeKind}
+      AND "deleted_at" IS NULL
+      AND ("valid_from" IS NULL OR "valid_from" <= ${now})
+      AND ("valid_to" IS NULL OR "valid_to" > ${now})
+  `;
+}
+
 // src/backend/drizzle/vector-runtime.ts
 var VECTOR_SLOT_PLACEHOLDER_DIMENSIONS = 1;
 var EMBEDDING_UPSERT_PARAM_COUNT = 5;
@@ -708,21 +728,21 @@ function identityOf(graphId, contribution) {
 function gateFulltextMethods(source, assert) {
   const gated = {};
   if (source.upsertFulltext) {
-    const raw = source.upsertFulltext.bind(source);
+    const raw = source.upsertFulltext;
     gated.upsertFulltext = async (params) => {
       await assert(params.graphId);
       await raw(params);
     };
   }
   if (source.deleteFulltext) {
-    const raw = source.deleteFulltext.bind(source);
+    const raw = source.deleteFulltext;
     gated.deleteFulltext = async (params) => {
       await assert(params.graphId);
       await raw(params);
     };
   }
   if (source.upsertFulltextBatch) {
-    const raw = source.upsertFulltextBatch.bind(source);
+    const raw = source.upsertFulltextBatch;
     gated.upsertFulltextBatch = async (params) => {
       if (params.rows.length === 0) return;
       await assert(params.graphId);
@@ -730,7 +750,7 @@ function gateFulltextMethods(source, assert) {
     };
   }
   if (source.deleteFulltextBatch) {
-    const raw = source.deleteFulltextBatch.bind(source);
+    const raw = source.deleteFulltextBatch;
     gated.deleteFulltextBatch = async (params) => {
       if (params.nodeIds.length === 0) return;
       await assert(params.graphId);
@@ -738,13 +758,13 @@ function gateFulltextMethods(source, assert) {
     };
   }
   if (source.fulltextSearch) {
-    const raw = source.fulltextSearch.bind(source);
+    const raw = source.fulltextSearch;
     gated.fulltextSearch = async (params) => {
       await assert(params.graphId);
       return raw(params);
     };
   }
-  const rawHardDelete = source.hardDeleteNode.bind(source);
+  const rawHardDelete = source.hardDeleteNode;
   gated.hardDeleteNode = async (params) => {
     await assert(params.graphId);
     await rawHardDelete(params);
@@ -1107,6 +1127,41 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
+function sqlNull(value) {
+  return value ?? sql.raw("NULL");
+}
+function resolveValidFrom(validFrom, timestamp2) {
+  if (validFrom === null) return void 0;
+  return validFrom ?? timestamp2;
+}
+function quotedColumn(column) {
+  return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function quotedTableName(tableName) {
+  return sql.raw(`"${tableName.replaceAll('"', '""')}"`);
+}
+var CODE_POINT_ORDER_BUILDERS = {
+  postgres: (value) => sql`${value} COLLATE "C"`,
+  sqlite: (value) => value
+};
+function codePointOrderKey(column, dialect) {
+  return CODE_POINT_ORDER_BUILDERS[dialect](column);
+}
+function liveNodeIdsSubquery(nodes2, graphId, nodeKind, nowIso2) {
+  return sql`SELECT ${nodes2.id} AS node_id FROM ${nodes2} WHERE ${nodes2.graphId} = ${graphId} AND ${nodes2.kind} = ${nodeKind} AND ${nodes2.deletedAt} IS NULL AND (${nodes2.validFrom} IS NULL OR ${nodes2.validFrom} <= ${nowIso2}) AND (${nodes2.validTo} IS NULL OR ${nodes2.validTo} > ${nowIso2})`;
+}
+function nodeColumnList(nodes2) {
+  return sql.raw(
+    `"${nodes2.graphId.name}", "${nodes2.kind.name}", "${nodes2.id.name}", "${nodes2.props.name}", "${nodes2.version.name}", "${nodes2.validFrom.name}", "${nodes2.validTo.name}", "${nodes2.createdAt.name}", "${nodes2.updatedAt.name}"`
+  );
+}
+function edgeColumnList(edges2) {
+  return sql.raw(
+    `"${edges2.graphId.name}", "${edges2.id.name}", "${edges2.kind.name}", "${edges2.fromKind.name}", "${edges2.fromId.name}", "${edges2.toKind.name}", "${edges2.toId.name}", "${edges2.props.name}", "${edges2.validFrom.name}", "${edges2.validTo.name}", "${edges2.createdAt.name}", "${edges2.updatedAt.name}"`
+  );
+}
+
+// src/backend/drizzle/operations/hybrid.ts
 function nodeIdOrderKey(dialect) {
   return codePointOrderKey(sql.raw("node_id"), dialect);
 }
@@ -1198,16 +1253,16 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: coerceNumericScore(row.fused_score),
-    ...present(row.vector_rank) ? { vectorRank: Number(row.vector_rank) } : {},
-    ...present(row.vector_score) ? { vectorScore: coerceNumericScore(row.vector_score) } : {},
-    ...present(row.fulltext_rank) ? { fulltextRank: Number(row.fulltext_rank) } : {},
-    ...present(row.fulltext_score) ? {
+    fusedScore: coerceNumericScore(row["fused_score"]),
+    ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
+    ...present(row["fulltext_score"]) ? {
       fulltextScore: coerceNumericScore(
-        row.fulltext_score
+        row["fulltext_score"]
       )
     } : {},
-    ...present(row.snippet) ? { snippet: String(row.snippet) } : {}
+    ...present(row["snippet"]) ? { snippet: String(row["snippet"]) } : {}
   };
 }
 function buildClearGraph(tables3, graphId) {
@@ -1261,9 +1316,7 @@ function buildTemporalConditions(table, params) {
   }
   if (mode === "current" || mode === "asOf") {
     if (params.asOf === void 0) {
-      throw new Error(
-        `asOf timestamp is required for temporal mode "${mode}"`
-      );
+      throw new Error(`asOf timestamp is required for temporal mode "${mode}"`);
     }
     conditions.push(
       sql`(${table.validFrom} IS NULL OR ${table.validFrom} <= ${params.asOf})`,
@@ -1457,7 +1510,10 @@ function buildGetEdges(tables3, graphId, ids) {
   return sql`
     SELECT * FROM ${edges2}
     WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${sqlValueList(ids)})
+      AND ${edges2.id} IN (${sql.join(
+    ids.map((id) => sql`${id}`),
+    sql`, `
+  )})
   `;
 }
 function buildUpdateEdge(tables3, params, timestamp2) {
@@ -1508,7 +1564,10 @@ function buildDeleteEdgesBatch(tables3, params, timestamp2) {
     UPDATE ${edges2}
     SET ${quotedColumn(edges2.deletedAt)} = ${timestamp2}
     WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${sqlValueList(params.ids)})
+      AND ${edges2.id} IN (${sql.join(
+    params.ids.map((id) => sql`${id}`),
+    sql`, `
+  )})
       AND ${edges2.deletedAt} IS NULL
   `;
 }
@@ -1517,7 +1576,10 @@ function buildHardDeleteEdgesBatch(tables3, params) {
   return sql`
     DELETE FROM ${edges2}
     WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${sqlValueList(params.ids)})
+      AND ${edges2.id} IN (${sql.join(
+    params.ids.map((id) => sql`${id}`),
+    sql`, `
+  )})
   `;
 }
 function buildHardDeleteEdge(tables3, params) {
@@ -1602,17 +1664,13 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
-  const matchCondition = strategy.matchCondition(
-    tableName,
-    params.query,
-    mode,
-    params.language
+  const matchCondition = toDrizzleSql(
+    strategy.matchCondition(tableName, params.query, mode, params.language),
+    dialect
   );
-  const rankExpression = strategy.rankExpression(
-    tableName,
-    params.query,
-    mode,
-    params.language
+  const rankExpression = toDrizzleSql(
+    strategy.rankExpression(tableName, params.query, mode, params.language),
+    dialect
   );
   const conditions = [
     matchCondition,
@@ -1623,13 +1681,17 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    conditions.push(sql`"node_id" IN (${candidates})`);
-  }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? strategy.snippetExpression(
-    tableName,
-    params.query,
-    mode,
-    params.language
+    const candidateSql = isSqlFragment(candidates) ? toDrizzleSql(candidates, dialect) : candidates;
+    conditions.push(sql`"node_id" IN (${candidateSql})`);
+  }
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? toDrizzleSql(
+    strategy.snippetExpression(
+      tableName,
+      params.query,
+      mode,
+      params.language
+    ),
+    dialect
   ) : sql`NULL`;
   const pageClause = params.offset === void 0 || params.offset === 0 ? sql`LIMIT ${params.limit}` : sql`LIMIT ${params.limit} OFFSET ${params.offset}`;
   return sql`
@@ -1720,7 +1782,10 @@ function buildGetNodes(tables3, graphId, kind, ids) {
     SELECT * FROM ${nodes2}
     WHERE ${nodes2.graphId} = ${graphId}
       AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${sqlValueList(ids)})
+      AND ${nodes2.id} IN (${sql.join(
+    ids.map((id) => sql`${id}`),
+    sql`, `
+  )})
   `;
 }
 function buildUpdateNode(tables3, params, timestamp2) {
@@ -1783,8 +1848,13 @@ function buildHardDeleteNode(tables3, params) {
   `;
 }
 function createSchemaDialectStrategy(dialect) {
-  const trueLiteral = dialect === "sqlite" ? sql.raw("1") : sql.raw("TRUE");
-  const falseLiteral = dialect === "sqlite" ? sql.raw("0") : sql.raw("FALSE");
+  const literals = {
+    postgres: { false: "FALSE", true: "TRUE" },
+    sqlite: { false: "0", true: "1" }
+  };
+  const dialectLiterals = literals[dialect];
+  const trueLiteral = sql.raw(dialectLiterals.true);
+  const falseLiteral = sql.raw(dialectLiterals.false);
   return {
     booleanLiteral(value) {
       return value ? trueLiteral : falseLiteral;
@@ -1800,7 +1870,9 @@ function buildInsertSchema(tables3, params, timestamp2, dialect = "sqlite") {
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const schemaDocumentJson = JSON.stringify(params.schemaDoc);
   const isActiveValue = strategy.booleanLiteral(params.isActive);
-  const columns = sql.raw(`"${schemaVersions2.graphId.name}", "${schemaVersions2.version.name}", "${schemaVersions2.schemaHash.name}", "${schemaVersions2.schemaDoc.name}", "${schemaVersions2.createdAt.name}", "${schemaVersions2.isActive.name}"`);
+  const columns = sql.raw(
+    `"${schemaVersions2.graphId.name}", "${schemaVersions2.version.name}", "${schemaVersions2.schemaHash.name}", "${schemaVersions2.schemaDoc.name}", "${schemaVersions2.createdAt.name}", "${schemaVersions2.isActive.name}"`
+  );
   return sql`
     INSERT INTO ${schemaVersions2} (${columns})
     VALUES (
@@ -1846,8 +1918,12 @@ function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
 }
 function buildInsertUniqueSqlite(tables3, params) {
   const { uniques: uniques2 } = tables3;
-  const columns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`);
-  const conflictColumns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
+  const columns = sql.raw(
+    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
+  );
   return sql`
     INSERT INTO ${uniques2} (${columns})
     VALUES (
@@ -1876,8 +1952,12 @@ function buildInsertUniqueSqlite(tables3, params) {
 }
 function buildInsertUniquePostgres(tables3, params) {
   const { uniques: uniques2 } = tables3;
-  const columns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`);
-  const conflictColumns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
+  const columns = sql.raw(
+    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
+  );
   const tableName = getTableName(uniques2);
   const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
   return sql`
@@ -1923,7 +2003,19 @@ function buildInsertUniqueBatch(tables3, dialect, entries) {
     `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
   );
   const tableName = getTableName(uniques2);
-  const existingColumn = (column) => dialect === "postgres" ? sql.raw(`"${tableName}"."${column.name}"`) : sql.raw(`"${column.name}"`);
+  const existingColumn = (column) => {
+    switch (dialect) {
+      case "postgres": {
+        return sql.raw(`"${tableName}"."${column.name}"`);
+      }
+      case "sqlite": {
+        return sql.raw(`"${column.name}"`);
+      }
+      default: {
+        return dialect;
+      }
+    }
+  };
   const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
   const valueRows = sql.join(
     entries.map(
@@ -2031,7 +2123,9 @@ function bindTableOperationBuilders(tables3, builders) {
     }
     return [name, boundBuilder];
   });
-  return Object.fromEntries(boundEntries);
+  return Object.fromEntries(
+    boundEntries
+  );
 }
 var COMMON_TABLE_OPERATION_BUILDERS = {
   buildInsertNode,
@@ -2075,15 +2169,15 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
   );
   const fulltextTable = tables3.fulltextTableName;
   const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params),
+    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }),
-    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params),
+    }).map((statement) => toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -2091,9 +2185,13 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       dialect,
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
-      params.candidates ?? liveNodeIdsSubquery(tables3.nodes, params.graphId, params.nodeKind, nowIso())
+      params.candidates ?? liveNodeIdsSubquery(
+        tables3.nodes,
+        params.graphId,
+        params.nodeKind,
+        nowIso()
+      )
     ),
-    buildLiveNodeIds: (graphId, nodeKind) => liveNodeIdsSubquery(tables3.nodes, graphId, nodeKind, nowIso()),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
       const candidates = params.candidates ?? liveNodeIdsSubquery(
         tables3.nodes,
@@ -2120,7 +2218,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: candidates,
+        candidatesSql: isSqlFragment(candidates) ? toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -2155,17 +2253,24 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       return buildSetActiveSchema(tables3, graphId, version, dialect);
     },
     buildTableExists(tableName) {
-      if (dialect === "postgres") {
-        return sql`
-          SELECT c.relname AS table_name
-          FROM pg_catalog.pg_class AS c
-          WHERE c.relname = ${tableName}
-            AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
-            AND pg_catalog.pg_table_is_visible(c.oid)
-          LIMIT 1
-        `;
+      switch (dialect) {
+        case "postgres": {
+          return sql`
+            SELECT c.relname AS table_name
+            FROM pg_catalog.pg_class AS c
+            WHERE c.relname = ${tableName}
+              AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
+              AND pg_catalog.pg_table_is_visible(c.oid)
+            LIMIT 1
+          `;
+        }
+        case "sqlite": {
+          return sql`SELECT name AS table_name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ${tableName}`;
+        }
+        default: {
+          return dialect;
+        }
       }
-      return sql`SELECT name AS table_name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ${tableName}`;
     },
     buildClearGraph(graphId) {
       return buildClearGraph(tables3, graphId);
@@ -2200,9 +2305,13 @@ function createSqliteOperationStrategy(tables3, fulltextStrategy) {
 function createPostgresOperationStrategy(tables3, fulltextStrategy) {
   return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
 }
+var DRIZZLE_DIALECT_LABELS = {
+  postgres: "Postgres",
+  sqlite: "SQLite"
+};
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (is(externalTx, brand)) return;
-  const label = backend === "postgres" ? "Postgres" : "SQLite";
+  const label = DRIZZLE_DIALECT_LABELS[backend];
   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" }
@@ -2691,6 +2800,8 @@ function createCommonOperationBackend(options) {
     }
   };
 }
+
+// src/backend/drizzle/trusted-import.ts
 var DATABASE_NULL = null;
 function quoteSqlIdentifier(identifier) {
   return `"${identifier.replaceAll('"', '""')}"`;
@@ -2715,7 +2826,7 @@ function requireStatementExecution(backend) {
 }
 function rowIndicatesExistingData(row) {
   if (typeof row !== "object" || row === null) return false;
-  const value = row.has_rows;
+  const value = row["has_rows"];
   return value === true || value === 1 || value === "1";
 }
 async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
@@ -2741,7 +2852,7 @@ async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
     asCompiledStatementSql(
-      sql.raw(
+      sql$1.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -2762,7 +2873,7 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   for (const definition of definitions) {
     await executeStatement(
       asCompiledStatementSql(
-        sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+        sql$1.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2793,7 +2904,7 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   for (const definition of definitions) {
     await executeStatement(
       asCompiledStatementSql(
-        sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+        sql$1.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2803,7 +2914,7 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      asCompiledStatementSql(sql.raw(definition.index_definition))
+      asCompiledStatementSql(sql$1.raw(definition.index_definition))
     );
   }
 }
@@ -2811,12 +2922,12 @@ async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
     asCompiledStatementSql(
-      sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+      sql$1.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
     asCompiledStatementSql(
-      sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+      sql$1.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
@@ -2959,16 +3070,6 @@ function getOrCreateLru(cache, key, cacheMax, create) {
   return value;
 }
 
-// src/backend/drizzle/execution/types.ts
-function compileQueryWithDialect(db, query, backendName) {
-  const databaseWithCompiler = db;
-  const compiler = databaseWithCompiler.dialect;
-  if (compiler === void 0) {
-    throw new Error(`${backendName} backend is missing a SQL compiler`);
-  }
-  return compiler.sqlToQuery(query);
-}
-
-export { EMBEDDING_UPSERT_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, hybridCandidatesRef, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, restoreSecondaryIndexes, schemaVersions, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-K3Q3LJY3.js.map
-//# sourceMappingURL=chunk-K3Q3LJY3.js.map
+export { EMBEDDING_UPSERT_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, restoreSecondaryIndexes, schemaVersions, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-G32AO634.js.map
+//# sourceMappingURL=chunk-G32AO634.js.map