@nicia-ai/typegraph 0.35.0 → 0.37.0

package/dist/chunk-YTSN73ND.js

@@ -0,0 +1,212 @@
+import { shortHash, quoteIdentifier } from './chunk-EXU3RASM.js';
+
+// src/indexes/system.ts
+var SYSTEM_INDEX_DECLARATIONS = [
+  // ---------------------------------------------------------- nodes
+  { table: "nodes", suffix: "kind_idx", columns: ["graph_id", "kind"] },
+  // Listing shape: kind partition ordered by creation with the
+  // soft-delete column ahead of it so `deleted_at IS NULL` list queries
+  // stay index-served.
+  {
+    table: "nodes",
+    suffix: "kind_created_idx",
+    columns: ["graph_id", "kind", "deleted_at", "created_at"]
+  },
+  {
+    table: "nodes",
+    suffix: "deleted_idx",
+    columns: ["graph_id", "deleted_at"]
+  },
+  {
+    table: "nodes",
+    suffix: "valid_idx",
+    columns: ["graph_id", "valid_from", "valid_to"]
+  },
+  // Bare-id lookup: the primary key leads with `kind` (graph_id, kind,
+  // id), so a `WHERE graph_id = ? AND id = ?` probe that doesn't know the
+  // kind can't seek it — SQLite falls back to a graph_id-only scan of
+  // every node in the graph (~3M at LDBC SF1).
+  // `store.algorithms.degree`'s node-kind subquery does exactly that
+  // lookup (it resolves the seed's kind by id), so without this index
+  // degree is a full nodes scan (~95ms at SF1). See typegraph#280.
+  { table: "nodes", suffix: "id_idx", columns: ["graph_id", "id"] },
+  // ---------------------------------------------------------- edges
+  { table: "edges", suffix: "kind_idx", columns: ["graph_id", "kind"] },
+  // Directional traversal index (outgoing): supports endpoint lookups
+  // and extra filtering by edge kind / target kind. Includes every
+  // system column the compiled query's soft-delete/temporal-validity
+  // predicate touches (deleted_at, valid_from, valid_to), trailed by
+  // to_id — the compiled traversal join reads `n.id = e.to_id` for an
+  // outgoing traversal (standard-builders.ts), so without to_id here
+  // the join still fetches the edge's heap row for that one column
+  // even with the seek/predicate columns covered.
+  {
+    table: "edges",
+    suffix: "from_idx",
+    columns: [
+      "graph_id",
+      "from_kind",
+      "from_id",
+      "kind",
+      "to_kind",
+      "deleted_at",
+      "valid_from",
+      "valid_to",
+      "to_id"
+    ]
+  },
+  // Directional traversal index (incoming): mirrors from_idx for
+  // reverse traversals, trailed by from_id for the same reason
+  // (`n.id = e.from_id` for an incoming traversal).
+  {
+    table: "edges",
+    suffix: "to_idx",
+    columns: [
+      "graph_id",
+      "to_kind",
+      "to_id",
+      "kind",
+      "from_kind",
+      "deleted_at",
+      "valid_from",
+      "valid_to",
+      "from_id"
+    ]
+  },
+  {
+    table: "edges",
+    suffix: "kind_created_idx",
+    columns: ["graph_id", "kind", "deleted_at", "created_at"]
+  },
+  {
+    table: "edges",
+    suffix: "deleted_idx",
+    columns: ["graph_id", "deleted_at"]
+  },
+  {
+    table: "edges",
+    suffix: "valid_idx",
+    columns: ["graph_id", "valid_from", "valid_to"]
+  },
+  // Cardinality enforcement: the one-per-endpoint check probes for a
+  // currently-valid edge of a kind from a specific endpoint.
+  {
+    table: "edges",
+    suffix: "cardinality_idx",
+    columns: ["graph_id", "kind", "from_kind", "from_id", "valid_to"]
+  },
+  // ---------------------------------------------------------- recordedNodes
+  {
+    table: "recordedNodes",
+    suffix: "entity_idx",
+    columns: ["graph_id", "kind", "id", "recorded_from", "recorded_to"]
+  },
+  {
+    table: "recordedNodes",
+    suffix: "open_idx",
+    columns: ["graph_id", "recorded_to"]
+  },
+  {
+    table: "recordedNodes",
+    suffix: "valid_idx",
+    columns: ["graph_id", "valid_from", "valid_to"]
+  },
+  // Bare-id lookup parity with the live nodes table: recorded-pinned
+  // reads swap this relation in as the node source, and `entity_idx`
+  // leads with `kind`, so the same kind-by-bare-id probe (e.g.
+  // `degree()` at a recorded coordinate) would otherwise scan every
+  // historical version in the graph. See typegraph#280.
+  { table: "recordedNodes", suffix: "id_idx", columns: ["graph_id", "id"] },
+  // ---------------------------------------------------------- recordedEdges
+  {
+    table: "recordedEdges",
+    suffix: "entity_idx",
+    columns: ["graph_id", "kind", "id", "recorded_from", "recorded_to"]
+  },
+  {
+    table: "recordedEdges",
+    suffix: "open_idx",
+    columns: ["graph_id", "recorded_to"]
+  },
+  {
+    table: "recordedEdges",
+    suffix: "from_idx",
+    columns: [
+      "graph_id",
+      "from_kind",
+      "from_id",
+      "kind",
+      "to_kind",
+      "recorded_from",
+      "recorded_to"
+    ]
+  },
+  {
+    table: "recordedEdges",
+    suffix: "to_idx",
+    columns: [
+      "graph_id",
+      "to_kind",
+      "to_id",
+      "kind",
+      "from_kind",
+      "recorded_from",
+      "recorded_to"
+    ]
+  },
+  {
+    table: "recordedEdges",
+    suffix: "valid_idx",
+    columns: ["graph_id", "valid_from", "valid_to"]
+  }
+];
+var DEFAULT_SYSTEM_INDEX_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges"
+};
+function resolveSystemIndexTableName(table, overrides) {
+  return overrides?.[table] ?? DEFAULT_SYSTEM_INDEX_TABLE_NAMES[table];
+}
+var MAX_SQL_IDENTIFIER_LENGTH = 63;
+function systemIndexName(physicalTableName, suffix) {
+  const full = `${physicalTableName}_${suffix}`;
+  if (full.length <= MAX_SQL_IDENTIFIER_LENGTH) return full;
+  const hash = shortHash(JSON.stringify([physicalTableName, suffix]));
+  return `${full.slice(0, MAX_SQL_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;
+}
+function resolveSystemIndexNames(overrides) {
+  return new Set(
+    SYSTEM_INDEX_DECLARATIONS.map(
+      (declaration) => systemIndexName(
+        resolveSystemIndexTableName(declaration.table, overrides),
+        declaration.suffix
+      )
+    )
+  );
+}
+function assertNoSystemIndexNameCollision(indexes, overrides) {
+  if (indexes.length === 0) return;
+  const reserved = resolveSystemIndexNames(overrides);
+  for (const index of indexes) {
+    if (reserved.has(index.name)) {
+      throw new Error(
+        `Index name "${index.name}" collides with a TypeGraph system index. Choose a different name \u2014 system index names are reserved, and a same-named CREATE INDEX IF NOT EXISTS would silently no-op against the system index instead of creating the declared one.`
+      );
+    }
+  }
+}
+function generateSystemIndexDDL(declaration, physicalTableName, options) {
+  const name = quoteIdentifier(
+    systemIndexName(physicalTableName, declaration.suffix)
+  );
+  const table = quoteIdentifier(physicalTableName);
+  const columns = declaration.columns.map((column) => quoteIdentifier(column)).join(", ");
+  const concurrently = options.concurrent ? "CONCURRENTLY " : "";
+  return `CREATE INDEX ${concurrently}IF NOT EXISTS ${name} ON ${table} (${columns});`;
+}
+
+export { SYSTEM_INDEX_DECLARATIONS, assertNoSystemIndexNameCollision, generateSystemIndexDDL, resolveSystemIndexNames, resolveSystemIndexTableName, systemIndexName };
+//# sourceMappingURL=chunk-YTSN73ND.js.map
+//# sourceMappingURL=chunk-YTSN73ND.js.map

package/dist/chunk-YTSN73ND.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/indexes/system.ts"],"names":[],"mappings":"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","file":"chunk-YTSN73ND.js","sourcesContent":["/**\n * System-index declarations — the single source of truth for the plain\n * btree indexes TypeGraph ships on its own relations.\n *\n * Both dialect schema factories (`createSqliteTables` /\n * `createPostgresTables`) derive their Drizzle index builders from this\n * list, so the two dialects cannot drift, and\n * `materializeSystemIndexes()` derives the same indexes as runtime DDL so\n * an index added in a new library version reaches already-initialized\n * databases (bootstrap DDL only runs on first boot — see\n * `loadActiveSchemaWithBootstrap`).\n *\n * Scope: non-unique btree column indexes on the four graph relations,\n * where performance iteration actually happens. Primary keys, unique /\n * partial-unique constraints, and status-table indexes are structural —\n * they are created with their table and never retrofitted — and stay in\n * the schema files.\n *\n * Changing a declaration's shape under the same suffix is a signature\n * drift: `materializeSystemIndexes` reports `failed` for it until the\n * operator drops the old physical index. Rename (new suffix) instead,\n * exactly like graph-declared indexes. Two acknowledged limits of that\n * contract: on databases whose indexes were bootstrap-created (no status\n * rows) an in-place reshape is undetectable at runtime — the rename rule\n * is enforced by review and the parity tests; and a renamed suffix\n * strands the old physical index (the runner only adds). When the first\n * rename actually happens, add a retired-suffixes list + drop path here.\n */\nimport { quoteIdentifier, shortHash } from \"../query/dialect/vector-strategy\";\n\n/** The TypeGraph relations that carry system indexes. */\nexport type SystemIndexTable =\n  \"nodes\" | \"edges\" | \"recordedNodes\" | \"recordedEdges\";\n\ntype LiveColumn =\n  | \"graph_id\"\n  | \"kind\"\n  | \"id\"\n  | \"deleted_at\"\n  | \"valid_from\"\n  | \"valid_to\"\n  | \"created_at\";\n\ntype LiveEdgeColumn =\n  LiveColumn | \"from_kind\" | \"from_id\" | \"to_kind\" | \"to_id\";\n\ntype RecordedColumn =\n  | \"graph_id\"\n  | \"kind\"\n  | \"id\"\n  | \"valid_from\"\n  | \"valid_to\"\n  | \"recorded_from\"\n  | \"recorded_to\";\n\ntype RecordedEdgeColumn =\n  RecordedColumn | \"from_kind\" | \"from_id\" | \"to_kind\" | \"to_id\";\n\ntype SystemIndexColumnsFor<T extends SystemIndexTable> =\n  T extends \"nodes\" ? LiveColumn\n  : T extends \"edges\" ? LiveEdgeColumn\n  : T extends \"recordedNodes\" ? RecordedColumn\n  : RecordedEdgeColumn;\n\ntype SystemIndexDeclarationFor<T extends SystemIndexTable> = Readonly<{\n  table: T;\n  /** Physical index name is `${physicalTableName}_${suffix}`. */\n  suffix: string;\n  columns: readonly [SystemIndexColumnsFor<T>, ...SystemIndexColumnsFor<T>[]];\n}>;\n\nexport type SystemIndexDeclaration =\n  | SystemIndexDeclarationFor<\"nodes\">\n  | SystemIndexDeclarationFor<\"edges\">\n  | SystemIndexDeclarationFor<\"recordedNodes\">\n  | SystemIndexDeclarationFor<\"recordedEdges\">;\n\nexport const SYSTEM_INDEX_DECLARATIONS: readonly SystemIndexDeclaration[] = [\n  // ---------------------------------------------------------- nodes\n  { table: \"nodes\", suffix: \"kind_idx\", columns: [\"graph_id\", \"kind\"] },\n  // Listing shape: kind partition ordered by creation with the\n  // soft-delete column ahead of it so `deleted_at IS NULL` list queries\n  // stay index-served.\n  {\n    table: \"nodes\",\n    suffix: \"kind_created_idx\",\n    columns: [\"graph_id\", \"kind\", \"deleted_at\", \"created_at\"],\n  },\n  {\n    table: \"nodes\",\n    suffix: \"deleted_idx\",\n    columns: [\"graph_id\", \"deleted_at\"],\n  },\n  {\n    table: \"nodes\",\n    suffix: \"valid_idx\",\n    columns: [\"graph_id\", \"valid_from\", \"valid_to\"],\n  },\n  // Bare-id lookup: the primary key leads with `kind` (graph_id, kind,\n  // id), so a `WHERE graph_id = ? AND id = ?` probe that doesn't know the\n  // kind can't seek it — SQLite falls back to a graph_id-only scan of\n  // every node in the graph (~3M at LDBC SF1).\n  // `store.algorithms.degree`'s node-kind subquery does exactly that\n  // lookup (it resolves the seed's kind by id), so without this index\n  // degree is a full nodes scan (~95ms at SF1). See typegraph#280.\n  { table: \"nodes\", suffix: \"id_idx\", columns: [\"graph_id\", \"id\"] },\n\n  // ---------------------------------------------------------- edges\n  { table: \"edges\", suffix: \"kind_idx\", columns: [\"graph_id\", \"kind\"] },\n  // Directional traversal index (outgoing): supports endpoint lookups\n  // and extra filtering by edge kind / target kind. Includes every\n  // system column the compiled query's soft-delete/temporal-validity\n  // predicate touches (deleted_at, valid_from, valid_to), trailed by\n  // to_id — the compiled traversal join reads `n.id = e.to_id` for an\n  // outgoing traversal (standard-builders.ts), so without to_id here\n  // the join still fetches the edge's heap row for that one column\n  // even with the seek/predicate columns covered.\n  {\n    table: \"edges\",\n    suffix: \"from_idx\",\n    columns: [\n      \"graph_id\",\n      \"from_kind\",\n      \"from_id\",\n      \"kind\",\n      \"to_kind\",\n      \"deleted_at\",\n      \"valid_from\",\n      \"valid_to\",\n      \"to_id\",\n    ],\n  },\n  // Directional traversal index (incoming): mirrors from_idx for\n  // reverse traversals, trailed by from_id for the same reason\n  // (`n.id = e.from_id` for an incoming traversal).\n  {\n    table: \"edges\",\n    suffix: \"to_idx\",\n    columns: [\n      \"graph_id\",\n      \"to_kind\",\n      \"to_id\",\n      \"kind\",\n      \"from_kind\",\n      \"deleted_at\",\n      \"valid_from\",\n      \"valid_to\",\n      \"from_id\",\n    ],\n  },\n  {\n    table: \"edges\",\n    suffix: \"kind_created_idx\",\n    columns: [\"graph_id\", \"kind\", \"deleted_at\", \"created_at\"],\n  },\n  {\n    table: \"edges\",\n    suffix: \"deleted_idx\",\n    columns: [\"graph_id\", \"deleted_at\"],\n  },\n  {\n    table: \"edges\",\n    suffix: \"valid_idx\",\n    columns: [\"graph_id\", \"valid_from\", \"valid_to\"],\n  },\n  // Cardinality enforcement: the one-per-endpoint check probes for a\n  // currently-valid edge of a kind from a specific endpoint.\n  {\n    table: \"edges\",\n    suffix: \"cardinality_idx\",\n    columns: [\"graph_id\", \"kind\", \"from_kind\", \"from_id\", \"valid_to\"],\n  },\n\n  // ---------------------------------------------------------- recordedNodes\n  {\n    table: \"recordedNodes\",\n    suffix: \"entity_idx\",\n    columns: [\"graph_id\", \"kind\", \"id\", \"recorded_from\", \"recorded_to\"],\n  },\n  {\n    table: \"recordedNodes\",\n    suffix: \"open_idx\",\n    columns: [\"graph_id\", \"recorded_to\"],\n  },\n  {\n    table: \"recordedNodes\",\n    suffix: \"valid_idx\",\n    columns: [\"graph_id\", \"valid_from\", \"valid_to\"],\n  },\n  // Bare-id lookup parity with the live nodes table: recorded-pinned\n  // reads swap this relation in as the node source, and `entity_idx`\n  // leads with `kind`, so the same kind-by-bare-id probe (e.g.\n  // `degree()` at a recorded coordinate) would otherwise scan every\n  // historical version in the graph. See typegraph#280.\n  { table: \"recordedNodes\", suffix: \"id_idx\", columns: [\"graph_id\", \"id\"] },\n\n  // ---------------------------------------------------------- recordedEdges\n  {\n    table: \"recordedEdges\",\n    suffix: \"entity_idx\",\n    columns: [\"graph_id\", \"kind\", \"id\", \"recorded_from\", \"recorded_to\"],\n  },\n  {\n    table: \"recordedEdges\",\n    suffix: \"open_idx\",\n    columns: [\"graph_id\", \"recorded_to\"],\n  },\n  {\n    table: \"recordedEdges\",\n    suffix: \"from_idx\",\n    columns: [\n      \"graph_id\",\n      \"from_kind\",\n      \"from_id\",\n      \"kind\",\n      \"to_kind\",\n      \"recorded_from\",\n      \"recorded_to\",\n    ],\n  },\n  {\n    table: \"recordedEdges\",\n    suffix: \"to_idx\",\n    columns: [\n      \"graph_id\",\n      \"to_kind\",\n      \"to_id\",\n      \"kind\",\n      \"from_kind\",\n      \"recorded_from\",\n      \"recorded_to\",\n    ],\n  },\n  {\n    table: \"recordedEdges\",\n    suffix: \"valid_idx\",\n    columns: [\"graph_id\", \"valid_from\", \"valid_to\"],\n  },\n];\n\n/** Default physical table names for the system-index relations. */\nconst DEFAULT_SYSTEM_INDEX_TABLE_NAMES: Readonly<\n  Record<SystemIndexTable, string>\n> = {\n  nodes: \"typegraph_nodes\",\n  edges: \"typegraph_edges\",\n  recordedNodes: \"typegraph_recorded_nodes\",\n  recordedEdges: \"typegraph_recorded_edges\",\n};\n\n/**\n * Resolves the physical table name for a system-index relation, honoring\n * a backend's table-name overrides.\n */\nexport function resolveSystemIndexTableName(\n  table: SystemIndexTable,\n  overrides:\n    Readonly<Partial<Record<SystemIndexTable, string | undefined>>> | undefined,\n): string {\n  return overrides?.[table] ?? DEFAULT_SYSTEM_INDEX_TABLE_NAMES[table];\n}\n\n/**\n * PostgreSQL truncates identifiers to NAMEDATALEN-1 = 63 bytes SILENTLY —\n * two suffixes of one long custom table name would collide after\n * truncation, and the catalog probes (which compare by exact name) would\n * never match the stored name, re-attempting the build on every boot.\n * SQLite has no such limit but uses the same bound so the two dialects'\n * index sets stay in byte-for-byte parity. (Char-based like the vector\n * identifier bound — multibyte table names are out of scope.)\n */\nconst MAX_SQL_IDENTIFIER_LENGTH = 63;\n\n/**\n * Physical index name: `${physicalTableName}_${suffix}`, deterministically\n * truncated + hash-suffixed past the 63-char identifier bound so distinct\n * indexes stay distinct. Single choke point — the Drizzle builders, the\n * runtime DDL, the catalog probes, and the status keys all derive the\n * name here, so they can never disagree.\n */\nexport function systemIndexName(\n  physicalTableName: string,\n  suffix: string,\n): string {\n  const full = `${physicalTableName}_${suffix}`;\n  if (full.length <= MAX_SQL_IDENTIFIER_LENGTH) return full;\n  const hash = shortHash(JSON.stringify([physicalTableName, suffix]));\n  return `${full.slice(0, MAX_SQL_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;\n}\n\n/**\n * Every system index name for a deployment's (possibly overridden) table\n * names. Graph-declared index names must not collide with these: a\n * colliding `CREATE INDEX IF NOT EXISTS` would silently no-op against the\n * system index (wrong shape) while recording a false success — see the\n * guards in the schema factories and `materializeIndexes`.\n */\nexport function resolveSystemIndexNames(\n  overrides:\n    Readonly<Partial<Record<SystemIndexTable, string | undefined>>> | undefined,\n): ReadonlySet<string> {\n  return new Set(\n    SYSTEM_INDEX_DECLARATIONS.map((declaration) =>\n      systemIndexName(\n        resolveSystemIndexTableName(declaration.table, overrides),\n        declaration.suffix,\n      ),\n    ),\n  );\n}\n\n/**\n * Rejects graph-declared indexes whose names collide with this\n * deployment's system index names. Called by both dialect schema\n * factories so a colliding declaration fails at table-definition time\n * instead of silently no-opping against the (differently shaped) system\n * index at CREATE INDEX IF NOT EXISTS time. `materializeIndexes` applies\n * the same check per-declaration on its runtime path.\n */\nexport function assertNoSystemIndexNameCollision(\n  indexes: readonly Readonly<{ name: string }>[],\n  overrides:\n    Readonly<Partial<Record<SystemIndexTable, string | undefined>>> | undefined,\n): void {\n  if (indexes.length === 0) return;\n  const reserved = resolveSystemIndexNames(overrides);\n  for (const index of indexes) {\n    if (reserved.has(index.name)) {\n      throw new Error(\n        `Index name \"${index.name}\" collides with a TypeGraph system ` +\n          `index. Choose a different name — system index names are ` +\n          `reserved, and a same-named CREATE INDEX IF NOT EXISTS would ` +\n          `silently no-op against the system index instead of creating ` +\n          `the declared one.`,\n      );\n    }\n  }\n}\n\n/**\n * Runtime DDL for one system index — byte-compatible with the index the\n * bootstrap path creates from the Drizzle schema (same name, same\n * columns), plus `CONCURRENTLY` where the dialect supports building\n * without blocking writes.\n */\nexport function generateSystemIndexDDL(\n  declaration: SystemIndexDeclaration,\n  physicalTableName: string,\n  options: Readonly<{ concurrent: boolean }>,\n): string {\n  const name = quoteIdentifier(\n    systemIndexName(physicalTableName, declaration.suffix),\n  );\n  const table = quoteIdentifier(physicalTableName);\n  const columns = declaration.columns\n    .map((column) => quoteIdentifier(column))\n    .join(\", \");\n  const concurrently = options.concurrent ? \"CONCURRENTLY \" : \"\";\n  return `CREATE INDEX ${concurrently}IF NOT EXISTS ${name} ON ${table} (${columns});`;\n}\n"]}

package/dist/{ddl-CZz7a0E8.d.cts → ddl-BD-ZfKeX.d.cts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './fulltext-strategy-CDkSSYhq.cjs';
-import { P as PostgresTables } from './postgres-CfEqsRMp.cjs';
-import { S as SqliteTables } from './sqlite-D7zBinNR.cjs';
+import { F as FulltextStrategy } from './fulltext-strategy-C27vXaeB.cjs';
+import { P as PostgresTables } from './postgres-YrYmPlaU.cjs';
+import { S as SqliteTables } from './sqlite-Pp8O19WE.cjs';
 
 /**
  * Generates all DDL statements for the given SQLite tables.

package/dist/{ddl-C2rZ-Aen.d.ts → ddl-CS0KUVwB.d.ts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './fulltext-strategy-B57yvC5Q.js';
-import { P as PostgresTables } from './postgres-DQ5R6rzV.js';
-import { S as SqliteTables } from './sqlite-DvQndLky.js';
+import { F as FulltextStrategy } from './fulltext-strategy-DebsMrqg.js';
+import { P as PostgresTables } from './postgres-IaBA4RgE.js';
+import { S as SqliteTables } from './sqlite-BUOHPx7p.js';
 
 /**
  * Generates all DDL statements for the given SQLite tables.

package/dist/{extension-types-ixRpJVUp.d.cts → extension-types-BM2ACfYO.d.cts}

@@ -11,8 +11,13 @@ type KindEntity = "node" | "edge";
  * kind directly (they back a per-`(kind, field)` typed embedding table
  * owned by the active `VectorStrategy`), but they participate in the same
  * materialization and diff pipelines, so they share this discriminator.
+ *
+ * `"system"` marks TypeGraph's own base-relation indexes
+ * (`SYSTEM_INDEX_DECLARATIONS`) — graph-independent, but materialized and
+ * status-tracked through the same pipeline; their status rows carry the
+ * relation key (e.g. `"recordedNodes"`) in the `kind` column.
  */
-type IndexEntity = "node" | "edge" | "vector";
+type IndexEntity = "node" | "edge" | "vector" | "system";
 /**
  * Field-level null-check operations that round-trip through persisted
  * documents (unique-constraint where clauses, index where clauses,

package/dist/{extension-types-ixRpJVUp.d.ts → extension-types-BM2ACfYO.d.ts}

@@ -11,8 +11,13 @@ type KindEntity = "node" | "edge";
  * kind directly (they back a per-`(kind, field)` typed embedding table
  * owned by the active `VectorStrategy`), but they participate in the same
  * materialization and diff pipelines, so they share this discriminator.
+ *
+ * `"system"` marks TypeGraph's own base-relation indexes
+ * (`SYSTEM_INDEX_DECLARATIONS`) — graph-independent, but materialized and
+ * status-tracked through the same pipeline; their status rows carry the
+ * relation key (e.g. `"recordedNodes"`) in the `kind` column.
  */
-type IndexEntity = "node" | "edge" | "vector";
+type IndexEntity = "node" | "edge" | "vector" | "system";
 /**
  * Field-level null-check operations that round-trip through persisted
  * documents (unique-constraint where clauses, index where clauses,

package/dist/{fulltext-strategy-CDkSSYhq.d.cts → fulltext-strategy-C27vXaeB.d.cts}

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import { a as NullCheckOp, K as KindEntity, T as TemporalMode, A as AnyEdgeType, N as NodeType, g as EdgeType, s as UniquenessScope, n as Collation, D as DeleteBehavior, f as KindAnnotations, m as Cardinality, q as EndpointExistence, G as GraphExtension, I as IndexEntity } from './extension-types-ixRpJVUp.cjs';
+import { a as NullCheckOp, K as KindEntity, T as TemporalMode, A as AnyEdgeType, N as NodeType, g as EdgeType, s as UniquenessScope, n as Collation, D as DeleteBehavior, f as KindAnnotations, m as Cardinality, q as EndpointExistence, G as GraphExtension, I as IndexEntity } from './extension-types-BM2ACfYO.cjs';
 import { z } from 'zod';
 import { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
@@ -424,13 +424,14 @@ interface VectorStrategy {
 }
 
 declare const SqlIntentBrand: unique symbol;
-type SqlIntent = "rows" | "statement";
+type SqlIntent = "rows" | "statement" | "temporary-statement";
 type IntentSql<I extends SqlIntent> = SQL & Readonly<{
     [SqlIntentBrand]: I;
 }>;
 type CompiledRowsSql = IntentSql<"rows">;
 type CompiledSelectSql = CompiledRowsSql;
 type CompiledStatementSql = IntentSql<"statement">;
+type CompiledTemporaryStatementSql = IntentSql<"temporary-statement">;
 declare function asCompiledRowsSql(query: SQL): CompiledRowsSql;
 declare function asCompiledSelectSql(query: SQL): CompiledSelectSql;
 declare function asCompiledStatementSql(query: SQL): CompiledStatementSql;
@@ -1652,6 +1653,19 @@ type FulltextCapabilities = Readonly<{
     /** Whether highlighting / snippets are supported. */
     highlighting: boolean;
 }>;
+/**
+ * Whole-graph analytics capabilities declared by a backend.
+ *
+ * `supported` means the backend can pin one transactional connection while
+ * an algorithm creates, updates, and drops session-local temporary state.
+ * `mathFunctions` records whether transcendental SQL functions needed by
+ * deferred algorithms such as MCL/spectral are available; exact WCC does not
+ * require them.
+ */
+type GraphAnalyticsCapabilities = Readonly<{
+    supported: boolean;
+    mathFunctions: boolean;
+}>;
 
 /**
  * Backend capabilities that vary by dialect.
@@ -1673,18 +1687,22 @@ type BackendCapabilities = Readonly<{
     /**
      * Maximum number of bound parameters the engine accepts in one statement.
      * SQLite defaults to 999 (raisable at compile time via
-     * `SQLITE_MAX_VARIABLE_NUMBER`); PostgreSQL's wire protocol caps it at 65535.
+     * `SQLITE_MAX_VARIABLE_NUMBER`), while hosted SQLite runtimes may impose a
+     * lower platform ceiling; PostgreSQL's wire protocol caps it at 65535.
      * Recorded-time capture and recorded point reads size their multi-row
      * statements to this ceiling — the same budget the backend's own batched
-     * inserts use — instead of a conservative dialect-blind constant. A custom
-     * build that raises the SQLite limit can override this here. Absent means the
-     * recorded-time fallback budget applies.
+     * inserts use — instead of a conservative dialect-blind constant. Custom
+     * runtimes can override a detected or probed limit here, but hosted platform
+     * hard ceilings may only be lowered. Absent means the recorded-time fallback
+     * budget applies.
      */
     maxBindParameters?: number;
     /** Vector search capabilities (undefined if not configured) */
     vector?: VectorCapabilities | undefined;
     /** Fulltext search capabilities (undefined if not configured) */
     fulltext?: FulltextCapabilities | undefined;
+    /** Whole-graph analytics capabilities (undefined when unavailable). */
+    graphAnalytics?: GraphAnalyticsCapabilities | undefined;
 }>;
 /**
  * A node/edge row's `props` column as the driver returned it: SQLite always
@@ -1814,6 +1832,18 @@ type InsertEdgeParams = Readonly<{
     validFrom?: string | null;
     validTo?: string;
 }>;
+/**
+ * Write-only session exposed inside {@link GraphBackend.trustedImport}.
+ *
+ * The caller has accepted the trusted-import contract: properties, endpoint
+ * references, uniqueness, and cardinality are not validated. Backends may
+ * therefore use engine-native ingestion primitives that bypass the normal
+ * store write pipeline.
+ */
+type TrustedImportSession = Readonly<{
+    insertNodes: (params: readonly InsertNodeParams[]) => Promise<void>;
+    insertEdges: (params: readonly InsertEdgeParams[]) => Promise<void>;
+}>;
 /**
  * Parameters for updating an edge.
  */
@@ -2354,12 +2384,25 @@ type RecordKindRemovalParams = Readonly<{
     /** Error message on failure; undefined on success or while pending. */
     error: string | undefined;
 }>;
+/** @internal Capability token for connection-local temporary writes. */
+declare const INTERNAL_TEMPORARY_WRITES: unique symbol;
 /**
  * Transaction options.
  */
 type TransactionOptions = Readonly<{
     /** Transaction isolation level (if supported) */
     isolationLevel?: "read_uncommitted" | "read_committed" | "repeatable_read" | "serializable";
+    /**
+     * Transaction access mode (if supported). `read_only` is intended for
+     * multi-statement reads that need one snapshot and must not perform writes.
+     */
+    accessMode?: "read_only" | "read_write";
+    /**
+     * @internal Permit writes only to connection-local temporary state. The
+     * iterative-operation primitive uses this when an engine rejects temporary
+     * DDL in a read-only transaction.
+     */
+    temporaryWrites?: typeof INTERNAL_TEMPORARY_WRITES;
 }>;
 /**
  * A caller-owned, already-open Drizzle transaction handle that a
@@ -2684,6 +2727,61 @@ type GraphBackend = Readonly<{
      * records the marker (success or failure) keyed by `graphId`.
      */
     ensureRuntimeContributions?: (graphId: string) => Promise<void>;
+    /**
+     * Privileged materializer for one embedding `(kind, field)` slot's
+     * `ownedTables` contribution(s): creates the per-field vector table and
+     * records its durable marker, idempotently. The vector counterpart of
+     * `ensureRuntimeContributions` — vectors are per-`(kind, field)` and
+     * graph-derived, so the store enumerates slots (via
+     * `resolveEmbeddingFields`) and uses the batch counterpart at boot under
+     * the privileged role. Pass `{ force: true }` to overwrite the marker
+     * at the current signature, bypassing the drift-guard — the sanctioned
+     * path `store.reembedVectorField()` uses after recreating storage at a
+     * new dimension. Pass `{ onDrift: "skip" }` to leave an
+     * already-provisioned slot whose shape has since changed untouched
+     * (warn + no-op) instead of refusing — the boot/evolve path, so a
+     * declared dimension change never blocks startup before the operator
+     * can run `reembedVectorField`. Present only on backends wired with a
+     * vector strategy.
+     */
+    ensureVectorSlotContribution?: (slot: VectorSlot, options?: Readonly<{
+        force?: boolean;
+        onDrift?: "throw" | "skip";
+    }>) => Promise<void>;
+    /**
+     * Batch form of `ensureVectorSlotContribution`, used by privileged boot to
+     * resolve every slot's durable markers with one graph-scoped query. The
+     * singular method remains available for re-embedding and compatibility.
+     */
+    ensureVectorSlotContributions?: (slots: readonly VectorSlot[], options?: Readonly<{
+        force?: boolean;
+        onDrift?: "throw" | "skip";
+    }>) => Promise<void>;
+    /**
+     * SELECT-only gate for one embedding `(kind, field)` slot: asserts the
+     * durable marker(s) for the slot's `ownedTables` contribution(s),
+     * cached per backend instance. Throws `StoreNotInitializedError` when
+     * the slot is missing, stale (signature drift), or recorded a failed
+     * last attempt. The vector counterpart of
+     * `assertRuntimeContributionsInitialized`, consulted by the verified
+     * runtime attach. Performs ZERO DDL and ZERO writes. Present only on
+     * backends wired with a vector strategy.
+     */
+    assertVectorSlotInitialized?: (slot: VectorSlot) => Promise<void>;
+    /**
+     * Batch form of `assertVectorSlotInitialized`, used by verified attach to
+     * resolve every slot's durable markers with one graph-scoped query.
+     */
+    assertVectorSlotsInitialized?: (slots: readonly VectorSlot[]) => Promise<void>;
+    /**
+     * Forget one embedding `(kind, field)` slot's durable contribution
+     * marker(s). Called after the slot's per-field table is dropped
+     * (vector-field reclaim) so a later `ensureVectorSlotContribution`
+     * re-creates the table instead of trusting an orphaned "initialized"
+     * marker. Does NOT drop the table itself (the caller already did).
+     * Present only on backends wired with a vector strategy.
+     */
+    deleteVectorSlotContribution?: (slot: VectorSlot) => Promise<void>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
      * owns. Same focused-bootstrap rationale as the other `ensure*Table`
@@ -2743,6 +2841,20 @@ type GraphBackend = Readonly<{
      * sizes this library is designed for.
      */
     refreshStatistics: () => Promise<void>;
+    /**
+     * Runs an intentionally trusted, all-or-nothing initial import.
+     *
+     * Optional because only backends that can pin one transaction and use a
+     * native high-throughput write path expose it. Implementations must reject
+     * a database whose TypeGraph node or edge tables already contain rows. They
+     * may temporarily remove rebuildable secondary indexes, but must restore
+     * them before committing. Any callback, insert, or rebuild failure rolls the
+     * entire operation back.
+     *
+     * This is a top-level-only lifecycle operation and is deliberately absent
+     * from {@link TransactionBackend}.
+     */
+    trustedImport?: <T>(fn: (session: TrustedImportSession) => Promise<T>) => Promise<T>;
     execute: <T>(query: CompiledRowsSql) => Promise<readonly T[]>;
     /**
      * Execute a non-row-returning SQL statement bound to this backend or
@@ -2751,6 +2863,13 @@ type GraphBackend = Readonly<{
      * capability-check and fail loudly.
      */
     executeStatement?: (query: CompiledStatementSql) => Promise<void>;
+    /**
+     * Execute an internally compiled statement against connection-local
+     * temporary state. History wrappers preserve this path because it cannot
+     * mutate graph or history tables; callers cannot construct its branded
+     * input through the public API.
+     */
+    executeTemporaryStatement?: (query: CompiledTemporaryStatementSql) => Promise<void>;
     /** Execute pre-compiled SQL text with bound parameters. Available on sync SQLite and pg backends. */
     executeRaw?: <T>(sqlText: string, params: readonly unknown[]) => Promise<readonly T[]>;
     /** Compile a Drizzle SQL object to { sql, params } without executing. */
@@ -2837,7 +2956,7 @@ type RemovalMaterializationBackend = Pick<GraphBackend, "ensureKindRemovalsTable
 type GraphLifecycleBackend = Pick<GraphBackend, "clearGraph" | "bootstrapTables">;
 type QueryExecutionBackend = Pick<GraphBackend, "execute">;
 type RawQueryExecutionBackend = Pick<GraphBackend, "executeRaw" | "compileSql">;
-type RawStatementExecutionBackend = Pick<GraphBackend, "executeStatement" | "executeDdl">;
+type RawStatementExecutionBackend = Pick<GraphBackend, "executeStatement" | "executeTemporaryStatement" | "executeDdl">;
 type BackendMaintenance = Pick<GraphBackend, "refreshStatistics">;
 type BackendTransactions = Pick<GraphBackend, "transaction" | "adoptTransaction">;
 type BackendLifecycle = Pick<GraphBackend, "close">;
@@ -3182,4 +3301,4 @@ interface FulltextStrategy {
 declare const tsvectorStrategy: FulltextStrategy;
 declare const fts5Strategy: FulltextStrategy;
 
-export { type BackendTransactions as $, type AnyPgDatabase as A, type BackendCapabilities as B, type SerializedOntology as C, type SerializedUniqueConstraint as D, type EdgeIndexConfig as E, type FulltextStrategy as F, type GraphBackend as G, type SchemaVersionRow as H, type IndexDeclaration as I, type JsonPointer as J, type InferenceType as K, type AggregateExpr as L, type MetaEdge as M, type NodeIndexConfig as N, type OntologyRelation as O, type FieldRef as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqliteExecutionProfileHints as S, type ComparisonOp as T, type AggregateComparisonPredicate as U, type VectorStrategy as V, type TraversalDirection as W, type AdoptedTransaction as X, type BackendIdentity as Y, type BackendLifecycle as Z, type BackendMaintenance as _, type AnySqliteDatabase as a, asCompiledStatementSql as a$, type CommitSchemaVersionExpected as a0, type CommitSchemaVersionParams as a1, type CompiledRowsSql as a2, type CompiledSelectSql as a3, type CompiledStatementSql as a4, type ContributionMaterializationBackend as a5, DEFAULT_SQL_SCHEMA as a6, type DeleteFulltextBatchParams as a7, type EdgeEntityReadBackend as a8, type EdgeEntityWriteBackend as a9, type QueryExecutionBackend as aA, type RawQueryExecutionBackend as aB, type RawStatementExecutionBackend as aC, type RecordedRelationOptions as aD, type RemovalMaterializationBackend as aE, type ResolveJsonPointer as aF, type ResolveJsonPointerSegments as aG, type ResolvedSqlTableNames as aH, type RowProps as aI, type SchemaCommitBackend as aJ, type SchemaReadBackend as aK, type SetActiveVersionParams as aL, type SortDirection as aM, type SqlIntent as aN, type SqlSchema as aO, type SqlTableNames as aP, type StrategyTableContribution as aQ, type TableContribution as aR, type TransactionBackend as aS, type TraversalExpansion as aT, type UniqueConstraintBackend as aU, type UpsertFulltextBatchParams as aV, type VectorCapabilities as aW, type VectorOperationBackend as aX, type VectorSlot as aY, asCompiledRowsSql as aZ, asCompiledSelectSql as a_, type ExternalRecordedReadSource as aa, type FilteredApproximateSearch as ab, type FilteredApproximateSearchMode as ac, type FulltextBatchRow as ad, type FulltextCapabilities as ae, type FulltextOperationBackend as af, type FulltextQueryMode as ag, type FulltextSearchParams as ah, type FulltextSearchResult as ai, type GraphEntityReadBackend as aj, type GraphEntityWriteBackend as ak, type GraphLifecycleBackend as al, type HybridFusionOptions as am, type IndexMaterializationBackend as an, type IntentSql as ao, type JsonPointerFor as ap, type JsonPointerInput as aq, type JsonPointerSegment as ar, type JsonPointerSegments as as, type JsonPointerSegmentsFor as at, MAX_JSON_POINTER_DEPTH as au, type MetaEdgeProperties as av, type NodeEntityReadBackend as aw, type NodeEntityWriteBackend as ax, type OrderSpec as ay, type ParameterRef as az, type SqliteTransactionMode as b, buildVectorCapabilities as b0, createSqlSchema as b1, fts5Strategy as b2, isMetaEdge as b3, joinJsonPointers as b4, jsonPointer as b5, normalizeJsonPointer as b6, parseJsonPointer as b7, recordedRelation as b8, rowPropsToJsonText as b9, rowPropsToObject as ba, tsvectorStrategy as bb, type ValueType as bc, type PredicateExpression as bd, type VectorMetricType as be, type Traversal as bf, type NodePredicate as bg, type ProjectedField as bh, type AggregateOrderSpec as bi, type GroupBySpec as bj, type RecursiveCyclePolicy as bk, type NodeRow as bl, type EdgeRow as bm, type VectorSlotMap as bn, type RecordedReadBinding as bo, type SelectiveField as bp, type ComposableQuery as bq, type SetOperationType as br, type SetOperation as bs, type VectorMetric as bt, type TransactionOptions as bu, type EdgeIndexDeclaration as c, type NodeIndexDeclaration as d, type IndexWhereExpression as e, type SqlDialect as f, type EdgeIndexDirection as g, type EdgeIndexWhereBuilder as h, type IndexOrigin as i, type IndexScope as j, type IndexWhereFieldBuilder as k, type IndexWhereInput as l, type NodeIndexWhereBuilder as m, type SystemColumnName as n, type VectorIndexDeclaration as o, type VectorIndexImplementation as p, type VectorIndexMetric as q, type VectorIndexParams as r, type SerializedSchema as s, type SchemaHash as t, type SerializedNodeDef as u, type SerializedEdgeDef as v, type SerializedMetaEdge as w, type SerializedOntologyRelation as x, type SerializedClosures as y, type JsonSchema as z };
+export { type BackendTransactions as $, type AnyPgDatabase as A, type BackendCapabilities as B, type SerializedOntology as C, type SerializedUniqueConstraint as D, type EdgeIndexDeclaration as E, type FulltextStrategy as F, type GraphBackend as G, type SchemaVersionRow as H, type IndexDeclaration as I, type JsonPointer as J, type InferenceType as K, type AggregateExpr as L, type MetaEdge as M, type NodeIndexDeclaration as N, type OntologyRelation as O, type FieldRef as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqliteExecutionProfileHints as S, type ComparisonOp as T, type AggregateComparisonPredicate as U, type VectorStrategy as V, type TraversalDirection as W, type AdoptedTransaction as X, type BackendIdentity as Y, type BackendLifecycle as Z, type BackendMaintenance as _, type AnySqliteDatabase as a, asCompiledRowsSql as a$, type CommitSchemaVersionExpected as a0, type CommitSchemaVersionParams as a1, type CompiledRowsSql as a2, type CompiledSelectSql as a3, type CompiledStatementSql as a4, type ContributionMaterializationBackend as a5, DEFAULT_SQL_SCHEMA as a6, type DeleteFulltextBatchParams as a7, type EdgeEntityReadBackend as a8, type EdgeEntityWriteBackend as a9, type ParameterRef as aA, type QueryExecutionBackend as aB, type RawQueryExecutionBackend as aC, type RawStatementExecutionBackend as aD, type RecordedRelationOptions as aE, type RemovalMaterializationBackend as aF, type ResolveJsonPointer as aG, type ResolveJsonPointerSegments as aH, type ResolvedSqlTableNames as aI, type RowProps as aJ, type SchemaCommitBackend as aK, type SchemaReadBackend as aL, type SetActiveVersionParams as aM, type SortDirection as aN, type SqlIntent as aO, type SqlSchema as aP, type SqlTableNames as aQ, type StrategyTableContribution as aR, type TableContribution as aS, type TransactionBackend as aT, type TraversalExpansion as aU, type TrustedImportSession as aV, type UniqueConstraintBackend as aW, type UpsertFulltextBatchParams as aX, type VectorCapabilities as aY, type VectorOperationBackend as aZ, type VectorSlot as a_, type ExternalRecordedReadSource as aa, type FilteredApproximateSearch as ab, type FilteredApproximateSearchMode as ac, type FulltextBatchRow as ad, type FulltextCapabilities as ae, type FulltextOperationBackend as af, type FulltextQueryMode as ag, type FulltextSearchParams as ah, type FulltextSearchResult as ai, type GraphAnalyticsCapabilities as aj, type GraphEntityReadBackend as ak, type GraphEntityWriteBackend as al, type GraphLifecycleBackend as am, type HybridFusionOptions as an, type IndexMaterializationBackend as ao, type IntentSql as ap, type JsonPointerFor as aq, type JsonPointerInput as ar, type JsonPointerSegment as as, type JsonPointerSegments as at, type JsonPointerSegmentsFor as au, MAX_JSON_POINTER_DEPTH as av, type MetaEdgeProperties as aw, type NodeEntityReadBackend as ax, type NodeEntityWriteBackend as ay, type OrderSpec as az, type SqliteTransactionMode as b, asCompiledSelectSql as b0, asCompiledStatementSql as b1, buildVectorCapabilities as b2, createSqlSchema as b3, fts5Strategy as b4, isMetaEdge as b5, joinJsonPointers as b6, jsonPointer as b7, normalizeJsonPointer as b8, parseJsonPointer as b9, recordedRelation as ba, rowPropsToJsonText as bb, rowPropsToObject as bc, tsvectorStrategy as bd, type ValueType as be, type PredicateExpression as bf, type VectorMetricType as bg, type Traversal as bh, type NodePredicate as bi, type ProjectedField as bj, type AggregateOrderSpec as bk, type GroupBySpec as bl, type RecursiveCyclePolicy as bm, type NodeRow as bn, type EdgeRow as bo, type VectorSlotMap as bp, type RecordedReadBinding as bq, type SelectiveField as br, type ComposableQuery as bs, type SetOperationType as bt, type SetOperation as bu, type VectorMetric as bv, type TransactionOptions as bw, type SqlDialect as c, type EdgeIndexConfig as d, type EdgeIndexDirection as e, type EdgeIndexWhereBuilder as f, type IndexOrigin as g, type IndexScope as h, type IndexWhereExpression as i, type IndexWhereFieldBuilder as j, type IndexWhereInput as k, type NodeIndexConfig as l, type NodeIndexWhereBuilder as m, type SystemColumnName as n, type VectorIndexDeclaration as o, type VectorIndexImplementation as p, type VectorIndexMetric as q, type VectorIndexParams as r, type SerializedSchema as s, type SchemaHash as t, type SerializedNodeDef as u, type SerializedEdgeDef as v, type SerializedMetaEdge as w, type SerializedOntologyRelation as x, type SerializedClosures as y, type JsonSchema as z };