@nicia-ai/typegraph 0.44.0 → 0.45.0

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

@@ -1,30 +1,30 @@
-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 { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-YMTXMPV6.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdateWhere, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, lockSchemaVersionForStoreWrite, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-Q6EDCUXV.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-TKORQCG4.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 { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-55ITBQJI.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 { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, planRemovals, stripGraphExtension, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-FQ7ZPOTZ.js';
 import { compareStrings, compareCodePoints } from './chunk-DRACN6XG.js';
-import { getTypeName } from './chunk-2Y4IFKW7.js';
+import { getTypeName } from './chunk-TKP5T34P.js';
 import { validateEdgeProps } from './chunk-DK2S42XB.js';
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-B75XRV3O.js';
+import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-V34A6R5V.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 { generateIndexDDL } from './chunk-FL5UQRES.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-QLUXRWKL.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-FLEQ2HBK.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-K3BUWSFR.js';
+import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-PVUI6KGR.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 } from './chunk-IJTLXNGJ.js';
-import { validateProjectionField } from './chunk-TVLKA4AY.js';
+import { IncompatibleChangeError } from './chunk-4GUBTVPV.js';
+import { validateProjectionField } from './chunk-42PYUGLS.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';
 
@@ -38,6 +38,7 @@ var NODE_WRITE_NAMES = [
   "create",
   "createFromRecord",
   "update",
+  "updateWhere",
   "delete",
   "hardDelete",
   "upsertById",
@@ -570,6 +571,13 @@ var StoreView = class extends CoordinatePinnedView {
     );
     return this.#edges;
   }
+  /** Heterogeneous multi-kind edge read pinned to this view's coordinate. */
+  bulkFindEdgesFrom(params, options) {
+    return this.store.bulkFindEdgesFrom(params, {
+      ...options,
+      ...withValidCoordinate(this.coordinate)
+    });
+  }
   /**
    * Read-only search facade. On a `current` view the read methods
    * (`fulltext` / `vector` / `hybrid`) delegate to the live `store.search`,
@@ -13911,6 +13919,35 @@ function narrowNode(node) {
 function narrowNodes(nodes) {
   return nodes;
 }
+function createFieldMember(accessor) {
+  const selectField = (name) => accessor.field(name);
+  return new Proxy(selectField, {
+    get(target, property, receiver) {
+      if (Reflect.has(target, property)) {
+        const ownProperty = Reflect.get(target, property, receiver);
+        return ownProperty;
+      }
+      return accessor.field("field")[property];
+    }
+  });
+}
+function evaluateNodePredicate(accessor, predicate) {
+  const collectionAccessor = new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") return;
+        if (property === "then" || property === "toJSON") return;
+        if (property === "id" || property === "kind" || property === "$fulltext") {
+          return accessor[property];
+        }
+        if (property === "field") return createFieldMember(accessor);
+        return accessor.field(property);
+      }
+    }
+  );
+  return predicate(collectionAccessor);
+}
 function buildCreateInput(kind, props, options) {
   const input = { kind, props };
   if (options?.id !== void 0) input.id = options.id;
@@ -13937,6 +13974,7 @@ function createNodeCollection(config) {
     executeCreateNoReturnBatch: executeNodeCreateNoReturnBatch2,
     executeCreateBatch: executeNodeCreateBatch2,
     executeUpdate: executeNodeUpdate2,
+    executeUpdateWhere: executeNodeUpdateWhere2,
     executeUpsertUpdate: executeNodeUpsertUpdate2,
     executeDelete: executeNodeDelete2,
     executeHardDelete: executeNodeHardDelete2,
@@ -13983,6 +14021,85 @@ function createNodeCollection(config) {
       );
       return narrowNode(result);
     },
+    async updateWhere(params) {
+      if (createQuery === void 0) {
+        throw new ConfigurationError(
+          `store.nodes.${kind}.updateWhere() requires a query-capable store`,
+          { kind, operation: "updateWhere" }
+        );
+      }
+      const exists = params.exists ?? [];
+      if (params.where === void 0 && exists.length === 0 && !params.all) {
+        throw new ConfigurationError(
+          `store.nodes.${kind}.updateWhere() requires where, exists, or explicit all: true`,
+          { kind, operation: "updateWhere" }
+        );
+      }
+      const rootAlias = "update_candidate";
+      const readInstant = nowIso();
+      let base = createQuery().fromDynamic(kind, rootAlias).temporal("asOf", readInstant);
+      const where = params.where;
+      if (where !== void 0) {
+        base = base.whereNode(
+          rootAlias,
+          (accessor) => evaluateNodePredicate(accessor, where)
+        );
+      }
+      const candidateIdColumn = `${rootAlias}_id`;
+      const compiledBranches = [];
+      for (const [index, relation] of exists.entries()) {
+        const edgeAlias = `update_edge_${index}`;
+        const relatedAlias = `update_related_${index}`;
+        const relationRoot = createQuery().fromDynamic(kind, rootAlias).temporal("asOf", readInstant);
+        let traversal = relationRoot.traverseDynamic(
+          relation.edgeKind,
+          edgeAlias,
+          {
+            direction: relation.direction,
+            expand: "none"
+          }
+        );
+        if (relation.whereEdge !== void 0) {
+          traversal = traversal.whereEdge(edgeAlias, relation.whereEdge);
+        }
+        let related = traversal.toDynamic(relation.relatedKind, relatedAlias);
+        if (relation.whereRelated !== void 0) {
+          related = related.whereNode(relatedAlias, relation.whereRelated);
+        }
+        compiledBranches.push(
+          related.select(
+            (ctx) => ctx[rootAlias]?.id
+          ).compile()
+        );
+      }
+      compiledBranches.unshift(
+        base.select((ctx) => ctx[rootAlias]?.id).compile()
+      );
+      const projectCandidateId = (branch, index) => sql`
+        SELECT ${sql.identifier(candidateIdColumn)}
+        FROM (${branch}) AS ${sql.identifier(`update_branch_${index}`)}
+      `;
+      let combinedCandidates = projectCandidateId(
+        requireDefined(compiledBranches[0]),
+        0
+      );
+      for (let index = 1; index < compiledBranches.length; index++) {
+        combinedCandidates = sql`${combinedCandidates} INTERSECT ${projectCandidateId(
+          requireDefined(compiledBranches[index]),
+          index
+        )}`;
+      }
+      const compiledCandidates = asCompiledSelectSql(combinedCandidates);
+      const result = await executeNodeUpdateWhere2(
+        kind,
+        params.patch,
+        compiledCandidates,
+        candidateIdColumn,
+        backend
+      );
+      await config.maybeRefreshStatisticsAfterBulk?.(result.affectedCount);
+      return result;
+    },
     async delete(id) {
       await executeNodeDelete2(kind, id, backend);
     },
@@ -14333,10 +14450,12 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "deleteEdge",
   "deleteEdgesBatch",
   "deleteEmbedding",
+  "deleteEmbeddingBatch",
   "deleteFulltext",
   "deleteFulltextBatch",
   "deleteNode",
   "deleteUnique",
+  "hardDeleteUniquesByNodeIds",
   "deleteVectorSlotContribution",
   "dialect",
   "dropVectorIndex",
@@ -14354,6 +14473,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "executeTemporaryStatement",
   "findEdgesByKind",
   "findEdgesByEndpointSet",
+  "findEdgesByHeterogeneousEndpointSet",
   "findEdgesConnectedTo",
   "findNodesByKind",
   "fulltextSearch",
@@ -14373,6 +14493,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "hardDeleteEdge",
   "hardDeleteEdgesBatch",
   "hardDeleteNode",
+  "hardDeleteUniquesByNodeIds",
   "hybridSearch",
   "insertEdge",
   "insertEdgeNoReturn",
@@ -14394,6 +14515,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "tableNames",
   "updateEdge",
   "updateNode",
+  "updateNodeSet",
   "upsertEmbedding",
   "upsertEmbeddingBatch",
   "upsertFulltext",
@@ -16749,6 +16871,7 @@ var NODE_WRITE_INTENT_COUNTERS = {
   create: countSingleWrite,
   createFromRecord: countSingleWrite,
   update: countSingleWrite,
+  updateWhere: countSingleWrite,
   delete: countSingleWrite,
   hardDelete: countSingleWrite,
   upsertById: countSingleWrite,
@@ -16929,6 +17052,10 @@ var CAUGHT_UP_VERB_DETAILS = {
   reembed: {
     phrase: "re-embed a vector field on",
     code: "REEMBED_BEFORE_INITIALIZE"
+  },
+  repair: {
+    phrase: "repair contributions for",
+    code: "REPAIR_CONTRIBUTIONS_BEFORE_INITIALIZE"
   }
 };
 var ROW_MAPPER_CONFIGS = {
@@ -17293,8 +17420,9 @@ var StoreImplementation = class _StoreImplementation {
    * `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.
+   * returns the Store for the resulting schema, 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);
@@ -17457,6 +17585,14 @@ var StoreImplementation = class _StoreImplementation {
       executeCreateBatch: (inputs, backend) => executeNodeCreateBatch(ctx, inputs, backend),
       executeCreateNoReturnBatch: (inputs, backend) => executeNodeCreateNoReturnBatch(ctx, inputs, backend),
       executeUpdate: (input, backend, options) => executeNodeUpdate(ctx, { ...input, id: input.id }, backend, options),
+      executeUpdateWhere: (kind, patch, candidateIds, candidateIdColumn, backend) => executeNodeUpdateWhere(
+        ctx,
+        kind,
+        patch,
+        candidateIds,
+        candidateIdColumn,
+        backend
+      ),
       executeUpsertUpdate: (input, backend, options) => executeNodeUpsertUpdate(
         ctx,
         { ...input, id: input.id },
@@ -17927,6 +18063,96 @@ var StoreImplementation = class _StoreImplementation {
       return results;
     });
   }
+  /**
+   * Reads several edge kinds from heterogeneous source nodes with round trips
+   * independent of the number of licensed edge/source-kind combinations.
+   *
+   * Results are flattened in source-group/id order. Repeated sources receive
+   * independent edge arrays, and sources with no matching edges remain present
+   * with an empty array. Inputs that exceed the backend bind budget are split
+   * into source chunks without splitting one source across statements.
+   */
+  async bulkFindEdgesFrom(params, options) {
+    const sources = params.sources.flatMap(
+      (group) => {
+        if (!Object.hasOwn(this.#graph.nodes, group.kind)) {
+          throw new KindNotFoundError(group.kind, "node", {
+            graphId: this.graphId
+          });
+        }
+        return group.ids.map((id) => ({ kind: group.kind, id }));
+      }
+    );
+    for (const edgeKind of params.edgeKinds) {
+      if (!Object.hasOwn(this.#graph.edges, edgeKind)) {
+        throw new KindNotFoundError(edgeKind, "edge", {
+          graphId: this.graphId
+        });
+      }
+    }
+    if (sources.length === 0 || params.edgeKinds.length === 0) {
+      return sources.map((source) => ({ source, edges: [] }));
+    }
+    const readEndpointSet = this.#baseBackend.findEdgesByHeterogeneousEndpointSet;
+    if (readEndpointSet === void 0) {
+      throw new ConfigurationError(
+        "store.bulkFindEdgesFrom() requires a backend that can read heterogeneous endpoint and edge-kind sets in set-oriented statements.",
+        {
+          backend: this.#baseBackend.dialect,
+          capability: "findEdgesByHeterogeneousEndpointSet",
+          operation: "bulkFindEdgesFrom"
+        },
+        {
+          suggestion: "Use per-edge-kind bulkFindFrom calls explicitly if that round-trip tradeoff is acceptable."
+        }
+      );
+    }
+    const limitPerInput = options?.limitPerInput;
+    if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
+      throw new ValidationError(
+        "bulk endpoint reads require limitPerInput to be a positive integer",
+        {
+          entityType: "edge",
+          kind: params.edgeKinds.join(","),
+          issues: [
+            {
+              path: "limitPerInput",
+              message: `Expected a positive integer, received ${String(limitPerInput)}`,
+              code: "invalid_value"
+            }
+          ]
+        }
+      );
+    }
+    const temporal = resolveTemporalReadParams(
+      options,
+      this.#graph.defaults.temporalMode
+    );
+    const endpoints = sources;
+    const rows = await readEndpointSet({
+      graphId: this.graphId,
+      side: "from",
+      endpoints,
+      edgeKinds: params.edgeKinds,
+      ...limitPerInput !== void 0 && this.#baseBackend.capabilities.windowFunctions && {
+        limitPerEndpoint: limitPerInput
+      },
+      ...temporal
+    });
+    const edgesBySource = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const edge = rowToEdge(row);
+      const key = `${edge.fromKind}\0${edge.fromId}`;
+      const bucket = edgesBySource.get(key);
+      if (bucket === void 0) edgesBySource.set(key, [edge]);
+      else bucket.push(edge);
+    }
+    return sources.map((source) => {
+      const bucket = edgesBySource.get(`${source.kind}\0${source.id}`) ?? [];
+      const edges = limitPerInput === void 0 ? [...bucket] : bucket.slice(0, limitPerInput);
+      return { source, edges };
+    });
+  }
   // === Subgraph Extraction ===
   /**
    * Extracts a typed subgraph by traversing from a root node.
@@ -18068,6 +18294,7 @@ var StoreImplementation = class _StoreImplementation {
     }
     const pending = [];
     const runHooks = this.#createBufferedHookRunner(pending);
+    const runBulkHooks = this.#createBufferedBulkHookRunner(pending);
     let recordedByGraph;
     const transactionOptions = receiptRecorder !== void 0 && this.#captureEnabled ? withRecordedFlushObserver(backendOptions, (instants) => {
       recordedByGraph = instants;
@@ -18078,7 +18305,8 @@ var StoreImplementation = class _StoreImplementation {
           txBackend,
           nativeTransaction,
           runHooks,
-          receiptRecorder
+          receiptRecorder,
+          runBulkHooks
         )
       );
       const result = this.#captureEnabled || this.#adapterBackend === void 0 ? await this.#backend.transaction(
@@ -18089,9 +18317,16 @@ var StoreImplementation = class _StoreImplementation {
         transactionOptions
       );
       for (const outcome of pending) {
-        this.#hooks.onOperationEnd?.(outcome.ctx, {
-          durationMs: outcome.durationMs
-        });
+        if (outcome.type === "bulkOperation") {
+          this.#hooks.onBulkOperationEnd?.(outcome.ctx, {
+            affectedCount: outcome.affectedCount,
+            durationMs: outcome.durationMs
+          });
+        } else {
+          this.#hooks.onOperationEnd?.(outcome.ctx, {
+            durationMs: outcome.durationMs
+          });
+        }
       }
       return { result, recordedByGraph };
     } catch (error) {
@@ -18281,9 +18516,11 @@ var StoreImplementation = class _StoreImplementation {
    * (#140); when history capture is enabled it is replaced with a fail-loud
    * guard because raw graph writes would bypass recorded-time capture.
    */
-  #buildTransactionContext(txBackend, sql2, runHooks = this.#immediateHookRunner(), receiptRecorder) {
+  #buildTransactionContext(txBackend, sql2, runHooks = this.#immediateHookRunner(), receiptRecorder, runBulkHooks = this.#immediateBulkHookRunner()) {
     const txNodeOperations = {
-      ...this.#buildNodeOperations(this.#createNodeOperationContext(runHooks)),
+      ...this.#buildNodeOperations(
+        this.#createNodeOperationContext(runHooks, runBulkHooks)
+      ),
       createQuery: () => this.#createQueryForBackend(txBackend),
       maybeRefreshStatisticsAfterBulk: void 0
     };
@@ -18451,12 +18688,14 @@ var StoreImplementation = class _StoreImplementation {
   /**
    * 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.
+   * returning the `Store` for 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.
+   * contexts close over the graph at construction time. After `evolve()`
+   * resolves, callers must use the returned Store (or the re-pointed
+   * `ref.current`) for every subsequent operation in the same request. A
+   * Store captured before the schema commit remains pinned to the old version,
+   * and its next managed write is rejected by the schema fence.
    *
    * **Cost for purely additive extensions is proportional to schema
    * document size, not row count.** The commit is a single CAS write.
@@ -18474,10 +18713,10 @@ var StoreImplementation = class _StoreImplementation {
    *
    * @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.
+   * @param options.ref - Optional handle whose `current` is overwritten with
+   *   the replacement before a successful call resolves. Code awaiting this
+   *   call can use the returned Store or `ref.current` immediately. A
+   *   previously captured Store is not mutated.
    *
    * @throws {GraphExtensionValidationError} when the extension is
    *   structurally invalid.
@@ -18561,8 +18800,8 @@ var StoreImplementation = class _StoreImplementation {
    * 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()`.
+   * @param options.ref - Optional handle to be re-pointed to the replacement
+   *   Store before a successful call resolves, mirroring `evolve()`.
    *
    * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE` (no
    *   schema yet) or `DEPRECATE_UNKNOWN_KIND` (name not on the graph).
@@ -18583,8 +18822,8 @@ var StoreImplementation = class _StoreImplementation {
    *
    * @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.
+   * @param options.ref - Optional handle to be re-pointed to the replacement
+   *   Store before a successful call resolves.
    *
    * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE`.
    * @throws {StaleVersionError} on a CAS race with another writer.
@@ -18864,6 +19103,39 @@ var StoreImplementation = class _StoreImplementation {
     const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(this.#graph) : [];
     return verify(this.graphId, vectorSlots);
   }
+  /**
+   * Non-destructively repairs contribution states whose physical storage can
+   * be preserved: `missing-marker` and `failed-materialization`.
+   * `orphaned-marker` and `stale` findings are returned as
+   * `requires-rebuild`; this method never drops contribution tables or
+   * fabricates the data needed to rebuild them.
+   *
+   * The repair re-audits inside the backend and resolves every declaration
+   * from the committed schema. Callers do not supply diagnostics, physical
+   * names, or DDL. A stale Store is caught up to the active persisted graph
+   * before its vector slots are enumerated, so repair does not use declarations
+   * from the Store's stale in-memory graph snapshot.
+   *
+   * @throws {ConfigurationError} when no schema has been initialized or the
+   *   backend cannot probe and repair strategy-owned contributions.
+   */
+  async repairContributions() {
+    const backend = this.#baseBackend;
+    const repair = backend.repairContributions;
+    if (repair === void 0) {
+      throw new ConfigurationError(
+        "repairContributions requires a backend that can probe and repair strategy-owned contribution tables.",
+        {
+          backend: backend.dialect,
+          capability: "contributions",
+          operation: "repair"
+        }
+      );
+    }
+    const { baseline } = await this.#loadCaughtUp("repair");
+    const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(baseline) : [];
+    return repair(this.graphId, vectorSlots);
+  }
   /**
    * Removes extension kinds from the schema with cascading edge and
    * ontology cleanup. Two-phase by design:
@@ -18918,9 +19190,10 @@ var StoreImplementation = class _StoreImplementation {
     );
     const recordKindRemoval = this.#backend.recordKindRemoval;
     if (recordKindRemoval !== void 0) {
-      if (this.#backend.ensureKindRemovalsTable !== void 0) {
-        await this.#backend.ensureKindRemovalsTable();
-      }
+      await ensureFocusedStatusTable(
+        this.#backend,
+        this.#backend.ensureKindRemovalsTable
+      );
       const attemptedAt = nowIso();
       const newSchemaVersion = committedRow.version;
       const queue = (kindName, entity) => recordKindRemoval(
@@ -19059,6 +19332,10 @@ var StoreImplementation = class _StoreImplementation {
       (kind) => !(kind in baseline.edges)
     );
     if (addedNodes.length === 0 && addedEdges.length === 0) return;
+    await ensureFocusedStatusTable(
+      this.#backend,
+      this.#backend.ensureKindRemovalsTable
+    );
     const pending = await getPendingKindRemovals(this.graphId);
     if (pending.length === 0) return;
     const blocked = pending.filter(
@@ -19105,7 +19382,10 @@ var StoreImplementation = class _StoreImplementation {
   #immediateHookRunner() {
     return (ctx, fn) => this.#withOperationHooks(ctx, fn);
   }
-  #createNodeOperationContext(runHooks = this.#immediateHookRunner()) {
+  #immediateBulkHookRunner() {
+    return (ctx, fn) => this.#withBulkOperationHooks(ctx, fn);
+  }
+  #createNodeOperationContext(runHooks = this.#immediateHookRunner(), runBulkHooks = this.#immediateBulkHookRunner()) {
     return {
       graph: this.#graph,
       graphId: this.graphId,
@@ -19115,7 +19395,14 @@ var StoreImplementation = class _StoreImplementation {
       revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
-      withOperationHooks: runHooks
+      withOperationHooks: runHooks,
+      createBulkOperationContext: (operation, kind) => ({
+        ...this.#createHookContext(),
+        operation,
+        entity: "node",
+        kind
+      }),
+      withBulkOperationHooks: runBulkHooks
     };
   }
   #createEdgeOperationContext(runHooks = this.#immediateHookRunner()) {
@@ -19213,6 +19500,21 @@ var StoreImplementation = class _StoreImplementation {
       throw error;
     }
   }
+  async #withBulkOperationHooks(ctx, fn) {
+    this.#hooks.onBulkOperationStart?.(ctx);
+    const startTime = Date.now();
+    try {
+      const result = await fn();
+      this.#hooks.onBulkOperationEnd?.(ctx, {
+        affectedCount: result.affectedCount,
+        durationMs: Date.now() - startTime
+      });
+      return result;
+    } catch (error) {
+      this.#hooks.onError?.(ctx, asError(error));
+      throw error;
+    }
+  }
   /**
    * A hook runner for operations that execute INSIDE an explicit
    * `store.transaction`: `onOperationStart` (and a failed operation's
@@ -19229,7 +19531,31 @@ var StoreImplementation = class _StoreImplementation {
       const startTime = Date.now();
       try {
         const result = await fn();
-        pending.push({ ctx, durationMs: Date.now() - startTime });
+        pending.push({
+          type: "operation",
+          ctx,
+          durationMs: Date.now() - startTime
+        });
+        return result;
+      } catch (error) {
+        this.#hooks.onError?.(ctx, asError(error));
+        throw error;
+      }
+    };
+  }
+  /** Buffered counterpart for set-based operations inside `transaction()`. */
+  #createBufferedBulkHookRunner(pending) {
+    return async (ctx, fn) => {
+      this.#hooks.onBulkOperationStart?.(ctx);
+      const startTime = Date.now();
+      try {
+        const result = await fn();
+        pending.push({
+          type: "bulkOperation",
+          ctx,
+          affectedCount: result.affectedCount,
+          durationMs: Date.now() - startTime
+        });
         return result;
       } catch (error) {
         this.#hooks.onError?.(ctx, asError(error));
@@ -19584,5 +19910,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-BCP7LLOY.js.map
-//# sourceMappingURL=chunk-BCP7LLOY.js.map
+//# sourceMappingURL=chunk-ID4WXTKL.js.map
+//# sourceMappingURL=chunk-ID4WXTKL.js.map