@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/chunk-6LEOAIIB.js

@@ -1,1160 +0,0 @@
-import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteSystemIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders } from './chunk-V76FGHY3.js';
-import { assertNoSystemIndexNameCollision } from './chunk-H3XP6BAV.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-EDLKIQRI.js';
-import { sql, is } from 'drizzle-orm';
-import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, bigint, index, uniqueIndex, check, boolean, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
-import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, uniqueIndex as uniqueIndex$1, check as check$1, getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
-
-var regconfig = customType({
-  dataType: () => "regconfig"
-});
-var tsvector = customType({
-  dataType: () => "tsvector"
-});
-
-// src/backend/drizzle/schema/postgres.ts
-var DEFAULT_TABLE_NAMES = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  recordedNodes: "typegraph_recorded_nodes",
-  recordedEdges: "typegraph_recorded_edges",
-  recordedClock: "typegraph_recorded_clock",
-  revisionOrigins: "typegraph_revision_origins",
-  identityAssertions: "typegraph_identity_assertions",
-  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
-  identityClosure: "typegraph_identity_closure",
-  identitySeparation: "typegraph_identity_separation",
-  uniques: "typegraph_node_uniques",
-  edgeClaims: "typegraph_edge_claims",
-  schemaVersions: "typegraph_schema_versions",
-  fulltext: "typegraph_node_fulltext",
-  indexMaterializations: "typegraph_index_materializations",
-  contributionMaterializations: "typegraph_contribution_materializations",
-  kindRemovals: "typegraph_kind_removals",
-  reconciliationMarkers: "typegraph_reconciliation_markers"
-};
-function createPostgresTables(names = {}, options = {}) {
-  const n = { ...DEFAULT_TABLE_NAMES, ...names };
-  const indexes = options.indexes ?? [];
-  assertNoSystemIndexNameCollision(indexes, n);
-  const nodes3 = pgTable(
-    n.nodes,
-    {
-      graphId: text("graph_id").notNull(),
-      kind: text("kind").notNull(),
-      id: text("id").notNull(),
-      props: jsonb("props").notNull(),
-      version: integer("version").notNull().default(1),
-      validFrom: timestamp("valid_from", { withTimezone: true }),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.kind, t.id] }),
-      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
-      // for both dialects + the runtime materializer).
-      ...buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
-      ...buildPostgresNodeIndexBuilders(t, indexes)
-    ]
-  );
-  const edges3 = pgTable(
-    n.edges,
-    {
-      graphId: text("graph_id").notNull(),
-      id: text("id").notNull(),
-      kind: text("kind").notNull(),
-      fromKind: text("from_kind").notNull(),
-      fromId: text("from_id").notNull(),
-      toKind: text("to_kind").notNull(),
-      toId: text("to_id").notNull(),
-      props: jsonb("props").notNull(),
-      validFrom: timestamp("valid_from", { withTimezone: true }),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.id] }),
-      ...buildPostgresSystemIndexBuilders("edges", n.edges, t),
-      ...buildPostgresEdgeIndexBuilders(t, indexes)
-    ]
-  );
-  const recordedNodes3 = pgTable(
-    n.recordedNodes,
-    {
-      historyId: text("history_id").notNull(),
-      graphId: text("graph_id").notNull(),
-      kind: text("kind").notNull(),
-      id: text("id").notNull(),
-      props: jsonb("props").notNull(),
-      version: integer("version").notNull(),
-      validFrom: timestamp("valid_from", { withTimezone: true }),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
-      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
-      op: text("op").notNull(),
-      schemaVersion: integer("schema_version"),
-      txId: text("tx_id"),
-      meta: jsonb("meta")
-    },
-    (t) => [
-      primaryKey({ columns: [t.historyId] }),
-      ...buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
-    ]
-  );
-  const recordedEdges3 = pgTable(
-    n.recordedEdges,
-    {
-      historyId: text("history_id").notNull(),
-      graphId: text("graph_id").notNull(),
-      id: text("id").notNull(),
-      kind: text("kind").notNull(),
-      fromKind: text("from_kind").notNull(),
-      fromId: text("from_id").notNull(),
-      toKind: text("to_kind").notNull(),
-      toId: text("to_id").notNull(),
-      props: jsonb("props").notNull(),
-      validFrom: timestamp("valid_from", { withTimezone: true }),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
-      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
-      op: text("op").notNull(),
-      schemaVersion: integer("schema_version"),
-      txId: text("tx_id"),
-      meta: jsonb("meta")
-    },
-    (t) => [
-      primaryKey({ columns: [t.historyId] }),
-      ...buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
-    ]
-  );
-  const recordedClock3 = pgTable(
-    n.recordedClock,
-    {
-      graphId: text("graph_id").notNull(),
-      revision: bigint("revision", { mode: "number" }).notNull(),
-      recordedAt: timestamp("recorded_at", { withTimezone: true }).notNull()
-    },
-    (t) => [primaryKey({ columns: [t.graphId] })]
-  );
-  const revisionOrigins = pgTable(
-    n.revisionOrigins,
-    {
-      graphId: text("graph_id").notNull(),
-      origin: text("origin").notNull()
-    },
-    (t) => [primaryKey({ columns: [t.graphId] })]
-  );
-  const identityAssertions = pgTable(
-    n.identityAssertions,
-    {
-      graphId: text("graph_id").notNull(),
-      id: text("id").notNull(),
-      relation: text("rel").notNull(),
-      aKind: text("a_kind").notNull(),
-      aId: text("a_id").notNull(),
-      bKind: text("b_kind").notNull(),
-      bId: text("b_id").notNull(),
-      validFrom: timestamp("valid_from", { withTimezone: true }).notNull(),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      endedByKind: text("ended_by_kind"),
-      endedById: text("ended_by_id")
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.id] }),
-      index(`${n.identityAssertions}_a_idx`).on(
-        t.graphId,
-        t.aKind,
-        t.aId,
-        t.validTo
-      ),
-      index(`${n.identityAssertions}_b_idx`).on(
-        t.graphId,
-        t.bKind,
-        t.bId,
-        t.validTo
-      ),
-      uniqueIndex(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(sql`${t.validTo} IS NULL`),
-      check(
-        `${n.identityAssertions}_ended_by_check`,
-        sql`(ended_by_kind IS NULL) = (ended_by_id IS NULL) AND (ended_by_kind IS NULL OR (valid_to IS NOT NULL AND ((ended_by_kind = a_kind AND ended_by_id = a_id) OR (ended_by_kind = b_kind AND ended_by_id = b_id))))`
-      )
-    ]
-  );
-  const recordedIdentityAssertions = pgTable(
-    n.recordedIdentityAssertions,
-    {
-      historyId: text("history_id").notNull(),
-      graphId: text("graph_id").notNull(),
-      id: text("id").notNull(),
-      relation: text("rel").notNull(),
-      aKind: text("a_kind").notNull(),
-      aId: text("a_id").notNull(),
-      bKind: text("b_kind").notNull(),
-      bId: text("b_id").notNull(),
-      validFrom: timestamp("valid_from", { withTimezone: true }).notNull(),
-      validTo: timestamp("valid_to", { withTimezone: true }),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true }),
-      endedByKind: text("ended_by_kind"),
-      endedById: text("ended_by_id"),
-      recordedFrom: bigint("recorded_from", { mode: "number" }).notNull(),
-      recordedTo: bigint("recorded_to", { mode: "number" }).notNull(),
-      op: text("op").notNull(),
-      schemaVersion: integer("schema_version"),
-      txId: text("tx_id"),
-      meta: jsonb("meta")
-    },
-    (t) => [
-      primaryKey({ columns: [t.historyId] }),
-      index(`${n.recordedIdentityAssertions}_entity_idx`).on(
-        t.graphId,
-        t.id,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedIdentityAssertions}_a_idx`).on(
-        t.graphId,
-        t.aKind,
-        t.aId,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedIdentityAssertions}_b_idx`).on(
-        t.graphId,
-        t.bKind,
-        t.bId,
-        t.recordedFrom,
-        t.recordedTo
-      )
-    ]
-  );
-  const identityClosure = pgTable(
-    n.identityClosure,
-    {
-      graphId: text("graph_id").notNull(),
-      memberKind: text("member_kind").notNull(),
-      memberId: text("member_id").notNull(),
-      classKind: text("class_kind").notNull(),
-      classId: text("class_id").notNull()
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.memberKind, t.memberId] }),
-      index(`${n.identityClosure}_class_idx`).on(
-        t.graphId,
-        t.classKind,
-        t.classId
-      )
-    ]
-  );
-  const identitySeparation = pgTable(
-    n.identitySeparation,
-    {
-      graphId: text("graph_id").notNull(),
-      classKeyLow: text("class_key_low").notNull(),
-      classKeyHigh: text("class_key_high").notNull()
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
-      index(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
-      check(
-        `${n.identitySeparation}_ordered_pair_check`,
-        sql`class_key_low COLLATE "C" < class_key_high COLLATE "C"`
-      )
-    ]
-  );
-  const uniques3 = pgTable(
-    n.uniques,
-    {
-      graphId: text("graph_id").notNull(),
-      nodeKind: text("node_kind").notNull(),
-      constraintName: text("constraint_name").notNull(),
-      key: text("key").notNull(),
-      nodeId: text("node_id").notNull(),
-      concreteKind: text("concrete_kind").notNull(),
-      deletedAt: timestamp("deleted_at", { withTimezone: true })
-    },
-    (t) => [
-      primaryKey({
-        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
-      }),
-      index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
-    ]
-  );
-  const edgeClaims3 = pgTable(
-    n.edgeClaims,
-    {
-      graphId: text("graph_id").notNull(),
-      axis: text("axis").notNull(),
-      key: text("key").notNull(),
-      edgeId: text("edge_id").notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.axis, t.key] }),
-      index(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
-    ]
-  );
-  const schemaVersions3 = pgTable(
-    n.schemaVersions,
-    {
-      graphId: text("graph_id").notNull(),
-      version: integer("version").notNull(),
-      schemaHash: text("schema_hash").notNull(),
-      schemaDoc: jsonb("schema_doc").notNull(),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-      isActive: boolean("is_active").notNull().default(false)
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.version] }),
-      index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
-      // Partial unique index enforcing the "at most one active version
-      // per graph" invariant at the storage layer. Defense in depth
-      // against buggy backend implementations or out-of-band writes.
-      // Forces the deactivate-then-activate ordering used by
-      // `commitSchemaVersion` and `setActiveVersion`.
-      uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = TRUE`)
-    ]
-  );
-  const indexMaterializations = pgTable(
-    n.indexMaterializations,
-    {
-      indexName: text("index_name").notNull(),
-      graphId: text("graph_id").notNull(),
-      entity: text("entity").notNull(),
-      kind: text("kind").notNull(),
-      signature: text("signature").notNull(),
-      schemaVersion: integer("schema_version").notNull(),
-      materializedAt: timestamp("materialized_at", { withTimezone: true }),
-      lastAttemptedAt: timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: text("last_error"),
-      // Cross-caller build claim: while `building_since` is fresh (within
-      // the lease), exactly one materializer owns this index's CREATE
-      // INDEX CONCURRENTLY. Serializes same-index CIC across processes —
-      // two concurrent expression-index CICs deadlock each other (no
-      // safe-snapshot exemption). NULL when no build is in flight.
-      buildingSince: timestamp("building_since", { withTimezone: true }),
-      claimToken: text("claim_token")
-    },
-    (t) => [primaryKey({ columns: [t.indexName] })]
-  );
-  const kindRemovals = pgTable(
-    n.kindRemovals,
-    {
-      graphId: text("graph_id").notNull(),
-      kindName: text("kind_name").notNull(),
-      entity: text("entity").notNull(),
-      schemaVersion: integer("schema_version").notNull(),
-      removedAt: timestamp("removed_at", { withTimezone: true }),
-      lastAttemptedAt: timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: text("last_error")
-    },
-    (t) => [
-      primaryKey({
-        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
-      })
-    ]
-  );
-  const reconciliationMarkers = pgTable(
-    n.reconciliationMarkers,
-    {
-      graphId: text("graph_id").notNull(),
-      reconciledToVersion: integer("reconciled_to_version").notNull()
-    },
-    (t) => [primaryKey({ columns: [t.graphId] })]
-  );
-  const contributionMaterializations = pgTable(
-    n.contributionMaterializations,
-    {
-      graphId: text("graph_id").notNull(),
-      logicalName: text("logical_name").notNull(),
-      owner: text("owner").notNull(),
-      tableName: text("table_name").notNull(),
-      signature: text("signature").notNull(),
-      materializedAt: timestamp("materialized_at", { withTimezone: true }),
-      lastAttemptedAt: timestamp("last_attempted_at", {
-        withTimezone: true
-      }).notNull(),
-      lastError: text("last_error")
-    },
-    (t) => [
-      primaryKey({
-        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
-      })
-    ]
-  );
-  const fulltext2 = pgTable(
-    n.fulltext,
-    {
-      graphId: text("graph_id").notNull(),
-      nodeKind: text("node_kind").notNull(),
-      nodeId: text("node_id").notNull(),
-      content: text("content").notNull(),
-      language: regconfig("language").notNull(),
-      tsv: tsvector("tsv").generatedAlwaysAs(sql`to_tsvector("language", "content")`).notNull(),
-      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
-    },
-    (t) => [
-      primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
-      index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
-      index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
-    ]
-  );
-  return {
-    nodes: nodes3,
-    edges: edges3,
-    recordedNodes: recordedNodes3,
-    recordedEdges: recordedEdges3,
-    recordedClock: recordedClock3,
-    revisionOrigins,
-    identityAssertions,
-    recordedIdentityAssertions,
-    identityClosure,
-    identitySeparation,
-    uniques: uniques3,
-    edgeClaims: edgeClaims3,
-    schemaVersions: schemaVersions3,
-    indexMaterializations,
-    contributionMaterializations,
-    kindRemovals,
-    reconciliationMarkers,
-    fulltext: fulltext2,
-    fulltextTableName: n.fulltext
-  };
-}
-var tables = createPostgresTables();
-var {
-  nodes,
-  edges,
-  recordedNodes,
-  recordedEdges,
-  recordedClock,
-  uniques,
-  edgeClaims,
-  schemaVersions,
-  fulltext
-} = tables;
-var LEGACY_EMBEDDINGS_TABLE_NAME = "typegraph_node_embeddings";
-var DEFAULT_TABLE_NAMES2 = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  recordedNodes: "typegraph_recorded_nodes",
-  recordedEdges: "typegraph_recorded_edges",
-  recordedClock: "typegraph_recorded_clock",
-  revisionOrigins: "typegraph_revision_origins",
-  identityAssertions: "typegraph_identity_assertions",
-  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
-  identityClosure: "typegraph_identity_closure",
-  identitySeparation: "typegraph_identity_separation",
-  uniques: "typegraph_node_uniques",
-  edgeClaims: "typegraph_edge_claims",
-  schemaVersions: "typegraph_schema_versions",
-  fulltext: "typegraph_node_fulltext",
-  indexMaterializations: "typegraph_index_materializations",
-  contributionMaterializations: "typegraph_contribution_materializations",
-  kindRemovals: "typegraph_kind_removals",
-  reconciliationMarkers: "typegraph_reconciliation_markers"
-};
-function createSqliteTables(names = {}, options = {}) {
-  const n = { ...DEFAULT_TABLE_NAMES2, ...names };
-  const indexes = options.indexes ?? [];
-  assertNoSystemIndexNameCollision(indexes, n);
-  const nodes3 = sqliteTable(
-    n.nodes,
-    {
-      graphId: text$1("graph_id").notNull(),
-      kind: text$1("kind").notNull(),
-      id: text$1("id").notNull(),
-      props: text$1("props").notNull(),
-      version: integer$1("version").notNull().default(1),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.kind, t.id] }),
-      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
-      // for both dialects + the runtime materializer).
-      ...buildSqliteSystemIndexBuilders("nodes", n.nodes, t),
-      ...buildSqliteNodeIndexBuilders(t, indexes)
-    ]
-  );
-  const edges3 = sqliteTable(
-    n.edges,
-    {
-      graphId: text$1("graph_id").notNull(),
-      id: text$1("id").notNull(),
-      kind: text$1("kind").notNull(),
-      fromKind: text$1("from_kind").notNull(),
-      fromId: text$1("from_id").notNull(),
-      toKind: text$1("to_kind").notNull(),
-      toId: text$1("to_id").notNull(),
-      props: text$1("props").notNull(),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.id] }),
-      ...buildSqliteSystemIndexBuilders("edges", n.edges, t),
-      ...buildSqliteEdgeIndexBuilders(t, indexes)
-    ]
-  );
-  const recordedNodes3 = sqliteTable(
-    n.recordedNodes,
-    {
-      historyId: text$1("history_id").notNull(),
-      graphId: text$1("graph_id").notNull(),
-      kind: text$1("kind").notNull(),
-      id: text$1("id").notNull(),
-      props: text$1("props").notNull(),
-      version: integer$1("version").notNull(),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at"),
-      recordedFrom: integer$1("recorded_from").notNull(),
-      recordedTo: integer$1("recorded_to").notNull(),
-      op: text$1("op").notNull(),
-      schemaVersion: integer$1("schema_version"),
-      txId: text$1("tx_id"),
-      meta: text$1("meta")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.historyId] }),
-      ...buildSqliteSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
-    ]
-  );
-  const recordedEdges3 = sqliteTable(
-    n.recordedEdges,
-    {
-      historyId: text$1("history_id").notNull(),
-      graphId: text$1("graph_id").notNull(),
-      id: text$1("id").notNull(),
-      kind: text$1("kind").notNull(),
-      fromKind: text$1("from_kind").notNull(),
-      fromId: text$1("from_id").notNull(),
-      toKind: text$1("to_kind").notNull(),
-      toId: text$1("to_id").notNull(),
-      props: text$1("props").notNull(),
-      validFrom: text$1("valid_from"),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at"),
-      recordedFrom: integer$1("recorded_from").notNull(),
-      recordedTo: integer$1("recorded_to").notNull(),
-      op: text$1("op").notNull(),
-      schemaVersion: integer$1("schema_version"),
-      txId: text$1("tx_id"),
-      meta: text$1("meta")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.historyId] }),
-      ...buildSqliteSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
-    ]
-  );
-  const recordedClock3 = sqliteTable(
-    n.recordedClock,
-    {
-      graphId: text$1("graph_id").notNull(),
-      revision: integer$1("revision").notNull(),
-      recordedAt: text$1("recorded_at").notNull()
-    },
-    (t) => [primaryKey$1({ columns: [t.graphId] })]
-  );
-  const revisionOrigins = sqliteTable(
-    n.revisionOrigins,
-    {
-      graphId: text$1("graph_id").notNull(),
-      origin: text$1("origin").notNull()
-    },
-    (t) => [primaryKey$1({ columns: [t.graphId] })]
-  );
-  const identityAssertions = sqliteTable(
-    n.identityAssertions,
-    {
-      graphId: text$1("graph_id").notNull(),
-      id: text$1("id").notNull(),
-      relation: text$1("rel").notNull(),
-      aKind: text$1("a_kind").notNull(),
-      aId: text$1("a_id").notNull(),
-      bKind: text$1("b_kind").notNull(),
-      bId: text$1("b_id").notNull(),
-      validFrom: text$1("valid_from").notNull(),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at"),
-      endedByKind: text$1("ended_by_kind"),
-      endedById: text$1("ended_by_id")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.id] }),
-      index$1(`${n.identityAssertions}_a_idx`).on(
-        t.graphId,
-        t.aKind,
-        t.aId,
-        t.validTo
-      ),
-      index$1(`${n.identityAssertions}_b_idx`).on(
-        t.graphId,
-        t.bKind,
-        t.bId,
-        t.validTo
-      ),
-      uniqueIndex$1(`${n.identityAssertions}_current_pair_idx`).on(t.graphId, t.relation, t.aKind, t.aId, t.bKind, t.bId).where(sql`${t.validTo} IS NULL`),
-      check$1(
-        `${n.identityAssertions}_ended_by_check`,
-        sql`(ended_by_kind IS NULL) = (ended_by_id IS NULL) AND (ended_by_kind IS NULL OR (valid_to IS NOT NULL AND ((ended_by_kind = a_kind AND ended_by_id = a_id) OR (ended_by_kind = b_kind AND ended_by_id = b_id))))`
-      )
-    ]
-  );
-  const recordedIdentityAssertions = sqliteTable(
-    n.recordedIdentityAssertions,
-    {
-      historyId: text$1("history_id").notNull(),
-      graphId: text$1("graph_id").notNull(),
-      id: text$1("id").notNull(),
-      relation: text$1("rel").notNull(),
-      aKind: text$1("a_kind").notNull(),
-      aId: text$1("a_id").notNull(),
-      bKind: text$1("b_kind").notNull(),
-      bId: text$1("b_id").notNull(),
-      validFrom: text$1("valid_from").notNull(),
-      validTo: text$1("valid_to"),
-      createdAt: text$1("created_at").notNull(),
-      updatedAt: text$1("updated_at").notNull(),
-      deletedAt: text$1("deleted_at"),
-      endedByKind: text$1("ended_by_kind"),
-      endedById: text$1("ended_by_id"),
-      recordedFrom: integer$1("recorded_from").notNull(),
-      recordedTo: integer$1("recorded_to").notNull(),
-      op: text$1("op").notNull(),
-      schemaVersion: integer$1("schema_version"),
-      txId: text$1("tx_id"),
-      meta: text$1("meta")
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.historyId] }),
-      index$1(`${n.recordedIdentityAssertions}_entity_idx`).on(
-        t.graphId,
-        t.id,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index$1(`${n.recordedIdentityAssertions}_a_idx`).on(
-        t.graphId,
-        t.aKind,
-        t.aId,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index$1(`${n.recordedIdentityAssertions}_b_idx`).on(
-        t.graphId,
-        t.bKind,
-        t.bId,
-        t.recordedFrom,
-        t.recordedTo
-      )
-    ]
-  );
-  const identityClosure = sqliteTable(
-    n.identityClosure,
-    {
-      graphId: text$1("graph_id").notNull(),
-      memberKind: text$1("member_kind").notNull(),
-      memberId: text$1("member_id").notNull(),
-      classKind: text$1("class_kind").notNull(),
-      classId: text$1("class_id").notNull()
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.memberKind, t.memberId] }),
-      index$1(`${n.identityClosure}_class_idx`).on(
-        t.graphId,
-        t.classKind,
-        t.classId
-      )
-    ]
-  );
-  const identitySeparation = sqliteTable(
-    n.identitySeparation,
-    {
-      graphId: text$1("graph_id").notNull(),
-      classKeyLow: text$1("class_key_low").notNull(),
-      classKeyHigh: text$1("class_key_high").notNull()
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.classKeyLow, t.classKeyHigh] }),
-      index$1(`${n.identitySeparation}_high_idx`).on(t.graphId, t.classKeyHigh),
-      check$1(
-        `${n.identitySeparation}_ordered_pair_check`,
-        sql`class_key_low < class_key_high`
-      )
-    ]
-  );
-  const uniques3 = sqliteTable(
-    n.uniques,
-    {
-      graphId: text$1("graph_id").notNull(),
-      nodeKind: text$1("node_kind").notNull(),
-      constraintName: text$1("constraint_name").notNull(),
-      key: text$1("key").notNull(),
-      nodeId: text$1("node_id").notNull(),
-      concreteKind: text$1("concrete_kind").notNull(),
-      deletedAt: text$1("deleted_at")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
-      }),
-      index$1(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
-    ]
-  );
-  const edgeClaims3 = sqliteTable(
-    n.edgeClaims,
-    {
-      graphId: text$1("graph_id").notNull(),
-      axis: text$1("axis").notNull(),
-      key: text$1("key").notNull(),
-      edgeId: text$1("edge_id").notNull(),
-      updatedAt: text$1("updated_at").notNull()
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.axis, t.key] }),
-      index$1(`${n.edgeClaims}_edge_idx`).on(t.graphId, t.edgeId)
-    ]
-  );
-  const schemaVersions3 = sqliteTable(
-    n.schemaVersions,
-    {
-      graphId: text$1("graph_id").notNull(),
-      version: integer$1("version").notNull(),
-      schemaHash: text$1("schema_hash").notNull(),
-      schemaDoc: text$1("schema_doc").notNull(),
-      createdAt: text$1("created_at").notNull(),
-      isActive: integer$1("is_active", { mode: "boolean" }).notNull().default(false)
-    },
-    (t) => [
-      primaryKey$1({ columns: [t.graphId, t.version] }),
-      index$1(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
-      // Partial unique index enforcing the "at most one active version
-      // per graph" invariant at the storage layer. Defense in depth
-      // against buggy backend implementations or out-of-band writes.
-      // Forces the deactivate-then-activate ordering used by
-      // `commitSchemaVersion` and `setActiveVersion`.
-      uniqueIndex$1(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(sql`${t.isActive} = 1`)
-    ]
-  );
-  const indexMaterializations = sqliteTable(
-    n.indexMaterializations,
-    {
-      indexName: text$1("index_name").notNull(),
-      graphId: text$1("graph_id").notNull(),
-      entity: text$1("entity").notNull(),
-      kind: text$1("kind").notNull(),
-      signature: text$1("signature").notNull(),
-      schemaVersion: integer$1("schema_version").notNull(),
-      materializedAt: text$1("materialized_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [primaryKey$1({ columns: [t.indexName] })]
-  );
-  const kindRemovals = sqliteTable(
-    n.kindRemovals,
-    {
-      graphId: text$1("graph_id").notNull(),
-      kindName: text$1("kind_name").notNull(),
-      entity: text$1("entity").notNull(),
-      schemaVersion: integer$1("schema_version").notNull(),
-      removedAt: text$1("removed_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
-      })
-    ]
-  );
-  const reconciliationMarkers = sqliteTable(
-    n.reconciliationMarkers,
-    {
-      graphId: text$1("graph_id").notNull(),
-      reconciledToVersion: integer$1("reconciled_to_version").notNull()
-    },
-    (t) => [primaryKey$1({ columns: [t.graphId] })]
-  );
-  const contributionMaterializations = sqliteTable(
-    n.contributionMaterializations,
-    {
-      graphId: text$1("graph_id").notNull(),
-      logicalName: text$1("logical_name").notNull(),
-      owner: text$1("owner").notNull(),
-      tableName: text$1("table_name").notNull(),
-      signature: text$1("signature").notNull(),
-      materializedAt: text$1("materialized_at"),
-      lastAttemptedAt: text$1("last_attempted_at").notNull(),
-      lastError: text$1("last_error")
-    },
-    (t) => [
-      primaryKey$1({
-        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
-      })
-    ]
-  );
-  return {
-    nodes: nodes3,
-    edges: edges3,
-    recordedNodes: recordedNodes3,
-    recordedEdges: recordedEdges3,
-    recordedClock: recordedClock3,
-    revisionOrigins,
-    identityAssertions,
-    recordedIdentityAssertions,
-    identityClosure,
-    identitySeparation,
-    uniques: uniques3,
-    edgeClaims: edgeClaims3,
-    schemaVersions: schemaVersions3,
-    indexMaterializations,
-    contributionMaterializations,
-    kindRemovals,
-    reconciliationMarkers,
-    /**
-     * The fulltext storage is a FTS5 virtual table which Drizzle cannot
-     * represent. DDL is emitted as raw SQL and operations query it via
-     * `sql.raw()`.
-     */
-    fulltextTableName: n.fulltext
-  };
-}
-var tables2 = createSqliteTables();
-var {
-  nodes: nodes2,
-  edges: edges2,
-  recordedNodes: recordedNodes2,
-  recordedEdges: recordedEdges2,
-  recordedClock: recordedClock2,
-  uniques: uniques2,
-  edgeClaims: edgeClaims2,
-  schemaVersions: schemaVersions2
-} = tables2;
-function getSqliteColumnType(column) {
-  switch (column.columnType) {
-    case "SQLiteText": {
-      return "TEXT";
-    }
-    case "SQLiteInteger": {
-      return "INTEGER";
-    }
-    case "SQLiteReal": {
-      return "REAL";
-    }
-    case "SQLiteBlob": {
-      return "BLOB";
-    }
-    default: {
-      return "TEXT";
-    }
-  }
-}
-function formatDefaultValue(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  return JSON.stringify(value);
-}
-function generateSqliteCreateTableSQL(table) {
-  const config = getTableConfig(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [
-      `"${column.name}"`,
-      getSqliteColumnType(column)
-    ];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  columnDefs.push(...renderTableChecks(config.checks, config.name));
-  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
-  ${columnDefs.join(",\n  ")}
-);`;
-}
-function renderTableChecks(checks, tableName) {
-  return checks.map(
-    (check3) => `CONSTRAINT "${check3.name}" CHECK (${inlineSqlOrThrow(
-      check3.value,
-      `table "${tableName}" CHECK constraint "${check3.name}"`
-    )})`
-  );
-}
-function renderIndexColumn(col) {
-  if (col && typeof col === "object" && "name" in col) {
-    return `"${col.name}"`;
-  }
-  const sql3 = tryInlineSql(col);
-  if (sql3 !== void 0) {
-    return sql3;
-  }
-  return "unknown";
-}
-function tryInlineSql(value) {
-  if (value && typeof value === "object" && "getSQL" in value) {
-    const maybe = value;
-    if (typeof maybe.getSQL === "function") {
-      return inlineSql(maybe.getSQL());
-    }
-  }
-  return inlineSql(value);
-}
-function flattenSqlChunk(chunk) {
-  if (typeof chunk === "string") {
-    return chunk;
-  }
-  if (typeof chunk === "object" && chunk !== null) {
-    if ("name" in chunk && typeof chunk.name === "string") {
-      return `"${chunk.name}"`;
-    }
-    if ("value" in chunk) {
-      const value = chunk.value;
-      if (typeof value === "string") {
-        return value;
-      }
-      if (Array.isArray(value)) {
-        return value.map((part) => flattenSqlChunk(part)).join("");
-      }
-    }
-    if ("queryChunks" in chunk && Array.isArray(chunk.queryChunks)) {
-      return chunk.queryChunks.map((part) => flattenSqlChunk(part)).join("");
-    }
-    if ("getSQL" in chunk) {
-      const maybe = chunk;
-      if (typeof maybe.getSQL === "function") {
-        return flattenSqlChunk(maybe.getSQL());
-      }
-    }
-  }
-  throw new Error(`Unable to inline SQL chunk: ${String(chunk)}`);
-}
-function inlineSql(value) {
-  try {
-    return flattenSqlChunk(value);
-  } catch {
-    return void 0;
-  }
-}
-function inlineSqlOrThrow(value, context) {
-  const inlined = inlineSql(value);
-  if (inlined === void 0) {
-    throw new Error(`Unable to inline SQL for ${context}`);
-  }
-  return inlined;
-}
-function generateSqliteCreateIndexSQL(table) {
-  const config = getTableConfig(table);
-  const statements = [];
-  for (const index3 of config.indexes) {
-    const indexConfig = index3.config;
-    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
-    const unique = indexConfig.unique ? "UNIQUE " : "";
-    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `SQLite index "${indexConfig.name}" WHERE clause`)}` : "";
-    statements.push(
-      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}" (${columns})${where};`
-    );
-  }
-  return statements;
-}
-function isSqliteTable(value) {
-  return is(value, SQLiteTable);
-}
-function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
-  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
-}
-function sqliteContributions(tables3 = tables2, fulltextStrategy = fts5Strategy) {
-  const contributions = [];
-  for (const [key, table] of Object.entries(tables3)) {
-    if (!isSqliteTable(table)) continue;
-    contributions.push({
-      logicalName: key,
-      owner: BASE_CONTRIBUTION_OWNER,
-      tableName: getTableConfig(table).name,
-      createDdl: [
-        generateSqliteCreateTableSQL(table),
-        ...generateSqliteCreateIndexSQL(table)
-      ],
-      runtimeEnsure: false
-    });
-  }
-  for (const declared of fulltextStrategy.ownedTables(
-    tables3.fulltextTableName
-  )) {
-    contributions.push(declared);
-  }
-  return contributions;
-}
-function generateSqliteDDL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
-  return sqliteContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
-  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
-}
-function getPgColumnType(column) {
-  switch (column.columnType) {
-    case "PgText": {
-      return "TEXT";
-    }
-    case "PgInteger": {
-      return "INTEGER";
-    }
-    case "PgBigInt53":
-    case "PgBigInt64": {
-      return "BIGINT";
-    }
-    case "PgBoolean": {
-      return "BOOLEAN";
-    }
-    case "PgJsonb": {
-      return "JSONB";
-    }
-    case "PgTimestamp": {
-      return column.config?.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
-    }
-    case "PgReal": {
-      return "REAL";
-    }
-    case "PgDoublePrecision": {
-      return "DOUBLE PRECISION";
-    }
-    case "PgCustomColumn": {
-      const dataType = column.getSQLType?.();
-      return dataType ?? "TEXT";
-    }
-    default: {
-      return "TEXT";
-    }
-  }
-}
-function formatPgDefaultValue(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  return JSON.stringify(value);
-}
-function generatePgCreateTableSQL(table) {
-  const config = getTableConfig$1(table);
-  const columnDefs = [];
-  for (const column of config.columns) {
-    const parts = [`"${column.name}"`, getPgColumnType(column)];
-    if (column.notNull) {
-      parts.push("NOT NULL");
-    }
-    if (column.hasDefault && column.default !== void 0) {
-      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
-    }
-    columnDefs.push(parts.join(" "));
-  }
-  const pk = config.primaryKeys[0];
-  if (pk) {
-    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
-    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
-  }
-  columnDefs.push(...renderTableChecks(config.checks, config.name));
-  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
-  ${columnDefs.join(",\n  ")}
-);`;
-}
-function generatePgCreateIndexSQL(table) {
-  const config = getTableConfig$1(table);
-  const statements = [];
-  for (const index3 of config.indexes) {
-    const indexConfig = index3.config;
-    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
-    const unique = indexConfig.unique ? "UNIQUE " : "";
-    const method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
-    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `PostgreSQL index "${indexConfig.name}" WHERE clause`)}` : "";
-    statements.push(
-      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}"${method} (${columns})${where};`
-    );
-  }
-  return statements;
-}
-function isPgTable(value) {
-  return is(value, PgTable);
-}
-function postgresContributions(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
-  const contributions = [];
-  for (const [key, table] of Object.entries(tables3)) {
-    if (!isPgTable(table)) continue;
-    if (table === tables3.fulltext) continue;
-    contributions.push({
-      logicalName: key,
-      owner: BASE_CONTRIBUTION_OWNER,
-      tableName: getTableConfig$1(table).name,
-      createDdl: [
-        generatePgCreateTableSQL(table),
-        ...generatePgCreateIndexSQL(table)
-      ],
-      runtimeEnsure: false
-    });
-  }
-  for (const declared of fulltextStrategy.ownedTables(
-    tables3.fulltextTableName
-  )) {
-    contributions.push(declared);
-  }
-  return contributions;
-}
-function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
-  return postgresContributions(tables3, fulltextStrategy).flatMap(
-    (contribution) => [...contribution.createDdl]
-  );
-}
-function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
-  const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
-  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
-  return `${extensionSql}
-
-${ddlSql}`;
-}
-
-export { LEGACY_EMBEDDINGS_TABLE_NAME, createPostgresTables, createSqliteTables, edgeClaims, edgeClaims2, edges, edges2, fulltext, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, nodes, nodes2, postgresContributions, recordedClock, recordedClock2, recordedEdges, recordedEdges2, recordedNodes, recordedNodes2, runtimeStrategyContributions, schemaVersions, schemaVersions2, sqliteContributions, tables, tables2, uniques, uniques2 };
-//# sourceMappingURL=chunk-6LEOAIIB.js.map
-//# sourceMappingURL=chunk-6LEOAIIB.js.map