@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/{chunk-Z2JCLZFJ.js → chunk-UKOVGCRN.js}

@@ -1,15 +1,1211 @@
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-YIURNGXI.js';
-import { runtimeStrategyContributions } from './chunk-6SWPJEYN.js';
-import { toDrizzleSql } from './chunk-OMZ37BM2.js';
-import { sortedReplacer } from './chunk-JBQQ7THH.js';
-import { parseDimensionMismatch, deriveBackend, chunk, isMissingTableError, isDuplicatePrimaryKeyError, errorChain } from './chunk-UGHG7PGX.js';
-import { resolveStampedValidityLowerBound, resolveStatedValidityLowerBound } from './chunk-5K2BKEBD.js';
+import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteSystemIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders, toDrizzleSql } from './chunk-PVFFH7TL.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso, buildHardDeleteUniquesByConcreteKind } from './chunk-VUQZNUHU.js';
+import { edgeCardinalityClaimTarget, EDGE_CARDINALITY_SPECS } from './chunk-NGQDGL5X.js';
+import { parseDimensionMismatch, deriveBackend, chunk, isMissingTableError, isDuplicatePrimaryKeyError, errorChain, sortedReplacer } from './chunk-QG5VEOKX.js';
+import { resolveWriteFencePlan, requireWriteFence } from './chunk-LKZDQ2B4.js';
+import { isSameClaimOwner, claimOwnerMatchesSql } from './chunk-RVUL2HXY.js';
+import { resolveStampedValidityLowerBound, resolveStatedValidityLowerBound } from './chunk-K46SDNQD.js';
+import { assertNoSystemIndexNameCollision } from './chunk-36VYWVQU.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-ZDKTPBGV.js';
-import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-3DMMGT6S.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionUnavailableError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-ZLONH2UD.js';
+import { getDialect } from './chunk-7G5IYROL.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER, buildFulltextGraphDelete, buildForeignFulltextGraphProbe } from './chunk-PC5NGH5A.js';
+import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-7QFRK6PU.js';
+import { ConfigurationError, EmbeddingDimensionChangedError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionUnavailableError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-YDEJQWOL.js';
 import { isPresent } from './chunk-DYATYRY4.js';
 import { sql, is, getTableName } from 'drizzle-orm';
+import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, bigint, index, uniqueIndex, check, boolean, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
+import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, uniqueIndex as uniqueIndex$1, check as check$1, getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+
+var regconfig = customType({
+  dataType: () => "regconfig"
+});
+var tsvector = 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 ?? [];
+  assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = pgTable(
+    n.nodes,
+    {
+      graphId: text("graph_id").notNull(),
+      kind: text("kind").notNull(),
+      id: text("id").notNull(),
+      props: jsonb("props").notNull(),
+      version: integer("version").notNull().default(1),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
+      ...buildPostgresNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = pgTable(
+    n.edges,
+    {
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      kind: text("kind").notNull(),
+      fromKind: text("from_kind").notNull(),
+      fromId: text("from_id").notNull(),
+      toKind: text("to_kind").notNull(),
+      toId: text("to_id").notNull(),
+      props: jsonb("props").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.id] }),
+      ...buildPostgresSystemIndexBuilders("edges", n.edges, t),
+      ...buildPostgresEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = pgTable(
+    n.recordedNodes,
+    {
+      historyId: text("history_id").notNull(),
+      graphId: text("graph_id").notNull(),
+      kind: text("kind").notNull(),
+      id: text("id").notNull(),
+      props: jsonb("props").notNull(),
+      version: integer("version").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
+      op: text("op").notNull(),
+      schemaVersion: integer("schema_version"),
+      txId: text("tx_id"),
+      meta: jsonb("meta")
+    },
+    (t) => [
+      primaryKey({ columns: [t.historyId] }),
+      ...buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = pgTable(
+    n.recordedEdges,
+    {
+      historyId: text("history_id").notNull(),
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      kind: text("kind").notNull(),
+      fromKind: text("from_kind").notNull(),
+      fromId: text("from_id").notNull(),
+      toKind: text("to_kind").notNull(),
+      toId: text("to_id").notNull(),
+      props: jsonb("props").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
+      op: text("op").notNull(),
+      schemaVersion: integer("schema_version"),
+      txId: text("tx_id"),
+      meta: jsonb("meta")
+    },
+    (t) => [
+      primaryKey({ columns: [t.historyId] }),
+      ...buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = pgTable(
+    n.recordedClock,
+    {
+      graphId: text("graph_id").notNull(),
+      revision: bigint("revision", { mode: "number" }).notNull(),
+      recordedAt: timestamp("recorded_at", { withTimezone: true }).notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = pgTable(
+    n.revisionOrigins,
+    {
+      graphId: text("graph_id").notNull(),
+      origin: text("origin").notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
+  const identityAssertions = pgTable(
+    n.identityAssertions,
+    {
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      relation: text("rel").notNull(),
+      aKind: text("a_kind").notNull(),
+      aId: text("a_id").notNull(),
+      bKind: text("b_kind").notNull(),
+      bId: text("b_id").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }).notNull(),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      endedByKind: text("ended_by_kind"),
+      endedById: text("ended_by_id")
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.id] }),
+      index(`${n.identityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.validTo
+      ),
+      index(`${n.identityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.validTo
+      ),
+      uniqueIndex(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(sql`${t.validTo} IS NULL`),
+      check(
+        `${n.identityAssertions}_ended_by_check`,
+        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 = pgTable(
+    n.recordedIdentityAssertions,
+    {
+      historyId: text("history_id").notNull(),
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      relation: text("rel").notNull(),
+      aKind: text("a_kind").notNull(),
+      aId: text("a_id").notNull(),
+      bKind: text("b_kind").notNull(),
+      bId: text("b_id").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }).notNull(),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      endedByKind: text("ended_by_kind"),
+      endedById: text("ended_by_id"),
+      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
+      op: text("op").notNull(),
+      schemaVersion: integer("schema_version"),
+      txId: text("tx_id"),
+      meta: jsonb("meta")
+    },
+    (t) => [
+      primaryKey({ columns: [t.historyId] }),
+      index(`${n.recordedIdentityAssertions}_entity_idx`).on(
+        t.graphId,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedIdentityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedIdentityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.recordedFrom,
+        t.recordedTo
+      )
+    ]
+  );
+  const identityClosure = pgTable(
+    n.identityClosure,
+    {
+      graphId: text("graph_id").notNull(),
+      memberKind: text("member_kind").notNull(),
+      memberId: text("member_id").notNull(),
+      classKind: text("class_kind").notNull(),
+      classId: text("class_id").notNull()
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.memberKind, t.memberId] }),
+      index(`${n.identityClosure}_class_idx`).on(
+        t.graphId,
+        t.classKind,
+        t.classId
+      )
+    ]
+  );
+  const identitySeparation = pgTable(
+    n.identitySeparation,
+    {
+      graphId: text("graph_id").notNull(),
+      classKeyLow: text("class_key_low").notNull(),
+      classKeyHigh: text("class_key_high").notNull()
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
+      index(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
+      check(
+        `${n.identitySeparation}_ordered_pair_check`,
+        sql`class_key_low COLLATE "C" < class_key_high COLLATE "C"`
+      )
+    ]
+  );
+  const uniques3 = pgTable(
+    n.uniques,
+    {
+      graphId: text("graph_id").notNull(),
+      nodeKind: text("node_kind").notNull(),
+      constraintName: text("constraint_name").notNull(),
+      key: text("key").notNull(),
+      nodeId: text("node_id").notNull(),
+      concreteKind: text("concrete_kind").notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const edgeClaims3 = pgTable(
+    n.edgeClaims,
+    {
+      graphId: text("graph_id").notNull(),
+      axis: text("axis").notNull(),
+      key: text("key").notNull(),
+      edgeId: text("edge_id").notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.axis, t.key] }),
+      index(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
+    ]
+  );
+  const schemaVersions3 = pgTable(
+    n.schemaVersions,
+    {
+      graphId: text("graph_id").notNull(),
+      version: integer("version").notNull(),
+      schemaHash: text("schema_hash").notNull(),
+      schemaDoc: jsonb("schema_doc").notNull(),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      isActive: boolean("is_active").notNull().default(false)
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.version] }),
+      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`.
+      uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = TRUE`)
+    ]
+  );
+  const indexMaterializations = pgTable(
+    n.indexMaterializations,
+    {
+      indexName: text("index_name").notNull(),
+      graphId: text("graph_id").notNull(),
+      entity: text("entity").notNull(),
+      kind: text("kind").notNull(),
+      signature: text("signature").notNull(),
+      schemaVersion: integer("schema_version").notNull(),
+      materializedAt: timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: 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: timestamp("building_since", { withTimezone: true }),
+      claimToken: text("claim_token")
+    },
+    (t) => [primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = pgTable(
+    n.kindRemovals,
+    {
+      graphId: text("graph_id").notNull(),
+      kindName: text("kind_name").notNull(),
+      entity: text("entity").notNull(),
+      schemaVersion: integer("schema_version").notNull(),
+      removedAt: timestamp("removed_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: text("last_error")
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = pgTable(
+    n.reconciliationMarkers,
+    {
+      graphId: text("graph_id").notNull(),
+      reconciledToVersion: integer("reconciled_to_version").notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = pgTable(
+    n.contributionMaterializations,
+    {
+      graphId: text("graph_id").notNull(),
+      logicalName: text("logical_name").notNull(),
+      owner: text("owner").notNull(),
+      tableName: text("table_name").notNull(),
+      signature: text("signature").notNull(),
+      materializedAt: timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: text("last_error")
+    },
+    (t) => [
+      primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  const fulltext2 = pgTable(
+    n.fulltext,
+    {
+      graphId: text("graph_id").notNull(),
+      nodeKind: text("node_kind").notNull(),
+      nodeId: text("node_id").notNull(),
+      content: text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      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 ?? [];
+  assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = sqliteTable(
+    n.nodes,
+    {
+      graphId: text$1("graph_id").notNull(),
+      kind: text$1("kind").notNull(),
+      id: text$1("id").notNull(),
+      props: text$1("props").notNull(),
+      version: integer$1("version").notNull().default(1),
+      validFrom: text$1("valid_from"),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...buildSqliteSystemIndexBuilders("nodes", n.nodes, t),
+      ...buildSqliteNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = sqliteTable(
+    n.edges,
+    {
+      graphId: text$1("graph_id").notNull(),
+      id: text$1("id").notNull(),
+      kind: text$1("kind").notNull(),
+      fromKind: text$1("from_kind").notNull(),
+      fromId: text$1("from_id").notNull(),
+      toKind: text$1("to_kind").notNull(),
+      toId: text$1("to_id").notNull(),
+      props: text$1("props").notNull(),
+      validFrom: text$1("valid_from"),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.id] }),
+      ...buildSqliteSystemIndexBuilders("edges", n.edges, t),
+      ...buildSqliteEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = sqliteTable(
+    n.recordedNodes,
+    {
+      historyId: text$1("history_id").notNull(),
+      graphId: text$1("graph_id").notNull(),
+      kind: text$1("kind").notNull(),
+      id: text$1("id").notNull(),
+      props: text$1("props").notNull(),
+      version: integer$1("version").notNull(),
+      validFrom: text$1("valid_from"),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at"),
+      recordedFrom: integer$1("recorded_from").notNull(),
+      recordedTo: integer$1("recorded_to").notNull(),
+      op: text$1("op").notNull(),
+      schemaVersion: integer$1("schema_version"),
+      txId: text$1("tx_id"),
+      meta: text$1("meta")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.historyId] }),
+      ...buildSqliteSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = sqliteTable(
+    n.recordedEdges,
+    {
+      historyId: text$1("history_id").notNull(),
+      graphId: text$1("graph_id").notNull(),
+      id: text$1("id").notNull(),
+      kind: text$1("kind").notNull(),
+      fromKind: text$1("from_kind").notNull(),
+      fromId: text$1("from_id").notNull(),
+      toKind: text$1("to_kind").notNull(),
+      toId: text$1("to_id").notNull(),
+      props: text$1("props").notNull(),
+      validFrom: text$1("valid_from"),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at"),
+      recordedFrom: integer$1("recorded_from").notNull(),
+      recordedTo: integer$1("recorded_to").notNull(),
+      op: text$1("op").notNull(),
+      schemaVersion: integer$1("schema_version"),
+      txId: text$1("tx_id"),
+      meta: text$1("meta")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.historyId] }),
+      ...buildSqliteSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = sqliteTable(
+    n.recordedClock,
+    {
+      graphId: text$1("graph_id").notNull(),
+      revision: integer$1("revision").notNull(),
+      recordedAt: text$1("recorded_at").notNull()
+    },
+    (t) => [primaryKey$1({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = sqliteTable(
+    n.revisionOrigins,
+    {
+      graphId: text$1("graph_id").notNull(),
+      origin: text$1("origin").notNull()
+    },
+    (t) => [primaryKey$1({ columns: [t.graphId] })]
+  );
+  const identityAssertions = sqliteTable(
+    n.identityAssertions,
+    {
+      graphId: text$1("graph_id").notNull(),
+      id: text$1("id").notNull(),
+      relation: text$1("rel").notNull(),
+      aKind: text$1("a_kind").notNull(),
+      aId: text$1("a_id").notNull(),
+      bKind: text$1("b_kind").notNull(),
+      bId: text$1("b_id").notNull(),
+      validFrom: text$1("valid_from").notNull(),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at"),
+      endedByKind: text$1("ended_by_kind"),
+      endedById: text$1("ended_by_id")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.id] }),
+      index$1(`${n.identityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.validTo
+      ),
+      index$1(`${n.identityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.validTo
+      ),
+      uniqueIndex$1(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(sql`${t.validTo} IS NULL`),
+      check$1(
+        `${n.identityAssertions}_ended_by_check`,
+        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 = sqliteTable(
+    n.recordedIdentityAssertions,
+    {
+      historyId: text$1("history_id").notNull(),
+      graphId: text$1("graph_id").notNull(),
+      id: text$1("id").notNull(),
+      relation: text$1("rel").notNull(),
+      aKind: text$1("a_kind").notNull(),
+      aId: text$1("a_id").notNull(),
+      bKind: text$1("b_kind").notNull(),
+      bId: text$1("b_id").notNull(),
+      validFrom: text$1("valid_from").notNull(),
+      validTo: text$1("valid_to"),
+      createdAt: text$1("created_at").notNull(),
+      updatedAt: text$1("updated_at").notNull(),
+      deletedAt: text$1("deleted_at"),
+      endedByKind: text$1("ended_by_kind"),
+      endedById: text$1("ended_by_id"),
+      recordedFrom: integer$1("recorded_from").notNull(),
+      recordedTo: integer$1("recorded_to").notNull(),
+      op: text$1("op").notNull(),
+      schemaVersion: integer$1("schema_version"),
+      txId: text$1("tx_id"),
+      meta: text$1("meta")
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.historyId] }),
+      index$1(`${n.recordedIdentityAssertions}_entity_idx`).on(
+        t.graphId,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index$1(`${n.recordedIdentityAssertions}_a_idx`).on(
+        t.graphId,
+        t.aKind,
+        t.aId,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index$1(`${n.recordedIdentityAssertions}_b_idx`).on(
+        t.graphId,
+        t.bKind,
+        t.bId,
+        t.recordedFrom,
+        t.recordedTo
+      )
+    ]
+  );
+  const identityClosure = sqliteTable(
+    n.identityClosure,
+    {
+      graphId: text$1("graph_id").notNull(),
+      memberKind: text$1("member_kind").notNull(),
+      memberId: text$1("member_id").notNull(),
+      classKind: text$1("class_kind").notNull(),
+      classId: text$1("class_id").notNull()
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.memberKind, t.memberId] }),
+      index$1(`${n.identityClosure}_class_idx`).on(
+        t.graphId,
+        t.classKind,
+        t.classId
+      )
+    ]
+  );
+  const identitySeparation = sqliteTable(
+    n.identitySeparation,
+    {
+      graphId: text$1("graph_id").notNull(),
+      classKeyLow: text$1("class_key_low").notNull(),
+      classKeyHigh: text$1("class_key_high").notNull()
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
+      index$1(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
+      check$1(
+        `${n.identitySeparation}_ordered_pair_check`,
+        sql`class_key_low < class_key_high`
+      )
+    ]
+  );
+  const uniques3 = sqliteTable(
+    n.uniques,
+    {
+      graphId: text$1("graph_id").notNull(),
+      nodeKind: text$1("node_kind").notNull(),
+      constraintName: text$1("constraint_name").notNull(),
+      key: text$1("key").notNull(),
+      nodeId: text$1("node_id").notNull(),
+      concreteKind: text$1("concrete_kind").notNull(),
+      deletedAt: text$1("deleted_at")
+    },
+    (t) => [
+      primaryKey$1({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      index$1(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const edgeClaims3 = sqliteTable(
+    n.edgeClaims,
+    {
+      graphId: text$1("graph_id").notNull(),
+      axis: text$1("axis").notNull(),
+      key: text$1("key").notNull(),
+      edgeId: text$1("edge_id").notNull(),
+      updatedAt: text$1("updated_at").notNull()
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.axis, t.key] }),
+      index$1(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
+    ]
+  );
+  const schemaVersions3 = sqliteTable(
+    n.schemaVersions,
+    {
+      graphId: text$1("graph_id").notNull(),
+      version: integer$1("version").notNull(),
+      schemaHash: text$1("schema_hash").notNull(),
+      schemaDoc: text$1("schema_doc").notNull(),
+      createdAt: text$1("created_at").notNull(),
+      isActive: integer$1("is_active", { mode: "boolean" }).notNull().default(false)
+    },
+    (t) => [
+      primaryKey$1({ columns: [t.graphId, t.version] }),
+      index$1(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      uniqueIndex$1(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = 1`)
+    ]
+  );
+  const indexMaterializations = sqliteTable(
+    n.indexMaterializations,
+    {
+      indexName: text$1("index_name").notNull(),
+      graphId: text$1("graph_id").notNull(),
+      entity: text$1("entity").notNull(),
+      kind: text$1("kind").notNull(),
+      signature: text$1("signature").notNull(),
+      schemaVersion: integer$1("schema_version").notNull(),
+      materializedAt: text$1("materialized_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [primaryKey$1({ columns: [t.indexName] })]
+  );
+  const kindRemovals = sqliteTable(
+    n.kindRemovals,
+    {
+      graphId: text$1("graph_id").notNull(),
+      kindName: text$1("kind_name").notNull(),
+      entity: text$1("entity").notNull(),
+      schemaVersion: integer$1("schema_version").notNull(),
+      removedAt: text$1("removed_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [
+      primaryKey$1({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = sqliteTable(
+    n.reconciliationMarkers,
+    {
+      graphId: text$1("graph_id").notNull(),
+      reconciledToVersion: integer$1("reconciled_to_version").notNull()
+    },
+    (t) => [primaryKey$1({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = sqliteTable(
+    n.contributionMaterializations,
+    {
+      graphId: text$1("graph_id").notNull(),
+      logicalName: text$1("logical_name").notNull(),
+      owner: text$1("owner").notNull(),
+      tableName: text$1("table_name").notNull(),
+      signature: text$1("signature").notNull(),
+      materializedAt: text$1("materialized_at"),
+      lastAttemptedAt: text$1("last_attempted_at").notNull(),
+      lastError: text$1("last_error")
+    },
+    (t) => [
+      primaryKey$1({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    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 = 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 = 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 is(value, SQLiteTable);
+}
+function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
+  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
+}
+function sqliteContributions(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
+    if (!isSqliteTable(table)) continue;
+    contributions.push({
+      logicalName: key,
+      owner: BASE_CONTRIBUTION_OWNER,
+      tableName: 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 = fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = 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 = getTableConfig$1(table);
+  const columnDefs = [];
+  for (const column of config.columns) {
+    const parts = [`"${column.name}"`, getPgColumnType(column)];
+    if (column.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (column.hasDefault && column.default !== void 0) {
+      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  const pk = config.primaryKeys[0];
+  if (pk) {
+    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
+  }
+  columnDefs.push(...renderTableChecks(config.checks, config.name));
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function generatePgCreateIndexSQL(table) {
+  const config = getTableConfig$1(table);
+  const statements = [];
+  for (const index3 of config.indexes) {
+    const indexConfig = index3.config;
+    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
+    const unique = indexConfig.unique ? "UNIQUE " : "";
+    const method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
+    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `PostgreSQL index "${indexConfig.name}" WHERE clause`)}` : "";
+    statements.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}"${method} (${columns})${where};`
+    );
+  }
+  return statements;
+}
+function isPgTable(value) {
+  return is(value, PgTable);
+}
+function postgresContributions(tables3 = tables, fulltextStrategy = 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: BASE_CONTRIBUTION_OWNER,
+      tableName: getTableConfig$1(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 = tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
+  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
+  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
+  return `${extensionSql}
+
+${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 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 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;
@@ -78,10 +1274,10 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = sql$1.identifier(nodesTableName);
+  const nodes3 = sql$1.identifier(nodesTableName);
   return sql$1`
     SELECT "id" AS node_id
-    FROM ${nodes}
+    FROM ${nodes3}
     WHERE "graph_id" = ${graphId}
       AND "kind" = ${nodeKind}
       AND "deleted_at" IS NULL
@@ -384,7 +1580,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;
     }
@@ -752,20 +1948,42 @@ function createContributionMaterializer(deps) {
     };
   }
   async function lockContributionDdl(tx) {
-    if (dialect !== "postgres") return;
-    await tx.execute(
-      asCompiledRowsSql(
-        sql$1`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
-      )
-    );
+    const plan = resolveWriteFencePlan(deps.fenceTarget);
+    const fence = requireWriteFence(plan, "contribution DDL", "advisory-lock");
+    switch (fence.kind) {
+      case "lock": {
+        await tx.execute(
+          asCompiledRowsSql(
+            sql$1`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(
-      asCompiledStatementSql(
-        sql$1`LOCK TABLE ${sql$1.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
-      )
+    const plan = resolveWriteFencePlan(deps.fenceTarget);
+    const fence = requireWriteFence(
+      plan,
+      "shared fulltext table lock",
+      "table-lock"
     );
+    switch (fence.kind) {
+      case "lock": {
+        await tx.executeStatement(
+          asCompiledStatementSql(
+            sql$1`LOCK TABLE ${sql$1.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
+          )
+        );
+        return;
+      }
+      case "engine-serialized": {
+        return;
+      }
+    }
   }
   async function readForeignGraphIds(tx, tableName, graphId) {
     const rows = await tx.execute(
@@ -1043,24 +2261,24 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
 function primaryKeyConstraintNames(relation, keyColumns) {
   return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
 }
-function nodePrimaryKeyConstraint(nodes) {
-  const relation = getTableName(nodes);
+function nodePrimaryKeyConstraint(nodes3) {
+  const relation = getTableName(nodes3);
   return {
     table: relation,
     constraintNames: primaryKeyConstraintNames(relation, [
-      nodes.graphId.name,
-      nodes.kind.name,
-      nodes.id.name
+      nodes3.graphId.name,
+      nodes3.kind.name,
+      nodes3.id.name
     ])
   };
 }
-function edgePrimaryKeyConstraint(edges) {
-  const relation = getTableName(edges);
+function edgePrimaryKeyConstraint(edges3) {
+  const relation = getTableName(edges3);
   return {
     table: relation,
     constraintNames: primaryKeyConstraintNames(relation, [
-      edges.graphId.name,
-      edges.id.name
+      edges3.graphId.name,
+      edges3.id.name
     ])
   };
 }
@@ -1085,17 +2303,17 @@ var CODE_POINT_ORDER_BUILDERS = {
 function codePointOrderKey(column, dialect) {
   return CODE_POINT_ORDER_BUILDERS[dialect](column);
 }
-function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso2) {
-  return sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso2}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso2})`;
+function liveNodeIdsSubquery(nodes3, graphId, nodeKind, nowIso2) {
+  return 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(nodes) {
+function nodeColumnList(nodes3) {
   return sql.raw(
-    `"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`
+    `"${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(edges) {
+function edgeColumnList(edges3) {
   return sql.raw(
-    `"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`
+    `"${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}"`
   );
 }
 
@@ -1107,20 +2325,20 @@ function hybridCandidatesRef() {
   return 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 ? sql`score DESC, ${nodeIdOrder} ASC` : 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 = sql.raw(
     columnPairs.map(
@@ -1173,17 +2391,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 sql`tg_hybrid_node.${quotedColumn(nodes[member])}`;
+function qualified(nodes3, member) {
+  return sql`tg_hybrid_node.${quotedColumn(nodes3[member])}`;
 }
 function present(value) {
   return value !== null && value !== void 0;
@@ -1203,67 +2421,78 @@ function mapHybridSearchRow(row, toNodeRow) {
     ...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: buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
+    { query: buildFulltextGraphDelete(tables3.fulltextTableName, graphId) },
     {
-      query: sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.recordedIdentityAssertions} WHERE ${tables3.recordedIdentityAssertions.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.recordedIdentityAssertions)
+      requiredTableName: getTableName(tables3.recordedIdentityAssertions)
     },
     {
-      query: sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.recordedEdges)
+      requiredTableName: getTableName(tables3.recordedEdges)
     },
     {
-      query: sql`DELETE FROM ${tables.recordedNodes} WHERE ${tables.recordedNodes.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.recordedNodes)
+      requiredTableName: getTableName(tables3.recordedNodes)
     },
     {
-      query: sql`DELETE FROM ${tables.recordedClock} WHERE ${tables.recordedClock.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.recordedClock)
+      requiredTableName: getTableName(tables3.recordedClock)
     },
     {
-      query: sql`DELETE FROM ${tables.identitySeparation} WHERE ${tables.identitySeparation.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.identitySeparation} WHERE ${tables3.identitySeparation.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.identitySeparation)
+      requiredTableName: getTableName(tables3.identitySeparation)
     },
     {
-      query: sql`DELETE FROM ${tables.identityClosure} WHERE ${tables.identityClosure.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.identityClosure} WHERE ${tables3.identityClosure.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.identityClosure)
+      requiredTableName: getTableName(tables3.identityClosure)
     },
     {
-      query: sql`DELETE FROM ${tables.identityAssertions} WHERE ${tables.identityAssertions.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables3.identityAssertions} WHERE ${tables3.identityAssertions.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables.identityAssertions)
+      requiredTableName: getTableName(tables3.identityAssertions)
     },
     {
-      query: sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
+      query: 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`.
+    // Tolerates absence for the reason the recorded relations do: bootstrap DDL
+    // runs only on first boot, so a database initialized before this relation
+    // existed has no such table, and clearing a graph must not become the
+    // operation that fails on it.
+    {
+      query: sql`DELETE FROM ${tables3.edgeClaims} WHERE ${tables3.edgeClaims.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables3.edgeClaims)
     },
     {
-      query: sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables.indexMaterializations} WHERE ${tables.indexMaterializations.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables.kindRemovals} WHERE ${tables.kindRemovals.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables.reconciliationMarkers} WHERE ${tables.reconciliationMarkers.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
     }
   ];
 }
@@ -1285,21 +2514,21 @@ function buildTemporalConditions(table, params) {
   }
   return conditions;
 }
-function buildFindNodesByKind(tables, params) {
-  const { nodes } = tables;
+function buildFindNodesByKind(tables3, params) {
+  const { nodes: nodes3 } = tables3;
   const conditions = [
-    sql`${nodes.graphId} = ${params.graphId}`,
-    sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
+    sql`${nodes3.graphId} = ${params.graphId}`,
+    sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(sql`${nodes.id} > ${params.after}`);
+    conditions.push(sql`${nodes3.id} > ${params.after}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
-  const orderByClause = params.orderBy === "id" ? sql`${nodes.id} ASC` : sql`${nodes.createdAt} DESC, ${nodes.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? sql`${nodes3.id} ASC` : sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
-      SELECT * FROM ${nodes}
+      SELECT * FROM ${nodes3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1307,28 +2536,28 @@ function buildFindNodesByKind(tables, params) {
   }
   if (params.limit !== void 0) {
     return sql`
-      SELECT * FROM ${nodes}
+      SELECT * FROM ${nodes3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return 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 = [
-    sql`${nodes.graphId} = ${params.graphId}`,
-    sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
+    sql`${nodes3.graphId} = ${params.graphId}`,
+    sql`${nodes3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes3, params)
   ];
   const whereClause = sql.join(conditions, sql` AND `);
   return sql`
-    SELECT COUNT(*) as count FROM ${nodes}
+    SELECT COUNT(*) as count FROM ${nodes3}
     WHERE ${whereClause}
   `;
 }
@@ -1338,43 +2567,43 @@ function buildIdSetCondition(column, ids) {
     sql`, `
   )})`;
 }
-function buildEdgeOrdering(tables, orderBy) {
-  const { edges } = tables;
-  return orderBy === "id" ? { qualified: sql`${edges.id} ASC`, bare: sql.raw(`"id" ASC`) } : {
-    qualified: sql`${edges.createdAt} DESC, ${edges.id} DESC`,
+function buildEdgeOrdering(tables3, orderBy) {
+  const { edges: edges3 } = tables3;
+  return orderBy === "id" ? { qualified: sql`${edges3.id} ASC`, bare: sql.raw(`"id" ASC`) } : {
+    qualified: sql`${edges3.createdAt} DESC, ${edges3.id} DESC`,
     bare: sql.raw(`"created_at" DESC, "id" DESC`)
   };
 }
-function buildFindEdgesByKind(tables, params) {
-  const { edges } = tables;
+function buildFindEdgesByKind(tables3, params) {
+  const { edges: edges3 } = tables3;
   const conditions = [
-    sql`${edges.graphId} = ${params.graphId}`,
-    sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
+    sql`${edges3.graphId} = ${params.graphId}`,
+    sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges.toId} = ${params.toId}`);
+    conditions.push(sql`${edges3.toId} = ${params.toId}`);
   }
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(sql`${edges.id} > ${params.after}`);
+    conditions.push(sql`${edges3.id} > ${params.after}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
   const { qualified: orderByClause } = buildEdgeOrdering(
-    tables,
+    tables3,
     params.orderBy
   );
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1382,37 +2611,37 @@ function buildFindEdgesByKind(tables, params) {
   }
   if (params.limit !== void 0) {
     return sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return 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 = sql.join(
     [
-      sql`${edges.graphId} = ${params.graphId}`,
-      sql`${edges.kind} = ${params.kind}`,
-      ...buildTemporalConditions(edges, params),
+      sql`${edges3.graphId} = ${params.graphId}`,
+      sql`${edges3.kind} = ${params.kind}`,
+      ...buildTemporalConditions(edges3, params),
       sql`${kindColumn} = ${params.endpointKind}`,
       buildIdSetCondition(idColumn, endpointIds)
     ],
     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 sql`
-      SELECT * FROM ${edges}
+      SELECT * FROM ${edges3}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
     `;
@@ -1421,7 +2650,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 sql`
@@ -1430,11 +2659,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 = sql.raw(`requested_endpoints."endpoint_kind"`);
   const requestedId = sql.raw(`requested_endpoints."endpoint_id"`);
   const requestedRows = sql.join(
@@ -1443,32 +2672,32 @@ function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edg
   );
   const whereClause = sql.join(
     [
-      sql`${edges.graphId} = ${params.graphId}`,
-      buildIdSetCondition(edges.kind, edgeKinds),
-      ...buildTemporalConditions(edges, params)
+      sql`${edges3.graphId} = ${params.graphId}`,
+      buildIdSetCondition(edges3.kind, edgeKinds),
+      ...buildTemporalConditions(edges3, params)
     ],
     sql` AND `
   );
   const joinClause = 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 sql`
       WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
         VALUES ${requestedRows}
       )
-      SELECT ${edges}.*
+      SELECT ${edges3}.*
       ${joinClause}
       ORDER BY ${orderByClause}
     `;
   }
   const ranked = sql`
-    SELECT ${edges}.*, ROW_NUMBER() OVER (
+    SELECT ${edges3}.*, ROW_NUMBER() OVER (
       PARTITION BY ${kindColumn}, ${idColumn} ORDER BY ${orderByClause}
     ) AS endpoint_rank
     ${joinClause}
@@ -1482,269 +2711,417 @@ 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 = [
-    sql`${edges.graphId} = ${params.graphId}`,
-    sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
+    sql`${edges3.graphId} = ${params.graphId}`,
+    sql`${edges3.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges3, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges3.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges3.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges3.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges.toId} = ${params.toId}`);
+    conditions.push(sql`${edges3.toId} = ${params.toId}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
   return sql`
-    SELECT COUNT(*) as count FROM ${edges}
+    SELECT COUNT(*) as count FROM ${edges3}
     WHERE ${whereClause}
   `;
 }
-function buildInsertEdge(tables, params, timestamp) {
-  const { edges } = tables;
+var PEER = "peer";
+function qualified2(relation, column) {
+  return sql.raw(`"${relation}"."${column.name}"`);
+}
+function inList(values) {
+  return sql.join(
+    values.map((value) => sql`${value}`),
+    sql`, `
+  );
+}
+function buildContendedUniqueRowAudit(tables3, graphId, constraintNames) {
+  const { uniques: uniques3 } = tables3;
+  const relation = getTableName(uniques3);
+  return sql`
+    SELECT
+      ${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 ${uniques3} AS ${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(tables3, graphId, cardinality, edgeKinds) {
+  const { edges: edges3 } = tables3;
+  const relation = getTableName(edges3);
+  const spec = EDGE_CARDINALITY_SPECS[cardinality];
+  const activeOnly = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified2(relation, edges3.validTo)} IS NULL` : sql.empty();
+  const peerActiveOnly = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified2(PEER, edges3.validTo)} IS NULL` : sql.empty();
+  const peerToEndpoints = spec.keyShape === "fromAndTo" ? sql`
+        AND ${qualified2(PEER, edges3.toKind)} = ${qualified2(relation, edges3.toKind)}
+                  AND ${qualified2(PEER, edges3.toId)} = ${qualified2(relation, edges3.toId)}
+      ` : sql.empty();
+  return sql`
+    SELECT
+      ${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 ${edges3} AS ${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(tables3, graphId, kinds) {
+  const { nodes: nodes3 } = tables3;
+  const relation = getTableName(nodes3);
+  const liveIdsOfKind = (kind) => sql`
+    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 sql`${liveIdsOfKind(kinds[0])} INTERSECT ${liveIdsOfKind(kinds[1])}`;
+}
+function qualified3(tableName, column) {
+  return sql.raw(`"${tableName}"."${column.name}"`);
+}
+function buildLockEdgeClaims(tables3, entries, timestamp2) {
+  const { edgeClaims: edgeClaims3 } = tables3;
+  const claimsName = getTableName(edgeClaims3);
+  const columns = sql.raw(
+    `"${edgeClaims3.graphId.name}", "${edgeClaims3.axis.name}", "${edgeClaims3.key.name}", "${edgeClaims3.edgeId.name}", "${edgeClaims3.updatedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${edgeClaims3.graphId.name}", "${edgeClaims3.axis.name}", "${edgeClaims3.key.name}"`
+  );
+  const valueRows = sql.join(
+    entries.map((entry) => {
+      const target = edgeCardinalityClaimTarget(entry);
+      return sql`(${entry.graphId}, ${target.axis}, ${target.key}, ${entry.edgeId}, ${timestamp2})`;
+    }),
+    sql`, `
+  );
+  return 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 = getTableName(edgeClaims3);
+  const edgesName = getTableName(edges3);
+  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];
+  const target = edgeCardinalityClaimTarget(params);
+  const toEndpointTerms = spec.keyShape === "fromAndTo" ? sql` AND ${qualified3(edgesName, edges3.toKind)} = ${params.toKind} AND ${qualified3(edgesName, edges3.toId)} = ${params.toId}` : sql``;
+  const activeTerm = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified3(edgesName, edges3.validTo)} IS NULL` : sql``;
+  return 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 sql`
+    DELETE FROM ${edgeClaims3}
+    WHERE ${edgeClaims3.graphId} = ${params.graphId}
+      AND ${edgeClaims3.edgeId} IN (${sql.join(
+    params.edgeIds.map((edgeId) => sql`${edgeId}`),
+    sql`, `
+  )})
+  `;
+}
+function buildInsertEdge(tables3, params, timestamp2) {
+  const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
+  const columns = edgeColumnList(edges3);
   return 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}, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      ${propsJson}, ${sqlNull(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 = edgeColumnList(edges);
+  const columns = edgeColumnList(edges3);
   return 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}, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      ${propsJson}, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
   `;
 }
-function buildInsertEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = 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 sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
-function buildInsertEdgesBatchReturning(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = 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 sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${edges} (${columns})
+    INSERT INTO ${edges3} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
-function buildGetEdge(tables, graphId, id) {
-  const { edges } = tables;
+function buildGetEdge(tables3, graphId, id) {
+  const { edges: edges3 } = tables3;
   return 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 sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} IN (${sql.join(
+    SELECT * FROM ${edges3}
+    WHERE ${edges3.graphId} = ${graphId}
+      AND ${edges3.id} IN (${sql.join(
     ids.map((id) => sql`${id}`),
     sql`, `
   )})
   `;
 }
-function expectedIdentityPredicate(tables, expected) {
-  const { edges } = tables;
+function expectedIdentityPredicate(tables3, expected) {
+  const { edges: edges3 } = tables3;
   const parts = [
-    expected.kind === void 0 ? void 0 : sql` AND ${edges.kind} = ${expected.kind}`,
-    expected.fromKind === void 0 ? void 0 : sql` AND ${edges.fromKind} = ${expected.fromKind}`,
-    expected.fromId === void 0 ? void 0 : sql` AND ${edges.fromId} = ${expected.fromId}`,
-    expected.toKind === void 0 ? void 0 : sql` AND ${edges.toKind} = ${expected.toKind}`,
-    expected.toId === void 0 ? void 0 : sql` AND ${edges.toId} = ${expected.toId}`
+    expected.kind === void 0 ? void 0 : sql` AND ${edges3.kind} = ${expected.kind}`,
+    expected.fromKind === void 0 ? void 0 : sql` AND ${edges3.fromKind} = ${expected.fromKind}`,
+    expected.fromId === void 0 ? void 0 : sql` AND ${edges3.fromId} = ${expected.fromId}`,
+    expected.toKind === void 0 ? void 0 : sql` AND ${edges3.toKind} = ${expected.toKind}`,
+    expected.toId === void 0 ? void 0 : sql` AND ${edges3.toId} = ${expected.toId}`
   ].filter((part) => part !== void 0);
   return parts.length === 0 ? sql.empty() : sql.join(parts, 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 = [
-    sql`${quotedColumn(edges.props)} = ${propsJson}`,
-    sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
+    sql`${quotedColumn(edges3.props)} = ${propsJson}`,
+    sql`${quotedColumn(edges3.updatedAt)} = ${timestamp2}`
   ];
   if (params.clearDeleted && params.validFrom !== void 0) {
     setParts.push(
-      sql`${quotedColumn(edges.validFrom)} = ${sqlNull(resolveStatedValidityLowerBound(params.validFrom))}`,
-      sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
+      sql`${quotedColumn(edges3.validFrom)} = ${sqlNull(resolveStatedValidityLowerBound(params.validFrom))}`,
+      sql`${quotedColumn(edges3.validTo)} = ${sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(sql`${quotedColumn(edges.validTo)} = NULL`);
+    setParts.push(sql`${quotedColumn(edges3.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(edges3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(edges.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(edges3.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
-  const expectedIdentity = expectedIdentityPredicate(tables, params);
+  const expectedIdentity = expectedIdentityPredicate(tables3, params);
   const expectedValidFrom = expectedValidFromPredicate(
-    edges.validFrom,
+    edges3.validFrom,
     params.expectedValidFrom
   );
   const expectedValidTo = expectedValidFromPredicate(
-    edges.validTo,
+    edges3.validTo,
     params.expectedValidTo
   );
   if (params.clearDeleted) {
     return 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 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 sql`
-    UPDATE ${edges}
-    SET ${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 sql`
-    UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${sql.join(
+    UPDATE ${edges3}
+    SET ${quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} IN (${sql.join(
     params.ids.map((id) => sql`${id}`),
     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 sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${sql.join(
+    DELETE FROM ${edges3}
+    WHERE ${edges3.graphId} = ${params.graphId}
+      AND ${edges3.id} IN (${sql.join(
     params.ids.map((id) => sql`${id}`),
     sql`, `
   )})
   `;
 }
-function buildHardDeleteEdge(tables, params) {
-  const { edges } = tables;
+function buildHardDeleteEdge(tables3, params) {
+  const { edges: edges3 } = tables3;
   return 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 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 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 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 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 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}
       )
   `;
 }
@@ -1806,136 +3183,136 @@ 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 = nodeColumnList(nodes);
+  const columns = nodeColumnList(nodes3);
   return sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      1, ${sqlNull(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 = nodeColumnList(nodes);
+  const columns = nodeColumnList(nodes3);
   return sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
+      1, ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}, ${sqlNull(params.validTo)},
+      ${timestamp2}, ${timestamp2}
     )
   `;
 }
-function buildInsertNodesBatch(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = 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 sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
-function buildInsertNodesBatchReturning(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = 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 sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return sql`
-    INSERT INTO ${nodes} (${columns})
+    INSERT INTO ${nodes3} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
-function buildGetNode(tables, graphId, kind, id) {
-  const { nodes } = tables;
+function buildGetNode(tables3, graphId, kind, id) {
+  const { nodes: nodes3 } = tables3;
   return 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 sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} IN (${sql.join(
+    SELECT * FROM ${nodes3}
+    WHERE ${nodes3.graphId} = ${graphId}
+      AND ${nodes3.kind} = ${kind}
+      AND ${nodes3.id} IN (${sql.join(
     ids.map((id) => sql`${id}`),
     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 = [
-    sql`${quotedColumn(nodes.props)} = ${propsJson}`,
-    sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
+    sql`${quotedColumn(nodes3.props)} = ${propsJson}`,
+    sql`${quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
+      sql`${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1`
     );
   }
   if (params.clearDeleted) {
     setParts.push(
-      sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}`,
-      sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
+      sql`${quotedColumn(nodes3.validFrom)} = ${sqlNull(resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp2))}`,
+      sql`${quotedColumn(nodes3.validTo)} = ${sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(sql`${quotedColumn(nodes.validTo)} = NULL`);
+    setParts.push(sql`${quotedColumn(nodes3.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(nodes3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(nodes.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(nodes3.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
   const expectedValidFrom = expectedValidFromPredicate(
-    nodes.validFrom,
+    nodes3.validFrom,
     params.expectedValidFrom
   );
   if (params.clearDeleted) {
     return 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 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;
+function buildUpdateNodeSet(tables3, dialect, params, timestamp2) {
+  const { nodes: nodes3 } = tables3;
   const adapter = getDialect(dialect);
   const patchedProps = toDrizzleSql(
     adapter.jsonSetProperties(
-      sql$1.identifier(nodes.props.name),
+      sql$1.identifier(nodes3.props.name),
       params.patch,
       params.unsetProperties ?? []
     ),
@@ -1947,38 +3324,38 @@ function buildUpdateNodeSet(tables, dialect, params, timestamp) {
     dialect
   );
   return sql`
-    UPDATE ${nodes}
-    SET ${quotedColumn(nodes.props)} = ${patchedProps},
-        ${quotedColumn(nodes.updatedAt)} = ${timestamp},
-        ${quotedColumn(nodes.version)} = ${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 sql`
-    UPDATE ${nodes}
-    SET ${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 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) {
@@ -1999,158 +3376,199 @@ 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 = 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 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 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 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 = sql`
-    UPDATE ${schemaVersions}
-    SET ${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 = sql`
-    UPDATE ${schemaVersions}
-    SET ${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 buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
+function drizzleSqlTag(strings, ...expressions) {
+  return 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 ? sql`${params.nodeId}` : sql`${params.concreteKind}`;
+}
+function excludedColumnByName(columnName) {
+  return sql`excluded.${quotedColumn({ name: columnName })}`;
+}
+function excludedColumn(column) {
+  return excludedColumnByName(column.name);
+}
+function buildInsertUniqueSqlite(tables3, params) {
+  const { uniques: uniques3 } = tables3;
   const columns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
+  );
+  const ownerMatches = claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => quotedColumn({ name: columnName }),
+    boundOwnerColumn(uniques3, params),
+    ownerColumnNames(uniques3)
   );
   return sql`
-    INSERT INTO ${uniques} (${columns})
+    INSERT INTO ${uniques3} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques.nodeId)}
+      ${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(uniques.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques.concreteKind)}
+      ${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(uniques.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques.deletedAt)}
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${quotedColumn(uniques3.deletedAt)}
       END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
+    RETURNING
+      ${quotedColumn(uniques3.nodeId)} as node_id,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind
   `;
 }
-function buildInsertUniquePostgres(tables, params) {
-  const { uniques } = tables;
+function buildInsertUniquePostgres(tables3, params) {
+  const { uniques: uniques3 } = tables3;
   const columns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
+  );
+  const tableName = getTableName(uniques3);
+  const existingColumnByName = (columnName) => sql`${quotedTableName(tableName)}.${quotedColumn({ name: columnName })}`;
+  const existingColumn = (column) => existingColumnByName(column.name);
+  const ownerMatches = claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => existingColumnByName(columnName),
+    boundOwnerColumn(uniques3, params),
+    ownerColumnNames(uniques3)
   );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
   return sql`
-    INSERT INTO ${uniques} (${columns})
+    INSERT INTO ${uniques3} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques.nodeId)}
+      ${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(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques.concreteKind)}
+      ${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(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques3.deletedAt)}
       END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
+    RETURNING
+      ${quotedColumn(uniques3.nodeId)} as node_id,
+      ${quotedColumn(uniques3.concreteKind)} as concrete_kind
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
   postgres: buildInsertUniquePostgres,
   sqlite: buildInsertUniqueSqlite
 };
-function buildInsertUnique(tables, dialect, params) {
+function buildInsertUnique(tables3, dialect, params) {
   const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables, params);
+  return builder(tables3, params);
 }
-function buildInsertUniqueBatch(tables, dialect, entries) {
-  const { uniques } = tables;
+function buildInsertUniqueBatch(tables3, dialect, entries) {
+  const { uniques: uniques3 } = tables3;
   const columns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}", "${uniques3.nodeId.name}", "${uniques3.concreteKind.name}", "${uniques3.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+    `"${uniques3.graphId.name}", "${uniques3.nodeKind.name}", "${uniques3.constraintName.name}", "${uniques3.key.name}"`
   );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => {
+  const tableName = getTableName(uniques3);
+  const existingColumnByName = (columnName) => {
     switch (dialect) {
       case "postgres": {
-        return sql.raw(`"${tableName}"."${column.name}"`);
+        return sql`${quotedTableName(tableName)}.${quotedColumn({ name: columnName })}`;
       }
       case "sqlite": {
-        return sql.raw(`"${column.name}"`);
+        return quotedColumn({ name: columnName });
       }
       default: {
         return dialect;
       }
     }
   };
-  const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
+  const existingColumn = (column) => existingColumnByName(column.name);
+  const ownerMatches = claimOwnerMatchesSql(
+    drizzleSqlTag,
+    (columnName) => existingColumnByName(columnName),
+    excludedColumnByName,
+    ownerColumnNames(uniques3)
+  );
   const valueRows = sql.join(
     entries.map(
       (params) => sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")})`
@@ -2158,105 +3576,108 @@ function buildInsertUniqueBatch(tables, dialect, entries) {
     sql`, `
   );
   return sql`
-    INSERT INTO ${uniques} (${columns})
+    INSERT INTO ${uniques3} (${columns})
     VALUES ${valueRows}
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.nodeId)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.nodeId)}
-        ELSE ${existingColumn(uniques.nodeId)}
+      ${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(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.concreteKind)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.concreteKind)}
-        ELSE ${existingColumn(uniques.concreteKind)}
+      ${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(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
+      ${quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques3.deletedAt)}
       END
     RETURNING
-      ${quotedColumn(uniques.nodeKind)} as node_kind,
-      ${quotedColumn(uniques.constraintName)} as constraint_name,
-      ${quotedColumn(uniques.key)} as key,
-      ${quotedColumn(uniques.nodeId)} as node_id
+      ${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(tables, params, timestamp) {
-  const { uniques } = tables;
+function buildDeleteUnique(tables3, params, timestamp2) {
+  const { uniques: uniques3 } = tables3;
+  const axisTerm = params.nodeKind === void 0 ? sql`` : sql` AND ${uniques3.nodeKind} = ${params.nodeKind}`;
   return sql`
-    UPDATE ${uniques}
-    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
+    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(tables, graphId, concreteKind, nodeId) {
-  return buildHardDeleteUniquesByNodeIds(tables, {
+function buildHardDeleteUniquesByNode(tables3, graphId, concreteKind, nodeId) {
+  return buildHardDeleteUniquesByNodeIds(tables3, {
     graphId,
     concreteKind,
     nodeIds: [nodeId]
   });
 }
-function buildHardDeleteUniquesByNodeIds(tables, params) {
-  const { uniques } = tables;
+function buildHardDeleteUniquesByNodeIds(tables3, params) {
+  const { uniques: uniques3 } = tables3;
   return sql`
-    DELETE FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.concreteKind} = ${params.concreteKind}
-      AND ${uniques.nodeId} IN (${sql.join(
+    DELETE FROM ${uniques3}
+    WHERE ${uniques3.graphId} = ${params.graphId}
+      AND ${uniques3.concreteKind} = ${params.concreteKind}
+      AND ${uniques3.nodeId} IN (${sql.join(
     params.nodeIds.map((nodeId) => sql`${nodeId}`),
     sql`, `
   )})
   `;
 }
-function buildCheckUnique(tables, params) {
-  const { uniques } = tables;
+function buildCheckUnique(tables3, params) {
+  const { uniques: uniques3 } = tables3;
   if (params.includeDeleted) {
     return sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} = ${params.key}
+      SELECT * FROM ${uniques3}
+      WHERE ${uniques3.graphId} = ${params.graphId}
+        AND ${uniques3.nodeKind} = ${params.nodeKind}
+        AND ${uniques3.constraintName} = ${params.constraintName}
+        AND ${uniques3.key} = ${params.key}
     `;
   }
   return sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
+    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(tables, params) {
-  const { uniques } = tables;
+function buildCheckUniqueBatch(tables3, params) {
+  const { uniques: uniques3 } = tables3;
   const keyPlaceholders = sql.join(
     params.keys.map((key) => sql`${key}`),
     sql`, `
   );
   if (params.includeDeleted) {
     return sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} IN (${keyPlaceholders})
+      SELECT * FROM ${uniques3}
+      WHERE ${uniques3.graphId} = ${params.graphId}
+        AND ${uniques3.nodeKind} = ${params.nodeKind}
+        AND ${uniques3.constraintName} = ${params.constraintName}
+        AND ${uniques3.key} IN (${keyPlaceholders})
     `;
   }
   return sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} IN (${keyPlaceholders})
-      AND ${uniques.deletedAt} IS NULL
+    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
   `;
 }
 
@@ -2264,10 +3685,10 @@ function buildCheckUniqueBatch(tables, params) {
 function nullableText(value) {
   return value === void 0 ? sql`NULL` : 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];
   });
@@ -2313,22 +3734,22 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   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) => toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
     buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
     }).map((statement) => toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
     buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
@@ -2338,7 +3759,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
       params.candidates ?? liveNodeIdsSubquery(
-        tables.nodes,
+        tables3.nodes,
         params.graphId,
         params.nodeKind,
         nowIso()
@@ -2346,7 +3767,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
       const candidates = params.candidates ?? liveNodeIdsSubquery(
-        tables.nodes,
+        tables3.nodes,
         params.graphId,
         params.nodeKind,
         nowIso()
@@ -2374,7 +3795,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
-        nodes: tables.nodes,
+        nodes: tables3.nodes,
         dialect,
         graphId: params.graphId,
         nodeKind: params.nodeKind,
@@ -2417,28 +3838,57 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     ...tableOperations,
     ...fulltextBuilders,
     primaryKeyConstraints: {
-      nodes: nodePrimaryKeyConstraint(tables.nodes),
-      edges: 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 buildInsertUnique(tables, dialect, params);
+      return buildInsertUnique(tables3, dialect, params);
     },
     buildInsertUniqueBatch(entries) {
-      return buildInsertUniqueBatch(tables, dialect, entries);
+      return buildInsertUniqueBatch(tables3, dialect, entries);
+    },
+    buildHardDeleteUniquesByConcreteKind(params) {
+      return buildHardDeleteUniquesByConcreteKind(
+        getTableName(tables3.uniques),
+        params
+      );
+    },
+    buildLockEdgeClaims(entries, timestamp2) {
+      return buildLockEdgeClaims(tables3, entries, timestamp2);
+    },
+    buildTakeOverEdgeClaim(params, timestamp2) {
+      return buildTakeOverEdgeClaim(tables3, params, timestamp2);
+    },
+    buildPurgeEdgeClaims(params) {
+      return buildPurgeEdgeClaims(tables3, params);
+    },
+    buildContendedUniqueRowAudit(graphId, constraintNames) {
+      return buildContendedUniqueRowAudit(tables3, graphId, constraintNames);
+    },
+    buildContendedEdgeRowAudit(graphId, cardinality, edgeKinds) {
+      return buildContendedEdgeRowAudit(
+        tables3,
+        graphId,
+        cardinality,
+        edgeKinds
+      );
+    },
+    buildDisjointOverlapAudit(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) {
@@ -2461,7 +3911,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       }
     },
     buildClearGraph(graphId) {
-      return buildClearGraph(tables, graphId);
+      return buildClearGraph(tables3, graphId);
     }
   };
 }
@@ -2487,11 +3937,14 @@ 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(tables3, fulltextStrategy) {
+  return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
 }
-function createPostgresOperationStrategy(tables, fulltextStrategy) {
-  return createCommonOperationStrategy(tables, "postgres", fulltextStrategy);
+function claimOwnerOf(params) {
+  return { concreteKind: params.concreteKind, nodeId: params.nodeId };
 }
 var DRIZZLE_DIALECT_LABELS = {
   postgres: "Postgres",
@@ -2594,6 +4047,50 @@ function createCommonOperationBackend(options) {
     }
     await execution.execRun(statement.query);
   }
+  async function claimEdgeCardinalityEntries(entries) {
+    if (entries.length === 0) return [];
+    const targetKey = (entry) => {
+      const target = edgeCardinalityClaimTarget(entry);
+      return `${target.axis}\0${target.key}`;
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const key = targetKey(entry);
+      if (seen.has(key)) {
+        throw new DatabaseOperationError(
+          "Two edge claims in one batch name the same cardinality axis and key; a multi-row upsert cannot affect one row twice.",
+          { operation: "insert", entity: "edge" }
+        );
+      }
+      seen.add(key);
+    }
+    const outcomes = /* @__PURE__ */ new Map();
+    for (const chunk2 of chunk(entries, batchConfig.edgeInsertBatchSize)) {
+      const lockQuery = operationStrategy.buildLockEdgeClaims(chunk2, nowIso2());
+      const rows = await execution.execAll(lockQuery);
+      const holderByTarget = new Map(
+        rows.map((row) => [`${row.axis}\0${row.key}`, row.holder_edge_id])
+      );
+      for (const entry of chunk2) {
+        const key = targetKey(entry);
+        const holder = holderByTarget.get(key);
+        if (holder === void 0 || holder === entry.edgeId) {
+          outcomes.set(key, { status: "claimed" });
+          continue;
+        }
+        const takeOver = await execution.execAll(
+          operationStrategy.buildTakeOverEdgeClaim(entry, nowIso2())
+        );
+        outcomes.set(
+          key,
+          takeOver.length > 0 ? { status: "claimed" } : { status: "refused", holderEdgeId: holder }
+        );
+      }
+    }
+    return entries.map(
+      (entry) => outcomes.get(targetKey(entry)) ?? { status: "claimed" }
+    );
+  }
   async function readActiveVersion(graphId) {
     const row = await execution.execGet(
       operationStrategy.buildGetActiveSchema(graphId)
@@ -2612,8 +4109,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),
         {
@@ -2634,10 +4131,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",
@@ -2649,9 +4146,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
+        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "node",
           relation: operationStrategy.primaryKeyConstraints.nodes,
@@ -2663,12 +4160,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatchReturning(
           chunk2,
-          timestamp
+          timestamp2
         );
         const rows = await withDuplicateKeyClassification(
           () => execution.execAll(query),
@@ -2698,8 +4195,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 DatabaseOperationError(
@@ -2725,15 +4222,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
@@ -2770,8 +4267,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),
         {
@@ -2792,10 +4289,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",
@@ -2807,9 +4304,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
+        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "edge",
           relation: operationStrategy.primaryKeyConstraints.edges,
@@ -2821,12 +4318,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatchReturning(
           chunk2,
-          timestamp
+          timestamp2
         );
         const rows = await withDuplicateKeyClassification(
           () => execution.execAll(query),
@@ -2856,8 +4353,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 DatabaseOperationError(
@@ -2871,8 +4368,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) {
@@ -2881,7 +4378,7 @@ 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
@@ -2889,7 +4386,7 @@ function createCommonOperationBackend(options) {
       for (const chunk2 of chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
-          timestamp
+          timestamp2
         );
         await execution.execRun(query);
       }
@@ -2976,13 +4473,23 @@ function createCommonOperationBackend(options) {
     async insertUnique(params) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
-      if (result && result.node_id !== params.nodeId) {
+      if (result && !isSameClaimOwner(
+        { concreteKind: result.concrete_kind, nodeId: result.node_id },
+        claimOwnerOf(params)
+      )) {
         throw new UniquenessError({
           constraintName: params.constraintName,
-          kind: params.nodeKind,
+          // The holder's own kind, never `nodeKind`: that column carries the
+          // claim AXIS, which a shared scope folds across kinds, so it need not
+          // be the holder's kind and usually is not.
+          kind: result.concrete_kind,
           existingId: result.node_id,
           newId: params.nodeId,
-          fields: []
+          fields: [],
+          // The axis THIS statement attempted — `mapClaimRefusal`'s only way to
+          // tell two disjoint pairs (or two scoped constraints) sharing a key
+          // apart, since `constraintName` alone does not.
+          axis: params.nodeKind
         });
       }
     },
@@ -2996,13 +4503,14 @@ function createCommonOperationBackend(options) {
           byTarget.set(targetKey(entry), entry);
           continue;
         }
-        if (existing.nodeId !== entry.nodeId) {
+        if (!isSameClaimOwner(claimOwnerOf(existing), claimOwnerOf(entry))) {
           throw new UniquenessError({
             constraintName: entry.constraintName,
-            kind: entry.nodeKind,
+            kind: existing.concreteKind,
             existingId: existing.nodeId,
             newId: entry.nodeId,
-            fields: []
+            fields: [],
+            axis: entry.nodeKind
           });
         }
       }
@@ -3016,26 +4524,27 @@ function createCommonOperationBackend(options) {
         const ownerByTarget = new Map(
           rows.map((row) => [
             `${row.node_kind}\0${row.constraint_name}\0${row.key}`,
-            row.node_id
+            { concreteKind: row.concrete_kind, nodeId: row.node_id }
           ])
         );
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
-          if (owner !== void 0 && owner !== entry.nodeId) {
+          if (owner !== void 0 && !isSameClaimOwner(owner, claimOwnerOf(entry))) {
             throw new UniquenessError({
               constraintName: entry.constraintName,
-              kind: entry.nodeKind,
-              existingId: owner,
+              kind: owner.concreteKind,
+              existingId: owner.nodeId,
               newId: entry.nodeId,
-              fields: []
+              fields: [],
+              axis: entry.nodeKind
             });
           }
         }
       }
     },
     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) {
@@ -3051,6 +4560,78 @@ function createCommonOperationBackend(options) {
         await execution.execRun(query);
       }
     },
+    async hardDeleteUniquesByConcreteKind(params) {
+      const query = operationStrategy.buildHardDeleteUniquesByConcreteKind(params);
+      await execution.execRun(query);
+    },
+    async claimEdgeCardinality(params) {
+      const [outcome] = await claimEdgeCardinalityEntries([params]);
+      return outcome ?? { status: "claimed" };
+    },
+    claimEdgeCardinalityBatch(entries) {
+      return claimEdgeCardinalityEntries(entries);
+    },
+    async purgeEdgeClaims(params) {
+      const edgeIds = [...new Set(params.edgeIds)];
+      for (const chunk2 of chunk(edgeIds, batchConfig.getEdgesChunkSize)) {
+        const query = operationStrategy.buildPurgeEdgeClaims({
+          ...params,
+          edgeIds: chunk2
+        });
+        await execution.execRun(query);
+      }
+    },
+    async readConstraintFenceViolations(params) {
+      const uniqueRows = params.uniqueConstraintNames.length === 0 ? [] : await execution.execAll(
+        operationStrategy.buildContendedUniqueRowAudit(
+          params.graphId,
+          params.uniqueConstraintNames
+        )
+      );
+      const contendedUniqueRows = uniqueRows.map((row) => ({
+        nodeKind: row.node_kind,
+        constraintName: row.constraint_name,
+        key: row.key,
+        concreteKind: row.concrete_kind,
+        nodeId: row.node_id
+      }));
+      const edgeKindsByCardinality = /* @__PURE__ */ new Map();
+      for (const declaration of params.edgeCardinalities) {
+        const kinds = edgeKindsByCardinality.get(declaration.cardinality) ?? [];
+        kinds.push(declaration.edgeKind);
+        edgeKindsByCardinality.set(declaration.cardinality, kinds);
+      }
+      const contendedEdgeRows = [];
+      for (const [cardinality, edgeKinds] of edgeKindsByCardinality) {
+        const rows = await execution.execAll(
+          operationStrategy.buildContendedEdgeRowAudit(
+            params.graphId,
+            cardinality,
+            edgeKinds
+          )
+        );
+        for (const row of rows) {
+          contendedEdgeRows.push({
+            edgeKind: row.edge_kind,
+            cardinality,
+            edgeId: row.edge_id,
+            fromKind: row.from_kind,
+            fromId: row.from_id,
+            toKind: row.to_kind,
+            toId: row.to_id
+          });
+        }
+      }
+      const disjointOverlaps = [];
+      for (const kinds of params.disjointKindPairs) {
+        const rows = await execution.execAll(
+          operationStrategy.buildDisjointOverlapAudit(params.graphId, kinds)
+        );
+        for (const row of rows)
+          disjointOverlaps.push({ kinds, nodeId: row.node_id });
+      }
+      return { contendedUniqueRows, contendedEdgeRows, disjointOverlaps };
+    },
     async checkUnique(params) {
       const query = operationStrategy.buildCheckUnique(params);
       const row = await execution.execGet(query);
@@ -3125,7 +4706,7 @@ function createCommonOperationBackend(options) {
         );
         await execution.execRun(flip.deactivateAll);
       }
-      const timestamp = nowIso2();
+      const timestamp2 = nowIso2();
       const insertQuery = operationStrategy.buildInsertSchema(
         {
           graphId: params.graphId,
@@ -3134,7 +4715,7 @@ function createCommonOperationBackend(options) {
           schemaDoc: params.schemaDoc,
           isActive: true
         },
-        timestamp
+        timestamp2
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
@@ -3334,7 +4915,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) => [
@@ -3342,16 +4923,16 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.kind,
           item.id,
           JSON.stringify(item.props),
-          resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          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) => [
@@ -3363,10 +4944,10 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.toKind,
           item.toId,
           JSON.stringify(item.props),
-          resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL,
           item.validTo ?? DATABASE_NULL,
-          timestamp,
-          timestamp
+          timestamp2,
+          timestamp2
         ])
       );
     }
@@ -3396,7 +4977,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)),
@@ -3404,16 +4985,16 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => 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)),
@@ -3425,11 +5006,11 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp2) ?? DATABASE_NULL
           )
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp))
+        postgresArray(params.map(() => timestamp2))
       ]);
     }
   };
@@ -3452,6 +5033,6 @@ function getOrCreateLru(cache, key, cacheMax, create) {
   return value;
 }
 
-export { EMBEDDING_UPSERT_PARAM_COUNT, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertActiveSchemaVersion, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, commitSchemaVersionIfKindsEmpty, contributionRebuildSupported, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, gateFulltext, gateFulltextMethods, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, restoreSecondaryIndexes, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tableExistsFromRow, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-Z2JCLZFJ.js.map
-//# sourceMappingURL=chunk-Z2JCLZFJ.js.map
+export { EMBEDDING_UPSERT_PARAM_COUNT, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertActiveSchemaVersion, assertAdoptedDialect, assertBundledCapabilityDeclarations, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, commitSchemaVersionIfKindsEmpty, contributionRebuildSupported, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTables, createSqliteTrustedImportSession, edgeClaims, edgeClaims2, edges, edges2, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, nodes2, postgresContributions, recordedClock, recordedClock2, recordedEdges, recordedEdges2, recordedNodes, recordedNodes2, restoreSecondaryIndexes, schemaVersions, schemaVersions2, sqliteContributions, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tableExistsFromRow, tables, tables2, uniques, uniques2, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-UKOVGCRN.js.map
+//# sourceMappingURL=chunk-UKOVGCRN.js.map