@nicia-ai/typegraph 0.43.0 → 0.44.0

package/dist/{chunk-JNXZQBN3.js → chunk-BCP7LLOY.js}

@@ -1,31 +1,31 @@
-import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-CVNGKTHO.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-L5AUCL5P.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, generateId, createGraphBackendProjection, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, validateEdgeEndpoints, buildPredicateIndex, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, closeRecordedHardDeletedKind, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-CTWZPYJW.js';
-import { chunk } from './chunk-35S6P5ZU.js';
-import { DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-CDYRPI5U.js';
-import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-UZLEQFTV.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant } from './chunk-2OOY4OYT.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, serializeIndexDeclaration } from './chunk-RAWG2FEU.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-PHXITZE4.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, lockSchemaVersionForStoreWrite, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-SBPC5IP3.js';
+import { isParameterRef, resolveParameterValueType, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, createGraphBackendProjection, generateId, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, validateEdgeEndpoints, closeRecordedHardDeletedKind, buildPredicateIndex, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-FSXTPBRN.js';
+import { chunk, groupBy } from './chunk-35S6P5ZU.js';
+import { DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-MIJKEVV7.js';
+import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-FMMIX6N4.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant } from './chunk-2L54C2C2.js';
+import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, planRemovals, stripGraphExtension, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-BEFM74L2.js';
 import { compareStrings, compareCodePoints } from './chunk-DRACN6XG.js';
-import { getTypeName } from './chunk-2HKIID5K.js';
-import { validateEdgeProps } from './chunk-O3USVVWS.js';
+import { getTypeName } from './chunk-2Y4IFKW7.js';
+import { validateEdgeProps } from './chunk-DK2S42XB.js';
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-CUPJL6TS.js';
-import { isKnownKind } from './chunk-3V6D5DEC.js';
-import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-GT7NEXSU.js';
-import { generateIndexDDL } from './chunk-2G6ZEGYO.js';
-import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-4XRP2N6B.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-ZP2KPDNN.js';
+import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-B75XRV3O.js';
+import { isKnownKind } from './chunk-S4KQ5LV4.js';
+import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-KCO5EFJU.js';
+import { generateIndexDDL } from './chunk-46GDII45.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-JRP3VGHS.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-TFMVL4QH.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
 import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-42XYPKZU.js';
-import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-M4GYQF2H.js';
+import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-K3BUWSFR.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-6DCB664D.js';
 import { createSchemaIntrospector } from './chunk-D7PG5D5K.js';
 import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
 import { getSearchableFields, resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage } from './chunk-PC2UBAUB.js';
-import { IncompatibleChangeError, RemoveCompileTimeKindError, KindHasReferentsError } from './chunk-EQOQOT55.js';
-import { validateProjectionField } from './chunk-4WYFRACU.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, UnsupportedBackendCapabilityError, GraphAlgorithmConvergenceError, EndpointNotFoundError, InvalidEdgeWeightError } from './chunk-OYJSYDIH.js';
+import { IncompatibleChangeError } from './chunk-IJTLXNGJ.js';
+import { validateProjectionField } from './chunk-TVLKA4AY.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, UnsupportedBackendCapabilityError, GraphAlgorithmConvergenceError, EndpointNotFoundError, InvalidEdgeWeightError } from './chunk-4MB3AQAQ.js';
 import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-G6Q5UM7U.js';
 
 // src/store/collection-surface.ts
@@ -170,7 +170,7 @@ function createCurrentOnlyRefusal(entity, method, coordinate) {
 function createBatchReadRefusal(entity, method, coordinate) {
   return () => {
     throw new ConfigurationError(
-      `'${method}' is not available on a read-only StoreView (${describeCoordinate(coordinate)}). Batch endpoint reads resolve through store.batch(...), which a view does not expose \u2014 use the live Store's batch loader, or the view's findFrom / findTo / findByEndpoints for single reads.`,
+      `'${method}' is not available on a read-only StoreView (${describeCoordinate(coordinate)}). Batch endpoint reads resolve through store.batch(...), which a view does not expose \u2014 use the live Store's batch(...), or the view's findFrom / findTo / findByEndpoints for single reads.`,
       {
         code: "STORE_VIEW_BATCH_UNAVAILABLE",
         entity,
@@ -264,6 +264,8 @@ function pinnedEdgeCollection(live, coordinate) {
     count: (filter) => live.count(filter, temporal),
     findFrom: (from) => live.findFrom(from, temporal),
     findTo: (to) => live.findTo(to, temporal),
+    bulkFindFrom: (froms, options) => live.bulkFindFrom(froms, { ...options, ...temporal }),
+    bulkFindTo: (tos, options) => live.bulkFindTo(tos, { ...options, ...temporal }),
     findByEndpoints: (from, to, options) => live.findByEndpoints(from, to, options, temporal)
   };
   return readOnlyCollectionProxy(reads, live, coordinate, "edge");
@@ -4910,7 +4912,7 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
     ...vectorPredicate === void 0 ? {} : { vectorPredicate },
     ...fulltextPredicate === void 0 ? {} : { fulltextPredicate }
   });
-  const groupBy = buildStandardGroupBy({ ast, dialect });
+  const groupBy2 = buildStandardGroupBy({ ast, dialect });
   const having2 = buildStandardHaving({ ast, ctx });
   const orderBy = selectStandardOrderBy({
     ast,
@@ -4927,7 +4929,7 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
   return emitStandardQuerySql({
     ctes,
     fromClause,
-    ...groupBy === void 0 ? {} : { groupBy },
+    ...groupBy2 === void 0 ? {} : { groupBy: groupBy2 },
     ...having2 === void 0 ? {} : { having: having2 },
     ...orderBy === void 0 ? {} : { orderBy },
     ...limitOffset === void 0 ? {} : { limitOffset },
@@ -5859,7 +5861,8 @@ function buildQueryTemplate(ast, graphId, compileOptions, backend) {
     needsReadInstant: queryAstNeedsCurrentReadInstant(ast)
   });
 }
-function fillTemplateParams(params, bindings, dialect) {
+var EMPTY_LIST_PARAMETERS = /* @__PURE__ */ new Map();
+function fillTemplateParams(params, bindings, dialect, listParameters = EMPTY_LIST_PARAMETERS) {
   let readInstant;
   return params.map((parameter) => {
     if (!isSqlPlaceholder(parameter)) return parameter;
@@ -5874,9 +5877,20 @@ function fillTemplateParams(params, bindings, dialect) {
         parameterName: name
       });
     }
+    if (listParameters.has(name)) {
+      assertListBinding(name, value);
+      return getDialect(dialect).packListValue(value);
+    }
     return bindSqlValue(value, dialect);
   });
 }
+function assertListBinding(name, value) {
+  if (Array.isArray(value)) return;
+  throw new ConfigurationError(
+    `Parameter "${name}" must be an array for in()/notIn()`,
+    { parameterName: name, actualType: typeof value }
+  );
+}
 
 // src/query/builder/prepared-query.ts
 function toLiteral(value) {
@@ -5903,20 +5917,21 @@ function toLiteral(value) {
     { parameterName: "value", actualType: typeof value }
   );
 }
+function isListComparisonOp(op) {
+  return op === "in" || op === "notIn";
+}
+function toLiteralList(parameterName, value) {
+  assertListBinding(parameterName, value);
+  return value.map((element) => toLiteral(element));
+}
 function substitutePredicateExpression(expr, bindings) {
   switch (expr.__type) {
     case "comparison": {
       if (isParameterRef(expr.right)) {
-        const value = bindings[expr.right.name];
-        if (value === void 0) {
-          throw new ConfigurationError(
-            `Missing binding for parameter "${expr.right.name}"`,
-            { parameterName: expr.right.name }
-          );
-        }
+        const value = resolveBinding(bindings, expr.right.name);
         return {
           ...expr,
-          right: toLiteral(value)
+          right: isListComparisonOp(expr.op) ? toLiteralList(expr.right.name, value) : toLiteral(value)
         };
       }
       return expr;
@@ -6029,6 +6044,7 @@ var PreparedQuery = class {
   #selectFn;
   #schemaIntrospector;
   #parameterMetadata;
+  #selectiveExecutionDisabled = false;
   /**
    * Per-AST cached placeholder template, keyed by AST reference so the
    * optimized (`#ast`) and unoptimized (`#unoptimizedAst`) variants cache
@@ -6049,6 +6065,7 @@ var PreparedQuery = class {
     this.#selectFn = config.selectFn;
     this.#schemaIntrospector = config.schemaIntrospector;
     this.#parameterMetadata = collectParameterMetadata(this.#ast);
+    assertDistinctParameterRoles(this.#parameterMetadata);
   }
   /**
    * The cached placeholder template for `ast`, or `undefined` when no fast
@@ -6082,7 +6099,7 @@ var PreparedQuery = class {
    */
   async execute(bindings = {}) {
     validateBindings(bindings, this.#parameterMetadata);
-    if (this.#selectiveFields !== void 0) {
+    if (this.#selectiveFields !== void 0 && !this.#selectiveExecutionDisabled) {
       try {
         const rows = await this.#executeSelectiveRows(bindings);
         return mapSelectiveResults(
@@ -6093,7 +6110,11 @@ var PreparedQuery = class {
           this.#selectFn
         );
       } catch (error) {
-        if (error instanceof MissingSelectiveFieldError || error instanceof UnsupportedPredicateError) {
+        if (error instanceof MissingSelectiveFieldError) {
+          this.#selectiveExecutionDisabled = true;
+          return this.#executeUnoptimized(bindings);
+        }
+        if (error instanceof UnsupportedPredicateError) {
           return this.#executeUnoptimized(bindings);
         }
         throw error;
@@ -6128,7 +6149,8 @@ var PreparedQuery = class {
       const params = fillTemplateParams(
         template.params,
         bindings,
-        this.#dialect
+        this.#dialect,
+        this.#parameterMetadata.listParameters
       );
       const rawRows2 = await executeRaw(
         template.sql,
@@ -6147,10 +6169,46 @@ var PreparedQuery = class {
   }
 };
 function collectParameterMetadata(ast) {
-  const names = /* @__PURE__ */ new Set();
-  const stringOpParameters = /* @__PURE__ */ new Set();
-  collectParameterMetadataFromAst(ast, names, stringOpParameters);
-  return { names, stringOpParameters };
+  const accumulator = {
+    names: /* @__PURE__ */ new Set(),
+    stringOpParameters: /* @__PURE__ */ new Set(),
+    listParameters: /* @__PURE__ */ new Map(),
+    scalarParameters: /* @__PURE__ */ new Set(),
+    conflictingElementTypes: /* @__PURE__ */ new Set()
+  };
+  collectParameterMetadataFromAst(ast, accumulator);
+  return accumulator;
+}
+function assertDistinctParameterRoles(metadata) {
+  if (metadata.conflictingElementTypes.size > 0) {
+    const names = [...metadata.conflictingElementTypes];
+    throw new ConfigurationError(
+      `Parameter${names.length === 1 ? "" : "s"} ${names.map((name) => `"${name}"`).join(", ")} bound as an in()/notIn() list against fields of different types; one list cannot satisfy both`,
+      { conflictingParameters: names }
+    );
+  }
+  const conflicting = [...metadata.listParameters.keys()].filter(
+    (name) => metadata.scalarParameters.has(name)
+  );
+  if (conflicting.length === 0) return;
+  throw new ConfigurationError(
+    `Parameter${conflicting.length === 1 ? "" : "s"} ${conflicting.map((name) => `"${name}"`).join(", ")} used both as an in()/notIn() list and as a scalar value`,
+    { conflictingParameters: conflicting }
+  );
+}
+function recordListElementType(accumulator, name, elementType) {
+  if (!accumulator.listParameters.has(name)) {
+    accumulator.listParameters.set(name, elementType);
+    return;
+  }
+  const existing = accumulator.listParameters.get(name);
+  if (existing === void 0) {
+    accumulator.listParameters.set(name, elementType);
+    return;
+  }
+  if (elementType !== void 0 && elementType !== existing) {
+    accumulator.conflictingElementTypes.add(name);
+  }
 }
 function hasParameterReferences(ast) {
   return collectParameterMetadata(ast).names.size > 0;
@@ -6161,63 +6219,58 @@ function composableQueryHasParameterReferences(query) {
   }
   return hasParameterReferences(query);
 }
-function collectParameterMetadataFromAst(ast, names, stringOpParameters) {
+function collectParameterMetadataFromAst(ast, accumulator) {
   for (const predicate of ast.predicates) {
-    collectParameterMetadataFromExpression(
-      predicate.expression,
-      names,
-      stringOpParameters
-    );
+    collectParameterMetadataFromExpression(predicate.expression, accumulator);
   }
   if (ast.having !== void 0) {
-    collectParameterMetadataFromExpression(
-      ast.having,
-      names,
-      stringOpParameters
-    );
+    collectParameterMetadataFromExpression(ast.having, accumulator);
   }
 }
-function collectParameterMetadataFromExpression(expression, names, stringOpParameters) {
+function collectParameterMetadataFromExpression(expression, accumulator) {
   switch (expression.__type) {
     case "comparison": {
       if (isParameterRef(expression.right)) {
-        names.add(expression.right.name);
+        const name = expression.right.name;
+        accumulator.names.add(name);
+        if (isListComparisonOp(expression.op)) {
+          recordListElementType(
+            accumulator,
+            name,
+            resolveParameterValueType(expression.left, expression.right)
+          );
+        } else {
+          accumulator.scalarParameters.add(name);
+        }
       }
       return;
     }
     case "string_op": {
       if (isParameterRef(expression.pattern)) {
-        names.add(expression.pattern.name);
-        stringOpParameters.add(expression.pattern.name);
+        accumulator.names.add(expression.pattern.name);
+        accumulator.scalarParameters.add(expression.pattern.name);
+        accumulator.stringOpParameters.add(expression.pattern.name);
       }
       return;
     }
     case "between": {
-      if (isParameterRef(expression.lower)) {
-        names.add(expression.lower.name);
-      }
-      if (isParameterRef(expression.upper)) {
-        names.add(expression.upper.name);
+      for (const bound of [expression.lower, expression.upper]) {
+        if (isParameterRef(bound)) {
+          accumulator.names.add(bound.name);
+          accumulator.scalarParameters.add(bound.name);
+        }
       }
       return;
     }
     case "and":
     case "or": {
       for (const predicate of expression.predicates) {
-        collectParameterMetadataFromExpression(
-          predicate,
-          names,
-          stringOpParameters
-        );
+        collectParameterMetadataFromExpression(predicate, accumulator);
       }
       return;
     }
     case "not": {
-      collectParameterMetadataFromExpression(
-        expression.predicate,
-        names,
-        stringOpParameters
-      );
+      collectParameterMetadataFromExpression(expression.predicate, accumulator);
       return;
     }
     case "null_check":
@@ -6228,26 +6281,15 @@ function collectParameterMetadataFromExpression(expression, names, stringOpParam
     case "fulltext_match": {
       return;
     }
-    case "exists": {
-      collectParameterMetadataFromAst(
-        expression.subquery,
-        names,
-        stringOpParameters
-      );
-      return;
-    }
+    case "exists":
     case "in_subquery": {
-      collectParameterMetadataFromAst(
-        expression.subquery,
-        names,
-        stringOpParameters
-      );
+      collectParameterMetadataFromAst(expression.subquery, accumulator);
       return;
     }
   }
 }
 function validateBindings(bindings, metadata) {
-  const { names: expectedNames, stringOpParameters } = metadata;
+  const { names: expectedNames, stringOpParameters, listParameters } = metadata;
   const missing = [];
   for (const name of expectedNames) {
     if (bindings[name] === void 0) {
@@ -6271,9 +6313,53 @@ function validateBindings(bindings, metadata) {
   }
   for (const name of expectedNames) {
     const value = bindings[name];
+    if (listParameters.has(name)) {
+      validateListBinding(name, value, listParameters.get(name));
+      continue;
+    }
     validateBindingValue(name, value, stringOpParameters.has(name));
   }
 }
+function validateListBinding(name, value, elementType) {
+  assertListBinding(name, value);
+  for (const element of value) {
+    validateBindingValue(name, element, false);
+    if (elementType === void 0) continue;
+    if (matchesElementType(element, elementType)) continue;
+    throw new ConfigurationError(
+      `Parameter "${name}" is bound against a ${elementType} field, so every element must be a ${elementType}; got ${describeBindingType(element)}`,
+      { parameterName: name, valueType: elementType }
+    );
+  }
+}
+function matchesElementType(value, elementType) {
+  switch (elementType) {
+    case "string": {
+      return typeof value === "string";
+    }
+    case "number": {
+      return typeof value === "number";
+    }
+    case "boolean": {
+      return typeof value === "boolean";
+    }
+    case "date": {
+      return value instanceof Date || typeof value === "string";
+    }
+    // No element cast is emitted for these, so there is no divergence to
+    // prevent — `array`/`object` are rejected earlier, at compile time.
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown": {
+      return true;
+    }
+  }
+}
+function describeBindingType(value) {
+  if (value instanceof Date) return "date";
+  return typeof value;
+}
 function validateBindingValue(name, value, isStringOp) {
   if (value === null) {
     throw new ConfigurationError(
@@ -6290,7 +6376,16 @@ function validateBindingValue(name, value, isStringOp) {
     }
     return;
   }
-  if (value instanceof Date || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new ConfigurationError(
+        `Parameter "${name}" must be a finite number, got ${String(value)}`,
+        { parameterName: name, actualType: "number" }
+      );
+    }
+    return;
+  }
+  if (value instanceof Date || typeof value === "string" || typeof value === "boolean") {
     return;
   }
   throw new ConfigurationError(
@@ -6867,7 +6962,9 @@ var ExecutableQuery = class _ExecutableQuery {
    * validates the AST once (a malformed query fails fast, here, instead of on
    * first use); the prepared query then compiles once into a reusable template
    * and fills a fresh read instant per execute() — see PreparedQuery's class
-   * doc comment.
+   * doc comment, which also covers the two cases that recompile per call
+   * instead (no `executeRaw`, or a statement whose semantics ride on the SQL
+   * object rather than its text).
    *
    * Use `param("name")` in predicates to create parameterized slots,
    * then pass values via `prepared.execute({ name: "value" })`.
@@ -7024,9 +7121,15 @@ var ExecutableQuery = class _ExecutableQuery {
   /**
    * Executes the query against a provided backend.
    *
-   * Used by `store.batch()` to run multiple queries over a single connection
-   * (e.g., within a transaction). The full compile → execute → transform
-   * pipeline runs identically to `execute()`, but against the given backend.
+   * Used by `store.batch()` to run several queries in sequence against one
+   * target — a transaction on backends that have them, the backend itself
+   * otherwise. The full compile → execute → transform pipeline runs
+   * identically to `execute()`, but against the given backend.
+   *
+   * Costs one statement, or two when the selective-field path runs and its
+   * mapping then falls back: `#tryOptimizedExecutionOn` detects that only
+   * after its statement has executed, and the caller re-runs the full fetch.
+   * The fallback clears the fast path for this instance.
    */
   async executeOn(backend) {
     const ast = this.toAst();
@@ -7133,29 +7236,15 @@ var ExecutableQuery = class _ExecutableQuery {
     const hasOptionalTraversal = this.#state.traversals.some(
       (traversal) => traversal.optional
     );
-    const trackingRuns = hasOptionalTraversal ? [
-      {
-        mode: "truthy",
-        optionalTraversalAliases: "present"
-      },
-      {
-        mode: "falsy",
-        optionalTraversalAliases: "present"
-      },
-      {
-        mode: "falsy",
-        optionalTraversalAliases: "absent"
-      }
-    ] : [
-      {
-        mode: "truthy",
-        optionalTraversalAliases: "present"
-      },
-      {
-        mode: "falsy",
-        optionalTraversalAliases: "present"
-      }
+    const presentTrackingRuns = [
+      { mode: "truthy", optionalTraversalAliases: "present" },
+      { mode: "max", optionalTraversalAliases: "present" },
+      { mode: "falsy", optionalTraversalAliases: "present" }
     ];
+    const trackingRuns = hasOptionalTraversal ? [
+      ...presentTrackingRuns,
+      { mode: "falsy", optionalTraversalAliases: "absent" }
+    ] : presentTrackingRuns;
     for (const run of trackingRuns) {
       const trackingContext = createTrackingContext(this.#state, tracker, {
         schemaIntrospector: this.#config.schemaIntrospector,
@@ -9160,7 +9249,11 @@ var UnionableQuery = class _UnionableQuery {
   /**
    * Executes the combined query against a provided backend.
    *
-   * Used by `store.batch()` to run multiple queries over a single connection.
+   * Used by `store.batch()` to run several queries in sequence against one
+   * target — a transaction on backends that have them, the backend itself
+   * otherwise. A set operation compiles to one statement; whether that target
+   * is a shared connection is the adapter's business, not a function of
+   * transaction support.
    */
   async executeOn(backend) {
     const ast = this.toAst();
@@ -10701,183 +10794,6 @@ function classifyUnique(kind, existing, next, recorders) {
   }
 }
 
-// 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;
-}
-
 // src/store/algorithms/context.ts
 var DEFAULT_ALGORITHM_MAX_HOPS = 10;
 var DEFAULT_NEIGHBOR_DEPTH = 1;
@@ -13530,6 +13446,36 @@ function buildUpdateEdgeInput(id, props, options) {
   if (options?.validTo !== void 0) input.validTo = options.validTo;
   return input;
 }
+function endpointKey(endpointKind, id) {
+  return `${endpointKind}\0${id}`;
+}
+function groupEndpointIdsByKind(references) {
+  const referencesByKind = groupBy(references, (ref) => ref.kind);
+  return new Map(
+    [...referencesByKind].map(([endpointKind, group]) => [
+      endpointKind,
+      group.map((ref) => ref.id)
+    ])
+  );
+}
+function assertLimitPerInput(kind, limitPerInput) {
+  if (limitPerInput === void 0) return;
+  if (Number.isInteger(limitPerInput) && limitPerInput > 0) return;
+  throw new ValidationError(
+    "bulk endpoint reads require limitPerInput to be a positive integer",
+    {
+      entityType: "edge",
+      kind,
+      issues: [
+        {
+          path: "limitPerInput",
+          message: `Expected a positive integer, received ${String(limitPerInput)}`,
+          code: "invalid_value"
+        }
+      ]
+    }
+  );
+}
 function mapBulkEdgeInputs(kind, items) {
   return items.map(
     (item) => buildCreateEdgeInput(kind, item.from, item.to, item.props ?? {}, item)
@@ -13552,29 +13498,74 @@ function createEdgeCollection(config) {
     temporalRowMatcher
   } = config;
   const mapRows = (rows) => rows.map((row) => narrowEdge(rowToEdge2(row)));
-  function buildEndpointFindParams(endpoint, options) {
-    return {
-      graphId,
-      kind,
-      ...endpoint,
-      ...resolveTemporalReadParams(options, defaultTemporalMode)
-    };
+  function buildEndpointFindParams(endpoint, temporal) {
+    return { graphId, kind, ...endpoint, ...temporal };
   }
   async function findEdgesFrom(from, target, options) {
     const rows = await target.findEdgesByKind(
       buildEndpointFindParams(
         { fromKind: from.kind, fromId: from.id },
-        options
+        resolveTemporalReadParams(options, defaultTemporalMode)
       )
     );
     return mapRows(rows);
   }
   async function findEdgesTo(to, target, options) {
     const rows = await target.findEdgesByKind(
-      buildEndpointFindParams({ toKind: to.kind, toId: to.id }, options)
+      buildEndpointFindParams(
+        { toKind: to.kind, toId: to.id },
+        resolveTemporalReadParams(options, defaultTemporalMode)
+      )
     );
     return mapRows(rows);
   }
+  async function findEdgesByEndpointSet(side, references, options) {
+    if (references.length === 0) return [];
+    const method = side === "from" ? "bulkFindFrom" : "bulkFindTo";
+    const readEndpointSet = backend.findEdgesByEndpointSet;
+    if (readEndpointSet === void 0) {
+      throw new ConfigurationError(
+        `store.edges.${kind}.${method}() requires a backend that can read a set of endpoints with set-oriented statements, and this backend does not implement findEdgesByEndpointSet.`,
+        {
+          backend: backend.dialect,
+          capability: "findEdgesByEndpointSet",
+          kind,
+          operation: method
+        },
+        {
+          suggestion: `Falling back to one findFrom/findTo per endpoint is deliberately NOT done here: a caller reaching for a bulk endpoint read is asking for a set-oriented read, and silently issuing N singleton statements is the cost surprise this method exists to avoid. Loop over findFrom/findTo explicitly if that trade is acceptable.`
+        }
+      );
+    }
+    const limitPerInput = options?.limitPerInput;
+    assertLimitPerInput(kind, limitPerInput);
+    const temporal = resolveTemporalReadParams(options, defaultTemporalMode);
+    const limitPerEndpoint = limitPerInput !== void 0 && backend.capabilities.windowFunctions ? { limitPerEndpoint: limitPerInput } : {};
+    const edgesByEndpoint = /* @__PURE__ */ new Map();
+    for (const [endpointKind, endpointIds] of groupEndpointIdsByKind(
+      references
+    )) {
+      const rows = await readEndpointSet({
+        graphId,
+        kind,
+        side,
+        endpointKind,
+        endpointIds,
+        ...limitPerEndpoint,
+        ...temporal
+      });
+      for (const edge of mapRows(rows)) {
+        const key = side === "from" ? endpointKey(edge.fromKind, edge.fromId) : endpointKey(edge.toKind, edge.toId);
+        const bucket = edgesByEndpoint.get(key);
+        if (bucket === void 0) edgesByEndpoint.set(key, [edge]);
+        else bucket.push(edge);
+      }
+    }
+    return references.map((ref) => {
+      const bucket = edgesByEndpoint.get(endpointKey(ref.kind, ref.id)) ?? [];
+      return limitPerInput === void 0 ? [...bucket] : bucket.slice(0, limitPerInput);
+    });
+  }
   function buildFindByEndpointsOptions(options, temporal) {
     const result = { ...resolveTemporalReadParams(temporal, defaultTemporalMode) };
     if (options?.matchOn !== void 0)
@@ -13622,6 +13613,12 @@ function createEdgeCollection(config) {
     async findTo(to, options) {
       return findEdgesTo(to, backend, options);
     },
+    async bulkFindFrom(froms, options) {
+      return findEdgesByEndpointSet("from", froms, options);
+    },
+    async bulkFindTo(tos, options) {
+      return findEdgesByEndpointSet("to", tos, options);
+    },
     batchFindFrom(from, options) {
       return { executeOn: (target) => findEdgesFrom(from, target, options) };
     },
@@ -14326,6 +14323,8 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "claimIndexMaterialization",
   "close",
   "commitSchemaVersion",
+  "commitSchemaVersionIfKindsEmpty",
+  "lockSchemaVersionForWrite",
   "compileSql",
   "countEdgesByKind",
   "countEdgesFrom",
@@ -14354,6 +14353,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "execute",
   "executeTemporaryStatement",
   "findEdgesByKind",
+  "findEdgesByEndpointSet",
   "findEdgesConnectedTo",
   "findNodesByKind",
   "fulltextSearch",
@@ -14399,7 +14399,8 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "upsertFulltext",
   "upsertFulltextBatch",
   "vectorSearch",
-  "vectorStrategy"
+  "vectorStrategy",
+  "verifyContributions"
 ];
 function createHistoryStoreBackendProjection(backend) {
   return Object.freeze(
@@ -14501,18 +14502,6 @@ async function runBucketedMaterialization(items, options, bucketKey, runOne) {
   );
   return results;
 }
-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
 var CLAIM_LEASE_MS = 15 * 6e4;
@@ -15216,21 +15205,38 @@ function buildPendingKindRemoval(args) {
 }
 async function materializeRemovals(context, options = {}) {
   const { backend, graphId } = context;
-  if (backend.executeDdl === void 0 || backend.recordKindRemoval === void 0 || backend.getPendingKindRemovals === void 0) {
+  if (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.",
+      "store.materializeRemovals() requires a backend with kind-removal primitives (recordKindRemoval, getPendingKindRemovals). The bundled SQLite and Postgres backends provide them.",
       { code: "MATERIALIZE_REMOVALS_BACKEND_UNSUPPORTED" }
     );
   }
   await ensureFocusedStatusTable(backend, backend.ensureKindRemovalsTable);
   await reconcilePendingRemovals(context);
-  const reclaimedVectorFields = await reclaimRemovedVectorFieldTables(context);
+  const activeRow = await backend.getActiveSchema(graphId);
+  const activeSchema = activeRow === void 0 ? void 0 : parseSerializedSchema(activeRow.schema_doc);
+  const reclaimedVectorFields = await reclaimRemovedVectorFieldTables(
+    context,
+    activeRow
+  );
   const pending = await backend.getPendingKindRemovals(graphId);
+  const liveKinds = liveKindNamesFrom(activeSchema);
   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)
+  const selected = pending.filter(
+    (row) => kindFilter === void 0 || kindFilter.has(row.kindName)
+  );
+  const candidates = selected.filter(
+    (row) => !liveKinds[row.entity].has(row.kindName)
   );
-  if (candidates.length === 0) return { results: [], reclaimedVectorFields };
+  const skipped = selected.filter((row) => liveKinds[row.entity].has(row.kindName)).map((row) => ({
+    kind: row.kindName,
+    entity: row.entity,
+    status: "skipped",
+    reason: "kind-is-live"
+  }));
+  if (candidates.length === 0) {
+    return { results: skipped, reclaimedVectorFields };
+  }
   const tableNames = backend.tableNames;
   const nodesTable = tableNames?.nodes ?? "typegraph_nodes";
   const edgesTable = tableNames?.edges ?? "typegraph_edges";
@@ -15247,14 +15253,13 @@ async function materializeRemovals(context, options = {}) {
     captureRecordedRemovals,
     recordedSchema: captureRecordedRemovals ? context.recordedSchema ?? createSqlSchema(backend.tableNames) : void 0
   };
-  return {
-    results: await runMaterialization(
-      candidates,
-      options,
-      (removal) => materializeOne2(removal, ctx)
-    ),
-    reclaimedVectorFields
-  };
+  const materialized = [];
+  for (const candidate of candidates) {
+    const entry2 = await materializeOne2(candidate, ctx);
+    materialized.push(entry2);
+    if (options.stopOnError === true && entry2.status === "failed") break;
+  }
+  return { results: [...materialized, ...skipped], reclaimedVectorFields };
 }
 async function reconcilePendingRemovals(context) {
   const { backend, graphId } = context;
@@ -15322,14 +15327,49 @@ async function reconcilePendingRemovals(context) {
     await backend.setReconciliationMarker(graphId, activeRow.version);
   }
 }
+function liveKindNamesFrom(schema) {
+  if (schema === void 0) {
+    return { node: /* @__PURE__ */ new Set(), edge: /* @__PURE__ */ new Set() };
+  }
+  return {
+    node: new Set(Object.keys(schema.nodes)),
+    edge: new Set(Object.keys(schema.edges))
+  };
+}
 function kindRemovalKey(entity, kindName, version) {
   return `${entity}|${kindName}|${version}`;
 }
 async function materializeOne2(row, ctx) {
   const recordKindRemoval = requireDefined(ctx.backend.recordKindRemoval);
+  const schemaWriteTransaction = ctx.backend.schemaWriteTransaction;
+  if (schemaWriteTransaction === void 0) {
+    throw new ConfigurationError(
+      "store.materializeRemovals() requires a backend that can hold the schema-write lock across the live-kind check and cleanup.",
+      { code: "MATERIALIZE_REMOVALS_SCHEMA_FENCE_UNSUPPORTED" }
+    );
+  }
   try {
-    await closeRecordedAndDeleteLiveRows(ctx, row);
-    await Promise.all(buildEmbeddingTableCleanup(ctx, row));
+    const outcome = await schemaWriteTransaction(
+      ctx.graphId,
+      async (target) => {
+        const activeRow = await target.getActiveSchema(ctx.graphId);
+        const activeSchema = activeRow === void 0 ? void 0 : parseSerializedSchema(activeRow.schema_doc);
+        if (liveKindNamesFrom(activeSchema)[row.entity].has(row.kindName)) {
+          return "skipped";
+        }
+        await closeRecordedAndDeleteLiveRows(ctx, row, target);
+        await dropEmbeddingTableStorage(ctx, row, target);
+        return "removed";
+      }
+    );
+    if (outcome === "skipped") {
+      return {
+        kind: row.kindName,
+        entity: row.entity,
+        status: "skipped",
+        reason: "kind-is-live"
+      };
+    }
     const removedAt = nowIso();
     await recordKindRemoval({
       graphId: ctx.graphId,
@@ -15364,28 +15404,33 @@ async function materializeOne2(row, ctx) {
     };
   }
 }
-async function closeRecordedAndDeleteLiveRows(ctx, row) {
+async function closeRecordedAndDeleteLiveRows(ctx, row, target) {
   const deleteStatements = buildRemovedKindLiveDeleteStatements(ctx, row);
   if (!ctx.captureRecordedRemovals || ctx.recordedSchema === void 0) {
-    await executeDeleteStatements(ctx.backend, deleteStatements);
+    await executeDeleteStatements(target, deleteStatements);
     return;
   }
   const recordedSchema = ctx.recordedSchema;
-  try {
-    await ctx.backend.transaction(async (target) => {
-      await closeRecordedHardDeletedKind(
-        target,
-        recordedSchema,
-        ctx.graphId,
-        { entity: row.entity, kind: row.kindName },
-        false
-      );
-      await executeDeleteStatements(target, deleteStatements);
-    });
-  } catch (error) {
-    if (!isMissingTableError(error)) throw error;
-    await executeDeleteStatements(ctx.backend, deleteStatements);
+  const requiredRecordedTables = [
+    recordedSchema.tables.recordedClock,
+    recordedSchema.tables.recordedEdges,
+    ...row.entity === "node" ? [recordedSchema.tables.recordedNodes] : []
+  ];
+  const recordedTablesExist = await Promise.all(
+    requiredRecordedTables.map((tableName) => target.tableExists(tableName))
+  );
+  if (recordedTablesExist.some((exists) => !exists)) {
+    await executeDeleteStatements(target, deleteStatements);
+    return;
   }
+  await closeRecordedHardDeletedKind(
+    target,
+    recordedSchema,
+    ctx.graphId,
+    { entity: row.entity, kind: row.kindName },
+    false
+  );
+  await executeDeleteStatements(target, deleteStatements);
 }
 function buildRemovedKindLiveDeleteStatements(ctx, row) {
   const graphLit = literal(ctx.graphId);
@@ -15403,41 +15448,22 @@ function buildRemovedKindLiveDeleteStatements(ctx, row) {
   ];
 }
 async function executeDeleteStatements(target, statements) {
-  if (target.executeStatement !== void 0) {
-    await Promise.all(
-      statements.map(
-        (statement) => requireDefined(target.executeStatement)(
-          asCompiledStatementSql(sql.raw(statement))
-        )
-      )
-    );
-    return;
+  for (const statement of statements) {
+    await target.executeStatement(asCompiledStatementSql(sql.raw(statement)));
   }
-  if (target.executeDdl === void 0) {
-    throw new ConfigurationError(
-      "store.materializeRemovals() requires a backend that can execute cleanup statements.",
-      { code: "MATERIALIZE_REMOVALS_BACKEND_UNSUPPORTED" }
-    );
-  }
-  await Promise.all(
-    statements.map((statement) => requireDefined(target.executeDdl)(statement))
-  );
 }
-function buildEmbeddingTableCleanup(ctx, row) {
+async function dropEmbeddingTableStorage(ctx, row, target) {
   const vectorStrategy = ctx.backend.vectorStrategy;
-  if (vectorStrategy === void 0) return [];
-  const executeDdl = requireDefined(ctx.backend.executeDdl);
-  const cleanup = (async () => {
-    const slots = await resolveRemovedKindEmbeddingSlots(ctx.backend, row);
-    await Promise.all(
-      slots.map(
-        (slot) => dropVectorSlotStorage(ctx.backend, vectorStrategy, executeDdl, slot)
-      )
-    );
-  })();
-  return [cleanup];
+  if (vectorStrategy === void 0) return;
+  const executeDdl = target.executeSchemaDdl;
+  const deleteContribution = target.deleteSchemaVectorSlotContribution;
+  const slots = await resolveRemovedKindEmbeddingSlots(target, row);
+  for (const slot of slots) {
+    await dropVectorSlotStorage(vectorStrategy, executeDdl, slot);
+    await deleteContribution(slot);
+  }
 }
-async function dropVectorSlotStorage(backend, strategy, executeDdl, slot) {
+async function dropVectorSlotStorage(strategy, executeDdl, slot) {
   try {
     for (const ddl of strategy.buildDropStorage(slot)) {
       await executeDdl(ddl);
@@ -15445,7 +15471,6 @@ async function dropVectorSlotStorage(backend, strategy, executeDdl, slot) {
   } catch (error) {
     if (!isMissingTableError(error)) throw error;
   }
-  await backend.deleteVectorSlotContribution?.(slot);
 }
 async function resolveRemovedKindEmbeddingSlots(backend, row) {
   const priorVersion = row.schemaVersion - 1;
@@ -15471,26 +15496,26 @@ async function resolveRemovedKindEmbeddingSlots(backend, row) {
 function vectorFieldKey(kind, fieldPath) {
   return `${kind}\0${fieldPath}`;
 }
-async function reclaimRemovedVectorFieldTables(context) {
+function vectorFieldKeysFrom(schema) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const declaration of schema.indexes ?? []) {
+    if (declaration.entity === "vector") {
+      keys.add(vectorFieldKey(declaration.kind, declaration.fieldPath));
+    }
+  }
+  return keys;
+}
+async function reclaimRemovedVectorFieldTables(context, activeRow) {
   const { backend, graphId } = context;
   const vectorStrategy = backend.vectorStrategy;
-  const executeDdl = backend.executeDdl;
-  if (vectorStrategy === void 0 || executeDdl === void 0) return [];
-  const activeRow = await backend.getActiveSchema(graphId);
+  if (vectorStrategy === void 0) return [];
   if (activeRow === void 0) return [];
   const cacheKey = `${graphId}\0${activeRow.version}`;
   let perBackend = reclaimCache.get(backend);
   const cached = perBackend?.get(cacheKey);
   if (cached !== void 0) return cached;
   const activeSchema = parseSerializedSchema(activeRow.schema_doc);
-  const activeVectorFields = /* @__PURE__ */ new Set();
-  for (const declaration of activeSchema.indexes ?? []) {
-    if (declaration.entity === "vector") {
-      activeVectorFields.add(
-        vectorFieldKey(declaration.kind, declaration.fieldPath)
-      );
-    }
-  }
+  const activeVectorFields = vectorFieldKeysFrom(activeSchema);
   const survivingKinds = new Set(Object.keys(activeSchema.nodes));
   const historical = /* @__PURE__ */ new Map();
   for (let version = activeRow.version - 1; version >= 1; version -= 1) {
@@ -15519,14 +15544,43 @@ async function reclaimRemovedVectorFieldTables(context) {
     (field2) => !activeVectorFields.has(vectorFieldKey(field2.kind, field2.fieldPath)) && survivingKinds.has(field2.kind)
   );
   const results = [];
+  let skippedAfterLockedRecheck = false;
+  const schemaWriteTransaction = backend.schemaWriteTransaction;
+  if (orphans.length > 0 && schemaWriteTransaction === void 0) {
+    throw new ConfigurationError(
+      "store.materializeRemovals() requires a backend that can hold the schema-write lock across the vector-field liveness check and cleanup.",
+      { code: "MATERIALIZE_REMOVALS_SCHEMA_FENCE_UNSUPPORTED" }
+    );
+  }
   for (const field2 of orphans) {
     try {
-      await dropVectorSlotStorage(
-        backend,
-        vectorStrategy,
-        executeDdl,
-        field2.slot
+      const reclaimed = await requireDefined(schemaWriteTransaction)(
+        graphId,
+        async (target) => {
+          const lockedActiveRow = await target.getActiveSchema(graphId);
+          if (lockedActiveRow === void 0) return false;
+          const lockedActiveSchema = parseSerializedSchema(
+            lockedActiveRow.schema_doc
+          );
+          const lockedVectorFields = vectorFieldKeysFrom(lockedActiveSchema);
+          if (lockedVectorFields.has(
+            vectorFieldKey(field2.kind, field2.fieldPath)
+          ) || !Object.hasOwn(lockedActiveSchema.nodes, field2.kind)) {
+            return false;
+          }
+          await dropVectorSlotStorage(
+            vectorStrategy,
+            target.executeSchemaDdl,
+            field2.slot
+          );
+          await target.deleteSchemaVectorSlotContribution(field2.slot);
+          return true;
+        }
       );
+      if (!reclaimed) {
+        skippedAfterLockedRecheck = true;
+        continue;
+      }
       results.push({
         kind: field2.kind,
         fieldPath: field2.fieldPath,
@@ -15541,7 +15595,7 @@ async function reclaimRemovedVectorFieldTables(context) {
       });
     }
   }
-  if (results.every((entry2) => entry2.status === "reclaimed")) {
+  if (!skippedAfterLockedRecheck && results.every((entry2) => entry2.status === "reclaimed")) {
     if (perBackend === void 0) {
       perBackend = /* @__PURE__ */ new Map();
       reclaimCache.set(backend, perBackend);
@@ -16211,7 +16265,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       validatedProps,
       matchOn
     );
-    const endpointKey = buildEndpointPairKey(
+    const endpointKey2 = buildEndpointPairKey(
       item.fromKind,
       item.fromId,
       item.toKind,
@@ -16224,7 +16278,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       toId: item.toId,
       validatedProps,
       compositeKey,
-      endpointKey,
+      endpointKey: endpointKey2,
       ...validFrom !== void 0 && { validFrom },
       ...validTo !== void 0 && { validTo }
     });
@@ -16242,7 +16296,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   }
   async function fetchRowsByEndpoint(reader) {
     const rowsByEndpoint = /* @__PURE__ */ new Map();
-    for (const [endpointKey, endpoint] of uniqueEndpoints) {
+    for (const [endpointKey2, endpoint] of uniqueEndpoints) {
       const rows = await reader.findEdgesByKind({
         graphId: ctx.graphId,
         kind,
@@ -16253,7 +16307,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         excludeDeleted: false,
         temporalMode: "includeTombstones"
       });
-      rowsByEndpoint.set(endpointKey, rows);
+      rowsByEndpoint.set(endpointKey2, rows);
     }
     return rowsByEndpoint;
   }
@@ -16914,6 +16968,39 @@ function syncStoreReplacementRef(ref, replacement) {
   if (ref === void 0) return;
   ref.current = replacement;
 }
+async function commitEvolvedSchemaWhenRequiredKindsAreEmpty(backend, graph, currentVersion, classification) {
+  const result = await commitNewSchemaVersionIfKindsEmpty(
+    backend,
+    graph,
+    currentVersion,
+    classification.requireEmpty.map((entry2) => ({
+      entity: entry2.entity,
+      kind: entry2.kindName
+    }))
+  );
+  if (result.status === "committed") return result.row;
+  const populatedKeys = new Set(
+    result.kinds.map((entry2) => `${entry2.entity}:${entry2.kind}`)
+  );
+  const nonEmpty = new Set(
+    classification.requireEmpty.filter(
+      (entry2) => populatedKeys.has(`${entry2.entity}:${entry2.kindName}`)
+    )
+  );
+  const error = buildIncompatibleChangeError(
+    classification,
+    nonEmpty,
+    graph.id
+  );
+  if (error !== void 0) throw error;
+  throw new ConfigurationError(
+    "Schema emptiness guard reported populated kinds that were not part of the compatibility classification.",
+    {
+      graphId: graph.id,
+      populatedKinds: result.kinds.map((entry2) => entry2.kind)
+    }
+  );
+}
 var StoreImplementation = class _StoreImplementation {
   [STORE_RUNTIME];
   #graph;
@@ -17759,19 +17846,54 @@ var StoreImplementation = class _StoreImplementation {
   }
   // === Batch Query Execution ===
   /**
-   * Executes multiple queries and returns a typed tuple of results.
+   * Runs several queries in sequence, returning a typed tuple. The portable
+   * guarantee is N serialized query executions — never one round trip.
+   *
+   * **Cost.** At least one statement per query, sometimes two: a query whose
+   * selective-field mapping falls back re-runs as a full fetch, and that
+   * fallback is detected *after* the selective statement has already
+   * executed. It clears the fast path, so a reused query instance pays the
+   * double only once — but the builder is immutable, so a query rebuilt per
+   * request pays it every request.
    *
-   * Each query preserves its own result type, projection, filtering, sorting,
-   * and pagination.
+   * With `backend.capabilities.transactions` the queries share one
+   * transaction; how that reaches the wire is the adapter's business. A SQL
+   * backend frames them with `begin`/`commit`, putting a networked one at
+   * N+2 round trips *at best*, while Durable Objects use an ambient storage
+   * transaction with no framing statements. Without transactions there is no
+   * framing. Connection reuse is a separate question from transaction
+   * support: the no-transaction path passes the same backend object, so an
+   * adapter may reuse one client there too. The portable guarantee is only
+   * that at most one query is in flight at a time.
    *
-   * **Snapshot consistency is conditional.** When
-   * `backend.capabilities.transactions` is `true`, queries run sequentially
-   * on a single connection inside an implicit transaction and observe the
-   * same database snapshot. When transactions are unavailable
-   * (Cloudflare D1, `drizzle-orm/neon-http`), queries run sequentially over
-   * independent connections and may observe writes that landed between them.
-   * Branch on `backend.capabilities.transactions` if you need a guaranteed
-   * snapshot.
+   * **Not a snapshot — and there is no way to make it one.** PostgreSQL
+   * defaults to read-committed isolation, so a later query can observe a
+   * commit the earlier ones did not. `store.transaction()` takes an
+   * `isolationLevel`, but its context exposes only `nodes` / `edges`: there is
+   * no public way to run a fluent query or a batch inside a transaction, so a
+   * snapshot across fluent queries is not available today. Collection reads
+   * can have one — `store.transaction(fn, { isolationLevel: "repeatable_read" })`
+   * reading through `tx.nodes` / `tx.edges` — but only where the backend has
+   * transactions (others ignore the option entirely), and a history-enabled
+   * store on PostgreSQL additionally requires `accessMode: "read_only"` or the
+   * call throws.
+   *
+   * **Will not fix an N+1.** Serializing N queries does not reduce their
+   * number. The alternatives are set-oriented or chunked rather than
+   * fixed-cost: `.traverse()` compiles a whole chain to one statement;
+   * `store.subgraph()` costs 2 statements on SQLite and 3 on PostgreSQL
+   * however large the result; `getByIds()` issues one statement per
+   * bind-limit chunk, falling back to one per distinct id where the backend
+   * exposes no batch read; `bulkFindByIndex()` costs one probe plus that same
+   * chunked hydration.
+   *
+   * **Versus `Promise.all`.** Workload- and adapter-dependent in both
+   * directions. `Promise.all` overlaps its queries against a pool with idle
+   * capacity, but it does not necessarily hold N connections, and against a
+   * single client or a saturated pool it queues. `batch()` keeps at most one
+   * query in flight, so it pays the sum of their latencies — but it can still
+   * come out ahead where connection acquisition dominates. Measure rather
+   * than assume.
    *
    * Read-only — use `bulkCreate`, `bulkInsert`, etc. for write batching.
    *
@@ -17796,9 +17918,10 @@ var StoreImplementation = class _StoreImplementation {
    */
   async batch(...queries) {
     return runOptionallyInTransaction(this.#baseBackend, async (target) => {
+      const queryBackend = this.#createHookedQueryBackend(target);
       const results = [];
       for (const query of queries) {
-        const result = await query.executeOn(target);
+        const result = await query.executeOn(queryBackend);
         results.push(result);
       }
       return results;
@@ -18080,6 +18203,13 @@ var StoreImplementation = class _StoreImplementation {
     const txBackend = adopt(externalTx);
     if (this.#captureEnabled) {
       await assertRecordedCaptureTransactionIsolation(txBackend);
+      await lockSchemaVersionForStoreWrite(
+        {
+          graphId: this.graphId,
+          schemaVersion: this.#schemaMetadata.schemaVersion
+        },
+        txBackend
+      );
     }
     const scope = this.#captureEnabled ? createRecordedTransactionScope(txBackend, this.#sqlSchema()) : {
       backend: txBackend,
@@ -18249,6 +18379,7 @@ var StoreImplementation = class _StoreImplementation {
     };
     await (this.#baseBackend.capabilities.transactions ? this.#baseBackend.transaction(async (tx) => doClear(tx)) : doClear(this.#baseBackend));
     await this.#clearVectorStorage();
+    this.#schemaMetadata = UNKNOWN_SCHEMA_METADATA;
     this.#nodeCollections = void 0;
     this.#edgeCollections = void 0;
     this.#algorithms = void 0;
@@ -18385,6 +18516,7 @@ var StoreImplementation = class _StoreImplementation {
       }
       return caughtUp;
     }
+    await this.#assertNoPendingRemovalFor(merged, baseline);
     const baselineDocument = baseline.extension ?? Object.freeze({});
     const classification = classifyModifications(baselineDocument, extension);
     if (classification.incompatible.length > 0) {
@@ -18393,20 +18525,12 @@ var StoreImplementation = class _StoreImplementation {
         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(
+    const committed = classification.requireEmpty.length > 0 ? await commitEvolvedSchemaWhenRequiredKindsAreEmpty(
       this.#backend,
       merged,
-      activeRow.version
-    );
+      activeRow.version,
+      classification
+    ) : await commitNewSchemaVersion(this.#backend, merged, activeRow.version);
     await materializeVectorContributions(this.#backend, merged);
     const evolved = this.#cloneWithGraph(
       merged,
@@ -18681,6 +18805,65 @@ var StoreImplementation = class _StoreImplementation {
     }
     return { recreated: true, reembedded };
   }
+  /**
+   * Diagnostic: compare each contribution currently expected by this graph
+   * and the backend strategies with its durable marker and the physical
+   * catalog. Reports detected unusable contributions, including a recorded
+   * failed materialization whose absent table agrees with the marker.
+   * Contributions with neither marker nor table and retired marker rows are
+   * omitted, so an empty array is not proof that storage was initialized.
+   *
+   * Opening a store never probes the catalog — `ensureRuntimeContributions`
+   * and the runtime asserts short-circuit on a per-instance signature cache
+   * and then on the marker row alone, which is the right default for a hot
+   * path. The cost is that a database whose contribution tables were dropped
+   * out of band (a partial restore, a hand-run `DROP`, a schema-scoped
+   * restore that missed them) opens completely clean and then fails at the
+   * first read of the affected slot. This is the explicit, operator-invoked
+   * check for that state; it is not, and should not become, a boot step.
+   *
+   * Purely read-only: one existence query per distinct contribution table
+   * plus one marker read per graph, no DDL and no writes, so it is safe to
+   * run under a least-privilege runtime role and safe to run on a live
+   * store. Each entry carries identity resolved from the active contribution
+   * declaration and matching the marker contract, so callers can route to a
+   * repair without reconstructing any internal naming contract.
+   *
+   * Route on `state`, NOT on whether the entry is a vector slot: the
+   * repairs differ per state and the wrong one destroys data.
+   * {@link Store.reembedVectorField} drops and recreates storage, so
+   * applying it to a `missing-marker` — table intact, only the marker
+   * wrong — discards every embedding to fix bookkeeping. See
+   * {@link ContributionDiagnostic} and the per-state repair tables in the
+   * troubleshooting guide.
+   *
+   * Vector slots are enumerated from the graph's declared embedding fields
+   * and are considered only when the backend advertises vector support; a
+   * backend without it never materialized them, so there is nothing to
+   * compare. Current fulltext contributions are always considered. For a
+   * readiness check, first construct the Store through a verified attach so
+   * initialization is established independently.
+   *
+   * @throws {ConfigurationError} when the backend cannot probe its own
+   *   catalog. Reporting "no problems found" on a backend that never
+   *   looked would be the one answer this diagnostic must never give.
+   */
+  async verifyContributions() {
+    const backend = this.#baseBackend;
+    const verify = backend.verifyContributions;
+    if (verify === void 0) {
+      throw new ConfigurationError(
+        "verifyContributions requires a backend that can probe its catalog for contribution tables.",
+        {
+          backend: backend.dialect,
+          capability: "contributions",
+          operation: "verify"
+        }
+      );
+    }
+    const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(this.#graph) : [];
+    return verify(this.graphId, vectorSlots);
+  }
   /**
    * Removes extension kinds from the schema with cascading edge and
    * ontology cleanup. Two-phase by design:
@@ -18861,42 +19044,36 @@ var StoreImplementation = class _StoreImplementation {
     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).
+   * Refuses an evolve that re-adds a kind whose data cleanup is still pending.
    *
-   * 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.
+   * Returns silently on backends without the removal queue: they cannot have
+   * a pending row, so there is nothing to conflict with.
    */
-  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];
+  async #assertNoPendingRemovalFor(merged, baseline) {
+    const getPendingKindRemovals = this.#backend.getPendingKindRemovals;
+    if (getPendingKindRemovals === void 0) return;
+    const addedNodes = Object.keys(merged.nodes).filter(
+      (kind) => !(kind in baseline.nodes)
+    );
+    const addedEdges = Object.keys(merged.edges).filter(
+      (kind) => !(kind in baseline.edges)
+    );
+    if (addedNodes.length === 0 && addedEdges.length === 0) return;
+    const pending = await getPendingKindRemovals(this.graphId);
+    if (pending.length === 0) return;
+    const blocked = pending.filter(
+      (row) => row.entity === "node" ? addedNodes.includes(row.kindName) : addedEdges.includes(row.kindName)
+    );
+    if (blocked.length === 0) return;
+    const named = blocked.map((row) => `${row.entity} "${row.kindName}"`).join(", ");
+    throw new ConfigurationError(
+      `Cannot re-add ${named} for graph "${this.graphId}": the previous removal's data cleanup has not run, so the old rows are still in the database and would become visible again alongside the new ones. Run store.materializeRemovals() first, then evolve.`,
+      {
+        code: "KIND_READD_BLOCKED_BY_PENDING_REMOVAL",
+        graphId: this.graphId,
+        kinds: blocked.map((row) => row.kindName)
       }
     );
-    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 = this.#adapterBackend === void 0 ? new _StoreImplementation(
@@ -18932,6 +19109,7 @@ var StoreImplementation = class _StoreImplementation {
     return {
       graph: this.#graph,
       graphId: this.graphId,
+      schemaVersion: this.#schemaMetadata.schemaVersion,
       historyEnabled: this.#captureEnabled,
       revisionTrackingEnabled: this.#revisionTrackingEnabled,
       revisionSchema: this.#sqlSchema(),
@@ -18944,6 +19122,7 @@ var StoreImplementation = class _StoreImplementation {
     return {
       graph: this.#graph,
       graphId: this.graphId,
+      schemaVersion: this.#schemaMetadata.schemaVersion,
       historyEnabled: this.#captureEnabled,
       revisionTrackingEnabled: this.#revisionTrackingEnabled,
       revisionSchema: this.#sqlSchema(),
@@ -18953,6 +19132,57 @@ var StoreImplementation = class _StoreImplementation {
     };
   }
   // === Internal: Hook Helpers ===
+  /**
+   * Decorates the query execution port so hooks observe each statement the
+   * query builder submits to the backend. A selective-projection retry
+   * therefore emits two independent start/end pairs with their actual SQL.
+   */
+  #createHookedQueryBackend(backend) {
+    if (this.#hooks.onQueryStart === void 0 && this.#hooks.onQueryEnd === void 0 && this.#hooks.onError === void 0) {
+      return backend;
+    }
+    const executeRaw = backend.executeRaw;
+    const compileSql = backend.compileSql;
+    const projected = createGraphBackendProjection(backend);
+    return {
+      ...projected,
+      execute: (query) => {
+        const compiled = compileSql === void 0 ? renderSql(query, backend.dialect) : compileSql(query);
+        return this.#withQueryHooks(
+          compiled.sql,
+          compiled.params,
+          () => backend.execute(query)
+        );
+      },
+      ...executeRaw === void 0 ? {} : {
+        executeRaw: (sqlText, params) => this.#withQueryHooks(
+          sqlText,
+          params,
+          () => executeRaw(sqlText, params)
+        )
+      }
+    };
+  }
+  async #withQueryHooks(sql2, params, execute) {
+    const ctx = {
+      ...this.#createHookContext(),
+      sql: sql2,
+      params
+    };
+    this.#hooks.onQueryStart?.(ctx);
+    const startTime = Date.now();
+    try {
+      const rows = await execute();
+      this.#hooks.onQueryEnd?.(ctx, {
+        rowCount: rows.length,
+        durationMs: Date.now() - startTime
+      });
+      return rows;
+    } catch (error) {
+      this.#hooks.onError?.(ctx, asError(error));
+      throw error;
+    }
+  }
   #createHookContext() {
     return {
       operationId: generateId(),
@@ -19034,13 +19264,14 @@ var StoreImplementation = class _StoreImplementation {
     };
   }
   #createQueryForBackend(backend, sealedCoordinate) {
+    const queryBackend = this.#createHookedQueryBackend(backend);
     return createInternalQueryBuilder(
       this.graphId,
       this.#registry,
       {
         // TransactionBackend omits transaction/close, but query execution only needs
         // the read-path/query capabilities shared with GraphBackend.
-        backend,
+        backend: queryBackend,
         dialect: backend.dialect,
         defaultTraversalExpansion: this.#defaultTraversalExpansion,
         ...this.#schema !== void 0 && { schema: this.#schema },
@@ -19353,5 +19584,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-JNXZQBN3.js.map
-//# sourceMappingURL=chunk-JNXZQBN3.js.map
+//# sourceMappingURL=chunk-BCP7LLOY.js.map
+//# sourceMappingURL=chunk-BCP7LLOY.js.map