@nicia-ai/typegraph 0.36.0 → 0.37.1

package/dist/{chunk-5DIPR3L3.js → chunk-GA4TT3DH.js}

@@ -1,23 +1,23 @@
-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-RAXU3RMB.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-DN5VP4JC.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, serializeIndexDeclaration } from './chunk-M75SUBFG.js';
-import { isKnownKind, validateEdgeProps } from './chunk-SKCOUWAX.js';
+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 { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { generateIndexDDL } from './chunk-UZV3AZKF.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-OR5ZA5WP.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-FPIZFYHE.js';
-import { createSchemaIntrospector } from './chunk-5SEGFTZX.js';
-import { IncompatibleChangeError, RemoveCompileTimeKindError, KindHasReferentsError } from './chunk-SXGE7ITL.js';
-import { validateProjectionField } from './chunk-S5F7ZLP2.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, assertValidRecordedInstant, validateEdgeEndpoints, recordedBindParamBudget, closeRecordedHardDeletedKind, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-5VTR2F2K.js';
-import { markAnnIndexScan, asCompiledSelectSql, isRawExecutable, annIndexScanTypes, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql } from './chunk-UT3S4SEN.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, runOptionallyInTransaction, baseField, objectField, arrayField, dateField, numberField, rowPropsToObject, createBackendOverlay, compileKindFilter, currentReadInstant, compileTemporalFilter, sqlValueList, chunk, buildPredicateIndex, compileFieldValue, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-IU46OHVW.js';
-import { withRecordedRelationsPrecondition, nowIso, validateOptionalCanonicalIsoDate, isMissingTableError } from './chunk-JFUPDJXD.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 { getSearchableFields, resolveEmbeddingFields, resolveDeclaredFulltextLanguage } from './chunk-KBGQIPRQ.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, EndpointNotFoundError } from './chunk-WI7ISNQF.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 { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-G6Q5UM7U.js';
 import { Placeholder, sql } from 'drizzle-orm';
 
@@ -394,7 +394,8 @@ function recordedSearch(coordinate) {
 var CoordinatePinnedView = class {
   store;
   coordinate;
-  #algorithms;
+  #algorithmFacade;
+  #internalAlgorithms;
   constructor(store, coordinate) {
     this.store = store;
     this.coordinate = coordinate;
@@ -415,9 +416,24 @@ var CoordinatePinnedView = class {
   query() {
     return this.store.sealedQuery(this.coordinate);
   }
-  algorithms() {
-    this.#algorithms ??= this.store.algorithmsAtCoordinate(this.coordinate);
-    return this.#algorithms;
+  internalAlgorithms() {
+    this.#internalAlgorithms ??= this.store.algorithmsAtCoordinate(
+      this.coordinate
+    );
+    return this.#internalAlgorithms;
+  }
+  /** Graph algorithms pinned to this view's immutable temporal coordinate. */
+  get algorithms() {
+    this.#algorithmFacade ??= Object.freeze({
+      shortestPath: (from, to, options) => this.shortestPath(from, to, options),
+      weightedShortestPath: (from, to, options) => this.weightedShortestPath(from, to, options),
+      reachable: (from, options) => this.reachable(from, options),
+      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)
+    });
+    return this.#algorithmFacade;
   }
   /** Extracts a subgraph at this view's pinned coordinate. */
   subgraph(rootId, options) {
@@ -429,35 +445,49 @@ var CoordinatePinnedView = class {
   }
   /** Shortest path between two nodes at this view's pinned coordinate. */
   shortestPath(from, to, options) {
-    return this.algorithms().shortestPath(from, to, {
+    return this.internalAlgorithms().shortestPath(from, to, {
+      ...options,
+      ...withCoordinate(this.coordinate)
+    });
+  }
+  /** Minimum-total-weight path at this view's pinned coordinate. */
+  weightedShortestPath(from, to, options) {
+    return this.internalAlgorithms().weightedShortestPath(from, to, {
       ...options,
       ...withCoordinate(this.coordinate)
     });
   }
   /** Nodes reachable from `from` at this view's pinned coordinate. */
   reachable(from, options) {
-    return this.algorithms().reachable(from, {
+    return this.internalAlgorithms().reachable(from, {
       ...options,
       ...withCoordinate(this.coordinate)
     });
   }
   /** Whether `to` is reachable from `from` at this view's pinned coordinate. */
   canReach(from, to, options) {
-    return this.algorithms().canReach(from, to, {
+    return this.internalAlgorithms().canReach(from, to, {
       ...options,
       ...withCoordinate(this.coordinate)
     });
   }
   /** The k-hop neighborhood of `node` at this view's pinned coordinate. */
   neighbors(node, options) {
-    return this.algorithms().neighbors(node, {
+    return this.internalAlgorithms().neighbors(node, {
       ...options,
       ...withCoordinate(this.coordinate)
     });
   }
   /** Counts active edges incident to `node` at this view's pinned coordinate. */
   degree(node, options) {
-    return this.algorithms().degree(node, {
+    return this.internalAlgorithms().degree(node, {
+      ...options,
+      ...withCoordinate(this.coordinate)
+    });
+  }
+  /** Exact WCC memberships at this view's pinned coordinate. */
+  weaklyConnectedComponents(options) {
+    return this.internalAlgorithms().weaklyConnectedComponents({
       ...options,
       ...withCoordinate(this.coordinate)
     });
@@ -1457,6 +1487,97 @@ function buildStandardOrderBy(input) {
   }
   return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
 }
+var LATE_MAT_TOPK_CTE_ALIAS = "cte_lm_topk";
+var LATE_MAT_SORT_KEY_PREFIX = "__lm_sk";
+var LATE_MAT_PHYSICAL_ALIAS_PREFIX = "lm_";
+function lateMaterializedPhysicalAlias(alias) {
+  return `${LATE_MAT_PHYSICAL_ALIAS_PREFIX}${alias}`;
+}
+function lateMaterializedNodeAliases(ast) {
+  return [
+    ast.start.alias,
+    ...ast.traversals.map((traversal) => traversal.nodeAlias)
+  ];
+}
+function lateMaterializedProjectedNodeAliases(ast) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (const field2 of ast.selectiveFields ?? []) {
+    referenced.add(field2.alias);
+  }
+  return lateMaterializedNodeAliases(ast).filter(
+    (alias) => referenced.has(alias)
+  );
+}
+function buildLateMaterializedTopKCte(input) {
+  const { ast, collapsedTraversalCteAlias, dialect, fromClause } = input;
+  const aliasToCte = buildAliasToCteMap(ast);
+  const cteAliasFor = (alias) => collapsedTraversalCteAlias ?? aliasToCte.get(alias) ?? `${ALIAS_CTE_PREFIX}${alias}`;
+  const columns = [];
+  for (const alias of lateMaterializedNodeAliases(ast)) {
+    const cteAlias = cteAliasFor(alias);
+    columns.push(
+      sql`${qualifyColumn(cteAlias, `${alias}_id`)} AS ${sql.raw(`${alias}_id`)}`,
+      sql`${qualifyColumn(cteAlias, `${alias}_kind`)} AS ${sql.raw(`${alias}_kind`)}`
+    );
+  }
+  for (const [index, orderSpec] of (ast.orderBy ?? []).entries()) {
+    const value = compileOrderFieldValue(
+      ast,
+      orderSpec.field,
+      dialect,
+      cteAliasFor(orderSpec.field.alias)
+    );
+    columns.push(
+      sql`${value} AS ${sql.raw(`${LATE_MAT_SORT_KEY_PREFIX}${index}`)}`
+    );
+  }
+  const innerOrderBy = buildStandardOrderBy({
+    ast,
+    dialect,
+    ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias }
+  });
+  const limitOffset = buildLimitOffsetClause({
+    limit: input.limit,
+    offset: input.offset
+  });
+  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` `)})`;
+}
+function buildLateMaterializedOuterProjection(ast, dialect) {
+  const columns = (ast.selectiveFields ?? []).map((field2) => {
+    const physicalAlias = lateMaterializedPhysicalAlias(field2.alias);
+    if (field2.isSystemField) {
+      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
+      return sql`${compileColumnReference(physicalAlias, dbColumn)} AS ${quoteIdentifier(field2.outputName)}`;
+    }
+    const extracted = compileSelectivePropsExtraction(
+      field2,
+      compileColumnReference(physicalAlias, "props"),
+      dialect
+    );
+    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+  });
+  return sql.join(columns, sql`, `);
+}
+function buildLateMaterializedOuterOrderBy(ast) {
+  const orderBy = ast.orderBy ?? [];
+  if (orderBy.length === 0) return void 0;
+  const topk = sql.raw(LATE_MAT_TOPK_CTE_ALIAS);
+  const parts = [];
+  for (const [index, orderSpec] of orderBy.entries()) {
+    const column = sql`${topk}.${sql.raw(`${LATE_MAT_SORT_KEY_PREFIX}${index}`)}`;
+    const direction = sql.raw(orderSpec.direction.toUpperCase());
+    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+    const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
+    parts.push(
+      sql`(${column} IS NULL) ${nullsDirection}`,
+      sql`${column} ${direction}`
+    );
+  }
+  return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
+}
 function fieldRefKey(field2) {
   const pointer = field2.jsonPointer ?? "";
   return `${field2.alias}:${field2.path.join(".")}:${pointer}`;
@@ -3611,31 +3732,34 @@ function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
     }
   }
 }
-function collectRequiredColumnsByAlias2(ast) {
+function collectRequiredColumnsByAlias2(ast, options) {
+  const includeProjection = options?.includeProjection ?? true;
   const requiredColumnsByAlias = /* @__PURE__ */ new Map();
   addRequiredColumn(requiredColumnsByAlias, ast.start.alias, "id");
   for (const traversal of ast.traversals) {
     addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
   }
   const hasSelectiveFields = (ast.selectiveFields?.length ?? 0) > 0;
-  if (hasSelectiveFields) {
-    for (const field2 of ast.selectiveFields ?? []) {
-      if (field2.isSystemField) {
-        addRequiredColumn(
-          requiredColumnsByAlias,
-          field2.alias,
-          mapSelectiveSystemFieldToColumn(field2.field)
-        );
+  if (includeProjection) {
+    if (hasSelectiveFields) {
+      for (const field2 of ast.selectiveFields ?? []) {
+        if (field2.isSystemField) {
+          addRequiredColumn(
+            requiredColumnsByAlias,
+            field2.alias,
+            mapSelectiveSystemFieldToColumn(field2.field)
+          );
+        }
       }
-    }
-  } else {
-    for (const projectedField of ast.projection.fields) {
-      const source = projectedField.source;
-      if (source.__type === "field_ref") {
-        markFieldRefAsRequired(requiredColumnsByAlias, source);
-      } else {
-        addRequiredColumn(requiredColumnsByAlias, source.field.alias, "id");
-        markFieldRefAsRequired(requiredColumnsByAlias, source.field);
+    } else {
+      for (const projectedField of ast.projection.fields) {
+        const source = projectedField.source;
+        if (source.__type === "field_ref") {
+          markFieldRefAsRequired(requiredColumnsByAlias, source);
+        } else {
+          addRequiredColumn(requiredColumnsByAlias, source.field.alias, "id");
+          markFieldRefAsRequired(requiredColumnsByAlias, source.field);
+        }
       }
     }
   }
@@ -4318,6 +4442,169 @@ function stripLimitOffsetFromPlanNode(node) {
   }
   return node;
 }
+function buildStandardStartAndTraversalCtes(input) {
+  const {
+    ast,
+    carryForwardPreviousColumns,
+    ctx,
+    graphId,
+    predicateIndex,
+    requiredColumnsByAlias,
+    temporalFilterPass,
+    traversalLimit
+  } = input;
+  const ctes = [
+    buildStandardStartCte({
+      ast,
+      ctx,
+      graphId,
+      predicateIndex,
+      requiredColumnsByAlias,
+      temporalFilterPass
+    })
+  ];
+  for (let index = 0; index < ast.traversals.length; index++) {
+    ctes.push(
+      buildStandardTraversalCte({
+        ast,
+        carryForwardPreviousColumns,
+        ctx,
+        graphId,
+        materializeCte: shouldMaterializeTraversalCte(
+          ctx.dialect,
+          ast.traversals.length,
+          index
+        ),
+        predicateIndex,
+        requiredColumnsByAlias,
+        temporalFilterPass,
+        traversalIndex: index,
+        traversalLimit
+      })
+    );
+  }
+  return ctes;
+}
+function selectiveFieldIsIdentity(field2) {
+  if (!field2.isSystemField) {
+    return false;
+  }
+  const column = mapSelectiveSystemFieldToColumn(field2.field);
+  return column === "id" || column === "kind";
+}
+function resolveLateMaterializationPlan(ast) {
+  if (ast.recordedAsOf !== void 0) {
+    return void 0;
+  }
+  const selectiveFields = ast.selectiveFields;
+  if (selectiveFields === void 0 || selectiveFields.length === 0) {
+    return void 0;
+  }
+  const orderBy = ast.orderBy;
+  if (orderBy === void 0 || orderBy.length === 0) {
+    return void 0;
+  }
+  if (ast.limit === void 0 || ast.limit <= 0) {
+    return void 0;
+  }
+  if (ast.groupBy !== void 0 || ast.having !== void 0) {
+    return void 0;
+  }
+  if (ast.aggregateOrderBy !== void 0 && ast.aggregateOrderBy.length > 0) {
+    return void 0;
+  }
+  if (ast.traversals.some((traversal) => traversal.optional)) {
+    return void 0;
+  }
+  const nodeAliases = /* @__PURE__ */ new Set([
+    ast.start.alias,
+    ...ast.traversals.map((traversal) => traversal.nodeAlias)
+  ]);
+  for (const field2 of selectiveFields) {
+    if (!nodeAliases.has(field2.alias)) {
+      return void 0;
+    }
+  }
+  for (const orderSpec of orderBy) {
+    if (!nodeAliases.has(orderSpec.field.alias)) {
+      return void 0;
+    }
+  }
+  const orderReferenced = /* @__PURE__ */ new Set();
+  for (const orderSpec of orderBy) {
+    const matched = findSelectivePropsFieldForFieldRef(
+      selectiveFields,
+      orderSpec.field
+    );
+    if (matched !== void 0) {
+      orderReferenced.add(matched);
+    }
+  }
+  const hasDeferredColumn = selectiveFields.some(
+    (field2) => !selectiveFieldIsIdentity(field2) && !orderReferenced.has(field2)
+  );
+  if (!hasDeferredColumn) {
+    return void 0;
+  }
+  const prunedSelectiveFields = selectiveFields.filter(
+    (field2) => field2.isSystemField || orderReferenced.has(field2)
+  );
+  return {
+    leanAst: { ...ast, selectiveFields: prunedSelectiveFields },
+    limit: ast.limit,
+    offset: ast.offset
+  };
+}
+function buildLateMaterializedOuterFromClause(ast, graphId, ctx) {
+  const topk = sql.raw(LATE_MAT_TOPK_CTE_ALIAS);
+  const joins = lateMaterializedProjectedNodeAliases(ast).map((alias) => {
+    const physical = sql.raw(lateMaterializedPhysicalAlias(alias));
+    return sql`JOIN ${ctx.schema.nodesTable} ${physical} ON ${physical}.graph_id = ${graphId} AND ${physical}.kind = ${topk}.${sql.raw(`${alias}_kind`)} AND ${physical}.id = ${topk}.${sql.raw(`${alias}_id`)}`;
+  });
+  return joins.length === 0 ? sql`FROM ${topk}` : sql`FROM ${topk} ${sql.join(joins, sql` `)}`;
+}
+function compileLateMaterializedQuery(ast, graphId, ctx, logicalPlan, predicateIndex, temporalFilterPass, collapsedTraversalCteAlias, shouldCollapseSelectiveTraversalRowset) {
+  const plan = resolveLateMaterializationPlan(ast);
+  if (plan === void 0) {
+    return void 0;
+  }
+  const { leanAst, limit, offset } = plan;
+  const { dialect } = ctx;
+  const leanRequiredColumns = collectRequiredColumnsByAlias2(leanAst, {
+    includeProjection: false
+  });
+  const ctes = buildStandardStartAndTraversalCtes({
+    ast: leanAst,
+    carryForwardPreviousColumns: shouldCollapseSelectiveTraversalRowset,
+    ctx,
+    graphId,
+    predicateIndex,
+    requiredColumnsByAlias: leanRequiredColumns,
+    temporalFilterPass,
+    traversalLimit: void 0
+  });
+  ctes.push(
+    buildLateMaterializedTopKCte({
+      ast: leanAst,
+      dialect,
+      fromClause: buildStandardFromClause({
+        ast: leanAst,
+        ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias }
+      }),
+      limit,
+      offset,
+      ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias }
+    })
+  );
+  const orderBy = buildLateMaterializedOuterOrderBy(ast);
+  return emitStandardQuerySql({
+    ctes,
+    fromClause: buildLateMaterializedOuterFromClause(ast, graphId, ctx),
+    ...orderBy === void 0 ? {} : { orderBy },
+    logicalPlan: stripLimitOffsetFromPlan(logicalPlan),
+    projection: buildLateMaterializedOuterProjection(ast, dialect)
+  });
+}
 var STANDARD_QUERY_STRATEGY_HANDLERS = {
   cte_project: compileStandardQueryWithCteStrategy
 };
@@ -4417,38 +4704,30 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
     if (fastPathSql) {
       return fastPathSql;
     }
-  }
-  const ctes = [
-    buildStandardStartCte({
+    const lateMaterializedSql = compileLateMaterializedQuery(
       ast,
-      ctx,
       graphId,
+      ctx,
+      logicalPlan,
       predicateIndex,
-      requiredColumnsByAlias,
-      temporalFilterPass
-    })
-  ];
-  for (let index = 0; index < ast.traversals.length; index++) {
-    const materializeTraversalCte = shouldMaterializeTraversalCte(
-      dialect,
-      ast.traversals.length,
-      index
-    );
-    ctes.push(
-      buildStandardTraversalCte({
-        ast,
-        carryForwardPreviousColumns: shouldCollapseSelectiveTraversalRowset,
-        ctx,
-        graphId,
-        materializeCte: materializeTraversalCte,
-        predicateIndex,
-        requiredColumnsByAlias,
-        temporalFilterPass,
-        traversalIndex: index,
-        traversalLimit: traversalCteLimit
-      })
+      temporalFilterPass,
+      collapsedTraversalCteAlias,
+      shouldCollapseSelectiveTraversalRowset
     );
+    if (lateMaterializedSql) {
+      return lateMaterializedSql;
+    }
   }
+  const ctes = buildStandardStartAndTraversalCtes({
+    ast,
+    carryForwardPreviousColumns: shouldCollapseSelectiveTraversalRowset,
+    ctx,
+    graphId,
+    predicateIndex,
+    requiredColumnsByAlias,
+    temporalFilterPass,
+    traversalLimit: traversalCteLimit
+  });
   if (vectorPredicate) {
     const nodeKinds = getNodeKindsForAlias(ast, vectorPredicate.field.alias);
     ctes.push(
@@ -10457,6 +10736,13 @@ function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
 // src/store/algorithms/context.ts
 var DEFAULT_ALGORITHM_MAX_HOPS = 10;
 var DEFAULT_NEIGHBOR_DEPTH = 1;
+function pickTemporalOptions(options) {
+  return {
+    ...options.temporalMode === void 0 ? {} : { temporalMode: options.temporalMode },
+    ...options.asOf === void 0 ? {} : { asOf: options.asOf },
+    ...options.recordedAsOf === void 0 ? {} : { recordedAsOf: options.recordedAsOf }
+  };
+}
 function resolveTemporalOptions(ctx, options) {
   const { valid } = resolveReadCoordinate(
     options.temporalMode ?? ctx.defaultTemporalMode,
@@ -10512,6 +10798,16 @@ function resolveMaxHops(rawMaxHops, fallback, optionName) {
   }
   return value;
 }
+function resolveMaxIterations(value, fallback, algorithm) {
+  const maxIterations = value ?? fallback;
+  if (!Number.isSafeInteger(maxIterations) || maxIterations < 1) {
+    throw new ConfigurationError(
+      `${algorithm} maxIterations must be a positive safe integer, got ${String(maxIterations)}.`,
+      { maxIterations }
+    );
+  }
+  return maxIterations;
+}
 function assertEdgeKinds(edges) {
   if (edges.length === 0) {
     throw new ConfigurationError(
@@ -10561,137 +10857,1636 @@ function compileDirectionFilter(ctx, direction, nodeId, nodesTable) {
     }
   }
 }
-async function executeReachable(ctx, sourceId, options) {
-  assertEdgeKinds(options.edges);
-  const maxHops = resolveMaxHops(
-    options.maxHops,
-    DEFAULT_ALGORITHM_MAX_HOPS,
-    "maxHops"
-  );
-  const cte = buildReachableCte({
-    graphId: ctx.graphId,
-    sourceId,
-    edgeKinds: options.edges,
-    maxHops,
-    direction: options.direction ?? "out",
-    cyclePolicy: options.cyclePolicy ?? "prevent",
-    includePath: false,
-    ...resolveTemporalOptions(ctx, options),
-    dialect: ctx.dialect,
-    schema: ctx.schema,
-    ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding }
-  });
-  const sourceFilter = options.excludeSource === true ? sql` WHERE id != ${sourceId}` : sql``;
-  const query = sql`${cte} SELECT id, kind, MIN(depth) AS depth FROM reachable${sourceFilter} GROUP BY id, kind ORDER BY depth ASC, id ASC`;
-  const rows = await ctx.backend.execute(
-    asCompiledRowsSql(query)
+function frontierIndexIdentifier(context) {
+  return sql.identifier(
+    `typegraph_iterative_${context.runId.replaceAll("-", "_")}_frontier`
   );
-  return rows.map((row) => ({
-    id: row.id,
-    kind: row.kind,
-    depth: Number(row.depth)
-  }));
 }
-async function executeCanReach(ctx, sourceId, targetId, options) {
-  assertEdgeKinds(options.edges);
-  const maxHops = resolveMaxHops(
-    options.maxHops,
-    DEFAULT_ALGORITHM_MAX_HOPS,
-    "maxHops"
-  );
-  const cte = buildReachableCte({
-    graphId: ctx.graphId,
-    sourceId,
-    edgeKinds: options.edges,
-    maxHops,
-    direction: options.direction ?? "out",
-    cyclePolicy: options.cyclePolicy ?? "prevent",
-    includePath: false,
-    ...resolveTemporalOptions(ctx, options),
-    dialect: ctx.dialect,
-    schema: ctx.schema,
-    ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding }
-  });
-  const query = sql`${cte} SELECT 1 AS hit FROM reachable WHERE id = ${targetId} LIMIT 1`;
-  const rows = await ctx.backend.execute(
-    asCompiledRowsSql(query)
-  );
-  return rows.length > 0;
+var DEFAULT_MAX_BIND_PARAMETERS = 999;
+var RESERVED_TEMPORAL_BIND_PARAMETERS_PER_BRANCH = 12;
+var RESERVED_WEIGHT_BIND_PARAMETERS_PER_BRANCH = 4;
+var WORKING_TABLE_ANALYZE_MINIMUM_ROWS = 16;
+var WORKING_TABLE_ANALYZE_GROWTH_FACTOR = 4;
+var ITERATIVE_WORKING_MEMORY_PATTERN = /^(\d+)(kB|MB|GB)$/;
+var WORKING_MEMORY_KILOBYTES_PER_UNIT = {
+  kB: 1,
+  MB: 1024,
+  GB: 1024 * 1024
+};
+var MIN_WORKING_MEMORY_KILOBYTES = 64;
+var MAX_WORKING_MEMORY_KILOBYTES = 2147483647;
+function resolveWorkingMemory(workingMemory) {
+  if (workingMemory === void 0) return void 0;
+  const match = ITERATIVE_WORKING_MEMORY_PATTERN.exec(workingMemory);
+  if (match === null) {
+    throw new ConfigurationError(
+      `Iterative graph operation workingMemory must be digits followed by kB, MB, or GB (for example "64MB"), got ${JSON.stringify(workingMemory)}.`,
+      { workingMemory }
+    );
+  }
+  const kilobytes = Number(match[1]) * (WORKING_MEMORY_KILOBYTES_PER_UNIT[match[2] ?? ""] ?? 0);
+  if (kilobytes < MIN_WORKING_MEMORY_KILOBYTES || kilobytes > MAX_WORKING_MEMORY_KILOBYTES) {
+    throw new ConfigurationError(
+      `Iterative graph operation workingMemory must be between ${MIN_WORKING_MEMORY_KILOBYTES}kB and ${MAX_WORKING_MEMORY_KILOBYTES}kB, got ${JSON.stringify(workingMemory)}.`,
+      { workingMemory, kilobytes }
+    );
+  }
+  return workingMemory;
 }
-async function executeNeighbors(ctx, sourceId, options) {
-  const depth = resolveMaxHops(options.depth, DEFAULT_NEIGHBOR_DEPTH, "depth");
-  return executeReachable(ctx, sourceId, {
+async function withInlineIterativeGraphOperation(ctx, options, run) {
+  if (ctx.backend.capabilities.transactions) {
+    return ctx.backend.transaction(
+      async (backend) => run(createOperation(ctx, options, backend)),
+      {
+        isolationLevel: "repeatable_read",
+        accessMode: "read_only"
+      }
+    );
+  }
+  return run(createOperation(ctx, options, ctx.backend));
+}
+async function runIterativeGraphOperation(ctx, options, plan) {
+  if (!ctx.backend.capabilities.transactions) {
+    throw new ConfigurationError(
+      "Temporary-table graph iteration requires a transactional backend.",
+      { 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 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
+        );
+        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
+        );
+        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
+    }
+  );
+}
+function shouldRefreshWorkingTableStatistics(workingTableSize, analyzedRowCount) {
+  if (workingTableSize < WORKING_TABLE_ANALYZE_MINIMUM_ROWS) return false;
+  if (analyzedRowCount === void 0) return true;
+  return workingTableSize >= analyzedRowCount * WORKING_TABLE_ANALYZE_GROWTH_FACTOR;
+}
+async function refreshWorkingTableStatistics(context, workingTableSize, analyzedRowCount) {
+  if (!shouldRefreshWorkingTableStatistics(workingTableSize, analyzedRowCount)) {
+    return analyzedRowCount;
+  }
+  const statement = context.operation.ctx.dialect.analyzeTemporaryTable(
+    context.workingTable
+  );
+  if (statement === void 0) return analyzedRowCount;
+  await context.executeTemporary(statement);
+  return workingTableSize;
+}
+async function dropWorkingTable(context, operationError) {
+  try {
+    await context.executeTemporary(
+      sql`DROP TABLE IF EXISTS ${context.workingTable}`
+    );
+  } catch (cleanupError) {
+    if (operationError === void 0) throw cleanupError;
+  }
+}
+async function fetchVisibleWorkingNodes(operation, nodeIds) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const chunk2 of chunkValues(nodeIds, operation.maxWorkingSetSize)) {
+    const query = sql`SELECT n.id, n.kind FROM ${operation.schema.nodesTable} n WHERE n.graph_id = ${operation.ctx.graphId} AND n.id IN (${sqlValueList(chunk2)}) AND ${operation.nodeTemporalFilter}`;
+    const rows = await operation.backend.execute(
+      asCompiledRowsSql(query)
+    );
+    for (const row of rows) nodes.set(nodeIdentityKey(row), row);
+  }
+  return [...nodes.values()].toSorted(
+    (left, right) => compareNodeIdentity(left, right)
+  );
+}
+async function reduceExpandedWorkingSet(operation, workingSet, direction, reduce) {
+  const reduced = /* @__PURE__ */ new Map();
+  for (const edgeKinds of operation.edgeKindChunks) {
+    for (const chunk2 of chunkValues(workingSet, operation.maxWorkingSetSize)) {
+      const rows = await operation.backend.execute(
+        asCompiledRowsSql(
+          compileExpansionQuery(operation, chunk2, direction, edgeKinds)
+        )
+      );
+      for (const row of rows) {
+        if (operation.weightExpression !== void 0 && !isPresent(row.weight)) {
+          throw new CompilerInvariantError(
+            "Weighted graph expansion produced a NULL weight. Either the plan skipped its weight audit, or edge data changed concurrently during a run on a backend without snapshot isolation.",
+            { source: row.source_id, target: row.target_id }
+          );
+        }
+        const expansion = {
+          source: { id: row.source_id, kind: row.source_kind },
+          target: { id: row.target_id, kind: row.target_kind },
+          ...isPresent(row.weight) ? { weight: Number(row.weight) } : {}
+        };
+        const targetKey = nodeIdentityKey(expansion.target);
+        const selected = reduce(reduced.get(targetKey), expansion);
+        if (selected !== void 0) reduced.set(targetKey, selected);
+      }
+    }
+  }
+  return reduced;
+}
+function nodeIdentityKey(node) {
+  return `${node.kind}\0${node.id}`;
+}
+function nodeIdentityKeyFromRow(id, kind) {
+  if (typeof id !== "string" || typeof kind !== "string") return void 0;
+  return nodeIdentityKey({ id, kind });
+}
+function compareNodeIdentity(left, right) {
+  return compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
+}
+var OUTGOING_DIRECTION_FIELDS = {
+  joinField: "from_id",
+  joinKindField: "from_kind",
+  targetField: "to_id",
+  targetKindField: "to_kind"
+};
+var INCOMING_DIRECTION_FIELDS = {
+  joinField: "to_id",
+  joinKindField: "to_kind",
+  targetField: "from_id",
+  targetKindField: "from_kind"
+};
+function fieldsForDirection(direction) {
+  switch (direction) {
+    case "out": {
+      return [OUTGOING_DIRECTION_FIELDS];
+    }
+    case "in": {
+      return [INCOMING_DIRECTION_FIELDS];
+    }
+    case "both": {
+      return [OUTGOING_DIRECTION_FIELDS, INCOMING_DIRECTION_FIELDS];
+    }
+  }
+}
+function compileDirectionUnion(direction, compileDirection) {
+  return sql.join(
+    fieldsForDirection(direction).map((fields) => compileDirection(fields)),
+    sql` UNION ALL `
+  );
+}
+function compileExpansionQuery(operation, workingSet, direction, edgeKinds) {
+  const workingValues = sql.join(
+    workingSet.map((node) => sql`(${node.id}, ${node.kind})`),
+    sql`, `
+  );
+  const workingCte = sql`WITH working_set(node_id, node_kind) AS (VALUES ${workingValues})`;
+  const expansion = compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalExpansion(
+      operation,
+      sql`working_set`,
+      sql`TRUE`,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField
+    )
+  );
+  return sql`${workingCte} ${expansion}`;
+}
+function compileWorkingTableExpansion(operation, workingTable, sourceFilter, direction, edgeKinds) {
+  return compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalExpansion(
+      operation,
+      workingTable,
+      sourceFilter,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField
+    )
+  );
+}
+function compileWorkingTableEdgeExpansion(operation, workingTable, sourceFilter, direction, edgeKinds, sourceProjection) {
+  return compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalEdgeExpansion(
+      operation,
+      workingTable,
+      sourceFilter,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField,
+      sourceProjection
+    )
+  );
+}
+function compileDirectionalExpansion(operation, workingRelation, sourceFilter, edgeKinds, joinField, joinKindField, targetField, targetKindField) {
+  const edgeExpansion = compileDirectionalEdgeExpansion(
+    operation,
+    workingRelation,
+    sourceFilter,
+    edgeKinds,
+    joinField,
+    joinKindField,
+    targetField,
+    targetKindField
+  );
+  const weightColumn = operation.weightExpression === void 0 ? sql`` : sql`, expanded.weight`;
+  return sql`SELECT expanded.source_id, expanded.source_kind, n.id AS target_id, n.kind AS target_kind${weightColumn} FROM (${edgeExpansion}) expanded JOIN ${operation.schema.nodesTable} n ON n.graph_id = ${operation.ctx.graphId} AND n.id = expanded.target_id AND n.kind = expanded.target_kind WHERE ${operation.nodeTemporalFilter}`;
+}
+function compileDirectionalEdgeExpansion(operation, workingRelation, sourceFilter, edgeKinds, joinField, joinKindField, targetField, targetKindField, sourceProjection) {
+  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), edgeKinds);
+  const weightColumn = operation.weightExpression === void 0 ? sql`` : sql`, ${operation.weightExpression} AS weight`;
+  const sourceColumns = sourceProjection === void 0 ? sql`` : sql`, ${sourceProjection}`;
+  return sql`SELECT w.node_id AS source_id, w.node_kind AS source_kind${sourceColumns}, e.${sql.raw(targetField)} AS target_id, e.${sql.raw(targetKindField)} AS target_kind${weightColumn} FROM ${workingRelation} w JOIN ${operation.schema.edgesTable} e ON e.${sql.raw(joinField)} = w.node_id AND e.${sql.raw(joinKindField)} = w.node_kind AND e.graph_id = ${operation.ctx.graphId} WHERE ${sourceFilter} AND ${edgeKindFilter} AND ${operation.edgeTemporalFilter}`;
+}
+function chunkValues(values, chunkSize) {
+  const chunks = [];
+  for (let offset = 0; offset < values.length; offset += chunkSize) {
+    chunks.push(values.slice(offset, offset + chunkSize));
+  }
+  return chunks;
+}
+function createOperation(ctx, options, backend) {
+  const temporal = resolveTemporalOptions(ctx, options);
+  const currentTimestamp = currentReadInstant();
+  const nodeTemporalFilter = compileTemporalFilter({
+    mode: temporal.temporalMode,
+    ...temporal.asOf === void 0 ? {} : { asOf: temporal.asOf },
+    ...temporal.recordedAsOf === void 0 ? {} : { recordedAsOf: temporal.recordedAsOf },
+    tableAlias: "n",
+    currentTimestamp
+  });
+  const edgeTemporalFilter = compileTemporalFilter({
+    mode: temporal.temporalMode,
+    ...temporal.asOf === void 0 ? {} : { asOf: temporal.asOf },
+    ...temporal.recordedAsOf === void 0 ? {} : { recordedAsOf: temporal.recordedAsOf },
+    tableAlias: "e",
+    currentTimestamp
+  });
+  const weightExpression = options.weightProperty === void 0 ? void 0 : compileWeightExpression(
+    ctx.dialect,
+    options.weightProperty,
+    options.defaultWeight
+  );
+  const direction = options.direction ?? "out";
+  const branchCount = direction === "both" ? 2 : 1;
+  const parameterLimit = backend.capabilities.maxBindParameters ?? DEFAULT_MAX_BIND_PARAMETERS;
+  const reservedPerBranch = RESERVED_TEMPORAL_BIND_PARAMETERS_PER_BRANCH + (weightExpression === void 0 ? 0 : RESERVED_WEIGHT_BIND_PARAMETERS_PER_BRANCH);
+  const fixedParameters = branchCount * reservedPerBranch;
+  const sharedBudget = parameterLimit - fixedParameters;
+  const maxEdgeKindsPerQuery = Math.floor(sharedBudget / (branchCount + 2));
+  if (maxEdgeKindsPerQuery < 1) {
+    throw new ConfigurationError(
+      "An iterative graph operation cannot fit its fixed filters within the backend bind-parameter limit.",
+      { parameterLimit, direction }
+    );
+  }
+  const edgeKindChunks = chunkValues(
+    [...new Set(options.edges)].toSorted(
+      (left, right) => compareStrings(left, right)
+    ),
+    maxEdgeKindsPerQuery
+  );
+  const largestEdgeKindChunk = Math.max(
+    ...edgeKindChunks.map((chunk2) => chunk2.length)
+  );
+  const maxWorkingSetSize = Math.floor(
+    (parameterLimit - branchCount * (largestEdgeKindChunk + reservedPerBranch)) / 2
+  );
+  if (maxWorkingSetSize < 1) {
+    throw new ConfigurationError(
+      "An iterative graph operation cannot fit one working-set node within the backend bind-parameter limit.",
+      { parameterLimit, direction }
+    );
+  }
+  return {
+    backend,
+    ctx,
+    edgeKindChunks,
+    direction,
+    maxWorkingSetSize,
+    nodeTemporalFilter,
+    edgeTemporalFilter,
+    schema: resolveReadSchema(ctx, options),
+    workingMemory: resolveWorkingMemory(options.workingMemory),
+    weightExpression
+  };
+}
+function compileWeightExpression(dialect, weightProperty, defaultWeight) {
+  const extracted = dialect.jsonExtractDouble(
+    sql.raw("e.props"),
+    jsonPointer([weightProperty])
+  );
+  return defaultWeight === void 0 ? extracted : sql`COALESCE(${extracted}, ${defaultWeight})`;
+}
+function supportsTemporaryIteration(ctx) {
+  return ctx.backend.capabilities.transactions && ctx.backend.capabilities.graphAnalytics?.supported !== false && ctx.backend.capabilities.returning !== false && ctx.backend.executeTemporaryStatement !== void 0;
+}
+function requireTemporaryStatements(backend) {
+  if (backend.executeTemporaryStatement === void 0) {
+    throw new ConfigurationError(
+      "Iterative graph operations require temporary-statement support on the transaction backend.",
+      { dialect: backend.dialect },
+      {
+        suggestion: "Use a built-in SQLite/PostgreSQL backend or implement executeTemporaryStatement on the custom 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,
+    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
+      };
+    },
+    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,
+    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,
+        reverseFrontierCount: expandForward ? state.reverseFrontierCount : round.insertedCount,
+        meeting: round.meeting,
+        workingTableSize: state.workingTableSize + round.insertedCount
+      };
+    },
+    hasConverged(state) {
+      return state.meeting !== void 0 || state.forwardFrontierCount === 0 || state.reverseFrontierCount === 0 || state.forwardDepth + state.reverseDepth >= maxHops;
+    },
+    async extractResult(context, state) {
+      if (state.meeting === void 0) return;
+      const rows = await readWorkingRows(context);
+      return buildShortestPath(
+        nodeIdentityKey(state.meeting),
+        createVisitedMapFromRows(rows, "forward"),
+        createVisitedMapFromRows(rows, "reverse")
+      );
+    }
+  });
+}
+function createWorkingTable(context) {
+  return sql`
+    CREATE TEMP TABLE ${context.workingTable} (
+        graph_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        side TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        node_kind TEXT NOT NULL,
+        depth INTEGER NOT NULL,
+        predecessor_id TEXT,
+        predecessor_kind TEXT,
+        meeting_depth INTEGER,
+        PRIMARY KEY (graph_id, run_id, side, node_kind, node_id)
+      )
+  `;
+}
+async function seedWorkingSide(context, nodeId, side) {
+  const { operation, workingTable, graphId, runId } = context;
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      INSERT INTO ${workingTable}
+        (graph_id, run_id, side, node_id, node_kind, depth,
+         predecessor_id, predecessor_kind)
+      SELECT ${graphId}, ${runId}, ${side}, n.id, n.kind, 0, NULL, NULL
+      FROM ${operation.schema.nodesTable} n
+      WHERE n.graph_id = ${graphId}
+        AND n.id = ${nodeId}
+        AND ${operation.nodeTemporalFilter}
+      ON CONFLICT (graph_id, run_id, side, node_kind, node_id) DO NOTHING
+      RETURNING node_id, node_kind
+    `)
+  );
+}
+function findSeedMeeting(forwardSeeds, reverseSeeds) {
+  const reverseKeys = new Set(
+    reverseSeeds.map(
+      (row) => nodeIdentityKey({ id: row.node_id, kind: row.node_kind })
+    )
+  );
+  let meeting;
+  for (const row of forwardSeeds) {
+    const candidate = { id: row.node_id, kind: row.node_kind, depth: 0 };
+    if (!reverseKeys.has(nodeIdentityKey(candidate))) continue;
+    if (meeting === void 0 || compareNodeIdentity(candidate, meeting) < 0) {
+      meeting = candidate;
+    }
+  }
+  return meeting;
+}
+async function expandWorkingTableRound(context, side, currentDepth, nextDepth, direction, maxHops) {
+  const oppositeSide = side === "forward" ? "reverse" : "forward";
+  let insertedCount = 0;
+  let meeting;
+  const { dialect } = context.operation.ctx;
+  const targetKind = dialect.binaryText(sql`expanded.target_kind`);
+  const targetId = dialect.binaryText(sql`expanded.target_id`);
+  const sourceId = dialect.binaryText(sql`expanded.source_id`);
+  const sourceKind = dialect.binaryText(sql`expanded.source_kind`);
+  for (const edgeKinds of context.operation.edgeKindChunks) {
+    const sourceFilter = sql`
+      w.graph_id = ${context.graphId}
+      AND w.run_id = ${context.runId}
+      AND w.side = ${side}
+      AND w.depth = ${currentDepth}
+    `;
+    const expansion = compileWorkingTableExpansion(
+      context.operation,
+      context.workingTable,
+      sourceFilter,
+      direction,
+      edgeKinds
+    );
+    const rows = await context.backend.execute(
+      asCompiledRowsSql(sql`
+        INSERT INTO ${context.workingTable}
+          (graph_id, run_id, side, node_id, node_kind, depth,
+           predecessor_id, predecessor_kind, meeting_depth)
+        SELECT
+          ${context.graphId}, ${context.runId}, ${side},
+          ranked.target_id, ranked.target_kind, ${nextDepth},
+          ranked.source_id, ranked.source_kind,
+          (
+            SELECT opposite.depth
+            FROM ${context.workingTable} opposite
+            WHERE opposite.graph_id = ${context.graphId}
+              AND opposite.run_id = ${context.runId}
+              AND opposite.side = ${oppositeSide}
+              AND opposite.node_id = ranked.target_id
+              AND opposite.node_kind = ranked.target_kind
+          )
+        FROM (
+          SELECT expanded.*,
+            ROW_NUMBER() OVER (
+              PARTITION BY ${targetKind}, ${targetId}
+              ORDER BY ${sourceId}, ${sourceKind}
+            ) AS candidate_rank
+          FROM (${expansion}) expanded
+        ) ranked
+        WHERE ranked.candidate_rank = 1
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${context.workingTable} visited
+            WHERE visited.graph_id = ${context.graphId}
+              AND visited.run_id = ${context.runId}
+              AND visited.side = ${side}
+              AND visited.node_id = ranked.target_id
+              AND visited.node_kind = ranked.target_kind
+          )
+        ON CONFLICT (graph_id, run_id, side, node_kind, node_id) DO NOTHING
+        RETURNING node_id, node_kind, meeting_depth
+      `)
+    );
+    insertedCount += rows.length;
+    meeting = selectRoundMeeting(meeting, rows, nextDepth, maxHops);
+  }
+  return { insertedCount, meeting };
+}
+function selectRoundMeeting(currentMeeting, rows, nextDepth, maxHops) {
+  let meeting = currentMeeting;
+  for (const row of rows) {
+    if (row.meeting_depth === null || row.meeting_depth === void 0) {
+      continue;
+    }
+    const totalDepth = nextDepth + Number(row.meeting_depth);
+    if (totalDepth > maxHops) continue;
+    const candidate = {
+      id: row.node_id,
+      kind: row.node_kind,
+      depth: totalDepth
+    };
+    if (meeting === void 0 || candidate.depth < meeting.depth || candidate.depth === meeting.depth && compareNodeIdentity(candidate, meeting) < 0) {
+      meeting = candidate;
+    }
+  }
+  return meeting;
+}
+async function expandReachableWorkingTableRound(context, side, currentDepth, nextDepth, direction) {
+  let insertedCount = 0;
+  for (const edgeKinds of context.operation.edgeKindChunks) {
+    const sourceFilter = sql`
+      w.graph_id = ${context.graphId}
+      AND w.run_id = ${context.runId}
+      AND w.side = ${side}
+      AND w.depth = ${currentDepth}
+    `;
+    const edgeExpansion = compileWorkingTableEdgeExpansion(
+      context.operation,
+      context.workingTable,
+      sourceFilter,
+      direction,
+      edgeKinds
+    );
+    const rows = await context.backend.execute(
+      asCompiledRowsSql(sql`
+        INSERT INTO ${context.workingTable}
+          (graph_id, run_id, side, node_id, node_kind, depth,
+           predecessor_id, predecessor_kind)
+        SELECT
+          ${context.graphId}, ${context.runId}, ${side},
+          candidates.target_id, candidates.target_kind, ${nextDepth},
+          NULL, NULL
+        FROM (
+          SELECT DISTINCT expanded.target_id, expanded.target_kind
+          FROM (${edgeExpansion}) expanded
+        ) candidates
+        JOIN ${context.operation.schema.nodesTable} n
+          ON n.graph_id = ${context.graphId}
+          AND n.id = candidates.target_id
+          AND n.kind = candidates.target_kind
+        WHERE ${context.operation.nodeTemporalFilter}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${context.workingTable} visited
+            WHERE visited.graph_id = ${context.graphId}
+              AND visited.run_id = ${context.runId}
+              AND visited.side = ${side}
+              AND visited.node_id = candidates.target_id
+              AND visited.node_kind = candidates.target_kind
+          )
+        ON CONFLICT (graph_id, run_id, side, node_kind, node_id) DO NOTHING
+        RETURNING node_id
+      `)
+    );
+    insertedCount += rows.length;
+  }
+  return insertedCount;
+}
+async function readWorkingRows(context, side) {
+  const sideFilter = side === void 0 ? sql`TRUE` : sql`side = ${side}`;
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT side, node_id, node_kind, depth,
+        predecessor_id, predecessor_kind
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId}
+        AND run_id = ${context.runId}
+        AND ${sideFilter}
+    `)
+  );
+}
+async function findReachableNodesInline(ctx, sourceId, maxHops, options) {
+  return withInlineIterativeGraphOperation(ctx, options, async (operation) => {
+    const sources = await fetchVisibleWorkingNodes(operation, [sourceId]);
+    if (sources.length === 0) return [];
+    const reached = new Map(
+      sources.map((source) => [
+        nodeIdentityKey(source),
+        { id: source.id, kind: source.kind, depth: 0 }
+      ])
+    );
+    let workingSet = sources;
+    for (let depth = 1; depth <= maxHops && workingSet.length > 0; depth++) {
+      const candidates = await expandInlineWorkingSet(
+        operation,
+        workingSet,
+        operation.direction,
+        reached
+      );
+      const nextWorkingSet = sortCandidates(candidates);
+      for (const candidate of nextWorkingSet) {
+        reached.set(nodeIdentityKey(candidate), {
+          id: candidate.id,
+          kind: candidate.kind,
+          depth
+        });
+      }
+      workingSet = nextWorkingSet;
+    }
+    return [...reached.values()].toSorted(
+      (left, right) => left.depth - right.depth || compareNodeIdentity(left, right)
+    );
+  });
+}
+async function findShortestPathInline(ctx, sourceId, targetId, maxHops, options) {
+  return withInlineIterativeGraphOperation(ctx, options, async (operation) => {
+    const visibleNodes = await fetchVisibleWorkingNodes(operation, [
+      sourceId,
+      targetId
+    ]);
+    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 };
+    const forwardVisited = createVisitedMap(sources);
+    const reverseVisited = createVisitedMap(targets);
+    let forwardWorkingSet = sources;
+    let reverseWorkingSet = targets;
+    let forwardDepth = 0;
+    let reverseDepth = 0;
+    while (forwardWorkingSet.length > 0 && reverseWorkingSet.length > 0 && forwardDepth + reverseDepth < maxHops) {
+      const expandForward = forwardWorkingSet.length <= reverseWorkingSet.length;
+      const activeVisited = expandForward ? forwardVisited : reverseVisited;
+      const oppositeVisited = expandForward ? reverseVisited : forwardVisited;
+      const currentWorkingSet = expandForward ? forwardWorkingSet : reverseWorkingSet;
+      const direction = expandForward ? operation.direction : reverseDirection(operation.direction);
+      const candidates = await expandInlineWorkingSet(
+        operation,
+        currentWorkingSet,
+        direction,
+        activeVisited
+      );
+      const nextDepth = (expandForward ? forwardDepth : reverseDepth) + 1;
+      const nextWorkingSet = sortCandidates(candidates);
+      for (const candidate of nextWorkingSet) {
+        activeVisited.set(nodeIdentityKey(candidate), {
+          id: candidate.id,
+          kind: candidate.kind,
+          depth: nextDepth,
+          parentKey: nodeIdentityKey({
+            id: candidate.parentId,
+            kind: candidate.parentKind
+          })
+        });
+      }
+      const meetingKey = findMeetingNodeKey(
+        nextWorkingSet,
+        activeVisited,
+        oppositeVisited
+      );
+      if (meetingKey !== void 0) {
+        return buildShortestPath(meetingKey, forwardVisited, reverseVisited);
+      }
+      if (expandForward) {
+        forwardWorkingSet = nextWorkingSet;
+        forwardDepth = nextDepth;
+      } else {
+        reverseWorkingSet = nextWorkingSet;
+        reverseDepth = nextDepth;
+      }
+    }
+    return;
+  });
+}
+async function expandInlineWorkingSet(operation, workingSet, direction, visited) {
+  return reduceExpandedWorkingSet(
+    operation,
+    workingSet,
+    direction,
+    (existing, expansion) => selectPredecessor(existing, expansion, visited)
+  );
+}
+function selectPredecessor(existing, expansion, visited) {
+  if (visited.has(nodeIdentityKey(expansion.target))) return existing;
+  if (existing !== void 0 && compareNodeIdentity(expansion.source, {
+    id: existing.parentId,
+    kind: existing.parentKind
+  }) >= 0) {
+    return existing;
+  }
+  return {
+    id: expansion.target.id,
+    kind: expansion.target.kind,
+    parentId: expansion.source.id,
+    parentKind: expansion.source.kind
+  };
+}
+function sortCandidates(candidates) {
+  return [...candidates.values()].toSorted(
+    (left, right) => compareNodeIdentity(left, right)
+  );
+}
+function findMeetingNodeKey(candidates, activeVisited, oppositeVisited) {
+  let best;
+  for (const candidate of candidates) {
+    const key = nodeIdentityKey(candidate);
+    const active = activeVisited.get(key);
+    const opposite = oppositeVisited.get(key);
+    if (active === void 0 || opposite === void 0) continue;
+    const meeting = {
+      key,
+      node: { id: candidate.id, kind: candidate.kind },
+      depth: active.depth + opposite.depth
+    };
+    if (best === void 0 || meeting.depth < best.depth || meeting.depth === best.depth && compareNodeIdentity(meeting.node, best.node) < 0) {
+      best = meeting;
+    }
+  }
+  return best?.key;
+}
+function buildShortestPath(meetingKey, forwardVisited, reverseVisited) {
+  const forwardKeys = [];
+  let cursor = meetingKey;
+  while (cursor !== void 0) {
+    forwardKeys.push(cursor);
+    cursor = forwardVisited.get(cursor)?.parentKey;
+  }
+  forwardKeys.reverse();
+  const pathKeys = [...forwardKeys];
+  cursor = reverseVisited.get(meetingKey)?.parentKey;
+  while (cursor !== void 0) {
+    pathKeys.push(cursor);
+    cursor = reverseVisited.get(cursor)?.parentKey;
+  }
+  const nodes = pathKeys.map((key) => {
+    const node = forwardVisited.get(key) ?? reverseVisited.get(key);
+    return { id: node?.id ?? "", kind: node?.kind ?? "" };
+  });
+  return { nodes, depth: nodes.length - 1 };
+}
+function createVisitedMap(nodes) {
+  return new Map(
+    nodes.map((node) => [
+      nodeIdentityKey(node),
+      { id: node.id, kind: node.kind, depth: 0, parentKey: void 0 }
+    ])
+  );
+}
+function createVisitedMapFromRows(rows, side) {
+  return new Map(
+    rows.filter((row) => row.side === side).map((row) => {
+      const parentKey = nodeIdentityKeyFromRow(
+        row.predecessor_id,
+        row.predecessor_kind
+      );
+      const node = {
+        id: row.node_id,
+        kind: row.node_kind,
+        depth: Number(row.depth),
+        parentKey
+      };
+      return [nodeIdentityKey(node), node];
+    })
+  );
+}
+function reverseDirection(direction) {
+  switch (direction) {
+    case "out": {
+      return "in";
+    }
+    case "in": {
+      return "out";
+    }
+    case "both": {
+      return "both";
+    }
+  }
+}
+
+// src/store/algorithms/reachable.ts
+async function executeReachable(ctx, sourceId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  const reached = await findReachableNodes(ctx, sourceId, maxHops, options);
+  return options.excludeSource === true ? reached.filter((node) => node.id !== sourceId) : reached;
+}
+async function executeCanReach(ctx, sourceId, targetId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  return await findShortestPath(ctx, sourceId, targetId, maxHops, options) !== void 0;
+}
+async function executeNeighbors(ctx, sourceId, options) {
+  const depth = resolveMaxHops(options.depth, DEFAULT_NEIGHBOR_DEPTH, "depth");
+  return executeReachable(ctx, sourceId, {
     edges: options.edges,
     maxHops: depth,
     direction: options.direction ?? "out",
     cyclePolicy: options.cyclePolicy ?? "prevent",
-    ...options.temporalMode !== void 0 && {
-      temporalMode: options.temporalMode
+    ...pickTemporalOptions(options),
+    ...options.workingMemory !== void 0 && {
+      workingMemory: options.workingMemory
+    },
+    excludeSource: true
+  });
+}
+
+// src/store/algorithms/shortest-path.ts
+async function executeShortestPath(ctx, sourceId, targetId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  return findShortestPath(ctx, sourceId, targetId, maxHops, options);
+}
+var DEFAULT_WCC_MAX_ITERATIONS = 1e3;
+async function executeWeaklyConnectedComponents(ctx, options) {
+  assertEdgeKinds(options.edges);
+  assertWeaklyConnectedComponentsSupported(ctx);
+  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 traversalOptions = {
+    edges: options.edges,
+    direction: "both",
+    ...pickTemporalOptions(options),
+    ...options.workingMemory === void 0 ? {} : { workingMemory: options.workingMemory }
+  };
+  return runIterativeGraphOperation(ctx, traversalOptions, {
+    algorithm: "weaklyConnectedComponents",
+    maxIterations,
+    createWorkingTable: createWorkingTable2,
+    initialize: (context) => initializeWorkingTable(context, nodeKinds),
+    runRound: runLabelPropagationRound,
+    hasConverged(state) {
+      return state.changedCount === 0;
+    },
+    extractResult: extractMemberships
+  });
+}
+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) {
+  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,
+      improved_round INTEGER NOT NULL,
+      PRIMARY KEY (graph_id, run_id, node_kind, node_id)
+    )
+  `;
+}
+async function initializeWorkingTable(context, nodeKinds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const nodeKindFilter = nodeKinds === void 0 ? sql`TRUE` : compileKindFilter(sql.raw("n.kind"), 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, improved_round)
+    SELECT
+      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind, 0
+    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, 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);
+  return { changedCount: workingTableSize, workingTableSize };
+}
+async function runLabelPropagationRound(context, state, iteration) {
+  for (const edgeKinds of context.operation.edgeKindChunks) {
+    await propagateChunkLabels(context, edgeKinds, iteration);
+  }
+  const changedRows = await applyNextLabels(context, iteration);
+  return {
+    changedCount: changedRows.length,
+    workingTableSize: state.workingTableSize
+  };
+}
+async function propagateChunkLabels(context, edgeKinds, iteration) {
+  const { operation, workingTable, graphId, runId } = context;
+  const expansion = compileWorkingTableEdgeExpansion(
+    operation,
+    workingTable,
+    sql`
+      w.graph_id = ${graphId}
+      AND w.run_id = ${runId}
+      AND w.improved_round = ${iteration - 1}
+    `,
+    "both",
+    edgeKinds,
+    sql`w.label_id AS source_label_id, w.label_kind AS source_label_kind`
+  );
+  const candidateId = operation.ctx.dialect.binaryText(sql`ranked.label_id`);
+  const candidateKind = operation.ctx.dialect.binaryText(
+    sql`ranked.label_kind`
+  );
+  const currentId = operation.ctx.dialect.binaryText(sql`target.next_label_id`);
+  const currentKind = operation.ctx.dialect.binaryText(
+    sql`target.next_label_kind`
+  );
+  const sourceId = operation.ctx.dialect.binaryText(sql`source.label_id`);
+  const sourceKind = operation.ctx.dialect.binaryText(sql`source.label_kind`);
+  const targetId = operation.ctx.dialect.binaryText(sql`source.target_id`);
+  const targetKind = operation.ctx.dialect.binaryText(sql`source.target_kind`);
+  await context.executeTemporary(sql`
+    WITH candidates AS (
+      SELECT
+        expanded.target_id,
+        expanded.target_kind,
+        expanded.source_label_id AS label_id,
+        expanded.source_label_kind AS label_kind
+      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
+    ), ranked AS (
+      SELECT
+        target_id,
+        target_kind,
+        label_id,
+        label_kind,
+        ROW_NUMBER() OVER (
+          PARTITION BY ${targetKind}, ${targetId}
+          ORDER BY ${sourceId}, ${sourceKind}
+        ) AS candidate_rank
+      FROM candidates source
+    )
+    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.node_id = ranked.target_id
+      AND target.node_kind = ranked.target_kind
+      AND ranked.candidate_rank = 1
+      AND (
+        ${candidateId} < ${currentId}
+        OR (
+          ${candidateId} = ${currentId}
+          AND ${candidateKind} < ${currentKind}
+        )
+      )
+  `);
+}
+function applyNextLabels(context, iteration) {
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      UPDATE ${context.workingTable}
+      SET label_id = next_label_id,
+          label_kind = next_label_kind,
+          improved_round = ${iteration}
+      WHERE graph_id = ${context.graphId}
+        AND run_id = ${context.runId}
+        AND (
+          label_id <> next_label_id OR label_kind <> next_label_kind
+        )
+      RETURNING node_id
+    `)
+  );
+}
+async function extractMemberships(context) {
+  const { operation } = context;
+  const componentId = operation.ctx.dialect.binaryText(sql`label_id`);
+  const componentKind = 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 AS component_id,
+        label_kind AS component_kind,
+        COUNT(*) OVER (
+          PARTITION BY ${componentKind}, ${componentId}
+        ) AS component_size
+      FROM ${context.workingTable}
+      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+      ORDER BY ${componentId}, ${componentKind}, ${nodeId}, ${nodeKind}
+    `)
+  );
+  return rows.map((row) => ({
+    id: row.node_id,
+    kind: row.node_kind,
+    componentId: row.component_id,
+    componentKind: row.component_kind,
+    size: Number(row.component_size)
+  }));
+}
+var DEFAULT_WEIGHTED_SHORTEST_PATH_MAX_ITERATIONS = 1e3;
+var WEIGHTED_ALGORITHM_NAME = "weightedShortestPath";
+var MAX_EDGE_WEIGHT = Number.MAX_VALUE / 2 ** 64;
+var MIN_EDGE_WEIGHT = Number.MIN_VALUE;
+async function executeWeightedShortestPath(ctx, sourceId, targetId, options) {
+  assertEdgeKinds(options.edges);
+  assertWeightOptions(options.weightProperty, options.defaultWeight);
+  const maxIterations = resolveMaxIterations(
+    options.maxIterations,
+    DEFAULT_WEIGHTED_SHORTEST_PATH_MAX_ITERATIONS,
+    WEIGHTED_ALGORITHM_NAME
+  );
+  const traversalOptions = options;
+  if (sourceId === targetId) {
+    return findWeightedSelfPath(ctx, sourceId, traversalOptions);
+  }
+  if (supportsTemporaryIteration(ctx)) {
+    return findWeightedShortestPathInWorkingTable(
+      ctx,
+      sourceId,
+      targetId,
+      maxIterations,
+      traversalOptions
+    );
+  }
+  return findWeightedShortestPathInline(
+    ctx,
+    sourceId,
+    targetId,
+    maxIterations,
+    traversalOptions
+  );
+}
+function assertWeightOptions(weightProperty, defaultWeight) {
+  if (typeof weightProperty !== "string" || weightProperty.length === 0) {
+    throw new ConfigurationError(
+      `${WEIGHTED_ALGORITHM_NAME} weightProperty must be a non-empty string.`,
+      { weightProperty }
+    );
+  }
+  if (defaultWeight !== void 0 && (!Number.isFinite(defaultWeight) || defaultWeight < 0 || defaultWeight > MAX_EDGE_WEIGHT)) {
+    throw new ConfigurationError(
+      `${WEIGHTED_ALGORITHM_NAME} defaultWeight must be a non-negative number no greater than ${MAX_EDGE_WEIGHT}, got ${String(defaultWeight)}.`,
+      { defaultWeight, maximum: MAX_EDGE_WEIGHT }
+    );
+  }
+}
+async function assertValidEdgeWeights(operation, weightProperty, defaultWeight) {
+  const { dialect } = operation.ctx;
+  const pointer = jsonPointer([weightProperty]);
+  const propsColumn = sql.raw("e.props");
+  const isNumber = dialect.jsonPathIsNumber(propsColumn, pointer);
+  const isMissing = dialect.jsonPathIsNull(propsColumn, pointer);
+  const weightText = dialect.jsonExtractText(propsColumn, pointer);
+  const weightNumber = sql`CASE WHEN ${isNumber} THEN ${dialect.jsonExtractNumber(propsColumn, pointer)} END`;
+  const missingViolation = defaultWeight === void 0 ? sql`audited.is_missing = 1` : dialect.booleanLiteral(false);
+  const negativeViolation = sql`audited.is_number = 1 AND audited.weight_number < 0`;
+  const outOfRangeViolation = sql`audited.is_number = 1 AND (ABS(audited.weight_number) > CAST(${MAX_EDGE_WEIGHT} AS NUMERIC) OR (audited.weight_number <> 0 AND ABS(audited.weight_number) < CAST(${MIN_EDGE_WEIGHT} AS NUMERIC)))`;
+  for (const edgeKinds of operation.edgeKindChunks) {
+    const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), edgeKinds);
+    const rows = await operation.backend.execute(
+      asCompiledRowsSql(sql`
+        SELECT audited.edge_id, audited.edge_kind, audited.weight_text,
+          audited.is_number, audited.is_missing
+        FROM (
+          SELECT e.id AS edge_id, e.kind AS edge_kind,
+            ${weightText} AS weight_text,
+            ${weightNumber} AS weight_number,
+            CASE WHEN ${isNumber} THEN 1 ELSE 0 END AS is_number,
+            CASE WHEN ${isMissing} THEN 1 ELSE 0 END AS is_missing
+          FROM ${operation.schema.edgesTable} e
+          WHERE e.graph_id = ${operation.ctx.graphId}
+            AND ${edgeKindFilter}
+            AND ${operation.edgeTemporalFilter}
+        ) audited
+        WHERE (${missingViolation})
+          OR (audited.is_missing = 0 AND audited.is_number = 0)
+          OR (${negativeViolation})
+          OR (${outOfRangeViolation})
+        ORDER BY ${dialect.binaryText(sql`audited.edge_id`)}
+        LIMIT 1
+      `)
+    );
+    const row = rows[0];
+    if (row !== void 0) {
+      throw createInvalidEdgeWeightError(row, weightProperty);
+    }
+  }
+}
+function createInvalidEdgeWeightError(row, weightProperty) {
+  const reason = resolveInvalidWeightReason(row);
+  const value = reason === "missing" || row.weight_text === null ? void 0 : formatWeightValue(row.weight_text);
+  return new InvalidEdgeWeightError({
+    edgeId: row.edge_id,
+    edgeKind: row.edge_kind,
+    property: weightProperty,
+    reason,
+    ...value === void 0 ? {} : { value }
+  });
+}
+function resolveInvalidWeightReason(row) {
+  if (flagIsSet(row.is_missing)) return "missing";
+  if (!flagIsSet(row.is_number)) return "non_numeric";
+  return Number(row.weight_text) < 0 ? "negative" : "out_of_range";
+}
+function flagIsSet(value) {
+  return Number(value) !== 0;
+}
+function formatWeightValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+async function findWeightedShortestPathInWorkingTable(ctx, sourceId, targetId, maxIterations, options) {
+  return runIterativeGraphOperation(ctx, options, {
+    algorithm: WEIGHTED_ALGORITHM_NAME,
+    maxIterations,
+    createWorkingTable: createWorkingTable3,
+    async initialize(context) {
+      await assertValidEdgeWeights(
+        context.operation,
+        options.weightProperty,
+        options.defaultWeight
+      );
+      if (!await hasVisibleNode(context.operation, targetId)) {
+        return {
+          frontierCount: 0,
+          workingTableSize: 0,
+          bestTargetDistance: void 0
+        };
+      }
+      await context.executeTemporary(sql`
+        CREATE INDEX ${frontierIndexIdentifier(context)}
+        ON ${context.workingTable} (graph_id, run_id, improved_round)
+      `);
+      const seeded = await seedDistances(context, sourceId);
+      return {
+        frontierCount: seeded.length,
+        workingTableSize: seeded.length,
+        // Seeds carry the source id, never the target's — the self-path
+        // case is short-circuited before this plan runs.
+        bestTargetDistance: void 0
+      };
+    },
+    async runRound(context, state, iteration) {
+      const round = await relaxFrontierRound(
+        context,
+        targetId,
+        iteration,
+        state.bestTargetDistance
+      );
+      return {
+        frontierCount: round.frontierCount,
+        // Overcounts by re-improved existing rows (RETURNING includes
+        // updates); acceptable because the size only paces the substrate's
+        // ANALYZE refresh, where too-early merely refreshes stats sooner.
+        workingTableSize: state.workingTableSize + round.frontierCount,
+        bestTargetDistance: round.bestTargetDistance
+      };
     },
-    ...options.asOf !== void 0 && { asOf: options.asOf },
-    ...options.recordedAsOf !== void 0 && {
-      recordedAsOf: options.recordedAsOf
+    hasConverged(state) {
+      return state.frontierCount === 0;
     },
-    excludeSource: true
+    async extractResult(context) {
+      return extractPathFromWorkingTable(context, targetId, maxIterations);
+    }
   });
 }
-async function executeShortestPath(ctx, sourceId, targetId, options) {
-  assertEdgeKinds(options.edges);
-  const maxHops = resolveMaxHops(
-    options.maxHops,
-    DEFAULT_ALGORITHM_MAX_HOPS,
-    "maxHops"
+async function hasVisibleNode(operation, nodeId) {
+  const rows = await operation.backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT n.id FROM ${operation.schema.nodesTable} n
+      WHERE n.graph_id = ${operation.ctx.graphId}
+        AND n.id = ${nodeId}
+        AND ${operation.nodeTemporalFilter}
+      LIMIT 1
+    `)
   );
-  if (sourceId === targetId) {
-    const source = await fetchNodeKind(ctx, sourceId, options);
-    if (source === void 0) return void 0;
-    return { nodes: [source], depth: 0 };
+  return rows.length > 0;
+}
+function createWorkingTable3(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,
+      distance DOUBLE PRECISION NOT NULL,
+      hops INTEGER NOT NULL,
+      predecessor_id TEXT,
+      predecessor_kind TEXT,
+      improved_round INTEGER NOT NULL,
+      PRIMARY KEY (graph_id, run_id, node_kind, node_id)
+    )
+  `;
+}
+async function seedDistances(context, sourceId) {
+  const { operation, workingTable, graphId, runId } = context;
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      INSERT INTO ${workingTable}
+        (graph_id, run_id, node_id, node_kind, distance, hops,
+         predecessor_id, predecessor_kind, improved_round)
+      SELECT ${graphId}, ${runId}, n.id, n.kind, 0, 0, NULL, NULL, 0
+      FROM ${operation.schema.nodesTable} n
+      WHERE n.graph_id = ${graphId}
+        AND n.id = ${sourceId}
+        AND ${operation.nodeTemporalFilter}
+      ON CONFLICT (graph_id, run_id, node_kind, node_id) DO NOTHING
+      RETURNING node_id
+    `)
+  );
+}
+async function relaxFrontierRound(context, targetId, iteration, roundBound) {
+  const { operation, workingTable, graphId, runId } = context;
+  const { dialect } = operation.ctx;
+  let frontierCount = 0;
+  let bestTargetDistance = roundBound;
+  for (const edgeKinds of operation.edgeKindChunks) {
+    const sourceFilter = sql`
+      w.graph_id = ${graphId}
+      AND w.run_id = ${runId}
+      AND w.improved_round = ${iteration - 1}
+    `;
+    const expansion = compileWorkingTableExpansion(
+      operation,
+      workingTable,
+      sourceFilter,
+      operation.direction,
+      edgeKinds
+    );
+    const rows = await context.backend.execute(
+      asCompiledRowsSql(sql`
+        INSERT INTO ${workingTable}
+          (graph_id, run_id, node_id, node_kind, distance, hops,
+           predecessor_id, predecessor_kind, improved_round)
+        SELECT
+          ${graphId}, ${runId}, ranked.target_id, ranked.target_kind,
+          ranked.candidate_distance, ranked.candidate_hops,
+          ranked.source_id, ranked.source_kind, ${iteration}
+        FROM (
+          SELECT candidates.*,
+            ROW_NUMBER() OVER (
+              PARTITION BY ${dialect.binaryText(sql`candidates.target_kind`)},
+                ${dialect.binaryText(sql`candidates.target_id`)}
+              ORDER BY candidates.candidate_distance,
+                ${dialect.binaryText(sql`candidates.source_id`)},
+                ${dialect.binaryText(sql`candidates.source_kind`)}
+            ) AS candidate_rank
+          FROM (
+            SELECT expanded.source_id, expanded.source_kind,
+              expanded.target_id, expanded.target_kind,
+              frontier.distance + expanded.weight AS candidate_distance,
+              frontier.hops + 1 AS candidate_hops
+            FROM (${expansion}) expanded
+            JOIN ${workingTable} frontier
+              ON frontier.graph_id = ${graphId}
+              AND frontier.run_id = ${runId}
+              AND frontier.node_id = expanded.source_id
+              AND frontier.node_kind = expanded.source_kind
+          ) candidates
+          WHERE ${roundBound === void 0 ? sql`TRUE` : sql`candidates.candidate_distance <= ${roundBound}`}
+        ) ranked
+        WHERE ranked.candidate_rank = 1
+        ON CONFLICT (graph_id, run_id, node_kind, node_id) DO UPDATE SET
+          distance = excluded.distance,
+          hops = excluded.hops,
+          predecessor_id = excluded.predecessor_id,
+          predecessor_kind = excluded.predecessor_kind,
+          improved_round = excluded.improved_round
+        WHERE excluded.distance < ${workingTable}.distance
+        RETURNING node_id, distance
+      `)
+    );
+    frontierCount += rows.length;
+    for (const row of rows) {
+      if (row.node_id !== targetId) continue;
+      const distance = Number(row.distance);
+      if (bestTargetDistance === void 0 || distance < bestTargetDistance) {
+        bestTargetDistance = distance;
+      }
+    }
   }
-  const cte = buildReachableCte({
-    graphId: ctx.graphId,
-    sourceId,
-    edgeKinds: options.edges,
-    maxHops,
-    direction: options.direction ?? "out",
-    cyclePolicy: options.cyclePolicy ?? "prevent",
-    includePath: true,
-    ...resolveTemporalOptions(ctx, options),
-    dialect: ctx.dialect,
-    schema: ctx.schema,
-    ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding }
-  });
-  const pathContainsCheck = sql`NOT (${ctx.dialect.cycleCheck(sql.raw("r.id"), sql.raw("h.path"))})`;
-  const query = sql`${cte}, hit AS (SELECT id, kind, depth, path FROM reachable WHERE id = ${targetId} ORDER BY depth ASC LIMIT 1) SELECT h.id AS hit_id, h.kind AS hit_kind, h.depth AS hit_depth, h.path AS hit_path, r.id AS node_id, r.kind AS node_kind FROM hit h LEFT JOIN reachable r ON ${pathContainsCheck}`;
-  const rows = await ctx.backend.execute(
-    asCompiledRowsSql(query)
+  return { frontierCount, bestTargetDistance };
+}
+async function extractPathFromWorkingTable(context, targetId, maxIterations) {
+  const { operation, workingTable, graphId, runId } = context;
+  const { dialect } = operation.ctx;
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(sql`
+      WITH RECURSIVE chain AS (
+        SELECT best.node_id, best.node_kind, best.distance, best.hops,
+          best.predecessor_id, best.predecessor_kind, 0 AS position
+        FROM (
+          SELECT node_id, node_kind, distance, hops,
+            predecessor_id, predecessor_kind
+          FROM ${workingTable}
+          WHERE graph_id = ${graphId}
+            AND run_id = ${runId}
+            AND node_id = ${targetId}
+          ORDER BY distance ASC, ${dialect.binaryText(sql`node_kind`)}
+          LIMIT 1
+        ) best
+        UNION ALL
+        SELECT w.node_id, w.node_kind, w.distance, w.hops,
+          w.predecessor_id, w.predecessor_kind, c.position + 1
+        FROM chain c
+        JOIN ${workingTable} w
+          ON w.graph_id = ${graphId}
+          AND w.run_id = ${runId}
+          AND w.node_id = c.predecessor_id
+          AND w.node_kind = c.predecessor_kind
+        WHERE c.position <= ${maxIterations}
+      )
+      SELECT node_id, node_kind, distance, hops
+      FROM chain
+      ORDER BY position DESC
+    `)
   );
-  const first = rows[0];
-  if (first === void 0) return void 0;
-  const pathIds = normalizePath(first.hit_path);
-  const kindById = buildKindIndex(rows);
-  const pathNodes = pathIds.map((id) => ({
-    id,
-    kind: kindById.get(id) ?? ""
-  }));
-  return { nodes: pathNodes, depth: Number(first.hit_depth) };
+  const target = rows.at(-1);
+  if (target === void 0) return void 0;
+  return {
+    nodes: rows.map((row) => ({ id: row.node_id, kind: row.node_kind })),
+    depth: Number(target.hops),
+    totalWeight: Number(target.distance)
+  };
 }
-function buildKindIndex(rows) {
-  const map = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (row.node_id !== void 0 && row.node_kind !== void 0) {
-      map.set(row.node_id, row.node_kind);
+async function findWeightedSelfPath(ctx, nodeId, options) {
+  return withInlineIterativeGraphOperation(ctx, options, async (operation) => {
+    await assertValidEdgeWeights(
+      operation,
+      options.weightProperty,
+      options.defaultWeight
+    );
+    const nodes = await fetchVisibleWorkingNodes(operation, [nodeId]);
+    const node = nodes.toSorted(
+      (left, right) => compareNodeIdentity(left, right)
+    )[0];
+    if (node === void 0) return;
+    return { nodes: [node], depth: 0, totalWeight: 0 };
+  });
+}
+async function findWeightedShortestPathInline(ctx, sourceId, targetId, maxIterations, options) {
+  return withInlineIterativeGraphOperation(ctx, options, async (operation) => {
+    await assertValidEdgeWeights(
+      operation,
+      options.weightProperty,
+      options.defaultWeight
+    );
+    const endpoints = await fetchVisibleWorkingNodes(operation, [
+      sourceId,
+      targetId
+    ]);
+    const sources = endpoints.filter((node) => node.id === sourceId);
+    if (sources.length === 0 || !endpoints.some((node) => node.id === targetId)) {
+      return;
     }
+    const settled = new Map(
+      sources.map((source) => [
+        nodeIdentityKey(source),
+        {
+          id: source.id,
+          kind: source.kind,
+          distance: 0,
+          hops: 0,
+          parentKey: void 0
+        }
+      ])
+    );
+    let bestTargetDistance;
+    let frontier = sources;
+    let rounds = 0;
+    while (frontier.length > 0) {
+      if (rounds >= maxIterations) {
+        throw new GraphAlgorithmConvergenceError(
+          WEIGHTED_ALGORITHM_NAME,
+          maxIterations
+        );
+      }
+      rounds++;
+      const candidates = await reduceExpandedWorkingSet(
+        operation,
+        frontier,
+        operation.direction,
+        (existing, expansion) => reduceWeightedCandidate(existing, expansion, settled)
+      );
+      const roundBound = bestTargetDistance;
+      const improved = [];
+      for (const [candidateKey, candidate] of candidates) {
+        const existing = settled.get(candidateKey);
+        if (existing !== void 0 && existing.distance <= candidate.distance) {
+          continue;
+        }
+        if (roundBound !== void 0 && candidate.distance > roundBound) {
+          continue;
+        }
+        settled.set(candidateKey, {
+          id: candidate.id,
+          kind: candidate.kind,
+          distance: candidate.distance,
+          hops: candidate.hops,
+          parentKey: nodeIdentityKey({
+            id: candidate.parentId,
+            kind: candidate.parentKind
+          })
+        });
+        improved.push({ id: candidate.id, kind: candidate.kind });
+        if (candidate.id === targetId && (bestTargetDistance === void 0 || candidate.distance < bestTargetDistance)) {
+          bestTargetDistance = candidate.distance;
+        }
+      }
+      frontier = improved.toSorted(
+        (left, right) => compareNodeIdentity(left, right)
+      );
+    }
+    return buildWeightedPathResult(settled, targetId);
+  });
+}
+function reduceWeightedCandidate(existing, expansion, settled) {
+  const weight = expansion.weight;
+  if (weight === void 0) return existing;
+  const sourceEntry = settled.get(nodeIdentityKey(expansion.source));
+  if (sourceEntry === void 0) return existing;
+  const candidateDistance = sourceEntry.distance + weight;
+  if (existing !== void 0 && (existing.distance < candidateDistance || existing.distance === candidateDistance && compareNodeIdentity(
+    { id: existing.parentId, kind: existing.parentKind },
+    expansion.source
+  ) <= 0)) {
+    return existing;
   }
-  return map;
+  return {
+    id: expansion.target.id,
+    kind: expansion.target.kind,
+    distance: candidateDistance,
+    hops: sourceEntry.hops + 1,
+    parentId: expansion.source.id,
+    parentKind: expansion.source.kind
+  };
 }
-async function fetchNodeKind(ctx, nodeId, options) {
-  const temporalFilter = resolveTemporalFilter(ctx, options);
-  const schema = resolveReadSchema(ctx, options);
-  const query = sql`SELECT id, kind FROM ${schema.nodesTable} WHERE graph_id = ${ctx.graphId} AND id = ${nodeId} AND ${temporalFilter} LIMIT 1`;
-  const rows = await ctx.backend.execute(asCompiledRowsSql(query));
-  const row = rows[0];
-  if (row === void 0) return void 0;
-  return { id: row.id, kind: row.kind };
+function buildWeightedPathResult(visited, targetId) {
+  let target;
+  for (const node of visited.values()) {
+    if (node.id !== targetId) continue;
+    if (target === void 0 || node.distance < target.distance || node.distance === target.distance && compareNodeIdentity(node, target) < 0) {
+      target = node;
+    }
+  }
+  if (target === void 0) return void 0;
+  const reversedNodes = [];
+  let cursor = target;
+  while (cursor !== void 0) {
+    reversedNodes.push({ id: cursor.id, kind: cursor.kind });
+    cursor = cursor.parentKey === void 0 ? void 0 : visited.get(cursor.parentKey);
+  }
+  return {
+    nodes: reversedNodes.toReversed(),
+    depth: target.hops,
+    totalWeight: target.distance
+  };
 }
 
 // src/store/algorithms/index.ts
@@ -10704,7 +12499,7 @@ function assertRecordedAsOfInternalOnly(options, method, allowRecordedAsOf) {
     code: "ALGORITHM_RECORDED_ASOF_INTERNAL_ONLY",
     message: `recordedAsOf is only available through store.asOfRecorded(...).${method}(...).`,
     context: { method },
-    suggestion: "Use store.asOfRecorded(recordedAt).reachable/shortestPath/canReach/neighbors/degree(...) instead of passing recordedAsOf directly."
+    suggestion: "Use store.asOfRecorded(recordedAt) or a recorded StoreView instead of passing recordedAsOf directly."
   });
 }
 function createGraphAlgorithms(params) {
@@ -10733,6 +12528,19 @@ function createGraphAlgorithms(params) {
         options
       );
     },
+    weightedShortestPath(from, to, options) {
+      assertRecordedAsOfInternalOnly(
+        options,
+        "weightedShortestPath",
+        allowRecordedAsOf
+      );
+      return executeWeightedShortestPath(
+        ctx,
+        resolveNodeId(from),
+        resolveNodeId(to),
+        options
+      );
+    },
     reachable(from, options) {
       assertRecordedAsOfInternalOnly(options, "reachable", allowRecordedAsOf);
       return executeReachable(ctx, resolveNodeId(from), options);
@@ -10753,6 +12561,14 @@ function createGraphAlgorithms(params) {
     degree(node, options) {
       assertRecordedAsOfInternalOnly(options, "degree", allowRecordedAsOf);
       return executeDegree(ctx, resolveNodeId(node), options ?? {});
+    },
+    weaklyConnectedComponents(options) {
+      assertRecordedAsOfInternalOnly(
+        options,
+        "weaklyConnectedComponents",
+        allowRecordedAsOf
+      );
+      return executeWeaklyConnectedComponents(ctx, options);
     }
   };
 }
@@ -11614,6 +13430,33 @@ async function ensureFocusedStatusTable(backend, ensureFocused) {
   }
   await backend.bootstrapTables?.();
 }
+async function runBucketedMaterialization(items, options, bucketKey, runOne) {
+  if (options.stopOnError === true) {
+    const results2 = [];
+    for (const item of items) {
+      const entry2 = await runOne(item);
+      results2.push(entry2);
+      if (entry2.status === "failed") break;
+    }
+    return results2;
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const [index, item] of items.entries()) {
+    const key = bucketKey(item);
+    const bucket = buckets.get(key);
+    if (bucket === void 0) buckets.set(key, [[index, item]]);
+    else bucket.push([index, item]);
+  }
+  const results = Array.from({ length: items.length });
+  await Promise.all(
+    [...buckets.values()].map(async (group) => {
+      for (const [index, item] of group) {
+        results[index] = await runOne(item);
+      }
+    })
+  );
+  return results;
+}
 async function runMaterialization(items, options, runOne) {
   if (options.stopOnError === true) {
     const results = [];
@@ -11641,18 +13484,10 @@ function delay(ms) {
 }
 async function materializeIndexes(context, options = {}) {
   const { graph, graphId, backend, schemaVersion } = context;
-  if (backend.executeDdl === void 0) {
-    throw new ConfigurationError(
-      "store.materializeIndexes() requires a backend with `executeDdl` support. The bundled SQLite and Postgres backends provide it; a custom backend without `executeDdl` cannot run index DDL.",
-      { code: "MATERIALIZE_BACKEND_UNSUPPORTED" }
-    );
-  }
-  if (backend.getIndexMaterialization === void 0 || backend.recordIndexMaterialization === void 0) {
-    throw new ConfigurationError(
-      "store.materializeIndexes() requires a backend with index materialization status primitives. The bundled SQLite and Postgres backends provide them; a custom backend must implement `getIndexMaterialization` and `recordIndexMaterialization`.",
-      { code: "MATERIALIZE_BACKEND_UNSUPPORTED" }
-    );
-  }
+  assertBackendSupportsIndexMaterialization(
+    backend,
+    "store.materializeIndexes()"
+  );
   const declared = graph.indexes ?? [];
   const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
   if (kindFilter !== void 0) {
@@ -11699,65 +13534,42 @@ async function materializeIndexes(context, options = {}) {
     backend,
     relationalPhysicalNames
   );
-  const materializeEntry = (declaration) => declaration.entity === "vector" ? materializeVectorIndex(
-    declaration,
-    backend,
-    graphId,
-    schemaVersion,
-    existingByStatusKey,
-    invalidLeftovers
-  ) : materializeRelationalIndex(
-    declaration,
-    backend,
-    dialect,
-    ddlOptions,
-    graphId,
-    schemaVersion,
-    existingByStatusKey,
-    invalidLeftovers
-  );
-  if (options.stopOnError === true) {
-    const results2 = [];
-    for (const declaration of candidates) {
-      const entry2 = await materializeEntry(declaration);
-      results2.push(entry2);
-      if (entry2.status === "failed") break;
+  const reservedSystemNames = resolveSystemIndexNames(backend.tableNames);
+  const materializeEntry = (declaration) => {
+    if (declaration.entity !== "vector" && reservedSystemNames.has(declaration.name)) {
+      return Promise.resolve(
+        entry(
+          declaration,
+          "failed",
+          new Error(
+            `Index name "${declaration.name}" collides with a TypeGraph system index. Rename the declaration \u2014 a same-named CREATE INDEX IF NOT EXISTS would silently no-op against the system index instead of creating the declared one.`
+          )
+        )
+      );
     }
-    await refreshStatisticsAfterCreation(
+    return declaration.entity === "vector" ? materializeVectorIndex(
+      declaration,
       backend,
-      results2,
-      options,
-      ddlOptions.concurrent
+      graphId,
+      schemaVersion,
+      existingByStatusKey,
+      invalidLeftovers
+    ) : materializeRelationalIndex(
+      declaration,
+      backend,
+      dialect,
+      ddlOptions,
+      graphId,
+      schemaVersion,
+      existingByStatusKey,
+      invalidLeftovers
     );
-    return { results: results2 };
-  }
-  const buckets = /* @__PURE__ */ new Map();
-  for (const declaration of candidates) {
-    const key = parallelBucketKey(declaration);
-    const list = buckets.get(key);
-    if (list === void 0) buckets.set(key, [declaration]);
-    else list.push(declaration);
-  }
-  const bucketResults = await Promise.all(
-    [...buckets.values()].map(async (group) => {
-      const out = [];
-      for (const declaration of group) {
-        out.push(await materializeEntry(declaration));
-      }
-      return out;
-    })
-  );
-  const byDeclaration = /* @__PURE__ */ new Map();
-  let bucketIndex = 0;
-  for (const group of buckets.values()) {
-    const entries = bucketResults[bucketIndex];
-    for (const [declarationIndex, declaration] of group.entries()) {
-      byDeclaration.set(declaration, entries[declarationIndex]);
-    }
-    bucketIndex += 1;
-  }
-  const results = candidates.map(
-    (declaration) => byDeclaration.get(declaration)
+  };
+  const results = await runBucketedMaterialization(
+    candidates,
+    options,
+    (declaration) => parallelBucketKey(declaration),
+    (declaration) => materializeEntry(declaration)
   );
   await refreshStatisticsAfterCreation(
     backend,
@@ -11814,7 +13626,7 @@ async function materializeRelationalIndex(declaration, backend, dialect, ddlOpti
       await backend.executeDdl(ddl);
     },
     existingByStatusKey,
-    invalidLeftovers
+    physicalRebuildPreload: invalidLeftovers
   });
 }
 async function materializeVectorIndex(declaration, backend, graphId, schemaVersion, existingByStatusKey, invalidLeftovers) {
@@ -11872,7 +13684,7 @@ async function materializeVectorIndex(declaration, backend, graphId, schemaVersi
     driftLabel: "Vector index",
     run: () => backend.createVectorIndex(params),
     existingByStatusKey,
-    invalidLeftovers
+    physicalRebuildPreload: invalidLeftovers
   });
 }
 async function materializeOne(declaration, backend, graphId, schemaVersion, action) {
@@ -11889,7 +13701,8 @@ async function materializeOne(declaration, backend, graphId, schemaVersion, acti
       statusKey,
       signature,
       driftLabel,
-      isInvalidLeftover: (physicalIndexName) => action.invalidLeftovers.has(physicalIndexName)
+      needsPhysicalRebuild: (physicalIndexName) => action.physicalRebuildPreload.has(physicalIndexName),
+      ...action.rebuildWithoutClaim === void 0 ? {} : { rebuildWithoutClaim: action.rebuildWithoutClaim }
     }
   );
   if (settled !== void 0) return settled;
@@ -11898,7 +13711,9 @@ async function materializeOne(declaration, backend, graphId, schemaVersion, acti
       statusKey,
       signature,
       driftLabel,
-      run
+      run,
+      ...action.freshNeedsPhysicalRebuild === void 0 ? {} : { freshNeedsPhysicalRebuild: action.freshNeedsPhysicalRebuild },
+      ...action.rebuildWithoutClaim === void 0 ? {} : { rebuildWithoutClaim: action.rebuildWithoutClaim }
     });
   }
   try {
@@ -11935,9 +13750,9 @@ async function materializeOne(declaration, backend, graphId, schemaVersion, acti
 }
 async function settleAgainstExisting(existing, declaration, backend, graphId, schemaVersion, action) {
   if (existing?.materializedAt === void 0) return void 0;
-  const { statusKey, signature, driftLabel, isInvalidLeftover } = action;
+  const { statusKey, signature, driftLabel, needsPhysicalRebuild } = action;
   if (existing.signature === signature) {
-    if (declaration.entity !== "vector" && hasIndexBuildClaimProtocol(backend) && await isInvalidLeftover(declaration.name)) {
+    if (declaration.entity !== "vector" && (hasIndexBuildClaimProtocol(backend) || action.rebuildWithoutClaim === true) && await needsPhysicalRebuild(declaration.name)) {
       return void 0;
     }
     return entry(declaration, "alreadyMaterialized");
@@ -12002,7 +13817,8 @@ async function materializeWithClaim(declaration, backend, graphId, schemaVersion
           driftLabel,
           // Post-claim the bulk preload is stale (we may have waited on
           // another builder's claim), so re-check this index fresh.
-          isInvalidLeftover: (physicalIndexName) => hasInvalidIndexLeftover(backend, physicalIndexName)
+          needsPhysicalRebuild: action.freshNeedsPhysicalRebuild ?? ((physicalIndexName) => hasInvalidIndexLeftover(backend, physicalIndexName)),
+          ...action.rebuildWithoutClaim === void 0 ? {} : { rebuildWithoutClaim: action.rebuildWithoutClaim }
         }
       );
       if (settled !== void 0) return settled;
@@ -12063,6 +13879,7 @@ async function hasInvalidIndexLeftover(backend, physicalIndexName) {
       FROM pg_class c
       JOIN pg_index i ON i.indexrelid = c.oid
       WHERE c.relname = ${physicalIndexName}
+        AND pg_catalog.pg_table_is_visible(c.oid)
     `)
   );
   return rows[0]?.invalid === true;
@@ -12071,17 +13888,64 @@ async function preloadInvalidIndexLeftovers(backend, physicalIndexNames) {
   if (backend.dialect !== "postgres" || physicalIndexNames.length === 0) {
     return /* @__PURE__ */ new Set();
   }
+  const { invalid } = await preloadPhysicalIndexStates(
+    backend,
+    physicalIndexNames
+  );
+  return invalid;
+}
+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));
+  }
   const rows = await backend.execute(
     asCompiledRowsSql(sql`
-      SELECT c.relname AS name
-      FROM pg_class c
-      JOIN pg_index i ON i.indexrelid = c.oid
-      WHERE c.relname IN (${sqlValueList(physicalIndexNames)})
-        AND NOT i.indisvalid
+      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 };
+  }
+  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;
   if (!await hasInvalidIndexLeftover(backend, physicalIndexName)) return;
@@ -12140,6 +14004,121 @@ function buildAttempt(args) {
     error: args.error?.message
   };
 }
+function backendSupportsIndexMaterialization(backend) {
+  return backend.executeDdl !== void 0 && backend.getIndexMaterialization !== void 0 && backend.recordIndexMaterialization !== void 0;
+}
+function assertBackendSupportsIndexMaterialization(backend, surface) {
+  if (backendSupportsIndexMaterialization(backend)) return;
+  throw new ConfigurationError(
+    `${surface} requires a backend with \`executeDdl\` and the index materialization status primitives (\`getIndexMaterialization\`, \`recordIndexMaterialization\`). The bundled SQLite and Postgres backends provide them; a custom backend must implement all three.`,
+    { code: "MATERIALIZE_BACKEND_UNSUPPORTED" }
+  );
+}
+async function materializeSystemIndexes(context, options = {}) {
+  const { backend, graphId, schemaVersion } = context;
+  assertBackendSupportsIndexMaterialization(
+    backend,
+    "store.materializeSystemIndexes()"
+  );
+  await ensureFocusedStatusTable(
+    backend,
+    backend.ensureIndexMaterializationsTable
+  );
+  const concurrent = backend.dialect === "postgres";
+  const candidates = SYSTEM_INDEX_DECLARATIONS.map((declaration) => {
+    const physicalTable = resolveSystemIndexTableName(
+      declaration.table,
+      backend.tableNames
+    );
+    return {
+      declaration,
+      physicalTable,
+      name: systemIndexName(physicalTable, declaration.suffix)
+    };
+  });
+  const statusKeys = candidates.map((candidate) => candidate.name);
+  const targetTables = [
+    ...new Set(candidates.map((candidate) => candidate.physicalTable))
+  ];
+  const [existingByStatusKey, physicalStates, existingTables] = await Promise.all([
+    preloadMaterializations(backend, statusKeys),
+    preloadPhysicalIndexStates(backend, statusKeys),
+    preloadExistingTables(backend, targetTables)
+  ]);
+  const { valid: physicallyPresent } = physicalStates;
+  const physicalRebuildPreload = new Set(
+    statusKeys.filter((name) => !physicallyPresent.has(name))
+  );
+  const materializeEntry = async (candidate) => {
+    const identity = {
+      name: candidate.name,
+      entity: "system",
+      kind: candidate.declaration.table
+    };
+    if (!existingTables.has(candidate.physicalTable)) {
+      return {
+        indexName: candidate.name,
+        entity: "system",
+        kind: candidate.declaration.table,
+        status: "skipped",
+        reason: `Relation "${candidate.physicalTable}" does not exist in this database`
+      };
+    }
+    const existing = existingByStatusKey.get(candidate.name);
+    if (existing !== void 0 && existing.entity !== "system") {
+      return entry(
+        identity,
+        "failed",
+        new Error(
+          `System index name "${candidate.name}" is already recorded by a ${existing.entity} index declaration (graph "${existing.graphId}"). Rename the graph-declared index \u2014 "typegraph_"-prefixed names belong to TypeGraph's system indexes.`
+        )
+      );
+    }
+    if (existing === void 0 && physicallyPresent.has(candidate.name)) {
+      return entry(identity, "alreadyMaterialized");
+    }
+    const signature = await computeSystemIndexSignature(
+      backend.dialect,
+      candidate.physicalTable,
+      candidate.declaration
+    );
+    const ddl = generateSystemIndexDDL(
+      candidate.declaration,
+      candidate.physicalTable,
+      { concurrent }
+    );
+    return materializeOne(identity, backend, graphId, schemaVersion, {
+      statusKey: candidate.name,
+      signature,
+      driftLabel: "System index",
+      run: () => backend.executeDdl(ddl),
+      existingByStatusKey,
+      physicalRebuildPreload,
+      freshNeedsPhysicalRebuild: async (physicalIndexName) => {
+        const fresh = await preloadPhysicalIndexStates(backend, [
+          physicalIndexName
+        ]);
+        return !fresh.valid.has(physicalIndexName);
+      },
+      rebuildWithoutClaim: true
+    });
+  };
+  const results = await runBucketedMaterialization(
+    candidates,
+    options,
+    (candidate) => candidate.physicalTable,
+    (candidate) => materializeEntry(candidate)
+  );
+  await refreshStatisticsAfterCreation(backend, results, options, concurrent);
+  return { results };
+}
+async function computeSystemIndexSignature(dialect, targetTableName, declaration) {
+  const json = JSON.stringify(
+    { dialect, targetTableName, declaration },
+    sortedReplacer
+  );
+  return sha256Hex(json, 16);
+}
 async function computeIndexSignature(dialect, targetTableName, declaration) {
   const hashable = {
     dialect,
@@ -12368,13 +14347,13 @@ function buildEmbeddingTableCleanup(ctx, row) {
     const slots = await resolveRemovedKindEmbeddingSlots(ctx.backend, row);
     await Promise.all(
       slots.map(
-        (slot) => dropVectorSlotStorage(vectorStrategy, executeDdl, slot)
+        (slot) => dropVectorSlotStorage(ctx.backend, vectorStrategy, executeDdl, slot)
       )
     );
   })();
   return [cleanup];
 }
-async function dropVectorSlotStorage(strategy, executeDdl, slot) {
+async function dropVectorSlotStorage(backend, strategy, executeDdl, slot) {
   try {
     for (const ddl of strategy.buildDropStorage(slot)) {
       await executeDdl(ddl);
@@ -12382,6 +14361,7 @@ async function dropVectorSlotStorage(strategy, executeDdl, slot) {
   } catch (error) {
     if (!isMissingTableError(error)) throw error;
   }
+  await backend.deleteVectorSlotContribution?.(slot);
 }
 async function resolveRemovedKindEmbeddingSlots(backend, row) {
   const priorVersion = row.schemaVersion - 1;
@@ -12457,7 +14437,12 @@ async function reclaimRemovedVectorFieldTables(context) {
   const results = [];
   for (const field2 of orphans) {
     try {
-      await dropVectorSlotStorage(vectorStrategy, executeDdl, field2.slot);
+      await dropVectorSlotStorage(
+        backend,
+        vectorStrategy,
+        executeDdl,
+        field2.slot
+      );
       results.push({
         kind: field2.kind,
         fieldPath: field2.fieldPath,
@@ -13841,9 +15826,11 @@ var Store = class _Store {
    * Tier 1 graph algorithms: shortest path, reachability, neighborhoods, and
    * degree centrality.
    *
-   * Each call compiles to a single recursive-CTE query against the backend.
-   * The facade is built lazily on first access and cached for the lifetime
-   * of the store.
+   * Traversal calls use the iterative graph-operation substrate: a set-based
+   * breadth-first frontier backed by a temporary working table, or a chunked
+   * inline relation when the backend cannot pin a transactional connection.
+   * `degree` uses a single count query. The facade is built lazily on first
+   * access and cached for the lifetime of the store.
    *
    * @example
    * ```typescript
@@ -14607,10 +16594,10 @@ var Store = class _Store {
     }) : backendOptions;
     try {
       const result = await this.#backend.transaction(
-        async (txBackend, sql17) => invoke(
+        async (txBackend, sql19) => invoke(
           this.#buildTransactionContext(
             txBackend,
-            sql17,
+            sql19,
             runHooks,
             receiptRecorder
           )
@@ -14728,7 +16715,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, sql17, runHooks = this.#immediateHookRunner(), receiptRecorder) {
+  #buildTransactionContext(txBackend, sql19, runHooks = this.#immediateHookRunner(), receiptRecorder) {
     const txNodeOperations = {
       ...this.#buildNodeOperations(this.#createNodeOperationContext(runHooks)),
       createQuery: () => this.#createQueryForBackend(txBackend),
@@ -14762,7 +16749,7 @@ var Store = class _Store {
       ));
     }
     const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
-    const sqlAvailability = this.#captureEnabled ? "history" : this.#revisionTrackingEnabled ? "revisionTracking" : sql17 === void 0 ? "unavailable" : "available";
+    const sqlAvailability = this.#captureEnabled ? "history" : this.#revisionTrackingEnabled ? "revisionTracking" : sql19 === void 0 ? "unavailable" : "available";
     const base = {
       nodes,
       edges,
@@ -14771,9 +16758,9 @@ var Store = class _Store {
       getNodeCollection,
       runNodeOperationHooks
     };
-    const withSql = sql17 === void 0 ? base : {
+    const withSql = sql19 === void 0 ? base : {
       ...base,
-      sql: this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql17
+      sql: this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql19
     };
     return receiptRecorder === void 0 ? withSql : this.#attachMeasure(withSql);
   }
@@ -14964,6 +16951,7 @@ var Store = class _Store {
       merged,
       activeRow.version
     );
+    await materializeVectorContributions(this.#backend, merged);
     const evolved = this.#cloneWithGraph(
       merged,
       options?.ref,
@@ -15066,6 +17054,29 @@ var Store = class _Store {
       options ?? {}
     );
   }
+  /**
+   * Materializes TypeGraph's own base-relation indexes
+   * (`SYSTEM_INDEX_DECLARATIONS`) against the live database.
+   *
+   * Bootstrap DDL runs only on first boot, so a system index shipped in a
+   * newer library version never reaches an already-initialized database on
+   * its own. `createStoreWithSchema` runs this automatically; deployments
+   * that boot with plain `createStore` / `createVerifiedStore` (zero-DDL by
+   * contract) adopt new system indexes by calling this once under a role
+   * that may run DDL. Same status-table, drift-signature, and Postgres
+   * `CREATE INDEX CONCURRENTLY` claim semantics as `materializeIndexes`.
+   */
+  async materializeSystemIndexes(options) {
+    const { activeRow } = await this.#loadCaughtUp("materialize");
+    return materializeSystemIndexes(
+      {
+        backend: this.#baseBackend,
+        graphId: this.graphId,
+        schemaVersion: activeRow.version
+      },
+      options ?? {}
+    );
+  }
   /**
    * Recreate a vector field's per-field storage at its current declared
    * dimension, then optionally re-embed existing rows.
@@ -15122,10 +17133,14 @@ var Store = class _Store {
     for (const ddl of strategy.buildDropStorage(slot)) {
       await backend.executeDdl(ddl);
     }
-    for (const contribution of strategy.ownedTables(slot)) {
-      for (const ddl of contribution.createDdl) {
-        await backend.executeDdl(ddl);
+    if (backend.ensureVectorSlotContribution === void 0) {
+      for (const contribution of strategy.ownedTables(slot)) {
+        for (const ddl of contribution.createDdl) {
+          await backend.executeDdl(ddl);
+        }
       }
+    } else {
+      await backend.ensureVectorSlotContribution(slot, { force: true });
     }
     const declaredIndexMaterializes = declaration.indexType !== "none" && backend.capabilities.vector?.indexTypes.includes(
       declaration.indexType
@@ -15607,6 +17622,20 @@ async function materializeRuntimeContributions(backend, graphId) {
   }
   await backend.ensureFulltextTable?.(graphId);
 }
+async function materializeVectorContributions(backend, graph) {
+  if (backend.capabilities.vector?.supported !== true) return;
+  const slots = resolveGraphVectorSlots(graph);
+  const ensureVectorSlotContributions = backend.ensureVectorSlotContributions;
+  if (ensureVectorSlotContributions !== void 0) {
+    await ensureVectorSlotContributions(slots, { onDrift: "skip" });
+    return;
+  }
+  const ensureVectorSlotContribution = backend.ensureVectorSlotContribution;
+  if (ensureVectorSlotContribution === void 0) return;
+  for (const slot of slots) {
+    await ensureVectorSlotContribution(slot, { onDrift: "skip" });
+  }
+}
 async function createStoreWithSchema(graph, backend, options) {
   const {
     graph: merged,
@@ -15618,6 +17647,10 @@ async function createStoreWithSchema(graph, backend, options) {
     preloaded: { activeRow, storedSchema }
   });
   await materializeRuntimeContributions(backend, merged.id);
+  await materializeVectorContributions(backend, merged);
+  if (options?.systemIndexes !== "skip") {
+    await materializeSystemIndexesOnBoot(backend, merged.id, result);
+  }
   const store = new Store(
     merged,
     backend,
@@ -15626,6 +17659,30 @@ async function createStoreWithSchema(graph, backend, options) {
   );
   return [store, result];
 }
+async function materializeSystemIndexesOnBoot(backend, graphId, result) {
+  if (result.status === "breaking") return;
+  if (!backendSupportsIndexMaterialization(backend)) return;
+  const schemaVersion = result.status === "migrated" ? result.toVersion : result.version;
+  try {
+    const { results } = await materializeSystemIndexes(
+      { backend: asRawBackend(backend), graphId, schemaVersion },
+      {}
+    );
+    const failed = results.filter(
+      (entryResult) => entryResult.status === "failed"
+    );
+    if (failed.length === 0) return;
+    console.warn(
+      `[typegraph] ${String(failed.length)} system index(es) failed to materialize at boot (${failed.map((entryResult) => entryResult.indexName).join(", ")}); the store is usable but the affected access paths fall back to scans. Retry via store.materializeSystemIndexes().`,
+      failed[0]?.error
+    );
+  } catch (error) {
+    console.warn(
+      "[typegraph] system-index materialization failed at boot; the store is usable but new system indexes were not adopted. Retry via store.materializeSystemIndexes().",
+      error
+    );
+  }
+}
 async function createVerifiedStore(graph, backend, options) {
   const {
     graph: merged,
@@ -15642,5 +17699,5 @@ async function createVerifiedStore(graph, backend, options) {
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-5DIPR3L3.js.map
-//# sourceMappingURL=chunk-5DIPR3L3.js.map
+//# sourceMappingURL=chunk-GA4TT3DH.js.map
+//# sourceMappingURL=chunk-GA4TT3DH.js.map