@nicia-ai/typegraph 0.38.0 → 0.40.0

package/dist/{chunk-G32AO634.js → chunk-W66YCXWT.js}

@@ -1,606 +1,22 @@
-import { tables } from './chunk-MTNEGGM2.js';
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-AOL64O4Z.js';
-import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, toDrizzleSql } from './chunk-Z2PPIVOO.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-L3DDZUZP.js';
+import { runtimeStrategyContributions } from './chunk-5J4VNCUD.js';
+import { toDrizzleSql } from './chunk-ZVME6OSV.js';
 import { chunk } from './chunk-35S6P5ZU.js';
-import { createBackendOverlay } from './chunk-PZHC5GCD.js';
+import { createBackendOverlay } from './chunk-L5ET7FYQ.js';
 import { sortedReplacer } from './chunk-UR7W5YQK.js';
-import { parseDimensionMismatch, isMissingTableError } from './chunk-KFLXWVUJ.js';
-import { assertNoSystemIndexNameCollision } from './chunk-BQITNFQJ.js';
+import { parseDimensionMismatch, isMissingTableError } from './chunk-UUIBACKJ.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-Y7M44XEK.js';
-import { sql as sql$1, asCompiledStatementSql, isSqlFragment } from './chunk-6XDBRDZE.js';
+import { sql as sql$1, asCompiledStatementSql, isSqlFragment } from './chunk-6N7QBIWN.js';
 import { isPresent } from './chunk-QMQLUA66.js';
 import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, StaleVersionError, StoreNotInitializedError } from './chunk-DPNA466P.js';
 import { sql, is, getTableName } from 'drizzle-orm';
-import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
-import { 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",
-  uniques: "typegraph_node_uniques",
-  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 nodes2 = 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 edges2 = 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 recordedNodes2 = 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: timestamp("recorded_from", {
-        withTimezone: true
-      }).notNull(),
-      recordedTo: timestamp("recorded_to", { withTimezone: true }).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 recordedEdges2 = 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: timestamp("recorded_from", {
-        withTimezone: true
-      }).notNull(),
-      recordedTo: timestamp("recorded_to", { withTimezone: true }).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 recordedClock2 = pgTable(
-    n.recordedClock,
-    {
-      graphId: text("graph_id").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 uniques2 = 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 schemaVersions2 = 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: nodes2,
-    edges: edges2,
-    recordedNodes: recordedNodes2,
-    recordedEdges: recordedEdges2,
-    recordedClock: recordedClock2,
-    revisionOrigins,
-    uniques: uniques2,
-    schemaVersions: schemaVersions2,
-    indexMaterializations,
-    contributionMaterializations,
-    kindRemovals,
-    reconciliationMarkers,
-    fulltext: fulltext2,
-    fulltextTableName: n.fulltext
-  };
-}
-var tables2 = createPostgresTables();
-var {
-  nodes,
-  edges,
-  recordedNodes,
-  recordedEdges,
-  recordedClock,
-  uniques,
-  schemaVersions,
-  fulltext
-} = tables2;
-function getSqliteColumnType(column) {
-  switch (column.columnType) {
-    case "SQLiteText": {
-      return "TEXT";
-    }
-    case "SQLiteInteger": {
-      return "INTEGER";
-    }
-    case "SQLiteReal": {
-      return "REAL";
-    }
-    case "SQLiteBlob": {
-      return "BLOB";
-    }
-    default: {
-      return "TEXT";
-    }
-  }
-}
-function formatDefaultValue(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  return JSON.stringify(value);
-}
-function generateSqliteCreateTableSQL(table) {
-  const config = getTableConfig(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [
-      `"${column.name}"`,
-      getSqliteColumnType(column)
-    ];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
-  ${columnDefs.join(",\n  ")}
-);`;
-}
-function renderIndexColumn(col) {
-  if (col && typeof col === "object" && "name" in col) {
-    return `"${col.name}"`;
-  }
-  const sql16 = tryInlineSql(col);
-  if (sql16 !== void 0) {
-    return sql16;
-  }
-  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 index2 of config.indexes) {
-    const indexConfig = index2.config;
-    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
-    const unique = indexConfig.unique ? "UNIQUE " : "";
-    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `SQLite index "${indexConfig.name}" WHERE clause`)}` : "";
-    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 = tables, 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 = tables, fulltextStrategy = fts5Strategy) {
-  return sqliteContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generateSqliteMigrationSQL(tables3 = tables, fulltextStrategy = fts5Strategy) {
-  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
-}
-function getPgColumnType(column) {
-  switch (column.columnType) {
-    case "PgText": {
-      return "TEXT";
-    }
-    case "PgInteger": {
-      return "INTEGER";
-    }
-    case "PgBoolean": {
-      return "BOOLEAN";
-    }
-    case "PgJsonb": {
-      return "JSONB";
-    }
-    case "PgTimestamp": {
-      return column.config?.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
-    }
-    case "PgReal": {
-      return "REAL";
-    }
-    case "PgDoublePrecision": {
-      return "DOUBLE PRECISION";
-    }
-    case "PgCustomColumn": {
-      const dataType = column.getSQLType?.();
-      return dataType ?? "TEXT";
-    }
-    default: {
-      return "TEXT";
-    }
-  }
-}
-function formatPgDefaultValue(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  return JSON.stringify(value);
-}
-function generatePgCreateTableSQL(table) {
-  const config = getTableConfig$1(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [`"${column.name}"`, getPgColumnType(column)];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
-  ${columnDefs.join(",\n  ")}
-);`;
-}
-function generatePgCreateIndexSQL(table) {
-  const config = getTableConfig$1(table);
-  const statements = [];
-  for (const index2 of config.indexes) {
-    const indexConfig = index2.config;
-    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
-    const unique = indexConfig.unique ? "UNIQUE " : "";
-    const method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
-    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 = tables2, 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 = tables2, fulltextStrategy = tsvectorStrategy) {
-  return postgresContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = tsvectorStrategy) {
-  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
-  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
-  return `${extensionSql}
-
-${ddlSql}`;
-}
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes2 = sql$1.identifier(nodesTableName);
+  const nodes = sql$1.identifier(nodesTableName);
   return sql$1`
     SELECT "id" AS node_id
-    FROM ${nodes2}
+    FROM ${nodes}
     WHERE "graph_id" = ${graphId}
       AND "kind" = ${nodeKind}
       AND "deleted_at" IS NULL
@@ -795,7 +211,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, index2) => cachedCreateDdl[index2] === statement
+      (statement, index) => cachedCreateDdl[index] === statement
     )) {
       return cachedSignature;
     }
@@ -1130,9 +546,9 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
 function sqlNull(value) {
   return value ?? sql.raw("NULL");
 }
-function resolveValidFrom(validFrom, timestamp2) {
+function resolveValidFrom(validFrom, timestamp) {
   if (validFrom === null) return void 0;
-  return validFrom ?? timestamp2;
+  return validFrom ?? timestamp;
 }
 function quotedColumn(column) {
   return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
@@ -1147,17 +563,17 @@ var CODE_POINT_ORDER_BUILDERS = {
 function codePointOrderKey(column, dialect) {
   return CODE_POINT_ORDER_BUILDERS[dialect](column);
 }
-function liveNodeIdsSubquery(nodes2, graphId, nodeKind, nowIso2) {
-  return sql`SELECT ${nodes2.id} AS node_id FROM ${nodes2} WHERE ${nodes2.graphId} = ${graphId} AND ${nodes2.kind} = ${nodeKind} AND ${nodes2.deletedAt} IS NULL AND (${nodes2.validFrom} IS NULL OR ${nodes2.validFrom} <= ${nowIso2}) AND (${nodes2.validTo} IS NULL OR ${nodes2.validTo} > ${nowIso2})`;
+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 nodeColumnList(nodes2) {
+function nodeColumnList(nodes) {
   return sql.raw(
-    `"${nodes2.graphId.name}", "${nodes2.kind.name}", "${nodes2.id.name}", "${nodes2.props.name}", "${nodes2.version.name}", "${nodes2.validFrom.name}", "${nodes2.validTo.name}", "${nodes2.createdAt.name}", "${nodes2.updatedAt.name}"`
+    `"${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}"`
   );
 }
-function edgeColumnList(edges2) {
+function edgeColumnList(edges) {
   return sql.raw(
-    `"${edges2.graphId.name}", "${edges2.id.name}", "${edges2.kind.name}", "${edges2.fromKind.name}", "${edges2.fromId.name}", "${edges2.toKind.name}", "${edges2.toId.name}", "${edges2.props.name}", "${edges2.validFrom.name}", "${edges2.validTo.name}", "${edges2.createdAt.name}", "${edges2.updatedAt.name}"`
+    `"${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}"`
   );
 }
 
@@ -1169,20 +585,20 @@ function hybridCandidatesRef() {
   return sql`SELECT node_id FROM tg_hybrid_cand`;
 }
 function buildHybridSearchStatement(input) {
-  const { nodes: nodes2 } = input;
+  const { nodes } = input;
   const nodeIdOrder = nodeIdOrderKey(input.dialect);
   const vectorOrder = input.vectorScoreDescending ? sql`score DESC, ${nodeIdOrder} ASC` : sql`score ASC, ${nodeIdOrder} ASC`;
   const columnPairs = [
-    [nodes2.graphId, "graph_id"],
-    [nodes2.kind, "kind"],
-    [nodes2.id, "id"],
-    [nodes2.props, "props"],
-    [nodes2.version, "version"],
-    [nodes2.validFrom, "valid_from"],
-    [nodes2.validTo, "valid_to"],
-    [nodes2.createdAt, "created_at"],
-    [nodes2.updatedAt, "updated_at"],
-    [nodes2.deletedAt, "deleted_at"]
+    [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"]
   ];
   const nodeColumns = sql.raw(
     columnPairs.map(
@@ -1235,17 +651,17 @@ function buildHybridSearchStatement(input) {
       tg_hybrid_fused.snippet AS snippet,
       ${nodeColumns}
     FROM tg_hybrid_fused
-    JOIN ${nodes2} AS tg_hybrid_node
-      ON ${qualified(nodes2, "graphId")} = ${input.graphId}
-     AND ${qualified(nodes2, "kind")} = ${input.nodeKind}
-     AND ${qualified(nodes2, "id")} = tg_hybrid_fused.node_id
-     AND ${qualified(nodes2, "deletedAt")} IS NULL
+    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
     ORDER BY fused_score DESC, ${nodeIdOrder} ASC
     LIMIT ${input.limit} OFFSET ${input.offset}
   `;
 }
-function qualified(nodes2, member) {
-  return sql`tg_hybrid_node.${quotedColumn(nodes2[member])}`;
+function qualified(nodes, member) {
+  return sql`tg_hybrid_node.${quotedColumn(nodes[member])}`;
 }
 function present(value) {
   return value !== null && value !== void 0;
@@ -1265,45 +681,45 @@ function mapHybridSearchRow(row, toNodeRow) {
     ...present(row["snippet"]) ? { snippet: String(row["snippet"]) } : {}
   };
 }
-function buildClearGraph(tables3, graphId) {
-  const fulltext2 = quotedTableName(tables3.fulltextTableName);
+function buildClearGraph(tables, graphId) {
+  const fulltext = quotedTableName(tables.fulltextTableName);
   return [
-    { query: sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}` },
+    { query: sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}` },
     {
-      query: sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables3.recordedEdges)
+      requiredTableName: getTableName(tables.recordedEdges)
     },
     {
-      query: sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables.recordedNodes} WHERE ${tables.recordedNodes.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables3.recordedNodes)
+      requiredTableName: getTableName(tables.recordedNodes)
     },
     {
-      query: sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
+      query: sql`DELETE FROM ${tables.recordedClock} WHERE ${tables.recordedClock.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: getTableName(tables3.recordedClock)
+      requiredTableName: getTableName(tables.recordedClock)
     },
     {
-      query: sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.indexMaterializations} WHERE ${tables.indexMaterializations.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.kindRemovals} WHERE ${tables.kindRemovals.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.reconciliationMarkers} WHERE ${tables.reconciliationMarkers.graphId} = ${graphId}`
     },
     {
-      query: sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
+      query: sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
     }
   ];
 }
@@ -1325,21 +741,21 @@ function buildTemporalConditions(table, params) {
   }
   return conditions;
 }
-function buildFindNodesByKind(tables3, params) {
-  const { nodes: nodes2 } = tables3;
+function buildFindNodesByKind(tables, params) {
+  const { nodes } = tables;
   const conditions = [
-    sql`${nodes2.graphId} = ${params.graphId}`,
-    sql`${nodes2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes2, params)
+    sql`${nodes.graphId} = ${params.graphId}`,
+    sql`${nodes.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(sql`${nodes2.id} > ${params.after}`);
+    conditions.push(sql`${nodes.id} > ${params.after}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
-  const orderByClause = params.orderBy === "id" ? sql`${nodes2.id} ASC` : sql`${nodes2.createdAt} DESC, ${nodes2.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? sql`${nodes.id} ASC` : sql`${nodes.createdAt} DESC, ${nodes.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
-      SELECT * FROM ${nodes2}
+      SELECT * FROM ${nodes}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1347,58 +763,58 @@ function buildFindNodesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return sql`
-      SELECT * FROM ${nodes2}
+      SELECT * FROM ${nodes}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return sql`
-    SELECT * FROM ${nodes2}
+    SELECT * FROM ${nodes}
     WHERE ${whereClause}
     ORDER BY ${orderByClause}
   `;
 }
-function buildCountNodesByKind(tables3, params) {
-  const { nodes: nodes2 } = tables3;
+function buildCountNodesByKind(tables, params) {
+  const { nodes } = tables;
   const conditions = [
-    sql`${nodes2.graphId} = ${params.graphId}`,
-    sql`${nodes2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes2, params)
+    sql`${nodes.graphId} = ${params.graphId}`,
+    sql`${nodes.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes, params)
   ];
   const whereClause = sql.join(conditions, sql` AND `);
   return sql`
-    SELECT COUNT(*) as count FROM ${nodes2}
+    SELECT COUNT(*) as count FROM ${nodes}
     WHERE ${whereClause}
   `;
 }
-function buildFindEdgesByKind(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildFindEdgesByKind(tables, params) {
+  const { edges } = tables;
   const conditions = [
-    sql`${edges2.graphId} = ${params.graphId}`,
-    sql`${edges2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges2, params)
+    sql`${edges.graphId} = ${params.graphId}`,
+    sql`${edges.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges2.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges2.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges2.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges2.toId} = ${params.toId}`);
+    conditions.push(sql`${edges.toId} = ${params.toId}`);
   }
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(sql`${edges2.id} > ${params.after}`);
+    conditions.push(sql`${edges.id} > ${params.after}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
-  const orderByClause = params.orderBy === "id" ? sql`${edges2.id} ASC` : sql`${edges2.createdAt} DESC, ${edges2.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? sql`${edges.id} ASC` : sql`${edges.createdAt} DESC, ${edges.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
-      SELECT * FROM ${edges2}
+      SELECT * FROM ${edges}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1406,254 +822,254 @@ function buildFindEdgesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return sql`
-      SELECT * FROM ${edges2}
+      SELECT * FROM ${edges}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return sql`
-    SELECT * FROM ${edges2}
+    SELECT * FROM ${edges}
     WHERE ${whereClause}
     ORDER BY ${orderByClause}
   `;
 }
-function buildCountEdgesByKind(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildCountEdgesByKind(tables, params) {
+  const { edges } = tables;
   const conditions = [
-    sql`${edges2.graphId} = ${params.graphId}`,
-    sql`${edges2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges2, params)
+    sql`${edges.graphId} = ${params.graphId}`,
+    sql`${edges.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(sql`${edges2.fromKind} = ${params.fromKind}`);
+    conditions.push(sql`${edges.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(sql`${edges2.fromId} = ${params.fromId}`);
+    conditions.push(sql`${edges.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(sql`${edges2.toKind} = ${params.toKind}`);
+    conditions.push(sql`${edges.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(sql`${edges2.toId} = ${params.toId}`);
+    conditions.push(sql`${edges.toId} = ${params.toId}`);
   }
   const whereClause = sql.join(conditions, sql` AND `);
   return sql`
-    SELECT COUNT(*) as count FROM ${edges2}
+    SELECT COUNT(*) as count FROM ${edges}
     WHERE ${whereClause}
   `;
 }
-function buildInsertEdge(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
+function buildInsertEdge(tables, params, timestamp) {
+  const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges2);
+  const columns = edgeColumnList(edges);
   return sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
-      ${timestamp2}, ${timestamp2}
+      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}, ${sqlNull(params.validTo)},
+      ${timestamp}, ${timestamp}
     )
     RETURNING *
   `;
 }
-function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
+function buildInsertEdgeNoReturn(tables, params, timestamp) {
+  const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges2);
+  const columns = edgeColumnList(edges);
   return sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
-      ${timestamp2}, ${timestamp2}
+      ${propsJson}, ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}, ${sqlNull(params.validTo)},
+      ${timestamp}, ${timestamp}
     )
   `;
 }
-function buildInsertEdgesBatch(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
-  const columns = edgeColumnList(edges2);
+function buildInsertEdgesBatch(tables, params, timestamp) {
+  const { edges } = tables;
+  const columns = edgeColumnList(edges);
   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(resolveValidFrom(edgeParams.validFrom, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveValidFrom(edgeParams.validFrom, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
-function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
-  const columns = edgeColumnList(edges2);
+function buildInsertEdgesBatchReturning(tables, params, timestamp) {
+  const { edges } = tables;
+  const columns = edgeColumnList(edges);
   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(resolveValidFrom(edgeParams.validFrom, timestamp2))}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(resolveValidFrom(edgeParams.validFrom, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
-function buildGetEdge(tables3, graphId, id) {
-  const { edges: edges2 } = tables3;
+function buildGetEdge(tables, graphId, id) {
+  const { edges } = tables;
   return sql`
-    SELECT * FROM ${edges2}
-    WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} = ${id}
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${graphId}
+      AND ${edges.id} = ${id}
   `;
 }
-function buildGetEdges(tables3, graphId, ids) {
-  const { edges: edges2 } = tables3;
+function buildGetEdges(tables, graphId, ids) {
+  const { edges } = tables;
   return sql`
-    SELECT * FROM ${edges2}
-    WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${sql.join(
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${graphId}
+      AND ${edges.id} IN (${sql.join(
     ids.map((id) => sql`${id}`),
     sql`, `
   )})
   `;
 }
-function buildUpdateEdge(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
+function buildUpdateEdge(tables, params, timestamp) {
+  const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    sql`${quotedColumn(edges2.props)} = ${propsJson}`,
-    sql`${quotedColumn(edges2.updatedAt)} = ${timestamp2}`
+    sql`${quotedColumn(edges.props)} = ${propsJson}`,
+    sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(edges2.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(edges2.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(edges.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
   if (params.clearDeleted) {
     return sql`
-      UPDATE ${edges2}
+      UPDATE ${edges}
       SET ${setClause}
-      WHERE ${edges2.graphId} = ${params.graphId}
-        AND ${edges2.id} = ${params.id}
+      WHERE ${edges.graphId} = ${params.graphId}
+        AND ${edges.id} = ${params.id}
       RETURNING *
     `;
   }
   return sql`
-    UPDATE ${edges2}
+    UPDATE ${edges}
     SET ${setClause}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} = ${params.id}
-      AND ${edges2.deletedAt} IS NULL
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} = ${params.id}
+      AND ${edges.deletedAt} IS NULL
     RETURNING *
   `;
 }
-function buildDeleteEdge(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
+function buildDeleteEdge(tables, params, timestamp) {
+  const { edges } = tables;
   return sql`
-    UPDATE ${edges2}
-    SET ${quotedColumn(edges2.deletedAt)} = ${timestamp2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} = ${params.id}
-      AND ${edges2.deletedAt} IS NULL
+    UPDATE ${edges}
+    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} = ${params.id}
+      AND ${edges.deletedAt} IS NULL
   `;
 }
-function buildDeleteEdgesBatch(tables3, params, timestamp2) {
-  const { edges: edges2 } = tables3;
+function buildDeleteEdgesBatch(tables, params, timestamp) {
+  const { edges } = tables;
   return sql`
-    UPDATE ${edges2}
-    SET ${quotedColumn(edges2.deletedAt)} = ${timestamp2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${sql.join(
+    UPDATE ${edges}
+    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} IN (${sql.join(
     params.ids.map((id) => sql`${id}`),
     sql`, `
   )})
-      AND ${edges2.deletedAt} IS NULL
+      AND ${edges.deletedAt} IS NULL
   `;
 }
-function buildHardDeleteEdgesBatch(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildHardDeleteEdgesBatch(tables, params) {
+  const { edges } = tables;
   return sql`
-    DELETE FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${sql.join(
+    DELETE FROM ${edges}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} IN (${sql.join(
     params.ids.map((id) => sql`${id}`),
     sql`, `
   )})
   `;
 }
-function buildHardDeleteEdge(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildHardDeleteEdge(tables, params) {
+  const { edges } = tables;
   return sql`
-    DELETE FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} = ${params.id}
+    DELETE FROM ${edges}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} = ${params.id}
   `;
 }
-function buildHardDeleteEdgesByNode(tables3, graphId, nodeKind, nodeId) {
-  const { edges: edges2 } = tables3;
+function buildHardDeleteEdgesByNode(tables, graphId, nodeKind, nodeId) {
+  const { edges } = tables;
   return sql`
-    DELETE FROM ${edges2}
-    WHERE ${edges2.graphId} = ${graphId}
+    DELETE FROM ${edges}
+    WHERE ${edges.graphId} = ${graphId}
       AND (
-        (${edges2.fromKind} = ${nodeKind} AND ${edges2.fromId} = ${nodeId})
-        OR (${edges2.toKind} = ${nodeKind} AND ${edges2.toId} = ${nodeId})
+        (${edges.fromKind} = ${nodeKind} AND ${edges.fromId} = ${nodeId})
+        OR (${edges.toKind} = ${nodeKind} AND ${edges.toId} = ${nodeId})
       )
   `;
 }
-function buildCountEdgesFrom(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildCountEdgesFrom(tables, params) {
+  const { edges } = tables;
   if (params.activeOnly) {
     return sql`
-      SELECT COUNT(*) as count FROM ${edges2}
-      WHERE ${edges2.graphId} = ${params.graphId}
-        AND ${edges2.kind} = ${params.edgeKind}
-        AND ${edges2.fromKind} = ${params.fromKind}
-        AND ${edges2.fromId} = ${params.fromId}
-        AND ${edges2.deletedAt} IS NULL
-        AND ${edges2.validTo} IS NULL
+      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
     `;
   }
   return sql`
-    SELECT COUNT(*) as count FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.kind} = ${params.edgeKind}
-      AND ${edges2.fromKind} = ${params.fromKind}
-      AND ${edges2.fromId} = ${params.fromId}
-      AND ${edges2.deletedAt} IS NULL
+    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
   `;
 }
-function buildEdgeExistsBetween(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildEdgeExistsBetween(tables, params) {
+  const { edges } = tables;
   return sql`
-    SELECT 1 FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.kind} = ${params.edgeKind}
-      AND ${edges2.fromKind} = ${params.fromKind}
-      AND ${edges2.fromId} = ${params.fromId}
-      AND ${edges2.toKind} = ${params.toKind}
-      AND ${edges2.toId} = ${params.toId}
-      AND ${edges2.deletedAt} IS NULL
+    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
     LIMIT 1
   `;
 }
-function buildFindEdgesConnectedTo(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildFindEdgesConnectedTo(tables, params) {
+  const { edges } = tables;
   return sql`
-    SELECT * FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.deletedAt} IS NULL
-      AND ${edges2.fromKind} = ${params.nodeKind}
-      AND ${edges2.fromId} = ${params.nodeId}
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.deletedAt} IS NULL
+      AND ${edges.fromKind} = ${params.nodeKind}
+      AND ${edges.fromId} = ${params.nodeId}
     UNION ALL
-    SELECT * FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.deletedAt} IS NULL
-      AND ${edges2.toKind} = ${params.nodeKind}
-      AND ${edges2.toId} = ${params.nodeId}
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.deletedAt} IS NULL
+      AND ${edges.toKind} = ${params.nodeKind}
+      AND ${edges.toId} = ${params.nodeId}
       AND NOT (
-        ${edges2.fromKind} = ${params.nodeKind}
-        AND ${edges2.fromId} = ${params.nodeId}
+        ${edges.fromKind} = ${params.nodeKind}
+        AND ${edges.fromId} = ${params.nodeId}
       )
   `;
 }
@@ -1715,136 +1131,136 @@ function assertValidSearchParams(params) {
     );
   }
 }
-function buildInsertNode(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
+function buildInsertNode(tables, params, timestamp) {
+  const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes2);
+  const columns = nodeColumnList(nodes);
   return sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
-      ${timestamp2}, ${timestamp2}
+      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}, ${sqlNull(params.validTo)},
+      ${timestamp}, ${timestamp}
     )
     RETURNING *
   `;
 }
-function buildInsertNodeNoReturn(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
+function buildInsertNodeNoReturn(tables, params, timestamp) {
+  const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes2);
+  const columns = nodeColumnList(nodes);
   return sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp2))}, ${sqlNull(params.validTo)},
-      ${timestamp2}, ${timestamp2}
+      1, ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}, ${sqlNull(params.validTo)},
+      ${timestamp}, ${timestamp}
     )
   `;
 }
-function buildInsertNodesBatch(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
-  const columns = nodeColumnList(nodes2);
+function buildInsertNodesBatch(tables, params, timestamp) {
+  const { nodes } = tables;
+  const columns = nodeColumnList(nodes);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES ${sql.join(values, sql`, `)}
   `;
 }
-function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
-  const columns = nodeColumnList(nodes2);
+function buildInsertNodesBatchReturning(tables, params, timestamp) {
+  const { nodes } = tables;
+  const columns = nodeColumnList(nodes);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES ${sql.join(values, sql`, `)}
     RETURNING *
   `;
 }
-function buildGetNode(tables3, graphId, kind, id) {
-  const { nodes: nodes2 } = tables3;
+function buildGetNode(tables, graphId, kind, id) {
+  const { nodes } = tables;
   return sql`
-    SELECT * FROM ${nodes2}
-    WHERE ${nodes2.graphId} = ${graphId}
-      AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} = ${id}
+    SELECT * FROM ${nodes}
+    WHERE ${nodes.graphId} = ${graphId}
+      AND ${nodes.kind} = ${kind}
+      AND ${nodes.id} = ${id}
   `;
 }
-function buildGetNodes(tables3, graphId, kind, ids) {
-  const { nodes: nodes2 } = tables3;
+function buildGetNodes(tables, graphId, kind, ids) {
+  const { nodes } = tables;
   return sql`
-    SELECT * FROM ${nodes2}
-    WHERE ${nodes2.graphId} = ${graphId}
-      AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${sql.join(
+    SELECT * FROM ${nodes}
+    WHERE ${nodes.graphId} = ${graphId}
+      AND ${nodes.kind} = ${kind}
+      AND ${nodes.id} IN (${sql.join(
     ids.map((id) => sql`${id}`),
     sql`, `
   )})
   `;
 }
-function buildUpdateNode(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
+function buildUpdateNode(tables, params, timestamp) {
+  const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    sql`${quotedColumn(nodes2.props)} = ${propsJson}`,
-    sql`${quotedColumn(nodes2.updatedAt)} = ${timestamp2}`
+    sql`${quotedColumn(nodes.props)} = ${propsJson}`,
+    sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      sql`${quotedColumn(nodes2.version)} = ${quotedColumn(nodes2.version)} + 1`
+      sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(sql`${quotedColumn(nodes2.validTo)} = ${params.validTo}`);
+    setParts.push(sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(sql`${quotedColumn(nodes2.deletedAt)} = NULL`);
+    setParts.push(sql`${quotedColumn(nodes.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
   if (params.clearDeleted) {
     return sql`
-      UPDATE ${nodes2}
+      UPDATE ${nodes}
       SET ${setClause}
-      WHERE ${nodes2.graphId} = ${params.graphId}
-        AND ${nodes2.kind} = ${params.kind}
-        AND ${nodes2.id} = ${params.id}
+      WHERE ${nodes.graphId} = ${params.graphId}
+        AND ${nodes.kind} = ${params.kind}
+        AND ${nodes.id} = ${params.id}
       RETURNING *
     `;
   }
   return sql`
-    UPDATE ${nodes2}
+    UPDATE ${nodes}
     SET ${setClause}
-    WHERE ${nodes2.graphId} = ${params.graphId}
-      AND ${nodes2.kind} = ${params.kind}
-      AND ${nodes2.id} = ${params.id}
-      AND ${nodes2.deletedAt} IS NULL
+    WHERE ${nodes.graphId} = ${params.graphId}
+      AND ${nodes.kind} = ${params.kind}
+      AND ${nodes.id} = ${params.id}
+      AND ${nodes.deletedAt} IS NULL
     RETURNING *
   `;
 }
-function buildDeleteNode(tables3, params, timestamp2) {
-  const { nodes: nodes2 } = tables3;
+function buildDeleteNode(tables, params, timestamp) {
+  const { nodes } = tables;
   return sql`
-    UPDATE ${nodes2}
-    SET ${quotedColumn(nodes2.deletedAt)} = ${timestamp2}
-    WHERE ${nodes2.graphId} = ${params.graphId}
-      AND ${nodes2.kind} = ${params.kind}
-      AND ${nodes2.id} = ${params.id}
-      AND ${nodes2.deletedAt} IS NULL
+    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
   `;
 }
-function buildHardDeleteNode(tables3, params) {
-  const { nodes: nodes2 } = tables3;
+function buildHardDeleteNode(tables, params) {
+  const { nodes } = tables;
   return sql`
-    DELETE FROM ${nodes2}
-    WHERE ${nodes2.graphId} = ${params.graphId}
-      AND ${nodes2.kind} = ${params.kind}
-      AND ${nodes2.id} = ${params.id}
+    DELETE FROM ${nodes}
+    WHERE ${nodes.graphId} = ${params.graphId}
+      AND ${nodes.kind} = ${params.kind}
+      AND ${nodes.id} = ${params.id}
   `;
 }
 function createSchemaDialectStrategy(dialect) {
@@ -1865,144 +1281,144 @@ var SCHEMA_DIALECT_STRATEGIES = {
   postgres: createSchemaDialectStrategy("postgres"),
   sqlite: createSchemaDialectStrategy("sqlite")
 };
-function buildInsertSchema(tables3, params, timestamp2, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions2 } = tables3;
+function buildInsertSchema(tables, params, timestamp, dialect = "sqlite") {
+  const { schemaVersions } = tables;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const schemaDocumentJson = JSON.stringify(params.schemaDoc);
   const isActiveValue = strategy.booleanLiteral(params.isActive);
   const columns = sql.raw(
-    `"${schemaVersions2.graphId.name}", "${schemaVersions2.version.name}", "${schemaVersions2.schemaHash.name}", "${schemaVersions2.schemaDoc.name}", "${schemaVersions2.createdAt.name}", "${schemaVersions2.isActive.name}"`
+    `"${schemaVersions.graphId.name}", "${schemaVersions.version.name}", "${schemaVersions.schemaHash.name}", "${schemaVersions.schemaDoc.name}", "${schemaVersions.createdAt.name}", "${schemaVersions.isActive.name}"`
   );
   return sql`
-    INSERT INTO ${schemaVersions2} (${columns})
+    INSERT INTO ${schemaVersions} (${columns})
     VALUES (
       ${params.graphId}, ${params.version},
       ${params.schemaHash}, ${schemaDocumentJson},
-      ${timestamp2}, ${isActiveValue}
+      ${timestamp}, ${isActiveValue}
     )
     RETURNING *
   `;
 }
-function buildGetActiveSchema(tables3, graphId, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions2 } = tables3;
+function buildGetActiveSchema(tables, graphId, dialect = "sqlite") {
+  const { schemaVersions } = tables;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   return sql`
-    SELECT * FROM ${schemaVersions2}
-    WHERE ${schemaVersions2.graphId} = ${graphId}
-      AND ${schemaVersions2.isActive} = ${strategy.booleanLiteral(true)}
+    SELECT * FROM ${schemaVersions}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+      AND ${schemaVersions.isActive} = ${strategy.booleanLiteral(true)}
   `;
 }
-function buildGetSchemaVersion(tables3, graphId, version) {
-  const { schemaVersions: schemaVersions2 } = tables3;
+function buildGetSchemaVersion(tables, graphId, version) {
+  const { schemaVersions } = tables;
   return sql`
-    SELECT * FROM ${schemaVersions2}
-    WHERE ${schemaVersions2.graphId} = ${graphId}
-      AND ${schemaVersions2.version} = ${version}
+    SELECT * FROM ${schemaVersions}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+      AND ${schemaVersions.version} = ${version}
   `;
 }
-function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
-  const { schemaVersions: schemaVersions2 } = tables3;
+function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
+  const { schemaVersions } = tables;
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = sql`
-    UPDATE ${schemaVersions2}
-    SET ${quotedColumn(schemaVersions2.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions2.graphId} = ${graphId}
+    UPDATE ${schemaVersions}
+    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
+    WHERE ${schemaVersions.graphId} = ${graphId}
   `;
   const activateVersion = sql`
-    UPDATE ${schemaVersions2}
-    SET ${quotedColumn(schemaVersions2.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions2.graphId} = ${graphId}
-      AND ${schemaVersions2.version} = ${version}
+    UPDATE ${schemaVersions}
+    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+      AND ${schemaVersions.version} = ${version}
   `;
   return { deactivateAll, activateVersion };
 }
-function buildInsertUniqueSqlite(tables3, params) {
-  const { uniques: uniques2 } = tables3;
+function buildInsertUniqueSqlite(tables, params) {
+  const { uniques } = tables;
   const columns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
   );
   return sql`
-    INSERT INTO ${uniques2} (${columns})
+    INSERT INTO ${uniques} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques2.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques2.nodeId)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques2.concreteKind)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques2.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques2.deletedAt)}
+      ${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)}
       END
-    RETURNING ${quotedColumn(uniques2.nodeId)} as node_id
+    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
   `;
 }
-function buildInsertUniquePostgres(tables3, params) {
-  const { uniques: uniques2 } = tables3;
+function buildInsertUniquePostgres(tables, params) {
+  const { uniques } = tables;
   const columns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
   );
-  const tableName = getTableName(uniques2);
+  const tableName = getTableName(uniques);
   const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
   return sql`
-    INSERT INTO ${uniques2} (${columns})
+    INSERT INTO ${uniques} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques2.nodeId)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques2.nodeId)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques2.concreteKind)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques2.deletedAt)}
+      ${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)}
       END
-    RETURNING ${quotedColumn(uniques2.nodeId)} as node_id
+    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
   postgres: buildInsertUniquePostgres,
   sqlite: buildInsertUniqueSqlite
 };
-function buildInsertUnique(tables3, dialect, params) {
+function buildInsertUnique(tables, dialect, params) {
   const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables3, params);
+  return builder(tables, params);
 }
-function buildInsertUniqueBatch(tables3, dialect, entries) {
-  const { uniques: uniques2 } = tables3;
+function buildInsertUniqueBatch(tables, dialect, entries) {
+  const { uniques } = tables;
   const columns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}", "${uniques2.nodeId.name}", "${uniques2.concreteKind.name}", "${uniques2.deletedAt.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
   );
   const conflictColumns = sql.raw(
-    `"${uniques2.graphId.name}", "${uniques2.nodeKind.name}", "${uniques2.constraintName.name}", "${uniques2.key.name}"`
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
   );
-  const tableName = getTableName(uniques2);
+  const tableName = getTableName(uniques);
   const existingColumn = (column) => {
     switch (dialect) {
       case "postgres": {
@@ -2024,102 +1440,102 @@ function buildInsertUniqueBatch(tables3, dialect, entries) {
     sql`, `
   );
   return sql`
-    INSERT INTO ${uniques2} (${columns})
+    INSERT INTO ${uniques} (${columns})
     VALUES ${valueRows}
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques2.nodeId)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN ${excludedColumn(uniques2.nodeId)}
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques2.nodeId)}
-        ELSE ${existingColumn(uniques2.nodeId)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN ${excludedColumn(uniques2.concreteKind)}
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques2.concreteKind)}
-        ELSE ${existingColumn(uniques2.concreteKind)}
+      ${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)}
       END,
-      ${quotedColumn(uniques2.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques2.nodeId)} = ${excludedColumn(uniques2.nodeId)} THEN NULL
-        WHEN ${existingColumn(uniques2.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques2.deletedAt)}
+      ${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)}
       END
     RETURNING
-      ${quotedColumn(uniques2.nodeKind)} as node_kind,
-      ${quotedColumn(uniques2.constraintName)} as constraint_name,
-      ${quotedColumn(uniques2.key)} as key,
-      ${quotedColumn(uniques2.nodeId)} as node_id
+      ${quotedColumn(uniques.nodeKind)} as node_kind,
+      ${quotedColumn(uniques.constraintName)} as constraint_name,
+      ${quotedColumn(uniques.key)} as key,
+      ${quotedColumn(uniques.nodeId)} as node_id
   `;
 }
-function buildDeleteUnique(tables3, params, timestamp2) {
-  const { uniques: uniques2 } = tables3;
+function buildDeleteUnique(tables, params, timestamp) {
+  const { uniques } = tables;
   return sql`
-    UPDATE ${uniques2}
-    SET ${quotedColumn(uniques2.deletedAt)} = ${timestamp2}
-    WHERE ${uniques2.graphId} = ${params.graphId}
-      AND ${uniques2.nodeKind} = ${params.nodeKind}
-      AND ${uniques2.constraintName} = ${params.constraintName}
-      AND ${uniques2.key} = ${params.key}
-      AND ${uniques2.deletedAt} IS NULL
+    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
   `;
 }
-function buildHardDeleteUniquesByNode(tables3, graphId, nodeId) {
-  const { uniques: uniques2 } = tables3;
+function buildHardDeleteUniquesByNode(tables, graphId, nodeId) {
+  const { uniques } = tables;
   return sql`
-    DELETE FROM ${uniques2}
-    WHERE ${uniques2.graphId} = ${graphId}
-      AND ${uniques2.nodeId} = ${nodeId}
+    DELETE FROM ${uniques}
+    WHERE ${uniques.graphId} = ${graphId}
+      AND ${uniques.nodeId} = ${nodeId}
   `;
 }
-function buildCheckUnique(tables3, params) {
-  const { uniques: uniques2 } = tables3;
+function buildCheckUnique(tables, params) {
+  const { uniques } = tables;
   if (params.includeDeleted) {
     return sql`
-      SELECT * FROM ${uniques2}
-      WHERE ${uniques2.graphId} = ${params.graphId}
-        AND ${uniques2.nodeKind} = ${params.nodeKind}
-        AND ${uniques2.constraintName} = ${params.constraintName}
-        AND ${uniques2.key} = ${params.key}
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} = ${params.key}
     `;
   }
   return sql`
-    SELECT * FROM ${uniques2}
-    WHERE ${uniques2.graphId} = ${params.graphId}
-      AND ${uniques2.nodeKind} = ${params.nodeKind}
-      AND ${uniques2.constraintName} = ${params.constraintName}
-      AND ${uniques2.key} = ${params.key}
-      AND ${uniques2.deletedAt} IS NULL
+    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
   `;
 }
-function buildCheckUniqueBatch(tables3, params) {
-  const { uniques: uniques2 } = tables3;
+function buildCheckUniqueBatch(tables, params) {
+  const { uniques } = tables;
   const keyPlaceholders = sql.join(
     params.keys.map((key) => sql`${key}`),
     sql`, `
   );
   if (params.includeDeleted) {
     return sql`
-      SELECT * FROM ${uniques2}
-      WHERE ${uniques2.graphId} = ${params.graphId}
-        AND ${uniques2.nodeKind} = ${params.nodeKind}
-        AND ${uniques2.constraintName} = ${params.constraintName}
-        AND ${uniques2.key} IN (${keyPlaceholders})
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} IN (${keyPlaceholders})
     `;
   }
   return sql`
-    SELECT * FROM ${uniques2}
-    WHERE ${uniques2.graphId} = ${params.graphId}
-      AND ${uniques2.nodeKind} = ${params.nodeKind}
-      AND ${uniques2.constraintName} = ${params.constraintName}
-      AND ${uniques2.key} IN (${keyPlaceholders})
-      AND ${uniques2.deletedAt} IS NULL
+    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
   `;
 }
 
 // src/backend/drizzle/operations/strategy.ts
-function bindTableOperationBuilders(tables3, builders) {
+function bindTableOperationBuilders(tables, builders) {
   const boundEntries = Object.entries(builders).map(([name, builder]) => {
     function boundBuilder(...args) {
-      return builder(tables3, ...args);
+      return builder(tables, ...args);
     }
     return [name, boundBuilder];
   });
@@ -2162,21 +1578,21 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCheckUniqueBatch,
   buildGetSchemaVersion
 };
-function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
+function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
   const tableOperations = bindTableOperationBuilders(
-    tables3,
+    tables,
     COMMON_TABLE_OPERATION_BUILDERS
   );
-  const fulltextTable = tables3.fulltextTableName;
+  const fulltextTable = tables.fulltextTableName;
   const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).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, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2).map((statement) => toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => toDrizzleSql(statement, dialect)),
     buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
@@ -2186,7 +1602,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
       params.candidates ?? liveNodeIdsSubquery(
-        tables3.nodes,
+        tables.nodes,
         params.graphId,
         params.nodeKind,
         nowIso()
@@ -2194,7 +1610,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
       const candidates = params.candidates ?? liveNodeIdsSubquery(
-        tables3.nodes,
+        tables.nodes,
         params.graphId,
         params.nodeKind,
         nowIso()
@@ -2222,7 +1638,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
-        nodes: tables3.nodes,
+        nodes: tables.nodes,
         dialect,
         graphId: params.graphId,
         nodeKind: params.nodeKind,
@@ -2238,19 +1654,19 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     ...tableOperations,
     ...fulltextBuilders,
     buildInsertUnique(params) {
-      return buildInsertUnique(tables3, dialect, params);
+      return buildInsertUnique(tables, dialect, params);
     },
     buildInsertUniqueBatch(entries) {
-      return buildInsertUniqueBatch(tables3, dialect, entries);
+      return buildInsertUniqueBatch(tables, dialect, entries);
     },
     buildGetActiveSchema(graphId) {
-      return buildGetActiveSchema(tables3, graphId, dialect);
+      return buildGetActiveSchema(tables, graphId, dialect);
     },
-    buildInsertSchema(params, timestamp2) {
-      return buildInsertSchema(tables3, params, timestamp2, dialect);
+    buildInsertSchema(params, timestamp) {
+      return buildInsertSchema(tables, params, timestamp, dialect);
     },
     buildSetActiveSchema(graphId, version) {
-      return buildSetActiveSchema(tables3, graphId, version, dialect);
+      return buildSetActiveSchema(tables, graphId, version, dialect);
     },
     buildTableExists(tableName) {
       switch (dialect) {
@@ -2273,7 +1689,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       }
     },
     buildClearGraph(graphId) {
-      return buildClearGraph(tables3, graphId);
+      return buildClearGraph(tables, graphId);
     }
   };
 }
@@ -2299,11 +1715,11 @@ function createCachedTableExistence(probe, options) {
     return exists;
   };
 }
-function createSqliteOperationStrategy(tables3, fulltextStrategy) {
-  return createCommonOperationStrategy(tables3, "sqlite", fulltextStrategy);
+function createSqliteOperationStrategy(tables, fulltextStrategy) {
+  return createCommonOperationStrategy(tables, "sqlite", fulltextStrategy);
 }
-function createPostgresOperationStrategy(tables3, fulltextStrategy) {
-  return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
+function createPostgresOperationStrategy(tables, fulltextStrategy) {
+  return createCommonOperationStrategy(tables, "postgres", fulltextStrategy);
 }
 var DRIZZLE_DIALECT_LABELS = {
   postgres: "Postgres",
@@ -2356,8 +1772,8 @@ function createCommonOperationBackend(options) {
       await execution.execRun(query);
     },
     async insertNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertNode(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildInsertNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
         throw new DatabaseOperationError(
@@ -2367,10 +1783,10 @@ function createCommonOperationBackend(options) {
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const query = operationStrategy.buildInsertNodeNoReturn(
         params,
-        timestamp2
+        timestamp
       );
       await execution.execRun(query);
     },
@@ -2378,9 +1794,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
         await execution.execRun(query);
       }
     },
@@ -2388,12 +1804,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatchReturning(
           chunk2,
-          timestamp2
+          timestamp
         );
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
@@ -2416,8 +1832,8 @@ function createCommonOperationBackend(options) {
       return allRows;
     },
     async updateNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildUpdateNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
         throw new DatabaseOperationError(
@@ -2427,8 +1843,8 @@ function createCommonOperationBackend(options) {
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildDeleteNode(params, timestamp);
       await execution.execRun(query);
     },
     // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
@@ -2464,8 +1880,8 @@ function createCommonOperationBackend(options) {
       await execution.execRun(query);
     },
     async insertEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildInsertEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
         throw new DatabaseOperationError(
@@ -2475,10 +1891,10 @@ function createCommonOperationBackend(options) {
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const query = operationStrategy.buildInsertEdgeNoReturn(
         params,
-        timestamp2
+        timestamp
       );
       await execution.execRun(query);
     },
@@ -2486,9 +1902,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
         await execution.execRun(query);
       }
     },
@@ -2496,12 +1912,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatchReturning(
           chunk2,
-          timestamp2
+          timestamp
         );
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
@@ -2524,8 +1940,8 @@ function createCommonOperationBackend(options) {
       return allRows;
     },
     async updateEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildUpdateEdge(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildUpdateEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
         throw new DatabaseOperationError(
@@ -2535,8 +1951,8 @@ function createCommonOperationBackend(options) {
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteEdge(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildDeleteEdge(params, timestamp);
       await execution.execRun(query);
     },
     async hardDeleteEdge(params) {
@@ -2545,7 +1961,7 @@ function createCommonOperationBackend(options) {
     },
     async deleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const softDeleteChunkSize = Math.max(
         1,
         batchConfig.getEdgesChunkSize - 1
@@ -2553,7 +1969,7 @@ function createCommonOperationBackend(options) {
       for (const chunk2 of chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
-          timestamp2
+          timestamp
         );
         await execution.execRun(query);
       }
@@ -2667,8 +2083,8 @@ function createCommonOperationBackend(options) {
       }
     },
     async deleteUnique(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteUnique(params, timestamp2);
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildDeleteUnique(params, timestamp);
       await execution.execRun(query);
     },
     async checkUnique(params) {
@@ -2745,7 +2161,7 @@ function createCommonOperationBackend(options) {
         );
         await execution.execRun(flip.deactivateAll);
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const insertQuery = operationStrategy.buildInsertSchema(
         {
           graphId: params.graphId,
@@ -2754,7 +2170,7 @@ function createCommonOperationBackend(options) {
           schemaDoc: params.schemaDoc,
           isActive: true
         },
-        timestamp2
+        timestamp
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
@@ -2931,8 +2347,8 @@ async function analyzeImportedTables(backend, tableNames) {
     )
   );
 }
-function resolvedValidFrom(validFrom, timestamp2) {
-  return validFrom === void 0 ? timestamp2 : validFrom;
+function resolvedValidFrom(validFrom, timestamp) {
+  return validFrom === void 0 ? timestamp : validFrom;
 }
 function postgresArray(values) {
   return `{${values.map(
@@ -2956,7 +2372,7 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
   return {
     async insertNodes(params) {
       if (params.length === 0) return;
-      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       await executePreparedRunBatch(
         nodeSql,
         params.map((item) => [
@@ -2964,16 +2380,16 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.kind,
           item.id,
           JSON.stringify(item.props),
-          resolvedValidFrom(item.validFrom, timestamp2),
+          resolvedValidFrom(item.validFrom, timestamp),
           item.validTo ?? DATABASE_NULL,
-          timestamp2,
-          timestamp2
+          timestamp,
+          timestamp
         ])
       );
     },
     async insertEdges(params) {
       if (params.length === 0) return;
-      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       await executePreparedRunBatch(
         edgeSql,
         params.map((item) => [
@@ -2985,10 +2401,10 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.toKind,
           item.toId,
           JSON.stringify(item.props),
-          resolvedValidFrom(item.validFrom, timestamp2),
+          resolvedValidFrom(item.validFrom, timestamp),
           item.validTo ?? DATABASE_NULL,
-          timestamp2,
-          timestamp2
+          timestamp,
+          timestamp
         ])
       );
     }
@@ -3018,22 +2434,22 @@ function createPostgresTrustedImportSession(backend, tableNames) {
   return {
     async insertNodes(params) {
       if (params.length === 0) return;
-      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       await executeRaw(nodeSql, [
         postgresArray(params.map((item) => item.graphId)),
         postgresArray(params.map((item) => item.kind)),
         postgresArray(params.map((item) => item.id)),
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
-          params.map((item) => resolvedValidFrom(item.validFrom, timestamp2))
+          params.map((item) => resolvedValidFrom(item.validFrom, timestamp))
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp2))
+        postgresArray(params.map(() => timestamp))
       ]);
     },
     async insertEdges(params) {
       if (params.length === 0) return;
-      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       await executeRaw(edgeSql, [
         postgresArray(params.map((item) => item.graphId)),
         postgresArray(params.map((item) => item.id)),
@@ -3044,10 +2460,10 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => item.toId)),
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
-          params.map((item) => resolvedValidFrom(item.validFrom, timestamp2))
+          params.map((item) => resolvedValidFrom(item.validFrom, timestamp))
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp2))
+        postgresArray(params.map(() => timestamp))
       ]);
     }
   };
@@ -3070,6 +2486,6 @@ function getOrCreateLru(cache, key, cacheMax, create) {
   return value;
 }
 
-export { EMBEDDING_UPSERT_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, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, restoreSecondaryIndexes, schemaVersions, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-G32AO634.js.map
-//# sourceMappingURL=chunk-G32AO634.js.map
+export { EMBEDDING_UPSERT_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, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, gateFulltext, gateFulltextMethods, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, restoreSecondaryIndexes, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-W66YCXWT.js.map
+//# sourceMappingURL=chunk-W66YCXWT.js.map