@nicia-ai/typegraph 0.39.0 → 0.41.0

package/dist/{chunk-Y6UA55YS.cjs → chunk-UDS5DZNY.cjs}

@@ -1,608 +1,24 @@
 'use strict';
 
-var chunkEOJFGECD_cjs = require('./chunk-EOJFGECD.cjs');
-var chunkE6TXEISH_cjs = require('./chunk-E6TXEISH.cjs');
-var chunkDOVMTPKE_cjs = require('./chunk-DOVMTPKE.cjs');
+var chunk7UTUKH4E_cjs = require('./chunk-7UTUKH4E.cjs');
+var chunkLLHMAHG4_cjs = require('./chunk-LLHMAHG4.cjs');
+var chunkSE422RES_cjs = require('./chunk-SE422RES.cjs');
 var chunkZDH3DX3C_cjs = require('./chunk-ZDH3DX3C.cjs');
-var chunkGNPGGLAE_cjs = require('./chunk-GNPGGLAE.cjs');
+var chunkQYDUCWD2_cjs = require('./chunk-QYDUCWD2.cjs');
 var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
 var chunkHP6LWBLB_cjs = require('./chunk-HP6LWBLB.cjs');
-var chunkGUUWKPTK_cjs = require('./chunk-GUUWKPTK.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkZKZAIX42_cjs = require('./chunk-ZKZAIX42.cjs');
-var chunkX6RDQ5NB_cjs = require('./chunk-X6RDQ5NB.cjs');
+var chunkYX3H63VV_cjs = require('./chunk-YX3H63VV.cjs');
 var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
 var chunkSAFZ6JTI_cjs = require('./chunk-SAFZ6JTI.cjs');
 var drizzleOrm = require('drizzle-orm');
-var pgCore = require('drizzle-orm/pg-core');
-var sqliteCore = require('drizzle-orm/sqlite-core');
-
-var regconfig = pgCore.customType({
-  dataType: () => "regconfig"
-});
-var tsvector = pgCore.customType({
-  dataType: () => "tsvector"
-});
-
-// src/backend/drizzle/schema/postgres.ts
-var DEFAULT_TABLE_NAMES = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  recordedNodes: "typegraph_recorded_nodes",
-  recordedEdges: "typegraph_recorded_edges",
-  recordedClock: "typegraph_recorded_clock",
-  revisionOrigins: "typegraph_revision_origins",
-  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 ?? [];
-  chunkGUUWKPTK_cjs.assertNoSystemIndexNameCollision(indexes, n);
-  const nodes2 = pgCore.pgTable(
-    n.nodes,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      kind: pgCore.text("kind").notNull(),
-      id: pgCore.text("id").notNull(),
-      props: pgCore.jsonb("props").notNull(),
-      version: pgCore.integer("version").notNull().default(1),
-      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
-      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
-      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
-      // for both dialects + the runtime materializer).
-      ...chunkDOVMTPKE_cjs.buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
-      ...chunkDOVMTPKE_cjs.buildPostgresNodeIndexBuilders(t, indexes)
-    ]
-  );
-  const edges2 = pgCore.pgTable(
-    n.edges,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      id: pgCore.text("id").notNull(),
-      kind: pgCore.text("kind").notNull(),
-      fromKind: pgCore.text("from_kind").notNull(),
-      fromId: pgCore.text("from_id").notNull(),
-      toKind: pgCore.text("to_kind").notNull(),
-      toId: pgCore.text("to_id").notNull(),
-      props: pgCore.jsonb("props").notNull(),
-      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
-      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.graphId, t.id] }),
-      ...chunkDOVMTPKE_cjs.buildPostgresSystemIndexBuilders("edges", n.edges, t),
-      ...chunkDOVMTPKE_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
-    ]
-  );
-  const recordedNodes2 = pgCore.pgTable(
-    n.recordedNodes,
-    {
-      historyId: pgCore.text("history_id").notNull(),
-      graphId: pgCore.text("graph_id").notNull(),
-      kind: pgCore.text("kind").notNull(),
-      id: pgCore.text("id").notNull(),
-      props: pgCore.jsonb("props").notNull(),
-      version: pgCore.integer("version").notNull(),
-      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
-      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: pgCore.timestamp("recorded_from", {
-        withTimezone: true
-      }).notNull(),
-      recordedTo: pgCore.timestamp("recorded_to", { withTimezone: true }).notNull(),
-      op: pgCore.text("op").notNull(),
-      schemaVersion: pgCore.integer("schema_version"),
-      txId: pgCore.text("tx_id"),
-      meta: pgCore.jsonb("meta")
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.historyId] }),
-      ...chunkDOVMTPKE_cjs.buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
-    ]
-  );
-  const recordedEdges2 = pgCore.pgTable(
-    n.recordedEdges,
-    {
-      historyId: pgCore.text("history_id").notNull(),
-      graphId: pgCore.text("graph_id").notNull(),
-      id: pgCore.text("id").notNull(),
-      kind: pgCore.text("kind").notNull(),
-      fromKind: pgCore.text("from_kind").notNull(),
-      fromId: pgCore.text("from_id").notNull(),
-      toKind: pgCore.text("to_kind").notNull(),
-      toId: pgCore.text("to_id").notNull(),
-      props: pgCore.jsonb("props").notNull(),
-      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
-      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: pgCore.timestamp("recorded_from", {
-        withTimezone: true
-      }).notNull(),
-      recordedTo: pgCore.timestamp("recorded_to", { withTimezone: true }).notNull(),
-      op: pgCore.text("op").notNull(),
-      schemaVersion: pgCore.integer("schema_version"),
-      txId: pgCore.text("tx_id"),
-      meta: pgCore.jsonb("meta")
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.historyId] }),
-      ...chunkDOVMTPKE_cjs.buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
-    ]
-  );
-  const recordedClock2 = pgCore.pgTable(
-    n.recordedClock,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      recordedAt: pgCore.timestamp("recorded_at", { withTimezone: true }).notNull()
-    },
-    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
-  );
-  const revisionOrigins = pgCore.pgTable(
-    n.revisionOrigins,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      origin: pgCore.text("origin").notNull()
-    },
-    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
-  );
-  const uniques2 = pgCore.pgTable(
-    n.uniques,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      nodeKind: pgCore.text("node_kind").notNull(),
-      constraintName: pgCore.text("constraint_name").notNull(),
-      key: pgCore.text("key").notNull(),
-      nodeId: pgCore.text("node_id").notNull(),
-      concreteKind: pgCore.text("concrete_kind").notNull(),
-      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      pgCore.primaryKey({
-        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
-      }),
-      pgCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
-    ]
-  );
-  const schemaVersions2 = pgCore.pgTable(
-    n.schemaVersions,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      version: pgCore.integer("version").notNull(),
-      schemaHash: pgCore.text("schema_hash").notNull(),
-      schemaDoc: pgCore.jsonb("schema_doc").notNull(),
-      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
-      isActive: pgCore.boolean("is_active").notNull().default(false)
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.graphId, t.version] }),
-      pgCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
-      // Partial unique index enforcing the "at most one active version
-      // per graph" invariant at the storage layer. Defense in depth
-      // against buggy backend implementations or out-of-band writes.
-      // Forces the deactivate-then-activate ordering used by
-      // `commitSchemaVersion` and `setActiveVersion`.
-      pgCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = TRUE`)
-    ]
-  );
-  const indexMaterializations = pgCore.pgTable(
-    n.indexMaterializations,
-    {
-      indexName: pgCore.text("index_name").notNull(),
-      graphId: pgCore.text("graph_id").notNull(),
-      entity: pgCore.text("entity").notNull(),
-      kind: pgCore.text("kind").notNull(),
-      signature: pgCore.text("signature").notNull(),
-      schemaVersion: pgCore.integer("schema_version").notNull(),
-      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
-      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: pgCore.text("last_error"),
-      // Cross-caller build claim: while `building_since` is fresh (within
-      // the lease), exactly one materializer owns this index's CREATE
-      // INDEX CONCURRENTLY. Serializes same-index CIC across processes —
-      // two concurrent expression-index CICs deadlock each other (no
-      // safe-snapshot exemption). NULL when no build is in flight.
-      buildingSince: pgCore.timestamp("building_since", { withTimezone: true }),
-      claimToken: pgCore.text("claim_token")
-    },
-    (t) => [pgCore.primaryKey({ columns: [t.indexName] })]
-  );
-  const kindRemovals = pgCore.pgTable(
-    n.kindRemovals,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      kindName: pgCore.text("kind_name").notNull(),
-      entity: pgCore.text("entity").notNull(),
-      schemaVersion: pgCore.integer("schema_version").notNull(),
-      removedAt: pgCore.timestamp("removed_at", { withTimezone: true }),
-      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: pgCore.text("last_error")
-    },
-    (t) => [
-      pgCore.primaryKey({
-        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
-      })
-    ]
-  );
-  const reconciliationMarkers = pgCore.pgTable(
-    n.reconciliationMarkers,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      reconciledToVersion: pgCore.integer("reconciled_to_version").notNull()
-    },
-    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
-  );
-  const contributionMaterializations = pgCore.pgTable(
-    n.contributionMaterializations,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      logicalName: pgCore.text("logical_name").notNull(),
-      owner: pgCore.text("owner").notNull(),
-      tableName: pgCore.text("table_name").notNull(),
-      signature: pgCore.text("signature").notNull(),
-      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
-      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: pgCore.text("last_error")
-    },
-    (t) => [
-      pgCore.primaryKey({
-        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
-      })
-    ]
-  );
-  const fulltext2 = pgCore.pgTable(
-    n.fulltext,
-    {
-      graphId: pgCore.text("graph_id").notNull(),
-      nodeKind: pgCore.text("node_kind").notNull(),
-      nodeId: pgCore.text("node_id").notNull(),
-      content: pgCore.text("content").notNull(),
-      language: regconfig("language").notNull(),
-      tsv: tsvector("tsv").generatedAlwaysAs(drizzleOrm.sql`to_tsvector("language", "content")`).notNull(),
-      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
-    },
-    (t) => [
-      pgCore.primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
-      pgCore.index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
-      pgCore.index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
-    ]
-  );
-  return {
-    nodes: 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 = sqliteCore.getTableConfig(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [
-      `"${column.name}"`,
-      getSqliteColumnType(column)
-    ];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  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 = sqliteCore.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 drizzleOrm.is(value, sqliteCore.SQLiteTable);
-}
-function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
-  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
-}
-function sqliteContributions(tables3 = chunkEOJFGECD_cjs.tables, fulltextStrategy = chunkZKZAIX42_cjs.fts5Strategy) {
-  const contributions = [];
-  for (const [key, table] of Object.entries(tables3)) {
-    if (!isSqliteTable(table)) continue;
-    contributions.push({
-      logicalName: key,
-      owner: chunkZKZAIX42_cjs.BASE_CONTRIBUTION_OWNER,
-      tableName: sqliteCore.getTableConfig(table).name,
-      createDdl: [
-        generateSqliteCreateTableSQL(table),
-        ...generateSqliteCreateIndexSQL(table)
-      ],
-      runtimeEnsure: false
-    });
-  }
-  for (const declared of fulltextStrategy.ownedTables(
-    tables3.fulltextTableName
-  )) {
-    contributions.push(declared);
-  }
-  return contributions;
-}
-function generateSqliteDDL(tables3 = chunkEOJFGECD_cjs.tables, fulltextStrategy = chunkZKZAIX42_cjs.fts5Strategy) {
-  return sqliteContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generateSqliteMigrationSQL(tables3 = chunkEOJFGECD_cjs.tables, fulltextStrategy = chunkZKZAIX42_cjs.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 = pgCore.getTableConfig(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [`"${column.name}"`, getPgColumnType(column)];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
-  ${columnDefs.join(",\n  ")}
-);`;
-}
-function generatePgCreateIndexSQL(table) {
-  const config = pgCore.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 method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
-    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `PostgreSQL index "${indexConfig.name}" WHERE clause`)}` : "";
-    statements.push(
-      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}"${method} (${columns})${where};`
-    );
-  }
-  return statements;
-}
-function isPgTable(value) {
-  return drizzleOrm.is(value, pgCore.PgTable);
-}
-function postgresContributions(tables3 = tables2, fulltextStrategy = chunkZKZAIX42_cjs.tsvectorStrategy) {
-  const contributions = [];
-  for (const [key, table] of Object.entries(tables3)) {
-    if (!isPgTable(table)) continue;
-    if (table === tables3.fulltext) continue;
-    contributions.push({
-      logicalName: key,
-      owner: chunkZKZAIX42_cjs.BASE_CONTRIBUTION_OWNER,
-      tableName: pgCore.getTableConfig(table).name,
-      createDdl: [
-        generatePgCreateTableSQL(table),
-        ...generatePgCreateIndexSQL(table)
-      ],
-      runtimeEnsure: false
-    });
-  }
-  for (const declared of fulltextStrategy.ownedTables(
-    tables3.fulltextTableName
-  )) {
-    contributions.push(declared);
-  }
-  return contributions;
-}
-function generatePostgresDDL(tables3 = tables2, fulltextStrategy = chunkZKZAIX42_cjs.tsvectorStrategy) {
-  return postgresContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = chunkZKZAIX42_cjs.tsvectorStrategy) {
-  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
-  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
-  return `${extensionSql}
-
-${ddlSql}`;
-}
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes2 = chunkX6RDQ5NB_cjs.sql.identifier(nodesTableName);
-  return chunkX6RDQ5NB_cjs.sql`
+  const nodes = chunkYX3H63VV_cjs.sql.identifier(nodesTableName);
+  return chunkYX3H63VV_cjs.sql`
     SELECT "id" AS node_id
-    FROM ${nodes2}
+    FROM ${nodes}
     WHERE "graph_id" = ${graphId}
       AND "kind" = ${nodeKind}
       AND "deleted_at" IS NULL
@@ -660,7 +76,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkE6TXEISH_cjs.formatPostgresTimestamp,
+  decode: chunk7UTUKH4E_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -774,7 +190,7 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunkGNPGGLAE_cjs.createBackendOverlay(
+  return chunkQYDUCWD2_cjs.createBackendOverlay(
     tx,
     gateFulltextMethods(tx, assert)
   );
@@ -797,7 +213,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;
     }
@@ -821,7 +237,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunkLLHMAHG4_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   async function materializeOne(graphId, contribution, signature, existing, options) {
     const force = options?.force === true;
@@ -843,13 +259,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature,
-        attemptedAt: chunkE6TXEISH_cjs.nowIso(),
+        attemptedAt: chunk7UTUKH4E_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkE6TXEISH_cjs.nowIso();
+    const attemptedAt = chunk7UTUKH4E_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -1030,7 +446,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkE6TXEISH_cjs.formatPostgresTimestamp,
+  decode: chunk7UTUKH4E_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -1088,7 +504,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkE6TXEISH_cjs.formatPostgresTimestamp,
+  decode: chunk7UTUKH4E_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -1132,9 +548,9 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
 function sqlNull(value) {
   return value ?? drizzleOrm.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 drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
@@ -1149,17 +565,17 @@ var CODE_POINT_ORDER_BUILDERS = {
 function codePointOrderKey(column, dialect) {
   return CODE_POINT_ORDER_BUILDERS[dialect](column);
 }
-function liveNodeIdsSubquery(nodes2, graphId, nodeKind, nowIso2) {
-  return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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}"`
   );
 }
 
@@ -1171,20 +587,20 @@ function hybridCandidatesRef() {
   return drizzleOrm.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 ? drizzleOrm.sql`score DESC, ${nodeIdOrder} ASC` : drizzleOrm.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 = drizzleOrm.sql.raw(
     columnPairs.map(
@@ -1237,17 +653,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 drizzleOrm.sql`tg_hybrid_node.${quotedColumn(nodes2[member])}`;
+function qualified(nodes, member) {
+  return drizzleOrm.sql`tg_hybrid_node.${quotedColumn(nodes[member])}`;
 }
 function present(value) {
   return value !== null && value !== void 0;
@@ -1255,57 +671,57 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkE6TXEISH_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunk7UTUKH4E_cjs.coerceNumericScore(row["fused_score"]),
     ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkE6TXEISH_cjs.coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: chunk7UTUKH4E_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkE6TXEISH_cjs.coerceNumericScore(
+      fulltextScore: chunk7UTUKH4E_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
     ...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: drizzleOrm.sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}` },
+    { query: drizzleOrm.sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}` },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables3.recordedEdges)
+      requiredTableName: drizzleOrm.getTableName(tables.recordedEdges)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables.recordedNodes} WHERE ${tables.recordedNodes.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables3.recordedNodes)
+      requiredTableName: drizzleOrm.getTableName(tables.recordedNodes)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
+      query: drizzleOrm.sql`DELETE FROM ${tables.recordedClock} WHERE ${tables.recordedClock.graphId} = ${graphId}`,
       ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables3.recordedClock)
+      requiredTableName: drizzleOrm.getTableName(tables.recordedClock)
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.indexMaterializations} WHERE ${tables.indexMaterializations.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.kindRemovals} WHERE ${tables.kindRemovals.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.reconciliationMarkers} WHERE ${tables.reconciliationMarkers.graphId} = ${graphId}`
     },
     {
-      query: drizzleOrm.sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
+      query: drizzleOrm.sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
     }
   ];
 }
@@ -1327,21 +743,21 @@ function buildTemporalConditions(table, params) {
   }
   return conditions;
 }
-function buildFindNodesByKind(tables3, params) {
-  const { nodes: nodes2 } = tables3;
+function buildFindNodesByKind(tables, params) {
+  const { nodes } = tables;
   const conditions = [
-    drizzleOrm.sql`${nodes2.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes2, params)
+    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes, params)
   ];
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${nodes2.id} > ${params.after}`);
+    conditions.push(drizzleOrm.sql`${nodes.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes2.id} ASC` : drizzleOrm.sql`${nodes2.createdAt} DESC, ${nodes2.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes.id} ASC` : drizzleOrm.sql`${nodes.createdAt} DESC, ${nodes.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes2}
+      SELECT * FROM ${nodes}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1349,58 +765,58 @@ function buildFindNodesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${nodes2}
+      SELECT * FROM ${nodes}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.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 = [
-    drizzleOrm.sql`${nodes2.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes2, params)
+    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
+    ...buildTemporalConditions(nodes, params)
   ];
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.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 = [
-    drizzleOrm.sql`${edges2.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges2, params)
+    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
   }
   if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.id} > ${params.after}`);
+    conditions.push(drizzleOrm.sql`${edges.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${edges2.id} ASC` : drizzleOrm.sql`${edges2.createdAt} DESC, ${edges2.id} DESC`;
+  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${edges.id} ASC` : drizzleOrm.sql`${edges.createdAt} DESC, ${edges.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges2}
+      SELECT * FROM ${edges}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
@@ -1408,254 +824,254 @@ function buildFindEdgesByKind(tables3, params) {
   }
   if (params.limit !== void 0) {
     return drizzleOrm.sql`
-      SELECT * FROM ${edges2}
+      SELECT * FROM ${edges}
       WHERE ${whereClause}
       ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.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 = [
-    drizzleOrm.sql`${edges2.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges2.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges2, params)
+    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
+    ...buildTemporalConditions(edges, params)
   ];
   if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.fromKind} = ${params.fromKind}`);
+    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
   }
   if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.fromId} = ${params.fromId}`);
+    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
   }
   if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.toKind} = ${params.toKind}`);
+    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
   }
   if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges2.toId} = ${params.toId}`);
+    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
   return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.sql`
-    INSERT INTO ${edges2} (${columns})
+    INSERT INTO ${edges} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
-function buildGetEdge(tables3, graphId, id) {
-  const { edges: edges2 } = tables3;
+function buildGetEdge(tables, graphId, id) {
+  const { edges } = tables;
   return drizzleOrm.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 drizzleOrm.sql`
-    SELECT * FROM ${edges2}
-    WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${drizzleOrm.sql.join(
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${graphId}
+      AND ${edges.id} IN (${drizzleOrm.sql.join(
     ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.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 = [
-    drizzleOrm.sql`${quotedColumn(edges2.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(edges2.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${quotedColumn(edges.props)} = ${propsJson}`,
+    drizzleOrm.sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges2.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges2.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(edges.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
     return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.sql`
-    UPDATE ${edges2}
-    SET ${quotedColumn(edges2.deletedAt)} = ${timestamp2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${drizzleOrm.sql.join(
+    UPDATE ${edges}
+    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} IN (${drizzleOrm.sql.join(
     params.ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.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 drizzleOrm.sql`
-    DELETE FROM ${edges2}
-    WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${drizzleOrm.sql.join(
+    DELETE FROM ${edges}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} IN (${drizzleOrm.sql.join(
     params.ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.sql`, `
   )})
   `;
 }
-function buildHardDeleteEdge(tables3, params) {
-  const { edges: edges2 } = tables3;
+function buildHardDeleteEdge(tables, params) {
+  const { edges } = tables;
   return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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}
       )
   `;
 }
@@ -1666,11 +1082,11 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
-  const matchCondition = chunkDOVMTPKE_cjs.toDrizzleSql(
+  const matchCondition = chunkSE422RES_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunkDOVMTPKE_cjs.toDrizzleSql(
+  const rankExpression = chunkSE422RES_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1683,10 +1099,10 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    const candidateSql = chunkX6RDQ5NB_cjs.isSqlFragment(candidates) ? chunkDOVMTPKE_cjs.toDrizzleSql(candidates, dialect) : candidates;
+    const candidateSql = chunkYX3H63VV_cjs.isSqlFragment(candidates) ? chunkSE422RES_cjs.toDrizzleSql(candidates, dialect) : candidates;
     conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
   }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkDOVMTPKE_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkSE422RES_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1717,136 +1133,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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.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 drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp2))}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(resolveValidFrom(nodeParams.validFrom, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
-    INSERT INTO ${nodes2} (${columns})
+    INSERT INTO ${nodes} (${columns})
     VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
     RETURNING *
   `;
 }
-function buildGetNode(tables3, graphId, kind, id) {
-  const { nodes: nodes2 } = tables3;
+function buildGetNode(tables, graphId, kind, id) {
+  const { nodes } = tables;
   return drizzleOrm.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 drizzleOrm.sql`
-    SELECT * FROM ${nodes2}
-    WHERE ${nodes2.graphId} = ${graphId}
-      AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${drizzleOrm.sql.join(
+    SELECT * FROM ${nodes}
+    WHERE ${nodes.graphId} = ${graphId}
+      AND ${nodes.kind} = ${kind}
+      AND ${nodes.id} IN (${drizzleOrm.sql.join(
     ids.map((id) => drizzleOrm.sql`${id}`),
     drizzleOrm.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 = [
-    drizzleOrm.sql`${quotedColumn(nodes2.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(nodes2.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${quotedColumn(nodes.props)} = ${propsJson}`,
+    drizzleOrm.sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes2.version)} = ${quotedColumn(nodes2.version)} + 1`
+      drizzleOrm.sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes2.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes2.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
     return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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) {
@@ -1867,144 +1283,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 = drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 = drizzleOrm.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 = drizzleOrm.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 = drizzleOrm.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 = drizzleOrm.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 drizzleOrm.sql`
-    INSERT INTO ${uniques2} (${columns})
+    INSERT INTO ${uniques} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(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 = drizzleOrm.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 = drizzleOrm.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 = drizzleOrm.getTableName(uniques2);
+  const tableName = drizzleOrm.getTableName(uniques);
   const existingColumn = (column) => drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
   return drizzleOrm.sql`
-    INSERT INTO ${uniques2} (${columns})
+    INSERT INTO ${uniques} (${columns})
     VALUES (
       ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
       ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(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 = drizzleOrm.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 = drizzleOrm.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 = drizzleOrm.getTableName(uniques2);
+  const tableName = drizzleOrm.getTableName(uniques);
   const existingColumn = (column) => {
     switch (dialect) {
       case "postgres": {
@@ -2026,102 +1442,102 @@ function buildInsertUniqueBatch(tables3, dialect, entries) {
     drizzleOrm.sql`, `
   );
   return drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 drizzleOrm.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 = drizzleOrm.sql.join(
     params.keys.map((key) => drizzleOrm.sql`${key}`),
     drizzleOrm.sql`, `
   );
   if (params.includeDeleted) {
     return drizzleOrm.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 drizzleOrm.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];
   });
@@ -2164,22 +1580,22 @@ 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) => chunkDOVMTPKE_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkDOVMTPKE_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunkSE422RES_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkSE422RES_cjs.toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }).map((statement) => chunkDOVMTPKE_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2).map((statement) => chunkDOVMTPKE_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkDOVMTPKE_cjs.toDrizzleSql(statement, dialect)),
+    }).map((statement) => chunkSE422RES_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkSE422RES_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkSE422RES_cjs.toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -2188,18 +1604,18 @@ 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,
-        chunkE6TXEISH_cjs.nowIso()
+        chunk7UTUKH4E_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
       const candidates = params.candidates ?? liveNodeIdsSubquery(
-        tables3.nodes,
+        tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkE6TXEISH_cjs.nowIso()
+        chunk7UTUKH4E_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -2220,11 +1636,11 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkX6RDQ5NB_cjs.isSqlFragment(candidates) ? chunkDOVMTPKE_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkYX3H63VV_cjs.isSqlFragment(candidates) ? chunkSE422RES_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
-        nodes: tables3.nodes,
+        nodes: tables.nodes,
         dialect,
         graphId: params.graphId,
         nodeKind: params.nodeKind,
@@ -2240,19 +1656,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) {
@@ -2275,7 +1691,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       }
     },
     buildClearGraph(graphId) {
-      return buildClearGraph(tables3, graphId);
+      return buildClearGraph(tables, graphId);
     }
   };
 }
@@ -2301,11 +1717,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",
@@ -2331,7 +1747,7 @@ function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
 }
 function createCommonOperationBackend(options) {
   const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? chunkE6TXEISH_cjs.nowIso;
+  const nowIso2 = options.nowIso ?? chunk7UTUKH4E_cjs.nowIso;
   const requiredClearTableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2358,8 +1774,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 chunkSAFZ6JTI_cjs.DatabaseOperationError(
@@ -2369,10 +1785,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);
     },
@@ -2380,9 +1796,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
         await execution.execRun(query);
       }
     },
@@ -2390,12 +1806,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const allRows = [];
       for (const chunk2 of chunkZDH3DX3C_cjs.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)));
@@ -2418,8 +1834,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 chunkSAFZ6JTI_cjs.DatabaseOperationError(
@@ -2429,8 +1845,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
@@ -2466,8 +1882,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 chunkSAFZ6JTI_cjs.DatabaseOperationError(
@@ -2477,10 +1893,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);
     },
@@ -2488,9 +1904,9 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return;
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
         await execution.execRun(query);
       }
     },
@@ -2498,12 +1914,12 @@ function createCommonOperationBackend(options) {
       if (params.length === 0) {
         return [];
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const allRows = [];
       for (const chunk2 of chunkZDH3DX3C_cjs.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)));
@@ -2526,8 +1942,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 chunkSAFZ6JTI_cjs.DatabaseOperationError(
@@ -2537,8 +1953,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) {
@@ -2547,7 +1963,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
@@ -2555,7 +1971,7 @@ function createCommonOperationBackend(options) {
       for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
-          timestamp2
+          timestamp
         );
         await execution.execRun(query);
       }
@@ -2669,8 +2085,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) {
@@ -2747,7 +2163,7 @@ function createCommonOperationBackend(options) {
         );
         await execution.execRun(flip.deactivateAll);
       }
-      const timestamp2 = nowIso2();
+      const timestamp = nowIso2();
       const insertQuery = operationStrategy.buildInsertSchema(
         {
           graphId: params.graphId,
@@ -2756,7 +2172,7 @@ function createCommonOperationBackend(options) {
           schemaDoc: params.schemaDoc,
           isActive: true
         },
-        timestamp2
+        timestamp
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
@@ -2853,8 +2269,8 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
 async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkX6RDQ5NB_cjs.asCompiledStatementSql(
-      chunkX6RDQ5NB_cjs.sql.raw(
+    chunkYX3H63VV_cjs.asCompiledStatementSql(
+      chunkYX3H63VV_cjs.sql.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -2874,8 +2290,8 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkX6RDQ5NB_cjs.asCompiledStatementSql(
-        chunkX6RDQ5NB_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkYX3H63VV_cjs.asCompiledStatementSql(
+        chunkYX3H63VV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2905,8 +2321,8 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkX6RDQ5NB_cjs.asCompiledStatementSql(
-        chunkX6RDQ5NB_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkYX3H63VV_cjs.asCompiledStatementSql(
+        chunkYX3H63VV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2916,25 +2332,25 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      chunkX6RDQ5NB_cjs.asCompiledStatementSql(chunkX6RDQ5NB_cjs.sql.raw(definition.index_definition))
+      chunkYX3H63VV_cjs.asCompiledStatementSql(chunkYX3H63VV_cjs.sql.raw(definition.index_definition))
     );
   }
 }
 async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkX6RDQ5NB_cjs.asCompiledStatementSql(
-      chunkX6RDQ5NB_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    chunkYX3H63VV_cjs.asCompiledStatementSql(
+      chunkYX3H63VV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
-    chunkX6RDQ5NB_cjs.asCompiledStatementSql(
-      chunkX6RDQ5NB_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    chunkYX3H63VV_cjs.asCompiledStatementSql(
+      chunkYX3H63VV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
-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(
@@ -2958,7 +2374,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) => [
@@ -2966,16 +2382,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) => [
@@ -2987,10 +2403,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
         ])
       );
     }
@@ -3020,22 +2436,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)),
@@ -3046,10 +2462,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))
       ]);
     }
   };
@@ -3093,20 +2509,11 @@ exports.createCachedTableExistence = createCachedTableExistence;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
-exports.createPostgresTables = createPostgresTables;
 exports.createPostgresTrustedImportSession = createPostgresTrustedImportSession;
 exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
 exports.createSqliteTrustedImportSession = createSqliteTrustedImportSession;
-exports.edges = edges;
-exports.fulltext = fulltext;
 exports.gateFulltext = gateFulltext;
 exports.gateFulltextMethods = gateFulltextMethods;
-exports.generatePgCreateTableSQL = generatePgCreateTableSQL;
-exports.generatePostgresDDL = generatePostgresDDL;
-exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
-exports.generateSqliteCreateTableSQL = generateSqliteCreateTableSQL;
-exports.generateSqliteDDL = generateSqliteDDL;
-exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
 exports.getOrCreateLru = getOrCreateLru;
 exports.lockPostgresTrustedImportTables = lockPostgresTrustedImportTables;
 exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
@@ -3114,18 +2521,11 @@ exports.mapHybridSearchRow = mapHybridSearchRow;
 exports.mapKindRemovalRow = mapKindRemovalRow;
 exports.mapMaterializationRow = mapMaterializationRow;
 exports.mapVectorWriteError = mapVectorWriteError;
-exports.nodes = nodes;
-exports.recordedClock = recordedClock;
-exports.recordedEdges = recordedEdges;
-exports.recordedNodes = recordedNodes;
 exports.restoreSecondaryIndexes = restoreSecondaryIndexes;
-exports.schemaVersions = schemaVersions;
 exports.suspendPostgresSecondaryIndexes = suspendPostgresSecondaryIndexes;
 exports.suspendSqliteSecondaryIndexes = suspendSqliteSecondaryIndexes;
-exports.tables = tables2;
-exports.uniques = uniques;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-Y6UA55YS.cjs.map
-//# sourceMappingURL=chunk-Y6UA55YS.cjs.map
+//# sourceMappingURL=chunk-UDS5DZNY.cjs.map
+//# sourceMappingURL=chunk-UDS5DZNY.cjs.map