@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/{chunk-RY2VIWAM.js → chunk-WDBCBWC4.js}

@@ -1,13 +1,13 @@
-import { tables } from './chunk-CYX2JTDG.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-6GNSY7AV.js';
-import { formatPostgresTimestamp, nowIso } from './chunk-QV245VMN.js';
+import { tables } from './chunk-VHMPG6UL.js';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-6FR2MMS6.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-55MZDDZV.js';
 import { sortedReplacer } from './chunk-UR7W5YQK.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-KUTNI6SI.js';
-import { sha256Hex } from './chunk-K34OPSJK.js';
-import { createBackendOverlay, chunk, isPresent, sqlValueList } from './chunk-V3QNTB7Z.js';
-import { parseDimensionMismatch, isMissingTableError } from './chunk-2MRAX3UE.js';
-import { quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-GZCNZ7QW.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-TQOYM4LN.js';
+import { sha256Hex } from './chunk-W63OVYY4.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-FPIZFYHE.js';
+import { createBackendOverlay, chunk, isPresent, sqlValueList } from './chunk-JBTOYDMN.js';
+import { parseDimensionMismatch, isMissingTableError } from './chunk-I7ZUZKFD.js';
+import { liveNodeIdsSubquery, quotedTableName, quotedColumn, codePointOrderKey, edgeColumnList, sqlNull, resolveValidFrom, nodeColumnList } from './chunk-OHMP6N2J.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-MP2JQKSG.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';
@@ -26,6 +26,7 @@ var DEFAULT_TABLE_NAMES = {
   recordedNodes: "typegraph_recorded_nodes",
   recordedEdges: "typegraph_recorded_edges",
   recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
   fulltext: "typegraph_node_fulltext",
@@ -86,7 +87,13 @@ function createPostgresTables(names = {}, options = {}) {
       primaryKey({ columns: [t.graphId, t.id] }),
       index(`${n.edges}_kind_idx`).on(t.graphId, t.kind),
       // Directional traversal index (outgoing): supports endpoint lookups
-      // and extra filtering by edge kind / target kind.
+      // and extra filtering by edge kind / target kind. Includes every
+      // system column the compiled query's soft-delete/temporal-validity
+      // predicate touches (deleted_at, valid_from, valid_to), trailed by
+      // to_id — the compiled traversal join reads `n.id = e.to_id` for an
+      // outgoing traversal (standard-builders.ts), so without to_id here
+      // the join still fetches the edge's heap row for that one column
+      // even with the seek/predicate columns covered.
       index(`${n.edges}_from_idx`).on(
         t.graphId,
         t.fromKind,
@@ -94,9 +101,13 @@ function createPostgresTables(names = {}, options = {}) {
         t.kind,
         t.toKind,
         t.deletedAt,
-        t.validTo
+        t.validFrom,
+        t.validTo,
+        t.toId
       ),
-      // Directional traversal index (incoming): mirrors from_idx for reverse traversals.
+      // Directional traversal index (incoming): mirrors from_idx for
+      // reverse traversals, trailed by from_id for the same reason
+      // (`n.id = e.from_id` for an incoming traversal).
       index(`${n.edges}_to_idx`).on(
         t.graphId,
         t.toKind,
@@ -104,7 +115,9 @@ function createPostgresTables(names = {}, options = {}) {
         t.kind,
         t.fromKind,
         t.deletedAt,
-        t.validTo
+        t.validFrom,
+        t.validTo,
+        t.fromId
       ),
       index(`${n.edges}_kind_created_idx`).on(
         t.graphId,
@@ -229,6 +242,14 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [primaryKey({ columns: [t.graphId] })]
   );
+  const revisionOrigins = pgTable(
+    n.revisionOrigins,
+    {
+      graphId: text("graph_id").notNull(),
+      origin: text("origin").notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
   const uniques2 = pgTable(
     n.uniques,
     {
@@ -281,7 +302,14 @@ function createPostgresTables(names = {}, options = {}) {
       lastAttemptedAt: timestamp("last_attempted_at", {
         withTimezone: true
       }).notNull(),
-      lastError: text("last_error")
+      lastError: text("last_error"),
+      // Cross-caller build claim: while `building_since` is fresh (within
+      // the lease), exactly one materializer owns this index's CREATE
+      // INDEX CONCURRENTLY. Serializes same-index CIC across processes —
+      // two concurrent expression-index CICs deadlock each other (no
+      // safe-snapshot exemption). NULL when no build is in flight.
+      buildingSince: timestamp("building_since", { withTimezone: true }),
+      claimToken: text("claim_token")
     },
     (t) => [primaryKey({ columns: [t.indexName] })]
   );
@@ -355,6 +383,7 @@ function createPostgresTables(names = {}, options = {}) {
     recordedNodes: recordedNodes2,
     recordedEdges: recordedEdges2,
     recordedClock: recordedClock2,
+    revisionOrigins,
     uniques: uniques2,
     schemaVersions: schemaVersions2,
     indexMaterializations,
@@ -431,9 +460,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql13 = tryInlineSql(col);
-  if (sql13 !== void 0) {
-    return sql13;
+  const sql14 = tryInlineSql(col);
+  if (sql14 !== void 0) {
+    return sql14;
   }
   return "unknown";
 }
@@ -689,6 +718,7 @@ function createVectorSlotLatch() {
   };
 }
 var VECTOR_SLOT_PLACEHOLDER_DIMENSIONS = 1;
+var EMBEDDING_UPSERT_PARAM_COUNT = 5;
 function vectorSlotFromParams(params) {
   return {
     graphId: params.graphId,
@@ -1065,6 +1095,109 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
+function nodeIdOrderKey(dialect) {
+  return codePointOrderKey(sql.raw("node_id"), dialect);
+}
+function hybridCandidatesRef() {
+  return sql`SELECT node_id FROM tg_hybrid_cand`;
+}
+function buildHybridSearchStatement(input) {
+  const { nodes: nodes2 } = input;
+  const nodeIdOrder = nodeIdOrderKey(input.dialect);
+  const vectorOrder = input.vectorScoreDescending ? sql`score DESC, ${nodeIdOrder} ASC` : sql`score ASC, ${nodeIdOrder} ASC`;
+  const columnPairs = [
+    [nodes2.graphId, "graph_id"],
+    [nodes2.kind, "kind"],
+    [nodes2.id, "id"],
+    [nodes2.props, "props"],
+    [nodes2.version, "version"],
+    [nodes2.validFrom, "valid_from"],
+    [nodes2.validTo, "valid_to"],
+    [nodes2.createdAt, "created_at"],
+    [nodes2.updatedAt, "updated_at"],
+    [nodes2.deletedAt, "deleted_at"]
+  ];
+  const nodeColumns = sql.raw(
+    columnPairs.map(
+      ([column, alias]) => `tg_hybrid_node."${column.name.replaceAll('"', '""')}" AS ${alias}`
+    ).join(", ")
+  );
+  return sql`
+    WITH tg_hybrid_cand AS (
+      SELECT node_id FROM (${input.candidatesSql}) AS tg_hybrid_cand_src
+    ),
+    tg_hybrid_vec AS (
+      SELECT node_id, score,
+             ROW_NUMBER() OVER (ORDER BY ${vectorOrder}) AS ord
+      FROM (${input.vectorSql}) AS tg_hybrid_vec_src
+    ),
+    tg_hybrid_fts AS (
+      SELECT node_id, score, snippet,
+             ROW_NUMBER() OVER (ORDER BY score DESC, ${nodeIdOrder} ASC) AS ord
+      FROM (${input.fulltextSql}) AS tg_hybrid_fts_src
+    ),
+    tg_hybrid_pairs AS (
+      SELECT node_id, ord AS vector_rank, score AS vector_score,
+             NULL AS fulltext_rank, NULL AS fulltext_score, NULL AS snippet
+      FROM tg_hybrid_vec
+      UNION ALL
+      SELECT node_id, NULL, NULL, ord, score, snippet
+      FROM tg_hybrid_fts
+    ),
+    tg_hybrid_fused AS MATERIALIZED (
+      SELECT node_id,
+        SUM(
+          COALESCE((${input.vectorWeight} * 1.0) / (${input.fusionK} + vector_rank), 0)
+          + COALESCE((${input.fulltextWeight} * 1.0) / (${input.fusionK} + fulltext_rank), 0)
+        ) AS fused_score,
+        MAX(vector_rank) AS vector_rank,
+        MAX(vector_score) AS vector_score,
+        MAX(fulltext_rank) AS fulltext_rank,
+        MAX(fulltext_score) AS fulltext_score,
+        MAX(snippet) AS snippet
+      FROM tg_hybrid_pairs
+      GROUP BY node_id
+    )
+    SELECT
+      tg_hybrid_fused.node_id AS node_id,
+      tg_hybrid_fused.fused_score AS fused_score,
+      tg_hybrid_fused.vector_rank AS vector_rank,
+      tg_hybrid_fused.vector_score AS vector_score,
+      tg_hybrid_fused.fulltext_rank AS fulltext_rank,
+      tg_hybrid_fused.fulltext_score AS fulltext_score,
+      tg_hybrid_fused.snippet AS snippet,
+      ${nodeColumns}
+    FROM tg_hybrid_fused
+    JOIN ${nodes2} AS tg_hybrid_node
+      ON ${qualified(nodes2, "graphId")} = ${input.graphId}
+     AND ${qualified(nodes2, "kind")} = ${input.nodeKind}
+     AND ${qualified(nodes2, "id")} = tg_hybrid_fused.node_id
+     AND ${qualified(nodes2, "deletedAt")} IS NULL
+    ORDER BY fused_score DESC, ${nodeIdOrder} ASC
+    LIMIT ${input.limit} OFFSET ${input.offset}
+  `;
+}
+function qualified(nodes2, member) {
+  return sql`tg_hybrid_node.${quotedColumn(nodes2[member])}`;
+}
+function present(value) {
+  return value !== null && value !== void 0;
+}
+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) ? {
+      fulltextScore: coerceNumericScore(
+        row.fulltext_score
+      )
+    } : {},
+    ...present(row.snippet) ? { snippet: String(row.snippet) } : {}
+  };
+}
 function buildClearGraph(tables3, graphId) {
   const fulltext2 = quotedTableName(tables3.fulltextTableName);
   return [
@@ -1254,7 +1387,7 @@ function buildInsertEdge(tables3, params, timestamp2) {
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1269,7 +1402,7 @@ function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
@@ -1279,7 +1412,7 @@ function buildInsertEdgesBatch(tables3, params, timestamp2) {
   const columns = edgeColumnList(edges2);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveValidFrom(edgeParams.validFrom, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
     INSERT INTO ${edges2} (${columns})
@@ -1291,7 +1424,7 @@ function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
   const columns = edgeColumnList(edges2);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveValidFrom(edgeParams.validFrom, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
     INSERT INTO ${edges2} (${columns})
@@ -1357,6 +1490,24 @@ function buildDeleteEdge(tables3, params, timestamp2) {
       AND ${edges2.deletedAt} IS NULL
   `;
 }
+function buildDeleteEdgesBatch(tables3, params, timestamp2) {
+  const { edges: edges2 } = tables3;
+  return sql`
+    UPDATE ${edges2}
+    SET ${quotedColumn(edges2.deletedAt)} = ${timestamp2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.id} IN (${sqlValueList(params.ids)})
+      AND ${edges2.deletedAt} IS NULL
+  `;
+}
+function buildHardDeleteEdgesBatch(tables3, params) {
+  const { edges: edges2 } = tables3;
+  return sql`
+    DELETE FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.id} IN (${sqlValueList(params.ids)})
+  `;
+}
 function buildHardDeleteEdge(tables3, params) {
   const { edges: edges2 } = tables3;
   return sql`
@@ -1435,7 +1586,7 @@ function buildFindEdgesConnectedTo(tables3, params) {
 function resolveMode(mode) {
   return mode ?? "websearch";
 }
-function buildFulltextSearch(tableName, params, strategy) {
+function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
@@ -1459,12 +1610,16 @@ function buildFulltextSearch(tableName, params, strategy) {
   if (params.minScore !== void 0) {
     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
   ) : sql`NULL`;
+  const pageClause = params.offset === void 0 || params.offset === 0 ? sql`LIMIT ${params.limit}` : sql`LIMIT ${params.limit} OFFSET ${params.offset}`;
   return sql`
     SELECT
       "node_id" AS node_id,
@@ -1472,8 +1627,8 @@ function buildFulltextSearch(tableName, params, strategy) {
       ${snippetExpr} AS snippet
     FROM ${table}
     WHERE ${sql.join(conditions, sql` AND `)}
-    ORDER BY ${rankExpression} DESC, "node_id" ASC
-    LIMIT ${params.limit}
+    ORDER BY ${rankExpression} DESC, ${codePointOrderKey(sql.raw('"node_id"'), dialect)} ASC
+    ${pageClause}
   `;
 }
 function assertValidSearchParams(params) {
@@ -1494,7 +1649,7 @@ function buildInsertNode(tables3, params, timestamp2) {
     INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1508,7 +1663,7 @@ function buildInsertNodeNoReturn(tables3, params, timestamp2) {
     INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
@@ -1518,7 +1673,7 @@ function buildInsertNodesBatch(tables3, params, timestamp2) {
   const columns = nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
     INSERT INTO ${nodes2} (${columns})
@@ -1530,7 +1685,7 @@ function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
   const columns = nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
     INSERT INTO ${nodes2} (${columns})
@@ -1747,6 +1902,50 @@ function buildInsertUnique(tables3, dialect, params) {
   const builder = UNIQUE_INSERT_BUILDERS[dialect];
   return builder(tables3, params);
 }
+function buildInsertUniqueBatch(tables3, dialect, entries) {
+  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 tableName = getTableName(uniques2);
+  const existingColumn = (column) => dialect === "postgres" ? sql.raw(`"${tableName}"."${column.name}"`) : sql.raw(`"${column.name}"`);
+  const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
+  const valueRows = sql.join(
+    entries.map(
+      (params) => sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")})`
+    ),
+    sql`, `
+  );
+  return sql`
+    INSERT INTO ${uniques2} (${columns})
+    VALUES ${valueRows}
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques2.nodeId)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN ${excludedColumn(uniques2.nodeId)}
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques2.nodeId)}
+        ELSE ${existingColumn(uniques2.nodeId)}
+      END,
+      ${quotedColumn(uniques2.concreteKind)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN ${excludedColumn(uniques2.concreteKind)}
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques2.concreteKind)}
+        ELSE ${existingColumn(uniques2.concreteKind)}
+      END,
+      ${quotedColumn(uniques2.deletedAt)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN NULL
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques2.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques2.nodeKind)} as node_kind,
+      ${quotedColumn(uniques2.constraintName)} as constraint_name,
+      ${quotedColumn(uniques2.key)} as key,
+      ${quotedColumn(uniques2.nodeId)} as node_id
+  `;
+}
 function buildDeleteUnique(tables3, params, timestamp2) {
   const { uniques: uniques2 } = tables3;
   return sql`
@@ -1840,7 +2039,9 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildGetEdges,
   buildUpdateEdge,
   buildDeleteEdge,
+  buildDeleteEdgesBatch,
   buildHardDeleteEdge,
+  buildHardDeleteEdgesBatch,
   buildHardDeleteEdgesByNode,
   buildCountEdgesFrom,
   buildEdgeExistsBetween,
@@ -1871,7 +2072,57 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     }),
     buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2),
     buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params),
-    buildFulltextSearch: (params) => buildFulltextSearch(fulltextTable, params, fulltextStrategy)
+    buildFulltextSearch: (params) => buildFulltextSearch(
+      fulltextTable,
+      params,
+      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())
+    ),
+    buildLiveNodeIds: (graphId, nodeKind) => liveNodeIdsSubquery(tables3.nodes, graphId, nodeKind, nowIso()),
+    buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
+      const candidates = params.candidates ?? liveNodeIdsSubquery(
+        tables3.nodes,
+        params.graphId,
+        params.nodeKind,
+        nowIso()
+      );
+      const fulltextSql = buildFulltextSearch(
+        fulltextTable,
+        {
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          query: params.fulltext.query,
+          limit: params.fulltext.k,
+          ...params.fulltext.mode === void 0 ? {} : { mode: params.fulltext.mode },
+          ...params.fulltext.language === void 0 ? {} : { language: params.fulltext.language },
+          ...params.fulltext.minScore === void 0 ? {} : { minScore: params.fulltext.minScore },
+          ...params.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: params.fulltext.includeSnippets }
+        },
+        fulltextStrategy,
+        dialect,
+        // Reference, not copy: the statement evaluates the shared
+        // tg_hybrid_cand CTE once for both legs.
+        hybridCandidatesRef()
+      );
+      return buildHybridSearchStatement({
+        candidatesSql: candidates,
+        vectorSql,
+        vectorScoreDescending,
+        fulltextSql,
+        nodes: tables3.nodes,
+        dialect,
+        graphId: params.graphId,
+        nodeKind: params.nodeKind,
+        fusionK: params.fusion.k,
+        vectorWeight: params.fusion.vectorWeight,
+        fulltextWeight: params.fusion.fulltextWeight,
+        limit: params.limit,
+        offset: params.offset ?? 0
+      });
+    }
   };
   return {
     ...tableOperations,
@@ -1879,6 +2130,9 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     buildInsertUnique(params) {
       return buildInsertUnique(tables3, dialect, params);
     },
+    buildInsertUniqueBatch(entries) {
+      return buildInsertUniqueBatch(tables3, dialect, entries);
+    },
     buildGetActiveSchema(graphId) {
       return buildGetActiveSchema(tables3, graphId, dialect);
     },
@@ -2137,6 +2391,28 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildHardDeleteEdge(params);
       await execution.execRun(query);
     },
+    async deleteEdgesBatch(params) {
+      if (params.ids.length === 0) return;
+      const timestamp2 = nowIso2();
+      const softDeleteChunkSize = Math.max(1, batchConfig.getEdgesChunkSize - 1);
+      for (const chunk2 of chunk(params.ids, softDeleteChunkSize)) {
+        const query = operationStrategy.buildDeleteEdgesBatch(
+          { graphId: params.graphId, ids: chunk2 },
+          timestamp2
+        );
+        await execution.execRun(query);
+      }
+    },
+    async hardDeleteEdgesBatch(params) {
+      if (params.ids.length === 0) return;
+      for (const chunk2 of chunk(params.ids, batchConfig.getEdgesChunkSize)) {
+        const query = operationStrategy.buildHardDeleteEdgesBatch({
+          graphId: params.graphId,
+          ids: chunk2
+        });
+        await execution.execRun(query);
+      }
+    },
     async countEdgesFrom(params) {
       const query = operationStrategy.buildCountEdgesFrom(params);
       const row = await execution.execGet(query);
@@ -2185,6 +2461,53 @@ function createCommonOperationBackend(options) {
         });
       }
     },
+    async insertUniqueBatch(entries) {
+      if (entries.length === 0) return;
+      const targetKey = (entry) => `${entry.nodeKind}\0${entry.constraintName}\0${entry.key}`;
+      const byTarget = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const existing = byTarget.get(targetKey(entry));
+        if (existing === void 0) {
+          byTarget.set(targetKey(entry), entry);
+          continue;
+        }
+        if (existing.nodeId !== entry.nodeId) {
+          throw new UniquenessError({
+            constraintName: entry.constraintName,
+            kind: entry.nodeKind,
+            existingId: existing.nodeId,
+            newId: entry.nodeId,
+            fields: []
+          });
+        }
+      }
+      const deduped = [...byTarget.values()];
+      for (const chunk2 of chunk(
+        deduped,
+        batchConfig.uniqueInsertBatchSize
+      )) {
+        const query = operationStrategy.buildInsertUniqueBatch(chunk2);
+        const rows = await execution.execAll(query);
+        const ownerByTarget = new Map(
+          rows.map((row) => [
+            `${row.node_kind}\0${row.constraint_name}\0${row.key}`,
+            row.node_id
+          ])
+        );
+        for (const entry of chunk2) {
+          const owner = ownerByTarget.get(targetKey(entry));
+          if (owner !== void 0 && owner !== entry.nodeId) {
+            throw new UniquenessError({
+              constraintName: entry.constraintName,
+              kind: entry.nodeKind,
+              existingId: owner,
+              newId: entry.nodeId,
+              fields: []
+            });
+          }
+        }
+      }
+    },
     async deleteUnique(params) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildDeleteUnique(params, timestamp2);
@@ -2347,6 +2670,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createSqliteOperationStrategy, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-RY2VIWAM.js.map
-//# sourceMappingURL=chunk-RY2VIWAM.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, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createSqliteOperationStrategy, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, hybridCandidatesRef, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-WDBCBWC4.js.map
+//# sourceMappingURL=chunk-WDBCBWC4.js.map