@nicia-ai/typegraph 0.38.0 → 0.40.0

package/dist/chunk-5J4VNCUD.js

@@ -0,0 +1,856 @@
+import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteSystemIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders } from './chunk-ZVME6OSV.js';
+import { assertNoSystemIndexNameCollision } from './chunk-AQVDAKXH.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-Y5UC3IXF.js';
+import { sql, is } from 'drizzle-orm';
+import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, bigint, index, boolean, uniqueIndex, 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, getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+
+var regconfig = customType({
+  dataType: () => "regconfig"
+});
+var tsvector = customType({
+  dataType: () => "tsvector"
+});
+
+// src/backend/drizzle/schema/postgres.ts
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges",
+  recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
+  uniques: "typegraph_node_uniques",
+  schemaVersions: "typegraph_schema_versions",
+  fulltext: "typegraph_node_fulltext",
+  indexMaterializations: "typegraph_index_materializations",
+  contributionMaterializations: "typegraph_contribution_materializations",
+  kindRemovals: "typegraph_kind_removals",
+  reconciliationMarkers: "typegraph_reconciliation_markers"
+};
+function createPostgresTables(names = {}, options = {}) {
+  const n = { ...DEFAULT_TABLE_NAMES, ...names };
+  const indexes = options.indexes ?? [];
+  assertNoSystemIndexNameCollision(indexes, n);
+  const 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 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 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,
+    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 ?? [];
+  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 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 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,
+    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 = 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 = 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})`);
+  }
+  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, 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-5J4VNCUD.js.map
+//# sourceMappingURL=chunk-5J4VNCUD.js.map