@nicia-ai/typegraph 0.28.1 → 0.29.0

package/dist/{chunk-NYQFPGYP.cjs → chunk-ZYQEXGYC.cjs}

@@ -1,9 +1,10 @@
 'use strict';
 
-var chunkFFHW2JEK_cjs = require('./chunk-FFHW2JEK.cjs');
-var chunkPN37HVAV_cjs = require('./chunk-PN37HVAV.cjs');
-var chunkCTHNVU6K_cjs = require('./chunk-CTHNVU6K.cjs');
-var chunkYEDQLNVE_cjs = require('./chunk-YEDQLNVE.cjs');
+var chunkF2Q76CQ4_cjs = require('./chunk-F2Q76CQ4.cjs');
+var chunkRP7YITHX_cjs = require('./chunk-RP7YITHX.cjs');
+var chunkC2RWFIYP_cjs = require('./chunk-C2RWFIYP.cjs');
+var chunkUPBXUOW7_cjs = require('./chunk-UPBXUOW7.cjs');
+var chunkG6P3OVDY_cjs = require('./chunk-G6P3OVDY.cjs');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
@@ -14,24 +15,6 @@ var regconfig = pgCore.customType({
 var tsvector = pgCore.customType({
   dataType: () => "tsvector"
 });
-var vector = pgCore.customType({
-  dataType(config) {
-    return config?.dimensions ? `vector(${config.dimensions})` : "vector";
-  },
-  toDriver(value) {
-    return `[${value.join(",")}]`;
-  },
-  fromDriver(value) {
-    if (Array.isArray(value)) {
-      return value;
-    }
-    const content = value.slice(1, -1);
-    if (content === "") {
-      return [];
-    }
-    return content.split(",").map((s) => Number.parseFloat(s.trim()));
-  }
-});
 
 // src/backend/drizzle/schema/postgres.ts
 var DEFAULT_TABLE_NAMES = {
@@ -39,7 +22,6 @@ var DEFAULT_TABLE_NAMES = {
   edges: "typegraph_edges",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
-  embeddings: "typegraph_node_embeddings",
   fulltext: "typegraph_node_fulltext",
   indexMaterializations: "typegraph_index_materializations",
   contributionMaterializations: "typegraph_contribution_materializations",
@@ -49,7 +31,7 @@ var DEFAULT_TABLE_NAMES = {
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
   const indexes = options.indexes ?? [];
-  const nodes3 = pgCore.pgTable(
+  const nodes2 = pgCore.pgTable(
     n.nodes,
     {
       graphId: pgCore.text("graph_id").notNull(),
@@ -74,10 +56,10 @@ 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),
-      ...chunkPN37HVAV_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+      ...chunkC2RWFIYP_cjs.buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
-  const edges3 = pgCore.pgTable(
+  const edges2 = pgCore.pgTable(
     n.edges,
     {
       graphId: pgCore.text("graph_id").notNull(),
@@ -133,10 +115,10 @@ function createPostgresTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkPN37HVAV_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+      ...chunkC2RWFIYP_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
-  const uniques3 = pgCore.pgTable(
+  const uniques2 = pgCore.pgTable(
     n.uniques,
     {
       graphId: pgCore.text("graph_id").notNull(),
@@ -154,7 +136,7 @@ function createPostgresTables(names = {}, options = {}) {
       pgCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
     ]
   );
-  const schemaVersions3 = pgCore.pgTable(
+  const schemaVersions2 = pgCore.pgTable(
     n.schemaVersions,
     {
       graphId: pgCore.text("graph_id").notNull(),
@@ -175,38 +157,6 @@ function createPostgresTables(names = {}, options = {}) {
       pgCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = TRUE`)
     ]
   );
-  const embeddings3 = pgCore.pgTable(
-    n.embeddings,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      nodeKind: pgCore.text("node_kind").notNull(),
-      nodeId: pgCore.text("node_id").notNull(),
-      fieldPath: pgCore.text("field_path").notNull(),
-      /** Embedding vector stored as native pgvector type */
-      embedding: vector("embedding").notNull(),
-      /** Number of dimensions (for validation) */
-      dimensions: pgCore.integer("dimensions").notNull(),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
-    },
-    (t) => [
-      pgCore.primaryKey({
-        columns: [t.graphId, t.nodeKind, t.nodeId, t.fieldPath]
-      }),
-      // Index for looking up embeddings by node
-      pgCore.index(`${n.embeddings}_node_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.nodeId
-      ),
-      // Index for filtering by kind and field (used in vector search)
-      pgCore.index(`${n.embeddings}_kind_field_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.fieldPath
-      )
-    ]
-  );
   const indexMaterializations = pgCore.pgTable(
     n.indexMaterializations,
     {
@@ -289,11 +239,10 @@ function createPostgresTables(names = {}, options = {}) {
     ]
   );
   return {
-    nodes: nodes3,
-    edges: edges3,
-    uniques: uniques3,
-    schemaVersions: schemaVersions3,
-    embeddings: embeddings3,
+    nodes: nodes2,
+    edges: edges2,
+    uniques: uniques2,
+    schemaVersions: schemaVersions2,
     indexMaterializations,
     contributionMaterializations,
     kindRemovals,
@@ -302,270 +251,8 @@ function createPostgresTables(names = {}, options = {}) {
     fulltextTableName: n.fulltext
   };
 }
-var tables = createPostgresTables();
-var {
-  nodes,
-  edges,
-  uniques,
-  schemaVersions,
-  embeddings,
-  fulltext
-} = tables;
-var DEFAULT_TABLE_NAMES2 = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  uniques: "typegraph_node_uniques",
-  schemaVersions: "typegraph_schema_versions",
-  embeddings: "typegraph_node_embeddings",
-  fulltext: "typegraph_node_fulltext",
-  indexMaterializations: "typegraph_index_materializations",
-  contributionMaterializations: "typegraph_contribution_materializations",
-  kindRemovals: "typegraph_kind_removals",
-  reconciliationMarkers: "typegraph_reconciliation_markers"
-};
-function createSqliteTables(names = {}, options = {}) {
-  const n = { ...DEFAULT_TABLE_NAMES2, ...names };
-  const indexes = options.indexes ?? [];
-  const nodes3 = sqliteCore.sqliteTable(
-    n.nodes,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      kind: sqliteCore.text("kind").notNull(),
-      id: sqliteCore.text("id").notNull(),
-      props: sqliteCore.text("props").notNull(),
-      version: sqliteCore.integer("version").notNull().default(1),
-      validFrom: sqliteCore.text("valid_from"),
-      validTo: sqliteCore.text("valid_to"),
-      createdAt: sqliteCore.text("created_at").notNull(),
-      updatedAt: sqliteCore.text("updated_at").notNull(),
-      deletedAt: sqliteCore.text("deleted_at")
-    },
-    (t) => [
-      sqliteCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
-      sqliteCore.index(`${n.nodes}_kind_idx`).on(t.graphId, t.kind),
-      sqliteCore.index(`${n.nodes}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      sqliteCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
-      sqliteCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkPN37HVAV_cjs.buildSqliteNodeIndexBuilders(t, indexes)
-    ]
-  );
-  const edges3 = sqliteCore.sqliteTable(
-    n.edges,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      id: sqliteCore.text("id").notNull(),
-      kind: sqliteCore.text("kind").notNull(),
-      fromKind: sqliteCore.text("from_kind").notNull(),
-      fromId: sqliteCore.text("from_id").notNull(),
-      toKind: sqliteCore.text("to_kind").notNull(),
-      toId: sqliteCore.text("to_id").notNull(),
-      props: sqliteCore.text("props").notNull(),
-      validFrom: sqliteCore.text("valid_from"),
-      validTo: sqliteCore.text("valid_to"),
-      createdAt: sqliteCore.text("created_at").notNull(),
-      updatedAt: sqliteCore.text("updated_at").notNull(),
-      deletedAt: sqliteCore.text("deleted_at")
-    },
-    (t) => [
-      sqliteCore.primaryKey({ columns: [t.graphId, t.id] }),
-      sqliteCore.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.
-      sqliteCore.index(`${n.edges}_from_idx`).on(
-        t.graphId,
-        t.fromKind,
-        t.fromId,
-        t.kind,
-        t.toKind,
-        t.deletedAt,
-        t.validTo
-      ),
-      // Directional traversal index (incoming): mirrors from_idx for reverse traversals.
-      sqliteCore.index(`${n.edges}_to_idx`).on(
-        t.graphId,
-        t.toKind,
-        t.toId,
-        t.kind,
-        t.fromKind,
-        t.deletedAt,
-        t.validTo
-      ),
-      sqliteCore.index(`${n.edges}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      sqliteCore.index(`${n.edges}_deleted_idx`).on(t.graphId, t.deletedAt),
-      sqliteCore.index(`${n.edges}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      sqliteCore.index(`${n.edges}_cardinality_idx`).on(
-        t.graphId,
-        t.kind,
-        t.fromKind,
-        t.fromId,
-        t.validTo
-      ),
-      ...chunkPN37HVAV_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
-    ]
-  );
-  const uniques3 = sqliteCore.sqliteTable(
-    n.uniques,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      nodeKind: sqliteCore.text("node_kind").notNull(),
-      constraintName: sqliteCore.text("constraint_name").notNull(),
-      key: sqliteCore.text("key").notNull(),
-      nodeId: sqliteCore.text("node_id").notNull(),
-      concreteKind: sqliteCore.text("concrete_kind").notNull(),
-      deletedAt: sqliteCore.text("deleted_at")
-    },
-    (t) => [
-      sqliteCore.primaryKey({
-        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
-      }),
-      sqliteCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
-    ]
-  );
-  const schemaVersions3 = sqliteCore.sqliteTable(
-    n.schemaVersions,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      version: sqliteCore.integer("version").notNull(),
-      schemaHash: sqliteCore.text("schema_hash").notNull(),
-      schemaDoc: sqliteCore.text("schema_doc").notNull(),
-      createdAt: sqliteCore.text("created_at").notNull(),
-      isActive: sqliteCore.integer("is_active", { mode: "boolean" }).notNull().default(false)
-    },
-    (t) => [
-      sqliteCore.primaryKey({ columns: [t.graphId, t.version] }),
-      sqliteCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
-      // Partial unique index enforcing the "at most one active version
-      // per graph" invariant at the storage layer. Defense in depth
-      // against buggy backend implementations or out-of-band writes.
-      // Forces the deactivate-then-activate ordering used by
-      // `commitSchemaVersion` and `setActiveVersion`.
-      sqliteCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = 1`)
-    ]
-  );
-  const embeddings3 = sqliteCore.sqliteTable(
-    n.embeddings,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      nodeKind: sqliteCore.text("node_kind").notNull(),
-      nodeId: sqliteCore.text("node_id").notNull(),
-      fieldPath: sqliteCore.text("field_path").notNull(),
-      /**
-       * Embedding vector.
-       * Stored as BLOB for sqlite-vec binary format, or JSON text for fallback.
-       * For sqlite-vec: use vec_f32() to convert JSON array to binary.
-       */
-      embedding: sqliteCore.blob("embedding", { mode: "buffer" }).notNull(),
-      /** Number of dimensions (for validation) */
-      dimensions: sqliteCore.integer("dimensions").notNull(),
-      createdAt: sqliteCore.text("created_at").notNull(),
-      updatedAt: sqliteCore.text("updated_at").notNull()
-    },
-    (t) => [
-      sqliteCore.primaryKey({
-        columns: [t.graphId, t.nodeKind, t.nodeId, t.fieldPath]
-      }),
-      // Index for looking up embeddings by node
-      sqliteCore.index(`${n.embeddings}_node_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.nodeId
-      ),
-      // Index for filtering by kind and field (used in vector search)
-      sqliteCore.index(`${n.embeddings}_kind_field_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.fieldPath
-      )
-    ]
-  );
-  const indexMaterializations = sqliteCore.sqliteTable(
-    n.indexMaterializations,
-    {
-      indexName: sqliteCore.text("index_name").notNull(),
-      graphId: sqliteCore.text("graph_id").notNull(),
-      entity: sqliteCore.text("entity").notNull(),
-      kind: sqliteCore.text("kind").notNull(),
-      signature: sqliteCore.text("signature").notNull(),
-      schemaVersion: sqliteCore.integer("schema_version").notNull(),
-      materializedAt: sqliteCore.text("materialized_at"),
-      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
-      lastError: sqliteCore.text("last_error")
-    },
-    (t) => [sqliteCore.primaryKey({ columns: [t.indexName] })]
-  );
-  const kindRemovals = sqliteCore.sqliteTable(
-    n.kindRemovals,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      kindName: sqliteCore.text("kind_name").notNull(),
-      entity: sqliteCore.text("entity").notNull(),
-      schemaVersion: sqliteCore.integer("schema_version").notNull(),
-      removedAt: sqliteCore.text("removed_at"),
-      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
-      lastError: sqliteCore.text("last_error")
-    },
-    (t) => [
-      sqliteCore.primaryKey({
-        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
-      })
-    ]
-  );
-  const reconciliationMarkers = sqliteCore.sqliteTable(
-    n.reconciliationMarkers,
-    {
-      graphId: sqliteCore.text("graph_id").notNull(),
-      reconciledToVersion: sqliteCore.integer("reconciled_to_version").notNull()
-    },
-    (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,
-    uniques: uniques3,
-    schemaVersions: schemaVersions3,
-    embeddings: embeddings3,
-    indexMaterializations,
-    contributionMaterializations,
-    kindRemovals,
-    reconciliationMarkers,
-    /**
-     * The fulltext storage is a FTS5 virtual table which Drizzle cannot
-     * represent. DDL is emitted as raw SQL and operations query it via
-     * `sql.raw()`.
-     */
-    fulltextTableName: n.fulltext
-  };
-}
-var tables2 = createSqliteTables();
-var { nodes: nodes2, edges: edges2, uniques: uniques2, schemaVersions: schemaVersions2, embeddings: embeddings2 } = tables2;
+var tables2 = createPostgresTables();
+var { nodes, edges, uniques, schemaVersions, fulltext } = tables2;
 function getSqliteColumnType(column) {
   switch (column.columnType) {
     case "SQLiteText": {
@@ -621,9 +308,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 sql12 = tryInlineSql(col);
+  if (sql12 !== void 0) {
+    return sql12;
   }
   return "unknown";
 }
@@ -682,8 +369,8 @@ function inlineSqlOrThrow(value, context) {
 function generateSqliteCreateIndexSQL(table) {
   const config = sqliteCore.getTableConfig(table);
   const statements = [];
-  for (const index3 of config.indexes) {
-    const indexConfig = index3.config;
+  for (const index2 of config.indexes) {
+    const indexConfig = index2.config;
     const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
     const unique = indexConfig.unique ? "UNIQUE " : "";
     const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `SQLite index "${indexConfig.name}" WHERE clause`)}` : "";
@@ -699,13 +386,13 @@ function isSqliteTable(value) {
 function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
   return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
 }
-function sqliteContributions(tables3 = tables2, fulltextStrategy = chunkPN37HVAV_cjs.fts5Strategy) {
+function sqliteContributions(tables3 = chunkF2Q76CQ4_cjs.tables, fulltextStrategy = chunkC2RWFIYP_cjs.fts5Strategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
     contributions.push({
       logicalName: key,
-      owner: chunkPN37HVAV_cjs.BASE_CONTRIBUTION_OWNER,
+      owner: chunkC2RWFIYP_cjs.BASE_CONTRIBUTION_OWNER,
       tableName: sqliteCore.getTableConfig(table).name,
       createDdl: [
         generateSqliteCreateTableSQL(table),
@@ -721,10 +408,12 @@ function sqliteContributions(tables3 = tables2, fulltextStrategy = chunkPN37HVAV
   }
   return contributions;
 }
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkPN37HVAV_cjs.fts5Strategy) {
-  return sqliteContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
+function generateSqliteDDL(tables3 = chunkF2Q76CQ4_cjs.tables, fulltextStrategy = chunkC2RWFIYP_cjs.fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
 }
-function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkPN37HVAV_cjs.fts5Strategy) {
+function generateSqliteMigrationSQL(tables3 = chunkF2Q76CQ4_cjs.tables, fulltextStrategy = chunkC2RWFIYP_cjs.fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -770,10 +459,7 @@ function generatePgCreateTableSQL(table) {
   const config = pgCore.getTableConfig(table);
   const columnDefs = [];
   for (const column of config.columns) {
-    const parts = [
-      `"${column.name}"`,
-      getPgColumnType(column)
-    ];
+    const parts = [`"${column.name}"`, getPgColumnType(column)];
     if (column.notNull) {
       parts.push("NOT NULL");
     }
@@ -794,8 +480,8 @@ function generatePgCreateTableSQL(table) {
 function generatePgCreateIndexSQL(table) {
   const config = pgCore.getTableConfig(table);
   const statements = [];
-  for (const index3 of config.indexes) {
-    const indexConfig = index3.config;
+  for (const index2 of config.indexes) {
+    const indexConfig = index2.config;
     const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
     const unique = indexConfig.unique ? "UNIQUE " : "";
     const method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
@@ -809,14 +495,14 @@ function generatePgCreateIndexSQL(table) {
 function isPgTable(value) {
   return drizzleOrm.is(value, pgCore.PgTable);
 }
-function postgresContributions(tables3 = tables, fulltextStrategy = chunkPN37HVAV_cjs.tsvectorStrategy) {
+function postgresContributions(tables3 = tables2, fulltextStrategy = chunkC2RWFIYP_cjs.tsvectorStrategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isPgTable(table)) continue;
     if (table === tables3.fulltext) continue;
     contributions.push({
       logicalName: key,
-      owner: chunkPN37HVAV_cjs.BASE_CONTRIBUTION_OWNER,
+      owner: chunkC2RWFIYP_cjs.BASE_CONTRIBUTION_OWNER,
       tableName: pgCore.getTableConfig(table).name,
       createDdl: [
         generatePgCreateTableSQL(table),
@@ -832,10 +518,12 @@ function postgresContributions(tables3 = tables, fulltextStrategy = chunkPN37HVA
   }
   return contributions;
 }
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunkPN37HVAV_cjs.tsvectorStrategy) {
-  return postgresContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
+function generatePostgresDDL(tables3 = tables2, fulltextStrategy = chunkC2RWFIYP_cjs.tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
 }
-function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkPN37HVAV_cjs.tsvectorStrategy) {
+function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = chunkC2RWFIYP_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}
@@ -843,10 +531,87 @@ function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunk
 ${ddlSql}`;
 }
 
+// src/backend/drizzle/vector-runtime.ts
+function vectorSlotKey(slot) {
+  return JSON.stringify([
+    slot.graphId,
+    slot.nodeKind,
+    slot.fieldPath,
+    slot.dimensions,
+    slot.metric,
+    slot.indexType
+  ]);
+}
+function createVectorSlotLatch() {
+  const inFlight = /* @__PURE__ */ new Map();
+  return {
+    ensure(strategy, slot, execDdl) {
+      const key = vectorSlotKey(slot);
+      const existing = inFlight.get(key);
+      if (existing !== void 0) return existing;
+      const run = (async () => {
+        for (const contribution of strategy.ownedTables(slot)) {
+          for (const statement of contribution.createDdl) {
+            await execDdl(statement);
+          }
+        }
+      })();
+      const cached = run.catch((error) => {
+        inFlight.delete(key);
+        throw error;
+      });
+      inFlight.set(key, cached);
+      return cached;
+    }
+  };
+}
+var VECTOR_SLOT_PLACEHOLDER_DIMENSIONS = 1;
+function vectorSlotFromParams(params) {
+  return {
+    graphId: params.graphId,
+    nodeKind: params.nodeKind,
+    fieldPath: params.fieldPath,
+    dimensions: params.dimensions,
+    metric: params.metric,
+    indexType: params.indexType
+  };
+}
+function vectorSlotFromCreateIndexParams(params) {
+  return {
+    ...vectorSlotFromParams(params),
+    ...params.indexParams === void 0 ? {} : { indexParams: params.indexParams }
+  };
+}
+function vectorSlotFromDropIndexParams(params) {
+  return {
+    graphId: params.graphId,
+    nodeKind: params.nodeKind,
+    fieldPath: params.fieldPath,
+    dimensions: VECTOR_SLOT_PLACEHOLDER_DIMENSIONS,
+    metric: "cosine",
+    indexType: "hnsw"
+  };
+}
+function mapVectorWriteError(error, params) {
+  const mismatch = chunkRP7YITHX_cjs.parseDimensionMismatch(error);
+  if (mismatch === void 0) return error;
+  const attempted = mismatch.actual ?? "a different number of";
+  return new chunkG6P3OVDY_cjs.EmbeddingDimensionChangedError(
+    `Embedding "${params.nodeKind}.${params.fieldPath}" was written with ${attempted} dimensions, but its per-field storage expects ${mismatch.expected}. The field's embedding dimension changed; existing vectors must be recreated and re-embedded.`,
+    {
+      kind: params.nodeKind,
+      fieldPath: params.fieldPath,
+      storedDimensions: mismatch.expected,
+      ...mismatch.actual === void 0 ? {} : { declaredDimensions: mismatch.actual }
+    },
+    { cause: error }
+  );
+}
+
 // src/backend/drizzle/row-mappers.ts
 function requireTimestamp(value, field) {
   if (value === void 0) {
-    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+    throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
       `Expected non-null ${field} timestamp`,
       { operation: "select", entity: "row" }
     );
@@ -855,7 +620,7 @@ function requireTimestamp(value, field) {
 }
 function asString(value, field) {
   if (typeof value !== "string") {
-    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+    throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
       `Expected ${field} to be string, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -864,7 +629,7 @@ function asString(value, field) {
 }
 function asNumber(value, field) {
   if (typeof value !== "number") {
-    throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+    throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
       `Expected ${field} to be number, got ${typeof value}`,
       { operation: "select", entity: "row" }
     );
@@ -905,7 +670,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   formatTimestamp: (value) => {
     if (value === null || value === void 0) return;
     if (typeof value !== "string") {
-      throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+      throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
         `Expected timestamp to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -914,7 +679,7 @@ var SQLITE_ROW_MAPPER_CONFIG = {
   },
   normalizeJson: (value) => {
     if (typeof value !== "string") {
-      throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+      throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
         `Expected JSON column to be string, got ${typeof value}`,
         { operation: "select", entity: "row" }
       );
@@ -1037,7 +802,7 @@ async function computeContributionSignature(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return chunkCTHNVU6K_cjs.sha256Hex(JSON.stringify(hashable, chunkFFHW2JEK_cjs.sortedReplacer), 16);
+  return chunkUPBXUOW7_cjs.sha256Hex(JSON.stringify(hashable, chunkRP7YITHX_cjs.sortedReplacer), 16);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -1171,7 +936,7 @@ function createContributionMaterializer(deps) {
         state: evaluateContributionState(existing, signature)
       };
     } catch (error) {
-      if (!chunkFFHW2JEK_cjs.isMissingTableError(error)) throw error;
+      if (!chunkRP7YITHX_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -1200,13 +965,13 @@ function createContributionMaterializer(deps) {
     for (const contribution of runtimeContributions()) {
       const read = await readContributionState(graphId, contribution);
       if (read.kind === "missing-table") {
-        throw new chunkYEDQLNVE_cjs.StoreNotInitializedError(graphId, "missing", {
+        throw new chunkG6P3OVDY_cjs.StoreNotInitializedError(graphId, "missing", {
           cause: read.error,
           details: { logicalName: contribution.logicalName }
         });
       }
       if (read.state !== "initialized") {
-        throw new chunkYEDQLNVE_cjs.StoreNotInitializedError(graphId, read.state, {
+        throw new chunkG6P3OVDY_cjs.StoreNotInitializedError(graphId, read.state, {
           details: { logicalName: contribution.logicalName }
         });
       }
@@ -1317,7 +1082,7 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (drizzleOrm.is(externalTx, brand)) return;
   const label = backend === "postgres" ? "Postgres" : "SQLite";
-  throw new chunkYEDQLNVE_cjs.ConfigurationError(
+  throw new chunkG6P3OVDY_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" }
   );
@@ -1327,15 +1092,15 @@ function chunkArray(values, size) {
     return [values];
   }
   const chunks = [];
-  for (let index3 = 0; index3 < values.length; index3 += size) {
-    chunks.push(values.slice(index3, index3 + size));
+  for (let index2 = 0; index2 < values.length; index2 += size) {
+    chunks.push(values.slice(index2, index2 + size));
   }
   return chunks;
 }
 function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
   const expectedVersion = expected.kind === "active" ? expected.version : 0;
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkYEDQLNVE_cjs.StaleVersionError({
+    throw new chunkG6P3OVDY_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
@@ -1356,7 +1121,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      if (!row) throw new chunkG6P3OVDY_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
@@ -1406,7 +1171,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      if (!row) throw new chunkG6P3OVDY_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
@@ -1416,18 +1181,19 @@ function createCommonOperationBackend(options) {
     },
     // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
     // within a transaction to prevent partial deletion on intermediate failure.
+    //
+    // Embeddings are NOT cleaned up here: they live in per-`(nodeKind,
+    // fieldPath)` strategy-owned tables addressable only with the slot
+    // context the graph-agnostic backend lacks. The store's hard-delete
+    // path (`executeNodeHardDelete`) drives `deleteNodeEmbeddings`, which
+    // resolves each embedding field and routes a per-field
+    // `backend.deleteEmbedding` through the active vector strategy.
     async hardDeleteNode(params) {
       const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
         params.graphId,
         params.id
       );
       await execution.execRun(deleteUniquesQuery);
-      const deleteEmbeddingsQuery = operationStrategy.buildHardDeleteEmbeddingsByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteEmbeddingsQuery);
       const deleteFulltextStatements = operationStrategy.buildDeleteFulltextByNode(
         params.graphId,
         params.kind,
@@ -1449,7 +1215,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      if (!row) throw new chunkG6P3OVDY_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
@@ -1499,7 +1265,7 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkYEDQLNVE_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      if (!row) throw new chunkG6P3OVDY_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
@@ -1550,7 +1316,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkYEDQLNVE_cjs.UniquenessError({
+        throw new chunkG6P3OVDY_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -1600,7 +1366,7 @@ function createCommonOperationBackend(options) {
       if (existingRaw !== void 0) {
         const existing = rowMappers.toSchemaVersionRow(existingRaw);
         if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkYEDQLNVE_cjs.SchemaContentConflictError({
+          throw new chunkG6P3OVDY_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -1648,7 +1414,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkYEDQLNVE_cjs.DatabaseOperationError(
+        throw new chunkG6P3OVDY_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -1669,7 +1435,7 @@ function createCommonOperationBackend(options) {
         )
       );
       if (!targetRaw) {
-        throw new chunkYEDQLNVE_cjs.MigrationError(
+        throw new chunkG6P3OVDY_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -1694,10 +1460,9 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
-  const fulltext2 = chunkPN37HVAV_cjs.quotedTableName(tables3.fulltextTableName);
+  const fulltext2 = chunkC2RWFIYP_cjs.quotedTableName(tables3.fulltextTableName);
   return [
     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}`,
     drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
@@ -1728,20 +1493,20 @@ function buildTemporalConditions(table, params) {
   return conditions;
 }
 function buildFindNodesByKind(tables3, params) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${nodes3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes3, params)
+    drizzleOrm.sql`${nodes2.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes2, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${nodes3.id} > ${params.after}`);
+    conditions.push(drizzleOrm.sql`${nodes2.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes3.id} ASC` : drizzleOrm.sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes2.id} ASC` : drizzleOrm.sql`${nodes2.createdAt} DESC, ${nodes2.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes3}
+      SELECT * FROM ${nodes2}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1749,286 +1514,286 @@ function buildFindNodesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes3}
+      SELECT * FROM ${nodes2}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes3}
+    SELECT * FROM ${nodes2}
     WHERE ${whereClause}
     ORDER BY ${orderByClause}
   `;
 }
 function buildCountNodesByKind(tables3, params) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${nodes3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes3, params)
+    drizzleOrm.sql`${nodes2.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes2, params)
   ];
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${nodes3}
+    SELECT COUNT(*) as count FROM ${nodes2}
     WHERE ${whereClause}
   `;
 }
 function buildFindEdgesByKind(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges3, params)
+    drizzleOrm.sql`${edges2.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges2, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges2.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges2.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges2.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges2.toId} = ${params.toId}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges3}
+      SELECT * FROM ${edges2}
       WHERE ${whereClause}
-      ORDER BY ${edges3.createdAt} DESC
+      ORDER BY ${edges2.createdAt} DESC
       LIMIT ${params.limit} OFFSET ${params.offset}
     `;
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges3}
+      SELECT * FROM ${edges2}
       WHERE ${whereClause}
-      ORDER BY ${edges3.createdAt} DESC
+      ORDER BY ${edges2.createdAt} DESC
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${edges3}
+    SELECT * FROM ${edges2}
     WHERE ${whereClause}
-    ORDER BY ${edges3.createdAt} DESC
+    ORDER BY ${edges2.createdAt} DESC
   `;
 }
 function buildCountEdgesByKind(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges3, params)
+    drizzleOrm.sql`${edges2.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges2, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges2.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges2.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges2.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges3.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges2.toId} = ${params.toId}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges3}
+    SELECT COUNT(*) as count FROM ${edges2}
     WHERE ${whereClause}
   `;
 }
 function buildInsertEdge(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
+  const columns = chunkC2RWFIYP_cjs.edgeColumnList(edges2);
   return drizzleOrm.sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkC2RWFIYP_cjs.sqlNull(params.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
   `;
 }
 function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
+  const columns = chunkC2RWFIYP_cjs.edgeColumnList(edges2);
   return drizzleOrm.sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
+      ${propsJson}, ${chunkC2RWFIYP_cjs.sqlNull(params.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertEdgesBatch(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
-  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
+  const { edges: edges2 } = tables3;
+  const columns = chunkC2RWFIYP_cjs.edgeColumnList(edges2);
   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}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkC2RWFIYP_cjs.sqlNull(edgeParams.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
   `;
 }
 function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
-  const columns = chunkPN37HVAV_cjs.edgeColumnList(edges3);
+  const { edges: edges2 } = tables3;
+  const columns = chunkC2RWFIYP_cjs.edgeColumnList(edges2);
   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}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkC2RWFIYP_cjs.sqlNull(edgeParams.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
 function buildGetEdge(tables3, graphId, id) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${edges3}
-    WHERE ${edges3.graphId} = ${graphId}
-      AND ${edges3.id} = ${id}
+    SELECT * FROM ${edges2}
+    WHERE ${edges2.graphId} = ${graphId}
+      AND ${edges2.id} = ${id}
   `;
 }
 function buildGetEdges(tables3, graphId, ids) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const idPlaceholders = drizzleOrm.sql.join(
     ids.map((edgeId) => drizzleOrm.sql`${edgeId}`),
     drizzleOrm.sql`, `
   );
   return drizzleOrm.sql`
-    SELECT * FROM ${edges3}
-    WHERE ${edges3.graphId} = ${graphId}
-      AND ${edges3.id} IN (${idPlaceholders})
+    SELECT * FROM ${edges2}
+    WHERE ${edges2.graphId} = ${graphId}
+      AND ${edges2.id} IN (${idPlaceholders})
   `;
 }
 function buildUpdateEdge(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(edges2.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(edges2.updatedAt)} = ${timestamp2}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(edges2.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(edges2.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
     return drizzleOrm.sql`
-      UPDATE ${edges3}
+      UPDATE ${edges2}
       SET ${setClause}
-      WHERE ${edges3.graphId} = ${params.graphId}
-        AND ${edges3.id} = ${params.id}
+      WHERE ${edges2.graphId} = ${params.graphId}
+        AND ${edges2.id} = ${params.id}
       RETURNING *
     `;
   }
   return drizzleOrm.sql`
-    UPDATE ${edges3}
+    UPDATE ${edges2}
     SET ${setClause}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.id} = ${params.id}
-      AND ${edges3.deletedAt} IS NULL
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.id} = ${params.id}
+      AND ${edges2.deletedAt} IS NULL
     RETURNING *
   `;
 }
 function buildDeleteEdge(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${edges3}
-    SET ${chunkPN37HVAV_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.id} = ${params.id}
-      AND ${edges3.deletedAt} IS NULL
+    UPDATE ${edges2}
+    SET ${chunkC2RWFIYP_cjs.quotedColumn(edges2.deletedAt)} = ${timestamp2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.id} = ${params.id}
+      AND ${edges2.deletedAt} IS NULL
   `;
 }
 function buildHardDeleteEdge(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${edges3}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.id} = ${params.id}
+    DELETE FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.id} = ${params.id}
   `;
 }
 function buildHardDeleteEdgesByNode(tables3, graphId, nodeKind, nodeId) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${edges3}
-    WHERE ${edges3.graphId} = ${graphId}
+    DELETE FROM ${edges2}
+    WHERE ${edges2.graphId} = ${graphId}
       AND (
-        (${edges3.fromKind} = ${nodeKind} AND ${edges3.fromId} = ${nodeId})
-        OR (${edges3.toKind} = ${nodeKind} AND ${edges3.toId} = ${nodeId})
+        (${edges2.fromKind} = ${nodeKind} AND ${edges2.fromId} = ${nodeId})
+        OR (${edges2.toKind} = ${nodeKind} AND ${edges2.toId} = ${nodeId})
       )
   `;
 }
 function buildCountEdgesFrom(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   if (params.activeOnly) {
     return drizzleOrm.sql`
-      SELECT COUNT(*) as count FROM ${edges3}
-      WHERE ${edges3.graphId} = ${params.graphId}
-        AND ${edges3.kind} = ${params.edgeKind}
-        AND ${edges3.fromKind} = ${params.fromKind}
-        AND ${edges3.fromId} = ${params.fromId}
-        AND ${edges3.deletedAt} IS NULL
-        AND ${edges3.validTo} IS NULL
+      SELECT COUNT(*) as count FROM ${edges2}
+      WHERE ${edges2.graphId} = ${params.graphId}
+        AND ${edges2.kind} = ${params.edgeKind}
+        AND ${edges2.fromKind} = ${params.fromKind}
+        AND ${edges2.fromId} = ${params.fromId}
+        AND ${edges2.deletedAt} IS NULL
+        AND ${edges2.validTo} IS NULL
     `;
   }
   return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges3}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.kind} = ${params.edgeKind}
-      AND ${edges3.fromKind} = ${params.fromKind}
-      AND ${edges3.fromId} = ${params.fromId}
-      AND ${edges3.deletedAt} IS NULL
+    SELECT COUNT(*) as count FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.kind} = ${params.edgeKind}
+      AND ${edges2.fromKind} = ${params.fromKind}
+      AND ${edges2.fromId} = ${params.fromId}
+      AND ${edges2.deletedAt} IS NULL
   `;
 }
 function buildEdgeExistsBetween(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    SELECT 1 FROM ${edges3}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.kind} = ${params.edgeKind}
-      AND ${edges3.fromKind} = ${params.fromKind}
-      AND ${edges3.fromId} = ${params.fromId}
-      AND ${edges3.toKind} = ${params.toKind}
-      AND ${edges3.toId} = ${params.toId}
-      AND ${edges3.deletedAt} IS NULL
+    SELECT 1 FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.kind} = ${params.edgeKind}
+      AND ${edges2.fromKind} = ${params.fromKind}
+      AND ${edges2.fromId} = ${params.fromId}
+      AND ${edges2.toKind} = ${params.toKind}
+      AND ${edges2.toId} = ${params.toId}
+      AND ${edges2.deletedAt} IS NULL
     LIMIT 1
   `;
 }
 function buildFindEdgesConnectedTo(tables3, params) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${edges3}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.deletedAt} IS NULL
-      AND ${edges3.fromKind} = ${params.nodeKind}
-      AND ${edges3.fromId} = ${params.nodeId}
+    SELECT * FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.deletedAt} IS NULL
+      AND ${edges2.fromKind} = ${params.nodeKind}
+      AND ${edges2.fromId} = ${params.nodeId}
     UNION ALL
-    SELECT * FROM ${edges3}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.deletedAt} IS NULL
-      AND ${edges3.toKind} = ${params.nodeKind}
-      AND ${edges3.toId} = ${params.nodeId}
+    SELECT * FROM ${edges2}
+    WHERE ${edges2.graphId} = ${params.graphId}
+      AND ${edges2.deletedAt} IS NULL
+      AND ${edges2.toKind} = ${params.nodeKind}
+      AND ${edges2.toId} = ${params.nodeId}
       AND NOT (
-        ${edges3.fromKind} = ${params.nodeKind}
-        AND ${edges3.fromId} = ${params.nodeId}
+        ${edges2.fromKind} = ${params.nodeKind}
+        AND ${edges2.fromId} = ${params.nodeId}
       )
   `;
 }
@@ -2038,7 +1803,7 @@ function resolveMode(mode) {
 function buildFulltextSearch(tableName, params, strategy) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
-  const table = chunkPN37HVAV_cjs.quotedTableName(tableName);
+  const table = chunkC2RWFIYP_cjs.quotedTableName(tableName);
   const matchCondition = strategy.matchCondition(
     tableName,
     params.query,
@@ -2087,136 +1852,136 @@ function assertValidSearchParams(params) {
   }
 }
 function buildInsertNode(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
+  const columns = chunkC2RWFIYP_cjs.nodeColumnList(nodes2);
   return drizzleOrm.sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
+      1, ${chunkC2RWFIYP_cjs.sqlNull(params.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
   `;
 }
 function buildInsertNodeNoReturn(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
+  const columns = chunkC2RWFIYP_cjs.nodeColumnList(nodes2);
   return drizzleOrm.sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkPN37HVAV_cjs.sqlNull(params.validFrom)}, ${chunkPN37HVAV_cjs.sqlNull(params.validTo)},
+      1, ${chunkC2RWFIYP_cjs.sqlNull(params.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertNodesBatch(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
-  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
+  const { nodes: nodes2 } = tables3;
+  const columns = chunkC2RWFIYP_cjs.nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    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`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkC2RWFIYP_cjs.sqlNull(nodeParams.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
   `;
 }
 function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
-  const columns = chunkPN37HVAV_cjs.nodeColumnList(nodes3);
+  const { nodes: nodes2 } = tables3;
+  const columns = chunkC2RWFIYP_cjs.nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    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`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkC2RWFIYP_cjs.sqlNull(nodeParams.validFrom)}, ${chunkC2RWFIYP_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
 function buildGetNode(tables3, graphId, kind, id) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes3}
-    WHERE ${nodes3.graphId} = ${graphId}
-      AND ${nodes3.kind} = ${kind}
-      AND ${nodes3.id} = ${id}
+    SELECT * FROM ${nodes2}
+    WHERE ${nodes2.graphId} = ${graphId}
+      AND ${nodes2.kind} = ${kind}
+      AND ${nodes2.id} = ${id}
   `;
 }
 function buildGetNodes(tables3, graphId, kind, ids) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const idPlaceholders = drizzleOrm.sql.join(
     ids.map((nodeId) => drizzleOrm.sql`${nodeId}`),
     drizzleOrm.sql`, `
   );
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes3}
-    WHERE ${nodes3.graphId} = ${graphId}
-      AND ${nodes3.kind} = ${kind}
-      AND ${nodes3.id} IN (${idPlaceholders})
+    SELECT * FROM ${nodes2}
+    WHERE ${nodes2.graphId} = ${graphId}
+      AND ${nodes2.kind} = ${kind}
+      AND ${nodes2.id} IN (${idPlaceholders})
   `;
 }
 function buildUpdateNode(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(nodes2.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(nodes2.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.version)} = ${chunkPN37HVAV_cjs.quotedColumn(nodes3.version)} + 1`
+      drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(nodes2.version)} = ${chunkC2RWFIYP_cjs.quotedColumn(nodes2.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(nodes2.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkPN37HVAV_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkC2RWFIYP_cjs.quotedColumn(nodes2.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
     return drizzleOrm.sql`
-      UPDATE ${nodes3}
+      UPDATE ${nodes2}
       SET ${setClause}
-      WHERE ${nodes3.graphId} = ${params.graphId}
-        AND ${nodes3.kind} = ${params.kind}
-        AND ${nodes3.id} = ${params.id}
+      WHERE ${nodes2.graphId} = ${params.graphId}
+        AND ${nodes2.kind} = ${params.kind}
+        AND ${nodes2.id} = ${params.id}
       RETURNING *
     `;
   }
   return drizzleOrm.sql`
-    UPDATE ${nodes3}
+    UPDATE ${nodes2}
     SET ${setClause}
-    WHERE ${nodes3.graphId} = ${params.graphId}
-      AND ${nodes3.kind} = ${params.kind}
-      AND ${nodes3.id} = ${params.id}
-      AND ${nodes3.deletedAt} IS NULL
+    WHERE ${nodes2.graphId} = ${params.graphId}
+      AND ${nodes2.kind} = ${params.kind}
+      AND ${nodes2.id} = ${params.id}
+      AND ${nodes2.deletedAt} IS NULL
     RETURNING *
   `;
 }
 function buildDeleteNode(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${nodes3}
-    SET ${chunkPN37HVAV_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
-    WHERE ${nodes3.graphId} = ${params.graphId}
-      AND ${nodes3.kind} = ${params.kind}
-      AND ${nodes3.id} = ${params.id}
-      AND ${nodes3.deletedAt} IS NULL
+    UPDATE ${nodes2}
+    SET ${chunkC2RWFIYP_cjs.quotedColumn(nodes2.deletedAt)} = ${timestamp2}
+    WHERE ${nodes2.graphId} = ${params.graphId}
+      AND ${nodes2.kind} = ${params.kind}
+      AND ${nodes2.id} = ${params.id}
+      AND ${nodes2.deletedAt} IS NULL
   `;
 }
 function buildHardDeleteNode(tables3, params) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${nodes3}
-    WHERE ${nodes3.graphId} = ${params.graphId}
-      AND ${nodes3.kind} = ${params.kind}
-      AND ${nodes3.id} = ${params.id}
+    DELETE FROM ${nodes2}
+    WHERE ${nodes2.graphId} = ${params.graphId}
+      AND ${nodes2.kind} = ${params.kind}
+      AND ${nodes2.id} = ${params.id}
   `;
 }
 function createSchemaDialectStrategy(dialect) {
@@ -2233,13 +1998,13 @@ var SCHEMA_DIALECT_STRATEGIES = {
   sqlite: createSchemaDialectStrategy("sqlite")
 };
 function buildInsertSchema(tables3, params, timestamp2, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions3 } = tables3;
+  const { schemaVersions: schemaVersions2 } = tables3;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const schemaDocumentJson = JSON.stringify(params.schemaDoc);
   const isActiveValue = strategy.booleanLiteral(params.isActive);
-  const columns = drizzleOrm.sql.raw(`"${schemaVersions3.graphId.name}", "${schemaVersions3.version.name}", "${schemaVersions3.schemaHash.name}", "${schemaVersions3.schemaDoc.name}", "${schemaVersions3.createdAt.name}", "${schemaVersions3.isActive.name}"`);
+  const columns = drizzleOrm.sql.raw(`"${schemaVersions2.graphId.name}", "${schemaVersions2.version.name}", "${schemaVersions2.schemaHash.name}", "${schemaVersions2.schemaDoc.name}", "${schemaVersions2.createdAt.name}", "${schemaVersions2.isActive.name}"`);
   return drizzleOrm.sql`
-    INSERT INTO ${schemaVersions3} (${columns})
+    INSERT INTO ${schemaVersions2} (${columns})
     VALUES (
       ${params.graphId}, ${params.version},
       ${params.schemaHash}, ${schemaDocumentJson},
@@ -2249,98 +2014,98 @@ function buildInsertSchema(tables3, params, timestamp2, dialect = "sqlite") {
   `;
 }
 function buildGetActiveSchema(tables3, graphId, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions3 } = tables3;
+  const { schemaVersions: schemaVersions2 } = tables3;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions3}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
-      AND ${schemaVersions3.isActive} = ${strategy.booleanLiteral(true)}
+    SELECT * FROM ${schemaVersions2}
+    WHERE ${schemaVersions2.graphId} = ${graphId}
+      AND ${schemaVersions2.isActive} = ${strategy.booleanLiteral(true)}
   `;
 }
 function buildGetSchemaVersion(tables3, graphId, version) {
-  const { schemaVersions: schemaVersions3 } = tables3;
+  const { schemaVersions: schemaVersions2 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions3}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
-      AND ${schemaVersions3.version} = ${version}
+    SELECT * FROM ${schemaVersions2}
+    WHERE ${schemaVersions2.graphId} = ${graphId}
+      AND ${schemaVersions2.version} = ${version}
   `;
 }
 function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions3 } = tables3;
+  const { schemaVersions: schemaVersions2 } = tables3;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
-    UPDATE ${schemaVersions3}
-    SET ${chunkPN37HVAV_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
+    UPDATE ${schemaVersions2}
+    SET ${chunkC2RWFIYP_cjs.quotedColumn(schemaVersions2.isActive)} = ${strategy.booleanLiteral(false)}
+    WHERE ${schemaVersions2.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
-    UPDATE ${schemaVersions3}
-    SET ${chunkPN37HVAV_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
-      AND ${schemaVersions3.version} = ${version}
+    UPDATE ${schemaVersions2}
+    SET ${chunkC2RWFIYP_cjs.quotedColumn(schemaVersions2.isActive)} = ${strategy.booleanLiteral(true)}
+    WHERE ${schemaVersions2.graphId} = ${graphId}
+      AND ${schemaVersions2.version} = ${version}
   `;
   return { deactivateAll, activateVersion };
 }
 function buildInsertUniqueSqlite(tables3, params) {
-  const { uniques: uniques3 } = tables3;
-  const columns = drizzleOrm.sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`);
-  const conflictColumns = drizzleOrm.sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`);
+  const { uniques: uniques2 } = tables3;
+  const columns = drizzleOrm.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 = drizzleOrm.sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
   return drizzleOrm.sql`
-    INSERT INTO ${uniques3} (${columns})
+    INSERT INTO ${uniques2} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} = CASE
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)}
       END,
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.concreteKind)} = CASE
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.concreteKind)}
       END,
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} = CASE
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)}
       END
-    RETURNING ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} as node_id
   `;
 }
 function buildInsertUniquePostgres(tables3, params) {
-  const { uniques: uniques3 } = tables3;
-  const columns = drizzleOrm.sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`);
-  const conflictColumns = drizzleOrm.sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`);
-  const tableName = drizzleOrm.getTableName(uniques3);
+  const { uniques: uniques2 } = tables3;
+  const columns = drizzleOrm.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 = drizzleOrm.sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
+  const tableName = drizzleOrm.getTableName(uniques2);
   const existingColumn = (column) => drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
   return drizzleOrm.sql`
-    INSERT INTO ${uniques3} (${columns})
+    INSERT INTO ${uniques2} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${existingColumn(uniques2.nodeId)}
       END,
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.concreteKind)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${existingColumn(uniques2.concreteKind)}
       END,
-      ${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)}
+      ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} = CASE
+        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques2.deletedAt)}
       END
-    RETURNING ${chunkPN37HVAV_cjs.quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
@@ -2352,327 +2117,67 @@ function buildInsertUnique(tables3, dialect, params) {
   return builder(tables3, params);
 }
 function buildDeleteUnique(tables3, params, timestamp2) {
-  const { uniques: uniques3 } = tables3;
+  const { uniques: uniques2 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${uniques3}
-    SET ${chunkPN37HVAV_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
-    WHERE ${uniques3.graphId} = ${params.graphId}
-      AND ${uniques3.nodeKind} = ${params.nodeKind}
-      AND ${uniques3.constraintName} = ${params.constraintName}
-      AND ${uniques3.key} = ${params.key}
-      AND ${uniques3.deletedAt} IS NULL
+    UPDATE ${uniques2}
+    SET ${chunkC2RWFIYP_cjs.quotedColumn(uniques2.deletedAt)} = ${timestamp2}
+    WHERE ${uniques2.graphId} = ${params.graphId}
+      AND ${uniques2.nodeKind} = ${params.nodeKind}
+      AND ${uniques2.constraintName} = ${params.constraintName}
+      AND ${uniques2.key} = ${params.key}
+      AND ${uniques2.deletedAt} IS NULL
   `;
 }
 function buildHardDeleteUniquesByNode(tables3, graphId, nodeId) {
-  const { uniques: uniques3 } = tables3;
+  const { uniques: uniques2 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${uniques3}
-    WHERE ${uniques3.graphId} = ${graphId}
-      AND ${uniques3.nodeId} = ${nodeId}
-  `;
-}
-function buildHardDeleteEmbeddingsByNode(tables3, graphId, nodeKind, nodeId) {
-  const { embeddings: embeddings3 } = tables3;
-  return drizzleOrm.sql`
-    DELETE FROM ${embeddings3}
-    WHERE ${embeddings3.graphId} = ${graphId}
-      AND ${embeddings3.nodeKind} = ${nodeKind}
-      AND ${embeddings3.nodeId} = ${nodeId}
+    DELETE FROM ${uniques2}
+    WHERE ${uniques2.graphId} = ${graphId}
+      AND ${uniques2.nodeId} = ${nodeId}
   `;
 }
 function buildCheckUnique(tables3, params) {
-  const { uniques: uniques3 } = tables3;
+  const { uniques: uniques2 } = tables3;
   if (params.includeDeleted) {
     return drizzleOrm.sql`
-      SELECT * FROM ${uniques3}
-      WHERE ${uniques3.graphId} = ${params.graphId}
-        AND ${uniques3.nodeKind} = ${params.nodeKind}
-        AND ${uniques3.constraintName} = ${params.constraintName}
-        AND ${uniques3.key} = ${params.key}
+      SELECT * FROM ${uniques2}
+      WHERE ${uniques2.graphId} = ${params.graphId}
+        AND ${uniques2.nodeKind} = ${params.nodeKind}
+        AND ${uniques2.constraintName} = ${params.constraintName}
+        AND ${uniques2.key} = ${params.key}
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${uniques3}
-    WHERE ${uniques3.graphId} = ${params.graphId}
-      AND ${uniques3.nodeKind} = ${params.nodeKind}
-      AND ${uniques3.constraintName} = ${params.constraintName}
-      AND ${uniques3.key} = ${params.key}
-      AND ${uniques3.deletedAt} IS NULL
+    SELECT * FROM ${uniques2}
+    WHERE ${uniques2.graphId} = ${params.graphId}
+      AND ${uniques2.nodeKind} = ${params.nodeKind}
+      AND ${uniques2.constraintName} = ${params.constraintName}
+      AND ${uniques2.key} = ${params.key}
+      AND ${uniques2.deletedAt} IS NULL
   `;
 }
 function buildCheckUniqueBatch(tables3, params) {
-  const { uniques: uniques3 } = tables3;
+  const { uniques: uniques2 } = tables3;
   const keyPlaceholders = drizzleOrm.sql.join(
     params.keys.map((key) => drizzleOrm.sql`${key}`),
     drizzleOrm.sql`, `
   );
   if (params.includeDeleted) {
     return drizzleOrm.sql`
-      SELECT * FROM ${uniques3}
-      WHERE ${uniques3.graphId} = ${params.graphId}
-        AND ${uniques3.nodeKind} = ${params.nodeKind}
-        AND ${uniques3.constraintName} = ${params.constraintName}
-        AND ${uniques3.key} IN (${keyPlaceholders})
+      SELECT * FROM ${uniques2}
+      WHERE ${uniques2.graphId} = ${params.graphId}
+        AND ${uniques2.nodeKind} = ${params.nodeKind}
+        AND ${uniques2.constraintName} = ${params.constraintName}
+        AND ${uniques2.key} IN (${keyPlaceholders})
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${uniques3}
-    WHERE ${uniques3.graphId} = ${params.graphId}
-      AND ${uniques3.nodeKind} = ${params.nodeKind}
-      AND ${uniques3.constraintName} = ${params.constraintName}
-      AND ${uniques3.key} IN (${keyPlaceholders})
-      AND ${uniques3.deletedAt} IS NULL
-  `;
-}
-var MAX_HNSW_EF_SEARCH = 1e3;
-function assertFiniteNumberArray(array, name) {
-  for (const [index3, value] of array.entries()) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new TypeError(
-        `${name}[${index3}] must be a finite number, got: ${value}`
-      );
-    }
-  }
-}
-function formatEmbeddingLiteral(embedding) {
-  assertFiniteNumberArray(embedding, "embedding");
-  return `[${embedding.join(",")}]`;
-}
-function buildUpsertEmbeddingPostgres(tables3, params, timestamp2) {
-  const { embeddings: embeddings3 } = tables3;
-  const embeddingLiteral = formatEmbeddingLiteral(params.embedding);
-  const columns = drizzleOrm.sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}", "${embeddings3.embedding.name}", "${embeddings3.dimensions.name}", "${embeddings3.createdAt.name}", "${embeddings3.updatedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}"`
-  );
-  const column = (target) => drizzleOrm.sql.raw(`"${target.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${embeddings3} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.fieldPath},
-      ${embeddingLiteral}::vector, ${params.dimensions}, ${timestamp2}, ${timestamp2}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${column(embeddings3.embedding)} = ${embeddingLiteral}::vector,
-      ${column(embeddings3.dimensions)} = ${params.dimensions},
-      ${column(embeddings3.updatedAt)} = ${timestamp2}
-  `;
-}
-function buildUpsertEmbeddingSqlite(tables3, params, timestamp2) {
-  const { embeddings: embeddings3 } = tables3;
-  const embeddingJson = JSON.stringify(params.embedding);
-  assertFiniteNumberArray(params.embedding, "embedding");
-  const columns = drizzleOrm.sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}", "${embeddings3.embedding.name}", "${embeddings3.dimensions.name}", "${embeddings3.createdAt.name}", "${embeddings3.updatedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}"`
-  );
-  const column = (target) => drizzleOrm.sql.raw(`"${target.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${embeddings3} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.fieldPath},
-      vec_f32(${embeddingJson}), ${params.dimensions}, ${timestamp2}, ${timestamp2}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${column(embeddings3.embedding)} = vec_f32(${embeddingJson}),
-      ${column(embeddings3.dimensions)} = ${params.dimensions},
-      ${column(embeddings3.updatedAt)} = ${timestamp2}
-  `;
-}
-function buildDeleteEmbedding(tables3, params) {
-  const { embeddings: embeddings3 } = tables3;
-  return drizzleOrm.sql`
-    DELETE FROM ${embeddings3}
-    WHERE ${embeddings3.graphId} = ${params.graphId}
-      AND ${embeddings3.nodeKind} = ${params.nodeKind}
-      AND ${embeddings3.nodeId} = ${params.nodeId}
-      AND ${embeddings3.fieldPath} = ${params.fieldPath}
-  `;
-}
-function buildGetEmbedding(tables3, graphId, nodeKind, nodeId, fieldPath) {
-  const { embeddings: embeddings3 } = tables3;
-  return drizzleOrm.sql`
-    SELECT * FROM ${embeddings3}
-    WHERE ${embeddings3.graphId} = ${graphId}
-      AND ${embeddings3.nodeKind} = ${nodeKind}
-      AND ${embeddings3.nodeId} = ${nodeId}
-      AND ${embeddings3.fieldPath} = ${fieldPath}
-  `;
-}
-function buildDistanceExpression(embeddingColumn, queryLiteral, metric) {
-  const vectorParameter = drizzleOrm.sql`${queryLiteral}::vector`;
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`(${embeddingColumn} <=> ${vectorParameter})`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`(${embeddingColumn} <-> ${vectorParameter})`;
-    }
-    case "inner_product": {
-      return drizzleOrm.sql`(${embeddingColumn} <#> ${vectorParameter})`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchScoreExpression(distanceExpression, metric) {
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`(1 - (${distanceExpression}))`;
-    }
-    case "l2":
-    case "inner_product": {
-      return distanceExpression;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchMinScoreCondition(distanceExpression, metric, minScore) {
-  switch (metric) {
-    case "cosine": {
-      const threshold = 1 - minScore;
-      return drizzleOrm.sql`${distanceExpression} <= ${threshold}`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      const negativeThreshold = -minScore;
-      return drizzleOrm.sql`${distanceExpression} <= ${negativeThreshold}`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function assertVectorSearchBounds(params) {
-  if (params.minScore !== void 0 && !Number.isFinite(params.minScore)) {
-    throw new TypeError(
-      `minScore must be a finite number, got: ${params.minScore}`
-    );
-  }
-  if (!Number.isInteger(params.limit) || params.limit <= 0) {
-    throw new Error(`limit must be a positive integer, got: ${params.limit}`);
-  }
-  if (params.efSearch !== void 0 && (!Number.isInteger(params.efSearch) || params.efSearch <= 0)) {
-    throw new Error(
-      `efSearch must be a positive integer, got: ${params.efSearch}`
-    );
-  }
-}
-function buildVectorSearchPostgres(tables3, params) {
-  const { embeddings: embeddings3 } = tables3;
-  const queryLiteral = formatEmbeddingLiteral(params.queryEmbedding);
-  assertVectorSearchBounds(params);
-  if (params.efSearch !== void 0 && params.efSearch > MAX_HNSW_EF_SEARCH) {
-    throw new RangeError(
-      `efSearch must be \u2264 ${MAX_HNSW_EF_SEARCH} (pgvector's hnsw.ef_search valid range is 1..${MAX_HNSW_EF_SEARCH}), got: ${params.efSearch}`
-    );
-  }
-  const embeddingColumn = drizzleOrm.sql`${embeddings3.embedding}`;
-  const distanceExpression = buildDistanceExpression(
-    embeddingColumn,
-    queryLiteral,
-    params.metric
-  );
-  const conditions = [
-    drizzleOrm.sql`${embeddings3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${embeddings3.nodeKind} = ${params.nodeKind}`,
-    drizzleOrm.sql`${embeddings3.fieldPath} = ${params.fieldPath}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(
-      buildVectorSearchMinScoreCondition(
-        distanceExpression,
-        params.metric,
-        params.minScore
-      )
-    );
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const scoreExpression = buildVectorSearchScoreExpression(
-    distanceExpression,
-    params.metric
-  );
-  return drizzleOrm.sql`
-    SELECT
-      ${embeddings3.nodeId} as node_id,
-      ${scoreExpression} as score
-    FROM ${embeddings3}
-    WHERE ${whereClause}
-    ORDER BY ${distanceExpression} ASC
-    LIMIT ${params.limit}
-  `;
-}
-function buildSqliteDistanceExpression(embeddingColumn, embeddingJson, metric) {
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`vec_distance_cosine(${embeddingColumn}, vec_f32(${embeddingJson}))`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`vec_distance_l2(${embeddingColumn}, vec_f32(${embeddingJson}))`;
-    }
-    case "inner_product": {
-      throw new Error(
-        "Inner product distance is not supported by sqlite-vec. Use 'cosine' or 'l2' metrics instead."
-      );
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchSqlite(tables3, params) {
-  const { embeddings: embeddings3 } = tables3;
-  assertFiniteNumberArray(params.queryEmbedding, "queryEmbedding");
-  const embeddingJson = JSON.stringify(params.queryEmbedding);
-  assertVectorSearchBounds(params);
-  const embeddingColumn = drizzleOrm.sql`${embeddings3.embedding}`;
-  const distanceExpression = buildSqliteDistanceExpression(
-    embeddingColumn,
-    embeddingJson,
-    params.metric
-  );
-  const conditions = [
-    drizzleOrm.sql`${embeddings3.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${embeddings3.nodeKind} = ${params.nodeKind}`,
-    drizzleOrm.sql`${embeddings3.fieldPath} = ${params.fieldPath}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(
-      buildVectorSearchMinScoreCondition(
-        distanceExpression,
-        params.metric,
-        params.minScore
-      )
-    );
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const scoreExpression = buildVectorSearchScoreExpression(
-    distanceExpression,
-    params.metric
-  );
-  return drizzleOrm.sql`
-    SELECT
-      ${embeddings3.nodeId} as node_id,
-      ${scoreExpression} as score
-    FROM ${embeddings3}
-    WHERE ${whereClause}
-    ORDER BY ${distanceExpression} ASC
-    LIMIT ${params.limit}
+    SELECT * FROM ${uniques2}
+    WHERE ${uniques2.graphId} = ${params.graphId}
+      AND ${uniques2.nodeKind} = ${params.nodeKind}
+      AND ${uniques2.constraintName} = ${params.constraintName}
+      AND ${uniques2.key} IN (${keyPlaceholders})
+      AND ${uniques2.deletedAt} IS NULL
   `;
 }
 
@@ -2715,7 +2220,6 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
-  buildHardDeleteEmbeddingsByNode,
   buildCheckUnique,
   buildCheckUniqueBatch,
   buildGetSchemaVersion
@@ -2759,221 +2263,10 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
   };
 }
 function createSqliteOperationStrategy(tables3, fulltextStrategy) {
-  const common = createCommonOperationStrategy(
-    tables3,
-    "sqlite",
-    fulltextStrategy
-  );
-  return {
-    ...common,
-    buildUpsertEmbedding(params, timestamp2) {
-      return buildUpsertEmbeddingSqlite(tables3, params, timestamp2);
-    },
-    buildDeleteEmbedding(params) {
-      return buildDeleteEmbedding(tables3, params);
-    },
-    buildVectorSearch(params) {
-      return buildVectorSearchSqlite(tables3, params);
-    }
-  };
+  return createCommonOperationStrategy(tables3, "sqlite", fulltextStrategy);
 }
 function createPostgresOperationStrategy(tables3, fulltextStrategy) {
-  const common = createCommonOperationStrategy(
-    tables3,
-    "postgres",
-    fulltextStrategy
-  );
-  return {
-    ...common,
-    buildUpsertEmbedding(params, timestamp2) {
-      return buildUpsertEmbeddingPostgres(tables3, params, timestamp2);
-    },
-    buildDeleteEmbedding(params) {
-      return buildDeleteEmbedding(tables3, params);
-    },
-    buildGetEmbedding(graphId, nodeKind, nodeId, fieldPath) {
-      return buildGetEmbedding(tables3, graphId, nodeKind, nodeId, fieldPath);
-    },
-    buildVectorSearch(params) {
-      return buildVectorSearchPostgres(tables3, params);
-    }
-  };
-}
-function assertPositiveInteger(value, name) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`${name} must be a positive integer, got: ${value}`);
-  }
-}
-function assertSafeIdentifier(value, name) {
-  if (!/^[a-z0-9_]+$/i.test(value)) {
-    throw new Error(
-      `${name} must contain only alphanumeric characters and underscores, got: ${value}`
-    );
-  }
-}
-function sanitizeIdentifier(s) {
-  return s.toLowerCase().replaceAll(/[^a-z0-9_]/g, "_");
-}
-function quoteIdentifier(value) {
-  return `"${value.replaceAll('"', '""')}"`;
-}
-function shortHash(input) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let index3 = 0; index3 < input.length; index3++) {
-    const ch = input.codePointAt(index3);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  const hi = (h2 >>> 0).toString(16).padStart(8, "0");
-  const lo = (h1 >>> 0).toString(16).padStart(8, "0");
-  return `${hi}${lo}`.slice(0, 8);
-}
-function generateVectorIndexName(graphId, nodeKind, fieldPath, metric = "cosine") {
-  const parts = [
-    "idx_emb",
-    sanitizeIdentifier(graphId),
-    sanitizeIdentifier(nodeKind),
-    sanitizeIdentifier(fieldPath),
-    metric
-  ];
-  const name = parts.join("_");
-  if (name.length <= chunkCTHNVU6K_cjs.MAX_PG_IDENTIFIER_LENGTH) {
-    return name;
-  }
-  const hash = shortHash(name);
-  const truncated = name.slice(0, chunkCTHNVU6K_cjs.MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length);
-  return `${truncated}_${hash}`;
-}
-function getOperatorClass(metric) {
-  switch (metric) {
-    case "cosine": {
-      return "vector_cosine_ops";
-    }
-    case "l2": {
-      return "vector_l2_ops";
-    }
-    case "inner_product": {
-      return "vector_ip_ops";
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error("Unsupported vector metric: " + String(_exhaustive));
-    }
-  }
-}
-function escapeSqlString(value) {
-  const tag = `tg${crypto.randomUUID().replaceAll("-", "").slice(0, 8)}`;
-  return `$${tag}$${value}$${tag}$`;
-}
-async function createPostgresVectorIndex(db, options) {
-  const {
-    graphId,
-    nodeKind,
-    fieldPath,
-    dimensions,
-    embeddingsTableName = "typegraph_node_embeddings",
-    indexType = "hnsw",
-    metric = "cosine",
-    hnswM = 16,
-    hnswEfConstruction = 64,
-    ivfflatLists = 100
-  } = options;
-  assertPositiveInteger(dimensions, "dimensions");
-  assertPositiveInteger(hnswM, "hnswM");
-  assertPositiveInteger(hnswEfConstruction, "hnswEfConstruction");
-  assertPositiveInteger(ivfflatLists, "ivfflatLists");
-  const indexName = generateVectorIndexName(graphId, nodeKind, fieldPath, metric);
-  const operatorClass = getOperatorClass(metric);
-  const quotedEmbeddingsTableName = quoteIdentifier(embeddingsTableName);
-  assertSafeIdentifier(indexName, "indexName");
-  const safeGraphId = escapeSqlString(graphId);
-  const safeNodeKind = escapeSqlString(nodeKind);
-  const safeFieldPath = escapeSqlString(fieldPath);
-  let indexSql;
-  const concurrentClause = options.concurrent === true ? "CONCURRENTLY " : "";
-  if (indexType === "hnsw") {
-    indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX ${concurrentClause}IF NOT EXISTS ${indexName}
-      ON ${quotedEmbeddingsTableName}
-      USING hnsw ((embedding::vector(${dimensions})) ${operatorClass})
-      WITH (m = ${hnswM}, ef_construction = ${hnswEfConstruction})
-      WHERE graph_id = ${safeGraphId}
-        AND node_kind = ${safeNodeKind}
-        AND field_path = ${safeFieldPath}
-    `);
-  } else if (indexType === "ivfflat") {
-    indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX ${concurrentClause}IF NOT EXISTS ${indexName}
-      ON ${quotedEmbeddingsTableName}
-      USING ivfflat ((embedding::vector(${dimensions})) ${operatorClass})
-      WITH (lists = ${ivfflatLists})
-      WHERE graph_id = ${safeGraphId}
-        AND node_kind = ${safeNodeKind}
-        AND field_path = ${safeFieldPath}
-    `);
-  } else {
-    return {
-      indexName,
-      success: true,
-      message: `Index type "${indexType}" not supported, skipping index creation`
-    };
-  }
-  try {
-    await db.execute(indexSql);
-    return {
-      indexName,
-      success: true,
-      message: `Created ${indexType.toUpperCase()} index "${indexName}" for ${nodeKind}.${fieldPath}`
-    };
-  } catch (error) {
-    return {
-      indexName,
-      success: false,
-      message: `Failed to create index: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-async function dropPostgresVectorIndex(db, indexName) {
-  assertSafeIdentifier(indexName, "indexName");
-  try {
-    const dropSql = drizzleOrm.sql.raw(`DROP INDEX IF EXISTS ${indexName}`);
-    await db.execute(dropSql);
-    return {
-      indexName,
-      success: true,
-      message: `Dropped index "${indexName}"`
-    };
-  } catch (error) {
-    return {
-      indexName,
-      success: false,
-      message: `Failed to drop index: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-function createSqliteVectorIndex(_options) {
-  const indexName = generateVectorIndexName(
-    _options.graphId,
-    _options.nodeKind,
-    _options.fieldPath,
-    _options.metric
-  );
-  return {
-    indexName,
-    success: true,
-    message: "SQLite/sqlite-vec uses optimized internal indexing, no explicit index needed"
-  };
-}
-function dropSqliteVectorIndex(graphId, nodeKind, fieldPath, metric = "cosine") {
-  const indexName = generateVectorIndexName(graphId, nodeKind, fieldPath, metric);
-  return {
-    indexName,
-    success: true,
-    message: "SQLite/sqlite-vec does not use explicit indexes"
-  };
+  return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
 }
 
 // src/backend/drizzle/execution/lru.ts
@@ -3026,19 +2319,11 @@ exports.createEdgeRowMapper = createEdgeRowMapper;
 exports.createNodeRowMapper = createNodeRowMapper;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
 exports.createPostgresTables = createPostgresTables;
-exports.createPostgresVectorIndex = createPostgresVectorIndex;
 exports.createSchemaVersionRowMapper = createSchemaVersionRowMapper;
 exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
-exports.createSqliteTables = createSqliteTables;
-exports.createSqliteVectorIndex = createSqliteVectorIndex;
 exports.createUniqueRowMapper = createUniqueRowMapper;
-exports.dropPostgresVectorIndex = dropPostgresVectorIndex;
-exports.dropSqliteVectorIndex = dropSqliteVectorIndex;
+exports.createVectorSlotLatch = createVectorSlotLatch;
 exports.edges = edges;
-exports.edges2 = edges2;
-exports.embeddings = embeddings;
-exports.embeddings2 = embeddings2;
-exports.formatPostgresTimestamp = formatPostgresTimestamp;
 exports.fulltext = fulltext;
 exports.gateFulltext = gateFulltext;
 exports.gateFulltextMethods = gateFulltextMethods;
@@ -3048,19 +2333,18 @@ exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
 exports.generateSqliteCreateTableSQL = generateSqliteCreateTableSQL;
 exports.generateSqliteDDL = generateSqliteDDL;
 exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
-exports.generateVectorIndexName = generateVectorIndexName;
 exports.getOrCreateLru = getOrCreateLru;
 exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
 exports.mapKindRemovalRow = mapKindRemovalRow;
 exports.mapMaterializationRow = mapMaterializationRow;
+exports.mapVectorWriteError = mapVectorWriteError;
 exports.nodes = nodes;
-exports.nodes2 = nodes2;
 exports.nowIso = nowIso;
 exports.schemaVersions = schemaVersions;
-exports.schemaVersions2 = schemaVersions2;
-exports.tables = tables;
-exports.tables2 = tables2;
+exports.tables = tables2;
 exports.uniques = uniques;
-exports.uniques2 = uniques2;
-//# sourceMappingURL=chunk-NYQFPGYP.cjs.map
-//# sourceMappingURL=chunk-NYQFPGYP.cjs.map
+exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
+exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
+exports.vectorSlotFromParams = vectorSlotFromParams;
+//# sourceMappingURL=chunk-ZYQEXGYC.cjs.map
+//# sourceMappingURL=chunk-ZYQEXGYC.cjs.map