@nicia-ai/typegraph 0.4.0 → 0.6.0

package/dist/chunk-JPO7W262.js

@@ -0,0 +1,2093 @@
+import { DatabaseOperationError, UniquenessError } from './chunk-SJ2QMDXY.js';
+import { buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-U3452TEU.js';
+import { sqliteTable, text, integer, primaryKey, index, blob, getTableConfig } from 'drizzle-orm/sqlite-core';
+import { customType, pgTable, timestamp, integer as integer$1, jsonb, text as text$1, primaryKey as primaryKey$1, index as index$1, boolean, getTableConfig as getTableConfig$1 } from 'drizzle-orm/pg-core';
+import { sql, getTableName } from 'drizzle-orm';
+
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  uniques: "typegraph_node_uniques",
+  schemaVersions: "typegraph_schema_versions",
+  embeddings: "typegraph_node_embeddings"
+};
+function createSqliteTables(names = {}, options = {}) {
+  const n = { ...DEFAULT_TABLE_NAMES, ...names };
+  const indexes = options.indexes ?? [];
+  const nodes3 = sqliteTable(
+    n.nodes,
+    {
+      graphId: text("graph_id").notNull(),
+      kind: text("kind").notNull(),
+      id: text("id").notNull(),
+      props: text("props").notNull(),
+      version: integer("version").notNull().default(1),
+      validFrom: text("valid_from"),
+      validTo: text("valid_to"),
+      createdAt: text("created_at").notNull(),
+      updatedAt: text("updated_at").notNull(),
+      deletedAt: text("deleted_at")
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      index(`${n.nodes}_kind_idx`).on(t.graphId, t.kind),
+      index(`${n.nodes}_kind_created_idx`).on(
+        t.graphId,
+        t.kind,
+        t.deletedAt,
+        t.createdAt
+      ),
+      index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
+      index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
+      ...buildSqliteNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = sqliteTable(
+    n.edges,
+    {
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      kind: text("kind").notNull(),
+      fromKind: text("from_kind").notNull(),
+      fromId: text("from_id").notNull(),
+      toKind: text("to_kind").notNull(),
+      toId: text("to_id").notNull(),
+      props: text("props").notNull(),
+      validFrom: text("valid_from"),
+      validTo: text("valid_to"),
+      createdAt: text("created_at").notNull(),
+      updatedAt: text("updated_at").notNull(),
+      deletedAt: text("deleted_at")
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.id] }),
+      index(`${n.edges}_kind_idx`).on(t.graphId, t.kind),
+      // Directional traversal index (outgoing): supports endpoint lookups
+      // and extra filtering by edge kind / target kind.
+      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.
+      index(`${n.edges}_to_idx`).on(
+        t.graphId,
+        t.toKind,
+        t.toId,
+        t.kind,
+        t.fromKind,
+        t.deletedAt,
+        t.validTo
+      ),
+      index(`${n.edges}_kind_created_idx`).on(
+        t.graphId,
+        t.kind,
+        t.deletedAt,
+        t.createdAt
+      ),
+      index(`${n.edges}_deleted_idx`).on(t.graphId, t.deletedAt),
+      index(`${n.edges}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
+      index(`${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("graph_id").notNull(),
+      nodeKind: text("node_kind").notNull(),
+      constraintName: text("constraint_name").notNull(),
+      key: text("key").notNull(),
+      nodeId: text("node_id").notNull(),
+      concreteKind: text("concrete_kind").notNull(),
+      deletedAt: text("deleted_at")
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const schemaVersions3 = sqliteTable(
+    n.schemaVersions,
+    {
+      graphId: text("graph_id").notNull(),
+      version: integer("version").notNull(),
+      schemaHash: text("schema_hash").notNull(),
+      schemaDoc: text("schema_doc").notNull(),
+      createdAt: text("created_at").notNull(),
+      isActive: integer("is_active", { mode: "boolean" }).notNull().default(false)
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.version] }),
+      index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+    ]
+  );
+  const embeddings3 = sqliteTable(
+    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 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("dimensions").notNull(),
+      createdAt: text("created_at").notNull(),
+      updatedAt: text("updated_at").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
+      )
+    ]
+  );
+  return { nodes: nodes3, edges: edges3, uniques: uniques3, schemaVersions: schemaVersions3, embeddings: embeddings3 };
+}
+var tables = createSqliteTables();
+var { nodes, edges, uniques, schemaVersions, embeddings } = tables;
+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_NAMES2 = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  uniques: "typegraph_node_uniques",
+  schemaVersions: "typegraph_schema_versions",
+  embeddings: "typegraph_node_embeddings"
+};
+function createPostgresTables(names = {}, options = {}) {
+  const n = { ...DEFAULT_TABLE_NAMES2, ...names };
+  const indexes = options.indexes ?? [];
+  const nodes3 = pgTable(
+    n.nodes,
+    {
+      graphId: text$1("graph_id").notNull(),
+      kind: text$1("kind").notNull(),
+      id: text$1("id").notNull(),
+      props: jsonb("props").notNull(),
+      version: integer$1("version").notNull().default(1),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true })
+    },
+    (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),
+      ...buildPostgresNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = pgTable(
+    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: jsonb("props").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true })
+    },
+    (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
+      ),
+      ...buildPostgresEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const uniques3 = pgTable(
+    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: timestamp("deleted_at", { withTimezone: true })
+    },
+    (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 = pgTable(
+    n.schemaVersions,
+    {
+      graphId: text$1("graph_id").notNull(),
+      version: integer$1("version").notNull(),
+      schemaHash: text$1("schema_hash").notNull(),
+      schemaDoc: jsonb("schema_doc").notNull(),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      isActive: boolean("is_active").notNull().default(false)
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.version] }),
+      index$1(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive)
+    ]
+  );
+  const embeddings3 = pgTable(
+    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 native pgvector type */
+      embedding: vector("embedding").notNull(),
+      /** Number of dimensions (for validation) */
+      dimensions: integer$1("dimensions").notNull(),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).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
+      )
+    ]
+  );
+  return { nodes: nodes3, edges: edges3, uniques: uniques3, schemaVersions: schemaVersions3, embeddings: embeddings3 };
+}
+var tables2 = createPostgresTables();
+var { nodes: nodes2, edges: edges2, uniques: uniques2, schemaVersions: schemaVersions2, embeddings: embeddings2 } = tables2;
+function getSqliteColumnType(column) {
+  switch (column.columnType) {
+    case "SQLiteText": {
+      return "TEXT";
+    }
+    case "SQLiteInteger": {
+      return "INTEGER";
+    }
+    case "SQLiteReal": {
+      return "REAL";
+    }
+    case "SQLiteBlob": {
+      return "BLOB";
+    }
+    default: {
+      return "TEXT";
+    }
+  }
+}
+function formatDefaultValue(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return JSON.stringify(value);
+}
+function generateSqliteCreateTableSQL(table) {
+  const config = getTableConfig(table);
+  const columnDefs = [];
+  for (const column of config.columns) {
+    const parts = [
+      `"${column.name}"`,
+      getSqliteColumnType(column)
+    ];
+    if (column.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (column.hasDefault && column.default !== void 0) {
+      parts.push(`DEFAULT ${formatDefaultValue(column.default)}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  const pk = config.primaryKeys[0];
+  if (pk) {
+    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
+  }
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function renderIndexColumn(col) {
+  if (col && typeof col === "object" && "name" in col) {
+    return `"${col.name}"`;
+  }
+  const sql10 = tryInlineSql(col);
+  if (sql10 !== void 0) {
+    return sql10;
+  }
+  return "unknown";
+}
+function tryInlineSql(value) {
+  if (value && typeof value === "object" && "getSQL" in value) {
+    const maybe = value;
+    if (typeof maybe.getSQL === "function") {
+      return inlineSql(maybe.getSQL());
+    }
+  }
+  return inlineSql(value);
+}
+function flattenSqlChunk(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (typeof chunk === "object" && chunk !== null) {
+    if ("value" in chunk && Array.isArray(chunk.value)) {
+      return chunk.value.map((part) => flattenSqlChunk(part)).join("");
+    }
+    if ("queryChunks" in chunk && Array.isArray(chunk.queryChunks)) {
+      return chunk.queryChunks.map((part) => flattenSqlChunk(part)).join("");
+    }
+    if ("getSQL" in chunk) {
+      const maybe = chunk;
+      if (typeof maybe.getSQL === "function") {
+        return flattenSqlChunk(maybe.getSQL());
+      }
+    }
+  }
+  throw new Error(`Unable to inline SQL chunk: ${String(chunk)}`);
+}
+function inlineSql(value) {
+  try {
+    return flattenSqlChunk(value);
+  } catch {
+    return void 0;
+  }
+}
+function inlineSqlOrThrow(value, context) {
+  const inlined = inlineSql(value);
+  if (inlined === void 0) {
+    throw new Error(`Unable to inline SQL for ${context}`);
+  }
+  return inlined;
+}
+function generateSqliteCreateIndexSQL(table) {
+  const config = getTableConfig(table);
+  const statements = [];
+  for (const index3 of config.indexes) {
+    const indexConfig = index3.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`)}` : "";
+    statements.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}" (${columns})${where};`
+    );
+  }
+  return statements;
+}
+function generateSqliteDDL(tables3 = tables) {
+  const statements = [];
+  for (const table of Object.values(tables3)) {
+    statements.push(generateSqliteCreateTableSQL(table));
+  }
+  for (const table of Object.values(tables3)) {
+    statements.push(...generateSqliteCreateIndexSQL(table));
+  }
+  return statements;
+}
+function generateSqliteMigrationSQL(tables3 = tables) {
+  return generateSqliteDDL(tables3).join("\n\n");
+}
+function getPgColumnType(column) {
+  switch (column.columnType) {
+    case "PgText": {
+      return "TEXT";
+    }
+    case "PgInteger": {
+      return "INTEGER";
+    }
+    case "PgBoolean": {
+      return "BOOLEAN";
+    }
+    case "PgJsonb": {
+      return "JSONB";
+    }
+    case "PgTimestamp": {
+      return column.config?.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
+    }
+    case "PgReal": {
+      return "REAL";
+    }
+    case "PgDoublePrecision": {
+      return "DOUBLE PRECISION";
+    }
+    case "PgCustomColumn": {
+      const dataType = column.getSQLType?.();
+      return dataType ?? "TEXT";
+    }
+    default: {
+      return "TEXT";
+    }
+  }
+}
+function formatPgDefaultValue(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  return JSON.stringify(value);
+}
+function generatePgCreateTableSQL(table) {
+  const config = getTableConfig$1(table);
+  const columnDefs = [];
+  for (const column of config.columns) {
+    const parts = [
+      `"${column.name}"`,
+      getPgColumnType(column)
+    ];
+    if (column.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (column.hasDefault && column.default !== void 0) {
+      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  const pk = config.primaryKeys[0];
+  if (pk) {
+    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
+  }
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function generatePgCreateIndexSQL(table) {
+  const config = getTableConfig$1(table);
+  const statements = [];
+  for (const index3 of config.indexes) {
+    const indexConfig = index3.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}` : "";
+    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `PostgreSQL index "${indexConfig.name}" WHERE clause`)}` : "";
+    statements.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}"${method} (${columns})${where};`
+    );
+  }
+  return statements;
+}
+function generatePostgresDDL(tables3 = tables2) {
+  const statements = [];
+  for (const table of Object.values(tables3)) {
+    statements.push(generatePgCreateTableSQL(table));
+  }
+  for (const table of Object.values(tables3)) {
+    statements.push(...generatePgCreateIndexSQL(table));
+  }
+  return statements;
+}
+function generatePostgresMigrationSQL(tables3 = tables2) {
+  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
+  const ddlSql = generatePostgresDDL(tables3).join("\n\n");
+  return `${extensionSql}
+
+${ddlSql}`;
+}
+
+// src/backend/types.ts
+var SQLITE_CAPABILITIES = {
+  jsonb: false,
+  // SQLite uses TEXT with json functions
+  partialIndexes: true,
+  // SQLite supports WHERE in CREATE INDEX
+  ginIndexes: false,
+  // SQLite doesn't have GIN
+  cte: true,
+  // SQLite supports WITH
+  returning: true,
+  // SQLite 3.35+ supports RETURNING
+  transactions: true
+  // SQLite supports transactions
+};
+var POSTGRES_CAPABILITIES = {
+  jsonb: true,
+  // PostgreSQL has native JSONB
+  partialIndexes: true,
+  ginIndexes: true,
+  cte: true,
+  returning: true,
+  transactions: true
+  // PostgreSQL supports transactions
+};
+var D1_CAPABILITIES = {
+  jsonb: false,
+  // D1 uses TEXT with json functions
+  partialIndexes: true,
+  ginIndexes: false,
+  cte: true,
+  returning: true,
+  transactions: false
+  // D1 does NOT support atomic transactions
+};
+
+// src/backend/drizzle/row-mappers.ts
+function requireTimestamp(value, field) {
+  if (value === void 0) {
+    throw new DatabaseOperationError(
+      `Expected non-null ${field} timestamp`,
+      { operation: "select", entity: "row" }
+    );
+  }
+  return value;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nullToUndefined(value) {
+  return value ?? void 0;
+}
+function formatPostgresTimestamp(value) {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") {
+    if (value.includes("T")) return value;
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+    return value;
+  }
+  return void 0;
+}
+function normalizeJsonColumn(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? {});
+}
+var SQLITE_ROW_MAPPER_CONFIG = {
+  formatTimestamp: (value) => nullToUndefined(value),
+  normalizeJson: (value) => value
+};
+var POSTGRES_ROW_MAPPER_CONFIG = {
+  formatTimestamp: formatPostgresTimestamp,
+  normalizeJson: normalizeJsonColumn
+};
+function createNodeRowMapper(config) {
+  return (row) => ({
+    graph_id: row.graph_id,
+    kind: row.kind,
+    id: row.id,
+    props: config.normalizeJson(row.props),
+    version: row.version,
+    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
+    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
+    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
+    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createEdgeRowMapper(config) {
+  return (row) => ({
+    graph_id: row.graph_id,
+    id: row.id,
+    kind: row.kind,
+    from_kind: row.from_kind,
+    from_id: row.from_id,
+    to_kind: row.to_kind,
+    to_id: row.to_id,
+    props: config.normalizeJson(row.props),
+    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
+    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
+    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
+    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createUniqueRowMapper(config) {
+  return (row) => ({
+    graph_id: row.graph_id,
+    node_kind: row.node_kind,
+    constraint_name: row.constraint_name,
+    key: row.key,
+    node_id: row.node_id,
+    concrete_kind: row.concrete_kind,
+    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createSchemaVersionRowMapper(config) {
+  return (row) => {
+    const isActiveValue = row.is_active;
+    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
+    return {
+      graph_id: row.graph_id,
+      version: row.version,
+      schema_hash: row.schema_hash,
+      schema_doc: config.normalizeJson(row.schema_doc),
+      created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+      is_active: isActive
+    };
+  };
+}
+
+// src/backend/drizzle/operation-backend-core.ts
+function chunkArray(values, size) {
+  if (values.length <= size) {
+    return [values];
+  }
+  const chunks = [];
+  for (let index3 = 0; index3 < values.length; index3 += size) {
+    chunks.push(values.slice(index3, index3 + size));
+  }
+  return chunks;
+}
+function createCommonOperationBackend(options) {
+  const { batchConfig, execution, operationStrategy, rowMappers } = options;
+  const nowIso2 = options.nowIso ?? nowIso;
+  return {
+    async insertNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertNode(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      return rowMappers.toNodeRow(row);
+    },
+    async insertNodeNoReturn(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertNodeNoReturn(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async insertNodesBatch(params) {
+      if (params.length === 0) {
+        return;
+      }
+      const timestamp2 = nowIso2();
+      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertNodesBatch(chunk, timestamp2);
+        await execution.execRun(query);
+      }
+    },
+    async insertNodesBatchReturning(params) {
+      if (params.length === 0) {
+        return [];
+      }
+      const timestamp2 = nowIso2();
+      const allRows = [];
+      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertNodesBatchReturning(chunk, timestamp2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
+      }
+      return allRows;
+    },
+    async getNode(graphId, kind, id) {
+      const query = operationStrategy.buildGetNode(graphId, kind, id);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toNodeRow(row) : void 0;
+    },
+    async getNodes(graphId, kind, ids) {
+      if (ids.length === 0) return [];
+      const allRows = [];
+      for (const chunk of chunkArray(ids, batchConfig.getNodesChunkSize)) {
+        const query = operationStrategy.buildGetNodes(graphId, kind, chunk);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
+      }
+      return allRows;
+    },
+    async updateNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateNode(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      return rowMappers.toNodeRow(row);
+    },
+    async deleteNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteNode(params, timestamp2);
+      await execution.execRun(query);
+    },
+    // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
+    // within a transaction to prevent partial deletion on intermediate failure.
+    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 deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
+        params.graphId,
+        params.kind,
+        params.id
+      );
+      await execution.execRun(deleteEdgesQuery);
+      const query = operationStrategy.buildHardDeleteNode(params);
+      await execution.execRun(query);
+    },
+    async insertEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertEdge(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      return rowMappers.toEdgeRow(row);
+    },
+    async insertEdgeNoReturn(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async insertEdgesBatch(params) {
+      if (params.length === 0) {
+        return;
+      }
+      const timestamp2 = nowIso2();
+      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertEdgesBatch(chunk, timestamp2);
+        await execution.execRun(query);
+      }
+    },
+    async insertEdgesBatchReturning(params) {
+      if (params.length === 0) {
+        return [];
+      }
+      const timestamp2 = nowIso2();
+      const allRows = [];
+      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk, timestamp2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
+      }
+      return allRows;
+    },
+    async getEdge(graphId, id) {
+      const query = operationStrategy.buildGetEdge(graphId, id);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toEdgeRow(row) : void 0;
+    },
+    async getEdges(graphId, ids) {
+      if (ids.length === 0) return [];
+      const allRows = [];
+      for (const chunk of chunkArray(ids, batchConfig.getEdgesChunkSize)) {
+        const query = operationStrategy.buildGetEdges(graphId, chunk);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
+      }
+      return allRows;
+    },
+    async updateEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateEdge(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      return rowMappers.toEdgeRow(row);
+    },
+    async deleteEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteEdge(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async hardDeleteEdge(params) {
+      const query = operationStrategy.buildHardDeleteEdge(params);
+      await execution.execRun(query);
+    },
+    async countEdgesFrom(params) {
+      const query = operationStrategy.buildCountEdgesFrom(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async edgeExistsBetween(params) {
+      const query = operationStrategy.buildEdgeExistsBetween(params);
+      const row = await execution.execGet(query);
+      return row !== void 0;
+    },
+    async findEdgesConnectedTo(params) {
+      const query = operationStrategy.buildFindEdgesConnectedTo(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toEdgeRow(row));
+    },
+    async findNodesByKind(params) {
+      const query = operationStrategy.buildFindNodesByKind(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toNodeRow(row));
+    },
+    async countNodesByKind(params) {
+      const query = operationStrategy.buildCountNodesByKind(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async findEdgesByKind(params) {
+      const query = operationStrategy.buildFindEdgesByKind(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toEdgeRow(row));
+    },
+    async countEdgesByKind(params) {
+      const query = operationStrategy.buildCountEdgesByKind(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async insertUnique(params) {
+      const query = operationStrategy.buildInsertUnique(params);
+      const result = await execution.execGet(query);
+      if (result && result.node_id !== params.nodeId) {
+        throw new UniquenessError({
+          constraintName: params.constraintName,
+          kind: params.nodeKind,
+          existingId: result.node_id,
+          newId: params.nodeId,
+          fields: []
+        });
+      }
+    },
+    async deleteUnique(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteUnique(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async checkUnique(params) {
+      const query = operationStrategy.buildCheckUnique(params);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toUniqueRow(row) : void 0;
+    },
+    async checkUniqueBatch(params) {
+      if (params.keys.length === 0) return [];
+      const query = operationStrategy.buildCheckUniqueBatch(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toUniqueRow(row));
+    },
+    async getActiveSchema(graphId) {
+      const query = operationStrategy.buildGetActiveSchema(graphId);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
+    },
+    async insertSchema(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertSchema(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Insert schema failed: no row returned", { operation: "insert", entity: "schema" });
+      return rowMappers.toSchemaVersionRow(row);
+    },
+    async getSchemaVersion(graphId, version) {
+      const query = operationStrategy.buildGetSchemaVersion(graphId, version);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
+    },
+    async setActiveSchema(graphId, version) {
+      const queries = operationStrategy.buildSetActiveSchema(graphId, version);
+      await execution.execRun(queries.deactivateAll);
+      await execution.execRun(queries.activateVersion);
+    },
+    async clearGraph(graphId) {
+      const statements = operationStrategy.buildClearGraph(graphId);
+      for (const statement of statements) {
+        await execution.execRun(statement);
+      }
+    }
+  };
+}
+function buildClearGraph(tables3, graphId) {
+  return [
+    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}`,
+    sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
+  ];
+}
+function buildTemporalConditions(table, params) {
+  const conditions = [];
+  const mode = params.temporalMode;
+  if (mode === "includeTombstones") return conditions;
+  if (params.excludeDeleted !== false) {
+    conditions.push(sql`${table.deletedAt} IS NULL`);
+  }
+  if (mode === "current" || mode === "asOf") {
+    const asOf = params.asOf;
+    conditions.push(
+      sql`(${table.validFrom} IS NULL OR ${table.validFrom} <= ${asOf})`,
+      sql`(${table.validTo} IS NULL OR ${table.validTo} > ${asOf})`
+    );
+  }
+  return conditions;
+}
+function buildFindNodesByKind(tables3, params) {
+  const { nodes: nodes3 } = tables3;
+  const conditions = [
+    sql`${nodes3.graphId} = ${params.graphId}`,
+    sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
+  ];
+  const whereClause = sql.join(conditions, sql` AND `);
+  if (params.limit !== void 0 && params.offset !== void 0) {
+    return sql`
+      SELECT * FROM ${nodes3}
+      WHERE ${whereClause}
+      ORDER BY ${nodes3.createdAt} DESC
+      LIMIT ${params.limit} OFFSET ${params.offset}
+    `;
+  }
+  if (params.limit !== void 0) {
+    return sql`
+      SELECT * FROM ${nodes3}
+      WHERE ${whereClause}
+      ORDER BY ${nodes3.createdAt} DESC
+      LIMIT ${params.limit}
+    `;
+  }
+  return sql`
+    SELECT * FROM ${nodes3}
+    WHERE ${whereClause}
+    ORDER BY ${nodes3.createdAt} DESC
+  `;
+}
+function buildCountNodesByKind(tables3, params) {
+  const { nodes: nodes3 } = tables3;
+  const conditions = [
+    sql`${nodes3.graphId} = ${params.graphId}`,
+    sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
+  ];
+  const whereClause = sql.join(conditions, sql` AND `);
+  return sql`
+    SELECT COUNT(*) as count FROM ${nodes3}
+    WHERE ${whereClause}
+  `;
+}
+function buildFindEdgesByKind(tables3, params) {
+  const { edges: edges3 } = tables3;
+  const conditions = [
+    sql`${edges3.graphId} = ${params.graphId}`,
+    sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
+  ];
+  if (params.fromKind !== void 0) {
+    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
+  }
+  if (params.fromId !== void 0) {
+    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
+  }
+  if (params.toKind !== void 0) {
+    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
+  }
+  if (params.toId !== void 0) {
+    conditions.push(sql`${edges3.toId} = ${params.toId}`);
+  }
+  const whereClause = sql.join(conditions, sql` AND `);
+  if (params.limit !== void 0 && params.offset !== void 0) {
+    return sql`
+      SELECT * FROM ${edges3}
+      WHERE ${whereClause}
+      ORDER BY ${edges3.createdAt} DESC
+      LIMIT ${params.limit} OFFSET ${params.offset}
+    `;
+  }
+  if (params.limit !== void 0) {
+    return sql`
+      SELECT * FROM ${edges3}
+      WHERE ${whereClause}
+      ORDER BY ${edges3.createdAt} DESC
+      LIMIT ${params.limit}
+    `;
+  }
+  return sql`
+    SELECT * FROM ${edges3}
+    WHERE ${whereClause}
+    ORDER BY ${edges3.createdAt} DESC
+  `;
+}
+function buildCountEdgesByKind(tables3, params) {
+  const { edges: edges3 } = tables3;
+  const conditions = [
+    sql`${edges3.graphId} = ${params.graphId}`,
+    sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
+  ];
+  if (params.fromKind !== void 0) {
+    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
+  }
+  if (params.fromId !== void 0) {
+    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
+  }
+  if (params.toKind !== void 0) {
+    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
+  }
+  if (params.toId !== void 0) {
+    conditions.push(sql`${edges3.toId} = ${params.toId}`);
+  }
+  const whereClause = sql.join(conditions, sql` AND `);
+  return sql`
+    SELECT COUNT(*) as count FROM ${edges3}
+    WHERE ${whereClause}
+  `;
+}
+function sqlNull(value) {
+  return value ?? sql.raw("NULL");
+}
+function quotedColumn(column) {
+  return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function nodeColumnList(nodes3) {
+  return sql.raw(`"${nodes3.graphId.name}", "${nodes3.kind.name}", "${nodes3.id.name}", "${nodes3.props.name}", "${nodes3.version.name}", "${nodes3.validFrom.name}", "${nodes3.validTo.name}", "${nodes3.createdAt.name}", "${nodes3.updatedAt.name}"`);
+}
+function edgeColumnList(edges3) {
+  return sql.raw(`"${edges3.graphId.name}", "${edges3.id.name}", "${edges3.kind.name}", "${edges3.fromKind.name}", "${edges3.fromId.name}", "${edges3.toKind.name}", "${edges3.toId.name}", "${edges3.props.name}", "${edges3.validFrom.name}", "${edges3.validTo.name}", "${edges3.createdAt.name}", "${edges3.updatedAt.name}"`);
+}
+
+// src/backend/drizzle/operations/edges.ts
+function buildInsertEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const columns = edgeColumnList(edges3);
+  return sql`
+    INSERT INTO ${edges3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.id}, ${params.kind},
+      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
+      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
+    )
+    RETURNING *
+  `;
+}
+function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const columns = edgeColumnList(edges3);
+  return sql`
+    INSERT INTO ${edges3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.id}, ${params.kind},
+      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
+      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
+    )
+  `;
+}
+function buildInsertEdgesBatch(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
+  const columns = edgeColumnList(edges3);
+  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})
+    VALUES ${sql.join(values, sql`, `)}
+  `;
+}
+function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
+  const columns = edgeColumnList(edges3);
+  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})
+    VALUES ${sql.join(values, sql`, `)}
+    RETURNING *
+  `;
+}
+function buildGetEdge(tables3, graphId, id) {
+  const { edges: edges3 } = tables3;
+  return sql`
+    SELECT * FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
+      AND ${edges3.id} = ${id}
+  `;
+}
+function buildGetEdges(tables3, graphId, ids) {
+  const { edges: edges3 } = 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})
+  `;
+}
+function buildUpdateEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const setParts = [
+    sql`${quotedColumn(edges3.props)} = ${propsJson}`,
+    sql`${quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+  ];
+  if (params.validTo !== void 0) {
+    setParts.push(sql`${quotedColumn(edges3.validTo)} = ${params.validTo}`);
+  }
+  if (params.clearDeleted) {
+    setParts.push(sql`${quotedColumn(edges3.deletedAt)} = NULL`);
+  }
+  const setClause = sql.join(setParts, sql`, `);
+  if (params.clearDeleted) {
+    return sql`
+      UPDATE ${edges3}
+      SET ${setClause}
+      WHERE ${edges3.graphId} = ${params.graphId}
+        AND ${edges3.id} = ${params.id}
+      RETURNING *
+    `;
+  }
+  return sql`
+    UPDATE ${edges3}
+    SET ${setClause}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} = ${params.id}
+      AND ${edges3.deletedAt} IS NULL
+    RETURNING *
+  `;
+}
+function buildDeleteEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = 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
+  `;
+}
+function buildHardDeleteEdge(tables3, params) {
+  const { edges: edges3 } = tables3;
+  return sql`
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} = ${params.id}
+  `;
+}
+function buildHardDeleteEdgesByNode(tables3, graphId, nodeKind, nodeId) {
+  const { edges: edges3 } = tables3;
+  return sql`
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
+      AND (
+        (${edges3.fromKind} = ${nodeKind} AND ${edges3.fromId} = ${nodeId})
+        OR (${edges3.toKind} = ${nodeKind} AND ${edges3.toId} = ${nodeId})
+      )
+  `;
+}
+function buildCountEdgesFrom(tables3, params) {
+  const { edges: edges3 } = 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
+    `;
+  }
+  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
+  `;
+}
+function buildEdgeExistsBetween(tables3, params) {
+  const { edges: edges3 } = 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
+    LIMIT 1
+  `;
+}
+function buildFindEdgesConnectedTo(tables3, params) {
+  const { edges: edges3 } = 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}
+    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}
+      AND NOT (
+        ${edges3.fromKind} = ${params.nodeKind}
+        AND ${edges3.fromId} = ${params.nodeId}
+      )
+  `;
+}
+function buildInsertNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const columns = nodeColumnList(nodes3);
+  return sql`
+    INSERT INTO ${nodes3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
+      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
+    )
+    RETURNING *
+  `;
+}
+function buildInsertNodeNoReturn(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const columns = nodeColumnList(nodes3);
+  return sql`
+    INSERT INTO ${nodes3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
+      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
+    )
+  `;
+}
+function buildInsertNodesBatch(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const columns = nodeColumnList(nodes3);
+  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})
+    VALUES ${sql.join(values, sql`, `)}
+  `;
+}
+function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const columns = nodeColumnList(nodes3);
+  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})
+    VALUES ${sql.join(values, sql`, `)}
+    RETURNING *
+  `;
+}
+function buildGetNode(tables3, graphId, kind, id) {
+  const { nodes: nodes3 } = tables3;
+  return sql`
+    SELECT * FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${graphId}
+      AND ${nodes3.kind} = ${kind}
+      AND ${nodes3.id} = ${id}
+  `;
+}
+function buildGetNodes(tables3, graphId, kind, ids) {
+  const { nodes: nodes3 } = 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})
+  `;
+}
+function buildUpdateNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const propsJson = JSON.stringify(params.props);
+  const setParts = [
+    sql`${quotedColumn(nodes3.props)} = ${propsJson}`,
+    sql`${quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+  ];
+  if (params.incrementVersion) {
+    setParts.push(
+      sql`${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1`
+    );
+  }
+  if (params.validTo !== void 0) {
+    setParts.push(sql`${quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+  }
+  if (params.clearDeleted) {
+    setParts.push(sql`${quotedColumn(nodes3.deletedAt)} = NULL`);
+  }
+  const setClause = sql.join(setParts, sql`, `);
+  if (params.clearDeleted) {
+    return sql`
+      UPDATE ${nodes3}
+      SET ${setClause}
+      WHERE ${nodes3.graphId} = ${params.graphId}
+        AND ${nodes3.kind} = ${params.kind}
+        AND ${nodes3.id} = ${params.id}
+      RETURNING *
+    `;
+  }
+  return sql`
+    UPDATE ${nodes3}
+    SET ${setClause}
+    WHERE ${nodes3.graphId} = ${params.graphId}
+      AND ${nodes3.kind} = ${params.kind}
+      AND ${nodes3.id} = ${params.id}
+      AND ${nodes3.deletedAt} IS NULL
+    RETURNING *
+  `;
+}
+function buildDeleteNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = 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
+  `;
+}
+function buildHardDeleteNode(tables3, params) {
+  const { nodes: nodes3 } = tables3;
+  return sql`
+    DELETE FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${params.graphId}
+      AND ${nodes3.kind} = ${params.kind}
+      AND ${nodes3.id} = ${params.id}
+  `;
+}
+function createSchemaDialectStrategy(dialect) {
+  const trueLiteral = dialect === "sqlite" ? sql.raw("1") : sql.raw("TRUE");
+  const falseLiteral = dialect === "sqlite" ? sql.raw("0") : sql.raw("FALSE");
+  return {
+    booleanLiteral(value) {
+      return value ? trueLiteral : falseLiteral;
+    }
+  };
+}
+var SCHEMA_DIALECT_STRATEGIES = {
+  postgres: createSchemaDialectStrategy("postgres"),
+  sqlite: createSchemaDialectStrategy("sqlite")
+};
+function buildInsertSchema(tables3, params, timestamp2, dialect = "sqlite") {
+  const { schemaVersions: schemaVersions3 } = 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}"`);
+  return sql`
+    INSERT INTO ${schemaVersions3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.version},
+      ${params.schemaHash}, ${schemaDocumentJson},
+      ${timestamp2}, ${isActiveValue}
+    )
+    RETURNING *
+  `;
+}
+function buildGetActiveSchema(tables3, graphId, dialect = "sqlite") {
+  const { schemaVersions: schemaVersions3 } = tables3;
+  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
+  return sql`
+    SELECT * FROM ${schemaVersions3}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.isActive} = ${strategy.booleanLiteral(true)}
+  `;
+}
+function buildGetSchemaVersion(tables3, graphId, version) {
+  const { schemaVersions: schemaVersions3 } = tables3;
+  return sql`
+    SELECT * FROM ${schemaVersions3}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.version} = ${version}
+  `;
+}
+function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
+  const { schemaVersions: schemaVersions3 } = tables3;
+  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
+  const deactivateAll = sql`
+    UPDATE ${schemaVersions3}
+    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+  `;
+  const activateVersion = sql`
+    UPDATE ${schemaVersions3}
+    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.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}"`);
+  return sql`
+    INSERT INTO ${uniques3} (${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)}
+      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)}
+      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)}
+      END
+    RETURNING ${quotedColumn(uniques3.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 existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
+  return sql`
+    INSERT INTO ${uniques3} (${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)}
+      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)}
+      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)}
+      END
+    RETURNING ${quotedColumn(uniques3.nodeId)} as node_id
+  `;
+}
+var UNIQUE_INSERT_BUILDERS = {
+  postgres: buildInsertUniquePostgres,
+  sqlite: buildInsertUniqueSqlite
+};
+function buildInsertUnique(tables3, dialect, params) {
+  const builder = UNIQUE_INSERT_BUILDERS[dialect];
+  return builder(tables3, params);
+}
+function buildDeleteUnique(tables3, params, timestamp2) {
+  const { uniques: uniques3 } = 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
+  `;
+}
+function buildHardDeleteUniquesByNode(tables3, graphId, nodeId) {
+  const { uniques: uniques3 } = 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}
+  `;
+}
+function buildCheckUnique(tables3, params) {
+  const { uniques: uniques3 } = 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}
+    `;
+  }
+  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
+  `;
+}
+function buildCheckUniqueBatch(tables3, params) {
+  const { uniques: uniques3 } = 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})
+    `;
+  }
+  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
+  `;
+}
+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 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 buildVectorSearchPostgres(tables3, params) {
+  const { embeddings: embeddings3 } = tables3;
+  const queryLiteral = formatEmbeddingLiteral(params.queryEmbedding);
+  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}`);
+  }
+  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}
+  `;
+}
+
+// src/backend/drizzle/operations/strategy.ts
+function bindTableOperationBuilders(tables3, builders) {
+  const boundEntries = Object.entries(builders).map(([name, builder]) => {
+    function boundBuilder(...args) {
+      return builder(tables3, ...args);
+    }
+    return [name, boundBuilder];
+  });
+  return Object.fromEntries(boundEntries);
+}
+var COMMON_TABLE_OPERATION_BUILDERS = {
+  buildInsertNode,
+  buildInsertNodeNoReturn,
+  buildInsertNodesBatch,
+  buildInsertNodesBatchReturning,
+  buildGetNode,
+  buildGetNodes,
+  buildUpdateNode,
+  buildDeleteNode,
+  buildHardDeleteNode,
+  buildInsertEdge,
+  buildInsertEdgeNoReturn,
+  buildInsertEdgesBatch,
+  buildInsertEdgesBatchReturning,
+  buildGetEdge,
+  buildGetEdges,
+  buildUpdateEdge,
+  buildDeleteEdge,
+  buildHardDeleteEdge,
+  buildHardDeleteEdgesByNode,
+  buildCountEdgesFrom,
+  buildEdgeExistsBetween,
+  buildFindEdgesConnectedTo,
+  buildFindNodesByKind,
+  buildCountNodesByKind,
+  buildFindEdgesByKind,
+  buildCountEdgesByKind,
+  buildDeleteUnique,
+  buildHardDeleteUniquesByNode,
+  buildHardDeleteEmbeddingsByNode,
+  buildCheckUnique,
+  buildCheckUniqueBatch,
+  buildGetSchemaVersion
+};
+function createCommonOperationStrategy(tables3, dialect) {
+  const tableOperations = bindTableOperationBuilders(
+    tables3,
+    COMMON_TABLE_OPERATION_BUILDERS
+  );
+  return {
+    ...tableOperations,
+    buildInsertUnique(params) {
+      return buildInsertUnique(tables3, dialect, params);
+    },
+    buildGetActiveSchema(graphId) {
+      return buildGetActiveSchema(tables3, graphId, dialect);
+    },
+    buildInsertSchema(params, timestamp2) {
+      return buildInsertSchema(tables3, params, timestamp2, dialect);
+    },
+    buildSetActiveSchema(graphId, version) {
+      return buildSetActiveSchema(tables3, graphId, version, dialect);
+    },
+    buildClearGraph(graphId) {
+      return buildClearGraph(tables3, graphId);
+    }
+  };
+}
+function createSqliteOperationStrategy(tables3) {
+  return createCommonOperationStrategy(tables3, "sqlite");
+}
+function createPostgresOperationStrategy(tables3) {
+  const common = createCommonOperationStrategy(tables3, "postgres");
+  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}`
+    );
+  }
+}
+var MAX_IDENTIFIER_LENGTH = 63;
+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_IDENTIFIER_LENGTH) {
+    return name;
+  }
+  const hash = shortHash(name);
+  const truncated = name.slice(0, MAX_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;
+  if (indexType === "hnsw") {
+    indexSql = sql.raw(`
+      CREATE INDEX 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 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"
+  };
+}
+
+// src/backend/drizzle/execution/types.ts
+function compileQueryWithDialect(db, query, backendName) {
+  const databaseWithCompiler = db;
+  const compiler = databaseWithCompiler.dialect;
+  if (compiler === void 0) {
+    throw new Error(`${backendName} backend is missing a SQL compiler`);
+  }
+  return compiler.sqlToQuery(query);
+}
+
+export { D1_CAPABILITIES, POSTGRES_CAPABILITIES, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CAPABILITIES, SQLITE_ROW_MAPPER_CONFIG, compileQueryWithDialect, createCommonOperationBackend, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2 };
+//# sourceMappingURL=chunk-JPO7W262.js.map
+//# sourceMappingURL=chunk-JPO7W262.js.map