@nicia-ai/typegraph 0.25.0 → 0.26.0

package/dist/{chunk-O2P3KAUT.cjs → chunk-TVUARC7S.cjs}

@@ -1,12 +1,19 @@
 'use strict';
 
-var chunkJTI5WT4P_cjs = require('./chunk-JTI5WT4P.cjs');
+var chunkIUIWCFG3_cjs = require('./chunk-IUIWCFG3.cjs');
+var chunkPN37HVAV_cjs = require('./chunk-PN37HVAV.cjs');
 var chunkCTHNVU6K_cjs = require('./chunk-CTHNVU6K.cjs');
-var chunkW5MTHMTE_cjs = require('./chunk-W5MTHMTE.cjs');
+var chunkYEDQLNVE_cjs = require('./chunk-YEDQLNVE.cjs');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
 
+var regconfig = pgCore.customType({
+  dataType: () => "regconfig"
+});
+var tsvector = pgCore.customType({
+  dataType: () => "tsvector"
+});
 var vector = pgCore.customType({
   dataType(config) {
     return config?.dimensions ? `vector(${config.dimensions})` : "vector";
@@ -35,6 +42,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"
 };
@@ -66,7 +74,7 @@ function createPostgresTables(names = {}, options = {}) {
       ),
       pgCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       pgCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkJTI5WT4P_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+      ...chunkPN37HVAV_cjs.buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = pgCore.pgTable(
@@ -125,7 +133,7 @@ function createPostgresTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkJTI5WT4P_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+      ...chunkPN37HVAV_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = pgCore.pgTable(
@@ -243,6 +251,43 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
   );
+  const contributionMaterializations = pgCore.pgTable(
+    n.contributionMaterializations,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      logicalName: pgCore.text("logical_name").notNull(),
+      owner: pgCore.text("owner").notNull(),
+      tableName: pgCore.text("table_name").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  const fulltext2 = pgCore.pgTable(
+    n.fulltext,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      content: pgCore.text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(drizzleOrm.sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      pgCore.index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      pgCore.index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
+    ]
+  );
   return {
     nodes: nodes3,
     edges: edges3,
@@ -250,22 +295,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",
@@ -274,6 +319,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"
 };
@@ -305,7 +351,7 @@ function createSqliteTables(names = {}, options = {}) {
       ),
       sqliteCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       sqliteCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkJTI5WT4P_cjs.buildSqliteNodeIndexBuilders(t, indexes)
+      ...chunkPN37HVAV_cjs.buildSqliteNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = sqliteCore.sqliteTable(
@@ -364,7 +410,7 @@ function createSqliteTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkJTI5WT4P_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
+      ...chunkPN37HVAV_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = sqliteCore.sqliteTable(
@@ -482,6 +528,24 @@ function createSqliteTables(names = {}, options = {}) {
     },
     (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
   );
+  const contributionMaterializations = sqliteCore.sqliteTable(
+    n.contributionMaterializations,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      logicalName: sqliteCore.text("logical_name").notNull(),
+      owner: sqliteCore.text("owner").notNull(),
+      tableName: sqliteCore.text("table_name").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
   return {
     nodes: nodes3,
     edges: edges3,
@@ -489,6 +553,7 @@ function createSqliteTables(names = {}, options = {}) {
     schemaVersions: schemaVersions3,
     embeddings: embeddings3,
     indexMaterializations,
+    contributionMaterializations,
     kindRemovals,
     reconciliationMarkers,
     /**
@@ -556,9 +621,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";
 }
@@ -629,23 +694,37 @@ 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 drizzleOrm.is(value, sqliteCore.SQLiteTable);
 }
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkJTI5WT4P_cjs.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 = chunkPN37HVAV_cjs.fts5Strategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
-    statements.push(generateSqliteCreateTableSQL(table));
+    contributions.push({
+      logicalName: key,
+      owner: chunkPN37HVAV_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: sqliteCore.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 generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkJTI5WT4P_cjs.fts5Strategy) {
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkPN37HVAV_cjs.fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
+}
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkPN37HVAV_cjs.fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -728,22 +807,35 @@ function generatePgCreateIndexSQL(table) {
   return statements;
 }
 function isPgTable(value) {
-  return typeof value === "object" && value !== null && typeof value !== "string";
+  return drizzleOrm.is(value, pgCore.PgTable);
 }
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunkJTI5WT4P_cjs.tsvectorStrategy) {
-  const statements = [];
-  for (const table of Object.values(tables3)) {
+function postgresContributions(tables3 = tables, fulltextStrategy = chunkPN37HVAV_cjs.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: chunkPN37HVAV_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: pgCore.getTableConfig(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 = chunkPN37HVAV_cjs.tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
 }
-function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkJTI5WT4P_cjs.tsvectorStrategy) {
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkPN37HVAV_cjs.tsvectorStrategy) {
   const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
   const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
   return `${extensionSql}
@@ -754,7 +846,7 @@ ${ddlSql}`;
 // src/backend/drizzle/row-mappers.ts
 function requireTimestamp(value, field) {
   if (value === void 0) {
-    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
       `Expected non-null ${field} timestamp`,
       { operation: "select", entity: "row" }
     );
@@ -763,7 +855,7 @@ function requireTimestamp(value, field) {
 }
 function asString(value, field) {
   if (typeof value !== "string") {
-    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
       `Expected ${field} to be string, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -772,7 +864,7 @@ function asString(value, field) {
 }
 function asNumber(value, field) {
   if (typeof value !== "number") {
-    throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
       `Expected ${field} to be number, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -796,6 +888,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 ?? {});
 }
@@ -803,7 +905,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   formatTimestamp: (value) => {
     if (value === null || value === void 0) return;
     if (typeof value !== "string") {
-      throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+      throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
         `Expected timestamp to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -812,7 +914,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   },
   normalizeJson: (value) => {
     if (typeof value !== "string") {
-      throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+      throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
         `Expected JSON column to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -880,6 +982,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 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("materialized_at")}, ${materializedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`;
+  return {
+    signature: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("signature")}`,
+    materializedAt: materializedAtSet,
+    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
+    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
+  };
+}
+async function computeContributionSignature(dialect, identity, createDdl) {
+  const hashable = {
+    dialect,
+    owner: identity.owner,
+    logicalName: identity.logicalName,
+    tableName: identity.tableName,
+    createDdl
+  };
+  return chunkCTHNVU6K_cjs.sha256Hex(JSON.stringify(hashable, chunkIUIWCFG3_cjs.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 (!chunkIUIWCFG3_cjs.isMissingTableError(error)) throw error;
+        throw new chunkYEDQLNVE_cjs.StoreNotInitializedError(graphId, "missing", {
+          cause: error,
+          details: { logicalName: contribution.logicalName }
+        });
+      }
+      const state = evaluateContributionState(existing, signature);
+      if (state !== "initialized") {
+        throw new chunkYEDQLNVE_cjs.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
@@ -979,8 +1297,14 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
-
-// src/backend/drizzle/operation-backend-core.ts
+function assertAdoptedDialect(externalTx, brand, backend) {
+  if (drizzleOrm.is(externalTx, brand)) return;
+  const label = backend === "postgres" ? "Postgres" : "SQLite";
+  throw new chunkYEDQLNVE_cjs.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];
@@ -994,7 +1318,7 @@ function chunkArray(values, size) {
 function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
   const expectedVersion = expected.kind === "active" ? expected.version : 0;
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkW5MTHMTE_cjs.StaleVersionError({
+    throw new chunkYEDQLNVE_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
@@ -1015,7 +1339,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
@@ -1065,7 +1389,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
@@ -1108,7 +1432,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
@@ -1158,7 +1482,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkW5MTHMTE_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
@@ -1209,7 +1533,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkW5MTHMTE_cjs.UniquenessError({
+        throw new chunkYEDQLNVE_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -1259,7 +1583,7 @@ function createCommonOperationBackend(options) {
       if (existingRaw !== void 0) {
         const existing = rowMappers.toSchemaVersionRow(existingRaw);
         if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkW5MTHMTE_cjs.SchemaContentConflictError({
+          throw new chunkYEDQLNVE_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -1307,7 +1631,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkW5MTHMTE_cjs.DatabaseOperationError(
+        throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -1328,7 +1652,7 @@ function createCommonOperationBackend(options) {
         )
       );
       if (!targetRaw) {
-        throw new chunkW5MTHMTE_cjs.MigrationError(
+        throw new chunkYEDQLNVE_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -1353,9 +1677,9 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
-  const fulltext = chunkJTI5WT4P_cjs.quotedTableName(tables3.fulltextTableName);
+  const fulltext2 = chunkPN37HVAV_cjs.quotedTableName(tables3.fulltextTableName);
   return [
-    drizzleOrm.sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}`,
+    drizzleOrm.sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
@@ -1503,13 +1827,13 @@ function buildCountEdgesByKind(tables3, params) {
 function buildInsertEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
+  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1518,23 +1842,23 @@ function buildInsertEdge(tables3, params, timestamp2) {
 function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
+  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertEdgesBatch(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
+  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1543,10 +1867,10 @@ function buildInsertEdgesBatch(tables3, params, timestamp2) {
 }
 function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = chunkJTI5WT4P_cjs.edgeColumnList(edges3);
+  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1578,14 +1902,14 @@ function buildUpdateEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1610,7 +1934,7 @@ function buildDeleteEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${edges3}
-    SET ${chunkJTI5WT4P_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    SET ${chunkPN37HVAV_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
     WHERE ${edges3.graphId} = ${params.graphId}
       AND ${edges3.id} = ${params.id}
       AND ${edges3.deletedAt} IS NULL
@@ -1697,7 +2021,7 @@ function resolveMode(mode) {
 function buildFulltextSearch(tableName, params, strategy) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
-  const table = chunkJTI5WT4P_cjs.quotedTableName(tableName);
+  const table = chunkPN37HVAV_cjs.quotedTableName(tableName);
   const matchCondition = strategy.matchCondition(
     tableName,
     params.query,
@@ -1748,12 +2072,12 @@ function assertValidSearchParams(params) {
 function buildInsertNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
+  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
+      1, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1762,22 +2086,22 @@ function buildInsertNode(tables3, params, timestamp2) {
 function buildInsertNodeNoReturn(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
+  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkJTI5WT4P_cjs.sqlNull(params.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(params.validTo)},
+      1, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertNodesBatch(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
+  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkPN37HVAV_cjs.sqlNull(nodeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1786,10 +2110,10 @@ function buildInsertNodesBatch(tables3, params, timestamp2) {
 }
 function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = chunkJTI5WT4P_cjs.nodeColumnList(nodes3);
+  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validFrom)}, ${chunkJTI5WT4P_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkPN37HVAV_cjs.sqlNull(nodeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1823,19 +2147,19 @@ function buildUpdateNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.version)} = ${chunkJTI5WT4P_cjs.quotedColumn(nodes3.version)} + 1`
+      drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.version)} = ${chunkPN37HVAV_cjs.quotedColumn(nodes3.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkJTI5WT4P_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1862,7 +2186,7 @@ function buildDeleteNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${nodes3}
-    SET ${chunkJTI5WT4P_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
+    SET ${chunkPN37HVAV_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
     WHERE ${nodes3.graphId} = ${params.graphId}
       AND ${nodes3.kind} = ${params.kind}
       AND ${nodes3.id} = ${params.id}
@@ -1929,12 +2253,12 @@ function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${chunkJTI5WT4P_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
+    SET ${chunkPN37HVAV_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${chunkJTI5WT4P_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
+    SET ${chunkPN37HVAV_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
       AND ${schemaVersions3.version} = ${version}
   `;
@@ -1952,22 +2276,22 @@ function buildInsertUniqueSqlite(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = CASE
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)}
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)}
       END,
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)} = CASE
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)}
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${chunkPN37HVAV_cjs.quotedColumn(uniques3.concreteKind)}
       END,
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = CASE
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)}
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)}
       END
-    RETURNING ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 function buildInsertUniquePostgres(tables3, params) {
@@ -1984,22 +2308,22 @@ function buildInsertUniquePostgres(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} = CASE
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
         ELSE ${existingColumn(uniques3.nodeId)}
       END,
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.concreteKind)} = CASE
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.concreteKind)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
         ELSE ${existingColumn(uniques3.concreteKind)}
       END,
-      ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = CASE
+      ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
         ELSE ${existingColumn(uniques3.deletedAt)}
       END
-    RETURNING ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
@@ -2014,7 +2338,7 @@ function buildDeleteUnique(tables3, params, timestamp2) {
   const { uniques: uniques3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${uniques3}
-    SET ${chunkJTI5WT4P_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
+    SET ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
     WHERE ${uniques3.graphId} = ${params.graphId}
       AND ${uniques3.nodeKind} = ${params.nodeKind}
       AND ${uniques3.constraintName} = ${params.constraintName}
@@ -2651,18 +2975,25 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
+exports.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.POSTGRES_INDEX_MAT_TIMESTAMPS = POSTGRES_INDEX_MAT_TIMESTAMPS;
 exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
 exports.POSTGRES_ROW_MAPPER_CONFIG = POSTGRES_ROW_MAPPER_CONFIG;
+exports.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = SQLITE_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.SQLITE_INDEX_MAT_TIMESTAMPS = SQLITE_INDEX_MAT_TIMESTAMPS;
 exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
 exports.SQLITE_ROW_MAPPER_CONFIG = SQLITE_ROW_MAPPER_CONFIG;
+exports.assertAdoptedDialect = assertAdoptedDialect;
+exports.buildContributionInsertValues = buildContributionInsertValues;
+exports.buildContributionOnConflictSet = buildContributionOnConflictSet;
 exports.buildKindRemovalInsertValues = buildKindRemovalInsertValues;
 exports.buildKindRemovalOnConflictSet = buildKindRemovalOnConflictSet;
 exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
 exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
+exports.coerceNumericScore = coerceNumericScore;
 exports.compileQueryWithDialect = compileQueryWithDialect;
 exports.createCommonOperationBackend = createCommonOperationBackend;
+exports.createContributionMaterializer = createContributionMaterializer;
 exports.createEdgeRowMapper = createEdgeRowMapper;
 exports.createNodeRowMapper = createNodeRowMapper;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
@@ -2680,6 +3011,9 @@ exports.edges2 = edges2;
 exports.embeddings = embeddings;
 exports.embeddings2 = embeddings2;
 exports.formatPostgresTimestamp = formatPostgresTimestamp;
+exports.fulltext = fulltext;
+exports.gateFulltext = gateFulltext;
+exports.gateFulltextMethods = gateFulltextMethods;
 exports.generatePgCreateTableSQL = generatePgCreateTableSQL;
 exports.generatePostgresDDL = generatePostgresDDL;
 exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
@@ -2688,6 +3022,7 @@ exports.generateSqliteDDL = generateSqliteDDL;
 exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
 exports.generateVectorIndexName = generateVectorIndexName;
 exports.getOrCreateLru = getOrCreateLru;
+exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
 exports.mapKindRemovalRow = mapKindRemovalRow;
 exports.mapMaterializationRow = mapMaterializationRow;
 exports.nodes = nodes;
@@ -2699,5 +3034,5 @@ exports.tables = tables;
 exports.tables2 = tables2;
 exports.uniques = uniques;
 exports.uniques2 = uniques2;
-//# sourceMappingURL=chunk-O2P3KAUT.cjs.map
-//# sourceMappingURL=chunk-O2P3KAUT.cjs.map
+//# sourceMappingURL=chunk-TVUARC7S.cjs.map
+//# sourceMappingURL=chunk-TVUARC7S.cjs.map