@nicia-ai/typegraph 0.39.0 → 0.40.0

package/dist/chunk-LLHMAHG4.cjs

@@ -0,0 +1,886 @@
+'use strict';
+
+var chunkSE422RES_cjs = require('./chunk-SE422RES.cjs');
+var chunkLLE25NRD_cjs = require('./chunk-LLE25NRD.cjs');
+var chunkHAQVISUF_cjs = require('./chunk-HAQVISUF.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 ?? [];
+  chunkLLE25NRD_cjs.assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = pgCore.pgTable(
+    n.nodes,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      id: pgCore.text("id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      version: pgCore.integer("version").notNull().default(1),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...chunkSE422RES_cjs.buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
+      ...chunkSE422RES_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = pgCore.pgTable(
+    n.edges,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      fromKind: pgCore.text("from_kind").notNull(),
+      fromId: pgCore.text("from_id").notNull(),
+      toKind: pgCore.text("to_kind").notNull(),
+      toId: pgCore.text("to_id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.id] }),
+      ...chunkSE422RES_cjs.buildPostgresSystemIndexBuilders("edges", n.edges, t),
+      ...chunkSE422RES_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = pgCore.pgTable(
+    n.recordedNodes,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      id: pgCore.text("id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      version: pgCore.integer("version").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: pgCore.bigint("recorded_to", { mode: "number" }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkSE422RES_cjs.buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = pgCore.pgTable(
+    n.recordedEdges,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      fromKind: pgCore.text("from_kind").notNull(),
+      fromId: pgCore.text("from_id").notNull(),
+      toKind: pgCore.text("to_kind").notNull(),
+      toId: pgCore.text("to_id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.bigint("recorded_from", { mode: "number" }).notNull(),
+      recordedTo: pgCore.bigint("recorded_to", { mode: "number" }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkSE422RES_cjs.buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = pgCore.pgTable(
+    n.recordedClock,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      revision: pgCore.bigint("revision", { mode: "number" }).notNull(),
+      recordedAt: pgCore.timestamp("recorded_at", { withTimezone: true }).notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = pgCore.pgTable(
+    n.revisionOrigins,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      origin: pgCore.text("origin").notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const uniques3 = pgCore.pgTable(
+    n.uniques,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      constraintName: pgCore.text("constraint_name").notNull(),
+      key: pgCore.text("key").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      concreteKind: pgCore.text("concrete_kind").notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true })
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      pgCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const schemaVersions3 = pgCore.pgTable(
+    n.schemaVersions,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      version: pgCore.integer("version").notNull(),
+      schemaHash: pgCore.text("schema_hash").notNull(),
+      schemaDoc: pgCore.jsonb("schema_doc").notNull(),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      isActive: pgCore.boolean("is_active").notNull().default(false)
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.version] }),
+      pgCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      pgCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = TRUE`)
+    ]
+  );
+  const indexMaterializations = pgCore.pgTable(
+    n.indexMaterializations,
+    {
+      indexName: pgCore.text("index_name").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error"),
+      // Cross-caller build claim: while `building_since` is fresh (within
+      // the lease), exactly one materializer owns this index's CREATE
+      // INDEX CONCURRENTLY. Serializes same-index CIC across processes —
+      // two concurrent expression-index CICs deadlock each other (no
+      // safe-snapshot exemption). NULL when no build is in flight.
+      buildingSince: pgCore.timestamp("building_since", { withTimezone: true }),
+      claimToken: pgCore.text("claim_token")
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = pgCore.pgTable(
+    n.kindRemovals,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      kindName: pgCore.text("kind_name").notNull(),
+      entity: pgCore.text("entity").notNull(),
+      schemaVersion: pgCore.integer("schema_version").notNull(),
+      removedAt: pgCore.timestamp("removed_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = pgCore.pgTable(
+    n.reconciliationMarkers,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      reconciledToVersion: pgCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = pgCore.pgTable(
+    n.contributionMaterializations,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      logicalName: pgCore.text("logical_name").notNull(),
+      owner: pgCore.text("owner").notNull(),
+      tableName: pgCore.text("table_name").notNull(),
+      signature: pgCore.text("signature").notNull(),
+      materializedAt: pgCore.timestamp("materialized_at", { withTimezone: true }),
+      lastAttemptedAt: pgCore.timestamp("last_attempted_at", {
+        withTimezone: true
+      }).notNull(),
+      lastError: pgCore.text("last_error")
+    },
+    (t) => [
+      pgCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  const fulltext2 = pgCore.pgTable(
+    n.fulltext,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      nodeKind: pgCore.text("node_kind").notNull(),
+      nodeId: pgCore.text("node_id").notNull(),
+      content: pgCore.text("content").notNull(),
+      language: regconfig("language").notNull(),
+      tsv: tsvector("tsv").generatedAlwaysAs(drizzleOrm.sql`to_tsvector("language", "content")`).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.graphId, t.nodeKind, t.nodeId] }),
+      pgCore.index(`${n.fulltext}_tsv_idx`).using("gin", t.tsv),
+      pgCore.index(`${n.fulltext}_kind_idx`).on(t.graphId, t.nodeKind)
+    ]
+  );
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    recordedNodes: recordedNodes3,
+    recordedEdges: recordedEdges3,
+    recordedClock: recordedClock3,
+    revisionOrigins,
+    uniques: uniques3,
+    schemaVersions: schemaVersions3,
+    indexMaterializations,
+    contributionMaterializations,
+    kindRemovals,
+    reconciliationMarkers,
+    fulltext: fulltext2,
+    fulltextTableName: n.fulltext
+  };
+}
+var tables = createPostgresTables();
+var {
+  nodes,
+  edges,
+  recordedNodes,
+  recordedEdges,
+  recordedClock,
+  uniques,
+  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",
+  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 createSqliteTables(names = {}, options = {}) {
+  const n = { ...DEFAULT_TABLE_NAMES2, ...names };
+  const indexes = options.indexes ?? [];
+  chunkLLE25NRD_cjs.assertNoSystemIndexNameCollision(indexes, n);
+  const nodes3 = sqliteCore.sqliteTable(
+    n.nodes,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      version: sqliteCore.integer("version").notNull().default(1),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...chunkSE422RES_cjs.buildSqliteSystemIndexBuilders("nodes", n.nodes, t),
+      ...chunkSE422RES_cjs.buildSqliteNodeIndexBuilders(t, indexes)
+    ]
+  );
+  const edges3 = sqliteCore.sqliteTable(
+    n.edges,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      fromKind: sqliteCore.text("from_kind").notNull(),
+      fromId: sqliteCore.text("from_id").notNull(),
+      toKind: sqliteCore.text("to_kind").notNull(),
+      toId: sqliteCore.text("to_id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.id] }),
+      ...chunkSE422RES_cjs.buildSqliteSystemIndexBuilders("edges", n.edges, t),
+      ...chunkSE422RES_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
+    ]
+  );
+  const recordedNodes3 = sqliteCore.sqliteTable(
+    n.recordedNodes,
+    {
+      historyId: sqliteCore.text("history_id").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      version: sqliteCore.integer("version").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      recordedFrom: sqliteCore.integer("recorded_from").notNull(),
+      recordedTo: sqliteCore.integer("recorded_to").notNull(),
+      op: sqliteCore.text("op").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version"),
+      txId: sqliteCore.text("tx_id"),
+      meta: sqliteCore.text("meta")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkSE422RES_cjs.buildSqliteSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
+    ]
+  );
+  const recordedEdges3 = sqliteCore.sqliteTable(
+    n.recordedEdges,
+    {
+      historyId: sqliteCore.text("history_id").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      id: sqliteCore.text("id").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      fromKind: sqliteCore.text("from_kind").notNull(),
+      fromId: sqliteCore.text("from_id").notNull(),
+      toKind: sqliteCore.text("to_kind").notNull(),
+      toId: sqliteCore.text("to_id").notNull(),
+      props: sqliteCore.text("props").notNull(),
+      validFrom: sqliteCore.text("valid_from"),
+      validTo: sqliteCore.text("valid_to"),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      updatedAt: sqliteCore.text("updated_at").notNull(),
+      deletedAt: sqliteCore.text("deleted_at"),
+      recordedFrom: sqliteCore.integer("recorded_from").notNull(),
+      recordedTo: sqliteCore.integer("recorded_to").notNull(),
+      op: sqliteCore.text("op").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version"),
+      txId: sqliteCore.text("tx_id"),
+      meta: sqliteCore.text("meta")
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.historyId] }),
+      ...chunkSE422RES_cjs.buildSqliteSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
+    ]
+  );
+  const recordedClock3 = sqliteCore.sqliteTable(
+    n.recordedClock,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      revision: sqliteCore.integer("revision").notNull(),
+      recordedAt: sqliteCore.text("recorded_at").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const revisionOrigins = sqliteCore.sqliteTable(
+    n.revisionOrigins,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      origin: sqliteCore.text("origin").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const uniques3 = sqliteCore.sqliteTable(
+    n.uniques,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      nodeKind: sqliteCore.text("node_kind").notNull(),
+      constraintName: sqliteCore.text("constraint_name").notNull(),
+      key: sqliteCore.text("key").notNull(),
+      nodeId: sqliteCore.text("node_id").notNull(),
+      concreteKind: sqliteCore.text("concrete_kind").notNull(),
+      deletedAt: sqliteCore.text("deleted_at")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.nodeKind, t.constraintName, t.key]
+      }),
+      sqliteCore.index(`${n.uniques}_node_idx`).on(t.graphId, t.concreteKind, t.nodeId)
+    ]
+  );
+  const schemaVersions3 = sqliteCore.sqliteTable(
+    n.schemaVersions,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      version: sqliteCore.integer("version").notNull(),
+      schemaHash: sqliteCore.text("schema_hash").notNull(),
+      schemaDoc: sqliteCore.text("schema_doc").notNull(),
+      createdAt: sqliteCore.text("created_at").notNull(),
+      isActive: sqliteCore.integer("is_active", { mode: "boolean" }).notNull().default(false)
+    },
+    (t) => [
+      sqliteCore.primaryKey({ columns: [t.graphId, t.version] }),
+      sqliteCore.index(`${n.schemaVersions}_active_idx`).on(t.graphId, t.isActive),
+      // Partial unique index enforcing the "at most one active version
+      // per graph" invariant at the storage layer. Defense in depth
+      // against buggy backend implementations or out-of-band writes.
+      // Forces the deactivate-then-activate ordering used by
+      // `commitSchemaVersion` and `setActiveVersion`.
+      sqliteCore.uniqueIndex(`${n.schemaVersions}_one_active_per_graph_idx`).on(t.graphId).where(drizzleOrm.sql`${t.isActive} = 1`)
+    ]
+  );
+  const indexMaterializations = sqliteCore.sqliteTable(
+    n.indexMaterializations,
+    {
+      indexName: sqliteCore.text("index_name").notNull(),
+      graphId: sqliteCore.text("graph_id").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      kind: sqliteCore.text("kind").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.indexName] })]
+  );
+  const kindRemovals = sqliteCore.sqliteTable(
+    n.kindRemovals,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      kindName: sqliteCore.text("kind_name").notNull(),
+      entity: sqliteCore.text("entity").notNull(),
+      schemaVersion: sqliteCore.integer("schema_version").notNull(),
+      removedAt: sqliteCore.text("removed_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.kindName, t.entity, t.schemaVersion]
+      })
+    ]
+  );
+  const reconciliationMarkers = sqliteCore.sqliteTable(
+    n.reconciliationMarkers,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      reconciledToVersion: sqliteCore.integer("reconciled_to_version").notNull()
+    },
+    (t) => [sqliteCore.primaryKey({ columns: [t.graphId] })]
+  );
+  const contributionMaterializations = sqliteCore.sqliteTable(
+    n.contributionMaterializations,
+    {
+      graphId: sqliteCore.text("graph_id").notNull(),
+      logicalName: sqliteCore.text("logical_name").notNull(),
+      owner: sqliteCore.text("owner").notNull(),
+      tableName: sqliteCore.text("table_name").notNull(),
+      signature: sqliteCore.text("signature").notNull(),
+      materializedAt: sqliteCore.text("materialized_at"),
+      lastAttemptedAt: sqliteCore.text("last_attempted_at").notNull(),
+      lastError: sqliteCore.text("last_error")
+    },
+    (t) => [
+      sqliteCore.primaryKey({
+        columns: [t.graphId, t.logicalName, t.owner, t.tableName]
+      })
+    ]
+  );
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    recordedNodes: recordedNodes3,
+    recordedEdges: recordedEdges3,
+    recordedClock: recordedClock3,
+    revisionOrigins,
+    uniques: uniques3,
+    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,
+  schemaVersions: schemaVersions2
+} = tables2;
+function getSqliteColumnType(column) {
+  switch (column.columnType) {
+    case "SQLiteText": {
+      return "TEXT";
+    }
+    case "SQLiteInteger": {
+      return "INTEGER";
+    }
+    case "SQLiteReal": {
+      return "REAL";
+    }
+    case "SQLiteBlob": {
+      return "BLOB";
+    }
+    default: {
+      return "TEXT";
+    }
+  }
+}
+function formatDefaultValue(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return JSON.stringify(value);
+}
+function generateSqliteCreateTableSQL(table) {
+  const config = sqliteCore.getTableConfig(table);
+  const columnDefs = [];
+  for (const column of config.columns) {
+    const parts = [
+      `"${column.name}"`,
+      getSqliteColumnType(column)
+    ];
+    if (column.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (column.hasDefault && column.default !== void 0) {
+      parts.push(`DEFAULT ${formatDefaultValue(column.default)}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  const pk = config.primaryKeys[0];
+  if (pk) {
+    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
+  }
+  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 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 = sqliteCore.getTableConfig(table);
+  const statements = [];
+  for (const index3 of config.indexes) {
+    const indexConfig = index3.config;
+    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
+    const unique = indexConfig.unique ? "UNIQUE " : "";
+    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `SQLite index "${indexConfig.name}" WHERE clause`)}` : "";
+    statements.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}" (${columns})${where};`
+    );
+  }
+  return statements;
+}
+function isSqliteTable(value) {
+  return drizzleOrm.is(value, sqliteCore.SQLiteTable);
+}
+function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
+  return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
+}
+function sqliteContributions(tables3 = tables2, fulltextStrategy = chunkHAQVISUF_cjs.fts5Strategy) {
+  const contributions = [];
+  for (const [key, table] of Object.entries(tables3)) {
+    if (!isSqliteTable(table)) continue;
+    contributions.push({
+      logicalName: key,
+      owner: chunkHAQVISUF_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: sqliteCore.getTableConfig(table).name,
+      createDdl: [
+        generateSqliteCreateTableSQL(table),
+        ...generateSqliteCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
+  }
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
+  }
+  return contributions;
+}
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = chunkHAQVISUF_cjs.fts5Strategy) {
+  return sqliteContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = chunkHAQVISUF_cjs.fts5Strategy) {
+  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
+}
+function getPgColumnType(column) {
+  switch (column.columnType) {
+    case "PgText": {
+      return "TEXT";
+    }
+    case "PgInteger": {
+      return "INTEGER";
+    }
+    case "PgBigInt53":
+    case "PgBigInt64": {
+      return "BIGINT";
+    }
+    case "PgBoolean": {
+      return "BOOLEAN";
+    }
+    case "PgJsonb": {
+      return "JSONB";
+    }
+    case "PgTimestamp": {
+      return column.config?.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
+    }
+    case "PgReal": {
+      return "REAL";
+    }
+    case "PgDoublePrecision": {
+      return "DOUBLE PRECISION";
+    }
+    case "PgCustomColumn": {
+      const dataType = column.getSQLType?.();
+      return dataType ?? "TEXT";
+    }
+    default: {
+      return "TEXT";
+    }
+  }
+}
+function formatPgDefaultValue(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  return JSON.stringify(value);
+}
+function generatePgCreateTableSQL(table) {
+  const config = pgCore.getTableConfig(table);
+  const columnDefs = [];
+  for (const column of config.columns) {
+    const parts = [`"${column.name}"`, getPgColumnType(column)];
+    if (column.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (column.hasDefault && column.default !== void 0) {
+      parts.push(`DEFAULT ${formatPgDefaultValue(column.default)}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  const pk = config.primaryKeys[0];
+  if (pk) {
+    const pkColumns = pk.columns.map((c) => `"${c.name}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkColumns})`);
+  }
+  return `CREATE TABLE IF NOT EXISTS "${config.name}" (
+  ${columnDefs.join(",\n  ")}
+);`;
+}
+function generatePgCreateIndexSQL(table) {
+  const config = pgCore.getTableConfig(table);
+  const statements = [];
+  for (const index3 of config.indexes) {
+    const indexConfig = index3.config;
+    const columns = indexConfig.columns.map((c) => renderIndexColumn(c)).join(", ");
+    const unique = indexConfig.unique ? "UNIQUE " : "";
+    const method = indexConfig.method && indexConfig.method !== "btree" ? ` USING ${indexConfig.method}` : "";
+    const where = indexConfig.where ? ` WHERE ${inlineSqlOrThrow(indexConfig.where, `PostgreSQL index "${indexConfig.name}" WHERE clause`)}` : "";
+    statements.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${indexConfig.name}" ON "${config.name}"${method} (${columns})${where};`
+    );
+  }
+  return statements;
+}
+function isPgTable(value) {
+  return drizzleOrm.is(value, pgCore.PgTable);
+}
+function postgresContributions(tables3 = tables, fulltextStrategy = chunkHAQVISUF_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: chunkHAQVISUF_cjs.BASE_CONTRIBUTION_OWNER,
+      tableName: pgCore.getTableConfig(table).name,
+      createDdl: [
+        generatePgCreateTableSQL(table),
+        ...generatePgCreateIndexSQL(table)
+      ],
+      runtimeEnsure: false
+    });
+  }
+  for (const declared of fulltextStrategy.ownedTables(
+    tables3.fulltextTableName
+  )) {
+    contributions.push(declared);
+  }
+  return contributions;
+}
+function generatePostgresDDL(tables3 = tables, fulltextStrategy = chunkHAQVISUF_cjs.tsvectorStrategy) {
+  return postgresContributions(tables3, fulltextStrategy).flatMap(
+    (contribution) => [...contribution.createDdl]
+  );
+}
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = chunkHAQVISUF_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}`;
+}
+
+exports.LEGACY_EMBEDDINGS_TABLE_NAME = LEGACY_EMBEDDINGS_TABLE_NAME;
+exports.createPostgresTables = createPostgresTables;
+exports.createSqliteTables = createSqliteTables;
+exports.edges = edges;
+exports.edges2 = edges2;
+exports.fulltext = fulltext;
+exports.generatePgCreateTableSQL = generatePgCreateTableSQL;
+exports.generatePostgresDDL = generatePostgresDDL;
+exports.generatePostgresMigrationSQL = generatePostgresMigrationSQL;
+exports.generateSqliteCreateTableSQL = generateSqliteCreateTableSQL;
+exports.generateSqliteDDL = generateSqliteDDL;
+exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
+exports.nodes = nodes;
+exports.nodes2 = nodes2;
+exports.postgresContributions = postgresContributions;
+exports.recordedClock = recordedClock;
+exports.recordedClock2 = recordedClock2;
+exports.recordedEdges = recordedEdges;
+exports.recordedEdges2 = recordedEdges2;
+exports.recordedNodes = recordedNodes;
+exports.recordedNodes2 = recordedNodes2;
+exports.runtimeStrategyContributions = runtimeStrategyContributions;
+exports.schemaVersions = schemaVersions;
+exports.schemaVersions2 = schemaVersions2;
+exports.sqliteContributions = sqliteContributions;
+exports.tables = tables;
+exports.tables2 = tables2;
+exports.uniques = uniques;
+exports.uniques2 = uniques2;
+//# sourceMappingURL=chunk-LLHMAHG4.cjs.map
+//# sourceMappingURL=chunk-LLHMAHG4.cjs.map