@nicia-ai/typegraph 0.24.1 → 0.25.0

package/dist/index.js

@@ -1,148 +1,28 @@
 import { quoteIdentifier, EMPTY_REQUIRED_COLUMNS, addRequiredColumn, markSelectiveFieldAsRequired, markFieldRefAsRequired, NODE_COLUMNS, shouldProjectColumn, mapSelectiveSystemFieldToColumn, isIdFieldRef, isAggregateExpr, EDGE_COLUMNS } from './chunk-3EUKJEQ3.js';
-import { META_EDGE_BRAND, META_EDGE_SUB_CLASS_OF, META_EDGE_NARROWER, META_EDGE_BROADER, META_EDGE_RELATED_TO, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_DIFFERENT_FROM, META_EDGE_DISJOINT_WITH, META_EDGE_HAS_PART, META_EDGE_PART_OF, META_EDGE_INVERSE_OF, META_EDGE_IMPLIES, ensureSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, validateNodeProps, validateEdgeProps } from './chunk-GFGVREHH.js';
-export { isMetaEdge } from './chunk-GFGVREHH.js';
-import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, nowIso, validateOptionalIsoDate, getNodeKinds, getEdgeKinds } from './chunk-LBORRUNJ.js';
-export { defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-LBORRUNJ.js';
-import { runOptionallyInTransaction } from './chunk-GUTQTMOV.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, CompilerInvariantError, KindNotFoundError, DatabaseOperationError, EdgeNotFoundError, NodeConstraintNotFoundError, RestrictedDeleteError, NodeNotFoundError, EndpointNotFoundError, UniquenessError, CardinalityError, EndpointError, DisjointError } from './chunk-WFMTAEEN.js';
-export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EdgeNotFoundError, EndpointError, EndpointNotFoundError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeNotFoundError, RestrictedDeleteError, SchemaMismatchError, TypeGraphError, UniquenessError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-WFMTAEEN.js';
-import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, getDialect, DEFAULT_STREAM_BATCH_SIZE, NODE_META_KEYS, EDGE_META_KEYS, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36 } from './chunk-753F33CV.js';
-export { fts5Strategy, tsvectorStrategy } from './chunk-753F33CV.js';
-import { jsonPointer, parseJsonPointer, createSchemaIntrospector, normalizeJsonPointer, joinJsonPointers, resolveFieldTypeInfoAtJsonPointer, getSearchableMetadata, DEFAULT_SEARCHABLE_LANGUAGE, getEmbeddingDimensions, isEmbeddingSchema } from './chunk-EYELZHKY.js';
-export { DEFAULT_SEARCHABLE_LANGUAGE, MAX_JSON_POINTER_DEPTH, embedding, getEmbeddingDimensions, getSearchableMetadata, isEmbeddingSchema, isSearchableSchema, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer, searchable } from './chunk-EYELZHKY.js';
+import { META_EDGE_BRAND, loadAndMergeGraphExtensionDocument, ensureSchema, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, validateNodeProps, validateEdgeProps, canonicalEqual, sortedReplacer } from './chunk-LVCSL6A3.js';
+export { broader, core, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, hasPart, implies, inverseOf, isMetaEdge, narrower, partOf, relatedTo, sameAs, subClassOf } from './chunk-LVCSL6A3.js';
+import { nowIso, isKnownKind, validateOptionalIsoDate, getNodeKinds, getEdgeKinds } from './chunk-EG6TJ3I5.js';
+export { defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-EG6TJ3I5.js';
+export { defineGraphExtension } from './chunk-NHQWXSTS.js';
+import { IncompatibleChangeError, filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, RemoveCompileTimeKindError, KindHasReferentsError, validateProjectionField } from './chunk-4BOWVUGQ.js';
+export { CURRENT_GRAPH_EXTENSION_VERSION, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, LEGACY_GRAPH_EXTENSION_VERSION, RemoveCompileTimeKindError, validateGraphExtension } from './chunk-4BOWVUGQ.js';
+import { runOptionallyInTransaction } from './chunk-FPCOUJSL.js';
+import { getDialect, generateIndexDDL } from './chunk-YZZBDCLV.js';
+export { andWhere, fts5Strategy, notWhere, orWhere, tsvectorStrategy } from './chunk-YZZBDCLV.js';
+import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, NODE_META_KEYS, EDGE_META_KEYS, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36, sha256Hex } from './chunk-EJCDOA37.js';
+export { defineEdgeIndex, defineNodeIndex } from './chunk-EJCDOA37.js';
+import { createSchemaIntrospector, resolveFieldTypeInfoAtJsonPointer, getSearchableMetadata, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-OOS2RKRH.js';
+export { DEFAULT_SEARCHABLE_LANGUAGE, getSearchableMetadata, isSearchableSchema, searchable } from './chunk-OOS2RKRH.js';
+import { getEmbeddingDimensions, isEmbeddingSchema } from './chunk-WVQXAFP3.js';
+export { embedding, getEmbeddingDimensions, isEmbeddingSchema } from './chunk-WVQXAFP3.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, DatabaseOperationError, EdgeNotFoundError, NodeConstraintNotFoundError, RestrictedDeleteError, NodeNotFoundError, EndpointNotFoundError, UniquenessError, CardinalityError, DisjointError } from './chunk-DOTEN2FG.js';
+export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EagerMaterializationError, EdgeNotFoundError, EndpointError, EndpointNotFoundError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeNotFoundError, RestrictedDeleteError, SchemaContentConflictError, SchemaMismatchError, StaleVersionError, TypeGraphError, UniquenessError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-DOTEN2FG.js';
+import { jsonPointer, parseJsonPointer, normalizeJsonPointer, joinJsonPointers } from './chunk-NZ5PMBTG.js';
+export { MAX_JSON_POINTER_DEPTH, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer } from './chunk-NZ5PMBTG.js';
 import { z } from 'zod';
 import { sql, Placeholder } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 
-// src/store/reserved-keys.ts
-var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta"
-]);
-var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta",
-  "fromKind",
-  "fromId",
-  "toKind",
-  "toId"
-]);
-var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-var RESERVED_PROPERTY_PREFIX = "$";
-function isReservedPropertyName(name) {
-  return name.startsWith(RESERVED_PROPERTY_PREFIX);
-}
-function assertSchemaKeysAreFree(entityKind, name, keys, reservedStructuralKeys) {
-  const structuralConflicts = keys.filter(
-    (key) => reservedStructuralKeys.has(key)
-  );
-  if (structuralConflicts.length > 0) {
-    const label = entityKind.toLowerCase();
-    throw new ConfigurationError(
-      `${entityKind} "${name}" schema contains reserved property names: ${structuralConflicts.join(", ")}`,
-      {
-        [`${label}Type`]: name,
-        conflicts: structuralConflicts,
-        reservedKeys: [...reservedStructuralKeys]
-      },
-      {
-        suggestion: `Rename the conflicting properties. Reserved names (${[...reservedStructuralKeys].join(", ")}) are added automatically to all ${label}s.`
-      }
-    );
-  }
-  const prefixConflicts = keys.filter((key) => isReservedPropertyName(key));
-  if (prefixConflicts.length > 0) {
-    const label = entityKind.toLowerCase();
-    throw new ConfigurationError(
-      `${entityKind} "${name}" schema uses the reserved "${RESERVED_PROPERTY_PREFIX}" prefix on: ${prefixConflicts.join(", ")}`,
-      {
-        [`${label}Type`]: name,
-        conflicts: prefixConflicts,
-        reservedPrefix: RESERVED_PROPERTY_PREFIX
-      },
-      {
-        suggestion: `Property names starting with "${RESERVED_PROPERTY_PREFIX}" are reserved for TypeGraph accessors (e.g. $fulltext). Rename each field.`
-      }
-    );
-  }
-}
-function validateProjectionField(field2, entityType, kind) {
-  const reserved = entityType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
-  if (reserved.has(field2)) {
-    throw new ConfigurationError(
-      `Projection field "${field2}" on ${entityType} kind "${kind}" conflicts with a reserved structural key`,
-      { field: field2, kind, entityType, reservedKeys: [...reserved] },
-      {
-        suggestion: `Remove "${field2}" from the projection. Structural fields (${[...reserved].join(", ")}) are included automatically when relevant.`
-      }
-    );
-  }
-  if (PROTOTYPE_POLLUTION_KEYS.has(field2)) {
-    throw new ConfigurationError(
-      `Projection field "${field2}" on ${entityType} kind "${kind}" is not allowed`,
-      { field: field2, kind, entityType },
-      {
-        suggestion: `"${field2}" cannot be used as a projection field name.`
-      }
-    );
-  }
-}
-function filterReservedKeys(props, reservedKeys) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (!reservedKeys.has(key)) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-
-// src/core/node.ts
-function validateSchemaKeys(schema, name) {
-  assertSchemaKeysAreFree(
-    "Node",
-    name,
-    Object.keys(schema.shape),
-    RESERVED_NODE_KEYS
-  );
-}
-function defineNode(name, options) {
-  validateSchemaKeys(options.schema, name);
-  return Object.freeze({
-    [NODE_TYPE_BRAND]: true,
-    kind: name,
-    schema: options.schema,
-    description: options.description
-  });
-}
-var EMPTY_SCHEMA = z.object({});
-function validateSchemaKeys2(schema, name) {
-  assertSchemaKeysAreFree(
-    "Edge",
-    name,
-    Object.keys(schema.shape),
-    RESERVED_EDGE_KEYS
-  );
-}
-function defineEdge(name, options) {
-  const schema = options?.schema ?? EMPTY_SCHEMA;
-  validateSchemaKeys2(schema, name);
-  return Object.freeze({
-    [EDGE_TYPE_BRAND]: true,
-    kind: name,
-    schema,
-    description: options?.description,
-    from: options?.from,
-    to: options?.to
-  });
-}
-
 // src/core/meta-edge.ts
 function metaEdge(name, options = {}) {
   const properties = {
@@ -187,200 +67,6 @@ function createExternalRef(table) {
   return (id) => ({ table, id });
 }
 
-// src/ontology/core-meta-edges.ts
-function createMetaEdge(name, properties) {
-  return Object.freeze({
-    [META_EDGE_BRAND]: true,
-    name,
-    properties: {
-      transitive: properties.transitive ?? false,
-      symmetric: properties.symmetric ?? false,
-      reflexive: properties.reflexive ?? false,
-      inverse: properties.inverse,
-      inference: properties.inference,
-      description: properties.description
-    }
-  });
-}
-var subClassOfMetaEdge = createMetaEdge(META_EDGE_SUB_CLASS_OF, {
-  transitive: true,
-  inference: "subsumption",
-  description: "Type inheritance (Podcast subClassOf Media)"
-});
-function subClassOf(child, parent) {
-  return {
-    metaEdge: subClassOfMetaEdge,
-    from: child,
-    to: parent
-  };
-}
-var broaderMetaEdge = createMetaEdge(META_EDGE_BROADER, {
-  transitive: true,
-  inverse: META_EDGE_NARROWER,
-  inference: "hierarchy",
-  description: "Broader concept (ML broader AI)"
-});
-function broader(narrowerConcept, broaderConcept) {
-  return {
-    metaEdge: broaderMetaEdge,
-    from: narrowerConcept,
-    to: broaderConcept
-  };
-}
-var narrowerMetaEdge = createMetaEdge(META_EDGE_NARROWER, {
-  transitive: true,
-  inverse: META_EDGE_BROADER,
-  inference: "hierarchy",
-  description: "Narrower concept (AI narrower ML)"
-});
-function narrower(broaderConcept, narrowerConcept) {
-  return {
-    metaEdge: narrowerMetaEdge,
-    from: broaderConcept,
-    to: narrowerConcept
-  };
-}
-var relatedToMetaEdge = createMetaEdge(META_EDGE_RELATED_TO, {
-  symmetric: true,
-  inference: "association",
-  description: "Non-hierarchical association"
-});
-function relatedTo(conceptA, conceptB) {
-  return {
-    metaEdge: relatedToMetaEdge,
-    from: conceptA,
-    to: conceptB
-  };
-}
-var equivalentToMetaEdge = createMetaEdge(META_EDGE_EQUIVALENT_TO, {
-  symmetric: true,
-  transitive: true,
-  inference: "substitution",
-  description: "Same class, different representation"
-});
-function equivalentTo(kindA, kindBOrIri) {
-  return {
-    metaEdge: equivalentToMetaEdge,
-    from: kindA,
-    to: kindBOrIri
-  };
-}
-var sameAsMetaEdge = createMetaEdge(META_EDGE_SAME_AS, {
-  symmetric: true,
-  transitive: true,
-  inference: "substitution",
-  description: "Same individual (for deduplication)"
-});
-function sameAs(kindA, kindBOrIri) {
-  return {
-    metaEdge: sameAsMetaEdge,
-    from: kindA,
-    to: kindBOrIri
-  };
-}
-var differentFromMetaEdge = createMetaEdge(META_EDGE_DIFFERENT_FROM, {
-  symmetric: true,
-  inference: "constraint",
-  description: "Explicitly different individuals"
-});
-function differentFrom(kindA, kindB) {
-  return {
-    metaEdge: differentFromMetaEdge,
-    from: kindA,
-    to: kindB
-  };
-}
-var disjointWithMetaEdge = createMetaEdge(META_EDGE_DISJOINT_WITH, {
-  symmetric: true,
-  inference: "constraint",
-  description: "Mutually exclusive types"
-});
-function disjointWith(kindA, kindB) {
-  return {
-    metaEdge: disjointWithMetaEdge,
-    from: kindA,
-    to: kindB
-  };
-}
-var partOfMetaEdge = createMetaEdge(META_EDGE_PART_OF, {
-  transitive: true,
-  inverse: META_EDGE_HAS_PART,
-  inference: "composition",
-  description: "X is part of Y"
-});
-function partOf(part, whole) {
-  return {
-    metaEdge: partOfMetaEdge,
-    from: part,
-    to: whole
-  };
-}
-var hasPartMetaEdge = createMetaEdge(META_EDGE_HAS_PART, {
-  transitive: true,
-  inverse: META_EDGE_PART_OF,
-  inference: "composition",
-  description: "Y has part X"
-});
-function hasPart(whole, part) {
-  return {
-    metaEdge: hasPartMetaEdge,
-    from: whole,
-    to: part
-  };
-}
-var inverseOfMetaEdge = createMetaEdge(META_EDGE_INVERSE_OF, {
-  symmetric: true,
-  inference: "none",
-  description: "Edge A is inverse of edge B"
-});
-var impliesMetaEdge = createMetaEdge(META_EDGE_IMPLIES, {
-  transitive: true,
-  inference: "none",
-  description: "Edge A implies edge B exists"
-});
-function inverseOf(edgeA, edgeB) {
-  return {
-    metaEdge: inverseOfMetaEdge,
-    from: edgeA,
-    to: edgeB
-  };
-}
-function implies(edgeA, edgeB) {
-  return {
-    metaEdge: impliesMetaEdge,
-    from: edgeA,
-    to: edgeB
-  };
-}
-var core = {
-  // Meta-edges
-  subClassOfMetaEdge,
-  broaderMetaEdge,
-  narrowerMetaEdge,
-  relatedToMetaEdge,
-  equivalentToMetaEdge,
-  sameAsMetaEdge,
-  differentFromMetaEdge,
-  disjointWithMetaEdge,
-  partOfMetaEdge,
-  hasPartMetaEdge,
-  inverseOfMetaEdge,
-  impliesMetaEdge,
-  // Relation factories
-  subClassOf,
-  broader,
-  narrower,
-  relatedTo,
-  equivalentTo,
-  sameAs,
-  differentFrom,
-  disjointWith,
-  partOf,
-  hasPart,
-  inverseOf,
-  implies
-};
-
 // src/query/subquery-utils.ts
 function normalizeValueType(valueType) {
   if (valueType === void 0 || valueType === "unknown") {
@@ -1024,8 +710,8 @@ function compileFieldJsonValue(field2, dialect, cteAlias, pointerOverride, cteCo
 }
 function resolveLiteralValueTypes(literals) {
   const resolved = /* @__PURE__ */ new Set();
-  for (const literal2 of literals) {
-    const valueType = normalizeValueType2(literal2.valueType);
+  for (const literal3 of literals) {
+    const valueType = normalizeValueType2(literal3.valueType);
     if (valueType) {
       resolved.add(valueType);
     }
@@ -1053,12 +739,12 @@ function resolveComparisonValueType(field2, right) {
   }
   return fieldType;
 }
-function resolvePredicateValueType(preferred, literal2) {
+function resolvePredicateValueType(preferred, literal3) {
   const normalizedPreferred = normalizeValueType2(preferred);
   if (normalizedPreferred) {
     return normalizedPreferred;
   }
-  return literal2 ? normalizeValueType2(literal2.valueType) : void 0;
+  return literal3 ? normalizeValueType2(literal3.valueType) : void 0;
 }
 function convertValueForSql(value, dialect) {
   return dialect.bindValue(value);
@@ -1928,7 +1614,8 @@ var DEFAULT_TABLE_NAMES = {
   nodes: "typegraph_nodes",
   edges: "typegraph_edges",
   embeddings: "typegraph_node_embeddings",
-  fulltext: "typegraph_node_fulltext"
+  fulltext: "typegraph_node_fulltext",
+  uniques: "typegraph_node_uniques"
 };
 var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
 function validateTableName(name, label) {
@@ -1955,6 +1642,7 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.edges, "edges");
   validateTableName(tables.embeddings, "embeddings");
   validateTableName(tables.fulltext, "fulltext");
+  validateTableName(tables.uniques, "uniques");
   return {
     tables,
     nodesTable: sql.raw(quoteIdentifier2(tables.nodes)),
@@ -4256,147 +3944,676 @@ function mapSubgraphEdgeRow(row, projectionPlan) {
   applyProjectedFields(projectedEdge, row, kindPlan);
   return projectedEdge;
 }
-var OPERATOR_MAP = {
-  union: "UNION",
-  unionAll: "UNION ALL",
-  intersect: "INTERSECT",
-  except: "EXCEPT"
-};
-function compileSetOperationWithStandardParenthesizedStrategy(op, graphId, dialect, logicalPlan, _schema, compileQuery2) {
-  return compileSetOperationStandard(
-    op,
-    graphId,
-    dialect,
-    logicalPlan,
-    compileQuery2
-  );
-}
-function compileSetOperationWithSqliteCompoundStrategy(op, graphId, dialect, logicalPlan, schema, _compileQuery) {
-  return compileSetOperationForSqlite(
-    op,
-    graphId,
-    dialect,
-    logicalPlan,
-    schema
-  );
-}
-var SET_OPERATION_STRATEGY_HANDLERS = {
-  standard_parenthesized: compileSetOperationWithStandardParenthesizedStrategy,
-  sqlite_compound: compileSetOperationWithSqliteCompoundStrategy
-};
-function runSetOperationPassPipeline(op, graphId, dialect) {
-  let state = {
-    dialect,
-    graphId,
-    logicalPlan: void 0,
-    op
+
+// src/graph-extension/classify.ts
+function classifyModifications(existing, next) {
+  const incompatible = [];
+  const requireEmptyMutable = /* @__PURE__ */ new Map();
+  const recordIncompatible = (entry2) => {
+    incompatible.push(entry2);
   };
-  const logicalPlanPass = runCompilerPass(state, {
-    name: "logical_plan",
-    execute(currentState) {
-      return lowerSetOperationToLogicalPlan({
-        dialect: currentState.dialect.name,
-        graphId: currentState.graphId,
-        op: currentState.op
+  const recordRequireEmpty = (entity, entry2) => {
+    const key = `${entity}:${entry2.kind}`;
+    const existingEntry = requireEmptyMutable.get(key);
+    if (existingEntry === void 0) {
+      requireEmptyMutable.set(key, {
+        entity,
+        kindName: entry2.kind,
+        changes: [entry2]
       });
-    },
-    update(currentState, logicalPlan) {
-      return {
-        ...currentState,
-        logicalPlan
-      };
+    } else {
+      existingEntry.changes.push(entry2);
     }
-  });
-  state = logicalPlanPass.state;
-  return state;
-}
-function compileSetOperation(op, graphId, dialect, schema, compileQuery2) {
-  const passState = runSetOperationPassPipeline(op, graphId, dialect);
-  const { logicalPlan } = passState;
-  if (logicalPlan === void 0) {
-    throw new CompilerInvariantError(
-      "Logical plan pass did not initialize plan state"
+  };
+  for (const [name, nextNode] of Object.entries(next.nodes ?? {})) {
+    const existingNode = existing.nodes?.[name];
+    if (existingNode === void 0) continue;
+    classifyNode(name, existingNode, nextNode, {
+      recordIncompatible,
+      recordRequireEmpty: (entry2) => {
+        recordRequireEmpty("node", entry2);
+      }
+    });
+  }
+  for (const [name, nextEdge] of Object.entries(next.edges ?? {})) {
+    const existingEdge = existing.edges?.[name];
+    if (existingEdge === void 0) continue;
+    classifyEdge(name, existingEdge, nextEdge, {
+      recordIncompatible,
+      recordRequireEmpty: (entry2) => {
+        recordRequireEmpty("edge", entry2);
+      }
+    });
+  }
+  const requireEmpty = [];
+  for (const value of requireEmptyMutable.values()) {
+    requireEmpty.push(
+      Object.freeze({
+        entity: value.entity,
+        kindName: value.kindName,
+        changes: Object.freeze([...value.changes])
+      })
     );
   }
-  const strategy = dialect.capabilities.setOperationStrategy;
-  const handler = SET_OPERATION_STRATEGY_HANDLERS[strategy];
-  return handler(op, graphId, dialect, logicalPlan, schema, compileQuery2);
+  return { incompatible, requireEmpty };
 }
-function compileSetOperationStandard(op, graphId, dialect, logicalPlan, compileQuery2) {
-  const coreSql = compileSetOperationCoreStandard(
-    op,
-    graphId,
-    dialect,
-    compileQuery2
-  );
-  const suffixClauses = buildSetOperationSuffixClauses(op, dialect);
-  return emitSetOperationQuerySql({
-    baseQuery: coreSql,
-    logicalPlan,
-    ...suffixClauses.length === 0 ? {} : { suffixClauses }
-  });
+function buildIncompatibleChangeError(classification, nonEmpty, graphId) {
+  const promoted = [];
+  for (const entry2 of nonEmpty) {
+    promoted.push(...entry2.changes);
+  }
+  const all = [...classification.incompatible, ...promoted];
+  if (all.length === 0) return void 0;
+  return new IncompatibleChangeError(all, graphId);
 }
-function compileSetOperationCoreStandard(op, graphId, dialect, compileQuery2) {
-  const left = compileComposableQueryStandard(
-    op.left,
-    graphId,
-    dialect,
-    compileQuery2
-  );
-  const right = compileComposableQueryStandard(
-    op.right,
-    graphId,
-    dialect,
-    compileQuery2
-  );
-  const opSql = sql.raw(OPERATOR_MAP[op.operator]);
-  return sql`(${left}) ${opSql} (${right})`;
+function classifyNode(kind, existing, next, recorders) {
+  classifyProperties(kind, existing.properties, next.properties, recorders);
+  classifyUnique(kind, existing.unique ?? [], next.unique ?? [], recorders);
 }
-function compileComposableQueryStandard(query, graphId, dialect, compileQuery2) {
-  if ("__type" in query) {
-    return compileSetOperationCoreStandard(
-      query,
-      graphId,
-      dialect,
-      compileQuery2
-    );
+function classifyEdge(kind, existing, next, recorders) {
+  classifyProperties(
+    kind,
+    existing.properties ?? {},
+    next.properties ?? {},
+    recorders
+  );
+  classifyEdgeEndpoints(kind, existing, next, recorders);
+}
+function classifyEdgeEndpoints(kind, existing, next, recorders) {
+  const fromExisting = new Set(existing.from);
+  const toExisting = new Set(existing.to);
+  const fromNext = new Set(next.from);
+  const toNext = new Set(next.to);
+  for (const removed of [...fromExisting].filter(
+    (entry2) => !fromNext.has(entry2)
+  )) {
+    recorders.recordRequireEmpty({
+      kind,
+      type: "TIGHTEN_EDGE_ENDPOINTS",
+      detail: `removed "${removed}" from \`from\``
+    });
   }
-  return compileQuery2(query, graphId);
-}
-function runSqliteSetOperationValidationPass(op) {
-  const leaves = [];
-  collectLeafQueries(op, leaves, "q");
-  for (const leaf of leaves) {
-    validateSqliteSetOpLeaf(leaf.ast);
+  for (const removed of [...toExisting].filter((entry2) => !toNext.has(entry2))) {
+    recorders.recordRequireEmpty({
+      kind,
+      type: "TIGHTEN_EDGE_ENDPOINTS",
+      detail: `removed "${removed}" from \`to\``
+    });
   }
-  return { leaves };
 }
-function compileSetOperationForSqlite(op, graphId, dialect, logicalPlan, schema) {
-  const { leaves } = runSqliteSetOperationValidationPass(op);
-  const allCtes = [];
-  const ctx = {
-    dialect,
-    schema,
-    compileQuery: () => {
-      throw new CompilerInvariantError(
-        "compileQuery is not available in set-operation CTE compilation"
-      );
+function classifyProperties(kind, existing, next, recorders) {
+  const existingNames = new Set(Object.keys(existing));
+  const nextNames = new Set(Object.keys(next));
+  for (const name of existingNames) {
+    if (!nextNames.has(name)) {
+      recorders.recordIncompatible({
+        kind,
+        field: name,
+        type: "REMOVE_PROPERTY"
+      });
     }
-  };
-  for (const leaf of leaves) {
-    const cte = compilePrefixedStartCte(leaf.ast, leaf.prefix, graphId, ctx);
-    allCtes.push(cte);
   }
-  const selectStatements = [];
-  for (const leaf of leaves) {
-    const select = compilePrefixedSelect(leaf.ast, leaf.prefix, dialect);
-    selectStatements.push(select);
+  for (const name of nextNames) {
+    if (!existingNames.has(name)) {
+      const property = next[name];
+      if (property.optional === true) continue;
+      recorders.recordRequireEmpty({
+        kind,
+        field: name,
+        type: "ADD_REQUIRED_PROPERTY"
+      });
+    }
   }
-  const compoundSelect = buildCompoundSelect(op, leaves, selectStatements);
-  const suffixClauses = buildSetOperationSuffixClauses(op, dialect);
-  return emitSetOperationQuerySql({
-    baseQuery: compoundSelect,
-    ...allCtes.length === 0 ? {} : { ctes: allCtes },
+  for (const name of existingNames) {
+    if (!nextNames.has(name)) continue;
+    classifyProperty(kind, name, existing[name], next[name], recorders);
+  }
+}
+function classifyProperty(kind, field2, existing, next, recorders) {
+  if (existing.type !== next.type) {
+    recorders.recordIncompatible({
+      kind,
+      field: field2,
+      type: "TYPE_CHANGE",
+      detail: `${existing.type} \u2192 ${next.type}`
+    });
+    return;
+  }
+  const wasOptional = existing.optional === true;
+  const isOptional = next.optional === true;
+  if (!wasOptional && isOptional) ; else if (wasOptional && !isOptional) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_OPTIONALITY",
+      detail: "optional: true \u2192 false"
+    });
+  }
+  switch (existing.type) {
+    case "string": {
+      classifyString(
+        kind,
+        field2,
+        existing,
+        next,
+        recorders
+      );
+      break;
+    }
+    case "number": {
+      classifyNumber(
+        kind,
+        field2,
+        existing,
+        next,
+        recorders
+      );
+      break;
+    }
+    case "enum": {
+      classifyEnum(
+        kind,
+        field2,
+        existing,
+        next,
+        recorders
+      );
+      break;
+    }
+    case "array": {
+      classifyArray(
+        kind,
+        field2,
+        existing,
+        next,
+        recorders
+      );
+      break;
+    }
+    case "object": {
+      classifyObject(
+        kind,
+        field2,
+        existing,
+        next,
+        recorders
+      );
+      break;
+    }
+  }
+}
+function classifyString(kind, field2, existing, next, recorders) {
+  if (existing.minLength !== next.minLength && next.minLength !== void 0 && (existing.minLength === void 0 || next.minLength > existing.minLength)) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_CONSTRAINT",
+      detail: `minLength: ${existing.minLength ?? "(none)"} \u2192 ${next.minLength}`
+    });
+  }
+  if (existing.maxLength !== next.maxLength && next.maxLength !== void 0 && (existing.maxLength === void 0 || next.maxLength < existing.maxLength)) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_CONSTRAINT",
+      detail: `maxLength: ${existing.maxLength ?? "(none)"} \u2192 ${next.maxLength}`
+    });
+  }
+  if (existing.pattern !== next.pattern) {
+    if (existing.pattern === void 0 && next.pattern !== void 0) {
+      recorders.recordRequireEmpty({
+        kind,
+        field: field2,
+        type: "ADD_PATTERN",
+        detail: next.pattern
+      });
+    } else if (existing.pattern !== void 0 && next.pattern === void 0) ; else if (existing.pattern !== void 0 && next.pattern !== void 0 && existing.pattern !== next.pattern) {
+      recorders.recordRequireEmpty({
+        kind,
+        field: field2,
+        type: "CHANGE_PATTERN",
+        detail: `${existing.pattern} \u2192 ${next.pattern}`
+      });
+    }
+  }
+  if (existing.format !== next.format) {
+    if (existing.format === void 0 && next.format !== void 0) {
+      recorders.recordRequireEmpty({
+        kind,
+        field: field2,
+        type: "ADD_FORMAT",
+        detail: next.format
+      });
+    } else if (existing.format !== void 0 && next.format === void 0) ; else {
+      recorders.recordRequireEmpty({
+        kind,
+        field: field2,
+        type: "CHANGE_FORMAT",
+        detail: `${existing.format} \u2192 ${next.format}`
+      });
+    }
+  }
+}
+function classifyNumber(kind, field2, existing, next, recorders) {
+  if (next.min !== void 0 && (existing.min === void 0 || next.min > existing.min)) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_CONSTRAINT",
+      detail: `min: ${existing.min ?? "(none)"} \u2192 ${next.min}`
+    });
+  }
+  if (next.max !== void 0 && (existing.max === void 0 || next.max < existing.max)) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_CONSTRAINT",
+      detail: `max: ${existing.max ?? "(none)"} \u2192 ${next.max}`
+    });
+  }
+  if (existing.int !== next.int && next.int === true && existing.int !== true) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_INT",
+      detail: "int: false \u2192 true"
+    });
+  }
+}
+function classifyEnum(kind, field2, existing, next, recorders) {
+  const nextValues = new Set(next.values);
+  const removed = existing.values.filter((value) => !nextValues.has(value));
+  if (removed.length > 0) {
+    recorders.recordRequireEmpty({
+      kind,
+      field: field2,
+      type: "TIGHTEN_ENUM",
+      detail: `removed values: ${removed.join(", ")}`
+    });
+  }
+}
+function classifyArray(kind, field2, existing, next, recorders) {
+  if (existing.items.type !== next.items.type) {
+    recorders.recordIncompatible({
+      kind,
+      field: `${field2}.items`,
+      type: "TYPE_CHANGE",
+      detail: `${existing.items.type} \u2192 ${next.items.type}`
+    });
+    return;
+  }
+  classifyProperty(
+    kind,
+    `${field2}.items`,
+    existing.items,
+    next.items,
+    recorders
+  );
+}
+function classifyObject(kind, field2, existing, next, recorders) {
+  classifyProperties(kind, existing.properties, next.properties, {
+    recordIncompatible: (entry2) => {
+      recorders.recordIncompatible({
+        ...entry2,
+        field: `${field2}.${entry2.field ?? ""}`
+      });
+    },
+    recordRequireEmpty: (entry2) => {
+      recorders.recordRequireEmpty({
+        ...entry2,
+        field: `${field2}.${entry2.field ?? ""}`
+      });
+    }
+  });
+}
+function classifyUnique(kind, existing, next, recorders) {
+  const existingByName = new Map(
+    existing.map((constraint) => [constraint.name, constraint])
+  );
+  const nextByName = new Map(
+    next.map((constraint) => [constraint.name, constraint])
+  );
+  for (const [name, constraint] of nextByName) {
+    if (!existingByName.has(name)) {
+      recorders.recordRequireEmpty({
+        kind,
+        type: "ADD_UNIQUE_ON_POPULATED",
+        detail: `unique constraint "${name}" on [${constraint.fields.join(", ")}]`
+      });
+    }
+  }
+  for (const [name, constraint] of existingByName) {
+    const newOne = nextByName.get(name);
+    if (newOne === void 0) continue;
+    const { name: _existingName, ...existingShape } = constraint;
+    const { name: _nextName, ...nextShape } = newOne;
+    if (!canonicalEqual(existingShape, nextShape)) {
+      recorders.recordRequireEmpty({
+        kind,
+        type: "ADD_UNIQUE_ON_POPULATED",
+        detail: `unique constraint "${name}" reshaped`
+      });
+    }
+  }
+}
+
+// src/graph-extension/remove.ts
+function planRemovals(graph, names) {
+  const document = graph.extension;
+  const namesSet = new Set(names);
+  if (namesSet.size === 0) {
+    return { document, removedNodeKinds: [], removedEdgeKinds: [] };
+  }
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(document);
+  const compileTimeNodeNames = new Set(
+    Object.keys(graph.nodes).filter((name) => !runtimeNodeNames.has(name))
+  );
+  const compileTimeEdgeNames = new Set(
+    Object.keys(graph.edges).filter((name) => !runtimeEdgeNames.has(name))
+  );
+  for (const name of namesSet) {
+    if (compileTimeNodeNames.has(name)) {
+      throw new RemoveCompileTimeKindError(name, "node", graph.id);
+    }
+    if (compileTimeEdgeNames.has(name)) {
+      throw new RemoveCompileTimeKindError(name, "edge", graph.id);
+    }
+  }
+  const removedNodeKinds = [...namesSet].filter(
+    (name) => runtimeNodeNames.has(name)
+  );
+  const explicitlyRemovedEdgeKinds = [...namesSet].filter(
+    (name) => runtimeEdgeNames.has(name)
+  );
+  const referentsByKind = buildCompileTimeReferentIndex(
+    graph,
+    runtimeEdgeNames
+  );
+  for (const kindName of removedNodeKinds) {
+    const referents = referentsByKind.get(kindName);
+    if (referents !== void 0 && referents.length > 0) {
+      throw new KindHasReferentsError(kindName, referents, graph.id);
+    }
+  }
+  if (document === void 0) {
+    return {
+      document: void 0,
+      removedNodeKinds: [],
+      removedEdgeKinds: []
+    };
+  }
+  const removedNodeKindsSet = new Set(removedNodeKinds);
+  const explicitlyRemovedEdgeKindsSet = new Set(explicitlyRemovedEdgeKinds);
+  const cascadeEdges = /* @__PURE__ */ new Set();
+  const updatedEdges = {};
+  for (const [edgeName, edgeDocument] of Object.entries(document.edges ?? {})) {
+    if (explicitlyRemovedEdgeKindsSet.has(edgeName)) {
+      cascadeEdges.add(edgeName);
+      continue;
+    }
+    const newFrom = edgeDocument.from.filter(
+      (kind) => !removedNodeKindsSet.has(kind)
+    );
+    const newTo = edgeDocument.to.filter(
+      (kind) => !removedNodeKindsSet.has(kind)
+    );
+    if (newFrom.length === 0 || newTo.length === 0) {
+      cascadeEdges.add(edgeName);
+      continue;
+    }
+    updatedEdges[edgeName] = {
+      ...edgeDocument,
+      from: newFrom,
+      to: newTo
+    };
+  }
+  const updatedNodes = {};
+  for (const [nodeName, nodeDocument] of Object.entries(document.nodes ?? {})) {
+    if (removedNodeKindsSet.has(nodeName)) continue;
+    updatedNodes[nodeName] = nodeDocument;
+  }
+  const survivingOntology = (document.ontology ?? []).filter(
+    (relation) => !removedNodeKindsSet.has(relation.from) && !removedNodeKindsSet.has(relation.to)
+  );
+  const allRemovedKinds = /* @__PURE__ */ new Set([
+    ...removedNodeKindsSet,
+    ...cascadeEdges,
+    ...explicitlyRemovedEdgeKindsSet
+  ]);
+  const survivingIndexes = (document.indexes ?? []).filter(
+    (index) => !allRemovedKinds.has(index.kind)
+  );
+  const newDocument = Object.freeze({
+    ...document.version === void 0 ? {} : { version: document.version },
+    ...Object.keys(updatedNodes).length === 0 ? {} : { nodes: updatedNodes },
+    ...Object.keys(updatedEdges).length === 0 ? {} : { edges: updatedEdges },
+    ...survivingOntology.length === 0 ? {} : { ontology: survivingOntology },
+    ...survivingIndexes.length === 0 ? {} : { indexes: survivingIndexes }
+  });
+  return {
+    document: newDocument,
+    removedNodeKinds,
+    removedEdgeKinds: [
+      ...explicitlyRemovedEdgeKinds,
+      ...[...cascadeEdges].filter(
+        (name) => !explicitlyRemovedEdgeKindsSet.has(name)
+      )
+    ]
+  };
+}
+function stripGraphExtension(graph) {
+  const document = graph.extension;
+  if (document === void 0) return graph;
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(document);
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(document);
+  const compileNodes = {};
+  for (const [name, registration] of Object.entries(graph.nodes)) {
+    if (runtimeNodeNames.has(name)) continue;
+    compileNodes[name] = registration;
+  }
+  const compileEdges = {};
+  for (const [name, registration] of Object.entries(graph.edges)) {
+    if (runtimeEdgeNames.has(name)) continue;
+    compileEdges[name] = registration;
+  }
+  const compileOntology = graph.ontology.filter(
+    (relation) => !runtimeOntologyKeys.has(compileTimeOntologyKey(relation))
+  );
+  const compileIndexes = (graph.indexes ?? []).filter(
+    (index) => index.origin !== "runtime"
+  );
+  return Object.freeze({
+    ...graph,
+    nodes: compileNodes,
+    edges: compileEdges,
+    ontology: compileOntology,
+    indexes: compileIndexes.length === 0 ? void 0 : compileIndexes,
+    extension: void 0
+  });
+}
+function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
+  const index = /* @__PURE__ */ new Map();
+  const append = (kindName, referent) => {
+    const existing = index.get(kindName);
+    if (existing === void 0) index.set(kindName, [referent]);
+    else existing.push(referent);
+  };
+  for (const [edgeName, registration] of Object.entries(graph.edges)) {
+    if (runtimeEdgeNames.has(edgeName)) continue;
+    const reg = registration;
+    const referent = {
+      type: "compile-time-edge",
+      name: edgeName
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const endpoint of reg.from ?? []) {
+      if (seen.has(endpoint.kind)) continue;
+      seen.add(endpoint.kind);
+      append(endpoint.kind, referent);
+    }
+    for (const endpoint of reg.to ?? []) {
+      if (seen.has(endpoint.kind)) continue;
+      seen.add(endpoint.kind);
+      append(endpoint.kind, referent);
+    }
+  }
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(
+    graph.extension
+  );
+  for (const relation of graph.ontology) {
+    if (runtimeOntologyKeys.has(compileTimeOntologyKey(relation))) continue;
+    const fromName = getTypeName(relation.from);
+    const toName = getTypeName(relation.to);
+    const referent = {
+      type: "compile-time-ontology",
+      name: `${relation.metaEdge.name}(${fromName}, ${toName})`
+    };
+    append(fromName, referent);
+    if (toName !== fromName) append(toName, referent);
+  }
+  return index;
+}
+var OPERATOR_MAP = {
+  union: "UNION",
+  unionAll: "UNION ALL",
+  intersect: "INTERSECT",
+  except: "EXCEPT"
+};
+function compileSetOperationWithStandardParenthesizedStrategy(op, graphId, dialect, logicalPlan, _schema, compileQuery2) {
+  return compileSetOperationStandard(
+    op,
+    graphId,
+    dialect,
+    logicalPlan,
+    compileQuery2
+  );
+}
+function compileSetOperationWithSqliteCompoundStrategy(op, graphId, dialect, logicalPlan, schema, _compileQuery) {
+  return compileSetOperationForSqlite(
+    op,
+    graphId,
+    dialect,
+    logicalPlan,
+    schema
+  );
+}
+var SET_OPERATION_STRATEGY_HANDLERS = {
+  standard_parenthesized: compileSetOperationWithStandardParenthesizedStrategy,
+  sqlite_compound: compileSetOperationWithSqliteCompoundStrategy
+};
+function runSetOperationPassPipeline(op, graphId, dialect) {
+  let state = {
+    dialect,
+    graphId,
+    logicalPlan: void 0,
+    op
+  };
+  const logicalPlanPass = runCompilerPass(state, {
+    name: "logical_plan",
+    execute(currentState) {
+      return lowerSetOperationToLogicalPlan({
+        dialect: currentState.dialect.name,
+        graphId: currentState.graphId,
+        op: currentState.op
+      });
+    },
+    update(currentState, logicalPlan) {
+      return {
+        ...currentState,
+        logicalPlan
+      };
+    }
+  });
+  state = logicalPlanPass.state;
+  return state;
+}
+function compileSetOperation(op, graphId, dialect, schema, compileQuery2) {
+  const passState = runSetOperationPassPipeline(op, graphId, dialect);
+  const { logicalPlan } = passState;
+  if (logicalPlan === void 0) {
+    throw new CompilerInvariantError(
+      "Logical plan pass did not initialize plan state"
+    );
+  }
+  const strategy = dialect.capabilities.setOperationStrategy;
+  const handler = SET_OPERATION_STRATEGY_HANDLERS[strategy];
+  return handler(op, graphId, dialect, logicalPlan, schema, compileQuery2);
+}
+function compileSetOperationStandard(op, graphId, dialect, logicalPlan, compileQuery2) {
+  const coreSql = compileSetOperationCoreStandard(
+    op,
+    graphId,
+    dialect,
+    compileQuery2
+  );
+  const suffixClauses = buildSetOperationSuffixClauses(op, dialect);
+  return emitSetOperationQuerySql({
+    baseQuery: coreSql,
+    logicalPlan,
+    ...suffixClauses.length === 0 ? {} : { suffixClauses }
+  });
+}
+function compileSetOperationCoreStandard(op, graphId, dialect, compileQuery2) {
+  const left = compileComposableQueryStandard(
+    op.left,
+    graphId,
+    dialect,
+    compileQuery2
+  );
+  const right = compileComposableQueryStandard(
+    op.right,
+    graphId,
+    dialect,
+    compileQuery2
+  );
+  const opSql = sql.raw(OPERATOR_MAP[op.operator]);
+  return sql`(${left}) ${opSql} (${right})`;
+}
+function compileComposableQueryStandard(query, graphId, dialect, compileQuery2) {
+  if ("__type" in query) {
+    return compileSetOperationCoreStandard(
+      query,
+      graphId,
+      dialect,
+      compileQuery2
+    );
+  }
+  return compileQuery2(query, graphId);
+}
+function runSqliteSetOperationValidationPass(op) {
+  const leaves = [];
+  collectLeafQueries(op, leaves, "q");
+  for (const leaf of leaves) {
+    validateSqliteSetOpLeaf(leaf.ast);
+  }
+  return { leaves };
+}
+function compileSetOperationForSqlite(op, graphId, dialect, logicalPlan, schema) {
+  const { leaves } = runSqliteSetOperationValidationPass(op);
+  const allCtes = [];
+  const ctx = {
+    dialect,
+    schema,
+    compileQuery: () => {
+      throw new CompilerInvariantError(
+        "compileQuery is not available in set-operation CTE compilation"
+      );
+    }
+  };
+  for (const leaf of leaves) {
+    const cte = compilePrefixedStartCte(leaf.ast, leaf.prefix, graphId, ctx);
+    allCtes.push(cte);
+  }
+  const selectStatements = [];
+  for (const leaf of leaves) {
+    const select = compilePrefixedSelect(leaf.ast, leaf.prefix, dialect);
+    selectStatements.push(select);
+  }
+  const compoundSelect = buildCompoundSelect(op, leaves, selectStatements);
+  const suffixClauses = buildSetOperationSuffixClauses(op, dialect);
+  return emitSetOperationQuerySql({
+    baseQuery: compoundSelect,
+    ...allCtes.length === 0 ? {} : { ctes: allCtes },
     logicalPlan,
     ...suffixClauses.length === 0 ? {} : { suffixClauses }
   });
@@ -8148,6 +8365,45 @@ var ExecutableQuery = class _ExecutableQuery {
   }
 };
 
+// src/query/builder/dynamic.ts
+function describeKindContext(entity, kindNames) {
+  if (kindNames === void 0 || kindNames.length === 0) {
+    return `${entity} (kind unresolved)`;
+  }
+  const list = kindNames.map((k) => `"${k}"`).join(" | ");
+  return `${entity} kind${kindNames.length > 1 ? "s" : ""} ${list}`;
+}
+function createDynamicFieldBuilder(introspector, alias, name, kindNames, entity) {
+  const typeInfo = kindNames === void 0 ? void 0 : entity === "node" ? introspector.getSharedFieldTypeInfo(kindNames, name) : introspector.getSharedEdgeFieldTypeInfo(kindNames, name);
+  const where = describeKindContext(entity, kindNames);
+  if (typeInfo === void 0) {
+    throw new Error(`Property "${name}" is not declared on ${where}.`);
+  }
+  const ref = fieldRef(alias, ["props"], {
+    jsonPointer: jsonPointer([name]),
+    valueType: typeInfo.valueType,
+    elementType: typeInfo.elementType
+  });
+  const base = buildFieldBuilderForTypeInfo(ref, typeInfo);
+  const expect = (asserted) => {
+    if (typeInfo.valueType !== asserted) {
+      throw new TypeError(
+        `Property "${name}" on ${where} is ${typeInfo.valueType}, not ${asserted}.`
+      );
+    }
+    return base;
+  };
+  return {
+    ...base,
+    string: () => expect("string"),
+    number: () => expect("number"),
+    date: () => expect("date"),
+    array: () => expect("array"),
+    object: () => expect("object"),
+    embedding: () => expect("embedding")
+  };
+}
+
 // src/query/builder/executable-aggregate-query.ts
 var NOT_COMPUTED2 = /* @__PURE__ */ Symbol("NOT_COMPUTED");
 var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
@@ -8478,6 +8734,21 @@ var TraversalBuilder = class _TraversalBuilder {
         }
       }
     };
+    if (this.#state.dynamicEdgeAliases.has(alias)) {
+      return {
+        id: idAccessor,
+        kind: kindAccessor,
+        fromId: fromIdAccessor,
+        toId: toIdAccessor,
+        field: (name) => createDynamicFieldBuilder(
+          this.#config.schemaIntrospector,
+          alias,
+          name,
+          allEdgeKinds,
+          "edge"
+        )
+      };
+    }
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
@@ -8495,6 +8766,35 @@ var TraversalBuilder = class _TraversalBuilder {
     validateSqlIdentifier(alias);
     const includeSubClasses = options?.includeSubClasses ?? false;
     const kinds = includeSubClasses ? this.#config.registry.expandSubClasses(kind) : [kind];
+    const newState = this.#stateWithTraversal(alias, kinds);
+    return new QueryBuilderClass(this.#config, newState);
+  }
+  /**
+   * String-keyed sibling of `to` for runtime-declared target kinds.
+   * Throws `KindNotFoundError` if the kind is not registered.
+   */
+  toDynamic(kind, alias, options) {
+    validateSqlIdentifier(alias);
+    if (!this.#config.registry.hasNodeType(kind)) {
+      throw new KindNotFoundError(kind, "node", {
+        graphId: this.#config.graphId
+      });
+    }
+    this.#assertValidEndpoint(kind);
+    const includeSubClasses = options?.includeSubClasses ?? false;
+    const kinds = includeSubClasses ? this.#config.registry.expandSubClasses(kind) : [kind];
+    const baseState = this.#stateWithTraversal(alias, kinds);
+    const newState = {
+      ...baseState,
+      dynamicNodeAliases: /* @__PURE__ */ new Set([...baseState.dynamicNodeAliases, alias])
+    };
+    return new QueryBuilderClass(this.#config, newState);
+  }
+  /**
+   * Builds the next `QueryBuilderState` after appending a traversal
+   * targeting `alias` with `kinds`. Shared by `to` and `toDynamic`.
+   */
+  #stateWithTraversal(alias, kinds) {
     const traversalBase = {
       edgeAlias: this.#edgeAlias,
       edgeKinds: this.#edgeKinds,
@@ -8520,14 +8820,53 @@ var TraversalBuilder = class _TraversalBuilder {
         }
       }
     } : baseTraversal;
-    const newState = {
+    return {
       ...this.#state,
       traversals: [...this.#state.traversals, traversal],
       predicates: [...this.#state.predicates, ...this.#pendingEdgePredicates],
       currentAlias: alias
-      // Update current alias to this traversal's target
     };
-    return new QueryBuilderClass(this.#config, newState);
+  }
+  /**
+   * Asserts a runtime-declared target kind is a valid endpoint for the
+   * current traversal. Mirrors the compile-time `ValidEdgeTargets`
+   * constraint enforced by `to(...)` — without this check `toDynamic`
+   * would silently accept e.g. `traverseDynamic("authoredBy") +
+   * toDynamic("Document")` where authoredBy.to=[Author] and produce an
+   * empty result set.
+   *
+   * Permissive on unions: if the target is assignable to any valid
+   * endpoint across the edges being traversed, accept. Subclass
+   * relationships are honored via `registry.isAssignableTo`.
+   */
+  #assertValidEndpoint(targetKind) {
+    const expectedKinds = /* @__PURE__ */ new Set();
+    const collectFromEdge = (edgeName, side) => {
+      const edgeType = this.#config.registry.getEdgeType(edgeName);
+      const endpoints = edgeType?.[side];
+      if (!endpoints) return;
+      for (const endpoint of endpoints) {
+        expectedKinds.add(endpoint.kind);
+      }
+    };
+    const forwardSide = this.#direction === "out" ? "to" : "from";
+    const inverseSide = this.#direction === "out" ? "from" : "to";
+    for (const edgeName of this.#edgeKinds) {
+      collectFromEdge(edgeName, forwardSide);
+    }
+    for (const edgeName of this.#inverseEdgeKinds) {
+      collectFromEdge(edgeName, inverseSide);
+    }
+    if (expectedKinds.size === 0) return;
+    for (const expected of expectedKinds) {
+      if (this.#config.registry.isAssignableTo(targetKind, expected)) return;
+    }
+    throw new EndpointError({
+      edgeKind: this.#edgeKinds[0] ?? "(unknown)",
+      endpoint: forwardSide,
+      actualKind: targetKind,
+      expectedKinds: [...expectedKinds]
+    });
   }
 };
 
@@ -8647,6 +8986,30 @@ var QueryBuilder = class _QueryBuilder {
     };
     return new _QueryBuilder(this.#config, newState);
   }
+  /**
+   * String-keyed sibling of `from` for runtime-declared kinds. Throws
+   * `KindNotFoundError` if the kind is not registered. Predicates use
+   * the `n.field("name").number().gte(...)` discriminator.
+   */
+  fromDynamic(kind, alias, options) {
+    validateSqlIdentifier(alias);
+    if (!this.#config.registry.hasNodeType(kind)) {
+      throw new KindNotFoundError(kind, "node", {
+        graphId: this.#config.graphId
+      });
+    }
+    const includeSubClasses = options?.includeSubClasses ?? false;
+    const kinds = includeSubClasses ? this.#config.registry.expandSubClasses(kind) : [kind];
+    const newState = {
+      ...this.#state,
+      startAlias: alias,
+      currentAlias: alias,
+      startKinds: kinds,
+      includeSubClasses,
+      dynamicNodeAliases: /* @__PURE__ */ new Set([...this.#state.dynamicNodeAliases, alias])
+    };
+    return new _QueryBuilder(this.#config, newState);
+  }
   /**
    * Adds a WHERE clause for a node.
    */
@@ -8714,6 +9077,13 @@ var QueryBuilder = class _QueryBuilder {
       false
     );
   }
+  /**
+   * String-keyed sibling of `traverse` for runtime-declared edge kinds.
+   * Throws `KindNotFoundError` if the edge kind is not registered.
+   */
+  traverseDynamic(edgeKind, edgeAlias, options) {
+    return this.#beginDynamicTraversal(edgeKind, edgeAlias, false, options);
+  }
   optionalTraverse(edgeKind, edgeAlias, options) {
     validateSqlIdentifier(edgeAlias);
     const direction = options?.direction ?? "out";
@@ -8737,6 +9107,55 @@ var QueryBuilder = class _QueryBuilder {
       true
     );
   }
+  /**
+   * String-keyed sibling of `optionalTraverse` for runtime-declared edge
+   * kinds. LEFT JOIN semantics — non-matching rows produce a null edge
+   * alias instead of dropping. Throws `KindNotFoundError` if the edge
+   * kind is not registered.
+   */
+  optionalTraverseDynamic(edgeKind, edgeAlias, options) {
+    return this.#beginDynamicTraversal(edgeKind, edgeAlias, true, options);
+  }
+  /**
+   * Shared body for `traverseDynamic` and `optionalTraverseDynamic`.
+   * The only difference is the `optional` flag passed to the
+   * `TraversalBuilder` constructor.
+   */
+  #beginDynamicTraversal(edgeKind, edgeAlias, optional, options) {
+    validateSqlIdentifier(edgeAlias);
+    if (!this.#config.registry.hasEdgeType(edgeKind)) {
+      throw new KindNotFoundError(edgeKind, "edge", {
+        graphId: this.#config.graphId
+      });
+    }
+    const direction = options?.direction ?? "out";
+    const expansion = options?.expand ?? this.#config.defaultTraversalExpansion;
+    const includeImplyingEdges = expansion === "implying" || expansion === "all";
+    const includeInverseEdges = expansion === "inverse" || expansion === "all";
+    const fromAlias = options?.from ?? this.#state.currentAlias;
+    const edgeKinds = this.#expandTraversalEdgeKinds(
+      edgeKind,
+      includeImplyingEdges
+    );
+    const inverseEdgeKinds = includeInverseEdges ? this.#expandInverseTraversalEdgeKinds(edgeKinds, includeImplyingEdges) : [];
+    const newState = {
+      ...this.#state,
+      dynamicEdgeAliases: /* @__PURE__ */ new Set([
+        ...this.#state.dynamicEdgeAliases,
+        edgeAlias
+      ])
+    };
+    return new TraversalBuilder(
+      this.#config,
+      newState,
+      edgeKinds,
+      edgeAlias,
+      direction,
+      fromAlias,
+      inverseEdgeKinds,
+      optional
+    );
+  }
   /**
    * Selects fields to return.
    */
@@ -9046,6 +9465,20 @@ var QueryBuilder = class _QueryBuilder {
       alias,
       () => this.#hasSearchableField(kindNames)
     );
+    if (this.#state.dynamicNodeAliases.has(alias)) {
+      return {
+        id: idAccessor,
+        kind: kindAccessor,
+        $fulltext: fulltextAccessor,
+        field: (name) => createDynamicFieldBuilder(
+          this.#config.schemaIntrospector,
+          alias,
+          name,
+          kindNames,
+          "node"
+        )
+      };
+    }
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
@@ -9124,6 +9557,21 @@ var QueryBuilder = class _QueryBuilder {
     const toIdAccessor = stringField(
       fieldRef(alias, ["to_id"], { valueType: "string" })
     );
+    if (this.#state.dynamicEdgeAliases.has(alias)) {
+      return {
+        id: idAccessor,
+        kind: kindAccessor,
+        fromId: fromIdAccessor,
+        toId: toIdAccessor,
+        field: (name) => createDynamicFieldBuilder(
+          this.#config.schemaIntrospector,
+          alias,
+          name,
+          edgeKindNames,
+          "edge"
+        )
+      };
+    }
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
@@ -9543,7 +9991,9 @@ function createQueryBuilder(graphId, registry, options) {
     asOf: void 0,
     groupBy: void 0,
     having: void 0,
-    fusion: void 0
+    fusion: void 0,
+    dynamicNodeAliases: /* @__PURE__ */ new Set(),
+    dynamicEdgeAliases: /* @__PURE__ */ new Set()
   };
   return new QueryBuilder(config, initialState);
 }
@@ -10071,17 +10521,17 @@ function createEdgeCollection(config) {
         }
         const results = Array.from({ length: items.length });
         if (toCreate.length > 0) {
-          const createInputs = toCreate.map((entry) => entry.input);
+          const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeEdgeCreateBatch2(createInputs, target);
-          for (const [index, entry] of toCreate.entries()) {
-            results[entry.index] = narrowEdge(created[index]);
+          for (const [index, entry2] of toCreate.entries()) {
+            results[entry2.index] = narrowEdge(created[index]);
           }
         }
-        for (const entry of toUpdate) {
-          const result = await executeEdgeUpsertUpdate2(entry.input, target, {
-            clearDeleted: entry.clearDeleted
+        for (const entry2 of toUpdate) {
+          const result = await executeEdgeUpsertUpdate2(entry2.input, target, {
+            clearDeleted: entry2.clearDeleted
           });
-          results[entry.index] = narrowEdge(result);
+          results[entry2.index] = narrowEdge(result);
         }
         return results;
       };
@@ -10392,17 +10842,17 @@ function createNodeCollection(config) {
         }
         const results = Array.from({ length: items.length });
         if (toCreate.length > 0) {
-          const createInputs = toCreate.map((entry) => entry.input);
+          const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeNodeCreateBatch2(createInputs, target);
-          for (const [index, entry] of toCreate.entries()) {
-            results[entry.index] = narrowNode(created[index]);
+          for (const [index, entry2] of toCreate.entries()) {
+            results[entry2.index] = narrowNode(created[index]);
           }
         }
-        for (const entry of toUpdate) {
-          const result = await executeNodeUpsertUpdate2(entry.input, target, {
-            clearDeleted: entry.clearDeleted
+        for (const entry2 of toUpdate) {
+          const result = await executeNodeUpsertUpdate2(entry2.input, target, {
+            clearDeleted: entry2.clearDeleted
           });
-          results[entry.index] = narrowNode(result);
+          results[entry2.index] = narrowNode(result);
         }
         return results;
       };
@@ -10498,51 +10948,614 @@ function createNodeCollection(config) {
     }
   };
 }
-
-// src/store/collection-factory.ts
-function createNodeCollectionsProxy(graph, graphId, registry, backend, operations) {
-  const collectionCache = /* @__PURE__ */ new Map();
-  return new Proxy({}, {
-    get: (_, kind) => {
-      if (!Object.hasOwn(graph.nodes, kind)) {
-        throw new KindNotFoundError(kind, "node");
-      }
-      const cached = collectionCache.get(kind);
-      if (cached !== void 0) {
-        return cached;
+
+// src/store/collection-factory.ts
+function createNodeCollectionsProxy(graph, graphId, registry, backend, operations) {
+  const collectionCache = /* @__PURE__ */ new Map();
+  return new Proxy({}, {
+    get: (_, kind) => {
+      if (!Object.hasOwn(graph.nodes, kind)) {
+        throw new KindNotFoundError(kind, "node");
+      }
+      const cached = collectionCache.get(kind);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const collection = createNodeCollection({
+        graphId,
+        kind,
+        backend,
+        ...operations
+      });
+      collectionCache.set(kind, collection);
+      return collection;
+    }
+  });
+}
+function createEdgeCollectionsProxy(graph, graphId, registry, backend, operations) {
+  const collectionCache = /* @__PURE__ */ new Map();
+  return new Proxy({}, {
+    get: (_, kind) => {
+      if (!Object.hasOwn(graph.edges, kind)) {
+        throw new KindNotFoundError(kind, "edge");
+      }
+      const cached = collectionCache.get(kind);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const collection = createEdgeCollection({
+        graphId,
+        kind,
+        backend,
+        ...operations
+      });
+      collectionCache.set(kind, collection);
+      return collection;
+    }
+  });
+}
+
+// src/store/introspect.ts
+function introspectSchema(graph, context) {
+  const extension = graph.extension;
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(extension);
+  const deprecated = graph.deprecatedKinds;
+  const kinds = [];
+  for (const [name, registration] of Object.entries(graph.nodes)) {
+    const reg = registration;
+    kinds.push({
+      name,
+      origin: runtimeNodeNames.has(name) ? "runtime" : "compile-time",
+      description: reg.type.description,
+      annotations: reg.type.annotations,
+      deprecated: deprecated.has(name),
+      properties: serializeSchemaProperties(reg.type.schema),
+      unique: (reg.unique ?? []).map((constraint) => ({
+        name: constraint.name,
+        fields: [...constraint.fields],
+        scope: constraint.scope,
+        collation: constraint.collation
+      }))
+    });
+  }
+  const edges = [];
+  for (const [name, registration] of Object.entries(graph.edges)) {
+    const reg = registration;
+    const edgeType = reg.type;
+    edges.push({
+      name,
+      origin: runtimeEdgeNames.has(name) ? "runtime" : "compile-time",
+      description: edgeType.description,
+      from: reg.from.map((entry2) => entry2.kind),
+      to: reg.to.map((entry2) => entry2.kind),
+      cardinality: reg.cardinality ?? "many",
+      endpointExistence: reg.endpointExistence ?? "notDeleted",
+      properties: serializeSchemaProperties(edgeType.schema),
+      annotations: edgeType.annotations,
+      deprecated: deprecated.has(name)
+    });
+  }
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(extension);
+  const ontology = graph.ontology.map((relation) => ({
+    metaEdge: relation.metaEdge.name,
+    from: getTypeName(relation.from),
+    to: getTypeName(relation.to),
+    origin: runtimeOntologyKeys.has(compileTimeOntologyKey(relation)) ? "runtime" : "compile-time"
+  }));
+  return {
+    graphId: context.graphId,
+    schemaVersion: context.schemaVersion,
+    schemaHash: context.schemaHash,
+    kinds,
+    edges,
+    ontology,
+    deprecatedKinds: new Set(deprecated),
+    extension
+  };
+}
+
+// src/store/materialize-shared.ts
+async function ensureFocusedStatusTable(backend, ensureFocused) {
+  if (ensureFocused !== void 0) {
+    await ensureFocused();
+    return;
+  }
+  await backend.bootstrapTables?.();
+}
+async function runMaterialization(items, options, runOne) {
+  if (options.stopOnError === true) {
+    const results = [];
+    for (const item of items) {
+      const entry2 = await runOne(item);
+      results.push(entry2);
+      if (entry2.status === "failed") break;
+    }
+    return results;
+  }
+  return Promise.all(items.map((item) => runOne(item)));
+}
+
+// src/store/materialize-indexes.ts
+async function materializeIndexes(context, options = {}) {
+  const { graph, graphId, backend, schemaVersion } = context;
+  if (backend.executeDdl === void 0) {
+    throw new ConfigurationError(
+      "store.materializeIndexes() requires a backend with `executeDdl` support. The bundled SQLite and Postgres backends provide it; a custom backend without `executeDdl` cannot run index DDL.",
+      { code: "MATERIALIZE_BACKEND_UNSUPPORTED" }
+    );
+  }
+  if (backend.getIndexMaterialization === void 0 || backend.recordIndexMaterialization === void 0) {
+    throw new ConfigurationError(
+      "store.materializeIndexes() requires a backend with index materialization status primitives. The bundled SQLite and Postgres backends provide them; a custom backend must implement `getIndexMaterialization` and `recordIndexMaterialization`.",
+      { code: "MATERIALIZE_BACKEND_UNSUPPORTED" }
+    );
+  }
+  const declared = graph.indexes ?? [];
+  const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+  if (kindFilter !== void 0) {
+    for (const name of kindFilter) {
+      if (!isKnownKind(graph, name)) {
+        throw new KindNotFoundError(
+          name,
+          Object.hasOwn(graph.edges, name) ? "edge" : "node",
+          {
+            graphId,
+            suggestion: "Only kinds declared on the graph (compile-time or runtime) can be passed to materializeIndexes."
+          }
+        );
+      }
+    }
+  }
+  const candidates = declared.filter(
+    (index) => kindFilter === void 0 ? true : kindFilter.has(index.kind)
+  );
+  if (candidates.length === 0) {
+    return { results: [] };
+  }
+  await ensureFocusedStatusTable(
+    backend,
+    backend.ensureIndexMaterializationsTable
+  );
+  const dialect = backend.dialect;
+  const tableNames = backend.tableNames;
+  const ddlOptions = {
+    ifNotExists: true,
+    concurrent: dialect === "postgres",
+    ...tableNames?.nodes === void 0 ? {} : { nodesTableName: tableNames.nodes },
+    ...tableNames?.edges === void 0 ? {} : { edgesTableName: tableNames.edges }
+  };
+  const statusKeys = candidates.map(
+    (declaration) => statusKeyFor(declaration, graphId)
+  );
+  const existingByStatusKey = await preloadMaterializations(
+    backend,
+    statusKeys
+  );
+  const materializeEntry = (declaration) => declaration.entity === "vector" ? materializeVectorIndex(
+    declaration,
+    backend,
+    graphId,
+    schemaVersion,
+    existingByStatusKey
+  ) : materializeRelationalIndex(
+    declaration,
+    backend,
+    dialect,
+    ddlOptions,
+    graphId,
+    schemaVersion,
+    existingByStatusKey
+  );
+  if (options.stopOnError === true) {
+    const results = [];
+    for (const declaration of candidates) {
+      const entry2 = await materializeEntry(declaration);
+      results.push(entry2);
+      if (entry2.status === "failed") break;
+    }
+    return { results };
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const declaration of candidates) {
+    const key = parallelBucketKey(declaration);
+    const list = buckets.get(key);
+    if (list === void 0) buckets.set(key, [declaration]);
+    else list.push(declaration);
+  }
+  const bucketResults = await Promise.all(
+    [...buckets.values()].map(async (group) => {
+      const out = [];
+      for (const declaration of group) {
+        out.push(await materializeEntry(declaration));
+      }
+      return out;
+    })
+  );
+  const byDeclaration = /* @__PURE__ */ new Map();
+  let bucketIndex = 0;
+  for (const group of buckets.values()) {
+    const entries = bucketResults[bucketIndex];
+    for (const [declarationIndex, declaration] of group.entries()) {
+      byDeclaration.set(declaration, entries[declarationIndex]);
+    }
+    bucketIndex += 1;
+  }
+  return {
+    results: candidates.map((declaration) => byDeclaration.get(declaration))
+  };
+}
+function parallelBucketKey(declaration) {
+  return declaration.entity;
+}
+async function materializeRelationalIndex(declaration, backend, dialect, ddlOptions, graphId, schemaVersion, existingByStatusKey) {
+  const ddl = generateIndexDDL(declaration, dialect, ddlOptions);
+  const targetTable = declaration.entity === "node" ? ddlOptions.nodesTableName ?? "typegraph_nodes" : ddlOptions.edgesTableName ?? "typegraph_edges";
+  const signature = await computeIndexSignature(
+    dialect,
+    targetTable,
+    declaration
+  );
+  return materializeOne(declaration, backend, graphId, schemaVersion, {
+    statusKey: declaration.name,
+    signature,
+    driftLabel: "Index",
+    run: () => backend.executeDdl(ddl),
+    existingByStatusKey
+  });
+}
+async function materializeVectorIndex(declaration, backend, graphId, schemaVersion, existingByStatusKey) {
+  if (declaration.indexType === "none") {
+    return skippedEntry(
+      declaration,
+      "indexType: 'none' opts out of automatic materialization"
+    );
+  }
+  const vectorCapability = backend.capabilities.vector;
+  if (vectorCapability?.supported !== true || backend.createVectorIndex === void 0) {
+    return skippedEntry(
+      declaration,
+      `Backend (${backend.dialect}) does not support vector indexes in its current configuration`
+    );
+  }
+  if (!vectorCapability.indexTypes.includes(declaration.indexType)) {
+    return skippedEntry(
+      declaration,
+      `Backend (${backend.dialect}) does not support index type "${declaration.indexType}" for vector indexes; supported: ${vectorCapability.indexTypes.join(", ") || "(none)"}`
+    );
+  }
+  const embeddingsTable = backend.tableNames?.embeddings ?? "typegraph_node_embeddings";
+  const signature = await computeIndexSignature(
+    backend.dialect,
+    embeddingsTable,
+    declaration
+  );
+  const params = {
+    graphId,
+    nodeKind: declaration.kind,
+    fieldPath: declaration.fieldPath,
+    dimensions: declaration.dimensions,
+    metric: declaration.metric,
+    indexType: declaration.indexType,
+    indexParams: {
+      m: declaration.indexParams.m,
+      efConstruction: declaration.indexParams.efConstruction,
+      ...declaration.indexParams.lists === void 0 ? {} : { lists: declaration.indexParams.lists }
+    },
+    concurrent: backend.dialect === "postgres"
+  };
+  return materializeOne(declaration, backend, graphId, schemaVersion, {
+    // Compound status-table key for vector entries. Pgvector creates
+    // one physical index per (graphId, kind, field) — so the
+    // per-deployment status table needs to disambiguate entries that
+    // SHARE a declaration name but belong to different graphs.
+    // Applied uniformly to auto-derived AND explicit declarations.
+    statusKey: vectorStatusKey(graphId, declaration.name),
+    signature,
+    driftLabel: "Vector index",
+    run: () => backend.createVectorIndex(params),
+    existingByStatusKey
+  });
+}
+async function materializeOne(declaration, backend, graphId, schemaVersion, action) {
+  const recordIndexMaterialization = backend.recordIndexMaterialization;
+  const { statusKey, signature, driftLabel, run, existingByStatusKey } = action;
+  const statusOverride = statusKey === declaration.name ? void 0 : { statusName: statusKey };
+  const existing = existingByStatusKey.get(statusKey);
+  if (existing?.materializedAt !== void 0) {
+    if (existing.signature === signature) {
+      return entry(declaration, "alreadyMaterialized");
+    }
+    const error = new Error(
+      `${driftLabel} "${declaration.name}" already materialized with a different signature (recorded by graph "${existing.graphId}" at version ${existing.schemaVersion}). Drop the index manually and retry, or rename the new declaration.`
+    );
+    await recordIndexMaterialization(
+      buildAttempt({
+        declaration,
+        graphId,
+        signature,
+        schemaVersion,
+        materializedAt: void 0,
+        error,
+        ...statusOverride
+      })
+    );
+    return entry(declaration, "failed", error);
+  }
+  try {
+    await run();
+    const attemptedAt = nowIso();
+    await recordIndexMaterialization(
+      buildAttempt({
+        declaration,
+        graphId,
+        signature,
+        schemaVersion,
+        materializedAt: attemptedAt,
+        error: void 0,
+        attemptedAt,
+        ...statusOverride
+      })
+    );
+    return entry(declaration, "created");
+  } catch (error_) {
+    const error = error_ instanceof Error ? error_ : new Error(String(error_));
+    await recordIndexMaterialization(
+      buildAttempt({
+        declaration,
+        graphId,
+        signature,
+        schemaVersion,
+        materializedAt: void 0,
+        error,
+        ...statusOverride
+      })
+    );
+    return entry(declaration, "failed", error);
+  }
+}
+function entry(declaration, status, error) {
+  return {
+    indexName: declaration.name,
+    entity: declaration.entity,
+    kind: declaration.kind,
+    status,
+    ...error === void 0 ? {} : { error }
+  };
+}
+function skippedEntry(declaration, reason) {
+  return {
+    indexName: declaration.name,
+    entity: "vector",
+    kind: declaration.kind,
+    status: "skipped",
+    reason
+  };
+}
+function vectorStatusKey(graphId, declarationName) {
+  return `${graphId}::${declarationName}`;
+}
+function statusKeyFor(declaration, graphId) {
+  return declaration.entity === "vector" ? vectorStatusKey(graphId, declaration.name) : declaration.name;
+}
+async function preloadMaterializations(backend, statusKeys) {
+  const map = /* @__PURE__ */ new Map();
+  if (statusKeys.length === 0) return map;
+  if (backend.getIndexMaterializations !== void 0) {
+    const rows2 = await backend.getIndexMaterializations(statusKeys);
+    for (const row of rows2) map.set(row.indexName, row);
+    return map;
+  }
+  const getOne = backend.getIndexMaterialization;
+  const rows = await Promise.all(statusKeys.map((key) => getOne(key)));
+  for (const [index, row] of rows.entries()) {
+    if (row !== void 0) map.set(statusKeys[index], row);
+  }
+  return map;
+}
+function buildAttempt(args) {
+  return {
+    indexName: args.statusName ?? args.declaration.name,
+    graphId: args.graphId,
+    entity: args.declaration.entity,
+    kind: args.declaration.kind,
+    signature: args.signature,
+    schemaVersion: args.schemaVersion,
+    attemptedAt: args.attemptedAt ?? nowIso(),
+    materializedAt: args.materializedAt,
+    error: args.error?.message
+  };
+}
+async function computeIndexSignature(dialect, targetTableName, declaration) {
+  const hashable = { dialect, targetTableName, declaration };
+  const json = JSON.stringify(hashable, sortedReplacer);
+  return sha256Hex(json, 16);
+}
+
+// src/store/materialize-removals.ts
+var ENTITY_KINDS = ["node", "edge"];
+function buildPendingKindRemoval(args) {
+  return { ...args, removedAt: void 0, error: void 0 };
+}
+async function materializeRemovals(context, options = {}) {
+  const { backend, graphId } = context;
+  if (backend.executeDdl === void 0 || backend.recordKindRemoval === void 0 || backend.getPendingKindRemovals === void 0) {
+    throw new ConfigurationError(
+      "store.materializeRemovals() requires a backend with kind-removal primitives (executeDdl, recordKindRemoval, getPendingKindRemovals). The bundled SQLite and Postgres backends provide them.",
+      { code: "MATERIALIZE_REMOVALS_BACKEND_UNSUPPORTED" }
+    );
+  }
+  await ensureFocusedStatusTable(backend, backend.ensureKindRemovalsTable);
+  await reconcilePendingRemovals(context);
+  const pending = await backend.getPendingKindRemovals(graphId);
+  const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+  const candidates = pending.filter(
+    (row) => kindFilter === void 0 ? true : kindFilter.has(row.kindName)
+  );
+  if (candidates.length === 0) return { results: [] };
+  const tableNames = backend.tableNames;
+  const nodesTable = tableNames?.nodes ?? "typegraph_nodes";
+  const edgesTable = tableNames?.edges ?? "typegraph_edges";
+  const embeddingsTable = tableNames?.embeddings ?? "typegraph_node_embeddings";
+  const fulltextTable = tableNames?.fulltext ?? "typegraph_node_fulltext";
+  const uniquesTable = tableNames?.uniques ?? "typegraph_node_uniques";
+  const ctx = {
+    backend,
+    graphId,
+    nodesTable,
+    edgesTable,
+    embeddingsTable,
+    fulltextTable,
+    uniquesTable
+  };
+  return {
+    results: await runMaterialization(
+      candidates,
+      options,
+      (removal) => materializeOne2(removal, ctx)
+    )
+  };
+}
+async function reconcilePendingRemovals(context) {
+  const { backend, graphId } = context;
+  const recordKindRemoval = backend.recordKindRemoval;
+  if (recordKindRemoval === void 0) return;
+  const activeRow = await backend.getActiveSchema(graphId);
+  if (activeRow === void 0 || activeRow.version <= 1) return;
+  if (backend.ensureReconciliationMarkersTable !== void 0) {
+    await backend.ensureReconciliationMarkersTable();
+  }
+  const marker = backend.getReconciliationMarker === void 0 ? void 0 : await backend.getReconciliationMarker(graphId);
+  if (marker !== void 0 && marker >= activeRow.version) return;
+  const allRemovals = await (backend.getAllKindRemovals === void 0 ? backend.getPendingKindRemovals(graphId) : backend.getAllKindRemovals(graphId));
+  const recorded = new Set(
+    allRemovals.map(
+      (row) => kindRemovalKey(row.entity, row.kindName, row.schemaVersion)
+    )
+  );
+  const reconciliations = [];
+  const stopAtVersion = marker ?? 1;
+  let currentRow = activeRow;
+  let currentSchema = parseSerializedSchema(activeRow.schema_doc);
+  while (currentRow.version > stopAtVersion) {
+    const priorRow = await backend.getSchemaVersion(
+      graphId,
+      currentRow.version - 1
+    );
+    if (priorRow === void 0) break;
+    const priorSchema = parseSerializedSchema(priorRow.schema_doc);
+    for (const entity of ENTITY_KINDS) {
+      const priorEntries = priorSchema[entity === "node" ? "nodes" : "edges"];
+      const currentEntries = currentSchema[entity === "node" ? "nodes" : "edges"];
+      for (const kindName of Object.keys(priorEntries)) {
+        if (kindName in currentEntries) continue;
+        if (recorded.has(kindRemovalKey(entity, kindName, currentRow.version))) {
+          continue;
+        }
+        reconciliations.push({
+          kindName,
+          entity,
+          schemaVersion: currentRow.version
+        });
       }
-      const collection = createNodeCollection({
-        graphId,
-        kind,
-        backend,
-        ...operations
-      });
-      collectionCache.set(kind, collection);
-      return collection;
     }
-  });
+    currentRow = priorRow;
+    currentSchema = priorSchema;
+  }
+  if (reconciliations.length > 0) {
+    const attemptedAt = nowIso();
+    await Promise.all(
+      reconciliations.map(
+        (entry2) => recordKindRemoval(
+          buildPendingKindRemoval({
+            graphId,
+            kindName: entry2.kindName,
+            entity: entry2.entity,
+            schemaVersion: entry2.schemaVersion,
+            attemptedAt
+          })
+        )
+      )
+    );
+  }
+  if (backend.setReconciliationMarker !== void 0) {
+    await backend.setReconciliationMarker(graphId, activeRow.version);
+  }
 }
-function createEdgeCollectionsProxy(graph, graphId, registry, backend, operations) {
-  const collectionCache = /* @__PURE__ */ new Map();
-  return new Proxy({}, {
-    get: (_, kind) => {
-      if (!Object.hasOwn(graph.edges, kind)) {
-        throw new KindNotFoundError(kind, "edge");
-      }
-      const cached = collectionCache.get(kind);
-      if (cached !== void 0) {
-        return cached;
-      }
-      const collection = createEdgeCollection({
-        graphId,
-        kind,
-        backend,
-        ...operations
-      });
-      collectionCache.set(kind, collection);
-      return collection;
+function kindRemovalKey(entity, kindName, version) {
+  return `${entity}|${kindName}|${version}`;
+}
+async function materializeOne2(row, ctx) {
+  const executeDdl = ctx.backend.executeDdl;
+  const recordKindRemoval = ctx.backend.recordKindRemoval;
+  try {
+    const deletes = [];
+    const graphLit = literal2(ctx.graphId);
+    const kindLit = literal2(row.kindName);
+    if (row.entity === "node") {
+      deletes.push(
+        executeDdl(
+          `DELETE FROM ${quote(ctx.nodesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`
+        ),
+        executeDdl(
+          `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND (from_kind = ${kindLit} OR to_kind = ${kindLit})`
+        ),
+        executeDdl(
+          `DELETE FROM ${quote(ctx.embeddingsTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`
+        ),
+        executeDdl(
+          `DELETE FROM ${quote(ctx.fulltextTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`
+        ),
+        executeDdl(
+          `DELETE FROM ${quote(ctx.uniquesTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`
+        )
+      );
+    } else {
+      deletes.push(
+        executeDdl(
+          `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`
+        )
+      );
     }
-  });
+    await Promise.all(deletes);
+    const removedAt = nowIso();
+    await recordKindRemoval({
+      graphId: ctx.graphId,
+      kindName: row.kindName,
+      entity: row.entity,
+      schemaVersion: row.schemaVersion,
+      attemptedAt: removedAt,
+      removedAt,
+      error: void 0
+    });
+    return {
+      kind: row.kindName,
+      entity: row.entity,
+      status: "removed"
+    };
+  } catch (error_) {
+    const error = error_ instanceof Error ? error_ : new Error(String(error_));
+    await recordKindRemoval({
+      graphId: ctx.graphId,
+      kindName: row.kindName,
+      entity: row.entity,
+      schemaVersion: row.schemaVersion,
+      attemptedAt: nowIso(),
+      removedAt: void 0,
+      error: error.message
+    });
+    return {
+      kind: row.kindName,
+      entity: row.entity,
+      status: "failed",
+      error
+    };
+  }
+}
+function quote(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function literal2(value) {
+  return `'${value.replaceAll("'", "''")}'`;
 }
 
 // src/constraints/index.ts
@@ -11389,13 +12402,13 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
     });
   }
   const uniqueEndpoints = /* @__PURE__ */ new Map();
-  for (const entry of validated) {
-    if (!uniqueEndpoints.has(entry.endpointKey)) {
-      uniqueEndpoints.set(entry.endpointKey, {
-        fromKind: entry.fromKind,
-        fromId: entry.fromId,
-        toKind: entry.toKind,
-        toId: entry.toId
+  for (const entry2 of validated) {
+    if (!uniqueEndpoints.has(entry2.endpointKey)) {
+      uniqueEndpoints.set(entry2.endpointKey, {
+        fromKind: entry2.fromKind,
+        fromId: entry2.fromId,
+        toKind: entry2.toKind,
+        toId: entry2.toId
       });
     }
   }
@@ -11417,29 +12430,29 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   const toFetch = [];
   const duplicateOf = [];
   const seenKeys = /* @__PURE__ */ new Map();
-  for (const [index, entry] of validated.entries()) {
-    const previousIndex = seenKeys.get(entry.compositeKey);
+  for (const [index, entry2] of validated.entries()) {
+    const previousIndex = seenKeys.get(entry2.compositeKey);
     if (previousIndex !== void 0) {
       duplicateOf.push({ index, sourceIndex: previousIndex });
       continue;
     }
-    seenKeys.set(entry.compositeKey, index);
-    const candidateRows = rowsByEndpoint.get(entry.endpointKey) ?? [];
+    seenKeys.set(entry2.compositeKey, index);
+    const candidateRows = rowsByEndpoint.get(entry2.endpointKey) ?? [];
     const { liveRow, deletedRow } = findMatchingEdge(
       candidateRows,
       matchOn,
-      entry.validatedProps
+      entry2.validatedProps
     );
     if (liveRow === void 0 && deletedRow === void 0) {
       toCreate.push({
         index,
         input: {
           kind,
-          fromKind: entry.fromKind,
-          fromId: entry.fromId,
-          toKind: entry.toKind,
-          toId: entry.toId,
-          props: entry.validatedProps
+          fromKind: entry2.fromKind,
+          fromId: entry2.fromId,
+          toKind: entry2.toKind,
+          toId: entry2.toId,
+          props: entry2.validatedProps
         }
       });
     } else {
@@ -11451,32 +12464,32 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         index,
         row: bestRow,
         isDeleted: liveRow === void 0,
-        validatedProps: entry.validatedProps,
-        fromKind: entry.fromKind,
-        fromId: entry.fromId,
-        toKind: entry.toKind,
-        toId: entry.toId
+        validatedProps: entry2.validatedProps,
+        fromKind: entry2.fromKind,
+        fromId: entry2.fromId,
+        toKind: entry2.toKind,
+        toId: entry2.toId
       });
     }
   }
   const results = Array.from({ length: items.length });
   if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry) => entry.input);
+    const createInputs = toCreate.map((entry2) => entry2.input);
     const createdEdges = await executeEdgeCreateBatch(
       ctx,
       createInputs,
       backend
     );
-    for (const [batchIndex, entry] of toCreate.entries()) {
-      results[entry.index] = {
+    for (const [batchIndex, entry2] of toCreate.entries()) {
+      results[entry2.index] = {
         edge: createdEdges[batchIndex],
         action: "created"
       };
     }
   }
-  for (const entry of toFetch) {
-    if (entry.isDeleted) {
-      const effectiveValidTo = entry.row.valid_to;
+  for (const entry2 of toFetch) {
+    if (entry2.isDeleted) {
+      const effectiveValidTo = entry2.row.valid_to;
       const constraintContext = {
         graphId: ctx.graphId,
         registry: ctx.registry,
@@ -11486,28 +12499,28 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         constraintContext,
         kind,
         cardinality,
-        entry.fromKind,
-        entry.fromId,
-        entry.toKind,
-        entry.toId,
+        entry2.fromKind,
+        entry2.fromId,
+        entry2.toKind,
+        entry2.toId,
         effectiveValidTo
       );
       const edge = await executeEdgeUpsertUpdate(
         ctx,
-        { id: entry.row.id, props: entry.validatedProps },
+        { id: entry2.row.id, props: entry2.validatedProps },
         backend,
         { clearDeleted: true }
       );
-      results[entry.index] = { edge, action: "resurrected" };
+      results[entry2.index] = { edge, action: "resurrected" };
     } else if (ifExists === "update") {
       const edge = await executeEdgeUpsertUpdate(
         ctx,
-        { id: entry.row.id, props: entry.validatedProps },
+        { id: entry2.row.id, props: entry2.validatedProps },
         backend
       );
-      results[entry.index] = { edge, action: "updated" };
+      results[entry2.index] = { edge, action: "updated" };
     } else {
-      results[entry.index] = { edge: rowToEdge(entry.row), action: "found" };
+      results[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
     }
   }
   for (const { index, sourceIndex } of duplicateOf) {
@@ -12480,7 +13493,7 @@ function validateAndComputeKeys(nodeKind, kind, constraint, items) {
 function collectUniqueKeys(validated) {
   return [
     ...new Set(
-      validated.map((entry) => entry.key).filter((key) => key !== void 0)
+      validated.map((entry2) => entry2.key).filter((key) => key !== void 0)
     )
   ];
 }
@@ -12586,21 +13599,21 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   }
   const results = Array.from({ length: items.length });
   if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry) => entry.input);
+    const createInputs = toCreate.map((entry2) => entry2.input);
     const createdNodes = await executeNodeCreateBatch(
       ctx,
       createInputs,
       backend
     );
-    for (const [batchIndex, entry] of toCreate.entries()) {
-      results[entry.index] = {
+    for (const [batchIndex, entry2] of toCreate.entries()) {
+      results[entry2.index] = {
         node: createdNodes[batchIndex],
         action: "created"
       };
     }
   }
-  for (const entry of toFetch) {
-    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry;
+  for (const entry2 of toFetch) {
+    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry2;
     const existingRow = await backend.getNode(
       ctx.graphId,
       concreteKind,
@@ -12845,7 +13858,7 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
   };
   const rows = await backend.fulltextSearch(params);
   if (rows.length === 0) return [];
-  const ids = rows.map((r) => r.nodeId);
+  const ids = rows.map((row) => row.nodeId);
   const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
   const hits = [];
   let rank = 1;
@@ -12862,6 +13875,41 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
   }
   return hits;
 }
+async function executeVectorSearch(ctx, nodeKind, options) {
+  const { backend, graphId } = ctx;
+  if (!backend.vectorSearch) {
+    throw new ConfigurationError("Backend does not support vector search", {
+      backend: backend.dialect,
+      capability: "vector"
+    });
+  }
+  if (!Number.isInteger(options.limit) || options.limit <= 0) {
+    throw new RangeError(
+      `vectorSearch.limit must be a positive integer, got: ${options.limit}`
+    );
+  }
+  const rows = await backend.vectorSearch({
+    graphId,
+    nodeKind,
+    fieldPath: options.fieldPath,
+    queryEmbedding: options.queryEmbedding,
+    metric: options.metric ?? "cosine",
+    limit: options.limit,
+    ...options.minScore === void 0 ? {} : { minScore: options.minScore }
+  });
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.nodeId);
+  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+  const hits = [];
+  let rank = 1;
+  for (const row of rows) {
+    const node = nodeMap.get(row.nodeId);
+    if (!node) continue;
+    hits.push({ node, score: row.score, rank });
+    rank += 1;
+  }
+  return hits;
+}
 async function executeHybridSearch(ctx, nodeKind, options) {
   const { backend, graphId } = ctx;
   if (!backend.vectorSearch) {
@@ -12922,58 +13970,58 @@ async function executeHybridSearch(ctx, nodeKind, options) {
   for (const [index, row] of vectorRows.entries()) {
     const rank2 = index + 1;
     const contribution = vectorWeight / (fusionK + rank2);
-    const entry = fused.get(row.nodeId) ?? {
+    const entry2 = fused.get(row.nodeId) ?? {
       nodeId: row.nodeId,
       fusedScore: 0
     };
-    entry.fusedScore += contribution;
-    entry.vectorRank = rank2;
-    entry.vectorScore = row.score;
-    fused.set(row.nodeId, entry);
+    entry2.fusedScore += contribution;
+    entry2.vectorRank = rank2;
+    entry2.vectorScore = row.score;
+    fused.set(row.nodeId, entry2);
   }
   for (const [index, row] of fulltextRows.entries()) {
     const rank2 = index + 1;
     const contribution = fulltextWeight / (fusionK + rank2);
-    const entry = fused.get(row.nodeId) ?? {
+    const entry2 = fused.get(row.nodeId) ?? {
       nodeId: row.nodeId,
       fusedScore: 0
     };
-    entry.fusedScore += contribution;
-    entry.fulltextRank = rank2;
-    entry.fulltextScore = row.score;
+    entry2.fusedScore += contribution;
+    entry2.fulltextRank = rank2;
+    entry2.fulltextScore = row.score;
     if (row.snippet !== void 0) {
-      entry.fulltextSnippet = row.snippet;
+      entry2.fulltextSnippet = row.snippet;
     }
-    fused.set(row.nodeId, entry);
+    fused.set(row.nodeId, entry2);
   }
   const ranked = [...fused.values()].toSorted(
     (a, b) => b.fusedScore - a.fusedScore || a.nodeId.localeCompare(b.nodeId)
   ).slice(0, options.limit);
-  const ids = ranked.map((entry) => entry.nodeId);
+  const ids = ranked.map((entry2) => entry2.nodeId);
   const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
   const hits = [];
   let rank = 1;
-  for (const entry of ranked) {
-    const node = nodeMap.get(entry.nodeId);
+  for (const entry2 of ranked) {
+    const node = nodeMap.get(entry2.nodeId);
     if (!node) continue;
     const typedNode = node;
     const hit = {
       node: typedNode,
-      score: entry.fusedScore,
+      score: entry2.fusedScore,
       rank,
-      ...entry.vectorRank !== void 0 && entry.vectorScore !== void 0 ? {
+      ...entry2.vectorRank !== void 0 && entry2.vectorScore !== void 0 ? {
         vector: {
           node: typedNode,
-          score: entry.vectorScore,
-          rank: entry.vectorRank
+          score: entry2.vectorScore,
+          rank: entry2.vectorRank
         }
       } : {},
-      ...entry.fulltextRank !== void 0 && entry.fulltextScore !== void 0 ? {
+      ...entry2.fulltextRank !== void 0 && entry2.fulltextScore !== void 0 ? {
         fulltext: {
           node: typedNode,
-          score: entry.fulltextScore,
-          rank: entry.fulltextRank,
-          ...entry.fulltextSnippet === void 0 ? {} : { snippet: entry.fulltextSnippet }
+          score: entry2.fulltextScore,
+          rank: entry2.fulltextRank,
+          ...entry2.fulltextSnippet === void 0 ? {} : { snippet: entry2.fulltextSnippet }
         }
       } : {}
     };
@@ -13086,12 +14134,32 @@ var StoreSearch = class {
    * `Node` objects.
    */
   async fulltext(nodeKind, options) {
+    this.#assertKindRegistered(nodeKind);
     return executeFulltextSearch(
       { graphId: this.#context.graphId, backend: this.#context.backend },
       nodeKind,
       options
     );
   }
+  /**
+   * Runs a vector similarity search against nodes of the given kind.
+   *
+   * Requires a field on the node schema declared with `embedding()`,
+   * either at compile time or via a graph extension (the auto-derived
+   * `VectorIndexDeclaration` flows through `materializeIndexes()` on
+   * the same path either way).
+   *
+   * Pure vector — no fulltext leg, no fusion. For combined
+   * vector+fulltext ranking, use `hybrid`.
+   */
+  async vector(nodeKind, options) {
+    this.#assertKindRegistered(nodeKind);
+    return executeVectorSearch(
+      { graphId: this.#context.graphId, backend: this.#context.backend },
+      nodeKind,
+      options
+    );
+  }
   /**
    * Runs a vector + fulltext hybrid search and fuses the results with
    * Reciprocal Rank Fusion.
@@ -13102,6 +14170,7 @@ var StoreSearch = class {
    * `fulltext.k` for higher-recall corpora.
    */
   async hybrid(nodeKind, options) {
+    this.#assertKindRegistered(nodeKind);
     return executeHybridSearch(
       { graphId: this.#context.graphId, backend: this.#context.backend },
       nodeKind,
@@ -13127,6 +14196,7 @@ var StoreSearch = class {
    * full consistency.
    */
   async rebuildFulltext(nodeKind, options = {}) {
+    if (nodeKind !== void 0) this.#assertKindRegistered(nodeKind);
     return rebuildFulltextIndex(
       {
         graphId: this.#context.graphId,
@@ -13137,27 +14207,62 @@ var StoreSearch = class {
       options
     );
   }
+  #assertKindRegistered(kind) {
+    if (this.#context.registry.hasNodeType(kind)) return;
+    throw new KindNotFoundError(kind, "node", {
+      graphId: this.#context.graphId,
+      suggestion: "Compile-time kinds come from defineGraph; extension kinds appear after store.evolve() returns. Check store.introspect() for the registered set."
+    });
+  }
 };
 
 // src/store/store.ts
-var Store = class {
+var UNKNOWN_SCHEMA_METADATA = Object.freeze({
+  schemaVersion: void 0,
+  schemaHash: void 0
+});
+var CAUGHT_UP_VERB_DETAILS = {
+  evolve: { phrase: "evolve", code: "EVOLVE_BEFORE_INITIALIZE" },
+  materialize: {
+    phrase: "materialize indexes on",
+    code: "MATERIALIZE_BEFORE_INITIALIZE"
+  },
+  remove: { phrase: "remove kinds on", code: "REMOVE_BEFORE_INITIALIZE" },
+  deprecate: {
+    phrase: "deprecate kinds on",
+    code: "DEPRECATE_BEFORE_INITIALIZE"
+  },
+  undeprecate: {
+    phrase: "undeprecate kinds on",
+    code: "DEPRECATE_BEFORE_INITIALIZE"
+  }
+};
+var Store = class _Store {
   #graph;
   #backend;
   #registry;
   #hooks;
   #schema;
+  #schemaMetadata;
   #defaultTraversalExpansion;
+  // Stored verbatim so `evolve()` can construct the next Store with
+  // identical options. Reconstructing from the individual private
+  // fields would silently drop any future StoreOptions field a
+  // maintainer adds without also threading it through evolve.
+  #options;
   #nodeCollections;
   #edgeCollections;
   #algorithms;
   #search;
-  constructor(graph, backend, options) {
+  constructor(graph, backend, options, schemaMetadata) {
     this.#graph = graph;
     this.#backend = backend;
     this.#registry = buildKindRegistry(graph);
     this.#hooks = options?.hooks ?? {};
     this.#schema = options?.schema ?? (backend.tableNames ? createSqlSchema(backend.tableNames) : void 0);
     this.#defaultTraversalExpansion = options?.queryDefaults?.traversalExpansion ?? "inverse";
+    this.#options = options;
+    this.#schemaMetadata = schemaMetadata ?? UNKNOWN_SCHEMA_METADATA;
   }
   // === Accessors ===
   /** The graph definition */
@@ -13271,23 +14376,125 @@ var Store = class {
    *
    * Use this for runtime string-keyed access when the kind is not known at
    * compile time (e.g., iterating all kinds, resolving from edge metadata,
-   * dynamic admin UIs).
+   * dynamic admin UIs). For the post-evolve "I just added this kind, give
+   * me the collection" pattern, prefer `getNodeCollectionOrThrow` — it
+   * throws `KindNotFoundError` instead of forcing a null-check.
    */
   getNodeCollection(kind) {
     if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
     return this.nodes[kind];
   }
+  /**
+   * Returns the node collection for the given kind. Throws
+   * `KindNotFoundError` when the kind is not registered.
+   *
+   * The dominant graph-extension-kind access pattern: `await store.evolve(...)`
+   * returns a new store, the caller immediately operates on the new
+   * kind, and the null-check the optional variant requires is busywork.
+   */
+  getNodeCollectionOrThrow(kind) {
+    const collection = this.getNodeCollection(kind);
+    if (collection === void 0) {
+      throw new KindNotFoundError(kind, "node", {
+        graphId: this.graphId
+      });
+    }
+    return collection;
+  }
   /**
    * Returns the edge collection for the given kind, or undefined if the kind
    * is not registered in this graph.
    *
    * Use this for runtime string-keyed access when the kind is not known at
-   * compile time.
+   * compile time. For post-evolve access, prefer `getEdgeCollectionOrThrow`.
    */
   getEdgeCollection(kind) {
     if (!Object.hasOwn(this.#graph.edges, kind)) return void 0;
     return this.edges[kind];
   }
+  /**
+   * Returns the edge collection for the given kind. Throws
+   * `KindNotFoundError` when the kind is not registered.
+   */
+  getEdgeCollectionOrThrow(kind) {
+    const collection = this.getEdgeCollection(kind);
+    if (collection === void 0) {
+      throw new KindNotFoundError(kind, "edge", {
+        graphId: this.graphId
+      });
+    }
+    return collection;
+  }
+  // === Dynamic Props Schema Access ===
+  /**
+   * Returns the Zod props schema for the given node kind, or `undefined`
+   * if the kind is not registered. Identity-preserving: returns the
+   * exact instance used by `.create()` / `.update()`, so a `parse()`
+   * surfaces the same underlying Zod issues that `ValidationError`
+   * wraps (operation-level checks like uniqueness and endpoints stay
+   * in `collection.create`).
+   */
+  getNodePropsSchema(kind) {
+    if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
+    return this.#graph.nodes[kind].type.schema;
+  }
+  /**
+   * Returns the Zod props schema for the given node kind. Throws
+   * `KindNotFoundError` when the kind is not registered.
+   */
+  getNodePropsSchemaOrThrow(kind) {
+    const schema = this.getNodePropsSchema(kind);
+    if (schema === void 0) {
+      throw new KindNotFoundError(kind, "node", {
+        graphId: this.graphId
+      });
+    }
+    return schema;
+  }
+  /**
+   * Returns the Zod props schema for the given edge kind, or `undefined`
+   * if the kind is not registered. Symmetric with `getNodePropsSchema`.
+   */
+  getEdgePropsSchema(kind) {
+    if (!Object.hasOwn(this.#graph.edges, kind)) return void 0;
+    return this.#graph.edges[kind].type.schema;
+  }
+  /**
+   * Returns the Zod props schema for the given edge kind. Throws
+   * `KindNotFoundError` when the kind is not registered.
+   */
+  getEdgePropsSchemaOrThrow(kind) {
+    const schema = this.getEdgePropsSchema(kind);
+    if (schema === void 0) {
+      throw new KindNotFoundError(kind, "edge", {
+        graphId: this.graphId
+      });
+    }
+    return schema;
+  }
+  /**
+   * Returns a unified read of the merged schema — every compile-time
+   * and graph-extension kind, every edge, every ontology relation,
+   * with explicit `origin: "compile-time" | "runtime"` markers — plus
+   * the persisted `extension` for round-tripping.
+   *
+   * Pure synchronous read built from the in-memory graph and the
+   * already-merged graph-extension document. `schemaVersion` and `schemaHash`
+   * are populated when the loader cached them at construction or after
+   * `evolve` returns; consumers needing a fresh read should call
+   * `backend.getActiveSchema(graphId)`.
+   *
+   * The return shape is the canonical schema-introspection surface:
+   * the prior standalone `store.deprecatedKinds` accessor is replaced
+   * by `introspect().deprecatedKinds`.
+   */
+  introspect() {
+    return introspectSchema(this.#graph, {
+      graphId: this.graphId,
+      schemaVersion: this.#schemaMetadata.schemaVersion,
+      schemaHash: this.#schemaMetadata.schemaHash
+    });
+  }
   /**
    * Node operations bound to this store instance.
    */
@@ -13639,6 +14846,415 @@ var Store = class {
   async refreshStatistics() {
     await this.#backend.refreshStatistics();
   }
+  /**
+   * Evolves the graph at runtime by merging a graph extension into the
+   * current schema, atomically committing a new schema version, and
+   * returning a fresh `Store` constructed against the merged graph.
+   *
+   * The `Store` is immutable — its registry, collections, and operation
+   * contexts close over the graph at construction time — so callers
+   * must use the returned store (or pass a `ref` to be re-pointed) for
+   * any work involving the new kinds.
+   *
+   * **Cost for purely additive extensions is proportional to schema
+   * document size, not row count.** The commit is a single CAS write.
+   * Tightening changes against existing graph-extension-declared kinds run
+   * row-count probes for those affected kinds so populated kinds can
+   * be rejected without a backfill.
+   *
+   * **Concurrent evolve recovery.** On `StaleVersionError`, refetch the
+   * current active schema (or dereference your `StoreRef`),
+   * reconstruct your `Store`, and re-call `evolve(extension)` against
+   * the new store. Re-validation may now surface deterministic errors
+   * (e.g., another caller just added a kind that collides with yours,
+   * or redeclared one of yours with a different shape). Don't loop
+   * blindly — surface the error.
+   *
+   * @param extension - Graph extension produced by
+   *   `defineGraphExtension(...)`.
+   * @param options.ref - Optional handle whose `current` is overwritten
+   *   atomically with the schema commit. Long-lived consumers
+   *   (request handlers, background workers) that dereference through
+   *   the ref see the new kinds on the *next* call.
+   *
+   * @throws {GraphExtensionValidationError} when the extension is
+   *   structurally invalid.
+   * @throws {KindCollisionError} when an extension kind shadows a
+   *   compile-time kind (code `KIND_COLLISION`).
+   * @throws {IncompatibleChangeError} when a redeclared kind narrows
+   *   in a way the existing rows can't satisfy
+   *   (code `INCOMPATIBLE_CHANGE`).
+   * @throws {GraphExtensionUnresolvedEndpointError} when an edge
+   *   endpoint references a kind that exists in neither the extension
+   *   nor the host graph
+   *   (code `GRAPH_EXTENSION_UNRESOLVED_ENDPOINT`).
+   * @throws {StaleVersionError} when another writer has advanced the
+   *   schema since this store was constructed; recovery as above.
+   * @throws {SchemaContentConflictError} when a row already exists at
+   *   the target version with a different content hash.
+   */
+  async evolve(extension, options) {
+    const { activeRow, baseline } = await this.#loadCaughtUp("evolve");
+    const merged = mergeGraphExtension(baseline, extension);
+    if (merged === baseline) {
+      if (baseline === this.#graph) {
+        if (options?.ref !== void 0) options.ref.current = this;
+        if (options?.eager !== void 0) {
+          await this.#runEagerOrThrow(this, options.eager);
+        }
+        return this;
+      }
+      const caughtUp = this.#cloneWithGraph(
+        baseline,
+        options?.ref,
+        schemaMetadataFromRow(activeRow)
+      );
+      if (options?.eager !== void 0) {
+        await this.#runEagerOrThrow(caughtUp, options.eager);
+      }
+      return caughtUp;
+    }
+    const baselineDocument = baseline.extension ?? Object.freeze({});
+    const classification = classifyModifications(baselineDocument, extension);
+    if (classification.incompatible.length > 0) {
+      throw new IncompatibleChangeError(
+        classification.incompatible,
+        this.graphId
+      );
+    }
+    if (classification.requireEmpty.length > 0) {
+      const nonEmpty = await this.#probeEmptyKinds(classification.requireEmpty);
+      const error = buildIncompatibleChangeError(
+        classification,
+        nonEmpty,
+        this.graphId
+      );
+      if (error !== void 0) throw error;
+    }
+    const committed = await commitNewSchemaVersion(
+      this.#backend,
+      merged,
+      activeRow.version
+    );
+    const evolved = this.#cloneWithGraph(
+      merged,
+      options?.ref,
+      schemaMetadataFromRow(committed)
+    );
+    if (options?.eager !== void 0) {
+      await this.#runEagerOrThrow(evolved, options.eager);
+    }
+    return evolved;
+  }
+  async #runEagerOrThrow(store, eager) {
+    const result = await store.materializeIndexes(eager);
+    if (result.results.some((entry2) => entry2.status === "failed")) {
+      throw new EagerMaterializationError(result, this.graphId);
+    }
+  }
+  /**
+   * Marks the named node and edge kinds as soft-deprecated. Surfaces in
+   * `store.introspect().deprecatedKinds` for introspection (codegen,
+   * UI tooling, lints) but does not gate reads, writes, or queries —
+   * deprecation is a signal, not a removal.
+   *
+   * Atomically commits a new schema version through the same primitive
+   * `evolve()` uses, so concurrent deprecate/evolve calls produce
+   * `StaleVersionError | SchemaContentConflictError` race losers that
+   * the caller refetches and retries. Idempotent: re-deprecating a
+   * kind that's already marked is a no-op (no version bump).
+   *
+   * @param names - Node or edge kind names to mark as deprecated.
+   * @param options.ref - Optional handle to be re-pointed atomically
+   *   with the schema commit, mirroring `evolve()`.
+   *
+   * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE` (no
+   *   schema yet) or `DEPRECATE_UNKNOWN_KIND` (name not on the graph).
+   * @throws {StaleVersionError} when another writer has advanced the
+   *   schema since this store was constructed; refetch and retry per
+   *   the same recipe `evolve()` documents.
+   * @throws {SchemaContentConflictError} when a row already exists at
+   *   the target version with a different content hash.
+   */
+  async deprecateKinds(names, options) {
+    return this.#updateDeprecatedKinds("add", names, options);
+  }
+  /**
+   * Reverses `deprecateKinds(...)` for the named kinds. Same race +
+   * idempotency semantics: removing a name that isn't currently
+   * deprecated is a no-op for that name (the call as a whole is a
+   * no-op only if every name was already absent).
+   *
+   * @param names - Node or edge kind names to remove from the
+   *   deprecated set.
+   * @param options.ref - Optional handle to be re-pointed atomically
+   *   with the schema commit.
+   *
+   * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE`.
+   * @throws {StaleVersionError} on a CAS race with another writer.
+   * @throws {SchemaContentConflictError} on a same-version content
+   *   conflict.
+   */
+  async undeprecateKinds(names, options) {
+    return this.#updateDeprecatedKinds("remove", names, options);
+  }
+  /**
+   * Runs `CREATE INDEX` DDL for the indexes declared on this graph and
+   * records per-deployment status in `typegraph_index_materializations`.
+   * The status table is per-database (two replicas of the same
+   * `schema_doc` are still two different databases for DDL purposes),
+   * so the same call against two replicas materializes independently.
+   *
+   * Idempotent. Re-running the verb against an already-materialized
+   * index is a no-op (`status: "alreadyMaterialized"`). Postgres uses
+   * `CREATE INDEX CONCURRENTLY` so live tables never take an
+   * `AccessExclusiveLock`. SQLite is single-writer regardless.
+   *
+   * Best-effort by default: a failed index records `status: "failed"`
+   * with the error and the loop continues. Pass `{ stopOnError: true }`
+   * to halt on the first failure.
+   *
+   * @param options.kinds - Restrict to indexes whose `kind` is in this
+   *   set. Throws `ConfigurationError` (`code:
+   *   "MATERIALIZE_UNKNOWN_KIND"`) if any name doesn't match a known
+   *   compile-time or extension kind.
+   * @param options.stopOnError - Halt on first failure. Default false.
+   *
+   * @throws {ConfigurationError} `MATERIALIZE_BACKEND_UNSUPPORTED` if
+   *   the backend lacks `executeDdl`, `getIndexMaterialization`, or
+   *   `recordIndexMaterialization`; `MATERIALIZE_UNKNOWN_KIND` for an
+   *   unknown kind name; `MATERIALIZE_BEFORE_INITIALIZE` if the store
+   *   has no schema yet.
+   */
+  async materializeIndexes(options) {
+    const { activeRow, baseline } = await this.#loadCaughtUp("materialize");
+    return materializeIndexes(
+      {
+        graph: baseline,
+        graphId: this.graphId,
+        backend: this.#backend,
+        schemaVersion: activeRow.version
+      },
+      options ?? {}
+    );
+  }
+  /**
+   * Removes extension kinds from the schema with cascading edge and
+   * ontology cleanup. Two-phase by design:
+   *
+   *   1. **Schema commit (this method).** Validates the removal,
+   *      rebuilds the persisted extension without the named kinds
+   *      (and without extension edges that lose their last endpoint),
+   *      CAS-commits the new schema version, and queues
+   *      per-deployment data-cleanup status. Millisecond budget.
+   *   2. **Data cleanup (`materializeRemovals`).** Deletes the orphan
+   *      rows from the nodes/edges tables. Bounded by row count.
+   *
+   * Pass `{ eager: {} }` to run the data-cleanup pass inline with
+   * default options, or `{ eager: { ... } }` to scope it; otherwise
+   * call `materializeRemovals()` later.
+   *
+   * Idempotent: removing a name that doesn't exist is a no-op (no
+   * version bump). Removing an extension kind referenced by a compile-
+   * time edge or ontology relation throws `KindHasReferentsError`.
+   * Removing a compile-time kind throws `RemoveCompileTimeKindError` —
+   * compile-time kinds are removed by recompiling and redeploying.
+   *
+   * @throws {RemoveCompileTimeKindError} when `names` includes a
+   *   compile-time kind.
+   * @throws {KindHasReferentsError} when an extension kind being
+   *   removed is referenced by a compile-time declaration.
+   * @throws {StaleVersionError} on a CAS race with another writer.
+   * @throws {SchemaContentConflictError} on a same-version content
+   *   conflict.
+   */
+  async removeKinds(names, options) {
+    const { activeRow, baseline } = await this.#loadCaughtUp("remove");
+    const plan = planRemovals(baseline, names);
+    if (plan.removedNodeKinds.length === 0 && plan.removedEdgeKinds.length === 0) {
+      if (baseline === this.#graph) {
+        if (options?.ref !== void 0) options.ref.current = this;
+        return this;
+      }
+      return this.#cloneWithGraph(
+        baseline,
+        options?.ref,
+        schemaMetadataFromRow(activeRow)
+      );
+    }
+    const compileTimeGraph = stripGraphExtension(this.#graph);
+    const merged = plan.document === void 0 ? compileTimeGraph : mergeGraphExtension(compileTimeGraph, plan.document);
+    const finalGraph = applyDeprecatedKinds(merged, baseline.deprecatedKinds);
+    const committedRow = await commitNewSchemaVersion(
+      this.#backend,
+      finalGraph,
+      activeRow.version
+    );
+    const recordKindRemoval = this.#backend.recordKindRemoval;
+    if (recordKindRemoval !== void 0) {
+      if (this.#backend.ensureKindRemovalsTable !== void 0) {
+        await this.#backend.ensureKindRemovalsTable();
+      }
+      const attemptedAt = nowIso();
+      const newSchemaVersion = committedRow.version;
+      const queue = (kindName, entity) => recordKindRemoval(
+        buildPendingKindRemoval({
+          graphId: this.graphId,
+          kindName,
+          entity,
+          schemaVersion: newSchemaVersion,
+          attemptedAt
+        })
+      );
+      await Promise.all([
+        ...plan.removedNodeKinds.map((name) => queue(name, "node")),
+        ...plan.removedEdgeKinds.map((name) => queue(name, "edge"))
+      ]);
+    }
+    const evolved = this.#cloneWithGraph(
+      finalGraph,
+      options?.ref,
+      schemaMetadataFromRow(committedRow)
+    );
+    if (options?.eager !== void 0) {
+      const kinds = [...plan.removedNodeKinds, ...plan.removedEdgeKinds];
+      await evolved.materializeRemovals({
+        ...options.eager,
+        kinds: options.eager.kinds ?? kinds
+      });
+    }
+    return evolved;
+  }
+  /**
+   * Runs the data-cleanup phase for any kinds removed via
+   * `removeKinds()` whose data has not yet been deleted on this
+   * deployment. Safe to call repeatedly; idempotent.
+   */
+  async materializeRemovals(options) {
+    return materializeRemovals(
+      { graphId: this.graphId, backend: this.#backend },
+      options ?? {}
+    );
+  }
+  async #updateDeprecatedKinds(direction, names, options) {
+    const verb = direction === "add" ? "deprecate" : "undeprecate";
+    const { activeRow, storedSchema, baseline } = await this.#loadCaughtUp(verb);
+    const nextSet = new Set(baseline.deprecatedKinds);
+    if (direction === "add") {
+      for (const name of names) {
+        if (!isKnownKind(baseline, name)) {
+          throw new KindNotFoundError(
+            name,
+            isKnownEdgeKind(baseline, name) ? "edge" : "node",
+            {
+              graphId: this.graphId,
+              suggestion: "Only kinds declared on the graph (compile-time or runtime) can be deprecated."
+            }
+          );
+        }
+        nextSet.add(name);
+      }
+    } else {
+      for (const name of names) nextSet.delete(name);
+    }
+    if (setsEqual(nextSet, baseline.deprecatedKinds)) {
+      if (baseline === this.#graph) {
+        if (options?.ref !== void 0) options.ref.current = this;
+        return this;
+      }
+      return this.#cloneWithGraph(
+        baseline,
+        options?.ref,
+        schemaMetadataFromRow(activeRow)
+      );
+    }
+    const merged = applyDeprecatedKinds(baseline, nextSet);
+    const result = await ensureSchema(this.#backend, merged, {
+      preloaded: { activeRow, storedSchema },
+      autoMigrate: true
+    });
+    const metadata = result.status === "migrated" || result.status === "initialized" ? schemaMetadataFromRow(result.committedRow) : schemaMetadataFromRow(activeRow);
+    return this.#cloneWithGraph(merged, options?.ref, metadata);
+  }
+  #catchUpToStored(storedSchema) {
+    const compileTimeGraph = stripGraphExtension(this.#graph);
+    const withGraphExtension = storedSchema.extension === void 0 ? compileTimeGraph : mergeGraphExtension(compileTimeGraph, storedSchema.extension);
+    return applyDeprecatedKinds(
+      withGraphExtension,
+      storedSchema.deprecatedKinds
+    );
+  }
+  /**
+   * Loads the active schema row, parses it, and catches the in-memory
+   * graph up to the persisted state — the shared preamble for
+   * `evolve`, `materializeIndexes`, and `(un)deprecateKinds`.
+   *
+   * Throws `ConfigurationError` with a verb-specific code when the
+   * graph has not been initialized yet. The catch-up step replays the
+   * persisted graph-extension document and deprecation set on top of the
+   * compile-time graph so we diff against the same baseline another
+   * writer would; the CAS guard inside `commitSchemaVersion` still
+   * serializes the actual commit.
+   */
+  async #loadCaughtUp(verb) {
+    const activeRow = await loadActiveSchemaWithBootstrap(
+      this.#backend,
+      this.graphId
+    );
+    if (activeRow === void 0) {
+      const { phrase, code } = CAUGHT_UP_VERB_DETAILS[verb];
+      throw new ConfigurationError(
+        `Cannot ${phrase} graph "${this.graphId}": no schema has been initialized. Call createStoreWithSchema first.`,
+        { code }
+      );
+    }
+    const storedSchema = parseSerializedSchema(activeRow.schema_doc);
+    const baseline = this.#catchUpToStored(storedSchema);
+    return { activeRow, storedSchema, baseline };
+  }
+  /**
+   * Probes each `requireEmpty` entry for any rows. Returns the set of
+   * composite keys (`${entity}:${kindName}`) that have at least one
+   * row — those entries need to be promoted from "allowed-on-empty"
+   * to incompatible. Dispatches to `countNodesByKind` for `node`
+   * entries and `countEdgesByKind` for `edge` entries (a single-
+   * primitive probe would always return 0 for the wrong-entity case
+   * and silently bypass the gate).
+   *
+   * Probes run in parallel; each entry is independent. Race window
+   * (probe → CAS commit): another writer can insert a row into a
+   * previously-empty kind. The schema commit still succeeds (CAS
+   * guards on schema version, not row count); the new schema rejects
+   * the inserted row at next read, which the operator inspects and
+   * either deletes or reverts. Rare in practice; tighter elimination
+   * would require `SELECT FOR UPDATE` on the rows table, too
+   * heavyweight for a millisecond-budget operation.
+   */
+  async #probeEmptyKinds(requireEmpty) {
+    const probes = requireEmpty.map(
+      async (entry2) => {
+        const count2 = entry2.entity === "node" ? await this.#backend.countNodesByKind({
+          graphId: this.graphId,
+          kind: entry2.kindName
+        }) : await this.#backend.countEdgesByKind({
+          graphId: this.graphId,
+          kind: entry2.kindName
+        });
+        return [entry2, count2];
+      }
+    );
+    const results = await Promise.all(probes);
+    const nonEmpty = /* @__PURE__ */ new Set();
+    for (const [entry2, count2] of results) {
+      if (count2 > 0) nonEmpty.add(entry2);
+    }
+    return nonEmpty;
+  }
+  #cloneWithGraph(graph, ref, schemaMetadata = this.#schemaMetadata) {
+    const next = new _Store(graph, this.#backend, this.#options, schemaMetadata);
+    if (ref !== void 0) ref.current = next;
+    return next;
+  }
   /**
    * Closes the store and releases underlying resources.
    *
@@ -13737,12 +15353,46 @@ var Store = class {
 function createStore(graph, backend, options) {
   return new Store(graph, backend, options);
 }
+function isKnownEdgeKind(graph, name) {
+  return Object.hasOwn(graph.edges, name);
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const value of a) if (!b.has(value)) return false;
+  return true;
+}
+function schemaMetadataFromRow(row) {
+  if (row === void 0) return UNKNOWN_SCHEMA_METADATA;
+  return Object.freeze({
+    schemaVersion: row.version,
+    schemaHash: row.schema_hash
+  });
+}
+function schemaMetadataForResult(activeRow, result) {
+  if (result.status === "initialized" || result.status === "migrated") {
+    return schemaMetadataFromRow(result.committedRow);
+  }
+  return schemaMetadataFromRow(activeRow);
+}
 async function createStoreWithSchema(graph, backend, options) {
-  const store = createStore(graph, backend, options);
-  const result = await ensureSchema(backend, graph, options);
+  const {
+    graph: merged,
+    activeRow,
+    storedSchema
+  } = await loadAndMergeGraphExtensionDocument(backend, graph);
+  const result = await ensureSchema(backend, merged, {
+    ...options,
+    preloaded: { activeRow, storedSchema }
+  });
+  const store = new Store(
+    merged,
+    backend,
+    options,
+    schemaMetadataForResult(activeRow, result)
+  );
   return [store, result];
 }
 
-export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, StoreSearch, UnionableQuery, avg, broader, composeFragments, core, count, countDistinct, countDistinctEdges, countEdges, createExternalRef, createFragment, createQueryBuilder, createSqlSchema, createStore, createStoreWithSchema, defineEdge, defineNode, defineSubgraphProject, differentFrom, disjointWith, equivalentTo, exists, externalRef, field, fieldRef, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inSubquery, inverseOf, isExternalRefSchema, isParameterRef, limitFragment, max, metaEdge, min, narrower, notExists, notInSubquery, offsetFragment, orderByFragment, param, partOf, relatedTo, sameAs, subClassOf, sum };
+export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, StoreSearch, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createExternalRef, createFragment, createQueryBuilder, createSqlSchema, createStore, createStoreWithSchema, defineSubgraphProject, exists, externalRef, field, fieldRef, generateId, getExternalRefTable, having, havingEq, havingGt, havingGte, havingLt, havingLte, inSubquery, isExternalRefSchema, isParameterRef, limitFragment, max, metaEdge, min, notExists, notInSubquery, offsetFragment, orderByFragment, param, sum };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map