@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/{chunk-GA4TT3DH.js → chunk-A2FGSWMQ.js}

@@ -1,25 +1,32 @@
-import { createEdgeRowMapper, createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG, quoteIdentifier, EMPTY_REQUIRED_COLUMNS, addRequiredColumn, mapSelectiveSystemFieldToColumn, markFieldRefAsRequired, findSelectivePropsFieldForFieldRef, markSelectiveFieldAsRequired, NODE_COLUMNS, shouldProjectColumn, isIdFieldRef, isAggregateExpr, EDGE_COLUMNS } from './chunk-M6VES7V6.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-RCVLFTCT.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, serializeIndexDeclaration } from './chunk-3RWZPJKV.js';
-import { isKnownKind, validateEdgeProps } from './chunk-3SLPDKHQ.js';
+import { compareStrings, compareCodePoints } from './chunk-DRACN6XG.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-AOL64O4Z.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-UPXDVI3T.js';
+import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, generateId, createGraphBackendProjection, vectorSlotKey, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, advanceRevisionClock, recordedReadSqlSchema, requireRecordedReadBinding, 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, compilePredicateClauses, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-RQPRCEIO.js';
+import { chunk } from './chunk-35S6P5ZU.js';
+import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-PZHC5GCD.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, asRecordedInstant, assertValidRecordedInstant } from './chunk-J6IJARLG.js';
+import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, serializeIndexDeclaration } from './chunk-VBH7ZXSZ.js';
+import { getTypeName } from './chunk-76HE7DJP.js';
+import { validateEdgeProps } from './chunk-ZE6NVENI.js';
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { generateIndexDDL } from './chunk-KQJ54OG5.js';
-import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-YTSN73ND.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-K5UBVGJN.js';
-import { sha256Hex, fnv1aBase36 } from './chunk-W63OVYY4.js';
-import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-EXU3RASM.js';
-import { createSchemaIntrospector } from './chunk-UGZUAYAR.js';
-import { IncompatibleChangeError, RemoveCompileTimeKindError, KindHasReferentsError } from './chunk-L7HQ2OSI.js';
-import { validateProjectionField } from './chunk-TPF25IG6.js';
-import { compareStrings, compareCodePoints } from './chunk-BYPOGQWK.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, assertRevisionTrackableBackend, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, createRecordedBackend, readRecordedClock, asRecordedInstant, ensureRevisionOrigin, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, createHistoryUnsafeSqlRef, createRevisionTrackingUnsafeSqlRef, generateId, vectorSlotKey, computeFulltextContent, advanceRevisionClock, recordedReadSqlSchema, requireRecordedReadBinding, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, validateEdgeEndpoints, recordedBindParamBudget, assertValidRecordedInstant, closeRecordedHardDeletedKind, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-VKGKDOKR.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, runOptionallyInTransaction, baseField, objectField, arrayField, dateField, numberField, annIndexScanTypes, rowPropsToObject, asCompiledRowsSql, sqlValueList, createBackendOverlay, compileKindFilter, currentReadInstant, compileTemporalFilter, markForceCustomPlan, chunk, INTERNAL_TEMPORARY_WRITES, buildPredicateIndex, compileFieldValue, asCompiledTemporaryStatementSql, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, asCompiledStatementSql, compilePredicateClauses, isPresent } from './chunk-44TA22QT.js';
-import { withRecordedRelationsPrecondition, nowIso, validateOptionalCanonicalIsoDate, isMissingTableError } from './chunk-XGPUQ56G.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-OHMP6N2J.js';
+import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-KFLXWVUJ.js';
+import { isKnownKind } from './chunk-PH4IJ3V5.js';
+import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-I6FX7AAG.js';
+import { generateIndexDDL } from './chunk-U4JDJKPD.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-BQITNFQJ.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-VDYA2HMS.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 } from './chunk-G3CSQLLT.js';
+import { assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-Y7M44XEK.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-6XDBRDZE.js';
+import { createSchemaIntrospector } from './chunk-D7PG5D5K.js';
+import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
 import { getSearchableFields, resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage } from './chunk-PC2UBAUB.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, UnsupportedBackendCapabilityError, GraphAlgorithmConvergenceError, EndpointNotFoundError, InvalidEdgeWeightError } from './chunk-5PNMDJ7J.js';
+import { IncompatibleChangeError, RemoveCompileTimeKindError, KindHasReferentsError } from './chunk-SCTZRFW5.js';
+import { validateProjectionField } from './chunk-XZA3Y4YH.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, UnsupportedBackendCapabilityError, GraphAlgorithmConvergenceError, EndpointNotFoundError, InvalidEdgeWeightError } from './chunk-DPNA466P.js';
 import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-G6Q5UM7U.js';
-import { Placeholder, sql } from 'drizzle-orm';
 
 // src/store/collection-surface.ts
 var CURRENT_ONLY_READ_NAMES = [
@@ -279,7 +286,7 @@ function pinnedCollections(live, coordinate, isKind, wrap) {
         if (cached !== void 0) return cached;
         const wrapped = wrap(
           kind,
-          live[kind],
+          requireDefined(live[kind]),
           coordinate
         );
         cache.set(kind, wrapped);
@@ -306,15 +313,15 @@ function pinnedEdgeCollectionsFor(store, coordinate, wrap) {
 }
 function recordedNodeCollection(store, kind, live, coordinate) {
   const reads = {
-    getById: (id) => store.recordedNodeGetById(kind, id, coordinate),
-    getByIds: (ids) => store.recordedNodeGetByIds(kind, ids, coordinate)
+    getById: (id) => storeRuntime(store).recordedNodeGetById(kind, id, coordinate),
+    getByIds: (ids) => storeRuntime(store).recordedNodeGetByIds(kind, ids, coordinate)
   };
   return recordedCollectionProxy(reads, live, coordinate, "node");
 }
 function recordedEdgeCollection(store, kind, live, coordinate) {
   const reads = {
-    getById: (id) => store.recordedEdgeGetById(kind, id, coordinate),
-    getByIds: (ids) => store.recordedEdgeGetByIds(kind, ids, coordinate)
+    getById: (id) => storeRuntime(store).recordedEdgeGetById(kind, id, coordinate),
+    getByIds: (ids) => storeRuntime(store).recordedEdgeGetByIds(kind, ids, coordinate)
   };
   return recordedCollectionProxy(reads, live, coordinate, "edge");
 }
@@ -414,12 +421,12 @@ var CoordinatePinnedView = class {
    * view's coordinate cannot be overridden on a per-query basis.
    */
   query() {
-    return this.store.sealedQuery(this.coordinate);
+    return storeRuntime(this.store).sealedQuery(this.coordinate);
   }
   internalAlgorithms() {
-    this.#internalAlgorithms ??= this.store.algorithmsAtCoordinate(
-      this.coordinate
-    );
+    this.#internalAlgorithms ??= storeRuntime(
+      this.store
+    ).algorithmsAtCoordinate(this.coordinate);
     return this.#internalAlgorithms;
   }
   /** Graph algorithms pinned to this view's immutable temporal coordinate. */
@@ -431,7 +438,10 @@ var CoordinatePinnedView = class {
       canReach: (from, to, options) => this.canReach(from, to, options),
       neighbors: (node, options) => this.neighbors(node, options),
       degree: (node, options) => this.degree(node, options),
-      weaklyConnectedComponents: (options) => this.weaklyConnectedComponents(options)
+      labelPropagation: (options) => this.labelPropagation(options),
+      weaklyConnectedComponents: (options) => this.weaklyConnectedComponents(options),
+      pageRank: (options) => this.pageRank(options),
+      personalizedPageRank: (options) => this.personalizedPageRank(options)
     });
     return this.#algorithmFacade;
   }
@@ -441,7 +451,10 @@ var CoordinatePinnedView = class {
       ...options,
       ...withCoordinate(this.coordinate)
     };
-    return this.store.subgraphAtCoordinate(rootId, internalOptions);
+    return storeRuntime(this.store).subgraphAtCoordinate(
+      rootId,
+      internalOptions
+    );
   }
   /** Shortest path between two nodes at this view's pinned coordinate. */
   shortestPath(from, to, options) {
@@ -485,6 +498,13 @@ var CoordinatePinnedView = class {
       ...withCoordinate(this.coordinate)
     });
   }
+  /** Deterministic label-propagation memberships at this view's coordinate. */
+  labelPropagation(options) {
+    return this.internalAlgorithms().labelPropagation({
+      ...options,
+      ...withCoordinate(this.coordinate)
+    });
+  }
   /** Exact WCC memberships at this view's pinned coordinate. */
   weaklyConnectedComponents(options) {
     return this.internalAlgorithms().weaklyConnectedComponents({
@@ -492,6 +512,20 @@ var CoordinatePinnedView = class {
       ...withCoordinate(this.coordinate)
     });
   }
+  /** Global PageRank scores at this view's pinned coordinate. */
+  pageRank(options) {
+    return this.internalAlgorithms().pageRank({
+      ...options,
+      ...withCoordinate(this.coordinate)
+    });
+  }
+  /** Personalized PageRank scores at this view's pinned coordinate. */
+  personalizedPageRank(options) {
+    return this.internalAlgorithms().personalizedPageRank({
+      ...options,
+      ...withCoordinate(this.coordinate)
+    });
+  }
 };
 var StoreView = class extends CoordinatePinnedView {
   #nodes;
@@ -788,6 +822,8 @@ function inspectSetOperationPlan(logicalPlan) {
     sortNode
   };
 }
+
+// src/query/compiler/emitter/recursive.ts
 function assertRecursiveEmitterClauseAlignment(logicalPlan, input) {
   const planShape = inspectRecursiveProjectPlan(logicalPlan);
   if (planShape.hasSort && input.orderBy === void 0) {
@@ -832,6 +868,8 @@ function emitRecursiveQuerySql(input) {
   }
   return sql.join(parts, sql` `);
 }
+
+// src/query/compiler/emitter/set-operations.ts
 function assertSetOperationEmitterClauseAlignment(logicalPlan, suffixClauses) {
   const shape = inspectSetOperationPlan(logicalPlan);
   const hasSuffixClauses = suffixClauses !== void 0 && suffixClauses.length > 0;
@@ -874,6 +912,8 @@ function emitSetOperationQuerySql(input) {
   }
   return sql.join(parts, sql` `);
 }
+
+// src/query/compiler/emitter/standard.ts
 function assertStandardEmitterClauseAlignment(logicalPlan, input) {
   const planShape = inspectStandardProjectPlan(logicalPlan);
   if (input.groupBy !== void 0 && !planShape.hasAggregate) {
@@ -942,7 +982,7 @@ function truncateToBytes(value, maxBytes) {
   const encoded = TEXT_ENCODER.encode(value);
   if (encoded.byteLength <= maxBytes) return value;
   let end = maxBytes;
-  while (end > 0 && encoded[end] >= 128 && encoded[end] < 192) {
+  while (end > 0 && requireDefined(encoded[end]) >= 128 && requireDefined(encoded[end]) < 192) {
     end--;
   }
   return new TextDecoder().decode(encoded.slice(0, end));
@@ -1009,6 +1049,94 @@ function compileSelectivePropsExtraction(field2, column, dialect) {
   });
 }
 
+// src/query/compiler/utils.ts
+var NODE_COLUMNS = [
+  "id",
+  "kind",
+  "props",
+  "version",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EDGE_COLUMNS = [
+  "id",
+  "kind",
+  "from_id",
+  "to_id",
+  "props",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
+function quoteIdentifier(identifier) {
+  return sql.identifier(identifier);
+}
+function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
+  if (alwaysRequiredColumns?.has(column)) return true;
+  if (requiredColumns === void 0) return true;
+  return requiredColumns.has(column);
+}
+function addRequiredColumn(requiredColumnsByAlias, alias, column) {
+  const existing = requiredColumnsByAlias.get(alias);
+  if (existing) {
+    existing.add(column);
+    return;
+  }
+  requiredColumnsByAlias.set(alias, /* @__PURE__ */ new Set([column]));
+}
+function markFieldRefAsRequired(requiredColumnsByAlias, field2) {
+  const column = field2.path[0];
+  if (column === void 0) return;
+  addRequiredColumn(requiredColumnsByAlias, field2.alias, column);
+}
+function mapSelectiveSystemFieldToColumn(field2) {
+  if (field2 === "fromId") return "from_id";
+  if (field2 === "toId") return "to_id";
+  if (field2.startsWith("meta.")) {
+    return field2.slice(5).replaceAll(/([A-Z])/g, "_$1").toLowerCase();
+  }
+  return field2;
+}
+function markSelectiveFieldAsRequired(requiredColumnsByAlias, field2) {
+  if (field2.isSystemField) {
+    addRequiredColumn(
+      requiredColumnsByAlias,
+      field2.alias,
+      mapSelectiveSystemFieldToColumn(field2.field)
+    );
+    return;
+  }
+  addRequiredColumn(requiredColumnsByAlias, field2.alias, "props");
+}
+function getTopLevelPropsFieldName(field2) {
+  const pointer = getFieldPointer(field2);
+  if (pointer === void 0) return void 0;
+  const segments = parseJsonPointer(pointer);
+  return segments.length === 1 ? segments[0] : void 0;
+}
+function findSelectivePropsFieldForFieldRef(selectiveFields, field2) {
+  if (selectiveFields === void 0 || selectiveFields.length === 0) {
+    return void 0;
+  }
+  const propsFieldName = getTopLevelPropsFieldName(field2);
+  if (propsFieldName === void 0) return void 0;
+  return selectiveFields.find(
+    (selectiveField) => !selectiveField.isSystemField && selectiveField.alias === field2.alias && selectiveField.field === propsFieldName
+  );
+}
+function isIdFieldRef(field2) {
+  return field2.path.length === 1 && field2.path[0] === "id" && field2.jsonPointer === void 0;
+}
+function isAggregateExpr(source) {
+  return "__type" in source && source.__type === "aggregate";
+}
+
 // src/query/compiler/emitter/standard-builders.ts
 function compileColumnReference(tableAlias, column) {
   if (tableAlias === void 0) {
@@ -1137,7 +1265,7 @@ function buildStandardTraversalCte(input) {
     traversalIndex,
     traversalLimit
   } = input;
-  const traversal = ast.traversals[traversalIndex];
+  const traversal = requireDefined(ast.traversals[traversalIndex]);
   const traversalLimitValue = traversalIndex === ast.traversals.length - 1 ? traversalLimit : void 0;
   const previousNodeKinds = getNodeKindsForAlias(ast, traversal.joinFromAlias);
   const directEdgeKinds = [...new Set(traversal.edgeKinds)];
@@ -1540,7 +1668,10 @@ function buildLateMaterializedTopKCte(input) {
     limit: input.limit,
     offset: input.offset
   });
-  const parts = [sql`SELECT ${sql.join(columns, sql`, `)}`, fromClause];
+  const parts = [
+    sql`SELECT ${sql.join(columns, sql`, `)}`,
+    fromClause
+  ];
   if (innerOrderBy !== void 0) parts.push(innerOrderBy);
   if (limitOffset !== void 0) parts.push(limitOffset);
   return sql`${sql.raw(LATE_MAT_TOPK_CTE_ALIAS)} AS (${sql.join(parts, sql` `)})`;
@@ -2369,7 +2500,7 @@ function lowerSetOperationToLogicalPlanNode(op, graphId, dialect, nextPlanNodeId
     if (op.limit !== void 0 && op.offset !== void 0) {
       currentNode = { ...limitOffsetBase, limit: op.limit, offset: op.offset };
     } else if (op.limit === void 0) {
-      currentNode = { ...limitOffsetBase, offset: op.offset };
+      currentNode = { ...limitOffsetBase, offset: requireDefined(op.offset) };
     } else {
       currentNode = { ...limitOffsetBase, limit: op.limit };
     }
@@ -2995,6 +3126,8 @@ function decodeByValueType(value, valueType) {
     }
   }
 }
+
+// src/store/recursive-cte.ts
 function buildReachableCte(options) {
   const trackPath = options.cyclePolicy === "prevent" || options.includePath;
   const edgeKindFilter = compileKindFilter(
@@ -3196,26 +3329,35 @@ async function executeSubgraph(params) {
   });
   const includedIdsCte = buildIncludedIdsCte(ctx);
   let membership;
-  if (ctx.dialect.name === "postgres") {
-    const includedIds = await fetchIncludedIds(
-      ctx,
-      reachableCte,
-      includedIdsCte
-    );
-    const idsArray = textArrayParam(includedIds);
-    membership = {
-      prefix: sql``,
-      idFilter: (column) => sql`EXISTS (SELECT 1 FROM unnest(${idsArray}) AS tg_included(id) WHERE tg_included.id = ${column})`,
-      parameterDependentPlan: true
-    };
-  } else {
-    membership = {
-      prefix: sql`${reachableCte}${includedIdsCte} `,
-      // SQLite: `column IN (subquery)` evaluates via a transient index —
-      // optimal as-is. (Postgres takes the parameterized text[] form above.)
-      idFilter: (column) => sql`${column} IN (SELECT id FROM included_ids)`,
-      parameterDependentPlan: false
-    };
+  const dialect = ctx.dialect.name;
+  switch (dialect) {
+    case "postgres": {
+      const includedIds = await fetchIncludedIds(
+        ctx,
+        reachableCte,
+        includedIdsCte
+      );
+      const idsArray = textArrayParam(includedIds);
+      membership = {
+        prefix: sql``,
+        idFilter: (column) => sql`EXISTS (SELECT 1 FROM unnest(${idsArray}) AS tg_included(id) WHERE tg_included.id = ${column})`,
+        parameterDependentPlan: true
+      };
+      break;
+    }
+    case "sqlite": {
+      membership = {
+        prefix: sql`${reachableCte}${includedIdsCte} `,
+        // SQLite: `column IN (subquery)` evaluates via a transient index —
+        // optimal as-is. (Postgres takes the parameterized text[] form above.)
+        idFilter: (column) => sql`${column} IN (SELECT id FROM included_ids)`,
+        parameterDependentPlan: false
+      };
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported SQL dialect: ${String(dialect)}`);
+    }
   }
   const [nodeRows, edgeRows] = await Promise.all([
     fetchSubgraphNodes(ctx, membership, nodeProjectionPlan),
@@ -3473,7 +3615,7 @@ function mapSubgraphNodeRow(row, projectionPlan) {
     id: row.id
   };
   if (kindPlan.includeMeta) {
-    projectedNode.meta = rowToNodeMeta(row);
+    projectedNode["meta"] = rowToNodeMeta(row);
   }
   applyProjectedFields(projectedNode, row, kindPlan);
   return projectedNode;
@@ -3495,11 +3637,13 @@ function mapSubgraphEdgeRow(row, projectionPlan) {
     toId: row.to_id
   };
   if (kindPlan.includeMeta) {
-    projectedEdge.meta = rowToEdgeMeta(row);
+    projectedEdge["meta"] = rowToEdgeMeta(row);
   }
   applyProjectedFields(projectedEdge, row, kindPlan);
   return projectedEdge;
 }
+
+// src/query/compiler/set-operations.ts
 var OPERATOR_MAP = {
   union: "UNION",
   unionAll: "UNION ALL",
@@ -4114,7 +4258,7 @@ function tryLowerSingleHopRecursiveTraversal(ast) {
   if (ast.traversals.length !== 1) {
     return void 0;
   }
-  const traversal = ast.traversals[0];
+  const traversal = requireDefined(ast.traversals[0]);
   const variableLength = traversal.variableLength;
   if (!variableLength) {
     return void 0;
@@ -4210,11 +4354,11 @@ function resolveCountAggregateFastPath(ast) {
   if (ast.orderBy?.some((orderSpec) => orderSpec.field.alias !== ast.start.alias)) {
     return void 0;
   }
-  const traversal = ast.traversals[0];
+  const traversal = requireDefined(ast.traversals[0]);
   if ((traversal.inverseEdgeKinds?.length ?? 0) > 0) {
     return void 0;
   }
-  const groupField = ast.groupBy.fields[0];
+  const groupField = requireDefined(ast.groupBy.fields[0]);
   if (groupField.alias !== ast.start.alias || !isIdFieldRef(groupField)) {
     return void 0;
   }
@@ -4981,14 +5125,14 @@ function decodeCursor(cursor) {
     }
     const json = atob(base64);
     const raw = JSON.parse(json);
-    if (typeof raw.v !== "number" || raw.v > CURSOR_VERSION) {
+    if (typeof raw["v"] !== "number" || raw["v"] > CURSOR_VERSION) {
       throw new ValidationError(
-        `Unsupported cursor version: ${String(raw.v)}. Maximum supported: ${CURSOR_VERSION}`,
+        `Unsupported cursor version: ${String(raw["v"])}. Maximum supported: ${CURSOR_VERSION}`,
         {
           issues: [
             {
               path: "cursor",
-              message: `Cursor version ${String(raw.v)} is not supported`
+              message: `Cursor version ${String(raw["v"])} is not supported`
             }
           ]
         },
@@ -4997,17 +5141,20 @@ function decodeCursor(cursor) {
         }
       );
     }
-    if (raw.d !== "f" && raw.d !== "b") {
-      throw new ValidationError(`Invalid cursor direction: ${String(raw.d)}`, {
-        issues: [
-          {
-            path: "cursor",
-            message: `Direction must be "f" (forward) or "b" (backward)`
-          }
-        ]
-      });
+    if (raw["d"] !== "f" && raw["d"] !== "b") {
+      throw new ValidationError(
+        `Invalid cursor direction: ${String(raw["d"])}`,
+        {
+          issues: [
+            {
+              path: "cursor",
+              message: `Direction must be "f" (forward) or "b" (backward)`
+            }
+          ]
+        }
+      );
     }
-    if (!Array.isArray(raw.vals) || !Array.isArray(raw.cols)) {
+    if (!Array.isArray(raw["vals"]) || !Array.isArray(raw["cols"])) {
       throw new ValidationError("Invalid cursor structure", {
         issues: [
           {
@@ -5017,21 +5164,21 @@ function decodeCursor(cursor) {
         ]
       });
     }
-    if (raw.vals.length !== raw.cols.length) {
+    if (raw["vals"].length !== raw["cols"].length) {
       throw new ValidationError("Cursor column count mismatch", {
         issues: [
           {
             path: "cursor",
-            message: `vals (${raw.vals.length}) and cols (${raw.cols.length}) must have same length`
+            message: `vals (${raw["vals"].length}) and cols (${raw["cols"].length}) must have same length`
           }
         ]
       });
     }
     return {
-      v: raw.v,
-      d: raw.d,
-      vals: raw.vals,
-      cols: raw.cols
+      v: raw["v"],
+      d: raw["d"],
+      vals: raw["vals"],
+      cols: raw["cols"]
     };
   } catch (error) {
     if (error instanceof ValidationError) {
@@ -5138,11 +5285,11 @@ function buildCursorPredicate(cursorData, orderBy, direction, targetAlias) {
   for (let index = 0; index < orderBy.length; index++) {
     const andConditions = [];
     for (let index_ = 0; index_ < index; index_++) {
-      const spec = orderBy[index_];
+      const spec = requireDefined(orderBy[index_]);
       const value = values[index_];
       andConditions.push(buildEqualityPredicate(spec.field, value));
     }
-    const currentSpec = orderBy[index];
+    const currentSpec = requireDefined(orderBy[index]);
     const currentValue = values[index];
     const isAsc = currentSpec.direction === "asc";
     const isForward = direction === "forward";
@@ -5151,12 +5298,12 @@ function buildCursorPredicate(cursorData, orderBy, direction, targetAlias) {
       buildComparisonPredicate(currentSpec.field, op, currentValue)
     );
     if (andConditions.length === 1) {
-      orConditions.push(andConditions[0]);
+      orConditions.push(requireDefined(andConditions[0]));
     } else {
       orConditions.push({ __type: "and", predicates: andConditions });
     }
   }
-  const expression = orConditions.length === 1 ? orConditions[0] : { __type: "or", predicates: orConditions };
+  const expression = orConditions.length === 1 ? requireDefined(orConditions[0]) : { __type: "or", predicates: orConditions };
   return {
     targetAlias,
     expression
@@ -5191,8 +5338,8 @@ function buildPaginatedResult(data, orderedRows, orderBy, limit, hasMore, isBack
   let nextCursor;
   let previousCursor;
   if (orderedRows.length > 0) {
-    const firstRow = orderedRows[0];
-    const lastRow = orderedRows.at(-1);
+    const firstRow = requireDefined(orderedRows[0]);
+    const lastRow = requireDefined(orderedRows.at(-1));
     const firstContext = buildContext(firstRow);
     const lastContext = buildContext(lastRow);
     previousCursor = buildCursorFromContext(firstContext, orderBy, "b");
@@ -5646,7 +5793,7 @@ function buildRequiredAliasValue(row, plan) {
     for (const field2 of plan.metaFields) {
       meta[field2.metaKey] = nullToUndefined(row[field2.outputName]);
     }
-    base.meta = createGuardedProxy(meta, `${plan.alias}.meta`);
+    base["meta"] = createGuardedProxy(meta, `${plan.alias}.meta`);
   }
   for (const field2 of plan.propsFields) {
     const decoded = decodeSelectedValue(row[field2.outputName], field2.typeInfo);
@@ -5673,9 +5820,11 @@ function createGuardedProxy(target, debugPath) {
     }
   });
 }
+
+// src/query/builder/read-instant-template.ts
 function templateHasReadInstant(template) {
   return template.params.some(
-    (parameter) => parameter instanceof Placeholder && parameter.name === CURRENT_READ_INSTANT_PLACEHOLDER
+    (parameter) => isSqlPlaceholder(parameter) && parameter.name === CURRENT_READ_INSTANT_PLACEHOLDER
   );
 }
 function queryAstNeedsCurrentReadInstant(ast) {
@@ -5709,10 +5858,9 @@ function buildQueryTemplate(ast, graphId, compileOptions, backend) {
   });
 }
 function fillTemplateParams(params, bindings, dialect) {
-  const adapter = getDialect(dialect);
   let readInstant;
   return params.map((parameter) => {
-    if (!(parameter instanceof Placeholder)) return parameter;
+    if (!isSqlPlaceholder(parameter)) return parameter;
     const name = parameter.name;
     if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {
       readInstant ??= nowIso();
@@ -5724,8 +5872,7 @@ function fillTemplateParams(params, bindings, dialect) {
         parameterName: name
       });
     }
-    if (value instanceof Date) return value.toISOString();
-    return adapter.bindValue(value);
+    return bindSqlValue(value, dialect);
   });
 }
 
@@ -5981,7 +6128,7 @@ var PreparedQuery = class {
         bindings,
         this.#dialect
       );
-      const rawRows2 = await this.#backend.executeRaw(
+      const rawRows2 = await executeRaw(
         template.sql,
         params
       );
@@ -6703,10 +6850,10 @@ var ExecutableQuery = class _ExecutableQuery {
     return this.#config.backend.compileSql(this.compile());
   }
   /**
-   * Compiles the query to a Drizzle SQL object.
+   * Compiles the query to TypeGraph's database-independent SQL fragment.
    *
-   * Returns a Drizzle SQL object that can be executed directly
-   * with db.all(), db.get(), etc.
+   * Pass the result to a GraphBackend, or use toSQL() to render SQL text and
+   * parameters for the configured dialect.
    */
   compile() {
     const ast = this.toAst();
@@ -6827,13 +6974,9 @@ var ExecutableQuery = class _ExecutableQuery {
     const template = executeRaw === void 0 ? void 0 : this.#templateFor(ast, slot);
     const rawRows = await this.#executeOnBackend(
       backend,
-      template !== void 0 && executeRaw !== void 0 ? (
-        // Method call (not the detached `executeRaw` local) so a this-using
-        // backend implementation keeps its receiver.
-        backend.executeRaw(
-          template.sql,
-          fillTemplateParams(template.params, {}, this.#dialect())
-        )
+      template !== void 0 && executeRaw !== void 0 ? executeRaw(
+        template.sql,
+        fillTemplateParams(template.params, {}, this.#dialect())
       ) : backend.execute(
         compileQuery(ast, this.#config.graphId, this.#compileOptions())
       ),
@@ -7147,12 +7290,12 @@ var ExecutableQuery = class _ExecutableQuery {
     if (orderedRows.length > 0) {
       try {
         previousCursor = this.#buildCursorFromSelectiveRow(
-          orderedRows[0],
+          requireDefined(orderedRows[0]),
           selectiveFields,
           "b"
         );
         nextCursor = this.#buildCursorFromSelectiveRow(
-          orderedRows.at(-1),
+          requireDefined(orderedRows.at(-1)),
           selectiveFields,
           "f"
         );
@@ -7180,7 +7323,7 @@ var ExecutableQuery = class _ExecutableQuery {
     for (const spec of this.#paginationOrderBy()) {
       const field2 = spec.field;
       if (field2.path.length === 1 && field2.path[0] !== "props" && field2.jsonPointer === void 0) {
-        tracker.record(field2.alias, field2.path[0], true);
+        tracker.record(field2.alias, requireDefined(field2.path[0]), true);
         continue;
       }
       if (field2.path.length !== 1 || field2.path[0] !== "props") {
@@ -7193,7 +7336,7 @@ var ExecutableQuery = class _ExecutableQuery {
       if (segments.length !== 1) {
         return false;
       }
-      tracker.record(field2.alias, segments[0], false);
+      tracker.record(field2.alias, requireDefined(segments[0]), false);
     }
     return true;
   }
@@ -7226,7 +7369,7 @@ var ExecutableQuery = class _ExecutableQuery {
         if (spec.field.path.length !== 1) {
           throw new MissingSelectiveFieldError(alias, "orderBy");
         }
-        const fieldName = spec.field.path[0];
+        const fieldName = requireDefined(spec.field.path[0]);
         const outputName2 = outputNameByAliasField.get(
           `${alias}\0${fieldName}`
         );
@@ -7241,7 +7384,7 @@ var ExecutableQuery = class _ExecutableQuery {
       if (segments.length === 0) {
         throw new MissingSelectiveFieldError(alias, "orderBy");
       }
-      const topField = segments[0];
+      const topField = requireDefined(segments[0]);
       const outputName = outputNameByAliasField.get(
         `${alias}\0${topField}`
       );
@@ -7271,7 +7414,7 @@ var ExecutableQuery = class _ExecutableQuery {
       }
       let current = aliasObject;
       for (let index = 0; index < segments.length - 1; index++) {
-        const segment = segments[index];
+        const segment = requireDefined(segments[index]);
         const existing_ = current[segment];
         if (typeof existing_ === "object" && existing_ !== null) {
           current = existing_;
@@ -7281,7 +7424,7 @@ var ExecutableQuery = class _ExecutableQuery {
           current = created;
         }
       }
-      current[segments.at(-1)] = decoded;
+      current[requireDefined(segments.at(-1))] = decoded;
     }
     return cursorContext;
   }
@@ -7573,7 +7716,7 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
     return this.#config.backend.compileSql(this.compile());
   }
   /**
-   * Compiles the query to a Drizzle SQL object.
+   * Compiles the query to TypeGraph's database-independent SQL fragment.
    */
   compile() {
     const ast = this.toAst();
@@ -7617,16 +7760,12 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
     }
     const executeRaw = backend.executeRaw;
     const template = executeRaw === void 0 ? void 0 : this.#resolveTemplate(ast);
-    const rows = template !== void 0 && executeRaw !== void 0 ? (
-      // Method call (not the detached `executeRaw` local) so a this-using
-      // backend implementation keeps its receiver.
-      await backend.executeRaw(
-        template.sql,
-        fillTemplateParams(
-          template.params,
-          {},
-          this.#config.dialect ?? "sqlite"
-        )
+    const rows = template !== void 0 && executeRaw !== void 0 ? await executeRaw(
+      template.sql,
+      fillTemplateParams(
+        template.params,
+        {},
+        this.#config.dialect ?? "sqlite"
       )
     ) : await backend.execute(
       compileQuery(ast, this.#config.graphId, this.#compileOptions())
@@ -8969,16 +9108,12 @@ var UnionableQuery = class _UnionableQuery {
     return executeOnBackend(
       backend,
       recordedAsOfForComposableQuery(ast),
-      template !== void 0 && executeRaw !== void 0 ? (
-        // Method call (not the detached `executeRaw` local) so a this-using
-        // backend implementation keeps its receiver.
-        backend.executeRaw(
-          template.sql,
-          fillTemplateParams(
-            template.params,
-            {},
-            this.#config.dialect ?? "sqlite"
-          )
+      template !== void 0 && executeRaw !== void 0 ? executeRaw(
+        template.sql,
+        fillTemplateParams(
+          template.params,
+          {},
+          this.#config.dialect ?? "sqlite"
         )
       ) : backend.execute(
         compileSetOperation2(
@@ -9441,6 +9576,8 @@ function processPage(schema, rows) {
   }
   return { toUpsert, toDelete, skipped, skippedIds };
 }
+
+// src/store/search.ts
 var SEARCH_CANDIDATE_ALIAS = "_sc";
 function buildKindCandidates(ctx, nodeKind, where) {
   if (where === void 0) return void 0;
@@ -9550,7 +9687,7 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
     kinds.map(async (kind) => {
       const candidates = buildKindCandidates(ctx, kind, options.where);
       const language = effectiveFulltextLanguage(ctx, kind, options.language);
-      const rows = await backend.fulltextSearch({
+      const rows = await requireDefined(backend.fulltextSearch)({
         graphId,
         nodeKind: kind,
         query: options.query,
@@ -9572,7 +9709,7 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
       }));
     })
   );
-  const merged = singleKind ? perKindRows[0] : perKindRows.flat().toSorted(
+  const merged = singleKind ? requireDefined(perKindRows[0]) : perKindRows.flat().toSorted(
     (a, b) => b.score - a.score || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
   ).slice(offset, offset + options.limit);
   if (merged.length === 0) return [];
@@ -9629,12 +9766,12 @@ async function executeVectorSearch(ctx, nodeKind, options) {
   }
   const offset = options.offset ?? 0;
   const singleKind = searchKinds.length === 1;
-  const metric = options.metric ?? searchKinds[0].slot.metric;
+  const metric = options.metric ?? requireDefined(searchKinds[0]).slot.metric;
   const perKindRows = await Promise.all(
     searchKinds.map(
       async ({ kind, slot }) => {
         const candidates = buildKindCandidates(ctx, kind, options.where);
-        const rows = await backend.vectorSearch({
+        const rows = await requireDefined(backend.vectorSearch)({
           graphId,
           nodeKind: kind,
           fieldPath: options.fieldPath,
@@ -9662,7 +9799,7 @@ async function executeVectorSearch(ctx, nodeKind, options) {
       }
     )
   );
-  const merged = singleKind ? perKindRows[0] : mergeVectorRows(perKindRows, metric).slice(
+  const merged = singleKind ? requireDefined(perKindRows[0]) : mergeVectorRows(perKindRows, metric).slice(
     offset,
     offset + options.limit
   );
@@ -9771,7 +9908,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
       "hybridSearch.vector.minScore"
     );
   }
-  const vectorMetric = options.vector.metric ?? vectorKinds[0].slot.metric;
+  const vectorMetric = options.vector.metric ?? requireDefined(vectorKinds[0]).slot.metric;
   const candidatesByKind = /* @__PURE__ */ new Map();
   for (const kind of fulltextKinds) {
     candidatesByKind.set(kind, buildKindCandidates(ctx, kind, options.where));
@@ -9781,9 +9918,9 @@ async function executeHybridSearch(ctx, nodeKind, options) {
       candidatesByKind.set(kind, buildKindCandidates(ctx, kind, options.where));
     }
   }
-  if (backend.hybridSearch !== void 0 && fulltextKinds.length === 1 && vectorKinds.length === 1 && fulltextKinds[0] === vectorKinds[0].kind) {
+  if (backend.hybridSearch !== void 0 && fulltextKinds.length === 1 && vectorKinds.length === 1 && fulltextKinds[0] === requireDefined(vectorKinds[0]).kind) {
     const kind = fulltextKinds[0];
-    const { slot } = vectorKinds[0];
+    const { slot } = requireDefined(vectorKinds[0]);
     const candidates = candidatesByKind.get(kind);
     const hybridFulltextLanguage = effectiveFulltextLanguage(
       ctx,
@@ -9844,7 +9981,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
     vectorKinds.map(
       async ({ kind, slot }) => {
         const candidates = candidatesByKind.get(kind);
-        const rows = await backend.vectorSearch({
+        const rows = await requireDefined(backend.vectorSearch)({
           graphId,
           nodeKind: kind,
           fieldPath: options.vector.fieldPath,
@@ -9874,7 +10011,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
         kind,
         options.fulltext.language
       );
-      const rows = await backend.fulltextSearch({
+      const rows = await requireDefined(backend.fulltextSearch)({
         graphId,
         nodeKind: kind,
         query: options.fulltext.query,
@@ -10314,7 +10451,7 @@ function classifyProperties(kind, existing, next, recorders) {
   }
   for (const name of nextNames) {
     if (!existingNames.has(name)) {
-      const property = next[name];
+      const property = requireDefined(next[name]);
       if (property.optional === true) continue;
       recorders.recordRequireEmpty({
         kind,
@@ -10325,7 +10462,13 @@ function classifyProperties(kind, existing, next, recorders) {
   }
   for (const name of existingNames) {
     if (!nextNames.has(name)) continue;
-    classifyProperty(kind, name, existing[name], next[name], recorders);
+    classifyProperty(
+      kind,
+      name,
+      requireDefined(existing[name]),
+      requireDefined(next[name]),
+      recorders
+    );
   }
 }
 function classifyProperty(kind, field2, existing, next, recorders) {
@@ -10816,6 +10959,33 @@ function assertEdgeKinds(edges) {
     );
   }
 }
+function compileNodeKindSeedFilter(nodeKinds) {
+  if (nodeKinds === void 0) return sql`TRUE`;
+  return compileKindFilter(sql.raw("n.kind"), nodeKinds);
+}
+function normalizeNodeKinds(nodeKinds) {
+  if (nodeKinds === void 0) return void 0;
+  return [...new Set(nodeKinds)].toSorted(
+    (left, right) => compareCodePoints(left, right)
+  );
+}
+function assertGraphAnalyticsSupported(ctx, algorithm, options = {}) {
+  const graphAnalytics = ctx.backend.capabilities.graphAnalytics?.supported === true;
+  const windowFunctions = ctx.backend.capabilities.windowFunctions;
+  if (graphAnalytics && (options.requiresWindowFunctions !== true || windowFunctions)) {
+    return;
+  }
+  throw new UnsupportedBackendCapabilityError(
+    algorithm,
+    "graphAnalytics",
+    {
+      dialect: ctx.backend.dialect,
+      supported: graphAnalytics,
+      ...options.requiresWindowFunctions === true ? { windowFunctions } : {}
+    },
+    "Use a built-in transactional SQLite/PostgreSQL backend, or declare graphAnalytics support on a compatible custom backend."
+  );
+}
 
 // src/store/algorithms/degree.ts
 async function executeDegree(ctx, nodeId, options = {}) {
@@ -10857,11 +11027,23 @@ function compileDirectionFilter(ctx, direction, nodeId, nodesTable) {
     }
   }
 }
+
+// src/store/algorithms/iterative-graph-operation.ts
 function frontierIndexIdentifier(context) {
   return sql.identifier(
     `typegraph_iterative_${context.runId.replaceAll("-", "_")}_frontier`
   );
 }
+async function countWorkingTableRows(context) {
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT COUNT(*) AS count
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+    `)
+  );
+  return Number(rows[0]?.count ?? 0);
+}
 var DEFAULT_MAX_BIND_PARAMETERS = 999;
 var RESERVED_TEMPORAL_BIND_PARAMETERS_PER_BRANCH = 12;
 var RESERVED_WEIGHT_BIND_PARAMETERS_PER_BRANCH = 4;
@@ -10912,71 +11094,69 @@ async function runIterativeGraphOperation(ctx, options, plan) {
       { dialect: ctx.backend.dialect }
     );
   }
-  return ctx.backend.transaction(
-    async (backend) => {
-      const temporaryBackend = requireTemporaryStatements(backend);
-      const runId = generateId();
-      const workingTable = sql.identifier(
-        `typegraph_iterative_${runId.replaceAll("-", "_")}`
+  const transactionOptions = {
+    isolationLevel: "repeatable_read",
+    accessMode: "read_only",
+    temporaryWrites: INTERNAL_TEMPORARY_WRITES
+  };
+  return ctx.backend.transaction(async (backend) => {
+    const temporaryBackend = requireTemporaryStatements(backend);
+    const runId = generateId();
+    const workingTable = sql.identifier(
+      `typegraph_iterative_${runId.replaceAll("-", "_")}`
+    );
+    const context = {
+      operation: createOperation(ctx, options, temporaryBackend),
+      backend: temporaryBackend,
+      workingTable,
+      graphId: ctx.graphId,
+      runId,
+      executeTemporary: async (query) => {
+        await temporaryBackend.executeTemporaryStatement(
+          asCompiledTemporaryStatementSql(query)
+        );
+      }
+    };
+    if (context.operation.workingMemory !== void 0) {
+      const workingMemoryStatement = ctx.dialect.setTransactionWorkingMemory(
+        context.operation.workingMemory
       );
-      const context = {
-        operation: createOperation(ctx, options, temporaryBackend),
-        backend: temporaryBackend,
-        workingTable,
-        graphId: ctx.graphId,
-        runId,
-        executeTemporary: async (query) => {
-          await temporaryBackend.executeTemporaryStatement(
-            asCompiledTemporaryStatementSql(query)
+      if (workingMemoryStatement !== void 0) {
+        await context.executeTemporary(workingMemoryStatement);
+      }
+    }
+    await context.executeTemporary(plan.createWorkingTable(context));
+    let operationFailure;
+    try {
+      let state = await plan.initialize(context);
+      let analyzedRowCount = await refreshWorkingTableStatistics(
+        context,
+        state.workingTableSize
+      );
+      for (let iteration = 1; iteration <= plan.maxIterations && !plan.hasConverged(state); iteration++) {
+        state = await plan.runRound(context, state, iteration);
+        if (iteration < plan.maxIterations && !plan.hasConverged(state)) {
+          analyzedRowCount = await refreshWorkingTableStatistics(
+            context,
+            state.workingTableSize,
+            analyzedRowCount
           );
         }
-      };
-      if (context.operation.workingMemory !== void 0) {
-        const workingMemoryStatement = ctx.dialect.setTransactionWorkingMemory(
-          context.operation.workingMemory
-        );
-        if (workingMemoryStatement !== void 0) {
-          await context.executeTemporary(workingMemoryStatement);
-        }
       }
-      await context.executeTemporary(plan.createWorkingTable(context));
-      let operationError;
-      try {
-        let state = await plan.initialize(context);
-        let analyzedRowCount = await refreshWorkingTableStatistics(
-          context,
-          state.workingTableSize
+      if (!plan.hasConverged(state)) {
+        throw new GraphAlgorithmConvergenceError(
+          plan.algorithm,
+          plan.maxIterations
         );
-        for (let iteration = 1; iteration <= plan.maxIterations && !plan.hasConverged(state); iteration++) {
-          state = await plan.runRound(context, state, iteration);
-          if (iteration < plan.maxIterations && !plan.hasConverged(state)) {
-            analyzedRowCount = await refreshWorkingTableStatistics(
-              context,
-              state.workingTableSize,
-              analyzedRowCount
-            );
-          }
-        }
-        if (!plan.hasConverged(state)) {
-          throw new GraphAlgorithmConvergenceError(
-            plan.algorithm,
-            plan.maxIterations
-          );
-        }
-        return await plan.extractResult(context, state);
-      } catch (error) {
-        operationError = error;
-        throw error;
-      } finally {
-        await dropWorkingTable(context, operationError);
       }
-    },
-    {
-      isolationLevel: "repeatable_read",
-      accessMode: "read_only",
-      temporaryWrites: INTERNAL_TEMPORARY_WRITES
+      return await plan.extractResult(context, state);
+    } catch (error) {
+      operationFailure = { error };
+      throw error;
+    } finally {
+      await cleanupWorkingTables(context, plan.cleanup, operationFailure);
     }
-  );
+  }, transactionOptions);
 }
 function shouldRefreshWorkingTableStatistics(workingTableSize, analyzedRowCount) {
   if (workingTableSize < WORKING_TABLE_ANALYZE_MINIMUM_ROWS) return false;
@@ -10994,14 +11174,27 @@ async function refreshWorkingTableStatistics(context, workingTableSize, analyzed
   await context.executeTemporary(statement);
   return workingTableSize;
 }
-async function dropWorkingTable(context, operationError) {
+async function dropWorkingTable(context, hasPrimaryFailure) {
   try {
     await context.executeTemporary(
       sql`DROP TABLE IF EXISTS ${context.workingTable}`
     );
   } catch (cleanupError) {
-    if (operationError === void 0) throw cleanupError;
+    if (!hasPrimaryFailure) throw cleanupError;
+  }
+}
+async function cleanupWorkingTables(context, cleanup, operationFailure) {
+  let cleanupFailure;
+  try {
+    await cleanup?.(context);
+  } catch (error) {
+    if (operationFailure === void 0) cleanupFailure = { error };
   }
+  await dropWorkingTable(
+    context,
+    operationFailure !== void 0 || cleanupFailure !== void 0
+  );
+  if (cleanupFailure !== void 0) throw cleanupFailure.error;
 }
 async function fetchVisibleWorkingNodes(operation, nodeIds) {
   const nodes = /* @__PURE__ */ new Map();
@@ -11254,100 +11447,833 @@ function requireTemporaryStatements(backend) {
   return backend;
 }
 
-// src/store/algorithms/breadth-first.ts
-async function findReachableNodes(ctx, sourceId, maxHops, options) {
-  if (supportsTemporaryIteration(ctx)) {
-    return findReachableNodesInWorkingTable(ctx, sourceId, maxHops, options);
-  }
-  return findReachableNodesInline(ctx, sourceId, maxHops, options);
-}
-async function findShortestPath(ctx, sourceId, targetId, maxHops, options) {
-  if (supportsTemporaryIteration(ctx)) {
-    return findShortestPathInWorkingTable(
-      ctx,
-      sourceId,
-      targetId,
-      maxHops,
-      options
-    );
-  }
-  return findShortestPathInline(ctx, sourceId, targetId, maxHops, options);
-}
-async function findReachableNodesInWorkingTable(ctx, sourceId, maxHops, options) {
-  return runIterativeGraphOperation(ctx, options, {
-    algorithm: "reachable",
-    maxIterations: maxHops,
+// src/store/algorithms/label-propagation.ts
+var DEFAULT_LABEL_PROPAGATION_MAX_ITERATIONS = 1e3;
+async function executeLabelPropagation(ctx, options) {
+  assertEdgeKinds(options.edges);
+  assertGraphAnalyticsSupported(ctx, "labelPropagation", {
+    requiresWindowFunctions: true
+  });
+  const maxIterations = resolveMaxIterations(
+    options.maxIterations,
+    DEFAULT_LABEL_PROPAGATION_MAX_ITERATIONS,
+    "labelPropagation"
+  );
+  const nodeKinds = normalizeNodeKinds(options.nodeKinds);
+  const policy = {
+    detector: createOscillationDetector(),
+    maxIterations,
+    onMaxIterations: options.onMaxIterations ?? "throw"
+  };
+  const traversalOptions = {
+    edges: options.edges,
+    direction: "both",
+    ...pickTemporalOptions(options),
+    ...options.workingMemory === void 0 ? {} : { workingMemory: options.workingMemory }
+  };
+  return runIterativeGraphOperation(ctx, traversalOptions, {
+    algorithm: "labelPropagation",
+    maxIterations,
     createWorkingTable,
-    async initialize(context) {
-      const seeded = await seedWorkingSide(context, sourceId, "forward");
-      return {
-        depth: 0,
-        frontierCount: seeded.length,
-        workingTableSize: seeded.length
-      };
-    },
-    async runRound(context, state) {
-      const nextDepth = state.depth + 1;
-      const frontierCount = await expandReachableWorkingTableRound(
-        context,
-        "forward",
-        state.depth,
-        nextDepth,
-        context.operation.direction
-      );
-      return {
-        depth: nextDepth,
-        frontierCount,
-        workingTableSize: state.workingTableSize + frontierCount
-      };
-    },
+    initialize: (context) => initializeWorkingTables(context, nodeKinds),
+    runRound: (context, state, iteration) => runLabelPropagationRound(context, state, iteration, policy),
     hasConverged(state) {
-      return state.frontierCount === 0 || state.depth >= maxHops;
+      return state.changedCount === 0 || state.completed;
     },
-    async extractResult(context) {
-      const rows = await readWorkingRows(context, "forward");
-      return rows.map((row) => ({
-        id: row.node_id,
-        kind: row.node_kind,
-        depth: Number(row.depth)
-      })).toSorted(
-        (left, right) => left.depth - right.depth || compareNodeIdentity(left, right)
-      );
-    }
+    extractResult: extractMemberships,
+    cleanup: dropNeighborTable
   });
 }
-async function findShortestPathInWorkingTable(ctx, sourceId, targetId, maxHops, options) {
-  return runIterativeGraphOperation(ctx, options, {
-    algorithm: "shortestPath",
-    maxIterations: maxHops,
-    createWorkingTable,
-    async initialize(context) {
-      const forwardSeeds = await seedWorkingSide(context, sourceId, "forward");
-      const reverseSeeds = await seedWorkingSide(context, targetId, "reverse");
-      return {
-        forwardDepth: 0,
-        reverseDepth: 0,
-        forwardFrontierCount: forwardSeeds.length,
-        reverseFrontierCount: reverseSeeds.length,
-        meeting: findSeedMeeting(forwardSeeds, reverseSeeds),
-        workingTableSize: forwardSeeds.length + reverseSeeds.length
-      };
-    },
-    async runRound(context, state) {
-      const expandForward = state.forwardFrontierCount <= state.reverseFrontierCount;
-      const side = expandForward ? "forward" : "reverse";
-      const currentDepth = expandForward ? state.forwardDepth : state.reverseDepth;
-      const nextDepth = currentDepth + 1;
-      const direction = expandForward ? context.operation.direction : reverseDirection(context.operation.direction);
-      const round = await expandWorkingTableRound(
-        context,
-        side,
-        currentDepth,
-        nextDepth,
-        direction,
-        maxHops
-      );
-      return {
+function createOscillationDetector() {
+  const shadowLabels = /* @__PURE__ */ new Map();
+  let previousRound;
+  return {
+    /** Records one applied round; true when the round inverts the previous. */
+    observeRound(changedRows) {
+      const round = /* @__PURE__ */ new Map();
+      for (const row of changedRows) {
+        const node = nodeIdentityKey({ id: row.node_id, kind: row.node_kind });
+        const after = nodeIdentityKey({
+          id: row.label_id,
+          kind: row.label_kind
+        });
+        const before = shadowLabels.get(node) ?? node;
+        round.set(node, { before, after });
+        shadowLabels.set(node, after);
+      }
+      const priorRound = previousRound;
+      previousRound = round;
+      if (priorRound?.size !== round.size) return false;
+      if (round.size === 0) return false;
+      for (const [node, change] of round) {
+        if (priorRound.get(node)?.before !== change.after) return false;
+      }
+      return true;
+    }
+  };
+}
+function createWorkingTable(context) {
+  return sql`
+    CREATE TEMP TABLE ${context.workingTable} (
+      graph_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      node_kind TEXT NOT NULL,
+      label_id TEXT NOT NULL,
+      label_kind TEXT NOT NULL,
+      next_label_id TEXT NOT NULL,
+      next_label_kind TEXT NOT NULL,
+      changed_round INTEGER NOT NULL,
+      active_round INTEGER NOT NULL,
+      PRIMARY KEY (graph_id, run_id, node_kind, node_id)
+    )
+  `;
+}
+function neighborTableIdentifier(context) {
+  return sql.identifier(
+    `typegraph_iterative_n_${context.runId.replaceAll("-", "_")}`
+  );
+}
+function activeIndexIdentifier(context) {
+  return sql.identifier(
+    `typegraph_iterative_a_${context.runId.replaceAll("-", "_")}`
+  );
+}
+async function initializeWorkingTables(context, nodeKinds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
+  await context.executeTemporary(sql`
+    INSERT INTO ${workingTable}
+      (graph_id, run_id, node_id, node_kind, label_id, label_kind,
+       next_label_id, next_label_kind, changed_round, active_round)
+    SELECT
+      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind, 0, 1
+    FROM ${operation.schema.nodesTable} n
+    WHERE n.graph_id = ${graphId}
+      AND ${nodeKindFilter}
+      AND ${operation.nodeTemporalFilter}
+  `);
+  await context.executeTemporary(sql`
+    CREATE INDEX ${frontierIndexIdentifier(context)}
+    ON ${workingTable} (graph_id, run_id, changed_round)
+  `);
+  await context.executeTemporary(sql`
+    CREATE INDEX ${activeIndexIdentifier(context)}
+    ON ${workingTable} (graph_id, run_id, active_round)
+  `);
+  const neighborTable = neighborTableIdentifier(context);
+  await context.executeTemporary(sql`
+    CREATE TEMP TABLE ${neighborTable} (
+      target_id TEXT NOT NULL,
+      target_kind TEXT NOT NULL,
+      neighbor_id TEXT NOT NULL,
+      neighbor_kind TEXT NOT NULL,
+      PRIMARY KEY (target_kind, target_id, neighbor_kind, neighbor_id)
+    )
+  `);
+  for (const edgeKinds of operation.edgeKindChunks) {
+    await materializeChunkNeighbors(context, edgeKinds);
+  }
+  const analyzeNeighbors = operation.ctx.dialect.analyzeTemporaryTable(neighborTable);
+  if (analyzeNeighbors !== void 0) {
+    await context.executeTemporary(analyzeNeighbors);
+  }
+  const workingTableSize = await countWorkingTableRows(context);
+  return {
+    changedCount: workingTableSize,
+    workingTableSize,
+    completed: false,
+    finishNextRound: false
+  };
+}
+async function runLabelPropagationRound(context, state, iteration, policy) {
+  if (iteration > 1) {
+    await markActiveNeighbors(context, iteration);
+  }
+  await selectWinningLabels(context, iteration);
+  const changedRows = await applyNextLabels(context, iteration);
+  const next = {
+    changedCount: changedRows.length,
+    workingTableSize: state.workingTableSize,
+    completed: false,
+    finishNextRound: false
+  };
+  if (next.changedCount === 0) return next;
+  if (state.finishNextRound) return { ...next, completed: true };
+  if (policy.detector.observeRound(changedRows)) {
+    return resolveOscillation(next, iteration, policy);
+  }
+  if (policy.onMaxIterations === "return" && iteration === policy.maxIterations) {
+    return { ...next, completed: true };
+  }
+  return next;
+}
+function resolveOscillation(state, iteration, policy) {
+  if (policy.onMaxIterations === "throw") {
+    throw new GraphAlgorithmConvergenceError(
+      "labelPropagation",
+      policy.maxIterations,
+      { oscillating: true }
+    );
+  }
+  const remaining = policy.maxIterations - iteration;
+  if (remaining % 2 === 0) return { ...state, completed: true };
+  return { ...state, finishNextRound: true };
+}
+async function markActiveNeighbors(context, iteration) {
+  const { workingTable, graphId, runId } = context;
+  const neighborTable = neighborTableIdentifier(context);
+  await context.executeTemporary(sql`
+    WITH candidates AS (
+      SELECT DISTINCT neighbors.neighbor_id, neighbors.neighbor_kind
+      FROM ${workingTable} changed
+      JOIN ${neighborTable} neighbors
+        ON neighbors.target_id = changed.node_id
+        AND neighbors.target_kind = changed.node_kind
+      WHERE changed.graph_id = ${graphId}
+        AND changed.run_id = ${runId}
+        AND changed.changed_round = ${iteration - 1}
+    )
+    UPDATE ${workingTable} AS target
+    SET active_round = ${iteration}
+    FROM candidates
+    WHERE target.graph_id = ${graphId}
+      AND target.run_id = ${runId}
+      AND target.node_id = candidates.neighbor_id
+      AND target.node_kind = candidates.neighbor_kind
+  `);
+}
+async function materializeChunkNeighbors(context, edgeKinds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const expansion = compileWorkingTableEdgeExpansion(
+    operation,
+    workingTable,
+    sql`
+      w.graph_id = ${graphId}
+      AND w.run_id = ${runId}
+    `,
+    "both",
+    edgeKinds
+  );
+  const neighborTable = neighborTableIdentifier(context);
+  await context.executeTemporary(sql`
+    INSERT INTO ${neighborTable}
+      (target_id, target_kind, neighbor_id, neighbor_kind)
+    SELECT DISTINCT
+      expanded.source_id,
+      expanded.source_kind,
+      expanded.target_id,
+      expanded.target_kind
+    FROM (${expansion}) expanded
+    JOIN ${workingTable} scoped_neighbor
+      ON scoped_neighbor.graph_id = ${graphId}
+      AND scoped_neighbor.run_id = ${runId}
+      AND scoped_neighbor.node_id = expanded.target_id
+      AND scoped_neighbor.node_kind = expanded.target_kind
+    WHERE expanded.source_id <> expanded.target_id
+      OR expanded.source_kind <> expanded.target_kind
+    ON CONFLICT (target_kind, target_id, neighbor_kind, neighbor_id)
+    DO NOTHING
+  `);
+}
+async function selectWinningLabels(context, iteration) {
+  const { operation, workingTable, graphId, runId } = context;
+  const neighborTable = neighborTableIdentifier(context);
+  const targetId = operation.ctx.dialect.binaryText(sql`totals.target_id`);
+  const targetKind = operation.ctx.dialect.binaryText(sql`totals.target_kind`);
+  const labelId = operation.ctx.dialect.binaryText(sql`totals.label_id`);
+  const labelKind = operation.ctx.dialect.binaryText(sql`totals.label_kind`);
+  await context.executeTemporary(sql`
+    WITH totals AS (
+      SELECT
+        neighbors.target_id,
+        neighbors.target_kind,
+        neighbor.label_id,
+        neighbor.label_kind,
+        COUNT(*) AS total_votes
+      FROM ${neighborTable} neighbors
+      JOIN ${workingTable} active
+        ON active.graph_id = ${graphId}
+        AND active.run_id = ${runId}
+        AND active.active_round = ${iteration}
+        AND active.node_id = neighbors.target_id
+        AND active.node_kind = neighbors.target_kind
+      JOIN ${workingTable} neighbor
+        ON neighbor.graph_id = ${graphId}
+        AND neighbor.run_id = ${runId}
+        AND neighbor.node_id = neighbors.neighbor_id
+        AND neighbor.node_kind = neighbors.neighbor_kind
+      GROUP BY
+        target_id,
+        target_kind,
+        neighbor.label_id,
+        neighbor.label_kind
+    ), ranked AS (
+      SELECT
+        target_id,
+        target_kind,
+        label_id,
+        label_kind,
+        ROW_NUMBER() OVER (
+          PARTITION BY ${targetKind}, ${targetId}
+          ORDER BY total_votes DESC, ${labelId}, ${labelKind}
+        ) AS label_rank
+      FROM totals
+    )
+    UPDATE ${workingTable} AS target
+    SET next_label_id = ranked.label_id,
+        next_label_kind = ranked.label_kind
+    FROM ranked
+    WHERE target.graph_id = ${graphId}
+      AND target.run_id = ${runId}
+      AND target.active_round = ${iteration}
+      AND target.node_id = ranked.target_id
+      AND target.node_kind = ranked.target_kind
+      AND ranked.label_rank = 1
+      AND (
+        target.next_label_id <> ranked.label_id
+        OR target.next_label_kind <> ranked.label_kind
+      )
+  `);
+}
+function applyNextLabels(context, iteration) {
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      UPDATE ${context.workingTable}
+      SET label_id = next_label_id,
+          label_kind = next_label_kind,
+          changed_round = ${iteration}
+      WHERE graph_id = ${context.graphId}
+        AND run_id = ${context.runId}
+        AND active_round = ${iteration}
+        AND (
+          label_id <> next_label_id OR label_kind <> next_label_kind
+        )
+      RETURNING node_id, node_kind, label_id, label_kind
+    `)
+  );
+}
+async function extractMemberships(context) {
+  const { operation } = context;
+  const labelId = operation.ctx.dialect.binaryText(sql`label_id`);
+  const labelKind = operation.ctx.dialect.binaryText(sql`label_kind`);
+  const nodeId = operation.ctx.dialect.binaryText(sql`node_id`);
+  const nodeKind = operation.ctx.dialect.binaryText(sql`node_kind`);
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT
+        node_id,
+        node_kind,
+        label_id,
+        label_kind
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+      ORDER BY ${labelId}, ${labelKind}, ${nodeId}, ${nodeKind}
+    `)
+  );
+  return rows.map((row) => ({
+    id: row.node_id,
+    kind: row.node_kind,
+    labelId: row.label_id,
+    labelKind: row.label_kind
+  }));
+}
+async function dropNeighborTable(context) {
+  await context.executeTemporary(
+    sql`DROP TABLE IF EXISTS ${neighborTableIdentifier(context)}`
+  );
+}
+
+// src/store/algorithms/page-rank.ts
+var DEFAULT_DAMPING_FACTOR = 0.85;
+var DEFAULT_TOLERANCE = 1e-8;
+var DEFAULT_MAX_ITERATIONS = 1e3;
+var BIND_PARAMETERS_PER_SEED = 3;
+var RESERVED_SEED_STATEMENT_BIND_PARAMETERS = 2;
+async function executePageRank(ctx, options) {
+  return executePageRankOperation(ctx, options, void 0);
+}
+async function executePersonalizedPageRank(ctx, options) {
+  return executePageRankOperation(ctx, options, normalizeSeeds(options.seeds));
+}
+function executePageRankOperation(ctx, options, seeds) {
+  const algorithm = seeds === void 0 ? "pageRank" : "personalizedPageRank";
+  assertEdgeKinds(options.edges);
+  assertGraphAnalyticsSupported(ctx, algorithm);
+  const resolved = resolvePageRankOptions(options, algorithm);
+  const traversalOptions = {
+    edges: options.edges,
+    direction: options.direction ?? "out",
+    ...pickTemporalOptions(options),
+    ...options.workingMemory === void 0 ? {} : { workingMemory: options.workingMemory }
+  };
+  return runIterativeGraphOperation(ctx, traversalOptions, {
+    algorithm,
+    maxIterations: resolved.maxIterations,
+    createWorkingTable: createWorkingTable2,
+    initialize: (context) => initializeWorkingTable(context, resolved.nodeKinds, seeds),
+    runRound: (context, state) => runPowerIterationRound(context, state, resolved.dampingFactor),
+    hasConverged(state) {
+      return state.maximumChange <= resolved.tolerance;
+    },
+    extractResult: extractScores
+  });
+}
+function resolvePageRankOptions(options, algorithm) {
+  const dampingFactor = options.dampingFactor ?? DEFAULT_DAMPING_FACTOR;
+  if (!Number.isFinite(dampingFactor) || dampingFactor < 0 || dampingFactor >= 1) {
+    throw new ConfigurationError(
+      `PageRank dampingFactor must be finite and in [0, 1), got ${String(dampingFactor)}.`,
+      { dampingFactor }
+    );
+  }
+  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+  if (!Number.isFinite(tolerance) || tolerance <= 0) {
+    throw new ConfigurationError(
+      `PageRank tolerance must be finite and greater than 0, got ${String(tolerance)}.`,
+      { tolerance }
+    );
+  }
+  return {
+    dampingFactor,
+    tolerance,
+    maxIterations: resolveMaxIterations(
+      options.maxIterations,
+      DEFAULT_MAX_ITERATIONS,
+      algorithm
+    ),
+    nodeKinds: normalizeNodeKinds(options.nodeKinds)
+  };
+}
+function normalizeSeeds(seeds) {
+  if (seeds.length === 0) {
+    throw new ConfigurationError(
+      "Personalized PageRank requires at least one seed.",
+      { seeds }
+    );
+  }
+  const combined = /* @__PURE__ */ new Map();
+  for (const seed of seeds) {
+    if (typeof seed.id !== "string" || seed.id.length === 0 || seed.id.includes("\0") || typeof seed.kind !== "string" || seed.kind.length === 0 || seed.kind.includes("\0")) {
+      throw new ConfigurationError(
+        "Personalized PageRank seed id and kind must be non-empty strings without NUL characters.",
+        { seed }
+      );
+    }
+    const weight = seed.weight ?? 1;
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new ConfigurationError(
+        `Personalized PageRank seed weight must be finite and greater than 0, got ${String(weight)}.`,
+        { seed }
+      );
+    }
+    const key = nodeIdentityKey(seed);
+    const previous = combined.get(key);
+    const combinedWeight = (previous?.weight ?? 0) + weight;
+    if (!Number.isFinite(combinedWeight)) {
+      throw new ConfigurationError(
+        "Personalized PageRank seed weights overflowed while combining duplicate seeds.",
+        { seed }
+      );
+    }
+    combined.set(key, { id: seed.id, kind: seed.kind, weight: combinedWeight });
+  }
+  const combinedSeeds = [...combined.values()];
+  let maximumWeight = 0;
+  for (const seed of combinedSeeds) {
+    maximumWeight = Math.max(maximumWeight, seed.weight);
+  }
+  const scaledTotal = combinedSeeds.reduce(
+    (total, seed) => total + seed.weight / maximumWeight,
+    0
+  );
+  return combinedSeeds.map((seed) => {
+    const weight = seed.weight / maximumWeight / scaledTotal;
+    if (weight === 0) {
+      throw new ConfigurationError(
+        "Personalized PageRank seed weights differ too much to normalize without underflow.",
+        { seed }
+      );
+    }
+    return { id: seed.id, kind: seed.kind, weight };
+  }).toSorted((left, right) => compareNodeIdentity(left, right));
+}
+function createWorkingTable2(context) {
+  return sql`
+    CREATE TEMP TABLE ${context.workingTable} (
+      graph_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      node_kind TEXT NOT NULL,
+      score DOUBLE PRECISION NOT NULL,
+      next_score DOUBLE PRECISION NOT NULL,
+      personalization DOUBLE PRECISION NOT NULL,
+      out_weight DOUBLE PRECISION NOT NULL,
+      PRIMARY KEY (graph_id, run_id, node_kind, node_id)
+    )
+  `;
+}
+async function initializeWorkingTable(context, nodeKinds, seeds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
+  await context.executeTemporary(sql`
+    INSERT INTO ${workingTable}
+      (graph_id, run_id, node_id, node_kind, score, next_score,
+       personalization, out_weight)
+    SELECT ${graphId}, ${runId}, n.id, n.kind, 0.0, 0.0, 0.0, 0.0
+    FROM ${operation.schema.nodesTable} n
+    WHERE n.graph_id = ${graphId}
+      AND ${nodeKindFilter}
+      AND ${operation.nodeTemporalFilter}
+  `);
+  const workingTableSize = await countWorkingTableRows(context);
+  if (workingTableSize === 0) {
+    if (seeds !== void 0) {
+      throw missingSeedError(seeds);
+    }
+    return {
+      activeScoreColumn: "score",
+      maximumChange: 0,
+      workingTableSize
+    };
+  }
+  if (seeds === void 0) {
+    const uniformWeight = 1 / workingTableSize;
+    await context.executeTemporary(sql`
+      UPDATE ${workingTable}
+      SET score = ${uniformWeight},
+          personalization = ${uniformWeight}
+      WHERE graph_id = ${graphId} AND run_id = ${runId}
+    `);
+  } else {
+    await initializePersonalization(context, seeds);
+  }
+  for (const edgeKinds of operation.edgeKindChunks) {
+    await accumulateOutWeights(context, edgeKinds);
+  }
+  return {
+    activeScoreColumn: "score",
+    maximumChange: Number.POSITIVE_INFINITY,
+    workingTableSize
+  };
+}
+async function initializePersonalization(context, seeds) {
+  const parameterLimit = context.operation.backend.capabilities.maxBindParameters ?? DEFAULT_MAX_BIND_PARAMETERS;
+  const seedChunkSize = Math.floor(
+    (parameterLimit - RESERVED_SEED_STATEMENT_BIND_PARAMETERS) / BIND_PARAMETERS_PER_SEED
+  );
+  if (seedChunkSize < 1) {
+    throw new ConfigurationError(
+      "Personalized PageRank cannot fit one seed within the backend bind-parameter limit.",
+      { parameterLimit }
+    );
+  }
+  for (let offset = 0; offset < seeds.length; offset += seedChunkSize) {
+    const chunk2 = seeds.slice(offset, offset + seedChunkSize);
+    const values = sql.join(
+      chunk2.map(
+        (seed) => sql`(${seed.id}, ${seed.kind}, CAST(${seed.weight} AS DOUBLE PRECISION))`
+      ),
+      sql`, `
+    );
+    await context.executeTemporary(sql`
+      WITH seed_values(node_id, node_kind, weight) AS (VALUES ${values})
+      UPDATE ${context.workingTable} AS target
+      SET score = seed_values.weight,
+          personalization = seed_values.weight
+      FROM seed_values
+      WHERE target.graph_id = ${context.graphId}
+        AND target.run_id = ${context.runId}
+        AND target.node_id = seed_values.node_id
+        AND target.node_kind = seed_values.node_kind
+    `);
+  }
+  const matchedRows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT node_id, node_kind
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId}
+        AND run_id = ${context.runId}
+        AND personalization > 0
+    `)
+  );
+  const matched = new Set(
+    matchedRows.map(
+      (row) => nodeIdentityKey({ id: row.node_id, kind: row.node_kind })
+    )
+  );
+  const missing = seeds.filter((seed) => !matched.has(nodeIdentityKey(seed)));
+  if (missing.length > 0) throw missingSeedError(missing);
+}
+function missingSeedError(seeds) {
+  return new ConfigurationError(
+    "Personalized PageRank seeds must identify visible nodes inside the selected induced subgraph.",
+    { missingSeeds: seeds.map((seed) => ({ id: seed.id, kind: seed.kind })) }
+  );
+}
+async function accumulateOutWeights(context, edgeKinds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const expansion = compileWorkingTableEdgeExpansion(
+    operation,
+    workingTable,
+    sql`w.graph_id = ${graphId} AND w.run_id = ${runId}`,
+    operation.direction,
+    edgeKinds
+  );
+  const transitionWeight = compileTransitionWeight(operation.direction);
+  await context.executeTemporary(sql`
+    WITH scoped_edges AS (
+      SELECT
+        expanded.source_id,
+        expanded.source_kind,
+        ${transitionWeight} AS transition_weight
+      FROM (${expansion}) expanded
+      JOIN ${workingTable} scoped_target
+        ON scoped_target.graph_id = ${graphId}
+        AND scoped_target.run_id = ${runId}
+        AND scoped_target.node_id = expanded.target_id
+        AND scoped_target.node_kind = expanded.target_kind
+    ), degrees AS (
+      SELECT source_id, source_kind, SUM(transition_weight) AS out_weight
+      FROM scoped_edges
+      GROUP BY source_id, source_kind
+    )
+    UPDATE ${workingTable} AS target
+    SET out_weight = target.out_weight + degrees.out_weight
+    FROM degrees
+    WHERE target.graph_id = ${graphId}
+      AND target.run_id = ${runId}
+      AND target.node_id = degrees.source_id
+      AND target.node_kind = degrees.source_kind
+  `);
+}
+function compileTransitionWeight(direction) {
+  if (direction !== "both") return sql`1.0`;
+  return sql`
+    CASE
+      WHEN expanded.source_id = expanded.target_id
+       AND expanded.source_kind = expanded.target_kind
+      THEN 0.5
+      ELSE 1.0
+    END
+  `;
+}
+async function runPowerIterationRound(context, state, dampingFactor) {
+  const sourceScoreColumn = state.activeScoreColumn;
+  const targetScoreColumn = sourceScoreColumn === "score" ? "next_score" : "score";
+  await resetTargetScores(
+    context,
+    sourceScoreColumn,
+    targetScoreColumn,
+    dampingFactor
+  );
+  for (const edgeKinds of context.operation.edgeKindChunks) {
+    await accumulateContributions(
+      context,
+      edgeKinds,
+      dampingFactor,
+      sourceScoreColumn,
+      targetScoreColumn
+    );
+  }
+  const maximumChange = await readMaximumChange(
+    context,
+    sourceScoreColumn,
+    targetScoreColumn
+  );
+  return {
+    activeScoreColumn: targetScoreColumn,
+    maximumChange,
+    workingTableSize: state.workingTableSize
+  };
+}
+async function resetTargetScores(context, sourceScoreColumn, targetScoreColumn, dampingFactor) {
+  const sourceScore = sql.identifier(sourceScoreColumn);
+  const targetScore = sql.identifier(targetScoreColumn);
+  await context.executeTemporary(sql`
+    UPDATE ${context.workingTable}
+    SET ${targetScore} = personalization * (
+      ${1 - dampingFactor} + ${dampingFactor} * (
+        SELECT COALESCE(SUM(dangling.${sourceScore}), 0.0)
+        FROM ${context.workingTable} dangling
+        WHERE dangling.graph_id = ${context.graphId}
+          AND dangling.run_id = ${context.runId}
+          AND dangling.out_weight = 0.0
+      )
+    )
+    WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+  `);
+}
+async function accumulateContributions(context, edgeKinds, dampingFactor, sourceScoreColumn, targetScoreColumn) {
+  const { operation, workingTable, graphId, runId } = context;
+  const sourceScore = sql.identifier(sourceScoreColumn);
+  const targetScore = sql.identifier(targetScoreColumn);
+  const expansion = compileWorkingTableEdgeExpansion(
+    operation,
+    workingTable,
+    sql`w.graph_id = ${graphId} AND w.run_id = ${runId}`,
+    operation.direction,
+    edgeKinds,
+    sql`w.${sourceScore} AS source_score, w.out_weight AS source_out_weight`
+  );
+  const transitionWeight = compileTransitionWeight(operation.direction);
+  await context.executeTemporary(sql`
+    WITH scoped_edges AS (
+      SELECT
+        expanded.target_id,
+        expanded.target_kind,
+        expanded.source_score,
+        expanded.source_out_weight,
+        ${transitionWeight} AS transition_weight
+      FROM (${expansion}) expanded
+      JOIN ${workingTable} scoped_target
+        ON scoped_target.graph_id = ${graphId}
+        AND scoped_target.run_id = ${runId}
+        AND scoped_target.node_id = expanded.target_id
+        AND scoped_target.node_kind = expanded.target_kind
+      WHERE expanded.source_out_weight > 0.0
+    ), contributions AS (
+      SELECT
+        target_id,
+        target_kind,
+        SUM(source_score * transition_weight / source_out_weight) AS score
+      FROM scoped_edges
+      GROUP BY target_id, target_kind
+    )
+    UPDATE ${workingTable} AS target
+    SET ${targetScore} = target.${targetScore} + ${dampingFactor} * contributions.score
+    FROM contributions
+    WHERE target.graph_id = ${graphId}
+      AND target.run_id = ${runId}
+      AND target.node_id = contributions.target_id
+      AND target.node_kind = contributions.target_kind
+  `);
+}
+async function readMaximumChange(context, sourceScoreColumn, targetScoreColumn) {
+  const sourceScore = sql.identifier(sourceScoreColumn);
+  const targetScore = sql.identifier(targetScoreColumn);
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT COALESCE(MAX(ABS(${targetScore} - ${sourceScore})), 0.0) AS value
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+    `)
+  );
+  return Number(rows[0]?.value ?? 0);
+}
+async function extractScores(context, state) {
+  const score = sql.identifier(state.activeScoreColumn);
+  const nodeId = context.operation.ctx.dialect.binaryText(sql`node_id`);
+  const nodeKind = context.operation.ctx.dialect.binaryText(sql`node_kind`);
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT node_id, node_kind, ${score} AS score
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+      ORDER BY ${score} DESC, ${nodeId}, ${nodeKind}
+    `)
+  );
+  return rows.map((row) => ({
+    id: row.node_id,
+    kind: row.node_kind,
+    score: Number(row.score)
+  }));
+}
+
+// src/store/algorithms/breadth-first.ts
+async function findReachableNodes(ctx, sourceId, maxHops, options) {
+  if (supportsTemporaryIteration(ctx)) {
+    return findReachableNodesInWorkingTable(ctx, sourceId, maxHops, options);
+  }
+  return findReachableNodesInline(ctx, sourceId, maxHops, options);
+}
+async function findShortestPath(ctx, sourceId, targetId, maxHops, options) {
+  if (supportsTemporaryIteration(ctx)) {
+    return findShortestPathInWorkingTable(
+      ctx,
+      sourceId,
+      targetId,
+      maxHops,
+      options
+    );
+  }
+  return findShortestPathInline(ctx, sourceId, targetId, maxHops, options);
+}
+async function findReachableNodesInWorkingTable(ctx, sourceId, maxHops, options) {
+  return runIterativeGraphOperation(ctx, options, {
+    algorithm: "reachable",
+    maxIterations: maxHops,
+    createWorkingTable: createWorkingTable3,
+    async initialize(context) {
+      const seeded = await seedWorkingSide(context, sourceId, "forward");
+      return {
+        depth: 0,
+        frontierCount: seeded.length,
+        workingTableSize: seeded.length
+      };
+    },
+    async runRound(context, state) {
+      const nextDepth = state.depth + 1;
+      const frontierCount = await expandReachableWorkingTableRound(
+        context,
+        "forward",
+        state.depth,
+        nextDepth,
+        context.operation.direction
+      );
+      return {
+        depth: nextDepth,
+        frontierCount,
+        workingTableSize: state.workingTableSize + frontierCount
+      };
+    },
+    hasConverged(state) {
+      return state.frontierCount === 0 || state.depth >= maxHops;
+    },
+    async extractResult(context) {
+      const rows = await readWorkingRows(context, "forward");
+      return rows.map((row) => ({
+        id: row.node_id,
+        kind: row.node_kind,
+        depth: Number(row.depth)
+      })).toSorted(
+        (left, right) => left.depth - right.depth || compareNodeIdentity(left, right)
+      );
+    }
+  });
+}
+async function findShortestPathInWorkingTable(ctx, sourceId, targetId, maxHops, options) {
+  return runIterativeGraphOperation(ctx, options, {
+    algorithm: "shortestPath",
+    maxIterations: maxHops,
+    createWorkingTable: createWorkingTable3,
+    async initialize(context) {
+      const forwardSeeds = await seedWorkingSide(context, sourceId, "forward");
+      const reverseSeeds = await seedWorkingSide(context, targetId, "reverse");
+      return {
+        forwardDepth: 0,
+        reverseDepth: 0,
+        forwardFrontierCount: forwardSeeds.length,
+        reverseFrontierCount: reverseSeeds.length,
+        meeting: findSeedMeeting(forwardSeeds, reverseSeeds),
+        workingTableSize: forwardSeeds.length + reverseSeeds.length
+      };
+    },
+    async runRound(context, state) {
+      const expandForward = state.forwardFrontierCount <= state.reverseFrontierCount;
+      const side = expandForward ? "forward" : "reverse";
+      const currentDepth = expandForward ? state.forwardDepth : state.reverseDepth;
+      const nextDepth = currentDepth + 1;
+      const direction = expandForward ? context.operation.direction : reverseDirection(context.operation.direction);
+      const round = await expandWorkingTableRound(
+        context,
+        side,
+        currentDepth,
+        nextDepth,
+        direction,
+        maxHops
+      );
+      return {
         forwardDepth: expandForward ? nextDepth : state.forwardDepth,
         reverseDepth: expandForward ? state.reverseDepth : nextDepth,
         forwardFrontierCount: expandForward ? round.insertedCount : state.forwardFrontierCount,
@@ -11370,7 +12296,7 @@ async function findShortestPathInWorkingTable(ctx, sourceId, targetId, maxHops,
     }
   });
 }
-function createWorkingTable(context) {
+function createWorkingTable3(context) {
   return sql`
     CREATE TEMP TABLE ${context.workingTable} (
         graph_id TEXT NOT NULL,
@@ -11612,7 +12538,8 @@ async function findShortestPathInline(ctx, sourceId, targetId, maxHops, options)
     const sources = visibleNodes.filter((node) => node.id === sourceId);
     const targets = visibleNodes.filter((node) => node.id === targetId);
     if (sources.length === 0 || targets.length === 0) return;
-    if (sourceId === targetId) return { nodes: [sources[0]], depth: 0 };
+    if (sourceId === targetId)
+      return { nodes: [requireDefined(sources[0])], depth: 0 };
     const forwardVisited = createVisitedMap(sources);
     const reverseVisited = createVisitedMap(targets);
     let forwardWorkingSet = sources;
@@ -11813,18 +12740,20 @@ async function executeShortestPath(ctx, sourceId, targetId, options) {
   );
   return findShortestPath(ctx, sourceId, targetId, maxHops, options);
 }
+
+// src/store/algorithms/weakly-connected-components.ts
 var DEFAULT_WCC_MAX_ITERATIONS = 1e3;
 async function executeWeaklyConnectedComponents(ctx, options) {
   assertEdgeKinds(options.edges);
-  assertWeaklyConnectedComponentsSupported(ctx);
+  assertGraphAnalyticsSupported(ctx, "weaklyConnectedComponents", {
+    requiresWindowFunctions: true
+  });
   const maxIterations = resolveMaxIterations(
     options.maxIterations,
     DEFAULT_WCC_MAX_ITERATIONS,
     "weaklyConnectedComponents"
   );
-  const nodeKinds = options.nodeKinds === void 0 ? void 0 : [...new Set(options.nodeKinds)].toSorted(
-    (left, right) => compareCodePoints(left, right)
-  );
+  const nodeKinds = normalizeNodeKinds(options.nodeKinds);
   const traversalOptions = {
     edges: options.edges,
     direction: "both",
@@ -11834,31 +12763,16 @@ async function executeWeaklyConnectedComponents(ctx, options) {
   return runIterativeGraphOperation(ctx, traversalOptions, {
     algorithm: "weaklyConnectedComponents",
     maxIterations,
-    createWorkingTable: createWorkingTable2,
-    initialize: (context) => initializeWorkingTable(context, nodeKinds),
-    runRound: runLabelPropagationRound,
+    createWorkingTable: createWorkingTable4,
+    initialize: (context) => initializeWorkingTable2(context, nodeKinds),
+    runRound: runLabelPropagationRound2,
     hasConverged(state) {
       return state.changedCount === 0;
     },
-    extractResult: extractMemberships
+    extractResult: extractMemberships2
   });
 }
-function assertWeaklyConnectedComponentsSupported(ctx) {
-  if (ctx.backend.capabilities.graphAnalytics?.supported === true && ctx.backend.capabilities.windowFunctions) {
-    return;
-  }
-  throw new UnsupportedBackendCapabilityError(
-    "weaklyConnectedComponents",
-    "graphAnalytics",
-    {
-      dialect: ctx.backend.dialect,
-      supported: ctx.backend.capabilities.graphAnalytics?.supported === true,
-      windowFunctions: ctx.backend.capabilities.windowFunctions
-    },
-    "Use a built-in transactional SQLite/PostgreSQL backend, or declare graphAnalytics support on a compatible custom backend."
-  );
-}
-function createWorkingTable2(context) {
+function createWorkingTable4(context) {
   return sql`
     CREATE TEMP TABLE ${context.workingTable} (
       graph_id TEXT NOT NULL,
@@ -11874,9 +12788,9 @@ function createWorkingTable2(context) {
     )
   `;
 }
-async function initializeWorkingTable(context, nodeKinds) {
+async function initializeWorkingTable2(context, nodeKinds) {
   const { operation, workingTable, graphId, runId } = context;
-  const nodeKindFilter = nodeKinds === void 0 ? sql`TRUE` : compileKindFilter(sql.raw("n.kind"), nodeKinds);
+  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
   await context.executeTemporary(sql`
     INSERT INTO ${workingTable}
       (graph_id, run_id, node_id, node_kind, label_id, label_kind,
@@ -11892,21 +12806,14 @@ async function initializeWorkingTable(context, nodeKinds) {
     CREATE INDEX ${frontierIndexIdentifier(context)}
     ON ${workingTable} (graph_id, run_id, improved_round)
   `);
-  const rows = await context.backend.execute(
-    asCompiledRowsSql(sql`
-      SELECT COUNT(*) AS count
-      FROM ${workingTable}
-      WHERE graph_id = ${graphId} AND run_id = ${runId}
-    `)
-  );
-  const workingTableSize = Number(rows[0]?.count ?? 0);
+  const workingTableSize = await countWorkingTableRows(context);
   return { changedCount: workingTableSize, workingTableSize };
 }
-async function runLabelPropagationRound(context, state, iteration) {
+async function runLabelPropagationRound2(context, state, iteration) {
   for (const edgeKinds of context.operation.edgeKindChunks) {
     await propagateChunkLabels(context, edgeKinds, iteration);
   }
-  const changedRows = await applyNextLabels(context, iteration);
+  const changedRows = await applyNextLabels2(context, iteration);
   return {
     changedCount: changedRows.length,
     workingTableSize: state.workingTableSize
@@ -11981,7 +12888,7 @@ async function propagateChunkLabels(context, edgeKinds, iteration) {
       )
   `);
 }
-function applyNextLabels(context, iteration) {
+function applyNextLabels2(context, iteration) {
   return context.backend.execute(
     asCompiledRowsSql(sql`
       UPDATE ${context.workingTable}
@@ -11997,7 +12904,7 @@ function applyNextLabels(context, iteration) {
     `)
   );
 }
-async function extractMemberships(context) {
+async function extractMemberships2(context) {
   const { operation } = context;
   const componentId = operation.ctx.dialect.binaryText(sql`label_id`);
   const componentKind = operation.ctx.dialect.binaryText(sql`label_kind`);
@@ -12026,6 +12933,8 @@ async function extractMemberships(context) {
     size: Number(row.component_size)
   }));
 }
+
+// src/store/algorithms/weighted-shortest-path.ts
 var DEFAULT_WEIGHTED_SHORTEST_PATH_MAX_ITERATIONS = 1e3;
 var WEIGHTED_ALGORITHM_NAME = "weightedShortestPath";
 var MAX_EDGE_WEIGHT = Number.MAX_VALUE / 2 ** 64;
@@ -12145,7 +13054,7 @@ async function findWeightedShortestPathInWorkingTable(ctx, sourceId, targetId, m
   return runIterativeGraphOperation(ctx, options, {
     algorithm: WEIGHTED_ALGORITHM_NAME,
     maxIterations,
-    createWorkingTable: createWorkingTable3,
+    createWorkingTable: createWorkingTable5,
     async initialize(context) {
       await assertValidEdgeWeights(
         context.operation,
@@ -12208,7 +13117,7 @@ async function hasVisibleNode(operation, nodeId) {
   );
   return rows.length > 0;
 }
-function createWorkingTable3(context) {
+function createWorkingTable5(context) {
   return sql`
     CREATE TEMP TABLE ${context.workingTable} (
       graph_id TEXT NOT NULL,
@@ -12562,6 +13471,14 @@ function createGraphAlgorithms(params) {
       assertRecordedAsOfInternalOnly(options, "degree", allowRecordedAsOf);
       return executeDegree(ctx, resolveNodeId(node), options ?? {});
     },
+    labelPropagation(options) {
+      assertRecordedAsOfInternalOnly(
+        options,
+        "labelPropagation",
+        allowRecordedAsOf
+      );
+      return executeLabelPropagation(ctx, options);
+    },
     weaklyConnectedComponents(options) {
       assertRecordedAsOfInternalOnly(
         options,
@@ -12569,6 +13486,18 @@ function createGraphAlgorithms(params) {
         allowRecordedAsOf
       );
       return executeWeaklyConnectedComponents(ctx, options);
+    },
+    pageRank(options) {
+      assertRecordedAsOfInternalOnly(options, "pageRank", allowRecordedAsOf);
+      return executePageRank(ctx, options);
+    },
+    personalizedPageRank(options) {
+      assertRecordedAsOfInternalOnly(
+        options,
+        "personalizedPageRank",
+        allowRecordedAsOf
+      );
+      return executePersonalizedPageRank(ctx, options);
     }
   };
 }
@@ -12795,10 +13724,10 @@ function createEdgeCollection(config) {
             itemIndex++;
             continue;
           }
-          const deletedAt = pendingEntry === void 0 ? original.deleted_at : void 0;
+          const deletedAt = pendingEntry === void 0 ? requireDefined(original).deleted_at : void 0;
           let dirty;
           if (config.upsertDirtyCheck !== void 0) {
-            const currentProps = pendingEntry?.props ?? rowPropsToObject(original.props);
+            const currentProps = pendingEntry?.props ?? rowPropsToObject(requireDefined(original).props);
             try {
               dirty = config.upsertDirtyCheck(
                 original?.kind ?? kind,
@@ -12813,7 +13742,9 @@ function createEdgeCollection(config) {
           const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
           if (coalesce) {
             if (pendingEntry === void 0) {
-              results2[itemIndex] = narrowEdge(rowToEdge2(original));
+              results2[itemIndex] = narrowEdge(
+                rowToEdge2(requireDefined(original))
+              );
             } else {
               deferred.push({
                 index: itemIndex,
@@ -12839,7 +13770,9 @@ function createEdgeCollection(config) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeEdgeCreateBatch2(createInputs, target);
           for (const [index, entry2] of toCreate.entries()) {
-            results2[entry2.index] = narrowEdge(created[index]);
+            results2[entry2.index] = narrowEdge(
+              requireDefined(created[index])
+            );
           }
         }
         for (const entry2 of toUpdate) {
@@ -12849,7 +13782,7 @@ function createEdgeCollection(config) {
           results2[entry2.index] = narrowEdge(result);
         }
         for (const { index, sourceIndex } of deferred) {
-          results2[index] = results2[sourceIndex];
+          results2[index] = requireDefined(results2[sourceIndex]);
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
@@ -13057,7 +13990,7 @@ function createNodeCollection(config) {
           temporal,
           defaultTemporalMode
         );
-        let query = createQuery().from(kind, "_n").temporal(asOf === void 0 ? temporalMode : "asOf", asOf).whereNode("_n", filter.where).select((ctx) => ctx._n);
+        let query = createQuery().from(kind, "_n").temporal(asOf === void 0 ? temporalMode : "asOf", asOf).whereNode("_n", filter.where).select((ctx) => ctx["_n"]);
         if (filter.limit !== void 0) query = query.limit(filter.limit);
         if (filter.offset !== void 0) query = query.offset(filter.offset);
         const results = await query.execute();
@@ -13087,7 +14020,7 @@ function createNodeCollection(config) {
     async upsertByIdFromRecord(id, data, options) {
       const existing = await backend.getNode(graphId, kind, id);
       if (existing) {
-        const runDirtyCheck = config.upsertDirtyCheck && (() => config.upsertDirtyCheck(
+        const runDirtyCheck = config.upsertDirtyCheck && (() => requireDefined(config.upsertDirtyCheck)(
           kind,
           id,
           rowPropsToObject(existing.props),
@@ -13157,10 +14090,10 @@ function createNodeCollection(config) {
             itemIndex++;
             continue;
           }
-          const deletedAt = pendingEntry === void 0 ? original.deleted_at : void 0;
+          const deletedAt = pendingEntry === void 0 ? requireDefined(original).deleted_at : void 0;
           let dirty;
           if (config.upsertDirtyCheck !== void 0) {
-            const currentProps = pendingEntry?.props ?? rowPropsToObject(original.props);
+            const currentProps = pendingEntry?.props ?? rowPropsToObject(requireDefined(original).props);
             try {
               dirty = config.upsertDirtyCheck(
                 kind,
@@ -13175,7 +14108,9 @@ function createNodeCollection(config) {
           const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
           if (coalesce) {
             if (pendingEntry === void 0) {
-              results2[itemIndex] = narrowNode(rowToNode2(original));
+              results2[itemIndex] = narrowNode(
+                rowToNode2(requireDefined(original))
+              );
             } else {
               deferred.push({
                 index: itemIndex,
@@ -13201,7 +14136,9 @@ function createNodeCollection(config) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeNodeCreateBatch2(createInputs, target);
           for (const [index, entry2] of toCreate.entries()) {
-            results2[entry2.index] = narrowNode(created[index]);
+            results2[entry2.index] = narrowNode(
+              requireDefined(created[index])
+            );
           }
         }
         for (const entry2 of toUpdate) {
@@ -13211,7 +14148,7 @@ function createNodeCollection(config) {
           results2[entry2.index] = narrowNode(result);
         }
         for (const { index, sourceIndex } of deferred) {
-          results2[index] = results2[sourceIndex];
+          results2[index] = requireDefined(results2[sourceIndex]);
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
@@ -13363,6 +14300,99 @@ function createEdgeCollectionsProxy(graph, graphId, registry, backend, operation
   });
 }
 
+// src/store/history-store-backend.ts
+var HISTORY_STORE_BACKEND_KEYS = [
+  "assertRuntimeContributionsInitialized",
+  "assertVectorSlotInitialized",
+  "assertVectorSlotsInitialized",
+  "bootstrapTables",
+  "capabilities",
+  "checkUnique",
+  "checkUniqueBatch",
+  "claimIndexMaterialization",
+  "close",
+  "commitSchemaVersion",
+  "compileSql",
+  "countEdgesByKind",
+  "countEdgesFrom",
+  "countNodesByKind",
+  "createVectorIndex",
+  "deleteEdge",
+  "deleteEdgesBatch",
+  "deleteEmbedding",
+  "deleteFulltext",
+  "deleteFulltextBatch",
+  "deleteNode",
+  "deleteUnique",
+  "deleteVectorSlotContribution",
+  "dialect",
+  "dropVectorIndex",
+  "edgeExistsBetween",
+  "ensureContributionMaterializationsTable",
+  "ensureFulltextTable",
+  "ensureIndexMaterializationsTable",
+  "ensureKindRemovalsTable",
+  "ensureReconciliationMarkersTable",
+  "ensureRevisionOriginsTable",
+  "ensureRuntimeContributions",
+  "ensureVectorSlotContribution",
+  "ensureVectorSlotContributions",
+  "execute",
+  "executeTemporaryStatement",
+  "findEdgesByKind",
+  "findEdgesConnectedTo",
+  "findNodesByKind",
+  "fulltextSearch",
+  "fulltextStrategy",
+  "getActiveSchema",
+  "getAllKindRemovals",
+  "getContributionMaterialization",
+  "getEdge",
+  "getEdges",
+  "getIndexMaterialization",
+  "getIndexMaterializations",
+  "getNode",
+  "getNodes",
+  "getPendingKindRemovals",
+  "getReconciliationMarker",
+  "getSchemaVersion",
+  "hardDeleteEdge",
+  "hardDeleteEdgesBatch",
+  "hardDeleteNode",
+  "hybridSearch",
+  "insertEdge",
+  "insertEdgeNoReturn",
+  "insertEdgesBatch",
+  "insertEdgesBatchReturning",
+  "insertNode",
+  "insertNodeNoReturn",
+  "insertNodesBatch",
+  "insertNodesBatchReturning",
+  "insertUnique",
+  "insertUniqueBatch",
+  "recordContributionMaterialization",
+  "recordIndexMaterialization",
+  "recordKindRemoval",
+  "refreshStatistics",
+  "releaseIndexMaterializationClaim",
+  "setActiveVersion",
+  "setReconciliationMarker",
+  "tableNames",
+  "updateEdge",
+  "updateNode",
+  "upsertEmbedding",
+  "upsertEmbeddingBatch",
+  "upsertFulltext",
+  "upsertFulltextBatch",
+  "vectorSearch",
+  "vectorStrategy"
+];
+function createHistoryStoreBackendProjection(backend) {
+  return Object.freeze(
+    projectBackendMembers(backend, HISTORY_STORE_BACKEND_KEYS)
+  );
+}
+
 // src/store/introspect.ts
 function introspectSchema(graph, context) {
   const extension = graph.extension;
@@ -13474,6 +14504,18 @@ async function runMaterialization(items, options, runOne) {
 var CLAIM_LEASE_MS = 15 * 6e4;
 var CLAIM_RETRY_DELAY_MS = 200;
 var CLAIM_WAIT_TIMEOUT_MS = CLAIM_LEASE_MS + 6e4;
+var INDEX_DIALECT_BEHAVIOR = {
+  postgres: {
+    concurrentBuilds: true,
+    hasInvalidIndexState: true,
+    supportsGinFamily: true
+  },
+  sqlite: {
+    concurrentBuilds: false,
+    hasInvalidIndexState: false,
+    supportsGinFamily: false
+  }
+};
 function hasIndexBuildClaimProtocol(backend) {
   return backend.claimIndexMaterialization !== void 0 && backend.releaseIndexMaterializationClaim !== void 0;
 }
@@ -13518,7 +14560,7 @@ async function materializeIndexes(context, options = {}) {
   const tableNames = backend.tableNames;
   const ddlOptions = {
     ifNotExists: true,
-    concurrent: dialect === "postgres",
+    concurrent: INDEX_DIALECT_BEHAVIOR[dialect].concurrentBuilds,
     ...tableNames?.nodes === void 0 ? {} : { nodesTableName: tableNames.nodes },
     ...tableNames?.edges === void 0 ? {} : { edgesTableName: tableNames.edges }
   };
@@ -13599,7 +14641,7 @@ function parallelBucketKey(declaration) {
   return declaration.entity;
 }
 async function materializeRelationalIndex(declaration, backend, dialect, ddlOptions, graphId, schemaVersion, existingByStatusKey, invalidLeftovers) {
-  if (declaration.method !== void 0 && dialect !== "postgres") {
+  if (declaration.method !== void 0 && !INDEX_DIALECT_BEHAVIOR[dialect].supportsGinFamily) {
     return {
       indexName: declaration.name,
       entity: declaration.entity,
@@ -13621,9 +14663,11 @@ async function materializeRelationalIndex(declaration, backend, dialect, ddlOpti
     driftLabel: "Index",
     run: async () => {
       if (declaration.method === "trigram") {
-        await backend.executeDdl("CREATE EXTENSION IF NOT EXISTS pg_trgm;");
+        await requireDefined(backend.executeDdl)(
+          "CREATE EXTENSION IF NOT EXISTS pg_trgm;"
+        );
       }
-      await backend.executeDdl(ddl);
+      await requireDefined(backend.executeDdl)(ddl);
     },
     existingByStatusKey,
     physicalRebuildPreload: invalidLeftovers
@@ -13671,7 +14715,7 @@ async function materializeVectorIndex(declaration, backend, graphId, schemaVersi
       efConstruction: declaration.indexParams.efConstruction,
       ...declaration.indexParams.lists === void 0 ? {} : { lists: declaration.indexParams.lists }
     },
-    concurrent: backend.dialect === "postgres"
+    concurrent: INDEX_DIALECT_BEHAVIOR[backend.dialect].concurrentBuilds
   };
   return materializeOne(declaration, backend, graphId, schemaVersion, {
     // Compound status-table key for vector entries. Pgvector creates
@@ -13682,13 +14726,15 @@ async function materializeVectorIndex(declaration, backend, graphId, schemaVersi
     statusKey: vectorStatusKey(graphId, declaration.name),
     signature,
     driftLabel: "Vector index",
-    run: () => backend.createVectorIndex(params),
+    run: () => requireDefined(backend.createVectorIndex)(params),
     existingByStatusKey,
     physicalRebuildPreload: invalidLeftovers
   });
 }
 async function materializeOne(declaration, backend, graphId, schemaVersion, action) {
-  const recordIndexMaterialization = backend.recordIndexMaterialization;
+  const recordIndexMaterialization = requireDefined(
+    backend.recordIndexMaterialization
+  );
   const { statusKey, signature, driftLabel, run, existingByStatusKey } = action;
   const statusOverride = statusKey === declaration.name ? void 0 : { statusName: statusKey };
   const settled = await settleAgainstExisting(
@@ -13760,7 +14806,7 @@ async function settleAgainstExisting(existing, declaration, backend, graphId, sc
   const error = new Error(
     `${driftLabel} "${declaration.name}" already materialized with a different signature (recorded by graph "${existing.graphId}" at version ${existing.schemaVersion}). Drop the index manually and retry, or rename the new declaration.`
   );
-  await backend.recordIndexMaterialization(
+  await requireDefined(backend.recordIndexMaterialization)(
     buildAttempt({
       declaration,
       graphId,
@@ -13776,11 +14822,13 @@ async function settleAgainstExisting(existing, declaration, backend, graphId, sc
 async function materializeWithClaim(declaration, backend, graphId, schemaVersion, action) {
   const { statusKey, signature, driftLabel, run } = action;
   const statusOverride = statusKey === declaration.name ? void 0 : { statusName: statusKey };
-  const recordIndexMaterialization = backend.recordIndexMaterialization;
+  const recordIndexMaterialization = requireDefined(
+    backend.recordIndexMaterialization
+  );
   const token = `${statusKey}:${nowIso()}:${Math.floor(performance.now() * 1e3)}`;
   const deadline = Date.now() + CLAIM_WAIT_TIMEOUT_MS;
   for (; ; ) {
-    const claimed = await backend.claimIndexMaterialization({
+    const claimed = await requireDefined(backend.claimIndexMaterialization)({
       indexName: statusKey,
       graphId,
       entity: declaration.entity,
@@ -13804,7 +14852,9 @@ async function materializeWithClaim(declaration, backend, graphId, schemaVersion
       continue;
     }
     try {
-      const fresh = await backend.getIndexMaterialization(statusKey);
+      const fresh = await requireDefined(backend.getIndexMaterialization)(
+        statusKey
+      );
       const settled = await settleAgainstExisting(
         fresh,
         declaration,
@@ -13858,7 +14908,7 @@ async function materializeWithClaim(declaration, backend, graphId, schemaVersion
       }
     } finally {
       try {
-        await backend.releaseIndexMaterializationClaim({
+        await requireDefined(backend.releaseIndexMaterializationClaim)({
           indexName: statusKey,
           token
         });
@@ -13872,7 +14922,9 @@ async function materializeWithClaim(declaration, backend, graphId, schemaVersion
   }
 }
 async function hasInvalidIndexLeftover(backend, physicalIndexName) {
-  if (backend.dialect !== "postgres") return false;
+  if (!INDEX_DIALECT_BEHAVIOR[backend.dialect].hasInvalidIndexState) {
+    return false;
+  }
   const rows = await backend.execute(
     asCompiledRowsSql(sql`
       SELECT NOT i.indisvalid AS invalid
@@ -13885,7 +14937,7 @@ async function hasInvalidIndexLeftover(backend, physicalIndexName) {
   return rows[0]?.invalid === true;
 }
 async function preloadInvalidIndexLeftovers(backend, physicalIndexNames) {
-  if (backend.dialect !== "postgres" || physicalIndexNames.length === 0) {
+  if (!INDEX_DIALECT_BEHAVIOR[backend.dialect].hasInvalidIndexState || physicalIndexNames.length === 0) {
     return /* @__PURE__ */ new Set();
   }
   const { invalid } = await preloadPhysicalIndexStates(
@@ -13896,55 +14948,69 @@ async function preloadInvalidIndexLeftovers(backend, physicalIndexNames) {
 }
 async function preloadExistingTables(backend, tableNames) {
   if (tableNames.length === 0) return /* @__PURE__ */ new Set();
-  if (backend.dialect === "postgres") {
-    const rows2 = await backend.execute(
-      asCompiledRowsSql(sql`
-        SELECT c.relname AS name
-        FROM pg_class c
-        WHERE c.relname IN (${sqlValueList(tableNames)})
-          AND c.relkind IN ('r', 'p')
-          AND pg_catalog.pg_table_is_visible(c.oid)
-      `)
-    );
-    return new Set(rows2.map((row) => row.name));
+  switch (backend.dialect) {
+    case "postgres": {
+      const rows = await backend.execute(
+        asCompiledRowsSql(sql`
+          SELECT c.relname AS name
+          FROM pg_class c
+          WHERE c.relname IN (${sqlValueList(tableNames)})
+            AND c.relkind IN ('r', 'p')
+            AND pg_catalog.pg_table_is_visible(c.oid)
+        `)
+      );
+      return new Set(rows.map((row) => row.name));
+    }
+    case "sqlite": {
+      const rows = await backend.execute(
+        asCompiledRowsSql(sql`
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table'
+            AND name IN (${sqlValueList(tableNames)})
+        `)
+      );
+      return new Set(rows.map((row) => row.name));
+    }
+    default: {
+      return backend.dialect;
+    }
   }
-  const rows = await backend.execute(
-    asCompiledRowsSql(sql`
-      SELECT name
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND name IN (${sqlValueList(tableNames)})
-    `)
-  );
-  return new Set(rows.map((row) => row.name));
 }
 async function preloadPhysicalIndexStates(backend, physicalIndexNames) {
   const valid = /* @__PURE__ */ new Set();
   const invalid = /* @__PURE__ */ new Set();
   if (physicalIndexNames.length === 0) return { valid, invalid };
-  if (backend.dialect === "postgres") {
-    const rows2 = await backend.execute(
-      asCompiledRowsSql(sql`
-        SELECT c.relname AS name, i.indisvalid AS valid
-        FROM pg_class c
-        JOIN pg_index i ON i.indexrelid = c.oid
-        WHERE c.relname IN (${sqlValueList(physicalIndexNames)})
-          AND pg_catalog.pg_table_is_visible(c.oid)
-      `)
-    );
-    for (const row of rows2) (row.valid ? valid : invalid).add(row.name);
-    return { valid, invalid };
+  switch (backend.dialect) {
+    case "postgres": {
+      const rows = await backend.execute(
+        asCompiledRowsSql(sql`
+          SELECT c.relname AS name, i.indisvalid AS valid
+          FROM pg_class c
+          JOIN pg_index i ON i.indexrelid = c.oid
+          WHERE c.relname IN (${sqlValueList(physicalIndexNames)})
+            AND pg_catalog.pg_table_is_visible(c.oid)
+        `)
+      );
+      for (const row of rows) (row.valid ? valid : invalid).add(row.name);
+      return { valid, invalid };
+    }
+    case "sqlite": {
+      const rows = await backend.execute(
+        asCompiledRowsSql(sql`
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'index'
+            AND name IN (${sqlValueList(physicalIndexNames)})
+        `)
+      );
+      for (const row of rows) valid.add(row.name);
+      return { valid, invalid };
+    }
+    default: {
+      return backend.dialect;
+    }
   }
-  const rows = await backend.execute(
-    asCompiledRowsSql(sql`
-      SELECT name
-      FROM sqlite_master
-      WHERE type = 'index'
-        AND name IN (${sqlValueList(physicalIndexNames)})
-    `)
-  );
-  for (const row of rows) valid.add(row.name);
-  return { valid, invalid };
 }
 async function dropInvalidIndexLeftover(backend, physicalIndexName) {
   if (backend.executeDdl === void 0) return;
@@ -13984,10 +15050,10 @@ async function preloadMaterializations(backend, statusKeys) {
     for (const row of rows2) map.set(row.indexName, row);
     return map;
   }
-  const getOne = backend.getIndexMaterialization;
+  const getOne = requireDefined(backend.getIndexMaterialization);
   const rows = await Promise.all(statusKeys.map((key) => getOne(key)));
   for (const [index, row] of rows.entries()) {
-    if (row !== void 0) map.set(statusKeys[index], row);
+    if (row !== void 0) map.set(requireDefined(statusKeys[index]), row);
   }
   return map;
 }
@@ -14024,7 +15090,7 @@ async function materializeSystemIndexes(context, options = {}) {
     backend,
     backend.ensureIndexMaterializationsTable
   );
-  const concurrent = backend.dialect === "postgres";
+  const concurrent = INDEX_DIALECT_BEHAVIOR[backend.dialect].concurrentBuilds;
   const candidates = SYSTEM_INDEX_DECLARATIONS.map((declaration) => {
     const physicalTable = resolveSystemIndexTableName(
       declaration.table,
@@ -14091,7 +15157,7 @@ async function materializeSystemIndexes(context, options = {}) {
       statusKey: candidate.name,
       signature,
       driftLabel: "System index",
-      run: () => backend.executeDdl(ddl),
+      run: () => requireDefined(backend.executeDdl)(ddl),
       existingByStatusKey,
       physicalRebuildPreload,
       freshNeedsPhysicalRebuild: async (physicalIndexName) => {
@@ -14128,6 +15194,8 @@ async function computeIndexSignature(dialect, targetTableName, declaration) {
   const json = JSON.stringify(hashable, sortedReplacer);
   return sha256Hex(json, 16);
 }
+
+// src/store/materialize-removals.ts
 var ENTITY_KINDS = ["node", "edge"];
 function buildPendingKindRemoval(args) {
   return { ...args, removedAt: void 0, error: void 0 };
@@ -14185,7 +15253,7 @@ async function reconcilePendingRemovals(context) {
   }
   const marker = backend.getReconciliationMarker === void 0 ? void 0 : await backend.getReconciliationMarker(graphId);
   if (marker !== void 0 && marker >= activeRow.version) return;
-  const allRemovals = await (backend.getAllKindRemovals === void 0 ? backend.getPendingKindRemovals(graphId) : backend.getAllKindRemovals(graphId));
+  const allRemovals = await (backend.getAllKindRemovals === void 0 ? requireDefined(backend.getPendingKindRemovals)(graphId) : backend.getAllKindRemovals(graphId));
   const recorded = new Set(
     allRemovals.map(
       (row) => kindRemovalKey(row.entity, row.kindName, row.schemaVersion)
@@ -14244,7 +15312,7 @@ function kindRemovalKey(entity, kindName, version) {
   return `${entity}|${kindName}|${version}`;
 }
 async function materializeOne2(row, ctx) {
-  const recordKindRemoval = ctx.backend.recordKindRemoval;
+  const recordKindRemoval = requireDefined(ctx.backend.recordKindRemoval);
   try {
     await closeRecordedAndDeleteLiveRows(ctx, row);
     await Promise.all(buildEmbeddingTableCleanup(ctx, row));
@@ -14324,7 +15392,9 @@ async function executeDeleteStatements(target, statements) {
   if (target.executeStatement !== void 0) {
     await Promise.all(
       statements.map(
-        (statement) => target.executeStatement(asCompiledStatementSql(sql.raw(statement)))
+        (statement) => requireDefined(target.executeStatement)(
+          asCompiledStatementSql(sql.raw(statement))
+        )
       )
     );
     return;
@@ -14336,13 +15406,13 @@ async function executeDeleteStatements(target, statements) {
     );
   }
   await Promise.all(
-    statements.map((statement) => target.executeDdl(statement))
+    statements.map((statement) => requireDefined(target.executeDdl)(statement))
   );
 }
 function buildEmbeddingTableCleanup(ctx, row) {
   const vectorStrategy = ctx.backend.vectorStrategy;
   if (vectorStrategy === void 0) return [];
-  const executeDdl = ctx.backend.executeDdl;
+  const executeDdl = requireDefined(ctx.backend.executeDdl);
   const cleanup = (async () => {
     const slots = await resolveRemovedKindEmbeddingSlots(ctx.backend, row);
     await Promise.all(
@@ -14976,7 +16046,7 @@ async function executeEdgeFindByEndpoints(ctx, kind, fromKind, fromId, toKind, t
     ...options?.asOf !== void 0 && { asOf: options.asOf }
   });
   if (candidateRows.length === 0) return void 0;
-  if (matchOn.length === 0) return rowToEdge(candidateRows[0]);
+  if (matchOn.length === 0) return rowToEdge(requireDefined(candidateRows[0]));
   const { liveRow } = findMatchingEdge(candidateRows, matchOn, props);
   return liveRow === void 0 ? void 0 : rowToEdge(liveRow);
 }
@@ -15209,7 +16279,10 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         found[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
       }
       for (const { index, sourceIndex } of probe.duplicateOf) {
-        found[index] = { edge: found[sourceIndex].edge, action: "found" };
+        found[index] = {
+          edge: requireDefined(found[sourceIndex]).edge,
+          action: "found"
+        };
       }
       return found;
     }
@@ -15228,7 +16301,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       );
       for (const [batchIndex, entry2] of toCreate.entries()) {
         results[entry2.index] = {
-          edge: createdEdges[batchIndex],
+          edge: requireDefined(createdEdges[batchIndex]),
           action: "created"
         };
       }
@@ -15270,12 +16343,14 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       }
     }
     for (const { index, sourceIndex } of duplicateOf) {
-      const sourceResult = results[sourceIndex];
+      const sourceResult = requireDefined(results[sourceIndex]);
       results[index] = { edge: sourceResult.edge, action: "found" };
     }
     return results;
   });
 }
+
+// src/store/recorded-read-service.ts
 var RECORDED_POINT_READ_FIXED_BIND_PARAMS = 8;
 function recordedPointReadIdChunk(backend) {
   const budget = recordedBindParamBudget(backend);
@@ -15291,12 +16366,13 @@ function withRelationsPrecondition(backend, promise, surface) {
   );
 }
 function createRecordedReadBackend(backend, surface) {
-  return createBackendOverlay(backend, {
+  const projectedBackend = createGraphBackendProjection(backend);
+  return createBackendOverlay(projectedBackend, {
     execute: (query) => withRelationsPrecondition(backend, backend.execute(query), surface),
     ...backend.executeRaw === void 0 ? {} : {
       executeRaw: (sqlText, params) => withRelationsPrecondition(
         backend,
-        backend.executeRaw(sqlText, params),
+        requireDefined(backend.executeRaw)(sqlText, params),
         surface
       )
     }
@@ -15604,9 +16680,6 @@ function wrapTransactionCollections(nodes, edges, recorder) {
   };
 }
 
-// src/store/types.ts
-var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
-
 // src/store/store.ts
 var UNKNOWN_SCHEMA_METADATA = Object.freeze({
   schemaVersion: void 0,
@@ -15633,8 +16706,12 @@ var CAUGHT_UP_VERB_DETAILS = {
     code: "REEMBED_BEFORE_INITIALIZE"
   }
 };
+var ROW_MAPPER_CONFIGS = {
+  postgres: POSTGRES_ROW_MAPPER_CONFIG,
+  sqlite: SQLITE_ROW_MAPPER_CONFIG
+};
 function rowMapperConfigFor(backend) {
-  return backend.dialect === "postgres" ? POSTGRES_ROW_MAPPER_CONFIG : SQLITE_ROW_MAPPER_CONFIG;
+  return ROW_MAPPER_CONFIGS[backend.dialect];
 }
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
@@ -15649,7 +16726,18 @@ function transactionOutcome(result, recorder, recordedByGraph, graphId) {
     )
   };
 }
-var Store = class _Store {
+function overlayPropertyDescriptors(base, overlay) {
+  return Object.defineProperties(Object.create(Reflect.getPrototypeOf(base)), {
+    ...Object.getOwnPropertyDescriptors(base),
+    ...Object.getOwnPropertyDescriptors(overlay)
+  });
+}
+function syncStoreReplacementRef(ref, replacement) {
+  if (ref === void 0) return;
+  ref.current = replacement;
+}
+var StoreImplementation = class _StoreImplementation {
+  [STORE_RUNTIME];
   #graph;
   /**
    * Bare backend for DDL, vector-storage, and bulk-materialization work that must
@@ -15657,6 +16745,7 @@ var Store = class _Store {
    */
   #baseBackend;
   #backend;
+  #adapterBackend;
   #captureEnabled;
   #revisionTrackingEnabled;
   #revisionOrigin;
@@ -15676,9 +16765,10 @@ var Store = class _Store {
   #edgeCollections;
   #algorithms;
   #search;
-  constructor(graph, backend, options, schemaMetadata) {
+  constructor(graph, backend, options, schemaMetadata, adapterBackend) {
     this.#graph = graph;
     this.#baseBackend = asRawBackend(backend);
+    this.#adapterBackend = adapterBackend;
     this.#captureEnabled = options?.history === true;
     this.#revisionTrackingEnabled = this.#captureEnabled || options?.revisionTracking === true;
     if (this.#revisionTrackingEnabled) {
@@ -15715,6 +16805,21 @@ var Store = class _Store {
     this.#defaultTraversalExpansion = options?.queryDefaults?.traversalExpansion ?? "inverse";
     this.#options = options;
     this.#schemaMetadata = schemaMetadata ?? UNKNOWN_SCHEMA_METADATA;
+    this[STORE_RUNTIME] = {
+      backend: this.#backend,
+      sealedQuery: (coordinate) => this.sealedQuery(coordinate),
+      recordedNodeGetById: (kind, id, coordinate) => this.recordedNodeGetById(kind, id, coordinate),
+      recordedNodeGetByIds: (kind, ids, coordinate) => this.recordedNodeGetByIds(kind, ids, coordinate),
+      recordedEdgeGetById: (kind, id, coordinate) => this.recordedEdgeGetById(kind, id, coordinate),
+      recordedEdgeGetByIds: (kind, ids, coordinate) => this.recordedEdgeGetByIds(kind, ids, coordinate),
+      subgraphAtCoordinate: (rootId, subgraphOptions) => this.subgraphAtCoordinate(rootId, subgraphOptions),
+      algorithmsAtCoordinate: (coordinate) => this.algorithmsAtCoordinate(coordinate)
+    };
+    Object.defineProperty(this, STORE_RUNTIME, {
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
   }
   // === Accessors ===
   /** The graph definition */
@@ -15725,14 +16830,14 @@ var Store = class _Store {
   get graphId() {
     return this.#graph.id;
   }
+  /** Runtime features available through this store's configured backend. */
+  get capabilities() {
+    return this.#baseBackend.capabilities;
+  }
   /** The kind registry for ontology lookups */
   get registry() {
     return this.#registry;
   }
-  /** The database backend */
-  get backend() {
-    return this.#backend;
-  }
   /**
    * Whether recorded-time capture is enabled for this store.
    *
@@ -15937,7 +17042,7 @@ var Store = class _Store {
    */
   getNodePropsSchema(kind) {
     if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
-    return this.#graph.nodes[kind].type.schema;
+    return requireDefined(this.#graph.nodes[kind]).type.schema;
   }
   /**
    * Returns the Zod props schema for the given node kind. Throws
@@ -15958,7 +17063,7 @@ var Store = class _Store {
    */
   getEdgePropsSchema(kind) {
     if (!Object.hasOwn(this.#graph.edges, kind)) return void 0;
-    return this.#graph.edges[kind].type.schema;
+    return requireDefined(this.#graph.edges[kind]).type.schema;
   }
   /**
    * Returns the Zod props schema for the given edge kind. Throws
@@ -16572,15 +17677,21 @@ var Store = class _Store {
         edges,
         // No real transaction: `tx.sql` is absent and there is no atomicity.
         sqlAvailability: "unavailable",
-        backend: this.#backend,
-        getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind),
-        // No transaction, no deferral: operations apply as they happen, so
-        // their hooks fire immediately.
-        runNodeOperationHooks: (operation, kind, id, hookedFunction) => this.#withOperationHooks(
-          this.#createOperationContext(operation, "node", kind, id),
-          hookedFunction
-        )
+        backend: createTransactionReadBackend(this.#backend),
+        [TRANSACTION_RUNTIME]: {
+          backend: this.#backend,
+          runNodeOperationHooks: (operation, kind, id, hookedFunction) => this.#withOperationHooks(
+            this.#createOperationContext(operation, "node", kind, id),
+            hookedFunction
+          )
+        },
+        getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind)
       };
+      Object.defineProperty(fallbackContext, TRANSACTION_RUNTIME, {
+        configurable: false,
+        enumerable: false,
+        writable: false
+      });
       const result = await invoke(
         receiptRecorder === void 0 ? fallbackContext : this.#attachMeasure(fallbackContext)
       );
@@ -16593,15 +17704,19 @@ var Store = class _Store {
       recordedByGraph = instants;
     }) : backendOptions;
     try {
-      const result = await this.#backend.transaction(
-        async (txBackend, sql19) => invoke(
-          this.#buildTransactionContext(
-            txBackend,
-            sql19,
-            runHooks,
-            receiptRecorder
-          )
-        ),
+      const run = async (txBackend, nativeTransaction) => invoke(
+        this.#buildTransactionContext(
+          txBackend,
+          nativeTransaction,
+          runHooks,
+          receiptRecorder
+        )
+      );
+      const result = this.#captureEnabled || this.#adapterBackend === void 0 ? await this.#backend.transaction(
+        (txBackend) => run(txBackend, void 0),
+        transactionOptions
+      ) : await this.#adapterBackend.transactionWithNative(
+        (txBackend, nativeTransaction) => run(txBackend, nativeTransaction),
         transactionOptions
       );
       for (const outcome of pending) {
@@ -16618,12 +17733,86 @@ var Store = class _Store {
       throw error;
     }
   }
+  /**
+   * Adopts a caller-owned, already-open Drizzle transaction so the graph
+   * store and the caller's relational writes commit or roll back as one
+   * Postgres/SQLite transaction (#134).
+   *
+   * Use this when the **relational layer owns the transaction**: the
+   * caller has opened a transaction and needs TypeGraph writes enlisted
+   * on the *same* connection. Unlike {@link transaction}, this opens no
+   * transaction — the caller's transaction is the single commit/rollback
+   * boundary.
+   *
+   * `withTransaction` is driver-agnostic; how the caller opens the
+   * transaction is not. **Async drivers** (node-postgres,
+   * `neon-serverless` Pool, libsql) use `db.transaction(async …)`.
+   * **Synchronous `better-sqlite3`** cannot — its driver rejects an
+   * `async` transaction callback (`Transaction function cannot return a
+   * promise`) and the async continuation would run outside the
+   * rolled-back transaction — so the caller opens the transaction with
+   * explicit `BEGIN`/`COMMIT`/`ROLLBACK` on the single connection
+   * instead. See the "Cross-Store Transactions" recipe for both shapes.
+   *
+   * The returned context reuses this store's already-resolved
+   * schema/registry: it runs **no** schema bootstrap, `evolve`, or
+   * migration, and emits **no DDL** inside the caller's transaction.
+   * Fulltext operations assert the durable materialization marker (a
+   * cached SELECT) and throw {@link StoreNotInitializedError} on a
+   * missing/stale/failed marker rather than migrating mid-transaction —
+   * so boot the parent store via `createAdapterStoreWithSchema` once at
+   * startup.
+   *
+   * @example
+   * ```typescript
+   * // Async driver (Postgres / libsql):
+   * await db.transaction(async (sqlTx) => {
+   *   const connector = await createConnectorRow(sqlTx, input); // Drizzle
+   *   const txStore = store.withTransaction(sqlTx);
+   *   await txStore.nodes.ArtifactSource.create({              // TypeGraph
+   *     connectorId: connector.id,
+   *   });
+   * }); // one COMMIT / ROLLBACK across both layers
+   * ```
+   *
+   * **The caller owns the connection — don't overlap writes on it.** The graph
+   * store and your Drizzle writes share the one connection the caller's
+   * transaction pinned. TypeGraph serializes the statements *its* collections
+   * issue, but your raw Drizzle statements (and any graph write run alongside
+   * them) are yours to sequence: a `Promise.all` mixing the two races two
+   * queries on that connection — the overlap Postgres removes in `pg@9`. Await
+   * each write before starting the next.
+   *
+   * Not available when the store was created with `{ history: true }`: a
+   * caller-owned transaction context would let writes happen after capture has
+   * lost its flush point. {@link AdapterHistoryStore} omits this method, while
+   * the runtime guard still throws `ConfigurationError` if the public contract
+   * is bypassed
+   * (`RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`) if the check is
+   * suppressed. Use {@link AdapterStore.withRecordedTransaction} on a history-enabled
+   * store, which adopts the same external transaction but flushes recorded-time
+   * capture before the caller commits.
+   *
+   * @throws {ConfigurationError} when the store has history capture enabled
+   *   (use {@link AdapterStore.withRecordedTransaction} instead), or when the backend
+   *   cannot adopt an external transaction — either it is not a Drizzle
+   *   Postgres/SQLite backend, or `backend.capabilities.transactions` is `false`
+   *   (`drizzle-orm/neon-http`, Cloudflare D1, SQLite
+   *   `transactionMode: "none"`). A non-atomic fallback is deliberately
+   *   not offered here: the caller's relational write *would* still
+   *   commit, defeating the purpose of cross-store atomicity.
+   * @throws {StoreNotInitializedError} at point of use, when a fulltext
+   *   operation on the returned context observes a missing/stale/failed
+   *   durable materialization marker (parent store not booted via
+   *   `createAdapterStoreWithSchema`). Rolls back the caller's transaction
+   *   without emitting any DDL.
+   */
   withTransaction(externalTx) {
     if (this.#captureEnabled) {
       throw recordedCaptureRequiresCallbackTransactionError();
     }
-    const adopt = this.#backend.adoptTransaction;
-    if (!adopt) {
+    const adopt = this.#adapterBackend?.adoptTransaction;
+    if (adopt === void 0) {
       throw new ConfigurationError(
         "This backend cannot adopt an external transaction for cross-store atomicity. adoptTransaction is provided only by the Drizzle Postgres/SQLite backends with transaction support. Check backend.capabilities.transactions, or run the relational and graph writes as separate transactions with manual compensation.",
         { capability: "adoptTransaction" }
@@ -16632,8 +17821,8 @@ var Store = class _Store {
     return this.#buildTransactionContext(adopt(externalTx), externalTx);
   }
   async withRecordedTransaction(externalTx, fn) {
-    const adopt = this.#baseBackend.adoptTransaction;
-    if (!adopt) {
+    const adopt = this.#adapterBackend?.adoptTransaction;
+    if (adopt === void 0) {
       throw new ConfigurationError(
         "This backend cannot adopt an external transaction for recorded-time capture.",
         { capability: "adoptTransaction" },
@@ -16694,16 +17883,17 @@ var Store = class _Store {
         context.edges,
         scopeRecorder
       );
-      const scoped = this.#attachMeasure({
-        ...context,
-        nodes,
-        edges,
-        getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind)
-      });
+      const scoped = this.#attachMeasure(
+        overlayPropertyDescriptors(context, {
+          nodes,
+          edges,
+          getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind)
+        })
+      );
       const result = await fn(scoped);
       return { result, receipt: scopeRecorder.snapshot() };
     };
-    return { ...context, measure };
+    return overlayPropertyDescriptors(context, { measure });
   }
   /**
    * Builds the `{ nodes, edges, sql }` projection bound to a
@@ -16715,7 +17905,7 @@ var Store = class _Store {
    * (#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, sql19, runHooks = this.#immediateHookRunner(), receiptRecorder) {
+  #buildTransactionContext(txBackend, sql2, runHooks = this.#immediateHookRunner(), receiptRecorder) {
     const txNodeOperations = {
       ...this.#buildNodeOperations(this.#createNodeOperationContext(runHooks)),
       createQuery: () => this.#createQueryForBackend(txBackend),
@@ -16749,19 +17939,40 @@ var Store = class _Store {
       ));
     }
     const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
-    const sqlAvailability = this.#captureEnabled ? "history" : this.#revisionTrackingEnabled ? "revisionTracking" : sql19 === void 0 ? "unavailable" : "available";
     const base = {
       nodes,
       edges,
-      sqlAvailability,
-      backend: txBackend,
-      getNodeCollection,
-      runNodeOperationHooks
-    };
-    const withSql = sql19 === void 0 ? base : {
-      ...base,
-      sql: this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql19
+      backend: createTransactionReadBackend(txBackend),
+      [TRANSACTION_RUNTIME]: { backend: txBackend, runNodeOperationHooks },
+      getNodeCollection
     };
+    let withSql;
+    if (this.#captureEnabled) {
+      withSql = {
+        ...base,
+        sqlAvailability: "history",
+        get sql() {
+          return throwHistoryUnsafeSqlAccess();
+        }
+      };
+    } else if (this.#revisionTrackingEnabled) {
+      withSql = {
+        ...base,
+        sqlAvailability: "revisionTracking",
+        get sql() {
+          return throwRevisionTrackingUnsafeSqlAccess();
+        }
+      };
+    } else if (sql2 === void 0) {
+      withSql = { ...base, sqlAvailability: "unavailable" };
+    } else {
+      withSql = { ...base, sql: sql2, sqlAvailability: "available" };
+    }
+    Object.defineProperty(withSql, TRANSACTION_RUNTIME, {
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
     return receiptRecorder === void 0 ? withSql : this.#attachMeasure(withSql);
   }
   // === Graph Lifecycle ===
@@ -16913,7 +18124,7 @@ var Store = class _Store {
     const merged = mergeGraphExtension(baseline, extension);
     if (merged === baseline) {
       if (baseline === this.#graph) {
-        if (options?.ref !== void 0) options.ref.current = this;
+        syncStoreReplacementRef(options?.ref, this);
         if (options?.eager !== void 0) {
           await this.#runEagerOrThrow(this, options.eager);
         }
@@ -17260,7 +18471,7 @@ var Store = class _Store {
     const plan = planRemovals(baseline, names);
     if (plan.removedNodeKinds.length === 0 && plan.removedEdgeKinds.length === 0) {
       if (baseline === this.#graph) {
-        if (options?.ref !== void 0) options.ref.current = this;
+        syncStoreReplacementRef(options?.ref, this);
         return this;
       }
       return this.#cloneWithGraph(
@@ -17351,7 +18562,7 @@ var Store = class _Store {
     }
     if (setsEqual(nextSet, baseline.deprecatedKinds)) {
       if (baseline === this.#graph) {
-        if (options?.ref !== void 0) options.ref.current = this;
+        syncStoreReplacementRef(options?.ref, this);
         return this;
       }
       return this.#cloneWithGraph(
@@ -17443,13 +18654,18 @@ var Store = class _Store {
     return nonEmpty;
   }
   #cloneWithGraph(graph, ref, schemaMetadata = this.#schemaMetadata) {
-    const next = new _Store(
+    const next = this.#adapterBackend === void 0 ? new _StoreImplementation(
       graph,
       this.#baseBackend,
       this.#options,
       schemaMetadata
+    ) : new AdapterStoreImplementation(
+      graph,
+      this.#adapterBackend,
+      this.#options,
+      schemaMetadata
     );
-    if (ref !== void 0) ref.current = next;
+    syncStoreReplacementRef(ref, next);
     return next;
   }
   /**
@@ -17591,8 +18807,100 @@ var Store = class _Store {
     );
   }
 };
+var AdapterStoreImplementation = class extends StoreImplementation {
+  backend;
+  constructor(graph, backend, options, schemaMetadata) {
+    super(graph, backend, options, schemaMetadata, backend);
+    this.backend = options?.history === true ? createHistoryStoreBackendProjection(this[STORE_RUNTIME].backend) : Object.freeze(
+      createGraphBackendProjection(this[STORE_RUNTIME].backend)
+    );
+  }
+  async evolve(extension, options) {
+    return this.#withAdapterReplacement(
+      options?.ref,
+      (replacementRef) => super.evolve(
+        extension,
+        options?.eager === void 0 ? { ref: replacementRef } : { eager: options.eager, ref: replacementRef }
+      )
+    );
+  }
+  async deprecateKinds(names, options) {
+    return this.#withAdapterReplacement(
+      options?.ref,
+      (replacementRef) => super.deprecateKinds(names, { ref: replacementRef })
+    );
+  }
+  async undeprecateKinds(names, options) {
+    return this.#withAdapterReplacement(
+      options?.ref,
+      (replacementRef) => super.undeprecateKinds(names, { ref: replacementRef })
+    );
+  }
+  async removeKinds(names, options) {
+    return this.#withAdapterReplacement(
+      options?.ref,
+      (replacementRef) => super.removeKinds(
+        names,
+        options?.eager === void 0 ? { ref: replacementRef } : { eager: options.eager, ref: replacementRef }
+      )
+    );
+  }
+  async #withAdapterReplacement(ref, operation) {
+    const tracked = createTrackedReplacementRef(this);
+    try {
+      await operation(tracked.ref);
+    } catch (error) {
+      if (tracked.wasReplaced()) {
+        const replacement2 = requireAdapterStoreImplementation(tracked.ref.current);
+        syncAdapterReplacementRef(ref, replacement2);
+      }
+      throw error;
+    }
+    const replacement = requireAdapterStoreImplementation(tracked.ref.current);
+    syncAdapterReplacementRef(ref, replacement);
+    return replacement;
+  }
+};
+function createTrackedReplacementRef(initial) {
+  let current = initial;
+  let replaced = false;
+  return {
+    ref: {
+      get current() {
+        return current;
+      },
+      set current(next) {
+        current = next;
+        replaced = true;
+      }
+    },
+    wasReplaced: () => replaced
+  };
+}
+function syncAdapterReplacementRef(ref, replacement) {
+  if (ref === void 0) return;
+  ref.current = replacement;
+}
+function requireAdapterStoreImplementation(store) {
+  if (isAdapterStoreImplementation(store)) return store;
+  throw new ConfigurationError(
+    "Adapter store replacement lost its adapter capabilities.",
+    { code: "ADAPTER_STORE_REPLACEMENT_INVARIANT" }
+  );
+}
+function isAdapterStoreImplementation(store) {
+  return store instanceof AdapterStoreImplementation;
+}
+function asAdapterStoreSurface(store) {
+  return store;
+}
 function createStore(graph, backend, options) {
-  return new Store(graph, backend, options);
+  return new StoreImplementation(graph, backend, options);
+}
+function createAdapterStore(graph, backend, options) {
+  return asAdapterStoreSurface(
+    new AdapterStoreImplementation(graph, backend, options)
+  );
 }
 function isKnownEdgeKind(graph, name) {
   return Object.hasOwn(graph.edges, name);
@@ -17637,6 +18945,18 @@ async function materializeVectorContributions(backend, graph) {
   }
 }
 async function createStoreWithSchema(graph, backend, options) {
+  const prepared = await prepareStoreWithSchema(graph, backend, options);
+  return [
+    new StoreImplementation(
+      prepared.graph,
+      backend,
+      options,
+      prepared.schemaMetadata
+    ),
+    prepared.result
+  ];
+}
+async function prepareStoreWithSchema(graph, backend, options) {
   const {
     graph: merged,
     activeRow,
@@ -17651,13 +18971,25 @@ async function createStoreWithSchema(graph, backend, options) {
   if (options?.systemIndexes !== "skip") {
     await materializeSystemIndexesOnBoot(backend, merged.id, result);
   }
-  const store = new Store(
-    merged,
-    backend,
-    options,
-    schemaMetadataForResult(activeRow, result)
-  );
-  return [store, result];
+  return {
+    graph: merged,
+    result,
+    schemaMetadata: schemaMetadataForResult(activeRow, result)
+  };
+}
+async function createAdapterStoreWithSchema(graph, backend, options) {
+  const prepared = await prepareStoreWithSchema(graph, backend, options);
+  return [
+    asAdapterStoreSurface(
+      new AdapterStoreImplementation(
+        prepared.graph,
+        backend,
+        options,
+        prepared.schemaMetadata
+      )
+    ),
+    prepared.result
+  ];
 }
 async function materializeSystemIndexesOnBoot(backend, graphId, result) {
   if (result.status === "breaking") return;
@@ -17684,20 +19016,44 @@ async function materializeSystemIndexesOnBoot(backend, graphId, result) {
   }
 }
 async function createVerifiedStore(graph, backend, options) {
+  const prepared = await prepareVerifiedStore(graph, backend);
+  return [
+    new StoreImplementation(
+      prepared.graph,
+      backend,
+      options,
+      prepared.schemaMetadata
+    ),
+    prepared.result
+  ];
+}
+async function prepareVerifiedStore(graph, backend) {
   const {
     graph: merged,
     activeRow,
     result
   } = await loadAndVerifyGraph(backend, graph);
-  const store = new Store(
-    merged,
-    backend,
-    options,
-    schemaMetadataFromRow(activeRow)
-  );
-  return [store, result];
+  return {
+    graph: merged,
+    result,
+    schemaMetadata: schemaMetadataFromRow(activeRow)
+  };
+}
+async function createVerifiedAdapterStore(graph, backend, options) {
+  const prepared = await prepareVerifiedStore(graph, backend);
+  return [
+    asAdapterStoreSurface(
+      new AdapterStoreImplementation(
+        prepared.graph,
+        backend,
+        options,
+        prepared.schemaMetadata
+      )
+    ),
+    prepared.result
+  ];
 }
 
-export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-GA4TT3DH.js.map
-//# sourceMappingURL=chunk-GA4TT3DH.js.map
+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-A2FGSWMQ.js.map
+//# sourceMappingURL=chunk-A2FGSWMQ.js.map