@nicia-ai/typegraph 0.35.0 → 0.37.0

package/dist/{chunk-UES55P7G.js → chunk-552KNYQJ.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-55MZDDZV.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-QNKSQTKQ.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, serializeIndexDeclaration } from './chunk-K3PPLHY7.js';
-import { sortedReplacer, canonicalEqual } from './chunk-UR7W5YQK.js';
-import { isKnownKind, validateEdgeProps } from './chunk-QWEUYILR.js';
-import { generateIndexDDL } from './chunk-UZV3AZKF.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-OR5ZA5WP.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-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-QOTI55H7.js';
-import { validateProjectionField } from './chunk-RGPG7EOJ.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-CZQ3FO2Q.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-JBTOYDMN.js';
-import { withRecordedRelationsPrecondition, nowIso, validateOptionalCanonicalIsoDate, isMissingTableError } from './chunk-I7ZUZKFD.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-MP2JQKSG.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(
@@ -10512,6 +10791,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,65 +10850,982 @@ 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)
-  );
-  return rows.map((row) => ({
-    id: row.id,
-    kind: row.kind,
-    depth: Number(row.depth)
-  }));
+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 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;
+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 executeNeighbors(ctx, sourceId, options) {
-  const depth = resolveMaxHops(options.depth, DEFAULT_NEIGHBOR_DEPTH, "depth");
+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 compareStrings(left.id, right.id) || compareStrings(left.kind, right.kind);
+}
+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})`;
+  switch (direction) {
+    case "out": {
+      return sql`${workingCte} ${compileDirectionalExpansion(operation, sql`working_set`, sql`TRUE`, edgeKinds, "from_id", "from_kind", "to_id", "to_kind")}`;
+    }
+    case "in": {
+      return sql`${workingCte} ${compileDirectionalExpansion(operation, sql`working_set`, sql`TRUE`, edgeKinds, "to_id", "to_kind", "from_id", "from_kind")}`;
+    }
+    case "both": {
+      const outgoing = compileDirectionalExpansion(
+        operation,
+        sql`working_set`,
+        sql`TRUE`,
+        edgeKinds,
+        "from_id",
+        "from_kind",
+        "to_id",
+        "to_kind"
+      );
+      const incoming = compileDirectionalExpansion(
+        operation,
+        sql`working_set`,
+        sql`TRUE`,
+        edgeKinds,
+        "to_id",
+        "to_kind",
+        "from_id",
+        "from_kind"
+      );
+      return sql`${workingCte} ${outgoing} UNION ALL ${incoming}`;
+    }
+  }
+}
+function compileWorkingTableExpansion(operation, workingTable, sourceFilter, direction, edgeKinds) {
+  switch (direction) {
+    case "out": {
+      return compileDirectionalExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "from_id",
+        "from_kind",
+        "to_id",
+        "to_kind"
+      );
+    }
+    case "in": {
+      return compileDirectionalExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "to_id",
+        "to_kind",
+        "from_id",
+        "from_kind"
+      );
+    }
+    case "both": {
+      const outgoing = compileDirectionalExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "from_id",
+        "from_kind",
+        "to_id",
+        "to_kind"
+      );
+      const incoming = compileDirectionalExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "to_id",
+        "to_kind",
+        "from_id",
+        "from_kind"
+      );
+      return sql`${outgoing} UNION ALL ${incoming}`;
+    }
+  }
+}
+function compileWorkingTableEdgeExpansion(operation, workingTable, sourceFilter, direction, edgeKinds) {
+  switch (direction) {
+    case "out": {
+      return compileDirectionalEdgeExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "from_id",
+        "from_kind",
+        "to_id",
+        "to_kind"
+      );
+    }
+    case "in": {
+      return compileDirectionalEdgeExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "to_id",
+        "to_kind",
+        "from_id",
+        "from_kind"
+      );
+    }
+    case "both": {
+      const outgoing = compileDirectionalEdgeExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "from_id",
+        "from_kind",
+        "to_id",
+        "to_kind"
+      );
+      const incoming = compileDirectionalEdgeExpansion(
+        operation,
+        workingTable,
+        sourceFilter,
+        edgeKinds,
+        "to_id",
+        "to_kind",
+        "from_id",
+        "from_kind"
+      );
+      return sql`${outgoing} UNION ALL ${incoming}`;
+    }
+  }
+}
+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) {
+  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), edgeKinds);
+  const weightColumn = operation.weightExpression === void 0 ? sql`` : sql`, ${operation.weightExpression} AS weight`;
+  return sql`SELECT w.node_id AS source_id, w.node_kind AS source_kind, 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.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;
+  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 expanded.target_kind, expanded.target_id
+              ORDER BY expanded.source_id, expanded.source_kind
+            ) 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}
+      ORDER BY side, depth, node_id, node_kind
+    `)
+  );
+}
+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, depth: active.depth + opposite.depth };
+    if (best === void 0 || meeting.depth < best.depth || meeting.depth === best.depth && compareStrings(meeting.key, best.key) < 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,
@@ -10632,9 +11838,14 @@ async function executeNeighbors(ctx, sourceId, options) {
     ...options.recordedAsOf !== void 0 && {
       recordedAsOf: options.recordedAsOf
     },
+    ...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(
@@ -10642,56 +11853,696 @@ async function executeShortestPath(ctx, sourceId, targetId, options) {
     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",
+    ...options.temporalMode === void 0 ? {} : { temporalMode: options.temporalMode },
+    ...options.asOf === void 0 ? {} : { asOf: options.asOf },
+    ...options.recordedAsOf === void 0 ? {} : { recordedAsOf: options.recordedAsOf },
+    ...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,
+      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)
+    SELECT
+      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind
+    FROM ${operation.schema.nodesTable} n
+    WHERE n.graph_id = ${graphId}
+      AND ${nodeKindFilter}
+      AND ${operation.nodeTemporalFilter}
+  `);
+  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) {
+  await resetNextLabels(context);
+  for (const edgeKinds of context.operation.edgeKindChunks) {
+    await propagateChunkLabels(context, edgeKinds);
+  }
+  const changedRows = await applyNextLabels(context);
+  return {
+    changedCount: changedRows.length,
+    workingTableSize: state.workingTableSize
+  };
+}
+async function resetNextLabels(context) {
+  await context.executeTemporary(sql`
+    UPDATE ${context.workingTable}
+    SET next_label_id = label_id, next_label_kind = label_kind
+    WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+  `);
+}
+async function propagateChunkLabels(context, edgeKinds) {
+  const { operation, workingTable, graphId, runId } = context;
+  const expansion = compileWorkingTableEdgeExpansion(
+    operation,
+    workingTable,
+    sql`w.graph_id = ${graphId} AND w.run_id = ${runId}`,
+    "both",
+    edgeKinds
+  );
+  const 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,
+        source.label_id,
+        source.label_kind
+      FROM (${expansion}) expanded
+      JOIN ${workingTable} source
+        ON source.graph_id = ${graphId}
+        AND source.run_id = ${runId}
+        AND source.node_id = expanded.source_id
+        AND source.node_kind = expanded.source_kind
+      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) {
+  return context.backend.execute(
+    asCompiledRowsSql(sql`
+      UPDATE ${context.workingTable}
+      SET label_id = next_label_id, label_kind = next_label_kind
+      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)
+  })).toSorted(compareMemberships);
+}
+function compareMemberships(left, right) {
+  return compareCodePoints(left.componentId, right.componentId) || compareCodePoints(left.componentKind, right.componentKind) || compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
+}
+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) {
-    const source = await fetchNodeKind(ctx, sourceId, options);
-    if (source === void 0) return void 0;
-    return { nodes: [source], depth: 0 };
+    return findWeightedSelfPath(ctx, sourceId, traversalOptions);
   }
-  const cte = buildReachableCte({
-    graphId: ctx.graphId,
+  if (supportsTemporaryIteration(ctx)) {
+    return findWeightedShortestPathInWorkingTable(
+      ctx,
+      sourceId,
+      targetId,
+      maxIterations,
+      traversalOptions
+    );
+  }
+  return findWeightedShortestPathInline(
+    ctx,
     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 }
+    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 }
   });
-  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)
+}
+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);
+}
+function compareNodeIdentityCodePoints(left, right) {
+  return compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
+}
+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
+      };
+    },
+    hasConverged(state) {
+      return state.frontierCount === 0;
+    },
+    async extractResult(context) {
+      return extractPathFromWorkingTable(context, targetId, maxIterations);
+    }
+  });
+}
+function frontierIndexIdentifier(context) {
+  return sql.identifier(
+    `typegraph_iterative_${context.runId.replaceAll("-", "_")}_frontier`
   );
-  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) };
 }
-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 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
+    `)
+  );
+  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;
+      }
     }
   }
-  return map;
+  return { frontierCount, bestTargetDistance };
 }
-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 };
+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 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)
+  };
+}
+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) => compareNodeIdentityCodePoints(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) => compareNodeIdentityCodePoints(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 && compareNodeIdentityCodePoints(
+    { id: existing.parentId, kind: existing.parentKind },
+    expansion.source
+  ) <= 0)) {
+    return existing;
+  }
+  return {
+    id: expansion.target.id,
+    kind: expansion.target.kind,
+    distance: candidateDistance,
+    hops: sourceEntry.hops + 1,
+    parentId: expansion.source.id,
+    parentKind: expansion.source.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 && compareNodeIdentityCodePoints(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 +12555,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 +12584,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 +12617,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);
     }
   };
 }
@@ -10955,32 +12827,70 @@ function createEdgeCollection(config) {
       const upsertAll = async (target) => {
         const ids = items.map((item) => item.id);
         const existingMap = await getEdgeRowsByIds(target, graphId, ids);
+        const results2 = Array.from({ length: items.length });
         const toCreate = [];
         const toUpdate = [];
+        const pending = /* @__PURE__ */ new Map();
+        const deferred = [];
         let itemIndex = 0;
         for (const item of items) {
-          const existing = existingMap.get(item.id);
-          if (existing) {
-            toUpdate.push({
+          const pendingEntry = pending.get(item.id);
+          const original = existingMap.get(item.id);
+          const inputProps = item.props ?? {};
+          if (pendingEntry === void 0 && original === void 0) {
+            toCreate.push({
               index: itemIndex,
-              input: buildUpdateEdgeInput(item.id, item.props ?? {}, item),
-              clearDeleted: existing.deleted_at !== void 0
+              input: buildCreateEdgeInput(
+                kind,
+                item.from,
+                item.to,
+                inputProps,
+                item
+              )
             });
+            itemIndex++;
+            continue;
+          }
+          const deletedAt = pendingEntry === void 0 ? original.deleted_at : void 0;
+          let dirty;
+          if (config.upsertDirtyCheck !== void 0) {
+            const currentProps = pendingEntry?.props ?? rowPropsToObject(original.props);
+            try {
+              dirty = config.upsertDirtyCheck(
+                original?.kind ?? kind,
+                item.id,
+                currentProps,
+                inputProps
+              );
+            } catch {
+              dirty = void 0;
+            }
+          }
+          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
+          if (coalesce) {
+            if (pendingEntry === void 0) {
+              results2[itemIndex] = narrowEdge(rowToEdge2(original));
+            } else {
+              deferred.push({
+                index: itemIndex,
+                sourceIndex: pendingEntry.sourceIndex
+              });
+            }
           } else {
-            toCreate.push({
+            toUpdate.push({
               index: itemIndex,
-              input: buildCreateEdgeInput(
-                kind,
-                item.from,
-                item.to,
-                item.props ?? {},
-                item
-              )
+              input: buildUpdateEdgeInput(item.id, inputProps, item),
+              clearDeleted: deletedAt !== void 0
             });
+            if (dirty !== void 0) {
+              pending.set(item.id, {
+                props: dirty.validatedProps,
+                sourceIndex: itemIndex
+              });
+            }
           }
           itemIndex++;
         }
-        const results2 = Array.from({ length: items.length });
         if (toCreate.length > 0) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeEdgeCreateBatch2(createInputs, target);
@@ -10994,10 +12904,13 @@ function createEdgeCollection(config) {
           });
           results2[entry2.index] = narrowEdge(result);
         }
-        return results2;
+        for (const { index, sourceIndex } of deferred) {
+          results2[index] = results2[sourceIndex];
+        }
+        return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const results = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
-      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
+      const { results, mutations } = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(mutations);
       return results;
     },
     async bulkInsert(items) {
@@ -11091,6 +13004,18 @@ function createEdgeCollection(config) {
   };
 }
 
+// src/store/collections/coalesce.ts
+function shouldCoalesceUpsert(existing, options, runDirtyCheck) {
+  if (runDirtyCheck === void 0 || existing.deleted_at !== void 0 || options?.validFrom !== void 0 || options?.validTo !== void 0) {
+    return false;
+  }
+  try {
+    return runDirtyCheck().unchanged;
+  } catch {
+    return false;
+  }
+}
+
 // src/store/collections/node-collection.ts
 function narrowNode(node) {
   return node;
@@ -11218,11 +13143,19 @@ function createNodeCollection(config) {
     async upsertByIdFromRecord(id, data, options) {
       const existing = await backend.getNode(graphId, kind, id);
       if (existing) {
-        const clearDeleted = existing.deleted_at !== void 0;
+        const runDirtyCheck = config.upsertDirtyCheck && (() => config.upsertDirtyCheck(
+          kind,
+          id,
+          rowPropsToObject(existing.props),
+          data
+        ));
+        if (shouldCoalesceUpsert(existing, options, runDirtyCheck)) {
+          return narrowNode(rowToNode2(existing));
+        }
         const result2 = await executeNodeUpdate2(
           buildUpdateInput(kind, id, data, options),
           backend,
-          { clearDeleted }
+          { clearDeleted: existing.deleted_at !== void 0 }
         );
         return narrowNode(result2);
       }
@@ -11263,26 +13196,63 @@ function createNodeCollection(config) {
             existingMap.set(row.id, row);
           }
         }
+        const results2 = Array.from({ length: items.length });
         const toCreate = [];
         const toUpdate = [];
+        const pending = /* @__PURE__ */ new Map();
+        const deferred = [];
         let itemIndex = 0;
         for (const item of items) {
-          const existing = existingMap.get(item.id);
-          if (existing) {
-            toUpdate.push({
+          const pendingEntry = pending.get(item.id);
+          const original = existingMap.get(item.id);
+          if (pendingEntry === void 0 && original === void 0) {
+            toCreate.push({
               index: itemIndex,
-              input: buildUpdateInput(kind, item.id, item.props, item),
-              clearDeleted: existing.deleted_at !== void 0
+              input: buildCreateInput(kind, item.props, item)
             });
+            itemIndex++;
+            continue;
+          }
+          const deletedAt = pendingEntry === void 0 ? original.deleted_at : void 0;
+          let dirty;
+          if (config.upsertDirtyCheck !== void 0) {
+            const currentProps = pendingEntry?.props ?? rowPropsToObject(original.props);
+            try {
+              dirty = config.upsertDirtyCheck(
+                kind,
+                item.id,
+                currentProps,
+                item.props
+              );
+            } catch {
+              dirty = void 0;
+            }
+          }
+          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
+          if (coalesce) {
+            if (pendingEntry === void 0) {
+              results2[itemIndex] = narrowNode(rowToNode2(original));
+            } else {
+              deferred.push({
+                index: itemIndex,
+                sourceIndex: pendingEntry.sourceIndex
+              });
+            }
           } else {
-            toCreate.push({
+            toUpdate.push({
               index: itemIndex,
-              input: buildCreateInput(kind, item.props, item)
+              input: buildUpdateInput(kind, item.id, item.props, item),
+              clearDeleted: deletedAt !== void 0
             });
+            if (dirty !== void 0) {
+              pending.set(item.id, {
+                props: dirty.validatedProps,
+                sourceIndex: itemIndex
+              });
+            }
           }
           itemIndex++;
         }
-        const results2 = Array.from({ length: items.length });
         if (toCreate.length > 0) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeNodeCreateBatch2(createInputs, target);
@@ -11296,10 +13266,13 @@ function createNodeCollection(config) {
           });
           results2[entry2.index] = narrowNode(result);
         }
-        return results2;
+        for (const { index, sourceIndex } of deferred) {
+          results2[index] = results2[sourceIndex];
+        }
+        return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const results = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
-      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
+      const { results, mutations } = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(mutations);
       return results;
     },
     async bulkInsert(items) {
@@ -11513,6 +13486,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 = [];
@@ -11540,18 +13540,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) {
@@ -11598,65 +13590,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,
@@ -11713,7 +13682,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) {
@@ -11771,7 +13740,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) {
@@ -11788,7 +13757,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;
@@ -11797,7 +13767,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 {
@@ -11834,9 +13806,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");
@@ -11901,7 +13873,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;
@@ -11962,6 +13935,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;
@@ -11970,17 +13944,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;
@@ -12039,6 +14060,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,
@@ -12267,13 +14403,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);
@@ -12281,6 +14417,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;
@@ -12356,7 +14493,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,
@@ -12697,21 +14839,45 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
     return rows.map((row) => rowToEdge(row));
   });
 }
+function computeEdgeUpdate(ctx, kind, id, existingProps, inputProps) {
+  const registration = getEdgeRegistration(ctx.graph, kind);
+  return validateEdgeProps(
+    registration.type.schema,
+    { ...existingProps, ...inputProps },
+    { kind, operation: "update", id }
+  );
+}
+function resolveEdgeUpdateProps(ctx, existing, inputProps) {
+  const existingProps = rowPropsToObject(existing.props);
+  const validatedProps = computeEdgeUpdate(
+    ctx,
+    existing.kind,
+    existing.id,
+    existingProps,
+    inputProps
+  );
+  return { existingProps, validatedProps };
+}
+function edgeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
+  const validatedProps = computeEdgeUpdate(
+    ctx,
+    kind,
+    id,
+    existingProps,
+    inputProps
+  );
+  return {
+    validatedProps,
+    unchanged: canonicalEqual(validatedProps, existingProps)
+  };
+}
 async function performEdgeUpdate(ctx, input, target, options) {
   const id = input.id;
   const existing = await target.getEdge(ctx.graphId, id);
   if (!existing || !options?.clearDeleted && existing.deleted_at) {
     throw new EdgeNotFoundError("unknown", id);
   }
-  const registration = getEdgeRegistration(ctx.graph, existing.kind);
-  const edgeKind = registration.type;
-  const existingProps = rowPropsToObject(existing.props);
-  const mergedProps = { ...existingProps, ...input.props };
-  const validatedProps = validateEdgeProps(edgeKind.schema, mergedProps, {
-    kind: existing.kind,
-    operation: "update",
-    id
-  });
+  const { validatedProps } = resolveEdgeUpdateProps(ctx, existing, input.props);
   const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
   const updateParams = {
     graphId: ctx.graphId,
@@ -13369,27 +15535,48 @@ function increment(counts, kind, count2) {
   counts[kind] = (counts[kind] ?? 0) + count2;
 }
 function createTransactionReceiptRecorder() {
-  const nodes = createCountBucket();
-  const edges = createCountBucket();
-  let total = 0;
+  const counters = {
+    nodes: createCountBucket(),
+    edges: createCountBucket(),
+    total: 0
+  };
+  let sealed = false;
   return {
     recordNode(kind, count2) {
-      increment(nodes, kind, count2);
-      total += count2;
+      increment(counters.nodes, kind, count2);
+      counters.total += count2;
     },
     recordEdge(kind, count2) {
-      increment(edges, kind, count2);
-      total += count2;
+      increment(counters.edges, kind, count2);
+      counters.total += count2;
     },
     snapshot(recorded) {
       return Object.freeze({
         writes: Object.freeze({
-          nodes: Object.freeze(Object.assign(createCountBucket(), nodes)),
-          edges: Object.freeze(Object.assign(createCountBucket(), edges)),
-          total
+          nodes: Object.freeze(
+            Object.assign(createCountBucket(), counters.nodes)
+          ),
+          edges: Object.freeze(
+            Object.assign(createCountBucket(), counters.edges)
+          ),
+          total: counters.total
         }),
         ...recorded === void 0 ? {} : { recorded }
       });
+    },
+    seal() {
+      sealed = true;
+    },
+    assertWritable() {
+      if (sealed) {
+        throw new ConfigurationError(
+          "Transaction context is sealed: a write happened through the receipt-tracked collections after the transaction callback returned.",
+          {},
+          {
+            suggestion: "Perform all writes inside the transactionWithReceipt / withRecordedTransaction callback; do not reuse the transaction context after it returns."
+          }
+        );
+      }
     }
   };
 }
@@ -13423,7 +15610,7 @@ function memoizedProxyGet(target, shouldWrap, wrap) {
     }
   });
 }
-function wrapWriteCollection(collection, kind, surface, record) {
+function wrapWriteCollection(collection, kind, surface, record, assertWritable) {
   return memoizedProxyGet(
     collection,
     (property) => surface.methodNames.has(property),
@@ -13431,6 +15618,7 @@ function wrapWriteCollection(collection, kind, surface, record) {
       if (!isWrappedMethod(value)) return value;
       const method = property;
       const wrapped = async (...args) => {
+        assertWritable();
         const count2 = surface.counters[method](args);
         const result = await Reflect.apply(value, collection, args);
         record(kind, count2);
@@ -13455,7 +15643,8 @@ function wrapTransactionCollections(nodes, edges, recorder) {
         collection,
         kind,
         NODE_WRITE_SURFACE,
-        recorder.recordNode
+        recorder.recordNode,
+        recorder.assertWritable
       )
     ),
     edges: wrapCollections(
@@ -13464,7 +15653,8 @@ function wrapTransactionCollections(nodes, edges, recorder) {
         collection,
         kind,
         EDGE_WRITE_SURFACE,
-        recorder.recordEdge
+        recorder.recordEdge,
+        recorder.assertWritable
       )
     )
   };
@@ -13505,6 +15695,7 @@ function rowMapperConfigFor(backend) {
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
+var EMPTY_RECORDED_FLUSH_INSTANTS = /* @__PURE__ */ new Map();
 function transactionOutcome(result, recorder, recordedByGraph, graphId) {
   const recorded = recordedByGraph?.get(graphId);
   return {
@@ -13691,9 +15882,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
@@ -13899,6 +16092,10 @@ var Store = class _Store {
         backend,
         options
       ),
+      // Present only when opted in; its absence is the coalesce off switch.
+      ...this.#options?.coalesceUnchangedUpserts === true && {
+        upsertDirtyCheck: (kind, id, existingProps, inputProps) => nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
+      },
       executeDelete: (kind, id, backend) => executeNodeDelete(ctx, kind, id, backend),
       executeHardDelete: (kind, id, backend) => executeNodeHardDelete(ctx, kind, id, backend),
       temporalRowMatcher: (options) => this.#temporalRowMatcher(options),
@@ -13953,6 +16150,10 @@ var Store = class _Store {
       executeCreateNoReturnBatch: (inputs, backend) => executeEdgeCreateNoReturnBatch(ctx, inputs, backend),
       executeUpdate: (input, backend) => executeEdgeUpdate(ctx, input, backend),
       executeUpsertUpdate: (input, backend, options) => executeEdgeUpsertUpdate(ctx, input, backend, options),
+      // Present only when opted in; its absence is the coalesce off switch.
+      ...this.#options?.coalesceUnchangedUpserts === true && {
+        upsertDirtyCheck: (kind, id, existingProps, inputProps) => edgeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
+      },
       executeDelete: (id, backend) => executeEdgeDelete(ctx, id, backend),
       executeHardDelete: (id, backend) => executeEdgeHardDelete(ctx, id, backend),
       temporalRowMatcher: (options) => this.#temporalRowMatcher(options),
@@ -14422,9 +16623,11 @@ var Store = class _Store {
           receiptRecorder
         ));
       }
-      const result = await invoke({
+      const fallbackContext = {
         nodes,
         edges,
+        // No real transaction: `tx.sql` is absent and there is no atomicity.
+        sqlAvailability: "unavailable",
         backend: this.#backend,
         getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind),
         // No transaction, no deferral: operations apply as they happen, so
@@ -14433,7 +16636,10 @@ var Store = class _Store {
           this.#createOperationContext(operation, "node", kind, id),
           hookedFunction
         )
-      });
+      };
+      const result = await invoke(
+        receiptRecorder === void 0 ? fallbackContext : this.#attachMeasure(fallbackContext)
+      );
       return { result, recordedByGraph: void 0 };
     }
     const pending = [];
@@ -14444,10 +16650,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
           )
@@ -14468,83 +16674,9 @@ var Store = class _Store {
       throw error;
     }
   }
-  /**
-   * Adopts a caller-owned, already-open Drizzle transaction so the graph
-   * store and the caller's relational writes commit or roll back as one
-   * Postgres/SQLite transaction (#134).
-   *
-   * Use this when the **relational layer owns the transaction**: the
-   * caller has opened a transaction and needs TypeGraph writes enlisted
-   * on the *same* connection. Unlike {@link transaction}, this opens no
-   * transaction — the caller's transaction is the single commit/rollback
-   * boundary.
-   *
-   * `withTransaction` is driver-agnostic; how the caller opens the
-   * transaction is not. **Async drivers** (node-postgres,
-   * `neon-serverless` Pool, libsql) use `db.transaction(async …)`.
-   * **Synchronous `better-sqlite3`** cannot — its driver rejects an
-   * `async` transaction callback (`Transaction function cannot return a
-   * promise`) and the async continuation would run outside the
-   * rolled-back transaction — so the caller opens the transaction with
-   * explicit `BEGIN`/`COMMIT`/`ROLLBACK` on the single connection
-   * instead. See the "Cross-Store Transactions" recipe for both shapes.
-   *
-   * The returned context reuses this store's already-resolved
-   * schema/registry: it runs **no** schema bootstrap, `evolve`, or
-   * migration, and emits **no DDL** inside the caller's transaction.
-   * Fulltext operations assert the durable materialization marker (a
-   * cached SELECT) and throw {@link StoreNotInitializedError} on a
-   * missing/stale/failed marker rather than migrating mid-transaction —
-   * so boot the parent store via `createStoreWithSchema` once at
-   * startup.
-   *
-   * @example
-   * ```typescript
-   * // Async driver (Postgres / libsql):
-   * await db.transaction(async (sqlTx) => {
-   *   const connector = await createConnectorRow(sqlTx, input); // Drizzle
-   *   const txStore = store.withTransaction(sqlTx);
-   *   await txStore.nodes.ArtifactSource.create({              // TypeGraph
-   *     connectorId: connector.id,
-   *   });
-   * }); // one COMMIT / ROLLBACK across both layers
-   * ```
-   *
-   * **The caller owns the connection — don't overlap writes on it.** The graph
-   * store and your Drizzle writes share the one connection the caller's
-   * transaction pinned. TypeGraph serializes the statements *its* collections
-   * issue, but your raw Drizzle statements (and any graph write run alongside
-   * them) are yours to sequence: a `Promise.all` mixing the two races two
-   * queries on that connection — the overlap Postgres removes in `pg@9`. Await
-   * each write before starting the next.
-   *
-   * Not available when the store was created with `{ history: true }`: a
-   * caller-owned transaction context would let writes happen after capture has
-   * lost its flush point, so this throws `ConfigurationError`
-   * (`RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`). Use
-   * {@link Store.withRecordedTransaction} on a history-enabled store, which
-   * adopts the same external transaction but flushes recorded-time capture
-   * before the caller commits.
-   *
-   * @throws {ConfigurationError} when the store has history capture enabled
-   *   (use {@link Store.withRecordedTransaction} instead), or when the backend
-   *   cannot adopt an external transaction — either it is not a Drizzle
-   *   Postgres/SQLite backend, or `backend.capabilities.transactions` is `false`
-   *   (`drizzle-orm/neon-http`, Cloudflare D1, SQLite
-   *   `transactionMode: "none"`). A non-atomic fallback is deliberately
-   *   not offered here: the caller's relational write *would* still
-   *   commit, defeating the purpose of cross-store atomicity.
-   * @throws {StoreNotInitializedError} at point of use, when a fulltext
-   *   operation on the returned context observes a missing/stale/failed
-   *   durable materialization marker (parent store not booted via
-   *   `createStoreWithSchema`). Rolls back the caller's transaction
-   *   without emitting any DDL.
-   */
   withTransaction(externalTx) {
     if (this.#captureEnabled) {
-      throw recordedCaptureRequiresCallbackTransactionError({
-        code: "RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION"
-      });
+      throw recordedCaptureRequiresCallbackTransactionError();
     }
     const adopt = this.#backend.adoptTransaction;
     if (!adopt) {
@@ -14572,17 +16704,62 @@ var Store = class _Store {
     }
     const scope = this.#captureEnabled ? createRecordedTransactionScope(txBackend, this.#sqlSchema()) : {
       backend: txBackend,
-      flush: () => Promise.resolve()
+      flush: () => Promise.resolve(EMPTY_RECORDED_FLUSH_INSTANTS)
     };
     if (this.#captureEnabled) {
       await lockRecordedGraphWrite(scope.backend, this.graphId);
     }
+    const receiptRecorder = createTransactionReceiptRecorder();
     const invoke = fn;
     const result = await invoke(
-      this.#buildTransactionContext(scope.backend, externalTx)
+      this.#buildTransactionContext(
+        scope.backend,
+        externalTx,
+        void 0,
+        receiptRecorder
+      )
     );
-    await scope.flush();
-    return result;
+    const recordedByGraph = await scope.flush();
+    if (!this.#captureEnabled) receiptRecorder.seal();
+    return transactionOutcome(
+      result,
+      receiptRecorder,
+      recordedByGraph,
+      this.graphId
+    );
+  }
+  /**
+   * Decorates a receipt-enabled transaction `context` with `measure`.
+   * Attribution is structural: `measure` wraps the context's *own* (already
+   * outer-recording) collections a second time with a fresh scope recorder, so a
+   * write through the scoped context counts in the scope and — via the inner
+   * wrapper it delegates to — the outer receipt, while a write through the outer
+   * `context` never reaches the scope recorder. This makes overlapping/concurrent
+   * measures safe by construction (each holds its own scope recorder) and lets
+   * scopes nest: the scoped context is itself decorated, so `scoped.measure(...)`
+   * chains one more wrapper. The scoped context's `getNodeCollection` resolves
+   * against the scope-wrapped map too, so dynamic-kind writes are attributed like
+   * `scoped.nodes.<Kind>`. The scope receipt's `recorded` is always undefined —
+   * the recorded instant is a whole-transaction flush concern.
+   */
+  #attachMeasure(context) {
+    const measure = async (fn) => {
+      const scopeRecorder = createTransactionReceiptRecorder();
+      const { nodes, edges } = wrapTransactionCollections(
+        context.nodes,
+        context.edges,
+        scopeRecorder
+      );
+      const scoped = this.#attachMeasure({
+        ...context,
+        nodes,
+        edges,
+        getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind)
+      });
+      const result = await fn(scoped);
+      return { result, receipt: scopeRecorder.snapshot() };
+    };
+    return { ...context, measure };
   }
   /**
    * Builds the `{ nodes, edges, sql }` projection bound to a
@@ -14594,7 +16771,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),
@@ -14628,24 +16805,20 @@ var Store = class _Store {
       ));
     }
     const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
-    if (sql17 === void 0) {
-      return {
-        nodes,
-        edges,
-        backend: txBackend,
-        getNodeCollection,
-        runNodeOperationHooks
-      };
-    }
-    const exposedSql = this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql17;
-    return {
+    const sqlAvailability = this.#captureEnabled ? "history" : this.#revisionTrackingEnabled ? "revisionTracking" : sql19 === void 0 ? "unavailable" : "available";
+    const base = {
       nodes,
       edges,
-      sql: exposedSql,
+      sqlAvailability,
       backend: txBackend,
       getNodeCollection,
       runNodeOperationHooks
     };
+    const withSql = sql19 === void 0 ? base : {
+      ...base,
+      sql: this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql19
+    };
+    return receiptRecorder === void 0 ? withSql : this.#attachMeasure(withSql);
   }
   // === Graph Lifecycle ===
   /**
@@ -14834,6 +17007,7 @@ var Store = class _Store {
       merged,
       activeRow.version
     );
+    await materializeVectorContributions(this.#backend, merged);
     const evolved = this.#cloneWithGraph(
       merged,
       options?.ref,
@@ -14936,6 +17110,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.
@@ -14992,10 +17189,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
@@ -15477,6 +17678,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,
@@ -15488,6 +17703,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,
@@ -15496,6 +17715,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,
@@ -15512,5 +17755,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-UES55P7G.js.map
-//# sourceMappingURL=chunk-UES55P7G.js.map
+//# sourceMappingURL=chunk-552KNYQJ.js.map
+//# sourceMappingURL=chunk-552KNYQJ.js.map