@nicia-ai/typegraph 0.50.0 → 0.51.0

package/dist/{chunk-XMY2SXOH.cjs → chunk-5WWEYV4H.cjs}

@@ -1,18 +1,1213 @@
 'use strict';
 
-var chunkEH3JZJUM_cjs = require('./chunk-EH3JZJUM.cjs');
-var chunkTP4NJTI3_cjs = require('./chunk-TP4NJTI3.cjs');
-var chunk45YZXI6X_cjs = require('./chunk-45YZXI6X.cjs');
-var chunk7PRMDZIA_cjs = require('./chunk-7PRMDZIA.cjs');
-var chunkZBFZGLZE_cjs = require('./chunk-ZBFZGLZE.cjs');
-var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkLLFPQOBA_cjs = require('./chunk-LLFPQOBA.cjs');
+var chunk36SX6QXP_cjs = require('./chunk-36SX6QXP.cjs');
+var chunkFMMW3KX7_cjs = require('./chunk-FMMW3KX7.cjs');
+var chunkNLX5OWK7_cjs = require('./chunk-NLX5OWK7.cjs');
+var chunkNUQ2YFFH_cjs = require('./chunk-NUQ2YFFH.cjs');
+var chunkCRZ56SZU_cjs = require('./chunk-CRZ56SZU.cjs');
 var chunkM5MSP3BI_cjs = require('./chunk-M5MSP3BI.cjs');
+var chunkI7YAY2VQ_cjs = require('./chunk-I7YAY2VQ.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkTEC24ZDA_cjs = require('./chunk-TEC24ZDA.cjs');
-var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
+var chunkJVA3KDEA_cjs = require('./chunk-JVA3KDEA.cjs');
+var chunkH2VWDQWC_cjs = require('./chunk-H2VWDQWC.cjs');
+var chunkH5IJSROF_cjs = require('./chunk-H5IJSROF.cjs');
 var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 var drizzleOrm = require('drizzle-orm');
+var pgCore = require('drizzle-orm/pg-core');
+var sqliteCore = require('drizzle-orm/sqlite-core');
+
+var regconfig = pgCore.customType({
+  dataType: () => "regconfig"
+});
+var tsvector = pgCore.customType({
+  dataType: () => "tsvector"
+});
+
+// src/backend/drizzle/schema/postgres.ts
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges",
+  recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
+  identityAssertions: "typegraph_identity_assertions",
+  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
+  identityClosure: "typegraph_identity_closure",
+  identitySeparation: "typegraph_identity_separation",
+  uniques: "typegraph_node_uniques",
+  edgeClaims: "typegraph_edge_claims",
+  schemaVersions: "typegraph_schema_versions",
+  fulltext: "typegraph_node_fulltext",
+  indexMaterializations: "typegraph_index_materializations",
+  contributionMaterializations: "typegraph_contribution_materializations",
+  kindRemovals: "typegraph_kind_removals",
+  reconciliationMarkers: "typegraph_reconciliation_markers"
+};
+function createPostgresTables(names = {}, options = {}) {
+  const n = { ...DEFAULT_TABLE_NAMES, ...names };
+  const indexes = options.indexes ?? [];
+  chunkI7YAY2VQ_cjs.assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = pgCore.pgTable(
+    n.nodes,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      id: pgCore.text("id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      version: pgCore.integer("version").notNull().default(1),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...chunkLLFPQOBA_cjs.buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
+      ...chunkLLFPQOBA_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = pgCore.pgTable(
+    n.edges,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      fromKind: pgCore.text("from_kind").notNull(),
+      fromId: pgCore.text("from_id").notNull(),
+      toKind: pgCore.text("to_kind").notNull(),
+      toId: pgCore.text("to_id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.id] }),
+      ...chunkLLFPQOBA_cjs.buildPostgresSystemIndexBuilders("edges", n.edges, t),
+      ...chunkLLFPQOBA_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = pgCore.pgTable(
+    n.recordedNodes,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      id: pgCore.text("id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      version: pgCore.integer("version").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: pgCore.bigint("recorded_to", { mode: "number" }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkLLFPQOBA_cjs.buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = pgCore.pgTable(
+    n.recordedEdges,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      fromKind: pgCore.text("from_kind").notNull(),
+      fromId: pgCore.text("from_id").notNull(),
+      toKind: pgCore.text("to_kind").notNull(),
+      toId: pgCore.text("to_id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: pgCore.bigint("recorded_to", { mode: "number" }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkLLFPQOBA_cjs.buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = pgCore.pgTable(
+    n.recordedClock,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      revision: pgCore.bigint("revision", { mode: "number" }).notNull(),
+      recordedAt: pgCore.timestamp("recorded_at", { withTimezone: true }).notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = pgCore.pgTable(
+    n.revisionOrigins,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      origin: pgCore.text("origin").notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const identityAssertions = pgCore.pgTable(
+    n.identityAssertions,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      relation: pgCore.text("rel").notNull(),
+      aKind: pgCore.text("a_kind").notNull(),
+      aId: pgCore.text("a_id").notNull(),
+      bKind: pgCore.text("b_kind").notNull(),
+      bId: pgCore.text("b_id").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }).notNull(),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      endedByKind: pgCore.text("ended_by_kind"),
+      endedById: pgCore.text("ended_by_id")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.id] }),
+      pgCore.index(`${n.identityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.validTo
+      ),
+      pgCore.index(`${n.identityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.validTo
+      ),
+      pgCore.uniqueIndex(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(drizzleOrm.sql`${t.validTo} IS NULL`),
+      pgCore.check(
+        `${n.identityAssertions}_ended_by_check`,
+        drizzleOrm.sql`(ended_by_kind IS NULL) = (ended_by_id IS NULL) AND (ended_by_kind IS NULL OR (valid_to IS NOT NULL AND ((ended_by_kind = a_kind AND ended_by_id = a_id) OR (ended_by_kind = b_kind AND ended_by_id = b_id))))`
+      )
+    ]
+  );
+  const recordedIdentityAssertions = pgCore.pgTable(
+    n.recordedIdentityAssertions,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      relation: pgCore.text("rel").notNull(),
+      aKind: pgCore.text("a_kind").notNull(),
+      aId: pgCore.text("a_id").notNull(),
+      bKind: pgCore.text("b_kind").notNull(),
+      bId: pgCore.text("b_id").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }).notNull(),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      endedByKind: pgCore.text("ended_by_kind"),
+      endedById: pgCore.text("ended_by_id"),
+      recordedFrom: pgCore.bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: pgCore.bigint("recorded_to", { mode: "number" }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      pgCore.index(`${n.recordedIdentityAssertions}_entity_idx`).on(
+        t.graphId,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedIdentityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedIdentityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.recordedFrom,
+        t.recordedTo
+      )
+    ]
+  );
+  const identityClosure = pgCore.pgTable(
+    n.identityClosure,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      memberKind: pgCore.text("member_kind").notNull(),
+      memberId: pgCore.text("member_id").notNull(),
+      classKind: pgCore.text("class_kind").notNull(),
+      classId: pgCore.text("class_id").notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.memberKind, t.memberId] }),
+      pgCore.index(`${n.identityClosure}_class_idx`).on(
+        t.graphId,
+        t.classKind,
+        t.classId
+      )
+    ]
+  );
+  const identitySeparation = pgCore.pgTable(
+    n.identitySeparation,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      classKeyLow: pgCore.text("class_key_low").notNull(),
+      classKeyHigh: pgCore.text("class_key_high").notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
+      pgCore.index(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
+      pgCore.check(
+        `${n.identitySeparation}_ordered_pair_check`,
+        drizzleOrm.sql`class_key_low COLLATE "C" < class_key_high COLLATE "C"`
+      )
+    ]
+  );
+  const uniques3 = pgCore.pgTable(
+    n.uniques,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      constraintName: pgCore.text("constraint_name").notNull(),
+      key: pgCore.text("key").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      concreteKind: pgCore.text("concrete_kind").notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      pgCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const edgeClaims3 = pgCore.pgTable(
+    n.edgeClaims,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      axis: pgCore.text("axis").notNull(),
+      key: pgCore.text("key").notNull(),
+      edgeId: pgCore.text("edge_id").notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.axis, t.key] }),
+      pgCore.index(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
+    ]
+  );
+  const schemaVersions3 = pgCore.pgTable(
+    n.schemaVersions,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      version: pgCore.integer("version").notNull(),
+      schemaHash: pgCore.text("schema_hash").notNull(),
+      schemaDoc: pgCore.jsonb("schema_doc").notNull(),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      isActive: pgCore.boolean("is_active").notNull().default(false)
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.version] }),
+      pgCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      pgCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = TRUE`)
+    ]
+  );
+  const indexMaterializations = pgCore.pgTable(
+    n.indexMaterializations,
+    {
+      indexName: pgCore.text("index_name").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error"),
+      // Cross-caller build claim: while `building_since` is fresh (within
+      // the lease), exactly one materializer owns this index's CREATE
+      // INDEX CONCURRENTLY. Serializes same-index CIC across processes —
+      // two concurrent expression-index CICs deadlock each other (no
+      // safe-snapshot exemption). NULL when no build is in flight.
+      buildingSince: pgCore.timestamp("building_since", { withTimezone: true }),
+      claimToken: pgCore.text("claim_token")
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = pgCore.pgTable(
+    n.kindRemovals,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      kindName: pgCore.text("kind_name").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      removedAt: pgCore.timestamp("removed_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = pgCore.pgTable(
+    n.reconciliationMarkers,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      reconciledToVersion: pgCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = pgCore.pgTable(
+    n.contributionMaterializations,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      logicalName: pgCore.text("logical_name").notNull(),
+      owner: pgCore.text("owner").notNull(),
+      tableName: pgCore.text("table_name").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  const fulltext2 = pgCore.pgTable(
+    n.fulltext,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      content: pgCore.text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(drizzleOrm.sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      pgCore.index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      pgCore.index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
+    ]
+  );
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    recordedNodes: recordedNodes3,
+    recordedEdges: recordedEdges3,
+    recordedClock: recordedClock3,
+    revisionOrigins,
+    identityAssertions,
+    recordedIdentityAssertions,
+    identityClosure,
+    identitySeparation,
+    uniques: uniques3,
+    edgeClaims: edgeClaims3,
+    schemaVersions: schemaVersions3,
+    indexMaterializations,
+    contributionMaterializations,
+    kindRemovals,
+    reconciliationMarkers,
+    fulltext: fulltext2,
+    fulltextTableName: n.fulltext
+  };
+}
+var tables = createPostgresTables();
+var {
+  nodes,
+  edges,
+  recordedNodes,
+  recordedEdges,
+  recordedClock,
+  uniques,
+  edgeClaims,
+  schemaVersions,
+  fulltext
+} = tables;
+var DEFAULT_TABLE_NAMES2 = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges",
+  recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
+  identityAssertions: "typegraph_identity_assertions",
+  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
+  identityClosure: "typegraph_identity_closure",
+  identitySeparation: "typegraph_identity_separation",
+  uniques: "typegraph_node_uniques",
+  edgeClaims: "typegraph_edge_claims",
+  schemaVersions: "typegraph_schema_versions",
+  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 ?? [];
+  chunkI7YAY2VQ_cjs.assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = sqliteCore.sqliteTable(
+    n.nodes,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      version: sqliteCore.integer("version").notNull().default(1),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...chunkLLFPQOBA_cjs.buildSqliteSystemIndexBuilders("nodes", n.nodes, t),
+      ...chunkLLFPQOBA_cjs.buildSqliteNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = sqliteCore.sqliteTable(
+    n.edges,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      fromKind: sqliteCore.text("from_kind").notNull(),
+      fromId: sqliteCore.text("from_id").notNull(),
+      toKind: sqliteCore.text("to_kind").notNull(),
+      toId: sqliteCore.text("to_id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.id] }),
+      ...chunkLLFPQOBA_cjs.buildSqliteSystemIndexBuilders("edges", n.edges, t),
+      ...chunkLLFPQOBA_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = sqliteCore.sqliteTable(
+    n.recordedNodes,
+    {
+      historyId: sqliteCore.text("history_id").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      version: sqliteCore.integer("version").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      recordedFrom: sqliteCore.integer("recorded_from").notNull(),
+      recordedTo: sqliteCore.integer("recorded_to").notNull(),
+      op: sqliteCore.text("op").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version"),
+      txId: sqliteCore.text("tx_id"),
+      meta: sqliteCore.text("meta")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkLLFPQOBA_cjs.buildSqliteSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = sqliteCore.sqliteTable(
+    n.recordedEdges,
+    {
+      historyId: sqliteCore.text("history_id").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      fromKind: sqliteCore.text("from_kind").notNull(),
+      fromId: sqliteCore.text("from_id").notNull(),
+      toKind: sqliteCore.text("to_kind").notNull(),
+      toId: sqliteCore.text("to_id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      recordedFrom: sqliteCore.integer("recorded_from").notNull(),
+      recordedTo: sqliteCore.integer("recorded_to").notNull(),
+      op: sqliteCore.text("op").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version"),
+      txId: sqliteCore.text("tx_id"),
+      meta: sqliteCore.text("meta")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkLLFPQOBA_cjs.buildSqliteSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = sqliteCore.sqliteTable(
+    n.recordedClock,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      revision: sqliteCore.integer("revision").notNull(),
+      recordedAt: sqliteCore.text("recorded_at").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = sqliteCore.sqliteTable(
+    n.revisionOrigins,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      origin: sqliteCore.text("origin").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const identityAssertions = sqliteCore.sqliteTable(
+    n.identityAssertions,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      relation: sqliteCore.text("rel").notNull(),
+      aKind: sqliteCore.text("a_kind").notNull(),
+      aId: sqliteCore.text("a_id").notNull(),
+      bKind: sqliteCore.text("b_kind").notNull(),
+      bId: sqliteCore.text("b_id").notNull(),
+      validFrom: sqliteCore.text("valid_from").notNull(),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      endedByKind: sqliteCore.text("ended_by_kind"),
+      endedById: sqliteCore.text("ended_by_id")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.id] }),
+      sqliteCore.index(`${n.identityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.validTo
+      ),
+      sqliteCore.index(`${n.identityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.validTo
+      ),
+      sqliteCore.uniqueIndex(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(drizzleOrm.sql`${t.validTo} IS NULL`),
+      sqliteCore.check(
+        `${n.identityAssertions}_ended_by_check`,
+        drizzleOrm.sql`(ended_by_kind IS NULL) = (ended_by_id IS NULL) AND (ended_by_kind IS NULL OR (valid_to IS NOT NULL AND ((ended_by_kind = a_kind AND ended_by_id = a_id) OR (ended_by_kind = b_kind AND ended_by_id = b_id))))`
+      )
+    ]
+  );
+  const recordedIdentityAssertions = sqliteCore.sqliteTable(
+    n.recordedIdentityAssertions,
+    {
+      historyId: sqliteCore.text("history_id").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      relation: sqliteCore.text("rel").notNull(),
+      aKind: sqliteCore.text("a_kind").notNull(),
+      aId: sqliteCore.text("a_id").notNull(),
+      bKind: sqliteCore.text("b_kind").notNull(),
+      bId: sqliteCore.text("b_id").notNull(),
+      validFrom: sqliteCore.text("valid_from").notNull(),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      endedByKind: sqliteCore.text("ended_by_kind"),
+      endedById: sqliteCore.text("ended_by_id"),
+      recordedFrom: sqliteCore.integer("recorded_from").notNull(),
+      recordedTo: sqliteCore.integer("recorded_to").notNull(),
+      op: sqliteCore.text("op").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version"),
+      txId: sqliteCore.text("tx_id"),
+      meta: sqliteCore.text("meta")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.historyId] }),
+      sqliteCore.index(`${n.recordedIdentityAssertions}_entity_idx`).on(
+        t.graphId,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      sqliteCore.index(`${n.recordedIdentityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      sqliteCore.index(`${n.recordedIdentityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.recordedFrom,
+        t.recordedTo
+      )
+    ]
+  );
+  const identityClosure = sqliteCore.sqliteTable(
+    n.identityClosure,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      memberKind: sqliteCore.text("member_kind").notNull(),
+      memberId: sqliteCore.text("member_id").notNull(),
+      classKind: sqliteCore.text("class_kind").notNull(),
+      classId: sqliteCore.text("class_id").notNull()
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.memberKind, t.memberId] }),
+      sqliteCore.index(`${n.identityClosure}_class_idx`).on(
+        t.graphId,
+        t.classKind,
+        t.classId
+      )
+    ]
+  );
+  const identitySeparation = sqliteCore.sqliteTable(
+    n.identitySeparation,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      classKeyLow: sqliteCore.text("class_key_low").notNull(),
+      classKeyHigh: sqliteCore.text("class_key_high").notNull()
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
+      sqliteCore.index(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
+      sqliteCore.check(
+        `${n.identitySeparation}_ordered_pair_check`,
+        drizzleOrm.sql`class_key_low < class_key_high`
+      )
+    ]
+  );
+  const uniques3 = sqliteCore.sqliteTable(
+    n.uniques,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      nodeKind: sqliteCore.text("node_kind").notNull(),
+      constraintName: sqliteCore.text("constraint_name").notNull(),
+      key: sqliteCore.text("key").notNull(),
+      nodeId: sqliteCore.text("node_id").notNull(),
+      concreteKind: sqliteCore.text("concrete_kind").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      sqliteCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const edgeClaims3 = sqliteCore.sqliteTable(
+    n.edgeClaims,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      axis: sqliteCore.text("axis").notNull(),
+      key: sqliteCore.text("key").notNull(),
+      edgeId: sqliteCore.text("edge_id").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull()
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.axis, t.key] }),
+      sqliteCore.index(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
+    ]
+  );
+  const schemaVersions3 = sqliteCore.sqliteTable(
+    n.schemaVersions,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      version: sqliteCore.integer("version").notNull(),
+      schemaHash: sqliteCore.text("schema_hash").notNull(),
+      schemaDoc: sqliteCore.text("schema_doc").notNull(),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      isActive: sqliteCore.integer("is_active", { mode: "boolean" }).notNull().default(false)
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.version] }),
+      sqliteCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      sqliteCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = 1`)
+    ]
+  );
+  const indexMaterializations = sqliteCore.sqliteTable(
+    n.indexMaterializations,
+    {
+      indexName: sqliteCore.text("index_name").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = sqliteCore.sqliteTable(
+    n.kindRemovals,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kindName: sqliteCore.text("kind_name").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      removedAt: sqliteCore.text("removed_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = sqliteCore.sqliteTable(
+    n.reconciliationMarkers,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      reconciledToVersion: sqliteCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = sqliteCore.sqliteTable(
+    n.contributionMaterializations,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      logicalName: sqliteCore.text("logical_name").notNull(),
+      owner: sqliteCore.text("owner").notNull(),
+      tableName: sqliteCore.text("table_name").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    recordedNodes: recordedNodes3,
+    recordedEdges: recordedEdges3,
+    recordedClock: recordedClock3,
+    revisionOrigins,
+    identityAssertions,
+    recordedIdentityAssertions,
+    identityClosure,
+    identitySeparation,
+    uniques: uniques3,
+    edgeClaims: edgeClaims3,
+    schemaVersions: schemaVersions3,
+    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,
+  recordedNodes: recordedNodes2,
+  recordedEdges: recordedEdges2,
+  recordedClock: recordedClock2,
+  uniques: uniques2,
+  edgeClaims: edgeClaims2,
+  schemaVersions: schemaVersions2
+} = 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 = sqliteCore.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})`);
+  }
+  columnDefs.push(...renderTableChecks(config.checks, config.name));
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function renderTableChecks(checks, tableName) {
+  return checks.map(
+    (check3) => `CONSTRAINT "${check3.name}" CHECK (${inlineSqlOrThrow(
+      check3.value,
+      `table "${tableName}" CHECK constraint "${check3.name}"`
+    )})`
+  );
+}
+function renderIndexColumn(col) {
+  if (col && typeof col === "object" && "name" in col) {
+    return `"${col.name}"`;
+  }
+  const sql19 = tryInlineSql(col);
+  if (sql19 !== void 0) {
+    return sql19;
+  }
+  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(chunk2) {
+  if (typeof chunk2 === "string") {
+    return chunk2;
+  }
+  if (typeof chunk2 === "object" && chunk2 !== null) {
+    if ("name" in chunk2 && typeof chunk2.name === "string") {
+      return `"${chunk2.name}"`;
+    }
+    if ("value" in chunk2) {
+      const value = chunk2.value;
+      if (typeof value === "string") {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((part) => flattenSqlChunk(part)).join("");
+      }
+    }
+    if ("queryChunks" in chunk2 && Array.isArray(chunk2.queryChunks)) {
+      return chunk2.queryChunks.map((part) => flattenSqlChunk(part)).join("");
+    }
+    if ("getSQL" in chunk2) {
+      const maybe = chunk2;
+      if (typeof maybe.getSQL === "function") {
+        return flattenSqlChunk(maybe.getSQL());
+      }
+    }
+  }
+  throw new Error(`Unable to inline SQL chunk: ${String(chunk2)}`);
+}
+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 = sqliteCore.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 isSqliteTable(value) {
+  return drizzleOrm.is(value, sqliteCore.SQLiteTable);
+}
+function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
+  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
+}
+function sqliteContributions(tables3 = tables2, fulltextStrategy = chunkH2VWDQWC_cjs.fts5Strategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
+    if (!isSqliteTable(table)) continue;
+    contributions.push({
+      logicalName: key,
+      owner: chunkH2VWDQWC_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: sqliteCore.getTableConfig(table).name,
+      createDdl: [
+        generateSqliteCreateTableSQL(table),
+        ...generateSqliteCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
+  }
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
+  }
+  return contributions;
+}
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkH2VWDQWC_cjs.fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkH2VWDQWC_cjs.fts5Strategy) {
+  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
+}
+function getPgColumnType(column) {
+  switch (column.columnType) {
+    case "PgText": {
+      return "TEXT";
+    }
+    case "PgInteger": {
+      return "INTEGER";
+    }
+    case "PgBigInt53":
+    case "PgBigInt64": {
+      return "BIGINT";
+    }
+    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 = pgCore.getTableConfig(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})`);
+  }
+  columnDefs.push(...renderTableChecks(config.checks, config.name));
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function generatePgCreateIndexSQL(table) {
+  const config = pgCore.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 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 isPgTable(value) {
+  return drizzleOrm.is(value, pgCore.PgTable);
+}
+function postgresContributions(tables3 = tables, fulltextStrategy = chunkH2VWDQWC_cjs.tsvectorStrategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
+    if (!isPgTable(table)) continue;
+    if (table === tables3.fulltext) continue;
+    contributions.push({
+      logicalName: key,
+      owner: chunkH2VWDQWC_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: pgCore.getTableConfig(table).name,
+      createDdl: [
+        generatePgCreateTableSQL(table),
+        ...generatePgCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
+  }
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
+  }
+  return contributions;
+}
+function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunkH2VWDQWC_cjs.tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkH2VWDQWC_cjs.tsvectorStrategy) {
+  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
+  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
+  return `${extensionSql}
+
+${ddlSql}`;
+}
+
+// src/backend/capabilities/declarations.ts
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+    return value;
+  }
+  Object.freeze(value);
+  for (const propertyValue of Object.values(value)) {
+    deepFreeze(propertyValue);
+  }
+  return value;
+}
+function assertBundledCapabilityDeclarations(capabilities) {
+  const { recursiveTraversal } = capabilities;
+  if (recursiveTraversal?.supported === false && recursiveTraversal.reason === void 0) {
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
+      "Backend capability declaration is contradictory: recursiveTraversal.supported is false but no reason is given.",
+      {
+        code: "CAPABILITY_DECLARATION_CONTRADICTION",
+        member: "recursiveTraversal",
+        missing: "reason"
+      },
+      {
+        suggestion: "Supply a `reason` explaining why this backend cannot perform recursive traversal."
+      }
+    );
+  }
+  if (recursiveTraversal?.supported === true && recursiveTraversal.reason !== void 0) {
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
+      "Backend capability declaration is contradictory: recursiveTraversal.supported is true but a dangling reason is present.",
+      {
+        code: "CAPABILITY_DECLARATION_CONTRADICTION",
+        member: "recursiveTraversal",
+        danglingReason: recursiveTraversal.reason
+      },
+      {
+        suggestion: "Remove `reason` when recursiveTraversal.supported is true \u2014 it is only meaningful alongside `supported: false`."
+      }
+    );
+  }
+  return deepFreeze(structuredClone(capabilities));
+}
 
 // src/backend/edge-endpoint-sets.ts
 var FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT = 6;
@@ -81,10 +1276,10 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = chunkOJHD3LXJ_cjs.sql.identifier(nodesTableName);
-  return chunkOJHD3LXJ_cjs.sql`
+  const nodes3 = chunkH5IJSROF_cjs.sql.identifier(nodesTableName);
+  return chunkH5IJSROF_cjs.sql`
     SELECT "id" AS node_id
-    FROM ${nodes}
+    FROM ${nodes3}
     WHERE "graph_id" = ${graphId}
       AND "kind" = ${nodeKind}
       AND "deleted_at" IS NULL
@@ -123,7 +1318,7 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkZBFZGLZE_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkNLX5OWK7_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
   return new chunkX4GDXBOP_cjs.EmbeddingDimensionChangedError(
@@ -142,7 +1337,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
+  decode: chunk36SX6QXP_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -192,7 +1387,7 @@ function contributionSignatureInput(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return JSON.stringify(hashable, chunkZBFZGLZE_cjs.sortedReplacer);
+  return JSON.stringify(hashable, chunkNLX5OWK7_cjs.sortedReplacer);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -251,7 +1446,7 @@ function identityOf(graphId, contribution) {
 }
 function missingTableErrorNames(error, tableName) {
   const quotedTableName2 = `"${tableName.replaceAll('"', '""')}"`;
-  for (const link of chunkZBFZGLZE_cjs.errorChain(error)) {
+  for (const link of chunkNLX5OWK7_cjs.errorChain(error)) {
     const message = errorMessage(link);
     if (typeof message !== "string") continue;
     const sqliteMatch = /\bno such table:\s*([^\s;:]+)/i.exec(message);
@@ -356,13 +1551,13 @@ function gateFulltextMethods(source, assert, refuseUnavailable) {
   return gated;
 }
 function gateFulltext(tx, assert, refuseUnavailable) {
-  return chunkZBFZGLZE_cjs.deriveBackend(
+  return chunkNLX5OWK7_cjs.deriveBackend(
     tx,
     gateFulltextMethods(tx, assert, refuseUnavailable)
   );
 }
 function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
-  return transactional && chunkTP4NJTI3_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
+  return transactional && runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
     (contribution) => contribution.dropDdl !== void 0
   );
 }
@@ -387,7 +1582,7 @@ function createContributionMaterializer(deps) {
     const cachedCreateDdl = cached?.createDdl;
     const cachedSignature = cached?.signature;
     if (cachedCreateDdl?.length === contribution.createDdl.length && cachedSignature !== void 0 && contribution.createDdl.every(
-      (statement, index) => cachedCreateDdl[index] === statement
+      (statement, index3) => cachedCreateDdl[index3] === statement
     )) {
       return cachedSignature;
     }
@@ -411,7 +1606,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunkTP4NJTI3_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   function cacheInitializedSignature(key, signature) {
     if (!uncacheableKeys.has(key)) {
@@ -438,13 +1633,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature: existing.signature,
-        attemptedAt: chunkEH3JZJUM_cjs.nowIso(),
+        attemptedAt: chunk36SX6QXP_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkEH3JZJUM_cjs.nowIso();
+    const attemptedAt = chunk36SX6QXP_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -480,7 +1675,7 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkZBFZGLZE_cjs.isMissingTableError(error)) throw error;
+      if (!chunkNLX5OWK7_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -583,7 +1778,7 @@ function createContributionMaterializer(deps) {
   }
   async function refuseUnavailableFulltext(graphId, error) {
     await Promise.resolve();
-    if (!chunkZBFZGLZE_cjs.isMissingTableError(error)) throw error;
+    if (!chunkNLX5OWK7_cjs.isMissingTableError(error)) throw error;
     const missingContribution = runtimeContributions().find(
       (contribution) => contribution.logicalName === "fulltext" && missingTableErrorNames(error, contribution.tableName)
     );
@@ -755,25 +1950,47 @@ function createContributionMaterializer(deps) {
     };
   }
   async function lockContributionDdl(tx) {
-    if (dialect !== "postgres") return;
-    await tx.execute(
-      chunkOJHD3LXJ_cjs.asCompiledRowsSql(
-        chunkOJHD3LXJ_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
-      )
-    );
+    const plan = chunkNUQ2YFFH_cjs.resolveWriteFencePlan(deps.fenceTarget);
+    const fence = chunkNUQ2YFFH_cjs.requireWriteFence(plan, "contribution DDL", "advisory-lock");
+    switch (fence.kind) {
+      case "lock": {
+        await tx.execute(
+          chunkH5IJSROF_cjs.asCompiledRowsSql(
+            chunkH5IJSROF_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
+          )
+        );
+        return;
+      }
+      case "engine-serialized": {
+        return;
+      }
+    }
   }
   async function lockSharedFulltextTable(tx, tableName) {
-    if (dialect !== "postgres") return;
-    await tx.executeStatement(
-      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-        chunkOJHD3LXJ_cjs.sql`LOCK TABLE ${chunkOJHD3LXJ_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
-      )
+    const plan = chunkNUQ2YFFH_cjs.resolveWriteFencePlan(deps.fenceTarget);
+    const fence = chunkNUQ2YFFH_cjs.requireWriteFence(
+      plan,
+      "shared fulltext table lock",
+      "table-lock"
     );
+    switch (fence.kind) {
+      case "lock": {
+        await tx.executeStatement(
+          chunkH5IJSROF_cjs.asCompiledStatementSql(
+            chunkH5IJSROF_cjs.sql`LOCK TABLE ${chunkH5IJSROF_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
+          )
+        );
+        return;
+      }
+      case "engine-serialized": {
+        return;
+      }
+    }
   }
   async function readForeignGraphIds(tx, tableName, graphId) {
     const rows = await tx.execute(
-      chunkOJHD3LXJ_cjs.asCompiledRowsSql(
-        chunkTEC24ZDA_cjs.buildForeignFulltextGraphProbe(
+      chunkH5IJSROF_cjs.asCompiledRowsSql(
+        chunkH2VWDQWC_cjs.buildForeignFulltextGraphProbe(
           tableName,
           graphId,
           FOREIGN_GRAPH_REPORT_LIMIT
@@ -876,13 +2093,13 @@ function createContributionMaterializer(deps) {
       }
       if (!recreateStorage) {
         await tx.executeStatement(
-          chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-            chunkTEC24ZDA_cjs.buildFulltextGraphDelete(sharedTable, graphId)
+          chunkH5IJSROF_cjs.asCompiledStatementSql(
+            chunkH2VWDQWC_cjs.buildFulltextGraphDelete(sharedTable, graphId)
           )
         );
       }
       const stats = await repopulate(tx);
-      const now = chunkEH3JZJUM_cjs.nowIso();
+      const now = chunk36SX6QXP_cjs.nowIso();
       for (const { contribution, signature } of stamps) {
         await record({
           ...identityOf(graphId, contribution),
@@ -944,7 +2161,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
+  decode: chunk36SX6QXP_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -1002,7 +2219,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
+  decode: chunk36SX6QXP_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -1043,27 +2260,87 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
+function primaryKeyConstraintNames(relation, keyColumns) {
+  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
+}
+function nodePrimaryKeyConstraint(nodes3) {
+  const relation = drizzleOrm.getTableName(nodes3);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      nodes3.graphId.name,
+      nodes3.kind.name,
+      nodes3.id.name
+    ])
+  };
+}
+function edgePrimaryKeyConstraint(edges3) {
+  const relation = drizzleOrm.getTableName(edges3);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      edges3.graphId.name,
+      edges3.id.name
+    ])
+  };
+}
+function sqlNull(value) {
+  return value ?? drizzleOrm.sql.raw("NULL");
+}
+function expectedValidFromPredicate(column, expected) {
+  if (expected === void 0) return drizzleOrm.sql.empty();
+  if (expected === null) return drizzleOrm.sql` AND ${column} IS NULL`;
+  return drizzleOrm.sql` AND ${column} = ${expected}`;
+}
+function quotedColumn(column) {
+  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function quotedTableName(tableName) {
+  return drizzleOrm.sql.raw(`"${tableName.replaceAll('"', '""')}"`);
+}
+var CODE_POINT_ORDER_BUILDERS = {
+  postgres: (value) => drizzleOrm.sql`${value} COLLATE "C"`,
+  sqlite: (value) => value
+};
+function codePointOrderKey(column, dialect) {
+  return CODE_POINT_ORDER_BUILDERS[dialect](column);
+}
+function liveNodeIdsSubquery(nodes3, graphId, nodeKind, nowIso2) {
+  return drizzleOrm.sql`SELECT ${nodes3.id} AS node_id FROM ${nodes3} WHERE ${nodes3.graphId} = ${graphId} AND ${nodes3.kind} = ${nodeKind} AND ${nodes3.deletedAt} IS NULL AND (${nodes3.validFrom} IS NULL OR ${nodes3.validFrom} <= ${nowIso2}) AND (${nodes3.validTo} IS NULL OR ${nodes3.validTo} > ${nowIso2})`;
+}
+function nodeColumnList(nodes3) {
+  return drizzleOrm.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 drizzleOrm.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/hybrid.ts
 function nodeIdOrderKey(dialect) {
-  return chunkEH3JZJUM_cjs.codePointOrderKey(drizzleOrm.sql.raw("node_id"), dialect);
+  return codePointOrderKey(drizzleOrm.sql.raw("node_id"), dialect);
 }
 function hybridCandidatesRef() {
   return drizzleOrm.sql`SELECT node_id FROM tg_hybrid_cand`;
 }
 function buildHybridSearchStatement(input) {
-  const { nodes } = input;
+  const { nodes: nodes3 } = input;
   const nodeIdOrder = nodeIdOrderKey(input.dialect);
   const vectorOrder = input.vectorScoreDescending ? drizzleOrm.sql`score DESC, ${nodeIdOrder} ASC` : drizzleOrm.sql`score ASC, ${nodeIdOrder} ASC`;
   const columnPairs = [
-    [nodes.graphId, "graph_id"],
-    [nodes.kind, "kind"],
-    [nodes.id, "id"],
-    [nodes.props, "props"],
-    [nodes.version, "version"],
-    [nodes.validFrom, "valid_from"],
-    [nodes.validTo, "valid_to"],
-    [nodes.createdAt, "created_at"],
-    [nodes.updatedAt, "updated_at"],
-    [nodes.deletedAt, "deleted_at"]
+    [nodes3.graphId, "graph_id"],
+    [nodes3.kind, "kind"],
+    [nodes3.id, "id"],
+    [nodes3.props, "props"],
+    [nodes3.version, "version"],
+    [nodes3.validFrom, "valid_from"],
+    [nodes3.validTo, "valid_to"],
+    [nodes3.createdAt, "created_at"],
+    [nodes3.updatedAt, "updated_at"],
+    [nodes3.deletedAt, "deleted_at"]
   ];
   const nodeColumns = drizzleOrm.sql.raw(
     columnPairs.map(
@@ -1116,17 +2393,17 @@ function buildHybridSearchStatement(input) {
       tg_hybrid_fused.snippet AS snippet,
       ${nodeColumns}
     FROM tg_hybrid_fused
-    JOIN ${nodes} AS tg_hybrid_node
-      ON ${qualified(nodes, "graphId")} = ${input.graphId}
-     AND ${qualified(nodes, "kind")} = ${input.nodeKind}
-     AND ${qualified(nodes, "id")} = tg_hybrid_fused.node_id
-     AND ${qualified(nodes, "deletedAt")} IS NULL
+    JOIN ${nodes3} AS tg_hybrid_node
+      ON ${qualified(nodes3, "graphId")} = ${input.graphId}
+     AND ${qualified(nodes3, "kind")} = ${input.nodeKind}
+     AND ${qualified(nodes3, "id")} = tg_hybrid_fused.node_id
+     AND ${qualified(nodes3, "deletedAt")} IS NULL
     ORDER BY fused_score DESC, ${nodeIdOrder} ASC
     LIMIT ${input.limit} OFFSET ${input.offset}
   `;
 }
-function qualified(nodes, member) {
-  return drizzleOrm.sql`tg_hybrid_node.${chunkEH3JZJUM_cjs.quotedColumn(nodes[member])}`;
+function qualified(nodes3, member) {
+  return drizzleOrm.sql`tg_hybrid_node.${quotedColumn(nodes3[member])}`;
 }
 function present(value) {
   return value !== null && value !== void 0;
@@ -1134,61 +2411,61 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkEH3JZJUM_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunk36SX6QXP_cjs.coerceNumericScore(row["fused_score"]),
     ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkEH3JZJUM_cjs.coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: chunk36SX6QXP_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkEH3JZJUM_cjs.coerceNumericScore(
+      fulltextScore: chunk36SX6QXP_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
     ...present(row["snippet"]) ? { snippet: String(row["snippet"]) } : {}
   };
 }
-function buildClearGraph(tables, graphId) {
+function buildClearGraph(tables3, graphId) {
   return [
     // The fulltext table is shared by every graph in the database, so its
     // graph-scoped delete is owned by one builder the destructive
     // contribution rebuild calls too — see `buildFulltextGraphDelete`.
-    { query: chunkTEC24ZDA_cjs.buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
+    { query: chunkH2VWDQWC_cjs.buildFulltextGraphDelete(tables3.fulltextTableName, graphId) },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedIdentityAssertions} WHERE ${tables3.recordedIdentityAssertions.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedIdentityAssertions)
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedIdentityAssertions)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedEdges)
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedEdges)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedNodes} WHERE ${tables.recordedNodes.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedNodes)
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedNodes)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedClock} WHERE ${tables.recordedClock.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedClock)
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedClock)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identitySeparation} WHERE ${tables.identitySeparation.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.identitySeparation} WHERE ${tables3.identitySeparation.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identitySeparation)
+      requiredTableName: drizzleOrm.getTableName(tables3.identitySeparation)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identityClosure} WHERE ${tables.identityClosure.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.identityClosure} WHERE ${tables3.identityClosure.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identityClosure)
+      requiredTableName: drizzleOrm.getTableName(tables3.identityClosure)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identityAssertions} WHERE ${tables.identityAssertions.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.identityAssertions} WHERE ${tables3.identityAssertions.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identityAssertions)
+      requiredTableName: drizzleOrm.getTableName(tables3.identityAssertions)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`
     },
     // Edge claims name the edges they are held by, so they are cleared
     // BEFORE the edges — the same ordering `uniques` gets against `nodes`.
@@ -1197,27 +2474,27 @@ function buildClearGraph(tables, graphId) {
     // existed has no such table, and clearing a graph must not become the
     // operation that fails on it.
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.edgeClaims} WHERE ${tables.edgeClaims.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables3.edgeClaims} WHERE ${tables3.edgeClaims.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.edgeClaims)
+      requiredTableName: drizzleOrm.getTableName(tables3.edgeClaims)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.indexMaterializations} WHERE ${tables.indexMaterializations.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.kindRemovals} WHERE ${tables.kindRemovals.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.reconciliationMarkers} WHERE ${tables.reconciliationMarkers.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
     }
   ];
 }
@@ -1239,21 +2516,21 @@ function buildTemporalConditions(table, params) {
   }
   return conditions;
 }
-function buildFindNodesByKind(tables, params) {
-  const { nodes } = tables;
+function buildFindNodesByKind(tables3, params) {
+  const { nodes: nodes3 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
+    drizzleOrm.sql`${nodes3.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${nodes.id} > ${params.after}`);
+    conditions.push(drizzleOrm.sql`${nodes3.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes.id} ASC` : drizzleOrm.sql`${nodes.createdAt} DESC, ${nodes.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes3.id} ASC` : drizzleOrm.sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
+      SELECT * FROM ${nodes3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1261,28 +2538,28 @@ function buildFindNodesByKind(tables, params) {
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
+      SELECT * FROM ${nodes3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
+    SELECT * FROM ${nodes3}
     WHERE ${whereClause}
     ORDER BY ${orderByClause}
   `;
 }
-function buildCountNodesByKind(tables, params) {
-  const { nodes } = tables;
+function buildCountNodesByKind(tables3, params) {
+  const { nodes: nodes3 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
+    drizzleOrm.sql`${nodes3.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
   ];
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${nodes}
+    SELECT COUNT(*) as count FROM ${nodes3}
     WHERE ${whereClause}
   `;
 }
@@ -1292,43 +2569,43 @@ function buildIdSetCondition(column, ids) {
     drizzleOrm.sql`, `
   )})`;
 }
-function buildEdgeOrdering(tables, orderBy) {
-  const { edges } = tables;
-  return orderBy === "id" ? { qualified: drizzleOrm.sql`${edges.id} ASC`, bare: drizzleOrm.sql.raw(`"id" ASC`) } : {
-    qualified: drizzleOrm.sql`${edges.createdAt} DESC, ${edges.id} DESC`,
+function buildEdgeOrdering(tables3, orderBy) {
+  const { edges: edges3 } = tables3;
+  return orderBy === "id" ? { qualified: drizzleOrm.sql`${edges3.id} ASC`, bare: drizzleOrm.sql.raw(`"id" ASC`) } : {
+    qualified: drizzleOrm.sql`${edges3.createdAt} DESC, ${edges3.id} DESC`,
     bare: drizzleOrm.sql.raw(`"created_at" DESC, "id" DESC`)
   };
 }
-function buildFindEdgesByKind(tables, params) {
-  const { edges } = tables;
+function buildFindEdgesByKind(tables3, params) {
+  const { edges: edges3 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
+    drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges3.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges3.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges3.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges3.toId} = ${params.toId}`);
   }
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.id} > ${params.after}`);
+    conditions.push(drizzleOrm.sql`${edges3.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   const { qualified: orderByClause } = buildEdgeOrdering(
-    tables,
+    tables3,
     params.orderBy
   );
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1336,37 +2613,37 @@ function buildFindEdgesByKind(tables, params) {
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.sql`
-    SELECT * FROM ${edges}
+    SELECT * FROM ${edges3}
     WHERE ${whereClause}
     ORDER BY ${orderByClause}
   `;
 }
-function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
-  const { edges } = tables;
+function buildFindEdgesByEndpointSet(tables3, params, endpointIds) {
+  const { edges: edges3 } = tables3;
   const fromSide = params.side === "from";
-  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
-  const idColumn = fromSide ? edges.fromId : edges.toId;
+  const kindColumn = fromSide ? edges3.fromKind : edges3.toKind;
+  const idColumn = fromSide ? edges3.fromId : edges3.toId;
   const whereClause = drizzleOrm.sql.join(
     [
-      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-      drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-      ...buildTemporalConditions(edges, params),
+      drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
+      drizzleOrm.sql`${edges3.kind} = ${params.kind}`,
+      ...buildTemporalConditions(edges3, params),
       drizzleOrm.sql`${kindColumn} = ${params.endpointKind}`,
       buildIdSetCondition(idColumn, endpointIds)
     ],
     drizzleOrm.sql` AND `
   );
-  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
+  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables3, void 0);
   if (params.limitPerEndpoint === void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
     `;
@@ -1375,7 +2652,7 @@ function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
     SELECT *, ROW_NUMBER() OVER (
       PARTITION BY ${idColumn} ORDER BY ${orderByClause}
     ) AS endpoint_rank
-    FROM ${edges}
+    FROM ${edges3}
     WHERE ${whereClause}
   `;
   return drizzleOrm.sql`
@@ -1384,11 +2661,11 @@ function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
     ORDER BY ${derivedOrderByClause}
   `;
 }
-function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edgeKinds) {
-  const { edges } = tables;
+function buildFindEdgesByHeterogeneousEndpointSet(tables3, params, endpoints, edgeKinds) {
+  const { edges: edges3 } = tables3;
   const fromSide = params.side === "from";
-  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
-  const idColumn = fromSide ? edges.fromId : edges.toId;
+  const kindColumn = fromSide ? edges3.fromKind : edges3.toKind;
+  const idColumn = fromSide ? edges3.fromId : edges3.toId;
   const requestedKind = drizzleOrm.sql.raw(`requested_endpoints."endpoint_kind"`);
   const requestedId = drizzleOrm.sql.raw(`requested_endpoints."endpoint_id"`);
   const requestedRows = drizzleOrm.sql.join(
@@ -1397,32 +2674,32 @@ function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edg
   );
   const whereClause = drizzleOrm.sql.join(
     [
-      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-      buildIdSetCondition(edges.kind, edgeKinds),
-      ...buildTemporalConditions(edges, params)
+      drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
+      buildIdSetCondition(edges3.kind, edgeKinds),
+      ...buildTemporalConditions(edges3, params)
     ],
     drizzleOrm.sql` AND `
   );
   const joinClause = drizzleOrm.sql`
-    FROM ${edges}
+    FROM ${edges3}
     INNER JOIN requested_endpoints
       ON ${kindColumn} = ${requestedKind}
      AND ${idColumn} = ${requestedId}
     WHERE ${whereClause}
   `;
-  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
+  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables3, void 0);
   if (params.limitPerEndpoint === void 0) {
     return drizzleOrm.sql`
       WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
         VALUES ${requestedRows}
       )
-      SELECT ${edges}.*
+      SELECT ${edges3}.*
       ${joinClause}
       ORDER BY ${orderByClause}
     `;
   }
   const ranked = drizzleOrm.sql`
-    SELECT ${edges}.*, ROW_NUMBER() OVER (
+    SELECT ${edges3}.*, ROW_NUMBER() OVER (
       PARTITION BY ${kindColumn}, ${idColumn} ORDER BY ${orderByClause}
     ) AS endpoint_rank
     ${joinClause}
@@ -1436,28 +2713,28 @@ function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edg
     ORDER BY ${derivedOrderByClause}
   `;
 }
-function buildCountEdgesByKind(tables, params) {
-  const { edges } = tables;
+function buildCountEdgesByKind(tables3, params) {
+  const { edges: edges3 } = tables3;
   const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
+    drizzleOrm.sql`${edges3.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges3.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges3.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges3.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges3.toId} = ${params.toId}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
+    SELECT COUNT(*) as count FROM ${edges3}
     WHERE ${whereClause}
   `;
 }
@@ -1471,313 +2748,382 @@ function inList(values) {
     drizzleOrm.sql`, `
   );
 }
-function buildContendedUniqueRowAudit(tables, graphId, constraintNames) {
-  const { uniques } = tables;
-  const relation = drizzleOrm.getTableName(uniques);
+function buildContendedUniqueRowAudit(tables3, graphId, constraintNames) {
+  const { uniques: uniques3 } = tables3;
+  const relation = drizzleOrm.getTableName(uniques3);
   return drizzleOrm.sql`
     SELECT
-      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.nodeKind)} as node_kind,
-      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.constraintName)} as constraint_name,
-      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.key)} as key,
-      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.concreteKind)} as concrete_kind,
-      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.nodeId)} as node_id
-    FROM ${uniques}
-    WHERE ${qualified2(relation, uniques.graphId)} = ${graphId}
-      AND ${qualified2(relation, uniques.constraintName)} IN (${inList(constraintNames)})
-      AND ${qualified2(relation, uniques.deletedAt)} IS NULL
+      ${quotedColumn(uniques3.nodeKind)} as node_kind,
+      ${quotedColumn(uniques3.constraintName)} as constraint_name,
+      ${quotedColumn(uniques3.key)} as key,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind,
+      ${quotedColumn(uniques3.nodeId)} as node_id
+    FROM ${uniques3}
+    WHERE ${qualified2(relation, uniques3.graphId)} = ${graphId}
+      AND ${qualified2(relation, uniques3.constraintName)} IN (${inList(constraintNames)})
+      AND ${qualified2(relation, uniques3.deletedAt)} IS NULL
       AND EXISTS (
-        SELECT 1 FROM ${uniques} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
-        WHERE ${qualified2(PEER, uniques.graphId)} = ${qualified2(relation, uniques.graphId)}
-          AND ${qualified2(PEER, uniques.constraintName)} = ${qualified2(relation, uniques.constraintName)}
-          AND ${qualified2(PEER, uniques.key)} = ${qualified2(relation, uniques.key)}
-          AND ${qualified2(PEER, uniques.deletedAt)} IS NULL
-          AND ${qualified2(PEER, uniques.nodeKind)} <> ${qualified2(relation, uniques.nodeKind)}
+        SELECT 1 FROM ${uniques3} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
+        WHERE ${qualified2(PEER, uniques3.graphId)} = ${qualified2(relation, uniques3.graphId)}
+          AND ${qualified2(PEER, uniques3.constraintName)} = ${qualified2(relation, uniques3.constraintName)}
+          AND ${qualified2(PEER, uniques3.key)} = ${qualified2(relation, uniques3.key)}
+          AND ${qualified2(PEER, uniques3.deletedAt)} IS NULL
+          AND ${qualified2(PEER, uniques3.nodeKind)} <> ${qualified2(relation, uniques3.nodeKind)}
       )
   `;
 }
-function buildContendedEdgeRowAudit(tables, graphId, cardinality, edgeKinds) {
-  const { edges } = tables;
-  const relation = drizzleOrm.getTableName(edges);
-  const spec = chunk7PRMDZIA_cjs.EDGE_CARDINALITY_SPECS[cardinality];
-  const activeOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(relation, edges.validTo)} IS NULL` : drizzleOrm.sql.empty();
-  const peerActiveOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(PEER, edges.validTo)} IS NULL` : drizzleOrm.sql.empty();
+function buildContendedEdgeRowAudit(tables3, graphId, cardinality, edgeKinds) {
+  const { edges: edges3 } = tables3;
+  const relation = drizzleOrm.getTableName(edges3);
+  const spec = chunkFMMW3KX7_cjs.EDGE_CARDINALITY_SPECS[cardinality];
+  const activeOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(relation, edges3.validTo)} IS NULL` : drizzleOrm.sql.empty();
+  const peerActiveOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(PEER, edges3.validTo)} IS NULL` : drizzleOrm.sql.empty();
   const peerToEndpoints = spec.keyShape === "fromAndTo" ? drizzleOrm.sql`
-        AND ${qualified2(PEER, edges.toKind)} = ${qualified2(relation, edges.toKind)}
-                  AND ${qualified2(PEER, edges.toId)} = ${qualified2(relation, edges.toId)}
+        AND ${qualified2(PEER, edges3.toKind)} = ${qualified2(relation, edges3.toKind)}
+                  AND ${qualified2(PEER, edges3.toId)} = ${qualified2(relation, edges3.toId)}
       ` : drizzleOrm.sql.empty();
   return drizzleOrm.sql`
     SELECT
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.id)} as edge_id,
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.kind)} as edge_kind,
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.fromKind)} as from_kind,
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.fromId)} as from_id,
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.toKind)} as to_kind,
-      ${chunkEH3JZJUM_cjs.quotedColumn(edges.toId)} as to_id
-    FROM ${edges}
-    WHERE ${qualified2(relation, edges.graphId)} = ${graphId}
-      AND ${qualified2(relation, edges.kind)} IN (${inList(edgeKinds)})
-      AND ${qualified2(relation, edges.deletedAt)} IS NULL${activeOnly}
+      ${quotedColumn(edges3.id)} as edge_id,
+      ${quotedColumn(edges3.kind)} as edge_kind,
+      ${quotedColumn(edges3.fromKind)} as from_kind,
+      ${quotedColumn(edges3.fromId)} as from_id,
+      ${quotedColumn(edges3.toKind)} as to_kind,
+      ${quotedColumn(edges3.toId)} as to_id
+    FROM ${edges3}
+    WHERE ${qualified2(relation, edges3.graphId)} = ${graphId}
+      AND ${qualified2(relation, edges3.kind)} IN (${inList(edgeKinds)})
+      AND ${qualified2(relation, edges3.deletedAt)} IS NULL${activeOnly}
       AND EXISTS (
-        SELECT 1 FROM ${edges} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
-        WHERE ${qualified2(PEER, edges.graphId)} = ${qualified2(relation, edges.graphId)}
-          AND ${qualified2(PEER, edges.kind)} = ${qualified2(relation, edges.kind)}
-          AND ${qualified2(PEER, edges.fromKind)} = ${qualified2(relation, edges.fromKind)}
-          AND ${qualified2(PEER, edges.fromId)} = ${qualified2(relation, edges.fromId)}${peerToEndpoints}
-          AND ${qualified2(PEER, edges.deletedAt)} IS NULL${peerActiveOnly}
-          AND ${qualified2(PEER, edges.id)} <> ${qualified2(relation, edges.id)}
+        SELECT 1 FROM ${edges3} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
+        WHERE ${qualified2(PEER, edges3.graphId)} = ${qualified2(relation, edges3.graphId)}
+          AND ${qualified2(PEER, edges3.kind)} = ${qualified2(relation, edges3.kind)}
+          AND ${qualified2(PEER, edges3.fromKind)} = ${qualified2(relation, edges3.fromKind)}
+          AND ${qualified2(PEER, edges3.fromId)} = ${qualified2(relation, edges3.fromId)}${peerToEndpoints}
+          AND ${qualified2(PEER, edges3.deletedAt)} IS NULL${peerActiveOnly}
+          AND ${qualified2(PEER, edges3.id)} <> ${qualified2(relation, edges3.id)}
       )
   `;
 }
-function buildDisjointOverlapAudit(tables, graphId, kinds) {
-  const { nodes } = tables;
-  const relation = drizzleOrm.getTableName(nodes);
+function buildDisjointOverlapAudit(tables3, graphId, kinds) {
+  const { nodes: nodes3 } = tables3;
+  const relation = drizzleOrm.getTableName(nodes3);
   const liveIdsOfKind = (kind) => drizzleOrm.sql`
-    SELECT ${chunkEH3JZJUM_cjs.quotedColumn(nodes.id)} as node_id
-    FROM ${nodes}
-    WHERE ${qualified2(relation, nodes.graphId)} = ${graphId}
-      AND ${qualified2(relation, nodes.kind)} = ${kind}
-      AND ${qualified2(relation, nodes.deletedAt)} IS NULL
+    SELECT ${quotedColumn(nodes3.id)} as node_id
+    FROM ${nodes3}
+    WHERE ${qualified2(relation, nodes3.graphId)} = ${graphId}
+      AND ${qualified2(relation, nodes3.kind)} = ${kind}
+      AND ${qualified2(relation, nodes3.deletedAt)} IS NULL
   `;
   return drizzleOrm.sql`${liveIdsOfKind(kinds[0])} INTERSECT ${liveIdsOfKind(kinds[1])}`;
 }
-function buildInsertEdge(tables, params, timestamp) {
-  const { edges } = tables;
+function qualified3(tableName, column) {
+  return drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
+}
+function buildLockEdgeClaims(tables3, entries, timestamp2) {
+  const { edgeClaims: edgeClaims3 } = tables3;
+  const claimsName = drizzleOrm.getTableName(edgeClaims3);
+  const columns = drizzleOrm.sql.raw(
+    `"${edgeClaims3.graphId.name}", "${edgeClaims3.axis.name}", "${edgeClaims3.key.name}", "${edgeClaims3.edgeId.name}", "${edgeClaims3.updatedAt.name}"`
+  );
+  const conflictColumns = drizzleOrm.sql.raw(
+    `"${edgeClaims3.graphId.name}", "${edgeClaims3.axis.name}", "${edgeClaims3.key.name}"`
+  );
+  const valueRows = drizzleOrm.sql.join(
+    entries.map((entry) => {
+      const target = chunkFMMW3KX7_cjs.edgeCardinalityClaimTarget(entry);
+      return drizzleOrm.sql`(${entry.graphId}, ${target.axis}, ${target.key}, ${entry.edgeId}, ${timestamp2})`;
+    }),
+    drizzleOrm.sql`, `
+  );
+  return drizzleOrm.sql`
+    INSERT INTO ${edgeClaims3} (${columns})
+    VALUES ${valueRows}
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET ${quotedColumn(edgeClaims3.updatedAt)} = ${qualified3(claimsName, edgeClaims3.updatedAt)}
+    RETURNING
+      ${quotedColumn(edgeClaims3.axis)} as axis,
+      ${quotedColumn(edgeClaims3.key)} as key,
+      ${quotedColumn(edgeClaims3.edgeId)} as holder_edge_id
+  `;
+}
+function buildTakeOverEdgeClaim(tables3, params, timestamp2) {
+  const { edgeClaims: edgeClaims3, edges: edges3 } = tables3;
+  const claimsName = drizzleOrm.getTableName(edgeClaims3);
+  const edgesName = drizzleOrm.getTableName(edges3);
+  const spec = chunkFMMW3KX7_cjs.EDGE_CARDINALITY_SPECS[params.cardinality];
+  const target = chunkFMMW3KX7_cjs.edgeCardinalityClaimTarget(params);
+  const toEndpointTerms = spec.keyShape === "fromAndTo" ? drizzleOrm.sql` AND ${qualified3(edgesName, edges3.toKind)} = ${params.toKind} AND ${qualified3(edgesName, edges3.toId)} = ${params.toId}` : drizzleOrm.sql``;
+  const activeTerm = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified3(edgesName, edges3.validTo)} IS NULL` : drizzleOrm.sql``;
+  return drizzleOrm.sql`
+    UPDATE ${edgeClaims3}
+    SET ${quotedColumn(edgeClaims3.edgeId)} = ${params.edgeId},
+        ${quotedColumn(edgeClaims3.updatedAt)} = ${timestamp2}
+    WHERE ${qualified3(claimsName, edgeClaims3.graphId)} = ${params.graphId}
+      AND ${qualified3(claimsName, edgeClaims3.axis)} = ${target.axis}
+      AND ${qualified3(claimsName, edgeClaims3.key)} = ${target.key}
+      AND ${qualified3(claimsName, edgeClaims3.edgeId)} <> ${params.edgeId}
+      AND NOT EXISTS (
+        SELECT 1 FROM ${edges3}
+        WHERE ${qualified3(edgesName, edges3.graphId)} = ${qualified3(claimsName, edgeClaims3.graphId)}
+          AND ${qualified3(edgesName, edges3.id)} = ${qualified3(claimsName, edgeClaims3.edgeId)}
+          AND ${qualified3(edgesName, edges3.deletedAt)} IS NULL
+          AND ${qualified3(edgesName, edges3.kind)} = ${params.edgeKind}
+          AND ${qualified3(edgesName, edges3.fromKind)} = ${params.fromKind}
+          AND ${qualified3(edgesName, edges3.fromId)} = ${params.fromId}${toEndpointTerms}${activeTerm}
+      )
+    RETURNING ${quotedColumn(edgeClaims3.edgeId)} as holder_edge_id
+  `;
+}
+function buildPurgeEdgeClaims(tables3, params) {
+  const { edgeClaims: edgeClaims3 } = tables3;
+  return drizzleOrm.sql`
+    DELETE FROM ${edgeClaims3}
+    WHERE ${edgeClaims3.graphId} = ${params.graphId}
+      AND ${edgeClaims3.edgeId} IN (${drizzleOrm.sql.join(
+    params.edgeIds.map((edgeId) => drizzleOrm.sql`${edgeId}`),
+    drizzleOrm.sql`, `
+  )})
+  `;
+}
+function buildInsertEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
+  const columns = edgeColumnList(edges3);
   return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      ${propsJson}, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
     RETURNING *
   `;
 }
-function buildInsertEdgeNoReturn(tables, params, timestamp) {
-  const { edges } = tables;
+function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
+  const columns = edgeColumnList(edges3);
   return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      ${propsJson}, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
   `;
 }
-function buildInsertEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
+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 drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
   `;
 }
-function buildInsertEdgesBatchReturning(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
+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 drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
-function buildGetEdge(tables, graphId, id) {
-  const { edges } = tables;
+function buildGetEdge(tables3, graphId, id) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} = ${id}
+    SELECT * FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
+      AND ${edges3.id} = ${id}
   `;
 }
-function buildGetEdges(tables, graphId, ids) {
-  const { edges } = tables;
+function buildGetEdges(tables3, graphId, ids) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
+    SELECT * FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
+      AND ${edges3.id} IN (${drizzleOrm.sql.join(
     ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.sql`, `
   )})
   `;
 }
-function expectedIdentityPredicate(tables, expected) {
-  const { edges } = tables;
+function expectedIdentityPredicate(tables3, expected) {
+  const { edges: edges3 } = tables3;
   const parts = [
-    expected.kind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.kind} = ${expected.kind}`,
-    expected.fromKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromKind} = ${expected.fromKind}`,
-    expected.fromId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromId} = ${expected.fromId}`,
-    expected.toKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toKind} = ${expected.toKind}`,
-    expected.toId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toId} = ${expected.toId}`
+    expected.kind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges3.kind} = ${expected.kind}`,
+    expected.fromKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges3.fromKind} = ${expected.fromKind}`,
+    expected.fromId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges3.fromId} = ${expected.fromId}`,
+    expected.toKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges3.toKind} = ${expected.toKind}`,
+    expected.toId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges3.toId} = ${expected.toId}`
   ].filter((part) => part !== void 0);
   return parts.length === 0 ? drizzleOrm.sql.empty() : drizzleOrm.sql.join(parts, drizzleOrm.sql``);
 }
-function buildUpdateEdge(tables, params, timestamp) {
-  const { edges } = tables;
+function buildUpdateEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.updatedAt)} = ${timestamp}`
+    drizzleOrm.sql`${quotedColumn(edges3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${quotedColumn(edges3.updatedAt)} = ${timestamp2}`
   ];
   if (params.clearDeleted && params.validFrom !== void 0) {
     setParts.push(
-      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validFrom)} = ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStatedValidityLowerBound(params.validFrom))}`,
-      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)}`
+      drizzleOrm.sql`${quotedColumn(edges3.validFrom)} = ${sqlNull(chunkM5MSP3BI_cjs.resolveStatedValidityLowerBound(params.validFrom))}`,
+      drizzleOrm.sql`${quotedColumn(edges3.validTo)} = ${sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(edges3.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(edges3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(edges3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  const expectedIdentity = expectedIdentityPredicate(tables, params);
-  const expectedValidFrom = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
-    edges.validFrom,
+  const expectedIdentity = expectedIdentityPredicate(tables3, params);
+  const expectedValidFrom = expectedValidFromPredicate(
+    edges3.validFrom,
     params.expectedValidFrom
   );
-  const expectedValidTo = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
-    edges.validTo,
+  const expectedValidTo = expectedValidFromPredicate(
+    edges3.validTo,
     params.expectedValidTo
   );
   if (params.clearDeleted) {
     return drizzleOrm.sql`
-      UPDATE ${edges}
+      UPDATE ${edges3}
       SET ${setClause}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
+      WHERE ${edges3.graphId} = ${params.graphId}
+        AND ${edges3.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
       RETURNING *
     `;
   }
   return drizzleOrm.sql`
-    UPDATE ${edges}
+    UPDATE ${edges3}
     SET ${setClause}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
-      AND ${edges.deletedAt} IS NULL
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
+      AND ${edges3.deletedAt} IS NULL
     RETURNING *
   `;
 }
-function buildDeleteEdge(tables, params, timestamp) {
-  const { edges } = tables;
+function buildDeleteEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
-      AND ${edges.deletedAt} IS NULL
+    UPDATE ${edges3}
+    SET ${quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} = ${params.id}${expectedIdentityPredicate(tables3, params.kind === void 0 ? {} : { kind: params.kind })}
+      AND ${edges3.deletedAt} IS NULL
   `;
 }
-function buildDeleteEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
+function buildDeleteEdgesBatch(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
+    UPDATE ${edges3}
+    SET ${quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} IN (${drizzleOrm.sql.join(
     params.ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.sql`, `
   )})
-      AND ${edges.deletedAt} IS NULL
+      AND ${edges3.deletedAt} IS NULL
   `;
 }
-function buildHardDeleteEdgesBatch(tables, params) {
-  const { edges } = tables;
+function buildHardDeleteEdgesBatch(tables3, params) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} IN (${drizzleOrm.sql.join(
     params.ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.sql`, `
   )})
   `;
 }
-function buildHardDeleteEdge(tables, params) {
-  const { edges } = tables;
+function buildHardDeleteEdge(tables3, params) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} = ${params.id}${expectedIdentityPredicate(tables3, params.kind === void 0 ? {} : { kind: params.kind })}
   `;
 }
-function buildHardDeleteEdgesByNode(tables, graphId, nodeKind, nodeId) {
-  const { edges } = tables;
+function buildHardDeleteEdgesByNode(tables3, graphId, nodeKind, nodeId) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
       AND (
-        (${edges.fromKind} = ${nodeKind} AND ${edges.fromId} = ${nodeId})
-        OR (${edges.toKind} = ${nodeKind} AND ${edges.toId} = ${nodeId})
+        (${edges3.fromKind} = ${nodeKind} AND ${edges3.fromId} = ${nodeId})
+        OR (${edges3.toKind} = ${nodeKind} AND ${edges3.toId} = ${nodeId})
       )
   `;
 }
-function buildCountEdgesFrom(tables, params) {
-  const { edges } = tables;
+function buildCountEdgesFrom(tables3, params) {
+  const { edges: edges3 } = tables3;
   if (params.activeOnly) {
     return drizzleOrm.sql`
-      SELECT COUNT(*) as count FROM ${edges}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.kind} = ${params.edgeKind}
-        AND ${edges.fromKind} = ${params.fromKind}
-        AND ${edges.fromId} = ${params.fromId}
-        AND ${edges.deletedAt} IS NULL
-        AND ${edges.validTo} IS NULL
+      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 drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.deletedAt} IS NULL
+    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(tables, params) {
-  const { edges } = tables;
+function buildEdgeExistsBetween(tables3, params) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    SELECT 1 FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.toKind} = ${params.toKind}
-      AND ${edges.toId} = ${params.toId}
-      AND ${edges.deletedAt} IS NULL
+    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(tables, params) {
-  const { edges } = tables;
+function buildFindEdgesConnectedTo(tables3, params) {
+  const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.fromKind} = ${params.nodeKind}
-      AND ${edges.fromId} = ${params.nodeId}
+    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 ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.toKind} = ${params.nodeKind}
-      AND ${edges.toId} = ${params.nodeId}
+    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 (
-        ${edges.fromKind} = ${params.nodeKind}
-        AND ${edges.fromId} = ${params.nodeId}
+        ${edges3.fromKind} = ${params.nodeKind}
+        AND ${edges3.fromId} = ${params.nodeId}
       )
   `;
 }
@@ -1787,12 +3133,12 @@ function resolveMode(mode) {
 function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
-  const table = chunkEH3JZJUM_cjs.quotedTableName(tableName);
-  const matchCondition = chunk45YZXI6X_cjs.toDrizzleSql(
+  const table = quotedTableName(tableName);
+  const matchCondition = chunkLLFPQOBA_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunk45YZXI6X_cjs.toDrizzleSql(
+  const rankExpression = chunkLLFPQOBA_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1805,10 +3151,10 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    const candidateSql = chunkOJHD3LXJ_cjs.isSqlFragment(candidates) ? chunk45YZXI6X_cjs.toDrizzleSql(candidates, dialect) : candidates;
+    const candidateSql = chunkH5IJSROF_cjs.isSqlFragment(candidates) ? chunkLLFPQOBA_cjs.toDrizzleSql(candidates, dialect) : candidates;
     conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
   }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunk45YZXI6X_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkLLFPQOBA_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1825,7 +3171,7 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
       ${snippetExpr} AS snippet
     FROM ${table}
     WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
-    ORDER BY ${rankExpression} DESC, ${chunkEH3JZJUM_cjs.codePointOrderKey(drizzleOrm.sql.raw('"node_id"'), dialect)} ASC
+    ORDER BY ${rankExpression} DESC, ${codePointOrderKey(drizzleOrm.sql.raw('"node_id"'), dialect)} ASC
     ${pageClause}
   `;
 }
@@ -1839,179 +3185,179 @@ function assertValidSearchParams(params) {
     );
   }
 }
-function buildInsertNode(tables, params, timestamp) {
-  const { nodes } = tables;
+function buildInsertNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
+  const columns = nodeColumnList(nodes3);
   return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      1, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
     RETURNING *
   `;
 }
-function buildInsertNodeNoReturn(tables, params, timestamp) {
-  const { nodes } = tables;
+function buildInsertNodeNoReturn(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
+  const columns = nodeColumnList(nodes3);
   return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      1, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
   `;
 }
-function buildInsertNodesBatch(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
+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 drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
   `;
 }
-function buildInsertNodesBatchReturning(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
+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 drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
-function buildGetNode(tables, graphId, kind, id) {
-  const { nodes } = tables;
+function buildGetNode(tables3, graphId, kind, id) {
+  const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} = ${id}
+    SELECT * FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${graphId}
+      AND ${nodes3.kind} = ${kind}
+      AND ${nodes3.id} = ${id}
   `;
 }
-function buildGetNodes(tables, graphId, kind, ids) {
-  const { nodes } = tables;
+function buildGetNodes(tables3, graphId, kind, ids) {
+  const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} IN (${drizzleOrm.sql.join(
+    SELECT * FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${graphId}
+      AND ${nodes3.kind} = ${kind}
+      AND ${nodes3.id} IN (${drizzleOrm.sql.join(
     ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.sql`, `
   )})
   `;
 }
-function buildUpdateNode(tables, params, timestamp) {
-  const { nodes } = tables;
+function buildUpdateNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.props)} = ${propsJson}`,
-    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.updatedAt)} = ${timestamp}`
+    drizzleOrm.sql`${quotedColumn(nodes3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} = ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} + 1`
+      drizzleOrm.sql`${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1`
     );
   }
   if (params.clearDeleted) {
     setParts.push(
-      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validFrom)} = ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}`,
-      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)}`
+      drizzleOrm.sql`${quotedColumn(nodes3.validFrom)} = ${sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}`,
+      drizzleOrm.sql`${quotedColumn(nodes3.validTo)} = ${sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(nodes3.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(nodes3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(nodes3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  const expectedValidFrom = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
-    nodes.validFrom,
+  const expectedValidFrom = expectedValidFromPredicate(
+    nodes3.validFrom,
     params.expectedValidFrom
   );
   if (params.clearDeleted) {
     return drizzleOrm.sql`
-      UPDATE ${nodes}
+      UPDATE ${nodes3}
       SET ${setClause}
-      WHERE ${nodes.graphId} = ${params.graphId}
-        AND ${nodes.kind} = ${params.kind}
-        AND ${nodes.id} = ${params.id}${expectedValidFrom}
-        AND ${nodes.deletedAt} IS NOT NULL
+      WHERE ${nodes3.graphId} = ${params.graphId}
+        AND ${nodes3.kind} = ${params.kind}
+        AND ${nodes3.id} = ${params.id}${expectedValidFrom}
+        AND ${nodes3.deletedAt} IS NOT NULL
       RETURNING *
     `;
   }
   return drizzleOrm.sql`
-    UPDATE ${nodes}
+    UPDATE ${nodes3}
     SET ${setClause}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}${expectedValidFrom}
-      AND ${nodes.deletedAt} IS NULL
+    WHERE ${nodes3.graphId} = ${params.graphId}
+      AND ${nodes3.kind} = ${params.kind}
+      AND ${nodes3.id} = ${params.id}${expectedValidFrom}
+      AND ${nodes3.deletedAt} IS NULL
     RETURNING *
   `;
 }
-function buildUpdateNodeSet(tables, dialect, params, timestamp) {
-  const { nodes } = tables;
-  const adapter = chunkTEC24ZDA_cjs.getDialect(dialect);
-  const patchedProps = chunk45YZXI6X_cjs.toDrizzleSql(
+function buildUpdateNodeSet(tables3, dialect, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
+  const adapter = chunkJVA3KDEA_cjs.getDialect(dialect);
+  const patchedProps = chunkLLFPQOBA_cjs.toDrizzleSql(
     adapter.jsonSetProperties(
-      chunkOJHD3LXJ_cjs.sql.identifier(nodes.props.name),
+      chunkH5IJSROF_cjs.sql.identifier(nodes3.props.name),
       params.patch,
       params.unsetProperties ?? []
     ),
     dialect
   );
-  const candidateIds = chunk45YZXI6X_cjs.toDrizzleSql(params.candidateIds, dialect);
-  const candidateIdColumn = chunk45YZXI6X_cjs.toDrizzleSql(
-    chunkOJHD3LXJ_cjs.sql.identifier(params.candidateIdColumn),
+  const candidateIds = chunkLLFPQOBA_cjs.toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = chunkLLFPQOBA_cjs.toDrizzleSql(
+    chunkH5IJSROF_cjs.sql.identifier(params.candidateIdColumn),
     dialect
   );
   return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(nodes.props)} = ${patchedProps},
-        ${chunkEH3JZJUM_cjs.quotedColumn(nodes.updatedAt)} = ${timestamp},
-        ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} = ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} + 1
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.deletedAt} IS NULL
-      AND ${nodes.id} IN (
+    UPDATE ${nodes3}
+    SET ${quotedColumn(nodes3.props)} = ${patchedProps},
+        ${quotedColumn(nodes3.updatedAt)} = ${timestamp2},
+        ${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1
+    WHERE ${nodes3.graphId} = ${params.graphId}
+      AND ${nodes3.kind} = ${params.kind}
+      AND ${nodes3.deletedAt} IS NULL
+      AND ${nodes3.id} IN (
         SELECT ${candidateIdColumn}
         FROM (${candidateIds}) AS tg_set_candidates
       )
     RETURNING *
   `;
 }
-function buildDeleteNode(tables, params, timestamp) {
-  const { nodes } = tables;
+function buildDeleteNode(tables3, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(nodes.deletedAt)} = ${timestamp}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-      AND ${nodes.deletedAt} IS NULL
+    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(tables, params) {
-  const { nodes } = tables;
+function buildHardDeleteNode(tables3, params) {
+  const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
-    DELETE FROM ${nodes}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
+    DELETE FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${params.graphId}
+      AND ${nodes3.kind} = ${params.kind}
+      AND ${nodes3.id} = ${params.id}
   `;
 }
 function createSchemaDialectStrategy(dialect) {
@@ -2032,66 +3378,319 @@ var SCHEMA_DIALECT_STRATEGIES = {
   postgres: createSchemaDialectStrategy("postgres"),
   sqlite: createSchemaDialectStrategy("sqlite")
 };
-function buildInsertSchema(tables, params, timestamp, dialect = "sqlite") {
-  const { schemaVersions } = tables;
+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 = drizzleOrm.sql.raw(
-    `"${schemaVersions.graphId.name}", "${schemaVersions.version.name}", "${schemaVersions.schemaHash.name}", "${schemaVersions.schemaDoc.name}", "${schemaVersions.createdAt.name}", "${schemaVersions.isActive.name}"`
+    `"${schemaVersions3.graphId.name}", "${schemaVersions3.version.name}", "${schemaVersions3.schemaHash.name}", "${schemaVersions3.schemaDoc.name}", "${schemaVersions3.createdAt.name}", "${schemaVersions3.isActive.name}"`
   );
   return drizzleOrm.sql`
-    INSERT INTO ${schemaVersions} (${columns})
+    INSERT INTO ${schemaVersions3} (${columns})
     VALUES (
       ${params.graphId}, ${params.version},
       ${params.schemaHash}, ${schemaDocumentJson},
-      ${timestamp}, ${isActiveValue}
+      ${timestamp2}, ${isActiveValue}
     )
     RETURNING *
   `;
 }
-function buildGetActiveSchema(tables, graphId, dialect = "sqlite") {
-  const { schemaVersions } = tables;
+function buildGetActiveSchema(tables3, graphId, dialect = "sqlite") {
+  const { schemaVersions: schemaVersions3 } = tables3;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.isActive} = ${strategy.booleanLiteral(true)}
+    SELECT * FROM ${schemaVersions3}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.isActive} = ${strategy.booleanLiteral(true)}
   `;
 }
-function buildGetSchemaVersion(tables, graphId, version) {
-  const { schemaVersions } = tables;
+function buildGetSchemaVersion(tables3, graphId, version) {
+  const { schemaVersions: schemaVersions3 } = tables3;
   return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
+    SELECT * FROM ${schemaVersions3}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.version} = ${version}
   `;
 }
-function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
-  const { schemaVersions } = tables;
+function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
+  const { schemaVersions: schemaVersions3 } = tables3;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
+    UPDATE ${schemaVersions3}
+    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${chunkEH3JZJUM_cjs.quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
+    UPDATE ${schemaVersions3}
+    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
+    WHERE ${schemaVersions3.graphId} = ${graphId}
+      AND ${schemaVersions3.version} = ${version}
   `;
   return { deactivateAll, activateVersion };
 }
+function drizzleSqlTag(strings, ...expressions) {
+  return drizzleOrm.sql(strings, ...expressions);
+}
+function ownerColumnNames(uniques3) {
+  return {
+    nodeId: uniques3.nodeId.name,
+    concreteKind: uniques3.concreteKind.name
+  };
+}
+function boundOwnerColumn(uniques3, params) {
+  return (columnName) => columnName === uniques3.nodeId.name ? drizzleOrm.sql`${params.nodeId}` : drizzleOrm.sql`${params.concreteKind}`;
+}
+function excludedColumnByName(columnName) {
+  return drizzleOrm.sql`excluded.${quotedColumn({ name: columnName })}`;
+}
+function excludedColumn(column) {
+  return excludedColumnByName(column.name);
+}
+function buildInsertUniqueSqlite(tables3, params) {
+  const { uniques: uniques3 } = tables3;
+  const columns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
+  );
+  const conflictColumns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
+  );
+  const ownerMatches = chunkCRZ56SZU_cjs.claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => quotedColumn({ name: columnName }),
+    boundOwnerColumn(uniques3, params),
+    ownerColumnNames(uniques3)
+  );
+  return drizzleOrm.sql`
+    INSERT INTO ${uniques3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${params.nodeId}
+        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${quotedColumn(uniques3.nodeId)}
+      END,
+      ${quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${params.concreteKind}
+        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${quotedColumn(uniques3.concreteKind)}
+      END,
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${quotedColumn(uniques3.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques3.nodeId)} as node_id,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind
+  `;
+}
+function buildInsertUniquePostgres(tables3, params) {
+  const { uniques: uniques3 } = tables3;
+  const columns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
+  );
+  const conflictColumns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
+  );
+  const tableName = drizzleOrm.getTableName(uniques3);
+  const existingColumnByName = (columnName) => drizzleOrm.sql`${quotedTableName(tableName)}.${quotedColumn({ name: columnName })}`;
+  const existingColumn = (column) => existingColumnByName(column.name);
+  const ownerMatches = chunkCRZ56SZU_cjs.claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => existingColumnByName(columnName),
+    boundOwnerColumn(uniques3, params),
+    ownerColumnNames(uniques3)
+  );
+  return drizzleOrm.sql`
+    INSERT INTO ${uniques3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${params.nodeId}
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${existingColumn(uniques3.nodeId)}
+      END,
+      ${quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${params.concreteKind}
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${existingColumn(uniques3.concreteKind)}
+      END,
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques3.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques3.nodeId)} as node_id,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind
+  `;
+}
+var UNIQUE_INSERT_BUILDERS = {
+  postgres: buildInsertUniquePostgres,
+  sqlite: buildInsertUniqueSqlite
+};
+function buildInsertUnique(tables3, dialect, params) {
+  const builder = UNIQUE_INSERT_BUILDERS[dialect];
+  return builder(tables3, params);
+}
+function buildInsertUniqueBatch(tables3, dialect, entries) {
+  const { uniques: uniques3 } = tables3;
+  const columns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
+  );
+  const conflictColumns = drizzleOrm.sql.raw(
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
+  );
+  const tableName = drizzleOrm.getTableName(uniques3);
+  const existingColumnByName = (columnName) => {
+    switch (dialect) {
+      case "postgres": {
+        return drizzleOrm.sql`${quotedTableName(tableName)}.${quotedColumn({ name: columnName })}`;
+      }
+      case "sqlite": {
+        return quotedColumn({ name: columnName });
+      }
+      default: {
+        return dialect;
+      }
+    }
+  };
+  const existingColumn = (column) => existingColumnByName(column.name);
+  const ownerMatches = chunkCRZ56SZU_cjs.claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => existingColumnByName(columnName),
+    excludedColumnByName,
+    ownerColumnNames(uniques3)
+  );
+  const valueRows = drizzleOrm.sql.join(
+    entries.map(
+      (params) => drizzleOrm.sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")})`
+    ),
+    drizzleOrm.sql`, `
+  );
+  return drizzleOrm.sql`
+    INSERT INTO ${uniques3} (${columns})
+    VALUES ${valueRows}
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${excludedColumn(uniques3.nodeId)}
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques3.nodeId)}
+        ELSE ${existingColumn(uniques3.nodeId)}
+      END,
+      ${quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${excludedColumn(uniques3.concreteKind)}
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques3.concreteKind)}
+        ELSE ${existingColumn(uniques3.concreteKind)}
+      END,
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques3.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques3.nodeKind)} as node_kind,
+      ${quotedColumn(uniques3.constraintName)} as constraint_name,
+      ${quotedColumn(uniques3.key)} as key,
+      ${quotedColumn(uniques3.nodeId)} as node_id,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind
+  `;
+}
+function buildDeleteUnique(tables3, params, timestamp2) {
+  const { uniques: uniques3 } = tables3;
+  const axisTerm = params.nodeKind === void 0 ? drizzleOrm.sql`` : drizzleOrm.sql` AND ${uniques3.nodeKind} = ${params.nodeKind}`;
+  return drizzleOrm.sql`
+    UPDATE ${uniques3}
+    SET ${quotedColumn(uniques3.deletedAt)} = ${timestamp2}
+    WHERE ${uniques3.graphId} = ${params.graphId}
+      AND ${uniques3.concreteKind} = ${params.concreteKind}
+      AND ${uniques3.nodeId} = ${params.nodeId}
+      AND ${uniques3.constraintName} = ${params.constraintName}
+      AND ${uniques3.key} = ${params.key}${axisTerm}
+      AND ${uniques3.deletedAt} IS NULL
+  `;
+}
+function buildHardDeleteUniquesByNode(tables3, graphId, concreteKind, nodeId) {
+  return buildHardDeleteUniquesByNodeIds(tables3, {
+    graphId,
+    concreteKind,
+    nodeIds: [nodeId]
+  });
+}
+function buildHardDeleteUniquesByNodeIds(tables3, params) {
+  const { uniques: uniques3 } = tables3;
+  return drizzleOrm.sql`
+    DELETE FROM ${uniques3}
+    WHERE ${uniques3.graphId} = ${params.graphId}
+      AND ${uniques3.concreteKind} = ${params.concreteKind}
+      AND ${uniques3.nodeId} IN (${drizzleOrm.sql.join(
+    params.nodeIds.map((nodeId) => drizzleOrm.sql`${nodeId}`),
+    drizzleOrm.sql`, `
+  )})
+  `;
+}
+function buildCheckUnique(tables3, params) {
+  const { uniques: uniques3 } = tables3;
+  if (params.includeDeleted) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${uniques3}
+      WHERE ${uniques3.graphId} = ${params.graphId}
+        AND ${uniques3.nodeKind} = ${params.nodeKind}
+        AND ${uniques3.constraintName} = ${params.constraintName}
+        AND ${uniques3.key} = ${params.key}
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT * FROM ${uniques3}
+    WHERE ${uniques3.graphId} = ${params.graphId}
+      AND ${uniques3.nodeKind} = ${params.nodeKind}
+      AND ${uniques3.constraintName} = ${params.constraintName}
+      AND ${uniques3.key} = ${params.key}
+      AND ${uniques3.deletedAt} IS NULL
+  `;
+}
+function buildCheckUniqueBatch(tables3, params) {
+  const { uniques: uniques3 } = tables3;
+  const keyPlaceholders = drizzleOrm.sql.join(
+    params.keys.map((key) => drizzleOrm.sql`${key}`),
+    drizzleOrm.sql`, `
+  );
+  if (params.includeDeleted) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${uniques3}
+      WHERE ${uniques3.graphId} = ${params.graphId}
+        AND ${uniques3.nodeKind} = ${params.nodeKind}
+        AND ${uniques3.constraintName} = ${params.constraintName}
+        AND ${uniques3.key} IN (${keyPlaceholders})
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT * FROM ${uniques3}
+    WHERE ${uniques3.graphId} = ${params.graphId}
+      AND ${uniques3.nodeKind} = ${params.nodeKind}
+      AND ${uniques3.constraintName} = ${params.constraintName}
+      AND ${uniques3.key} IN (${keyPlaceholders})
+      AND ${uniques3.deletedAt} IS NULL
+  `;
+}
 
 // src/backend/drizzle/operations/strategy.ts
 function nullableText(value) {
   return value === void 0 ? drizzleOrm.sql`NULL` : drizzleOrm.sql`${value}`;
 }
-function bindTableOperationBuilders(tables, builders) {
+function bindTableOperationBuilders(tables3, builders) {
   const boundEntries = Object.entries(builders).map(([name, builder]) => {
     function boundBuilder(...args) {
-      return builder(tables, ...args);
+      return builder(tables3, ...args);
     }
     return [name, boundBuilder];
   });
@@ -2130,30 +3729,30 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildFindEdgesByEndpointSet,
   buildFindEdgesByHeterogeneousEndpointSet,
   buildCountEdgesByKind,
-  buildDeleteUnique: chunkEH3JZJUM_cjs.buildDeleteUnique,
-  buildHardDeleteUniquesByNode: chunkEH3JZJUM_cjs.buildHardDeleteUniquesByNode,
-  buildHardDeleteUniquesByNodeIds: chunkEH3JZJUM_cjs.buildHardDeleteUniquesByNodeIds,
-  buildCheckUnique: chunkEH3JZJUM_cjs.buildCheckUnique,
-  buildCheckUniqueBatch: chunkEH3JZJUM_cjs.buildCheckUniqueBatch,
+  buildDeleteUnique,
+  buildHardDeleteUniquesByNode,
+  buildHardDeleteUniquesByNodeIds,
+  buildCheckUnique,
+  buildCheckUniqueBatch,
   buildGetSchemaVersion
 };
-function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
+function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
   const tableOperations = bindTableOperationBuilders(
-    tables,
+    tables3,
     COMMON_TABLE_OPERATION_BUILDERS
   );
-  const fulltextTable = tables.fulltextTableName;
-  const contributionMaterializations = tables.contributionMaterializations;
+  const fulltextTable = tables3.fulltextTableName;
+  const contributionMaterializations = tables3.contributionMaterializations;
   const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2).map((statement) => chunkLLFPQOBA_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkLLFPQOBA_cjs.toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
+    }).map((statement) => chunkLLFPQOBA_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2).map((statement) => chunkLLFPQOBA_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkLLFPQOBA_cjs.toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -2161,19 +3760,19 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       dialect,
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
-      params.candidates ?? chunkEH3JZJUM_cjs.liveNodeIdsSubquery(
-        tables.nodes,
+      params.candidates ?? liveNodeIdsSubquery(
+        tables3.nodes,
         params.graphId,
         params.nodeKind,
-        chunkEH3JZJUM_cjs.nowIso()
+        chunk36SX6QXP_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
-      const candidates = params.candidates ?? chunkEH3JZJUM_cjs.liveNodeIdsSubquery(
-        tables.nodes,
+      const candidates = params.candidates ?? liveNodeIdsSubquery(
+        tables3.nodes,
         params.graphId,
         params.nodeKind,
-        chunkEH3JZJUM_cjs.nowIso()
+        chunk36SX6QXP_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -2194,11 +3793,11 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkOJHD3LXJ_cjs.isSqlFragment(candidates) ? chunk45YZXI6X_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkH5IJSROF_cjs.isSqlFragment(candidates) ? chunkLLFPQOBA_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
-        nodes: tables.nodes,
+        nodes: tables3.nodes,
         dialect,
         graphId: params.graphId,
         nodeKind: params.nodeKind,
@@ -2241,57 +3840,57 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     ...tableOperations,
     ...fulltextBuilders,
     primaryKeyConstraints: {
-      nodes: chunkEH3JZJUM_cjs.nodePrimaryKeyConstraint(tables.nodes),
-      edges: chunkEH3JZJUM_cjs.edgePrimaryKeyConstraint(tables.edges)
+      nodes: nodePrimaryKeyConstraint(tables3.nodes),
+      edges: edgePrimaryKeyConstraint(tables3.edges)
     },
-    buildUpdateNodeSet(params, timestamp) {
-      return buildUpdateNodeSet(tables, dialect, params, timestamp);
+    buildUpdateNodeSet(params, timestamp2) {
+      return buildUpdateNodeSet(tables3, dialect, params, timestamp2);
     },
     buildDeleteContributionMaterialization,
     buildInsertContributionMaterialization,
     buildInsertUnique(params) {
-      return chunkEH3JZJUM_cjs.buildInsertUnique(tables, dialect, params);
+      return buildInsertUnique(tables3, dialect, params);
     },
     buildInsertUniqueBatch(entries) {
-      return chunkEH3JZJUM_cjs.buildInsertUniqueBatch(tables, dialect, entries);
+      return buildInsertUniqueBatch(tables3, dialect, entries);
     },
     buildHardDeleteUniquesByConcreteKind(params) {
-      return chunkEH3JZJUM_cjs.buildHardDeleteUniquesByConcreteKind(
-        drizzleOrm.getTableName(tables.uniques),
+      return chunk36SX6QXP_cjs.buildHardDeleteUniquesByConcreteKind(
+        drizzleOrm.getTableName(tables3.uniques),
         params
       );
     },
-    buildLockEdgeClaims(entries, timestamp) {
-      return chunkEH3JZJUM_cjs.buildLockEdgeClaims(tables, entries, timestamp);
+    buildLockEdgeClaims(entries, timestamp2) {
+      return buildLockEdgeClaims(tables3, entries, timestamp2);
     },
-    buildTakeOverEdgeClaim(params, timestamp) {
-      return chunkEH3JZJUM_cjs.buildTakeOverEdgeClaim(tables, params, timestamp);
+    buildTakeOverEdgeClaim(params, timestamp2) {
+      return buildTakeOverEdgeClaim(tables3, params, timestamp2);
     },
     buildPurgeEdgeClaims(params) {
-      return chunkEH3JZJUM_cjs.buildPurgeEdgeClaims(tables, params);
+      return buildPurgeEdgeClaims(tables3, params);
     },
     buildContendedUniqueRowAudit(graphId, constraintNames) {
-      return buildContendedUniqueRowAudit(tables, graphId, constraintNames);
+      return buildContendedUniqueRowAudit(tables3, graphId, constraintNames);
     },
     buildContendedEdgeRowAudit(graphId, cardinality, edgeKinds) {
       return buildContendedEdgeRowAudit(
-        tables,
+        tables3,
         graphId,
         cardinality,
         edgeKinds
       );
     },
     buildDisjointOverlapAudit(graphId, kinds) {
-      return buildDisjointOverlapAudit(tables, graphId, kinds);
+      return buildDisjointOverlapAudit(tables3, graphId, kinds);
     },
     buildGetActiveSchema(graphId) {
-      return buildGetActiveSchema(tables, graphId, dialect);
+      return buildGetActiveSchema(tables3, graphId, dialect);
     },
-    buildInsertSchema(params, timestamp) {
-      return buildInsertSchema(tables, params, timestamp, dialect);
+    buildInsertSchema(params, timestamp2) {
+      return buildInsertSchema(tables3, params, timestamp2, dialect);
     },
     buildSetActiveSchema(graphId, version) {
-      return buildSetActiveSchema(tables, graphId, version, dialect);
+      return buildSetActiveSchema(tables3, graphId, version, dialect);
     },
     buildTableExists(tableName) {
       switch (dialect) {
@@ -2314,7 +3913,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       }
     },
     buildClearGraph(graphId) {
-      return buildClearGraph(tables, graphId);
+      return buildClearGraph(tables3, graphId);
     }
   };
 }
@@ -2340,11 +3939,11 @@ function createCachedTableExistence(probe, options) {
     return exists;
   };
 }
-function createSqliteOperationStrategy(tables, fulltextStrategy) {
-  return createCommonOperationStrategy(tables, "sqlite", fulltextStrategy);
+function createSqliteOperationStrategy(tables3, fulltextStrategy) {
+  return createCommonOperationStrategy(tables3, "sqlite", fulltextStrategy);
 }
-function createPostgresOperationStrategy(tables, fulltextStrategy) {
-  return createCommonOperationStrategy(tables, "postgres", fulltextStrategy);
+function createPostgresOperationStrategy(tables3, fulltextStrategy) {
+  return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
 }
 function claimOwnerOf(params) {
   return { concreteKind: params.concreteKind, nodeId: params.nodeId };
@@ -2365,7 +3964,7 @@ async function withDuplicateKeyClassification(run, context) {
   try {
     return await run();
   } catch (error) {
-    if (!chunkZBFZGLZE_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
+    if (!chunkNLX5OWK7_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
     throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
       `Insert ${context.entity} failed: a row with this identity already exists`,
       {
@@ -2437,7 +4036,7 @@ function createCommonOperationBackend(options) {
     operationStrategy,
     rowMappers
   } = options;
-  const nowIso2 = options.nowIso ?? chunkEH3JZJUM_cjs.nowIso;
+  const nowIso2 = options.nowIso ?? chunk36SX6QXP_cjs.nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2453,7 +4052,7 @@ function createCommonOperationBackend(options) {
   async function claimEdgeCardinalityEntries(entries) {
     if (entries.length === 0) return [];
     const targetKey = (entry) => {
-      const target = chunk7PRMDZIA_cjs.edgeCardinalityClaimTarget(entry);
+      const target = chunkFMMW3KX7_cjs.edgeCardinalityClaimTarget(entry);
       return `${target.axis}\0${target.key}`;
     };
     const seen = /* @__PURE__ */ new Set();
@@ -2468,7 +4067,7 @@ function createCommonOperationBackend(options) {
       seen.add(key);
     }
     const outcomes = /* @__PURE__ */ new Map();
-    for (const chunk2 of chunkZBFZGLZE_cjs.chunk(entries, batchConfig.edgeInsertBatchSize)) {
+    for (const chunk2 of chunkNLX5OWK7_cjs.chunk(entries, batchConfig.edgeInsertBatchSize)) {
       const lockQuery = operationStrategy.buildLockEdgeClaims(chunk2, nowIso2());
       const rows = await execution.execAll(lockQuery);
       const holderByTarget = new Map(
@@ -2503,7 +4102,7 @@ function createCommonOperationBackend(options) {
   return {
     tableExists,
     async executeSchemaDdl(ddl) {
-      await execution.execRun(chunkOJHD3LXJ_cjs.asCompiledStatementSql(chunkOJHD3LXJ_cjs.sql.raw(ddl)));
+      await execution.execRun(chunkH5IJSROF_cjs.asCompiledStatementSql(chunkH5IJSROF_cjs.sql.raw(ddl)));
     },
     async executeStatement(query) {
       await execution.execRun(query);
@@ -2512,8 +4111,8 @@ function createCommonOperationBackend(options) {
       await execution.execRun(query);
     },
     async insertNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertNode(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertNode(params, timestamp2);
       const row = await withDuplicateKeyClassification(
         () => execution.execGet(query),
         {
@@ -2534,10 +4133,10 @@ function createCommonOperationBackend(options) {
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertNodeNoReturn(
         params,
-        timestamp
+        timestamp2
       );
       await withDuplicateKeyClassification(() => execution.execRun(query), {
         entity: "node",
@@ -2549,9 +4148,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp = nowIso2();
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
+      const timestamp2 = nowIso2();
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "node",
           relation: operationStrategy.primaryKeyConstraints.nodes,
@@ -2563,12 +4162,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatchReturning(
           chunk2,
-          timestamp
+          timestamp2
         );
         const rows = await withDuplicateKeyClassification(
           () => execution.execAll(query),
@@ -2590,7 +4189,7 @@ function createCommonOperationBackend(options) {
     async getNodes(graphId, kind, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
         const query = operationStrategy.buildGetNodes(graphId, kind, chunk2);
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
@@ -2598,8 +4197,8 @@ function createCommonOperationBackend(options) {
       return allRows;
     },
     async updateNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
       if (!row)
         throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
@@ -2625,15 +4224,15 @@ function createCommonOperationBackend(options) {
           { operation: "updateNodeSet", kind: params.kind }
         );
       }
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateNodeSet(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateNodeSet(params, timestamp2);
       const rows = await execution.execAll(query);
       const updatedRows = rows.map((row) => rowMappers.toNodeRow(row));
       return { affectedCount: updatedRows.length, rows: updatedRows };
     },
     async deleteNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteNode(params, timestamp2);
       await execution.execRun(query);
     },
     // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
@@ -2670,8 +4269,8 @@ function createCommonOperationBackend(options) {
       await execution.execRun(query);
     },
     async insertEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await withDuplicateKeyClassification(
         () => execution.execGet(query),
         {
@@ -2692,10 +4291,10 @@ function createCommonOperationBackend(options) {
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdgeNoReturn(
         params,
-        timestamp
+        timestamp2
       );
       await withDuplicateKeyClassification(() => execution.execRun(query), {
         entity: "edge",
@@ -2707,9 +4306,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp = nowIso2();
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
+      const timestamp2 = nowIso2();
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "edge",
           relation: operationStrategy.primaryKeyConstraints.edges,
@@ -2721,12 +4320,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatchReturning(
           chunk2,
-          timestamp
+          timestamp2
         );
         const rows = await withDuplicateKeyClassification(
           () => execution.execAll(query),
@@ -2748,7 +4347,7 @@ function createCommonOperationBackend(options) {
     async getEdges(graphId, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
         const query = operationStrategy.buildGetEdges(graphId, chunk2);
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
@@ -2756,8 +4355,8 @@ function createCommonOperationBackend(options) {
       return allRows;
     },
     async updateEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateEdge(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
       if (!row)
         throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
@@ -2771,8 +4370,8 @@ function createCommonOperationBackend(options) {
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteEdge(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteEdge(params, timestamp2);
       await execution.execRun(query);
     },
     async hardDeleteEdge(params) {
@@ -2781,22 +4380,22 @@ function createCommonOperationBackend(options) {
     },
     async deleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const softDeleteChunkSize = Math.max(
         1,
         batchConfig.getEdgesChunkSize - 1
       );
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params.ids, softDeleteChunkSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
-          timestamp
+          timestamp2
         );
         await execution.execRun(query);
       }
     },
     async hardDeleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(
         params.ids,
         batchConfig.getEdgesChunkSize
       )) {
@@ -2840,7 +4439,7 @@ function createCommonOperationBackend(options) {
     async findEdgesByEndpointSet(params) {
       const ids = resolveEdgeEndpointIds(params);
       const edgeRows = [];
-      for (const idChunk of chunkZBFZGLZE_cjs.chunk(
+      for (const idChunk of chunkNLX5OWK7_cjs.chunk(
         ids,
         batchConfig.findEdgesEndpointChunkSize
       )) {
@@ -2857,7 +4456,7 @@ function createCommonOperationBackend(options) {
       const { edgeKinds, endpoints, endpointChunkSize } = resolveHeterogeneousEdgeRead(params, maxBindParameters);
       if (edgeKinds.length === 0 || endpoints.length === 0) return [];
       const edgeRows = [];
-      for (const endpointChunk of chunkZBFZGLZE_cjs.chunk(endpoints, endpointChunkSize)) {
+      for (const endpointChunk of chunkNLX5OWK7_cjs.chunk(endpoints, endpointChunkSize)) {
         const query = operationStrategy.buildFindEdgesByHeterogeneousEndpointSet(
           params,
           endpointChunk,
@@ -2876,7 +4475,7 @@ function createCommonOperationBackend(options) {
     async insertUnique(params) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
-      if (result && !chunkLLVOQOWE_cjs.isSameClaimOwner(
+      if (result && !chunkCRZ56SZU_cjs.isSameClaimOwner(
         { concreteKind: result.concrete_kind, nodeId: result.node_id },
         claimOwnerOf(params)
       )) {
@@ -2906,7 +4505,7 @@ function createCommonOperationBackend(options) {
           byTarget.set(targetKey(entry), entry);
           continue;
         }
-        if (!chunkLLVOQOWE_cjs.isSameClaimOwner(claimOwnerOf(existing), claimOwnerOf(entry))) {
+        if (!chunkCRZ56SZU_cjs.isSameClaimOwner(claimOwnerOf(existing), claimOwnerOf(entry))) {
           throw new chunkX4GDXBOP_cjs.UniquenessError({
             constraintName: entry.constraintName,
             kind: existing.concreteKind,
@@ -2918,7 +4517,7 @@ function createCommonOperationBackend(options) {
         }
       }
       const deduped = [...byTarget.values()];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(
         deduped,
         batchConfig.uniqueInsertBatchSize
       )) {
@@ -2932,7 +4531,7 @@ function createCommonOperationBackend(options) {
         );
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
-          if (owner !== void 0 && !chunkLLVOQOWE_cjs.isSameClaimOwner(owner, claimOwnerOf(entry))) {
+          if (owner !== void 0 && !chunkCRZ56SZU_cjs.isSameClaimOwner(owner, claimOwnerOf(entry))) {
             throw new chunkX4GDXBOP_cjs.UniquenessError({
               constraintName: entry.constraintName,
               kind: owner.concreteKind,
@@ -2946,13 +4545,13 @@ function createCommonOperationBackend(options) {
       }
     },
     async deleteUnique(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteUnique(params, timestamp);
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteUnique(params, timestamp2);
       await execution.execRun(query);
     },
     async hardDeleteUniquesByNodeIds(params) {
       const nodeIds = [...new Set(params.nodeIds)];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(
         nodeIds,
         batchConfig.uniqueDeleteChunkSize
       )) {
@@ -2976,7 +4575,7 @@ function createCommonOperationBackend(options) {
     },
     async purgeEdgeClaims(params) {
       const edgeIds = [...new Set(params.edgeIds)];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(edgeIds, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(edgeIds, batchConfig.getEdgesChunkSize)) {
         const query = operationStrategy.buildPurgeEdgeClaims({
           ...params,
           edgeIds: chunk2
@@ -3043,7 +4642,7 @@ function createCommonOperationBackend(options) {
     async checkUniqueBatch(params) {
       if (params.keys.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
+      for (const chunk2 of chunkNLX5OWK7_cjs.chunk(
         params.keys,
         batchConfig.checkUniqueBatchChunkSize
       )) {
@@ -3109,7 +4708,7 @@ function createCommonOperationBackend(options) {
         );
         await execution.execRun(flip.deactivateAll);
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const insertQuery = operationStrategy.buildInsertSchema(
         {
           graphId: params.graphId,
@@ -3118,7 +4717,7 @@ function createCommonOperationBackend(options) {
           schemaDoc: params.schemaDoc,
           isActive: true
         },
-        timestamp
+        timestamp2
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
@@ -3216,8 +4815,8 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
 async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-      chunkOJHD3LXJ_cjs.sql.raw(
+    chunkH5IJSROF_cjs.asCompiledStatementSql(
+      chunkH5IJSROF_cjs.sql.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -3237,8 +4836,8 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-        chunkOJHD3LXJ_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkH5IJSROF_cjs.asCompiledStatementSql(
+        chunkH5IJSROF_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -3268,8 +4867,8 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-        chunkOJHD3LXJ_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkH5IJSROF_cjs.asCompiledStatementSql(
+        chunkH5IJSROF_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -3279,20 +4878,20 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      chunkOJHD3LXJ_cjs.asCompiledStatementSql(chunkOJHD3LXJ_cjs.sql.raw(definition.index_definition))
+      chunkH5IJSROF_cjs.asCompiledStatementSql(chunkH5IJSROF_cjs.sql.raw(definition.index_definition))
     );
   }
 }
 async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-      chunkOJHD3LXJ_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    chunkH5IJSROF_cjs.asCompiledStatementSql(
+      chunkH5IJSROF_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
-    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
-      chunkOJHD3LXJ_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    chunkH5IJSROF_cjs.asCompiledStatementSql(
+      chunkH5IJSROF_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
@@ -3318,7 +4917,7 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
   return {
     async insertNodes(params) {
       if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
       await executePreparedRunBatch(
         nodeSql,
         params.map((item) => [
@@ -3326,16 +4925,16 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.kind,
           item.id,
           JSON.stringify(item.props),
-          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL,
           item.validTo ?? DATABASE_NULL,
-          timestamp,
-          timestamp
+          timestamp2,
+          timestamp2
         ])
       );
     },
     async insertEdges(params) {
       if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
       await executePreparedRunBatch(
         edgeSql,
         params.map((item) => [
@@ -3347,10 +4946,10 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.toKind,
           item.toId,
           JSON.stringify(item.props),
-          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL,
           item.validTo ?? DATABASE_NULL,
-          timestamp,
-          timestamp
+          timestamp2,
+          timestamp2
         ])
       );
     }
@@ -3380,7 +4979,7 @@ function createPostgresTrustedImportSession(backend, tableNames) {
   return {
     async insertNodes(params) {
       if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
       await executeRaw(nodeSql, [
         postgresArray(params.map((item) => item.graphId)),
         postgresArray(params.map((item) => item.kind)),
@@ -3388,16 +4987,16 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL
           )
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp))
+        postgresArray(params.map(() => timestamp2))
       ]);
     },
     async insertEdges(params) {
       if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
       await executeRaw(edgeSql, [
         postgresArray(params.map((item) => item.graphId)),
         postgresArray(params.map((item) => item.id)),
@@ -3409,11 +5008,11 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL
           )
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp))
+        postgresArray(params.map(() => timestamp2))
       ]);
     }
   };
@@ -3447,6 +5046,7 @@ exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
 exports.analyzeImportedTables = analyzeImportedTables;
 exports.assertActiveSchemaVersion = assertActiveSchemaVersion;
 exports.assertAdoptedDialect = assertAdoptedDialect;
+exports.assertBundledCapabilityDeclarations = assertBundledCapabilityDeclarations;
 exports.assertTrustedImportDatabaseEmpty = assertTrustedImportDatabaseEmpty;
 exports.buildContributionInsertValues = buildContributionInsertValues;
 exports.buildContributionOnConflictSet = buildContributionOnConflictSet;
@@ -3461,11 +5061,24 @@ exports.createCachedTableExistence = createCachedTableExistence;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
+exports.createPostgresTables = createPostgresTables;
 exports.createPostgresTrustedImportSession = createPostgresTrustedImportSession;
 exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
+exports.createSqliteTables = createSqliteTables;
 exports.createSqliteTrustedImportSession = createSqliteTrustedImportSession;
+exports.edgeClaims = edgeClaims;
+exports.edgeClaims2 = edgeClaims2;
+exports.edges = edges;
+exports.edges2 = edges2;
+exports.fulltext = fulltext;
 exports.gateFulltext = gateFulltext;
 exports.gateFulltextMethods = gateFulltextMethods;
+exports.generatePgCreateTableSQL = generatePgCreateTableSQL;
+exports.generatePostgresDDL = generatePostgresDDL;
+exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
+exports.generateSqliteCreateTableSQL = generateSqliteCreateTableSQL;
+exports.generateSqliteDDL = generateSqliteDDL;
+exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
 exports.getOrCreateLru = getOrCreateLru;
 exports.lockPostgresTrustedImportTables = lockPostgresTrustedImportTables;
 exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
@@ -3473,12 +5086,28 @@ exports.mapHybridSearchRow = mapHybridSearchRow;
 exports.mapKindRemovalRow = mapKindRemovalRow;
 exports.mapMaterializationRow = mapMaterializationRow;
 exports.mapVectorWriteError = mapVectorWriteError;
+exports.nodes = nodes;
+exports.nodes2 = nodes2;
+exports.postgresContributions = postgresContributions;
+exports.recordedClock = recordedClock;
+exports.recordedClock2 = recordedClock2;
+exports.recordedEdges = recordedEdges;
+exports.recordedEdges2 = recordedEdges2;
+exports.recordedNodes = recordedNodes;
+exports.recordedNodes2 = recordedNodes2;
 exports.restoreSecondaryIndexes = restoreSecondaryIndexes;
+exports.schemaVersions = schemaVersions;
+exports.schemaVersions2 = schemaVersions2;
+exports.sqliteContributions = sqliteContributions;
 exports.suspendPostgresSecondaryIndexes = suspendPostgresSecondaryIndexes;
 exports.suspendSqliteSecondaryIndexes = suspendSqliteSecondaryIndexes;
 exports.tableExistsFromRow = tableExistsFromRow;
+exports.tables = tables;
+exports.tables2 = tables2;
+exports.uniques = uniques;
+exports.uniques2 = uniques2;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-XMY2SXOH.cjs.map
-//# sourceMappingURL=chunk-XMY2SXOH.cjs.map
+//# sourceMappingURL=chunk-5WWEYV4H.cjs.map
+//# sourceMappingURL=chunk-5WWEYV4H.cjs.map