@nicia-ai/typegraph 0.28.1 → 0.29.0

package/dist/{chunk-TKM2WDT4.js → chunk-3DTLDGIM.js}

@@ -1,10 +1,11 @@
-import { isMissingTableError, sortedReplacer } from './chunk-O57GYGYK.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders, tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-ZTREJOGB.js';
-import { MAX_PG_IDENTIFIER_LENGTH, sha256Hex } from './chunk-EJCDOA37.js';
-import { DatabaseOperationError, ConfigurationError, MigrationError, SchemaContentConflictError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-U5ROKVRF.js';
+import { tables } from './chunk-HKN622O4.js';
+import { parseDimensionMismatch, isMissingTableError, sortedReplacer } from './chunk-M6OC455F.js';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-7KLVFWXR.js';
+import { sha256Hex } from './chunk-OGUH56BB.js';
+import { EmbeddingDimensionChangedError, DatabaseOperationError, ConfigurationError, MigrationError, SchemaContentConflictError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-MB363HT5.js';
 import { sql, is, getTableName } from 'drizzle-orm';
 import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
-import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, uniqueIndex as uniqueIndex$1, blob, getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
 
 var regconfig = customType({
   dataType: () => "regconfig"
@@ -12,24 +13,6 @@ var regconfig = customType({
 var tsvector = customType({
   dataType: () => "tsvector"
 });
-var vector = 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 = {
@@ -37,7 +20,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",
@@ -47,7 +29,7 @@ var DEFAULT_TABLE_NAMES = {
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
   const indexes = options.indexes ?? [];
-  const nodes3 = pgTable(
+  const nodes2 = pgTable(
     n.nodes,
     {
       graphId: text("graph_id").notNull(),
@@ -75,7 +57,7 @@ function createPostgresTables(names = {}, options = {}) {
       ...buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
-  const edges3 = pgTable(
+  const edges2 = pgTable(
     n.edges,
     {
       graphId: text("graph_id").notNull(),
@@ -134,7 +116,7 @@ function createPostgresTables(names = {}, options = {}) {
       ...buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
-  const uniques3 = pgTable(
+  const uniques2 = pgTable(
     n.uniques,
     {
       graphId: text("graph_id").notNull(),
@@ -152,7 +134,7 @@ function createPostgresTables(names = {}, options = {}) {
       index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
     ]
   );
-  const schemaVersions3 = pgTable(
+  const schemaVersions2 = pgTable(
     n.schemaVersions,
     {
       graphId: text("graph_id").notNull(),
@@ -173,38 +155,6 @@ function createPostgresTables(names = {}, options = {}) {
       uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = TRUE`)
     ]
   );
-  const embeddings3 = pgTable(
-    n.embeddings,
-    {
-      graphId: text("graph_id").notNull(),
-      nodeKind: text("node_kind").notNull(),
-      nodeId: text("node_id").notNull(),
-      fieldPath: text("field_path").notNull(),
-      /** Embedding vector stored as native pgvector type */
-      embedding: vector("embedding").notNull(),
-      /** Number of dimensions (for validation) */
-      dimensions: integer("dimensions").notNull(),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
-    },
-    (t) => [
-      primaryKey({
-        columns: [t.graphId, t.nodeKind, t.nodeId, t.fieldPath]
-      }),
-      // Index for looking up embeddings by node
-      index(`${n.embeddings}_node_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.nodeId
-      ),
-      // Index for filtering by kind and field (used in vector search)
-      index(`${n.embeddings}_kind_field_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.fieldPath
-      )
-    ]
-  );
   const indexMaterializations = pgTable(
     n.indexMaterializations,
     {
@@ -287,11 +237,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,
@@ -300,270 +249,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 = sqliteTable(
-    n.nodes,
-    {
-      graphId: text$1("graph_id").notNull(),
-      kind: text$1("kind").notNull(),
-      id: text$1("id").notNull(),
-      props: text$1("props").notNull(),
-      version: integer$1("version").notNull().default(1),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.kind, t.id] }),
-      index$1(`${n.nodes}_kind_idx`).on(t.graphId, t.kind),
-      index$1(`${n.nodes}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      index$1(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
-      index$1(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...buildSqliteNodeIndexBuilders(t, indexes)
-    ]
-  );
-  const edges3 = sqliteTable(
-    n.edges,
-    {
-      graphId: text$1("graph_id").notNull(),
-      id: text$1("id").notNull(),
-      kind: text$1("kind").notNull(),
-      fromKind: text$1("from_kind").notNull(),
-      fromId: text$1("from_id").notNull(),
-      toKind: text$1("to_kind").notNull(),
-      toId: text$1("to_id").notNull(),
-      props: text$1("props").notNull(),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.id] }),
-      index$1(`${n.edges}_kind_idx`).on(t.graphId, t.kind),
-      // Directional traversal index (outgoing): supports endpoint lookups
-      // and extra filtering by edge kind / target kind.
-      index$1(`${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.
-      index$1(`${n.edges}_to_idx`).on(
-        t.graphId,
-        t.toKind,
-        t.toId,
-        t.kind,
-        t.fromKind,
-        t.deletedAt,
-        t.validTo
-      ),
-      index$1(`${n.edges}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      index$1(`${n.edges}_deleted_idx`).on(t.graphId, t.deletedAt),
-      index$1(`${n.edges}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      index$1(`${n.edges}_cardinality_idx`).on(
-        t.graphId,
-        t.kind,
-        t.fromKind,
-        t.fromId,
-        t.validTo
-      ),
-      ...buildSqliteEdgeIndexBuilders(t, indexes)
-    ]
-  );
-  const uniques3 = sqliteTable(
-    n.uniques,
-    {
-      graphId: text$1("graph_id").notNull(),
-      nodeKind: text$1("node_kind").notNull(),
-      constraintName: text$1("constraint_name").notNull(),
-      key: text$1("key").notNull(),
-      nodeId: text$1("node_id").notNull(),
-      concreteKind: text$1("concrete_kind").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
-      }),
-      index$1(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
-    ]
-  );
-  const schemaVersions3 = sqliteTable(
-    n.schemaVersions,
-    {
-      graphId: text$1("graph_id").notNull(),
-      version: integer$1("version").notNull(),
-      schemaHash: text$1("schema_hash").notNull(),
-      schemaDoc: text$1("schema_doc").notNull(),
-      createdAt: text$1("created_at").notNull(),
-      isActive: integer$1("is_active", { mode: "boolean" }).notNull().default(false)
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.version] }),
-      index$1(`${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`.
-      uniqueIndex$1(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = 1`)
-    ]
-  );
-  const embeddings3 = sqliteTable(
-    n.embeddings,
-    {
-      graphId: text$1("graph_id").notNull(),
-      nodeKind: text$1("node_kind").notNull(),
-      nodeId: text$1("node_id").notNull(),
-      fieldPath: text$1("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: blob("embedding", { mode: "buffer" }).notNull(),
-      /** Number of dimensions (for validation) */
-      dimensions: integer$1("dimensions").notNull(),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull()
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.nodeKind, t.nodeId, t.fieldPath]
-      }),
-      // Index for looking up embeddings by node
-      index$1(`${n.embeddings}_node_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.nodeId
-      ),
-      // Index for filtering by kind and field (used in vector search)
-      index$1(`${n.embeddings}_kind_field_idx`).on(
-        t.graphId,
-        t.nodeKind,
-        t.fieldPath
-      )
-    ]
-  );
-  const indexMaterializations = sqliteTable(
-    n.indexMaterializations,
-    {
-      indexName: text$1("index_name").notNull(),
-      graphId: text$1("graph_id").notNull(),
-      entity: text$1("entity").notNull(),
-      kind: text$1("kind").notNull(),
-      signature: text$1("signature").notNull(),
-      schemaVersion: integer$1("schema_version").notNull(),
-      materializedAt: text$1("materialized_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [primaryKey$1({ columns: [t.indexName] })]
-  );
-  const kindRemovals = sqliteTable(
-    n.kindRemovals,
-    {
-      graphId: text$1("graph_id").notNull(),
-      kindName: text$1("kind_name").notNull(),
-      entity: text$1("entity").notNull(),
-      schemaVersion: integer$1("schema_version").notNull(),
-      removedAt: text$1("removed_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
-      })
-    ]
-  );
-  const reconciliationMarkers = sqliteTable(
-    n.reconciliationMarkers,
-    {
-      graphId: text$1("graph_id").notNull(),
-      reconciledToVersion: integer$1("reconciled_to_version").notNull()
-    },
-    (t) => [primaryKey$1({ columns: [t.graphId] })]
-  );
-  const contributionMaterializations = sqliteTable(
-    n.contributionMaterializations,
-    {
-      graphId: text$1("graph_id").notNull(),
-      logicalName: text$1("logical_name").notNull(),
-      owner: text$1("owner").notNull(),
-      tableName: text$1("table_name").notNull(),
-      signature: text$1("signature").notNull(),
-      materializedAt: text$1("materialized_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
-      })
-    ]
-  );
-  return {
-    nodes: nodes3,
-    edges: edges3,
-    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": {
@@ -619,9 +306,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";
 }
@@ -680,8 +367,8 @@ function inlineSqlOrThrow(value, context) {
 function generateSqliteCreateIndexSQL(table) {
   const config = 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`)}` : "";
@@ -697,7 +384,7 @@ function isSqliteTable(value) {
 function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
   return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
 }
-function sqliteContributions(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+function sqliteContributions(tables3 = tables, fulltextStrategy = fts5Strategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
@@ -719,10 +406,12 @@ function sqliteContributions(tables3 = tables2, fulltextStrategy = fts5Strategy)
   }
   return contributions;
 }
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
-  return sqliteContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
+function generateSqliteDDL(tables3 = tables, fulltextStrategy = fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
 }
-function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+function generateSqliteMigrationSQL(tables3 = tables, fulltextStrategy = fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -768,10 +457,7 @@ function generatePgCreateTableSQL(table) {
   const config = getTableConfig$1(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");
     }
@@ -792,8 +478,8 @@ function generatePgCreateTableSQL(table) {
 function generatePgCreateIndexSQL(table) {
   const config = getTableConfig$1(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}` : "";
@@ -807,7 +493,7 @@ function generatePgCreateIndexSQL(table) {
 function isPgTable(value) {
   return is(value, PgTable);
 }
-function postgresContributions(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
+function postgresContributions(tables3 = tables2, fulltextStrategy = tsvectorStrategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isPgTable(table)) continue;
@@ -830,10 +516,12 @@ function postgresContributions(tables3 = tables, fulltextStrategy = tsvectorStra
   }
   return contributions;
 }
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
-  return postgresContributions(tables3, fulltextStrategy).flatMap((contribution) => [...contribution.createDdl]);
+function generatePostgresDDL(tables3 = tables2, fulltextStrategy = tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
 }
-function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
+function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = 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}
@@ -841,6 +529,83 @@ function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvec
 ${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 = parseDimensionMismatch(error);
+  if (mismatch === void 0) return error;
+  const attempted = mismatch.actual ?? "a different number of";
+  return new 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) {
@@ -1325,8 +1090,8 @@ 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;
 }
@@ -1414,18 +1179,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,
@@ -1695,7 +1461,6 @@ function buildClearGraph(tables3, graphId) {
   const fulltext2 = quotedTableName(tables3.fulltextTableName);
   return [
     sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
-    sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
@@ -1726,20 +1491,20 @@ function buildTemporalConditions(table, params) {
   return conditions;
 }
 function buildFindNodesByKind(tables3, params) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const conditions = [
-    sql`${nodes3.graphId} = ${params.graphId}`,
-    sql`${nodes3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes3, params)
+    sql`${nodes2.graphId} = ${params.graphId}`,
+    sql`${nodes2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes2, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(sql`${nodes3.id} > ${params.after}`);
+    conditions.push(sql`${nodes2.id} > ${params.after}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
-  const orderByClause = params.orderBy === "id" ? sql`${nodes3.id} ASC` : sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? sql`${nodes2.id} ASC` : sql`${nodes2.createdAt} DESC, ${nodes2.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
-      SELECT * FROM ${nodes3}
+      SELECT * FROM ${nodes2}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1747,104 +1512,104 @@ function buildFindNodesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return sql`
-      SELECT * FROM ${nodes3}
+      SELECT * FROM ${nodes2}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return 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 = [
-    sql`${nodes3.graphId} = ${params.graphId}`,
-    sql`${nodes3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes3, params)
+    sql`${nodes2.graphId} = ${params.graphId}`,
+    sql`${nodes2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes2, params)
   ];
   const whereClause = sql.join(conditions, sql` AND `);
   return 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 = [
-    sql`${edges3.graphId} = ${params.graphId}`,
-    sql`${edges3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges3, params)
+    sql`${edges2.graphId} = ${params.graphId}`,
+    sql`${edges2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges2, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges2.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges2.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges2.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges3.toId} = ${params.toId}`);
+    conditions.push(sql`${edges2.toId} = ${params.toId}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
   if (params.limit !== void 0 && params.offset !== void 0) {
     return 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 sql`
-      SELECT * FROM ${edges3}
+      SELECT * FROM ${edges2}
       WHERE ${whereClause}
-      ORDER BY ${edges3.createdAt} DESC
+      ORDER BY ${edges2.createdAt} DESC
       LIMIT ${params.limit}
     `;
   }
   return 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 = [
-    sql`${edges3.graphId} = ${params.graphId}`,
-    sql`${edges3.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges3, params)
+    sql`${edges2.graphId} = ${params.graphId}`,
+    sql`${edges2.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges2, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges2.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges2.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges2.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges3.toId} = ${params.toId}`);
+    conditions.push(sql`${edges2.toId} = ${params.toId}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
   return 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 = edgeColumnList(edges3);
+  const columns = edgeColumnList(edges2);
   return sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
@@ -1855,11 +1620,11 @@ function buildInsertEdge(tables3, params, timestamp2) {
   `;
 }
 function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges3);
+  const columns = edgeColumnList(edges2);
   return sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
@@ -1869,164 +1634,164 @@ function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
   `;
 }
 function buildInsertEdgesBatch(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
-  const columns = edgeColumnList(edges3);
+  const { edges: edges2 } = tables3;
+  const columns = edgeColumnList(edges2);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
     return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
 function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
-  const { edges: edges3 } = tables3;
-  const columns = edgeColumnList(edges3);
+  const { edges: edges2 } = tables3;
+  const columns = edgeColumnList(edges2);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
     return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${edges3} (${columns})
+    INSERT INTO ${edges2} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
 function buildGetEdge(tables3, graphId, id) {
-  const { edges: edges3 } = tables3;
+  const { edges: edges2 } = tables3;
   return 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 = sql.join(
     ids.map((edgeId) => sql`${edgeId}`),
     sql`, `
   );
   return 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 = [
-    sql`${quotedColumn(edges3.props)} = ${propsJson}`,
-    sql`${quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+    sql`${quotedColumn(edges2.props)} = ${propsJson}`,
+    sql`${quotedColumn(edges2.updatedAt)} = ${timestamp2}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(edges3.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(edges2.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(edges3.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(edges2.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
   if (params.clearDeleted) {
     return 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 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 sql`
-    UPDATE ${edges3}
-    SET ${quotedColumn(edges3.deletedAt)} = ${timestamp2}
-    WHERE ${edges3.graphId} = ${params.graphId}
-      AND ${edges3.id} = ${params.id}
-      AND ${edges3.deletedAt} IS NULL
+    UPDATE ${edges2}
+    SET ${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 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 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 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 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 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 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}
       )
   `;
 }
@@ -2085,11 +1850,11 @@ function assertValidSearchParams(params) {
   }
 }
 function buildInsertNode(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes3);
+  const columns = nodeColumnList(nodes2);
   return sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
       1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
@@ -2099,11 +1864,11 @@ function buildInsertNode(tables3, params, timestamp2) {
   `;
 }
 function buildInsertNodeNoReturn(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes3);
+  const columns = nodeColumnList(nodes2);
   return sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
       1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
@@ -2112,109 +1877,109 @@ function buildInsertNodeNoReturn(tables3, params, timestamp2) {
   `;
 }
 function buildInsertNodesBatch(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
-  const columns = nodeColumnList(nodes3);
+  const { nodes: nodes2 } = tables3;
+  const columns = nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
     return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
 function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
-  const { nodes: nodes3 } = tables3;
-  const columns = nodeColumnList(nodes3);
+  const { nodes: nodes2 } = tables3;
+  const columns = nodeColumnList(nodes2);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
     return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${nodes3} (${columns})
+    INSERT INTO ${nodes2} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
 function buildGetNode(tables3, graphId, kind, id) {
-  const { nodes: nodes3 } = tables3;
+  const { nodes: nodes2 } = tables3;
   return 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 = sql.join(
     ids.map((nodeId) => sql`${nodeId}`),
     sql`, `
   );
   return 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 = [
-    sql`${quotedColumn(nodes3.props)} = ${propsJson}`,
-    sql`${quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+    sql`${quotedColumn(nodes2.props)} = ${propsJson}`,
+    sql`${quotedColumn(nodes2.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      sql`${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1`
+      sql`${quotedColumn(nodes2.version)} = ${quotedColumn(nodes2.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(nodes2.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(nodes3.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(nodes2.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
   if (params.clearDeleted) {
     return 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 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 sql`
-    UPDATE ${nodes3}
-    SET ${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 ${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 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) {
@@ -2231,13 +1996,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 = sql.raw(`"${schemaVersions3.graphId.name}", "${schemaVersions3.version.name}", "${schemaVersions3.schemaHash.name}", "${schemaVersions3.schemaDoc.name}", "${schemaVersions3.createdAt.name}", "${schemaVersions3.isActive.name}"`);
+  const columns = sql.raw(`"${schemaVersions2.graphId.name}", "${schemaVersions2.version.name}", "${schemaVersions2.schemaHash.name}", "${schemaVersions2.schemaDoc.name}", "${schemaVersions2.createdAt.name}", "${schemaVersions2.isActive.name}"`);
   return sql`
-    INSERT INTO ${schemaVersions3} (${columns})
+    INSERT INTO ${schemaVersions2} (${columns})
     VALUES (
       ${params.graphId}, ${params.version},
       ${params.schemaHash}, ${schemaDocumentJson},
@@ -2247,98 +2012,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 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 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 = sql`
-    UPDATE ${schemaVersions3}
-    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
+    UPDATE ${schemaVersions2}
+    SET ${quotedColumn(schemaVersions2.isActive)} = ${strategy.booleanLiteral(false)}
+    WHERE ${schemaVersions2.graphId} = ${graphId}
   `;
   const activateVersion = sql`
-    UPDATE ${schemaVersions3}
-    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions3.graphId} = ${graphId}
-      AND ${schemaVersions3.version} = ${version}
+    UPDATE ${schemaVersions2}
+    SET ${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 = 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 = sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`);
+  const { uniques: uniques2 } = tables3;
+  const columns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`);
+  const conflictColumns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
   return sql`
-    INSERT INTO ${uniques3} (${columns})
+    INSERT INTO ${uniques2} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques3.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques3.nodeId)}
+      ${quotedColumn(uniques2.nodeId)} = CASE
+        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${quotedColumn(uniques2.nodeId)}
       END,
-      ${quotedColumn(uniques3.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques3.concreteKind)}
+      ${quotedColumn(uniques2.concreteKind)} = CASE
+        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${quotedColumn(uniques2.concreteKind)}
       END,
-      ${quotedColumn(uniques3.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques3.deletedAt)}
+      ${quotedColumn(uniques2.deletedAt)} = CASE
+        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${quotedColumn(uniques2.deletedAt)}
       END
-    RETURNING ${quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${quotedColumn(uniques2.nodeId)} as node_id
   `;
 }
 function buildInsertUniquePostgres(tables3, params) {
-  const { uniques: uniques3 } = tables3;
-  const columns = 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 = sql.raw(`"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`);
-  const tableName = getTableName(uniques3);
+  const { uniques: uniques2 } = tables3;
+  const columns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`);
+  const conflictColumns = sql.raw(`"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`);
+  const tableName = getTableName(uniques2);
   const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
   return sql`
-    INSERT INTO ${uniques3} (${columns})
+    INSERT INTO ${uniques2} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${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)}
+      ${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,
-      ${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)}
+      ${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,
-      ${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)}
+      ${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 ${quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${quotedColumn(uniques2.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
@@ -2350,327 +2115,67 @@ function buildInsertUnique(tables3, dialect, params) {
   return builder(tables3, params);
 }
 function buildDeleteUnique(tables3, params, timestamp2) {
-  const { uniques: uniques3 } = tables3;
+  const { uniques: uniques2 } = tables3;
   return sql`
-    UPDATE ${uniques3}
-    SET ${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 ${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 sql`
-    DELETE FROM ${uniques3}
-    WHERE ${uniques3.graphId} = ${graphId}
-      AND ${uniques3.nodeId} = ${nodeId}
-  `;
-}
-function buildHardDeleteEmbeddingsByNode(tables3, graphId, nodeKind, nodeId) {
-  const { embeddings: embeddings3 } = tables3;
-  return 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 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 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 = sql.join(
     params.keys.map((key) => sql`${key}`),
     sql`, `
   );
   if (params.includeDeleted) {
     return 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 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 = 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 = sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}"`
-  );
-  const column = (target) => sql.raw(`"${target.name}"`);
-  return 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 = 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 = sql.raw(
-    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}"`
-  );
-  const column = (target) => sql.raw(`"${target.name}"`);
-  return 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 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 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 = sql`${queryLiteral}::vector`;
-  switch (metric) {
-    case "cosine": {
-      return sql`(${embeddingColumn} <=> ${vectorParameter})`;
-    }
-    case "l2": {
-      return sql`(${embeddingColumn} <-> ${vectorParameter})`;
-    }
-    case "inner_product": {
-      return sql`(${embeddingColumn} <#> ${vectorParameter})`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchScoreExpression(distanceExpression, metric) {
-  switch (metric) {
-    case "cosine": {
-      return 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 sql`${distanceExpression} <= ${threshold}`;
-    }
-    case "l2": {
-      return sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      const negativeThreshold = -minScore;
-      return 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 = sql`${embeddings3.embedding}`;
-  const distanceExpression = buildDistanceExpression(
-    embeddingColumn,
-    queryLiteral,
-    params.metric
-  );
-  const conditions = [
-    sql`${embeddings3.graphId} = ${params.graphId}`,
-    sql`${embeddings3.nodeKind} = ${params.nodeKind}`,
-    sql`${embeddings3.fieldPath} = ${params.fieldPath}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(
-      buildVectorSearchMinScoreCondition(
-        distanceExpression,
-        params.metric,
-        params.minScore
-      )
-    );
-  }
-  const whereClause = sql.join(conditions, sql` AND `);
-  const scoreExpression = buildVectorSearchScoreExpression(
-    distanceExpression,
-    params.metric
-  );
-  return 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 sql`vec_distance_cosine(${embeddingColumn}, vec_f32(${embeddingJson}))`;
-    }
-    case "l2": {
-      return 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 = sql`${embeddings3.embedding}`;
-  const distanceExpression = buildSqliteDistanceExpression(
-    embeddingColumn,
-    embeddingJson,
-    params.metric
-  );
-  const conditions = [
-    sql`${embeddings3.graphId} = ${params.graphId}`,
-    sql`${embeddings3.nodeKind} = ${params.nodeKind}`,
-    sql`${embeddings3.fieldPath} = ${params.fieldPath}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(
-      buildVectorSearchMinScoreCondition(
-        distanceExpression,
-        params.metric,
-        params.minScore
-      )
-    );
-  }
-  const whereClause = sql.join(conditions, sql` AND `);
-  const scoreExpression = buildVectorSearchScoreExpression(
-    distanceExpression,
-    params.metric
-  );
-  return 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
   `;
 }
 
@@ -2713,7 +2218,6 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
-  buildHardDeleteEmbeddingsByNode,
   buildCheckUnique,
   buildCheckUniqueBatch,
   buildGetSchemaVersion
@@ -2757,221 +2261,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 <= MAX_PG_IDENTIFIER_LENGTH) {
-    return name;
-  }
-  const hash = shortHash(name);
-  const truncated = name.slice(0, 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 = 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 = 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 = 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
@@ -3001,6 +2294,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, SQLITE_ROW_MAPPER_CONFIG, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, coerceNumericScore, compileQueryWithDialect, createCommonOperationBackend, createContributionMaterializer, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
-//# sourceMappingURL=chunk-TKM2WDT4.js.map
-//# sourceMappingURL=chunk-TKM2WDT4.js.map
+export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, SQLITE_ROW_MAPPER_CONFIG, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, coerceNumericScore, compileQueryWithDialect, createCommonOperationBackend, createContributionMaterializer, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createSchemaVersionRowMapper, createSqliteOperationStrategy, createUniqueRowMapper, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, nowIso, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-3DTLDGIM.js.map
+//# sourceMappingURL=chunk-3DTLDGIM.js.map