@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/{chunk-WLRIWYHQ.js → chunk-UES55P7G.js}

@@ -1,24 +1,24 @@
-import { quoteIdentifier, EMPTY_REQUIRED_COLUMNS, addRequiredColumn, markSelectiveFieldAsRequired, markFieldRefAsRequired, NODE_COLUMNS, shouldProjectColumn, mapSelectiveSystemFieldToColumn, isIdFieldRef, isAggregateExpr, EDGE_COLUMNS } from './chunk-3EUKJEQ3.js';
-import { createEdgeRowMapper, createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG } from './chunk-QV245VMN.js';
-import { runHookedWriteOperation, runInWriteTransaction } from './chunk-6SCVW4AS.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, getTypeName, validateNodeProps, validateEdgeProps } from './chunk-K2TGS3EN.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-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, getNodeKinds, getEdgeKinds } from './chunk-CHXTTSC6.js';
-import { generateIndexDDL } from './chunk-SHLY4MCM.js';
-import { getDialect, assertVectorMinScore, compileNodeIndexFieldKeys, compileIndexWhere, vectorScoreExpression, vectorMinScoreCondition } from './chunk-KUTNI6SI.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-4DIBPQNJ.js';
-import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
-import { createSchemaIntrospector } from './chunk-BVTWD66D.js';
-import { IncompatibleChangeError, filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, RemoveCompileTimeKindError, KindHasReferentsError, validateProjectionField } from './chunk-ZURTTSCM.js';
-import { compareStrings } from './chunk-4S2FXGBJ.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, asCompiledSelectSql, getSearchableFields, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, createRecordedBackend, readRecordedClock, asRecordedInstant, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, createHistoryUnsafeSqlRef, generateId, vectorSlotKey, getEmbeddingFields, computeFulltextContent, recordedReadSqlSchema, requireRecordedReadBinding, asCompiledRowsSql, getKindsForUniquenessCheck, checkWherePredicate, computeUniqueKey, applyNodeHardDelete, createNodeWriteContext, applyNodeSoftDelete, runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, edgeInsertDispatch, getNodeRowsByIds, getEdgeRowsByIds, applyNodeUpdate, applyNodeInsertSideEffects, checkCardinality, checkUniqueEdge, validateEdgeEndpoints, assertValidRecordedInstant, checkUniquenessConstraints, createUniquenessContext, recordedBindParamBudget, checkDisjointness, closeRecordedHardDeletedKind, asCompiledStatementSql, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, ALIAS_CTE_PREFIX } from './chunk-A7SZZFAG.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, runOptionallyInTransaction, baseField, objectField, arrayField, dateField, numberField, isLiveNodeRow, createBackendOverlay, compileKindFilter, chunk, sqlValueList, buildPredicateIndex, compileFieldValue, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, compilePredicateExpression, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-V3QNTB7Z.js';
-import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-XXVEULWX.js';
-import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-2MRAX3UE.js';
-import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { resolveEmbeddingFields } from './chunk-Z5XBMDXU.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, UniquenessError, DatabaseOperationError, CardinalityError, EdgeNotFoundError, NodeIndexNotFoundError, NodeConstraintNotFoundError, NodeNotFoundError, EndpointNotFoundError } from './chunk-TQOYM4LN.js';
-import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-K5P5OZXS.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 { 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 { 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 { 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 { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-G6Q5UM7U.js';
 import { Placeholder, sql } from 'drizzle-orm';
 
 // src/store/collection-surface.ts
@@ -27,11 +27,38 @@ var CURRENT_ONLY_READ_NAMES = [
   "bulkFindByConstraint",
   "bulkFindByIndex"
 ];
+var NODE_WRITE_NAMES = [
+  "create",
+  "createFromRecord",
+  "update",
+  "delete",
+  "hardDelete",
+  "upsertById",
+  "upsertByIdFromRecord",
+  "bulkCreate",
+  "bulkUpsertById",
+  "bulkInsert",
+  "bulkDelete",
+  "getOrCreateByConstraint",
+  "bulkGetOrCreateByConstraint"
+];
 var EDGE_BATCH_READ_NAMES = [
   "batchFindFrom",
   "batchFindTo",
   "batchFindByEndpoints"
 ];
+var EDGE_WRITE_NAMES = [
+  "create",
+  "update",
+  "delete",
+  "hardDelete",
+  "bulkCreate",
+  "bulkUpsertById",
+  "bulkInsert",
+  "bulkDelete",
+  "getOrCreateByEndpoints",
+  "bulkGetOrCreateByEndpoints"
+];
 
 // src/store/recorded-coordinate-guard.ts
 function hasOwnRecordedAsOf(options) {
@@ -211,9 +238,6 @@ function pinnedNodeCollection(live, coordinate) {
   const reads = {
     getById: (id) => live.getById(id, temporal),
     getByIds: (ids) => live.getByIds(ids, temporal),
-    // `live.find` is the NodeCollection read, not Array#find — the
-    // (filter, temporal) shape trips the array-method heuristics.
-    // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
     find: (filter) => live.find(filter, temporal),
     count: () => live.count(temporal)
   };
@@ -229,9 +253,6 @@ function pinnedEdgeCollection(live, coordinate) {
   const reads = {
     getById: (id) => live.getById(id, temporal),
     getByIds: (ids) => live.getByIds(ids, temporal),
-    // `live.find` is the EdgeCollection read, not Array#find — the
-    // (filter, temporal) shape trips the array-method heuristics.
-    // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
     find: (filter) => live.find(filter, temporal),
     count: (filter) => live.count(filter, temporal),
     findFrom: (from) => live.findFrom(from, temporal),
@@ -885,6 +906,29 @@ function emitStandardQuerySql(input) {
   return sql.join(parts, sql` `);
 }
 
+// src/utils/identifier.ts
+var TEXT_ENCODER = new TextEncoder();
+function truncateToBytes(value, maxBytes) {
+  const encoded = TEXT_ENCODER.encode(value);
+  if (encoded.byteLength <= maxBytes) return value;
+  let end = maxBytes;
+  while (end > 0 && encoded[end] >= 128 && encoded[end] < 192) {
+    end--;
+  }
+  return new TextDecoder().decode(encoded.slice(0, end));
+}
+function boundPgIdentifier(name, hashInput) {
+  if (TEXT_ENCODER.encode(name).byteLength <= MAX_PG_IDENTIFIER_LENGTH) {
+    return name;
+  }
+  const hash = fnv1aBase36(hashInput);
+  const truncated = truncateToBytes(
+    name,
+    MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length
+  );
+  return `${truncated}_${hash}`;
+}
+
 // src/query/ast.ts
 var DEFAULT_RRF_K = 60;
 var DEFAULT_RRF_WEIGHT = 1;
@@ -926,6 +970,14 @@ function compileTypedJsonExtract(input) {
     }
   }
 }
+function compileSelectivePropsExtraction(field2, column, dialect) {
+  return compileTypedJsonExtract({
+    column,
+    dialect,
+    pointer: jsonPointer([field2.field]),
+    valueType: field2.valueType
+  });
+}
 
 // src/query/compiler/emitter/standard-builders.ts
 function compileColumnReference(tableAlias, column) {
@@ -938,6 +990,11 @@ function qualifyColumn(owner, name) {
   return sql`${quoteIdentifier(owner)}.${quoteIdentifier(name)}`;
 }
 var SCOPED_RELEVANCE_NODES_ALIAS = "scoped_relevance_nodes";
+function selectivePropsCteColumnName(field2) {
+  const { alias, field: fieldName } = field2;
+  const encoded = `__tg_${alias.length}:${alias}:${fieldName.length}:${fieldName}`;
+  return boundPgIdentifier(encoded, `${alias}\0${fieldName}`);
+}
 function buildScopedNodeIdsSubquery(nodeAlias) {
   const cteAlias = `${ALIAS_CTE_PREFIX}${nodeAlias}`;
   return sql`
@@ -949,19 +1006,52 @@ function buildScopedNodeIdsSubquery(nodeAlias) {
       ) AS ${sql.raw(SCOPED_RELEVANCE_NODES_ALIAS)}
   `;
 }
-function compileNodeSelectColumns(tableAlias, alias, requiredColumns) {
-  return NODE_COLUMNS.filter(
+function compileSelectivePropsSelectColumns(input) {
+  const { alias, dialect, selectiveFields, tableAlias } = input;
+  const propsFields = selectiveFields?.filter(
+    (field2) => !field2.isSystemField && field2.alias === alias
+  ) ?? [];
+  if (propsFields.length === 0) return [];
+  const propsColumn = compileColumnReference(tableAlias, "props");
+  return propsFields.map((field2) => {
+    const extracted = compileSelectivePropsExtraction(
+      field2,
+      propsColumn,
+      dialect
+    );
+    return sql`${extracted} AS ${quoteIdentifier(selectivePropsCteColumnName(field2))}`;
+  });
+}
+function appendSelectivePropsColumns(baseColumns, input) {
+  return [...baseColumns, ...compileSelectivePropsSelectColumns(input)];
+}
+function compileNodeSelectColumns(input) {
+  const { alias, dialect, requiredColumns, selectiveFields, tableAlias } = input;
+  const baseColumns = NODE_COLUMNS.filter(
     (column) => column === "id" || column === "kind" || shouldProjectColumn(requiredColumns, column)
   ).map(
     (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
   );
+  return appendSelectivePropsColumns(baseColumns, {
+    alias,
+    dialect,
+    selectiveFields,
+    tableAlias
+  });
 }
-function compileEdgeSelectColumns(tableAlias, alias, requiredColumns) {
-  return EDGE_COLUMNS.filter(
+function compileEdgeSelectColumns(input) {
+  const { alias, dialect, requiredColumns, selectiveFields, tableAlias } = input;
+  const baseColumns = EDGE_COLUMNS.filter(
     (column) => shouldProjectColumn(requiredColumns, column)
   ).map(
     (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
   );
+  return appendSelectivePropsColumns(baseColumns, {
+    alias,
+    dialect,
+    selectiveFields,
+    tableAlias
+  });
 }
 function buildStandardStartCte(input) {
   const { ast, ctx, graphId, predicateIndex, requiredColumnsByAlias } = input;
@@ -990,7 +1080,13 @@ function buildStandardStartCte(input) {
   return sql`
     cte_${sql.raw(alias)} AS ${cteMaterialization}(
       SELECT ${sql.join(
-    compileNodeSelectColumns(void 0, alias, effectiveRequiredColumns),
+    compileNodeSelectColumns({
+      alias,
+      dialect: ctx.dialect,
+      requiredColumns: effectiveRequiredColumns,
+      selectiveFields: ast.selectiveFields,
+      tableAlias: void 0
+    }),
     sql`, `
   )}
       FROM ${ctx.schema.nodesTable}
@@ -1055,8 +1151,20 @@ function buildStandardTraversalCte(input) {
   ];
   const selectColumns = [
     ...previousRowColumns,
-    ...compileEdgeSelectColumns("e", edgeAlias, requiredEdgeColumns),
-    ...compileNodeSelectColumns("n", nodeAlias, requiredNodeColumns)
+    ...compileEdgeSelectColumns({
+      alias: edgeAlias,
+      dialect: ctx.dialect,
+      requiredColumns: requiredEdgeColumns,
+      selectiveFields: ast.selectiveFields,
+      tableAlias: "e"
+    }),
+    ...compileNodeSelectColumns({
+      alias: nodeAlias,
+      dialect: ctx.dialect,
+      requiredColumns: requiredNodeColumns,
+      selectiveFields: ast.selectiveFields,
+      tableAlias: "n"
+    })
   ];
   const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : ctx.dialect.capabilities.emitNotMaterializedHint ? sql`NOT MATERIALIZED ` : sql``;
   function compileTraversalBranch(branch) {
@@ -1196,7 +1304,6 @@ function buildStandardProjection(input) {
   if (ast.selectiveFields && ast.selectiveFields.length > 0) {
     return compileSelectiveProjection(
       ast.selectiveFields,
-      dialect,
       ast,
       collapsedTraversalCteAlias
     );
@@ -1221,7 +1328,7 @@ function buildAliasToCteMap(ast) {
   }
   return map;
 }
-function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteAlias) {
+function compileSelectiveProjection(fields, ast, collapsedTraversalCteAlias) {
   const aliasToCte = buildAliasToCteMap(ast);
   const columns = fields.map((field2) => {
     const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(field2.alias) ?? `cte_${field2.alias}`;
@@ -1229,19 +1336,20 @@ function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteA
       const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
       return sql`${sql.raw(cteAlias)}.${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
     }
-    const propsColumn = `${field2.alias}_props`;
-    const column = sql`${sql.raw(cteAlias)}.${sql.raw(propsColumn)}`;
-    const pointer = jsonPointer([field2.field]);
-    const extracted = compileTypedJsonExtract({
-      column,
-      dialect,
-      pointer,
-      valueType: field2.valueType
-    });
-    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+    return sql`${sql.raw(cteAlias)}.${quoteIdentifier(selectivePropsCteColumnName(field2))} AS ${quoteIdentifier(field2.outputName)}`;
   });
   return sql.join(columns, sql`, `);
 }
+function compileOrderFieldValue(ast, field2, dialect, cteAlias) {
+  const selectiveField = findSelectivePropsFieldForFieldRef(
+    ast.selectiveFields,
+    field2
+  );
+  if (selectiveField !== void 0) {
+    return sql`${sql.raw(cteAlias)}.${quoteIdentifier(selectivePropsCteColumnName(selectiveField))}`;
+  }
+  return compileFieldValue(field2, dialect, field2.valueType, cteAlias);
+}
 function buildRelevanceJoins(vectorPredicate, fulltextPredicate) {
   const hybridTargetAlias = getHybridTargetAlias(
     vectorPredicate,
@@ -1309,23 +1417,25 @@ function buildStandardFromClause(input) {
 }
 function buildStandardOrderBy(input) {
   const { ast, collapsedTraversalCteAlias, dialect } = input;
-  if (!ast.orderBy || ast.orderBy.length === 0) {
+  const fieldOrderBy = ast.orderBy ?? [];
+  const aggregateOrderBy = ast.aggregateOrderBy ?? [];
+  if (fieldOrderBy.length === 0 && aggregateOrderBy.length === 0) {
     return void 0;
   }
-  const aliasToCte = buildAliasToCteMap(ast);
+  const aliasToCte = fieldOrderBy.length > 0 ? buildAliasToCteMap(ast) : void 0;
   const parts = [];
-  for (const orderSpec of ast.orderBy) {
+  for (const orderSpec of fieldOrderBy) {
     const valueType = orderSpec.field.valueType;
     if (valueType === "array" || valueType === "object") {
       throw new UnsupportedPredicateError(
         "Ordering by JSON arrays or objects is not supported"
       );
     }
-    const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(orderSpec.field.alias) ?? `cte_${orderSpec.field.alias}`;
-    const field2 = compileFieldValue(
+    const cteAlias = collapsedTraversalCteAlias ?? aliasToCte?.get(orderSpec.field.alias) ?? `cte_${orderSpec.field.alias}`;
+    const field2 = compileOrderFieldValue(
+      ast,
       orderSpec.field,
       dialect,
-      valueType,
       cteAlias
     );
     const direction = sql.raw(orderSpec.direction.toUpperCase());
@@ -1336,6 +1446,15 @@ function buildStandardOrderBy(input) {
       sql`${field2} ${direction}`
     );
   }
+  for (const orderSpec of aggregateOrderBy) {
+    const column = quoteIdentifier(orderSpec.outputName);
+    const direction = sql.raw(orderSpec.direction.toUpperCase());
+    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+    const nullsKeyword = sql.raw(
+      nulls === "first" ? "NULLS FIRST" : "NULLS LAST"
+    );
+    parts.push(sql`${column} ${direction} ${nullsKeyword}`);
+  }
   return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
 }
 function fieldRefKey(field2) {
@@ -1418,12 +1537,48 @@ function buildStandardEmbeddingsCte(input) {
   );
   const branches = declaringKinds.map((kind) => {
     const tableName = vectorStrategy.tableName(graphId, kind, fieldPath);
-    const branchMetric = metric ?? vectorSlots?.get(vectorSlotKey(kind, fieldPath))?.metric ?? "cosine";
+    const slotDescriptor = vectorSlots?.get(vectorSlotKey(kind, fieldPath));
+    const branchMetric = metric ?? slotDescriptor?.metric ?? "cosine";
+    const engineFormEligible = vectorPredicate.approximate === true || vectorStrategy.searchIsExact === true;
+    const annSlot = engineFormEligible && branchMetric === slotDescriptor?.metric ? slotDescriptor : void 0;
+    if (annSlot !== void 0) {
+      ctx.annIndexTypes?.add(annSlot.indexType);
+      const candidateCte = `${ALIAS_CTE_PREFIX}${field2.alias}`;
+      const kindCandidates = sql`SELECT ${qualifyColumn(candidateCte, `${field2.alias}_id`)} FROM ${quoteIdentifier(candidateCte)} WHERE ${qualifyColumn(candidateCte, `${field2.alias}_kind`)} = ${kind}`;
+      const annSql = vectorStrategy.buildSearch(
+        {
+          graphId,
+          nodeKind: kind,
+          fieldPath,
+          dimensions: annSlot.dimensions,
+          metric: branchMetric,
+          indexType: annSlot.indexType
+        },
+        {
+          graphId,
+          nodeKind: kind,
+          fieldPath,
+          queryEmbedding,
+          metric: branchMetric,
+          dimensions: annSlot.dimensions,
+          indexType: annSlot.indexType,
+          limit: vectorPredicate.limit,
+          ...minScore === void 0 ? {} : { minScore }
+        },
+        kindCandidates
+      );
+      const distanceFromScore = branchMetric === "cosine" ? sql.raw("(1.0 - score)") : sql.raw("score");
+      return sql`
+        SELECT node_id, ${kind} AS node_kind, ${distanceFromScore} AS distance, score
+        FROM (${annSql}) AS tg_ann_src
+      `;
+    }
     const distanceExpr = vectorStrategy.distanceExpression(
       qualifyColumn(tableName, "embedding"),
       queryEmbedding,
       branchMetric
     );
+    const exactDistanceExpr = sql`(${distanceExpr} + 0.0)`;
     const scoreExpr = vectorScoreExpression(distanceExpr, branchMetric);
     const conditions = [
       sql`${qualifyColumn(tableName, "graph_id")} = ${graphId}`
@@ -1437,7 +1592,7 @@ function buildStandardEmbeddingsCte(input) {
       SELECT
         ${qualifyColumn(tableName, "node_id")} AS node_id,
         ${kind} AS node_kind,
-        ${distanceExpr} AS distance,
+        ${exactDistanceExpr} AS distance,
         ${scoreExpr} AS score
       FROM ${quoteIdentifier(tableName)}
       INNER JOIN ${scopedNodes}
@@ -1496,17 +1651,18 @@ function buildStandardFulltextCte(input) {
       `Fulltext match predicates are not supported for dialect "${dialect.name}"`
     );
   }
+  const effectiveLanguage = language ?? sharedDeclaredLanguage(ctx.fulltextLanguages, nodeKinds);
   const matchCondition = fulltextStrategy.matchCondition(
     tableName,
     query,
     mode,
-    language
+    effectiveLanguage
   );
   const rankExpression = fulltextStrategy.rankExpression(
     tableName,
     query,
     mode,
-    language
+    effectiveLanguage
   );
   const conditions = [
     sql`${qualifyColumn(tableName, "graph_id")} = ${graphId}`,
@@ -1541,6 +1697,16 @@ function buildStandardFulltextCte(input) {
     )
   `;
 }
+function sharedDeclaredLanguage(fulltextLanguages, nodeKinds) {
+  if (fulltextLanguages === void 0) return void 0;
+  const languages = /* @__PURE__ */ new Set();
+  for (const kind of nodeKinds) {
+    const language = fulltextLanguages.get(kind);
+    if (language !== void 0) languages.add(language);
+  }
+  if (languages.size !== 1) return void 0;
+  return [...languages][0];
+}
 function buildStandardHybridCandidateCte() {
   return sql`
     ${sql.raw(HYBRID_CANDIDATES_CTE_ALIAS)} AS (
@@ -1562,10 +1728,10 @@ function compileUserOrderBy(ast, dialect) {
       );
     }
     const cteAlias = aliasToCte.get(orderSpec.field.alias) ?? `${ALIAS_CTE_PREFIX}${orderSpec.field.alias}`;
-    const field2 = compileFieldValue(
+    const field2 = compileOrderFieldValue(
+      ast,
       orderSpec.field,
       dialect,
-      valueType,
       cteAlias
     );
     const direction = sql.raw(orderSpec.direction.toUpperCase());
@@ -1712,51 +1878,10 @@ function runCompilerPass(state, pass) {
     state: pass.update(state, output)
   };
 }
-function compileTemporalFilter(options) {
-  const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = options;
-  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
-  const deletedAt = sql`${prefix}deleted_at`;
-  const validFrom = sql`${prefix}valid_from`;
-  const validTo = sql`${prefix}valid_to`;
-  const validFilter = (() => {
-    switch (mode) {
-      case "current": {
-        const now = recordedAsOf === void 0 ? currentTimestamp ?? sql`CURRENT_TIMESTAMP` : sql`${recordedAsOf}`;
-        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
-      }
-      case "asOf": {
-        if (asOf === void 0) {
-          throw new Error(
-            `asOf timestamp is required for temporal mode "asOf"`
-          );
-        }
-        const timestamp = asOf;
-        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
-      }
-      case "includeEnded": {
-        return sql`${deletedAt} IS NULL`;
-      }
-      case "includeTombstones": {
-        return sql.raw("1=1");
-      }
-    }
-  })();
-  if (recordedAsOf === void 0) return validFilter;
-  const recordedFrom = sql`${prefix}recorded_from`;
-  const recordedTo = sql`${prefix}recorded_to`;
-  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedAsOf} AND ${recordedAsOf} < ${recordedTo}`;
-}
-function extractTemporalOptions(ast, tableAlias) {
-  return {
-    mode: ast.temporalMode.mode,
-    asOf: ast.temporalMode.asOf,
-    recordedAsOf: ast.recordedAsOf,
-    tableAlias
-  };
-}
 
 // src/query/compiler/passes/temporal.ts
-function createTemporalFilterPass(ast, currentTimestamp) {
+function createTemporalFilterPass(ast, readInstant = "literal") {
+  const currentTimestamp = currentReadInstantFor(readInstant);
   return {
     forAlias(tableAlias) {
       return compileTemporalFilter({
@@ -1873,12 +1998,14 @@ function appendAggregateSortLimitAndProjectNodes(currentNode, ast, nextPlanNodeI
     };
     node = ast.having === void 0 ? aggregateNode : { ...aggregateNode, having: ast.having };
   }
-  if (ast.orderBy !== void 0 && ast.orderBy.length > 0) {
+  const hasFieldOrderBy = ast.orderBy !== void 0 && ast.orderBy.length > 0;
+  const hasAggregateOrderBy = ast.aggregateOrderBy !== void 0 && ast.aggregateOrderBy.length > 0;
+  if (hasFieldOrderBy || hasAggregateOrderBy) {
     node = {
       id: nextPlanNodeId(),
       input: node,
       op: "sort",
-      orderBy: ast.orderBy
+      orderBy: ast.orderBy ?? []
     };
   }
   if (limit !== void 0 || ast.offset !== void 0) {
@@ -2237,7 +2364,7 @@ function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
     execute(currentState) {
       return createTemporalFilterPass(
         currentState.ast,
-        currentState.ctx.dialect.currentTimestamp()
+        currentState.ctx.readInstant
       );
     },
     update(currentState, temporalFilterPass) {
@@ -2645,12 +2772,7 @@ function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
       return sql`${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
     }
     const column = sql.raw(`${field2.alias}_props`);
-    const extracted = compileTypedJsonExtract({
-      column,
-      dialect,
-      pointer: jsonPointer([field2.field]),
-      valueType: field2.valueType
-    });
+    const extracted = compileSelectivePropsExtraction(field2, column, dialect);
     return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
   });
   const vl = traversal.variableLength;
@@ -2758,7 +2880,7 @@ function buildReachableCte(options) {
     sql.raw("e.kind"),
     options.edgeKinds
   );
-  const currentTimestamp = options.dialect.currentTimestamp();
+  const currentTimestamp = currentReadInstant();
   const nodeTemporalFilter = compileTemporalFilter({
     mode: options.temporalMode,
     asOf: options.asOf,
@@ -2871,66 +2993,8 @@ function buildBidirectionalBranch(options) {
   return sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${sql.join([...options.whereClauses], sql` AND `)}`;
 }
 
-// src/store/row-mappers.ts
-function nullToUndefined2(value) {
-  return value === null ? void 0 : value;
-}
-function rowToNode(row) {
-  const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS);
-  return {
-    kind: row.kind,
-    id: row.id,
-    meta: rowToNodeMeta(row),
-    ...props
-  };
-}
-function rowToNodeMeta(row) {
-  return {
-    version: row.version,
-    validFrom: nullToUndefined2(row.valid_from),
-    validTo: nullToUndefined2(row.valid_to),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    deletedAt: nullToUndefined2(row.deleted_at)
-  };
-}
-function rowToEdge(row) {
-  const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS);
-  return {
-    id: row.id,
-    kind: row.kind,
-    fromKind: row.from_kind,
-    fromId: row.from_id,
-    toKind: row.to_kind,
-    toId: row.to_id,
-    meta: rowToEdgeMeta(row),
-    ...props
-  };
-}
-function rowToEdgeMeta(row) {
-  return {
-    validFrom: nullToUndefined2(row.valid_from),
-    validTo: nullToUndefined2(row.valid_to),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    deletedAt: nullToUndefined2(row.deleted_at)
-  };
-}
-
 // src/store/subgraph.ts
 var DEFAULT_SUBGRAPH_MAX_DEPTH = 10;
-var TEXT_ENCODER = new TextEncoder();
-function truncateToBytes(value, maxBytes) {
-  const encoded = TEXT_ENCODER.encode(value);
-  if (encoded.byteLength <= maxBytes) return value;
-  let end = maxBytes;
-  while (end > 0 && encoded[end] >= 128 && encoded[end] < 192) {
-    end--;
-  }
-  return new TextDecoder().decode(encoded.slice(0, end));
-}
 function projectionAlias(entityPrefix, kind, field2) {
   const prefix = entityPrefix === "node" ? "sg_n" : "sg_e";
   const hash = fnv1aBase36(`${kind}\0${field2}`);
@@ -3010,9 +3074,31 @@ async function executeSubgraph(params) {
     ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding }
   });
   const includedIdsCte = buildIncludedIdsCte(ctx);
+  let membership;
+  if (ctx.dialect.name === "postgres") {
+    const includedIds = await fetchIncludedIds(
+      ctx,
+      reachableCte,
+      includedIdsCte
+    );
+    const idsArray = textArrayParam(includedIds);
+    membership = {
+      prefix: sql``,
+      idFilter: (column) => sql`EXISTS (SELECT 1 FROM unnest(${idsArray}) AS tg_included(id) WHERE tg_included.id = ${column})`,
+      parameterDependentPlan: true
+    };
+  } else {
+    membership = {
+      prefix: sql`${reachableCte}${includedIdsCte} `,
+      // SQLite: `column IN (subquery)` evaluates via a transient index —
+      // optimal as-is. (Postgres takes the parameterized text[] form above.)
+      idFilter: (column) => sql`${column} IN (SELECT id FROM included_ids)`,
+      parameterDependentPlan: false
+    };
+  }
   const [nodeRows, edgeRows] = await Promise.all([
-    fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, nodeProjectionPlan),
-    fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, edgeProjectionPlan)
+    fetchSubgraphNodes(ctx, membership, nodeProjectionPlan),
+    fetchSubgraphEdges(ctx, membership, edgeProjectionPlan)
   ]);
   const nodesMap = /* @__PURE__ */ new Map();
   for (const row of nodeRows) {
@@ -3112,13 +3198,27 @@ function buildIncludedIdsCte(ctx) {
   const whereClause = filters.length > 0 ? sql` WHERE ${sql.join(filters, sql` AND `)}` : sql``;
   return sql`, included_ids AS (SELECT DISTINCT id FROM reachable${whereClause})`;
 }
-async function fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, projectionPlan) {
+function textArrayParam(values) {
+  const elements = values.map(
+    (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`
+  );
+  return sql`${`{${elements.join(",")}}`}::text[]`;
+}
+async function fetchIncludedIds(ctx, reachableCte, includedIdsCte) {
+  const rows = await ctx.backend.execute(
+    asCompiledRowsSql(
+      sql`${reachableCte}${includedIdsCte} SELECT id FROM included_ids`
+    )
+  );
+  return rows.map((row) => row.id);
+}
+async function fetchSubgraphNodes(ctx, membership, projectionPlan) {
   const nodeTemporalFilter = compileTemporalFilter({
     mode: ctx.temporalMode,
     asOf: ctx.asOf,
     recordedAsOf: ctx.recordedAsOf,
     tableAlias: "n",
-    currentTimestamp: ctx.dialect.currentTimestamp()
+    currentTimestamp: currentReadInstant()
   });
   const columns = [
     sql`n.kind`,
@@ -3134,19 +3234,20 @@ async function fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, projectionP
     ]),
     ...buildProjectedPropertyColumns("n", projectionPlan, ctx.dialect)
   ];
-  const query = sql`${reachableCte}${includedIdsCte} SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND ${nodeTemporalFilter} AND n.id IN (SELECT id FROM included_ids)`;
+  const query = sql`${membership.prefix}SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND ${nodeTemporalFilter} AND ${membership.idFilter(sql.raw("n.id"))}`;
+  if (membership.parameterDependentPlan) markForceCustomPlan(query);
   return ctx.backend.execute(
     asCompiledRowsSql(query)
   );
 }
-async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, projectionPlan) {
+async function fetchSubgraphEdges(ctx, membership, projectionPlan) {
   const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
   const edgeTemporalFilter = compileTemporalFilter({
     mode: ctx.temporalMode,
     asOf: ctx.asOf,
     recordedAsOf: ctx.recordedAsOf,
     tableAlias: "e",
-    currentTimestamp: ctx.dialect.currentTimestamp()
+    currentTimestamp: currentReadInstant()
   });
   const columns = [
     sql`e.id`,
@@ -3165,7 +3266,8 @@ async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, projectionP
     ]),
     ...buildProjectedPropertyColumns("e", projectionPlan, ctx.dialect)
   ];
-  const query = sql`${reachableCte}${includedIdsCte} SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND ${edgeTemporalFilter} AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
+  const query = sql`${membership.prefix}SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND ${edgeTemporalFilter} AND ${membership.idFilter(sql.raw("e.from_id"))} AND ${membership.idFilter(sql.raw("e.to_id"))}`;
+  if (membership.parameterDependentPlan) markForceCustomPlan(query);
   return ctx.backend.execute(
     asCompiledRowsSql(query)
   );
@@ -3515,9 +3617,16 @@ function collectRequiredColumnsByAlias2(ast) {
   for (const traversal of ast.traversals) {
     addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
   }
-  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
-    for (const field2 of ast.selectiveFields) {
-      markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
+  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)
+        );
+      }
     }
   } else {
     for (const projectedField of ast.projection.fields) {
@@ -3537,14 +3646,25 @@ function collectRequiredColumnsByAlias2(ast) {
   }
   if (ast.orderBy) {
     for (const orderSpec of ast.orderBy) {
+      if (findSelectivePropsFieldForFieldRef(
+        ast.selectiveFields,
+        orderSpec.field
+      ) !== void 0) {
+        continue;
+      }
       markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
     }
   }
   if (ast.having) {
     markPredicateFieldsAsRequired(requiredColumnsByAlias, ast.having);
   }
-  for (const predicate of ast.predicates) {
-    markPredicateFieldsAsRequired(requiredColumnsByAlias, predicate.expression);
+  if (!hasSelectiveFields) {
+    for (const predicate of ast.predicates) {
+      markPredicateFieldsAsRequired(
+        requiredColumnsByAlias,
+        predicate.expression
+      );
+    }
   }
   return requiredColumnsByAlias;
 }
@@ -3724,10 +3844,7 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
   const temporalPass = runCompilerPass(state, {
     name: "temporal_filters",
     execute(currentState) {
-      return createTemporalFilterPass(
-        currentState.ast,
-        currentState.ctx.dialect.currentTimestamp()
-      );
+      return createTemporalFilterPass(currentState.ast, ctx.readInstant);
     },
     update(currentState, temporalFilterPass) {
       return {
@@ -3838,9 +3955,12 @@ function compileQuery(ast, graphId, options = "sqlite") {
     "recorded-query"
   );
   const adapter = resolveDialectAdapter(dialect, options_.fulltextStrategy);
+  const annIndexTypes = /* @__PURE__ */ new Set();
   const ctx = {
     dialect: adapter,
     schema,
+    annIndexTypes,
+    readInstant: options_.readInstant ?? "literal",
     compileQuery: (subAst, subGraphId) => compileQuery(
       inheritRecordedAsOf(subAst, ast.recordedAsOf),
       subGraphId,
@@ -3848,16 +3968,23 @@ function compileQuery(ast, graphId, options = "sqlite") {
     ),
     ...options_.vectorStrategy === void 0 ? {} : { vectorStrategy: options_.vectorStrategy },
     windowFunctions: options_.windowFunctions ?? true,
-    ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots }
+    ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots },
+    ...options_.fulltextLanguages === void 0 ? {} : { fulltextLanguages: options_.fulltextLanguages }
   };
+  function finish(compiled) {
+    if (annIndexTypes.size > 0) {
+      markAnnIndexScan(compiled, [...annIndexTypes]);
+    }
+    return asCompiledSelectSql(compiled);
+  }
   if (hasVariableLengthTraversal(ast)) {
     const lowered = tryLowerSingleHopRecursiveTraversal(ast);
     if (lowered !== void 0) {
-      return asCompiledSelectSql(compileStandardQuery(lowered, graphId, ctx));
+      return finish(compileStandardQuery(lowered, graphId, ctx));
     }
-    return asCompiledSelectSql(compileVariableLengthQuery(ast, graphId, ctx));
+    return finish(compileVariableLengthQuery(ast, graphId, ctx));
   }
-  return asCompiledSelectSql(compileStandardQuery(ast, graphId, ctx));
+  return finish(compileStandardQuery(ast, graphId, ctx));
 }
 function tryLowerSingleHopRecursiveTraversal(ast) {
   if (ast.traversals.length !== 1) {
@@ -3884,15 +4011,21 @@ function compileSetOperation2(op, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
   const adapter = resolveDialectAdapter(dialect, options_.fulltextStrategy);
-  return asCompiledSelectSql(
-    compileSetOperation(
-      op,
-      graphId,
-      adapter,
-      (ast, gid) => compileQuery(ast, gid, propagateOptions(options_)),
-      options_.vectorStrategy
-    )
+  const annIndexTypes = /* @__PURE__ */ new Set();
+  const compileOperand = (ast, gid) => {
+    const compiled = compileQuery(ast, gid, propagateOptions(options_));
+    for (const indexType of annIndexScanTypes(compiled) ?? []) {
+      annIndexTypes.add(indexType);
+    }
+    return compiled;
+  };
+  const combined = withPinnedReadInstant(
+    () => compileSetOperation(op, graphId, adapter, compileOperand, options_.vectorStrategy)
   );
+  if (annIndexTypes.size > 0) {
+    markAnnIndexScan(combined, [...annIndexTypes]);
+  }
+  return asCompiledSelectSql(combined);
 }
 function resolveDialectAdapter(dialect, fulltextStrategy) {
   const baseAdapter = getDialect(dialect);
@@ -3935,7 +4068,9 @@ function propagateOptions(options_) {
     ...options_.vectorStrategy === void 0 ? {} : { vectorStrategy: options_.vectorStrategy },
     windowFunctions: options_.windowFunctions ?? true,
     ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots },
-    ...options_.recordedReadBinding === void 0 ? {} : { recordedReadBinding: options_.recordedReadBinding }
+    ...options_.fulltextLanguages === void 0 ? {} : { fulltextLanguages: options_.fulltextLanguages },
+    ...options_.recordedReadBinding === void 0 ? {} : { recordedReadBinding: options_.recordedReadBinding },
+    ...options_.readInstant === void 0 ? {} : { readInstant: options_.readInstant }
   };
 }
 function resolveCountAggregateFastPath(ast) {
@@ -4097,7 +4232,7 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
       sql`COUNT(DISTINCT e.id) AS ${sql.raw(edgeCountDistinctColumn)}`
     );
   }
-  const startCteLimit = traversal.optional && ast.orderBy === void 0 && ast.limit !== void 0 ? { limit: ast.limit, offset: ast.offset } : void 0;
+  const startCteLimit = traversal.optional && ast.orderBy === void 0 && ast.aggregateOrderBy === void 0 && ast.limit !== void 0 ? { limit: ast.limit, offset: ast.offset } : void 0;
   const startCte = buildStandardStartCte({
     ast,
     ctx,
@@ -4437,9 +4572,9 @@ function transformPathColumns(rows, state, _dialect) {
   }
   return changed ? result : rows;
 }
-var RESERVED_NODE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
-var RESERVED_EDGE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
-function nullToUndefined3(value) {
+var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
+var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
+function nullToUndefined2(value) {
   return value === null ? void 0 : value;
 }
 function assignPropsExcludingReserved(target, props, reservedKeys) {
@@ -4455,13 +4590,13 @@ function buildSelectableNode(row, alias) {
   const propsRaw = row[`${alias}_props`];
   const rawProps = typeof propsRaw === "string" ? JSON.parse(propsRaw) : propsRaw ?? {};
   const version = row[`${alias}_version`];
-  const validFrom = nullToUndefined3(
+  const validFrom = nullToUndefined2(
     row[`${alias}_valid_from`]
   );
-  const validTo = nullToUndefined3(row[`${alias}_valid_to`]);
+  const validTo = nullToUndefined2(row[`${alias}_valid_to`]);
   const createdAt = row[`${alias}_created_at`];
   const updatedAt = row[`${alias}_updated_at`];
-  const deletedAt = nullToUndefined3(
+  const deletedAt = nullToUndefined2(
     row[`${alias}_deleted_at`]
   );
   const result = {
@@ -4476,7 +4611,7 @@ function buildSelectableNode(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS2);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS);
   return result;
 }
 function buildSelectableNodeOrUndefined(row, alias) {
@@ -4496,13 +4631,13 @@ function buildSelectableEdge(row, alias) {
   const toId = row[`${alias}_to_id`];
   const propsRaw = row[`${alias}_props`];
   const rawProps = typeof propsRaw === "string" ? JSON.parse(propsRaw) : propsRaw ?? {};
-  const validFrom = nullToUndefined3(
+  const validFrom = nullToUndefined2(
     row[`${alias}_valid_from`]
   );
-  const validTo = nullToUndefined3(row[`${alias}_valid_to`]);
+  const validTo = nullToUndefined2(row[`${alias}_valid_to`]);
   const createdAt = row[`${alias}_created_at`];
   const updatedAt = row[`${alias}_updated_at`];
-  const deletedAt = nullToUndefined3(
+  const deletedAt = nullToUndefined2(
     row[`${alias}_deleted_at`]
   );
   const result = {
@@ -4518,7 +4653,7 @@ function buildSelectableEdge(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS2);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS);
   return result;
 }
 function buildSelectContext(row, startAlias, traversals) {
@@ -5259,6 +5394,61 @@ function createGuardedProxy(target, debugPath) {
     }
   });
 }
+function templateHasReadInstant(template) {
+  return template.params.some(
+    (parameter) => parameter instanceof Placeholder && parameter.name === CURRENT_READ_INSTANT_PLACEHOLDER
+  );
+}
+function queryAstNeedsCurrentReadInstant(ast) {
+  return ast.temporalMode.mode === "current" && ast.recordedAsOf === void 0;
+}
+function composableNeedsCurrentReadInstant(query) {
+  if ("__type" in query) {
+    return composableNeedsCurrentReadInstant(query.left) || composableNeedsCurrentReadInstant(query.right);
+  }
+  return queryAstNeedsCurrentReadInstant(query);
+}
+function buildReadInstantTemplate(args) {
+  const { backend } = args;
+  if (backend?.compileSql === void 0) return void 0;
+  const compiled = args.compile();
+  if (!isRawExecutable(compiled)) return void 0;
+  const template = backend.compileSql(compiled);
+  if (args.needsReadInstant && !templateHasReadInstant(template)) {
+    return void 0;
+  }
+  return template;
+}
+function buildQueryTemplate(ast, graphId, compileOptions, backend) {
+  return buildReadInstantTemplate({
+    compile: () => compileQuery(ast, graphId, {
+      ...compileOptions,
+      readInstant: "placeholder"
+    }),
+    backend,
+    needsReadInstant: queryAstNeedsCurrentReadInstant(ast)
+  });
+}
+function fillTemplateParams(params, bindings, dialect) {
+  const adapter = getDialect(dialect);
+  let readInstant;
+  return params.map((parameter) => {
+    if (!(parameter instanceof Placeholder)) return parameter;
+    const name = parameter.name;
+    if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {
+      readInstant ??= nowIso();
+      return readInstant;
+    }
+    const value = bindings[name];
+    if (value === void 0) {
+      throw new ConfigurationError(`Missing binding for parameter "${name}"`, {
+        parameterName: name
+      });
+    }
+    if (value instanceof Date) return value.toISOString();
+    return adapter.bindValue(value);
+  });
+}
 
 // src/query/builder/prepared-query.ts
 function toLiteral(value) {
@@ -5399,31 +5589,9 @@ function substituteParameters(ast, bindings) {
     }
   };
 }
-function fillPlaceholders(params, bindings, dialect) {
-  const adapter = getDialect(dialect);
-  return params.map((parameter) => {
-    if (parameter instanceof Placeholder) {
-      const name = parameter.name;
-      const value = bindings[name];
-      if (value === void 0) {
-        throw new ConfigurationError(
-          `Missing binding for parameter "${name}"`,
-          { parameterName: name }
-        );
-      }
-      if (value instanceof Date) return value.toISOString();
-      return adapter.bindValue(value);
-    }
-    return parameter;
-  });
-}
 var PreparedQuery = class {
   #ast;
   #unoptimizedAst;
-  #sqlText;
-  #sqlParams;
-  #unoptimizedSqlText;
-  #unoptimizedSqlParams;
   #backend;
   #dialect;
   #graphId;
@@ -5433,13 +5601,17 @@ var PreparedQuery = class {
   #selectFn;
   #schemaIntrospector;
   #parameterMetadata;
+  /**
+   * Per-AST cached placeholder template, keyed by AST reference so the
+   * optimized (`#ast`) and unoptimized (`#unoptimizedAst`) variants cache
+   * independently. A cached `undefined` records "no fast-path template" (the
+   * backend lacks `compileSql`, or the statement was not safely cacheable) so
+   * we don't rebuild it on every call.
+   */
+  #templateCache = /* @__PURE__ */ new Map();
   constructor(config) {
     this.#ast = config.ast;
     this.#unoptimizedAst = config.unoptimizedAst;
-    this.#sqlText = config.sqlText;
-    this.#sqlParams = config.sqlParams;
-    this.#unoptimizedSqlText = config.unoptimizedSqlText;
-    this.#unoptimizedSqlParams = config.unoptimizedSqlParams;
     this.#backend = config.backend;
     this.#dialect = config.dialect;
     this.#graphId = config.graphId;
@@ -5450,6 +5622,26 @@ var PreparedQuery = class {
     this.#schemaIntrospector = config.schemaIntrospector;
     this.#parameterMetadata = collectParameterMetadata(this.#ast);
   }
+  /**
+   * The cached placeholder template for `ast`, or `undefined` when no fast
+   * path applies. Compiled once (in placeholder mode) and reused across every
+   * `execute()`; the read instant is refreshed per call by
+   * {@link fillTemplateParams}, never frozen into the cache.
+   */
+  #template(ast) {
+    if (this.#templateCache.has(ast)) return this.#templateCache.get(ast);
+    const template = this.#buildTemplate(ast);
+    this.#templateCache.set(ast, template);
+    return template;
+  }
+  #buildTemplate(ast) {
+    return buildQueryTemplate(
+      ast,
+      this.#graphId,
+      this.#compileOptions,
+      this.#backend
+    );
+  }
   /** The set of parameter names required by this prepared query. */
   get parameterNames() {
     return this.#parameterMetadata.names;
@@ -5482,26 +5674,7 @@ var PreparedQuery = class {
     return this.#executeUnoptimized(bindings);
   }
   async #executeSelectiveRows(bindings) {
-    if (this.#sqlText !== void 0 && this.#sqlParams !== void 0 && this.#backend.executeRaw !== void 0) {
-      const filledParams = fillPlaceholders(
-        this.#sqlParams,
-        bindings,
-        this.#dialect
-      );
-      const rawRows2 = await this.#backend.executeRaw(
-        this.#sqlText,
-        filledParams
-      );
-      return transformPathColumns(rawRows2, this.#state, this.#dialect);
-    }
-    const concreteAst = substituteParameters(this.#ast, bindings);
-    const compiled = compileQuery(
-      concreteAst,
-      this.#graphId,
-      this.#compileOptions
-    );
-    const rawRows = await this.#backend.execute(compiled);
-    return transformPathColumns(rawRows, this.#state, this.#dialect);
+    return this.#executeRows(this.#ast, bindings);
   }
   async #executeUnoptimized(bindings) {
     const rows = await this.#executeUnoptimizedRows(bindings);
@@ -5513,19 +5686,29 @@ var PreparedQuery = class {
     );
   }
   async #executeUnoptimizedRows(bindings) {
-    if (this.#unoptimizedSqlText !== void 0 && this.#unoptimizedSqlParams !== void 0 && this.#backend.executeRaw !== void 0) {
-      const filledParams = fillPlaceholders(
-        this.#unoptimizedSqlParams,
+    return this.#executeRows(this.#unoptimizedAst, bindings);
+  }
+  /**
+   * Runs one AST variant with the given bindings. Prefers the cached template
+   * + `executeRaw` fast path; falls back to substituting bindings into the AST
+   * and compiling fresh when the backend cannot execute raw SQL text.
+   */
+  async #executeRows(ast, bindings) {
+    const executeRaw = this.#backend.executeRaw;
+    const template = executeRaw === void 0 ? void 0 : this.#template(ast);
+    if (template !== void 0 && executeRaw !== void 0) {
+      const params = fillTemplateParams(
+        template.params,
         bindings,
         this.#dialect
       );
       const rawRows2 = await this.#backend.executeRaw(
-        this.#unoptimizedSqlText,
-        filledParams
+        template.sql,
+        params
       );
       return transformPathColumns(rawRows2, this.#state, this.#dialect);
     }
-    const concreteAst = substituteParameters(this.#unoptimizedAst, bindings);
+    const concreteAst = substituteParameters(ast, bindings);
     const compiled = compileQuery(
       concreteAst,
       this.#graphId,
@@ -5969,6 +6152,9 @@ function buildQueryAst(config, state) {
     ...state.offset !== void 0 && { offset: state.offset },
     ...state.groupBy !== void 0 && { groupBy: state.groupBy },
     ...state.having !== void 0 && { having: state.having },
+    ...state.aggregateOrderBy.length > 0 && {
+      aggregateOrderBy: state.aggregateOrderBy
+    },
     ...state.fusion !== void 0 && { fusion: state.fusion }
   };
 }
@@ -5994,12 +6180,27 @@ function buildCompileOptions(config) {
     dialect: config.dialect ?? "sqlite",
     schema: config.schema,
     windowFunctions: config.backend?.capabilities.windowFunctions ?? true,
-    ...fulltextStrategy === void 0 ? {} : { fulltextStrategy },
+    ...fulltextStrategy === void 0 ? {} : {
+      fulltextStrategy,
+      fulltextLanguages: buildFulltextLanguages(config.registry)
+    },
     ...vectorStrategy === void 0 ? {} : { vectorStrategy, vectorSlots: buildVectorSlots(config.registry) },
     ...recordedReadBinding === void 0 ? {} : { recordedReadBinding }
   };
 }
 var vectorSlotsCache = /* @__PURE__ */ new WeakMap();
+var fulltextLanguagesCache = /* @__PURE__ */ new WeakMap();
+function buildFulltextLanguages(registry) {
+  const cached = fulltextLanguagesCache.get(registry);
+  if (cached !== void 0) return cached;
+  const languages = /* @__PURE__ */ new Map();
+  for (const [nodeKind, nodeType] of registry.nodeKinds) {
+    const language = resolveDeclaredFulltextLanguage(nodeType.schema);
+    if (language !== void 0) languages.set(nodeKind, language);
+  }
+  fulltextLanguagesCache.set(registry, languages);
+  return languages;
+}
 function buildVectorSlots(registry) {
   const cached = vectorSlotsCache.get(registry);
   if (cached !== void 0) return cached;
@@ -6027,20 +6228,35 @@ var ExecutableQuery = class _ExecutableQuery {
   #config;
   #state;
   #selectFn;
-  #cachedCompiled = NOT_COMPUTED;
-  #cachedOptimizedCompiled = NOT_COMPUTED;
   #cachedSelectiveFieldsForExecute = NOT_COMPUTED;
   #cachedSelectiveFieldsForPagination = NOT_COMPUTED;
+  // The instance is immutable (every builder method returns a new instance),
+  // so the AST and its param-ref check are invariant — compute each once and
+  // reuse across execute()/paginate()/stream() instead of rebuilding per call.
+  #cachedAst;
+  #cachedHasParameterReferences;
+  // Per-instance compiled placeholder templates for the full and
+  // selective-field ASTs (NOT_COMPUTED = not yet built; undefined = no fast
+  // path). Reused across execute()/executeOn() calls so a repeated query
+  // compiles once; the read instant is filled fresh per call, never cached.
+  #fullTemplate = NOT_COMPUTED;
+  #selectiveTemplate = NOT_COMPUTED;
   constructor(config, state, selectFunction) {
     this.#config = config;
     this.#state = state;
     this.#selectFn = selectFunction;
   }
   /**
-   * Builds the query AST.
+   * Builds the query AST (memoized — the instance is immutable).
    */
   toAst() {
-    return buildQueryAst(this.#config, this.#state);
+    return this.#cachedAst ??= buildQueryAst(this.#config, this.#state);
+  }
+  /** Whether this query uses `param()` refs (memoized). */
+  #hasParameterReferences() {
+    return this.#cachedHasParameterReferences ??= hasParameterReferences(
+      this.toAst()
+    );
   }
   /**
    * Orders results.
@@ -6214,19 +6430,16 @@ var ExecutableQuery = class _ExecutableQuery {
    * with db.all(), db.get(), etc.
    */
   compile() {
-    if (this.#cachedCompiled !== NOT_COMPUTED) return this.#cachedCompiled;
     const ast = this.toAst();
-    const compiled = compileQuery(
-      ast,
-      this.#config.graphId,
-      this.#compileOptions()
-    );
-    this.#cachedCompiled = compiled;
-    return compiled;
+    return compileQuery(ast, this.#config.graphId, this.#compileOptions());
   }
   /**
-   * Creates a prepared (pre-compiled) query that can be executed
-   * multiple times with different parameter bindings.
+   * Creates a prepared (pre-validated) query that can be executed multiple
+   * times with different parameter bindings. Builds and structurally
+   * validates the AST once (a malformed query fails fast, here, instead of on
+   * first use); the prepared query then compiles once into a reusable template
+   * and fills a fresh read instant per execute() — see PreparedQuery's class
+   * doc comment.
    *
    * Use `param("name")` in predicates to create parameterized slots,
    * then pass values via `prepared.execute({ name: "value" })`.
@@ -6253,36 +6466,16 @@ var ExecutableQuery = class _ExecutableQuery {
         "Cannot prepare query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
       );
     }
-    const baseAst = buildQueryAst(this.#config, this.#state);
+    const baseAst = this.toAst();
     const selectiveFields = this.#getSelectiveFieldsForExecute();
     const ast = selectiveFields === void 0 ? baseAst : { ...baseAst, selectiveFields };
     const unoptimizedAst = baseAst;
     const compileOptions = this.#compileOptions();
-    const compiled = compileQuery(ast, this.#config.graphId, compileOptions);
-    let sqlText;
-    let sqlParams;
-    let unoptimizedSqlText;
-    let unoptimizedSqlParams;
-    if (this.#config.backend.compileSql !== void 0) {
-      const result = this.#config.backend.compileSql(compiled);
-      sqlText = result.sql;
-      sqlParams = result.params;
-      const unoptimizedCompiled = compileQuery(
-        unoptimizedAst,
-        this.#config.graphId,
-        compileOptions
-      );
-      const unoptimizedResult = this.#config.backend.compileSql(unoptimizedCompiled);
-      unoptimizedSqlText = unoptimizedResult.sql;
-      unoptimizedSqlParams = unoptimizedResult.params;
-    }
+    compileQuery(ast, this.#config.graphId, compileOptions);
+    compileQuery(unoptimizedAst, this.#config.graphId, compileOptions);
     return new PreparedQuery({
       ast,
       unoptimizedAst,
-      sqlText,
-      sqlParams,
-      unoptimizedSqlText,
-      unoptimizedSqlParams,
       backend: this.#config.backend,
       dialect: this.#config.dialect ?? "sqlite",
       graphId: this.#config.graphId,
@@ -6316,6 +6509,59 @@ var ExecutableQuery = class _ExecutableQuery {
       surface
     });
   }
+  #dialect() {
+    return this.#config.dialect ?? "sqlite";
+  }
+  /**
+   * The cached placeholder template for one AST variant (`"full"` or
+   * `"selective"`), or `undefined` when no fast path applies. Built once per
+   * instance from the store backend's compiler; reusable across executions and
+   * across store/transaction backends of the same dialect, since SQL text and
+   * parameters depend only on the AST and dialect. The read instant is filled
+   * fresh per call by {@link fillTemplateParams}, never frozen into the cache.
+   */
+  #templateFor(ast, slot) {
+    const cached = slot === "full" ? this.#fullTemplate : this.#selectiveTemplate;
+    if (cached !== NOT_COMPUTED) return cached;
+    const built = this.#buildTemplate(ast);
+    if (slot === "full") this.#fullTemplate = built;
+    else this.#selectiveTemplate = built;
+    return built;
+  }
+  #buildTemplate(ast) {
+    return buildQueryTemplate(
+      ast,
+      this.#config.graphId,
+      this.#compileOptions(),
+      this.#config.backend
+    );
+  }
+  /**
+   * Fetches raw rows for one AST variant, path-column-normalized. Prefers the
+   * cached template + `executeRaw` fast path; falls back to a fresh literal
+   * compile via `backend.execute` when the backend cannot run raw SQL text (in
+   * which case no template is built). Callers map the returned rows to typed
+   * results.
+   */
+  async #fetchRows(backend, ast, slot, surface) {
+    const executeRaw = backend.executeRaw;
+    const template = executeRaw === void 0 ? void 0 : this.#templateFor(ast, slot);
+    const rawRows = await this.#executeOnBackend(
+      backend,
+      template !== void 0 && executeRaw !== void 0 ? (
+        // Method call (not the detached `executeRaw` local) so a this-using
+        // backend implementation keeps its receiver.
+        backend.executeRaw(
+          template.sql,
+          fillTemplateParams(template.params, {}, this.#dialect())
+        )
+      ) : backend.execute(
+        compileQuery(ast, this.#config.graphId, this.#compileOptions())
+      ),
+      surface
+    );
+    return transformPathColumns(rawRows, this.#state, this.#dialect());
+  }
   /**
    * Executes the query and returns typed results.
    *
@@ -6333,7 +6579,8 @@ var ExecutableQuery = class _ExecutableQuery {
       );
     }
     const backend = this.#config.backend;
-    if (hasParameterReferences(this.toAst())) {
+    const ast = this.toAst();
+    if (this.#hasParameterReferences()) {
       throw new Error(
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
@@ -6342,14 +6589,7 @@ var ExecutableQuery = class _ExecutableQuery {
     if (optimizedResult !== void 0) {
       return optimizedResult;
     }
-    const compiled = this.compile();
-    const rawRows = await this.#executeOnBackend(
-      backend,
-      backend.execute(compiled),
-      "recorded-query"
-    );
-    this.#config.dialect ?? "sqlite";
-    const rows = transformPathColumns(rawRows, this.#state);
+    const rows = await this.#fetchRows(backend, ast, "full", "recorded-query");
     return mapResults(
       rows,
       this.#state.startAlias,
@@ -6366,7 +6606,7 @@ var ExecutableQuery = class _ExecutableQuery {
    */
   async executeOn(backend) {
     const ast = this.toAst();
-    if (hasParameterReferences(ast)) {
+    if (this.#hasParameterReferences()) {
       throw new Error(
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
@@ -6375,14 +6615,12 @@ var ExecutableQuery = class _ExecutableQuery {
     if (optimizedResult !== void 0) {
       return optimizedResult;
     }
-    const compiled = this.compile();
-    const rawRows = await this.#executeOnBackend(
+    const rows = await this.#fetchRows(
       backend,
-      backend.execute(compiled),
+      ast,
+      "full",
       "recorded-batch-query"
     );
-    this.#config.dialect ?? "sqlite";
-    const rows = transformPathColumns(rawRows, this.#state);
     return mapResults(
       rows,
       this.#state.startAlias,
@@ -6401,30 +6639,15 @@ var ExecutableQuery = class _ExecutableQuery {
     if (selectiveFields === void 0) {
       return void 0;
     }
-    let compiled;
-    if (this.#cachedOptimizedCompiled === NOT_COMPUTED) {
-      const baseAst = buildQueryAst(this.#config, this.#state);
-      const selectiveAst = {
-        ...baseAst,
-        selectiveFields
-      };
-      compiled = compileQuery(
-        selectiveAst,
-        this.#config.graphId,
-        this.#compileOptions()
-      );
-      this.#cachedOptimizedCompiled = compiled;
-    } else {
-      compiled = this.#cachedOptimizedCompiled;
-    }
+    const baseAst = this.toAst();
+    const selectiveAst = { ...baseAst, selectiveFields };
     const backend = this.#requireBackend();
-    const rawSelectiveRows = await this.#executeOnBackend(
+    const rows = await this.#fetchRows(
       backend,
-      backend.execute(compiled),
+      selectiveAst,
+      "selective",
       "recorded-query"
     );
-    this.#config.dialect ?? "sqlite";
-    const rows = transformPathColumns(rawSelectiveRows, this.#state);
     try {
       return mapSelectiveResults(
         rows,
@@ -6436,12 +6659,10 @@ var ExecutableQuery = class _ExecutableQuery {
     } catch (error) {
       if (error instanceof MissingSelectiveFieldError) {
         this.#cachedSelectiveFieldsForExecute = void 0;
-        this.#cachedOptimizedCompiled = NOT_COMPUTED;
         return void 0;
       }
       if (error instanceof UnsupportedPredicateError) {
         this.#cachedSelectiveFieldsForExecute = void 0;
-        this.#cachedOptimizedCompiled = NOT_COMPUTED;
         return void 0;
       }
       throw error;
@@ -6456,29 +6677,14 @@ var ExecutableQuery = class _ExecutableQuery {
     if (selectiveFields === void 0) {
       return void 0;
     }
-    let compiled;
-    if (this.#cachedOptimizedCompiled === NOT_COMPUTED) {
-      const baseAst = buildQueryAst(this.#config, this.#state);
-      const selectiveAst = {
-        ...baseAst,
-        selectiveFields
-      };
-      compiled = compileQuery(
-        selectiveAst,
-        this.#config.graphId,
-        this.#compileOptions()
-      );
-      this.#cachedOptimizedCompiled = compiled;
-    } else {
-      compiled = this.#cachedOptimizedCompiled;
-    }
-    const rawSelectiveRows = await this.#executeOnBackend(
+    const baseAst = this.toAst();
+    const selectiveAst = { ...baseAst, selectiveFields };
+    const rows = await this.#fetchRows(
       backend,
-      backend.execute(compiled),
+      selectiveAst,
+      "selective",
       "recorded-batch-query"
     );
-    this.#config.dialect ?? "sqlite";
-    const rows = transformPathColumns(rawSelectiveRows, this.#state);
     try {
       return mapSelectiveResults(
         rows,
@@ -6490,12 +6696,10 @@ var ExecutableQuery = class _ExecutableQuery {
     } catch (error) {
       if (error instanceof MissingSelectiveFieldError) {
         this.#cachedSelectiveFieldsForExecute = void 0;
-        this.#cachedOptimizedCompiled = NOT_COMPUTED;
         return void 0;
       }
       if (error instanceof UnsupportedPredicateError) {
         this.#cachedSelectiveFieldsForExecute = void 0;
-        this.#cachedOptimizedCompiled = NOT_COMPUTED;
         return void 0;
       }
       throw error;
@@ -7003,7 +7207,10 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
   #config;
   #state;
   #fields;
-  #cachedCompiled = NOT_COMPUTED2;
+  // Per-instance compiled placeholder template, reused across execute() calls
+  // (see #resolveTemplate). NOT_COMPUTED = not yet built; undefined = no fast
+  // path.
+  #template = NOT_COMPUTED2;
   constructor(config, state, fields) {
     this.#config = config;
     this.#state = state;
@@ -7015,6 +7222,43 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
   toAst() {
     return buildQueryAst(this.#config, this.#state);
   }
+  /**
+   * Orders results by a grouped field or aggregate alias.
+   *
+   * `key` is one of the output names passed to `.aggregate({...})` — either
+   * a grouped field (e.g. `genre`) or an aggregate alias (e.g. `bookCount`).
+   * Both are ordered the same way: by referencing the SELECT-list output
+   * column, since every `.aggregate()` field is projected with an alias.
+   *
+   * Chain multiple calls to sort by more than one key, in call order:
+   * `.orderBy("genre").orderBy("bookCount", "desc")` sorts by genre first,
+   * then by book count within each genre.
+   *
+   * @example
+   * ```typescript
+   * // Top 2 authors by book count
+   * store.query()
+   *   .from("Author", "a")
+   *   .traverse("wrote", "e")
+   *   .to("Book", "b")
+   *   .groupByNode("a")
+   *   .aggregate({ author: field("a", "name"), bookCount: count("b") })
+   *   .orderBy("bookCount", "desc")
+   *   .limit(2)
+   *   .execute();
+   * ```
+   */
+  orderBy(key, direction = "asc") {
+    const orderSpec = { outputName: key, direction };
+    return new _ExecutableAggregateQuery(
+      this.#config,
+      {
+        ...this.#state,
+        aggregateOrderBy: [...this.#state.aggregateOrderBy, orderSpec]
+      },
+      this.#fields
+    );
+  }
   /**
    * Limits the number of results.
    */
@@ -7053,34 +7297,61 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
    * Compiles the query to a Drizzle SQL object.
    */
   compile() {
-    if (this.#cachedCompiled !== NOT_COMPUTED2) {
-      return this.#cachedCompiled;
-    }
     const ast = this.toAst();
-    const compiled = compileQuery(
-      ast,
-      this.#config.graphId,
-      this.#compileOptions()
-    );
-    this.#cachedCompiled = compiled;
-    return compiled;
+    return compileQuery(ast, this.#config.graphId, this.#compileOptions());
   }
   #compileOptions() {
     return buildCompileOptions(this.#config);
   }
+  /**
+   * The cached placeholder template for this aggregate query, or `undefined`
+   * when no fast path applies. Built once per instance; the read instant is
+   * filled fresh per execution by {@link fillTemplateParams}.
+   */
+  #resolveTemplate(ast) {
+    if (this.#template !== NOT_COMPUTED2) return this.#template;
+    this.#template = buildQueryTemplate(
+      ast,
+      this.#config.graphId,
+      this.#compileOptions(),
+      this.#config.backend
+    );
+    return this.#template;
+  }
   /**
    * Executes the query and returns typed results.
    *
    * @throws Error if no backend is configured
    */
   async execute() {
-    if (!this.#config.backend) {
+    const backend = this.#config.backend;
+    if (!backend) {
       throw new Error(
         "Cannot execute query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
       );
     }
-    const compiled = this.compile();
-    const rows = await this.#config.backend.execute(compiled);
+    const ast = this.toAst();
+    if (hasParameterReferences(ast)) {
+      throw new Error(
+        "Aggregate queries do not support param() references; bind a concrete value instead."
+      );
+    }
+    const executeRaw = backend.executeRaw;
+    const template = executeRaw === void 0 ? void 0 : this.#resolveTemplate(ast);
+    const rows = template !== void 0 && executeRaw !== void 0 ? (
+      // Method call (not the detached `executeRaw` local) so a this-using
+      // backend implementation keeps its receiver.
+      await backend.executeRaw(
+        template.sql,
+        fillTemplateParams(
+          template.params,
+          {},
+          this.#config.dialect ?? "sqlite"
+        )
+      )
+    ) : await backend.execute(
+      compileQuery(ast, this.#config.graphId, this.#compileOptions())
+    );
     return this.#mapResults(rows);
   }
   /**
@@ -8234,7 +8505,6 @@ var QueryBuilder = class _QueryBuilder {
 };
 
 // src/query/builder/unionable-query.ts
-var NOT_COMPUTED3 = /* @__PURE__ */ Symbol("NOT_COMPUTED");
 function executeOnBackend(backend, recordedAsOf, promise, surface) {
   if (recordedAsOf === void 0) return promise;
   return withRecordedRelationsPrecondition(promise, {
@@ -8248,10 +8518,14 @@ function recordedAsOfForComposableQuery(query) {
   }
   return query.recordedAsOf;
 }
+var NOT_COMPUTED3 = /* @__PURE__ */ Symbol("NOT_COMPUTED");
 var UnionableQuery = class _UnionableQuery {
   #config;
   #state;
-  #cachedCompiled = NOT_COMPUTED3;
+  // Per-instance compiled placeholder template, reused across
+  // execute()/executeOn() calls; the read instant is filled fresh per call.
+  // NOT_COMPUTED = not yet built; undefined = no fast path.
+  #template = NOT_COMPUTED3;
   constructor(config, state) {
     this.#config = config;
     this.#state = state;
@@ -8379,20 +8653,76 @@ var UnionableQuery = class _UnionableQuery {
    * Compiles the set operation to SQL.
    */
   compile() {
-    if (this.#cachedCompiled !== NOT_COMPUTED3) {
-      return this.#cachedCompiled;
-    }
-    const compiled = compileSetOperation2(
+    return compileSetOperation2(
       this.toAst(),
       this.#config.graphId,
       this.#compileOptions()
     );
-    this.#cachedCompiled = compiled;
-    return compiled;
   }
   #compileOptions() {
     return buildCompileOptions(this.#config);
   }
+  /**
+   * The cached placeholder template for this set operation, or `undefined`
+   * when no fast path applies. Built once per instance; every operand's read
+   * instant is the shared placeholder, filled fresh per execution by
+   * {@link fillTemplateParams}.
+   */
+  #resolveTemplate(ast) {
+    if (this.#template !== NOT_COMPUTED3) return this.#template;
+    this.#template = buildReadInstantTemplate({
+      compile: () => compileSetOperation2(ast, this.#config.graphId, {
+        ...this.#compileOptions(),
+        readInstant: "placeholder"
+      }),
+      backend: this.#config.backend,
+      needsReadInstant: composableNeedsCurrentReadInstant(ast)
+    });
+    return this.#template;
+  }
+  /**
+   * Fetches raw rows for the set operation: cached template + `executeRaw`
+   * when available, else a fresh literal compile via `backend.execute`.
+   */
+  async #fetchRows(backend, ast, surface) {
+    const executeRaw = backend.executeRaw;
+    const template = executeRaw === void 0 ? void 0 : this.#resolveTemplate(ast);
+    return executeOnBackend(
+      backend,
+      recordedAsOfForComposableQuery(ast),
+      template !== void 0 && executeRaw !== void 0 ? (
+        // Method call (not the detached `executeRaw` local) so a this-using
+        // backend implementation keeps its receiver.
+        backend.executeRaw(
+          template.sql,
+          fillTemplateParams(
+            template.params,
+            {},
+            this.#config.dialect ?? "sqlite"
+          )
+        )
+      ) : backend.execute(
+        compileSetOperation2(
+          ast,
+          this.#config.graphId,
+          this.#compileOptions()
+        )
+      ),
+      surface
+    );
+  }
+  /** Applies the select-function transformation, if one is attached. */
+  #mapRows(rows) {
+    if (this.#state.selectFn && this.#state.startAlias) {
+      return mapResults(
+        rows,
+        this.#state.startAlias,
+        this.#state.traversals ?? [],
+        this.#state.selectFn
+      );
+    }
+    return rows;
+  }
   /**
    * Executes the combined query.
    */
@@ -8409,22 +8739,7 @@ var UnionableQuery = class _UnionableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
-    const compiled = this.compile();
-    const rows = await executeOnBackend(
-      backend,
-      recordedAsOfForComposableQuery(ast),
-      backend.execute(compiled),
-      "recorded-query"
-    );
-    if (this.#state.selectFn && this.#state.startAlias) {
-      return mapResults(
-        rows,
-        this.#state.startAlias,
-        this.#state.traversals ?? [],
-        this.#state.selectFn
-      );
-    }
-    return rows;
+    return this.#mapRows(await this.#fetchRows(backend, ast, "recorded-query"));
   }
   /**
    * Executes the combined query against a provided backend.
@@ -8438,23 +8753,9 @@ var UnionableQuery = class _UnionableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
-    const compiled = this.compile();
-    const recordedAsOf = recordedAsOfForComposableQuery(ast);
-    const rows = await executeOnBackend(
-      backend,
-      recordedAsOf,
-      backend.execute(compiled),
-      "recorded-batch-query"
+    return this.#mapRows(
+      await this.#fetchRows(backend, ast, "recorded-batch-query")
     );
-    if (this.#state.selectFn && this.#state.startAlias) {
-      return mapResults(
-        rows,
-        this.#state.startAlias,
-        this.#state.traversals ?? [],
-        this.#state.selectFn
-      );
-    }
-    return rows;
   }
 };
 
@@ -8674,6 +8975,7 @@ function createQueryBuilderWithContext(graphId, registry, options) {
     predicates: [],
     projection: [],
     orderBy: [],
+    aggregateOrderBy: [],
     limit: void 0,
     offset: void 0,
     temporalMode: sealed?.mode ?? "current",
@@ -8836,7 +9138,7 @@ function processPage(schema, rows) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(row.props);
+      parsed = rowPropsToObject(row.props);
     } catch {
       skipped += 1;
       skippedIds.push(row.id);
@@ -8860,21 +9162,84 @@ function processPage(schema, rows) {
   }
   return { toUpsert, toDelete, skipped, skippedIds };
 }
-
-// src/store/search.ts
-function resolveSearchSlot(ctx, nodeKind, fieldPath) {
+var SEARCH_CANDIDATE_ALIAS = "_sc";
+function buildKindCandidates(ctx, nodeKind, where) {
+  if (where === void 0) return void 0;
+  if (ctx.createQuery === void 0) {
+    throw new ConfigurationError(
+      "search with a where predicate requires a query-capable store",
+      { capability: "search", graphId: ctx.graphId }
+    );
+  }
+  const chain = ctx.createQuery().from(nodeKind, SEARCH_CANDIDATE_ALIAS).whereNode(SEARCH_CANDIDATE_ALIAS, where);
+  const compiled = chain.select(
+    (aliases) => aliases[SEARCH_CANDIDATE_ALIAS]
+  ).compile();
+  return sql`SELECT ${sql.raw(`"${SEARCH_CANDIDATE_ALIAS}_id"`)} AS node_id FROM (${compiled}) AS tg_search_candidates`;
+}
+function resolveSearchKinds(ctx, nodeKind, includeSubClasses) {
+  if (includeSubClasses !== true) return [nodeKind];
+  if (ctx.createQuery === void 0) {
+    throw new ConfigurationError(
+      "search with includeSubClasses requires a query-capable store",
+      { capability: "search", graphId: ctx.graphId }
+    );
+  }
+  return ctx.registry.expandSubClasses(nodeKind);
+}
+function assertSearchOffset(offset, label) {
+  if (offset === void 0) return;
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new RangeError(
+      `${label} must be a non-negative integer, got: ${offset}`
+    );
+  }
+}
+function effectiveFulltextLanguage(ctx, nodeKind, override) {
+  if (override !== void 0) return override;
   const nodeType = ctx.registry.getNodeType(nodeKind);
-  if (nodeType !== void 0) {
-    const fields = getEmbeddingFields(nodeType.schema);
-    const field2 = fields.find((entry2) => entry2.fieldPath === fieldPath);
-    if (field2 !== void 0) {
-      return {
-        dimensions: field2.dimensions,
-        metric: field2.metric,
-        indexType: field2.indexType
-      };
-    }
+  if (nodeType === void 0) return void 0;
+  return resolveDeclaredFulltextLanguage(nodeType.schema);
+}
+function searchNodeKey(kind, nodeId) {
+  return `${kind}\0${nodeId}`;
+}
+function scoreDescending(metric) {
+  return metric === "cosine";
+}
+async function fetchNodesForRows(backend, graphId, rows) {
+  const idsByKind = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const ids = idsByKind.get(row.kind) ?? /* @__PURE__ */ new Set();
+    ids.add(row.nodeId);
+    idsByKind.set(row.kind, ids);
   }
+  const map = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...idsByKind].map(async ([kind, ids]) => {
+      const kindMap = await fetchNodesByIds(backend, graphId, kind, [...ids]);
+      for (const [id, node] of kindMap) {
+        map.set(searchNodeKey(kind, id), node);
+      }
+    })
+  );
+  return map;
+}
+function tryResolveSearchSlot(ctx, nodeKind, fieldPath) {
+  const nodeType = ctx.registry.getNodeType(nodeKind);
+  if (nodeType === void 0) return void 0;
+  const fields = getEmbeddingFields(nodeType.schema);
+  const field2 = fields.find((entry2) => entry2.fieldPath === fieldPath);
+  if (field2 === void 0) return void 0;
+  return {
+    dimensions: field2.dimensions,
+    metric: field2.metric,
+    indexType: field2.indexType
+  };
+}
+function resolveSearchSlot(ctx, nodeKind, fieldPath) {
+  const slot = tryResolveSearchSlot(ctx, nodeKind, fieldPath);
+  if (slot !== void 0) return slot;
   throw new ConfigurationError(
     `Node kind "${nodeKind}" has no embedding field "${fieldPath}". Declare it with embedding(dimensions) on the node schema.`,
     { capability: "vector", graphId: ctx.graphId }
@@ -8893,29 +9258,50 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
       `fulltextSearch.limit must be a positive integer, got: ${options.limit}`
     );
   }
+  assertSearchOffset(options.offset, "fulltextSearch.offset");
   validateFulltextCallOptions(backend, {
     mode: options.mode,
     includeSnippets: options.includeSnippets,
     language: options.language
   });
-  const params = {
-    graphId,
-    nodeKind,
-    query: options.query,
-    limit: options.limit,
-    ...options.mode ? { mode: options.mode } : {},
-    ...options.language ? { language: options.language } : {},
-    ...options.minScore === void 0 ? {} : { minScore: options.minScore },
-    ...options.includeSnippets === void 0 ? {} : { includeSnippets: options.includeSnippets }
-  };
-  const rows = await backend.fulltextSearch(params);
-  if (rows.length === 0) return [];
-  const ids = rows.map((row) => row.nodeId);
-  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+  const kinds = resolveSearchKinds(ctx, nodeKind, options.includeSubClasses);
+  const offset = options.offset ?? 0;
+  const singleKind = kinds.length === 1;
+  const perKindRows = await Promise.all(
+    kinds.map(async (kind) => {
+      const candidates = buildKindCandidates(ctx, kind, options.where);
+      const language = effectiveFulltextLanguage(ctx, kind, options.language);
+      const rows = await backend.fulltextSearch({
+        graphId,
+        nodeKind: kind,
+        query: options.query,
+        // A single kind pushes the page into SQL; multiple kinds fetch
+        // each kind's full page-covering prefix and re-slice after merge.
+        limit: singleKind ? options.limit : options.limit + offset,
+        ...singleKind && offset > 0 ? { offset } : {},
+        ...candidates === void 0 ? {} : { candidates },
+        ...options.mode ? { mode: options.mode } : {},
+        ...language === void 0 ? {} : { language },
+        ...options.minScore === void 0 ? {} : { minScore: options.minScore },
+        ...options.includeSnippets === void 0 ? {} : { includeSnippets: options.includeSnippets }
+      });
+      return rows.map((row) => ({
+        kind,
+        nodeId: row.nodeId,
+        score: row.score,
+        ...row.snippet === void 0 ? {} : { snippet: row.snippet }
+      }));
+    })
+  );
+  const merged = singleKind ? perKindRows[0] : perKindRows.flat().toSorted(
+    (a, b) => b.score - a.score || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
+  ).slice(offset, offset + options.limit);
+  if (merged.length === 0) return [];
+  const nodeMap = await fetchNodesForRows(backend, graphId, merged);
   const hits = [];
   let rank = 1;
-  for (const row of rows) {
-    const node = nodeMap.get(row.nodeId);
+  for (const row of merged) {
+    const node = nodeMap.get(searchNodeKey(row.kind, row.nodeId));
     if (!node) continue;
     hits.push({
       node,
@@ -8941,46 +9327,106 @@ async function executeVectorSearch(ctx, nodeKind, options) {
     );
   }
   assertEfSearch(options.efSearch, "vectorSearch.efSearch");
-  const slot = resolveSearchSlot(ctx, nodeKind, options.fieldPath);
-  assertVectorQueryCompatible(
-    backend,
-    slot,
-    { metric: options.metric, queryEmbedding: options.queryEmbedding },
+  assertSearchOffset(options.offset, "vectorSearch.offset");
+  const searchKinds = resolveVectorSearchKinds(
+    ctx,
+    nodeKind,
+    options.fieldPath,
+    options.includeSubClasses,
     "vectorSearch"
   );
-  assertMinScore(
-    options.minScore,
-    options.metric ?? slot.metric,
-    "vectorSearch.minScore"
+  for (const { slot } of searchKinds) {
+    assertVectorQueryCompatible(
+      backend,
+      slot,
+      { metric: options.metric, queryEmbedding: options.queryEmbedding },
+      "vectorSearch"
+    );
+    assertMinScore(
+      options.minScore,
+      options.metric ?? slot.metric,
+      "vectorSearch.minScore"
+    );
+  }
+  const offset = options.offset ?? 0;
+  const singleKind = searchKinds.length === 1;
+  const metric = options.metric ?? searchKinds[0].slot.metric;
+  const perKindRows = await Promise.all(
+    searchKinds.map(
+      async ({ kind, slot }) => {
+        const candidates = buildKindCandidates(ctx, kind, options.where);
+        const rows = await backend.vectorSearch({
+          graphId,
+          nodeKind: kind,
+          fieldPath: options.fieldPath,
+          queryEmbedding: options.queryEmbedding,
+          // Default to the field's DECLARED metric (the metric its index was
+          // built for); only an explicit caller override changes it.
+          // Defaulting to cosine here would mis-rank l2 / inner_product
+          // fields and bypass their ANN index.
+          metric,
+          dimensions: slot.dimensions,
+          indexType: slot.indexType,
+          // A single kind pushes the page into SQL; multiple kinds fetch
+          // each kind's full page-covering prefix and re-slice after merge.
+          limit: singleKind ? options.limit : options.limit + offset,
+          ...singleKind && offset > 0 ? { offset } : {},
+          ...candidates === void 0 ? {} : { candidates },
+          ...options.minScore === void 0 ? {} : { minScore: options.minScore },
+          ...options.efSearch === void 0 ? {} : { efSearch: options.efSearch }
+        });
+        return rows.map((row) => ({
+          kind,
+          nodeId: row.nodeId,
+          score: row.score
+        }));
+      }
+    )
+  );
+  const merged = singleKind ? perKindRows[0] : mergeVectorRows(perKindRows, metric).slice(
+    offset,
+    offset + options.limit
   );
-  const rows = await backend.vectorSearch({
-    graphId,
-    nodeKind,
-    fieldPath: options.fieldPath,
-    queryEmbedding: options.queryEmbedding,
-    // Default to the field's DECLARED metric (the metric its index was built
-    // for); only an explicit caller override changes it. Defaulting to cosine
-    // here would mis-rank l2 / inner_product fields and bypass their ANN index.
-    metric: options.metric ?? slot.metric,
-    dimensions: slot.dimensions,
-    indexType: slot.indexType,
-    limit: options.limit,
-    ...options.minScore === void 0 ? {} : { minScore: options.minScore },
-    ...options.efSearch === void 0 ? {} : { efSearch: options.efSearch }
-  });
-  if (rows.length === 0) return [];
-  const ids = rows.map((row) => row.nodeId);
-  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+  if (merged.length === 0) return [];
+  const nodeMap = await fetchNodesForRows(backend, graphId, merged);
   const hits = [];
   let rank = 1;
-  for (const row of rows) {
-    const node = nodeMap.get(row.nodeId);
+  for (const row of merged) {
+    const node = nodeMap.get(searchNodeKey(row.kind, row.nodeId));
     if (!node) continue;
     hits.push({ node, score: row.score, rank });
     rank += 1;
   }
   return hits;
 }
+function resolveVectorSearchKinds(ctx, nodeKind, fieldPath, includeSubClasses, label) {
+  const kinds = resolveSearchKinds(ctx, nodeKind, includeSubClasses);
+  const resolved = [];
+  for (const kind of kinds) {
+    const slot = tryResolveSearchSlot(ctx, kind, fieldPath);
+    if (slot !== void 0) resolved.push({ kind, slot });
+  }
+  if (resolved.length === 0) resolveSearchSlot(ctx, nodeKind, fieldPath);
+  const metrics = new Set(resolved.map(({ slot }) => slot.metric));
+  if (metrics.size > 1) {
+    throw new ConfigurationError(
+      `${label}: kinds expanded from "${nodeKind}" declare different metrics for "${fieldPath}" (${[...metrics].join(", ")}). Cross-kind vector ranking requires one shared declared metric \u2014 search the kinds separately.`,
+      { capability: "vector", graphId: ctx.graphId }
+    );
+  }
+  return resolved;
+}
+function mergeVectorRows(perKindRows, metric) {
+  const descending = scoreDescending(metric);
+  return perKindRows.flat().toSorted(
+    (a, b) => (descending ? b.score - a.score : a.score - b.score) || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
+  );
+}
+function mergeFulltextRows(perKindRows) {
+  return perKindRows.flat().toSorted(
+    (a, b) => b.score - a.score || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
+  );
+}
 async function executeHybridSearch(ctx, nodeKind, options) {
   const { backend, graphId } = ctx;
   if (!backend.vectorSearch) {
@@ -9009,50 +9455,165 @@ async function executeHybridSearch(ctx, nodeKind, options) {
     includeSnippets: options.fulltext.includeSnippets,
     language: options.fulltext.language
   });
+  assertSearchOffset(options.offset, "hybridSearch.offset");
   const fusionK = options.fusion?.k ?? DEFAULT_RRF_K;
   const vectorWeight = options.fusion?.weights?.vector ?? DEFAULT_RRF_WEIGHT;
   const fulltextWeight = options.fusion?.weights?.fulltext ?? DEFAULT_RRF_WEIGHT;
+  const offset = options.offset ?? 0;
   const overFetchMultiplier = 4;
-  const vectorK = options.vector.k ?? options.limit * overFetchMultiplier;
-  const fulltextK = options.fulltext.k ?? options.limit * overFetchMultiplier;
-  const vectorSlot = resolveSearchSlot(ctx, nodeKind, options.vector.fieldPath);
-  assertVectorQueryCompatible(
-    backend,
-    vectorSlot,
-    {
-      metric: options.vector.metric,
-      queryEmbedding: options.vector.queryEmbedding
-    },
-    "hybridSearch.vector"
-  );
-  assertMinScore(
-    options.vector.minScore,
-    options.vector.metric ?? vectorSlot.metric,
-    "hybridSearch.vector.minScore"
-  );
-  const vectorPromise = backend.vectorSearch({
-    graphId,
+  const pageLimit = options.limit + offset;
+  const vectorK = options.vector.k ?? pageLimit * overFetchMultiplier;
+  const fulltextK = options.fulltext.k ?? pageLimit * overFetchMultiplier;
+  const fulltextKinds = resolveSearchKinds(
+    ctx,
     nodeKind,
-    fieldPath: options.vector.fieldPath,
-    queryEmbedding: options.vector.queryEmbedding,
-    // Default to the field's declared metric (see executeVectorSearch).
-    metric: options.vector.metric ?? vectorSlot.metric,
-    dimensions: vectorSlot.dimensions,
-    indexType: vectorSlot.indexType,
-    limit: vectorK,
-    ...options.vector.minScore === void 0 ? {} : { minScore: options.vector.minScore },
-    ...options.vector.efSearch === void 0 ? {} : { efSearch: options.vector.efSearch }
-  });
-  const fulltextPromise = backend.fulltextSearch({
-    graphId,
+    options.includeSubClasses
+  );
+  const vectorKinds = resolveVectorSearchKinds(
+    ctx,
     nodeKind,
-    query: options.fulltext.query,
-    limit: fulltextK,
-    ...options.fulltext.mode ? { mode: options.fulltext.mode } : {},
-    ...options.fulltext.language ? { language: options.fulltext.language } : {},
-    ...options.fulltext.minScore === void 0 ? {} : { minScore: options.fulltext.minScore },
-    ...options.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: options.fulltext.includeSnippets }
-  });
+    options.vector.fieldPath,
+    options.includeSubClasses,
+    "hybridSearch.vector"
+  );
+  for (const { slot } of vectorKinds) {
+    assertVectorQueryCompatible(
+      backend,
+      slot,
+      {
+        metric: options.vector.metric,
+        queryEmbedding: options.vector.queryEmbedding
+      },
+      "hybridSearch.vector"
+    );
+    assertMinScore(
+      options.vector.minScore,
+      options.vector.metric ?? slot.metric,
+      "hybridSearch.vector.minScore"
+    );
+  }
+  const vectorMetric = options.vector.metric ?? vectorKinds[0].slot.metric;
+  const candidatesByKind = /* @__PURE__ */ new Map();
+  for (const kind of fulltextKinds) {
+    candidatesByKind.set(kind, buildKindCandidates(ctx, kind, options.where));
+  }
+  for (const { kind } of vectorKinds) {
+    if (!candidatesByKind.has(kind)) {
+      candidatesByKind.set(kind, buildKindCandidates(ctx, kind, options.where));
+    }
+  }
+  if (backend.hybridSearch !== void 0 && fulltextKinds.length === 1 && vectorKinds.length === 1 && fulltextKinds[0] === vectorKinds[0].kind) {
+    const kind = fulltextKinds[0];
+    const { slot } = vectorKinds[0];
+    const candidates = candidatesByKind.get(kind);
+    const hybridFulltextLanguage = effectiveFulltextLanguage(
+      ctx,
+      kind,
+      options.fulltext.language
+    );
+    const rows = await backend.hybridSearch({
+      graphId,
+      nodeKind: kind,
+      vector: {
+        fieldPath: options.vector.fieldPath,
+        queryEmbedding: options.vector.queryEmbedding,
+        metric: vectorMetric,
+        dimensions: slot.dimensions,
+        indexType: slot.indexType,
+        k: vectorK,
+        ...options.vector.minScore === void 0 ? {} : { minScore: options.vector.minScore },
+        ...options.vector.efSearch === void 0 ? {} : { efSearch: options.vector.efSearch }
+      },
+      fulltext: {
+        query: options.fulltext.query,
+        k: fulltextK,
+        ...options.fulltext.mode ? { mode: options.fulltext.mode } : {},
+        ...hybridFulltextLanguage === void 0 ? {} : { language: hybridFulltextLanguage },
+        ...options.fulltext.minScore === void 0 ? {} : { minScore: options.fulltext.minScore },
+        ...options.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: options.fulltext.includeSnippets }
+      },
+      fusion: { k: fusionK, vectorWeight, fulltextWeight },
+      limit: options.limit,
+      ...offset === 0 ? {} : { offset },
+      ...candidates === void 0 ? {} : { candidates }
+    });
+    return rows.map((row, index) => {
+      const typedNode = rowToNode(row.node);
+      return {
+        node: typedNode,
+        score: row.fusedScore,
+        rank: index + 1,
+        ...row.vectorRank !== void 0 && row.vectorScore !== void 0 ? {
+          vector: {
+            node: typedNode,
+            score: row.vectorScore,
+            rank: row.vectorRank
+          }
+        } : {},
+        ...row.fulltextRank !== void 0 && row.fulltextScore !== void 0 ? {
+          fulltext: {
+            node: typedNode,
+            score: row.fulltextScore,
+            rank: row.fulltextRank,
+            ...row.snippet === void 0 ? {} : { snippet: row.snippet }
+          }
+        } : {}
+      };
+    });
+  }
+  const vectorPromise = Promise.all(
+    vectorKinds.map(
+      async ({ kind, slot }) => {
+        const candidates = candidatesByKind.get(kind);
+        const rows = await backend.vectorSearch({
+          graphId,
+          nodeKind: kind,
+          fieldPath: options.vector.fieldPath,
+          queryEmbedding: options.vector.queryEmbedding,
+          // Default to the field's declared metric (see executeVectorSearch).
+          metric: vectorMetric,
+          dimensions: slot.dimensions,
+          indexType: slot.indexType,
+          limit: vectorK,
+          ...candidates === void 0 ? {} : { candidates },
+          ...options.vector.minScore === void 0 ? {} : { minScore: options.vector.minScore },
+          ...options.vector.efSearch === void 0 ? {} : { efSearch: options.vector.efSearch }
+        });
+        return rows.map((row) => ({
+          kind,
+          nodeId: row.nodeId,
+          score: row.score
+        }));
+      }
+    )
+  ).then((perKind) => mergeVectorRows(perKind, vectorMetric).slice(0, vectorK));
+  const fulltextPromise = Promise.all(
+    fulltextKinds.map(async (kind) => {
+      const candidates = candidatesByKind.get(kind);
+      const language = effectiveFulltextLanguage(
+        ctx,
+        kind,
+        options.fulltext.language
+      );
+      const rows = await backend.fulltextSearch({
+        graphId,
+        nodeKind: kind,
+        query: options.fulltext.query,
+        limit: fulltextK,
+        ...candidates === void 0 ? {} : { candidates },
+        ...options.fulltext.mode ? { mode: options.fulltext.mode } : {},
+        ...language === void 0 ? {} : { language },
+        ...options.fulltext.minScore === void 0 ? {} : { minScore: options.fulltext.minScore },
+        ...options.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: options.fulltext.includeSnippets }
+      });
+      return rows.map((row) => ({
+        kind,
+        nodeId: row.nodeId,
+        score: row.score,
+        ...row.snippet === void 0 ? {} : { snippet: row.snippet }
+      }));
+    })
+  ).then((perKind) => mergeFulltextRows(perKind).slice(0, fulltextK));
   const [vectorRows, fulltextRows] = await Promise.all([
     vectorPromise,
     fulltextPromise
@@ -9061,19 +9622,23 @@ async function executeHybridSearch(ctx, nodeKind, options) {
   for (const [index, row] of vectorRows.entries()) {
     const rank2 = index + 1;
     const contribution = vectorWeight / (fusionK + rank2);
-    const entry2 = fused.get(row.nodeId) ?? {
+    const key = searchNodeKey(row.kind, row.nodeId);
+    const entry2 = fused.get(key) ?? {
+      kind: row.kind,
       nodeId: row.nodeId,
       fusedScore: 0
     };
     entry2.fusedScore += contribution;
     entry2.vectorRank = rank2;
     entry2.vectorScore = row.score;
-    fused.set(row.nodeId, entry2);
+    fused.set(key, entry2);
   }
   for (const [index, row] of fulltextRows.entries()) {
     const rank2 = index + 1;
     const contribution = fulltextWeight / (fusionK + rank2);
-    const entry2 = fused.get(row.nodeId) ?? {
+    const key = searchNodeKey(row.kind, row.nodeId);
+    const entry2 = fused.get(key) ?? {
+      kind: row.kind,
       nodeId: row.nodeId,
       fusedScore: 0
     };
@@ -9083,17 +9648,24 @@ async function executeHybridSearch(ctx, nodeKind, options) {
     if (row.snippet !== void 0) {
       entry2.fulltextSnippet = row.snippet;
     }
-    fused.set(row.nodeId, entry2);
+    fused.set(key, entry2);
   }
   const ranked = [...fused.values()].toSorted(
-    (a, b) => b.fusedScore - a.fusedScore || compareStrings(a.nodeId, b.nodeId)
-  ).slice(0, options.limit);
-  const ids = ranked.map((entry2) => entry2.nodeId);
-  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+    (a, b) => b.fusedScore - a.fusedScore || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
+  ).slice(offset, offset + options.limit);
+  const nodeMap = await fetchNodesForRows(
+    backend,
+    graphId,
+    ranked.map((entry2) => ({
+      kind: entry2.kind,
+      nodeId: entry2.nodeId,
+      score: entry2.fusedScore
+    }))
+  );
   const hits = [];
   let rank = 1;
   for (const entry2 of ranked) {
-    const node = nodeMap.get(entry2.nodeId);
+    const node = nodeMap.get(searchNodeKey(entry2.kind, entry2.nodeId));
     if (!node) continue;
     const typedNode = node;
     const hit = {
@@ -9259,12 +9831,10 @@ var StoreSearch = class {
   async fulltext(nodeKind, options) {
     this.#assertKindRegistered(nodeKind);
     return executeFulltextSearch(
-      {
-        graphId: this.#context.graphId,
-        backend: this.#context.backend,
-        registry: this.#context.registry
-      },
+      this.#context,
       nodeKind,
+      // Contravariance: the narrowed accessor callback is intentionally
+      // wider than the base instantiation the core helpers take.
       options
     );
   }
@@ -9282,12 +9852,10 @@ var StoreSearch = class {
   async vector(nodeKind, options) {
     this.#assertKindRegistered(nodeKind);
     return executeVectorSearch(
-      {
-        graphId: this.#context.graphId,
-        backend: this.#context.backend,
-        registry: this.#context.registry
-      },
+      this.#context,
       nodeKind,
+      // Contravariance: the narrowed accessor callback is intentionally
+      // wider than the base instantiation the core helpers take.
       options
     );
   }
@@ -9303,12 +9871,10 @@ var StoreSearch = class {
   async hybrid(nodeKind, options) {
     this.#assertKindRegistered(nodeKind);
     return executeHybridSearch(
-      {
-        graphId: this.#context.graphId,
-        backend: this.#context.backend,
-        registry: this.#context.registry
-      },
+      this.#context,
       nodeKind,
+      // Contravariance: the narrowed accessor callback is intentionally
+      // wider than the base instantiation the core helpers take.
       options
     );
   }
@@ -9888,30 +10454,6 @@ function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
   return index;
 }
 
-// src/registry/builders.ts
-function buildKindRegistry(graph) {
-  const nodeTypes = extractNodeTypes(graph);
-  const edgeTypes = extractEdgeTypes(graph);
-  const closures = graph.ontology.length > 0 ? computeClosuresFromOntology(graph.ontology) : createEmptyClosures();
-  return new KindRegistry(nodeTypes, edgeTypes, closures);
-}
-function extractNodeTypes(graph) {
-  const result = /* @__PURE__ */ new Map();
-  for (const typeName of getNodeKinds(graph)) {
-    const registration = graph.nodes[typeName];
-    result.set(typeName, registration.type);
-  }
-  return result;
-}
-function extractEdgeTypes(graph) {
-  const result = /* @__PURE__ */ new Map();
-  for (const typeName of getEdgeKinds(graph)) {
-    const registration = graph.edges[typeName];
-    result.set(typeName, registration.type);
-  }
-  return result;
-}
-
 // src/store/algorithms/context.ts
 var DEFAULT_ALGORITHM_MAX_HOPS = 10;
 var DEFAULT_NEIGHBOR_DEPTH = 1;
@@ -9944,7 +10486,7 @@ function resolveTemporalFilter(ctx, options, tableAlias) {
     asOf: resolved.asOf,
     recordedAsOf: resolved.recordedAsOf,
     tableAlias,
-    currentTimestamp: ctx.dialect.currentTimestamp()
+    currentTimestamp: currentReadInstant()
   };
   return compileTemporalFilter(filterOptions);
 }
@@ -9982,15 +10524,17 @@ function assertEdgeKinds(edges) {
 // src/store/algorithms/degree.ts
 async function executeDegree(ctx, nodeId, options = {}) {
   const direction = options.direction ?? "both";
+  const edgeKinds = options.edges ?? Object.keys(ctx.graph.edges);
+  if (edgeKinds.length === 0) return 0;
+  const schema = resolveReadSchema(ctx, options);
   const whereClauses = [
     sql`graph_id = ${ctx.graphId}`,
     resolveTemporalFilter(ctx, options),
-    compileDirectionFilter(direction, nodeId)
+    compileDirectionFilter(ctx, direction, nodeId, schema.nodesTable)
   ];
   if (options.edges !== void 0) {
     whereClauses.push(compileKindFilter(sql.raw("kind"), options.edges));
   }
-  const schema = resolveReadSchema(ctx, options);
   const countExpr = direction === "both" ? sql`COUNT(DISTINCT id)` : sql`COUNT(*)`;
   const query = sql`SELECT ${countExpr} AS count FROM ${schema.edgesTable} WHERE ${sql.join(whereClauses, sql` AND `)}`;
   const rows = await ctx.backend.execute(
@@ -9998,16 +10542,22 @@ async function executeDegree(ctx, nodeId, options = {}) {
   );
   return Number(rows[0]?.count ?? 0);
 }
-function compileDirectionFilter(direction, nodeId) {
+function nodeKindSubquery(ctx, nodeId, nodesTable) {
+  return sql`(SELECT kind FROM ${nodesTable} WHERE graph_id = ${ctx.graphId} AND id = ${nodeId} LIMIT 1)`;
+}
+function compileDirectionFilter(ctx, direction, nodeId, nodesTable) {
+  const nodeKind = nodeKindSubquery(ctx, nodeId, nodesTable);
+  const fromSide = sql`(from_kind = ${nodeKind} AND from_id = ${nodeId})`;
+  const toSide = sql`(to_kind = ${nodeKind} AND to_id = ${nodeId})`;
   switch (direction) {
     case "out": {
-      return sql`from_id = ${nodeId}`;
+      return fromSide;
     }
     case "in": {
-      return sql`to_id = ${nodeId}`;
+      return toSide;
     }
     case "both": {
-      return sql`(from_id = ${nodeId} OR to_id = ${nodeId})`;
+      return sql`(${fromSide} OR ${toSide})`;
     }
   }
 }
@@ -10161,6 +10711,8 @@ function createGraphAlgorithms(params) {
   const allowRecordedAsOf = params.allowRecordedAsOf === true;
   const ctx = {
     graphId: params.graphId,
+    graph: params.graph,
+    registry: params.registry,
     backend: params.backend,
     dialect: getDialect(params.backend.dialect),
     schema: params.schema ?? createSqlSchema(params.backend.tableNames),
@@ -10391,9 +10943,11 @@ function createEdgeCollection(config) {
         const results2 = await backend.transaction(
           async (txBackend) => executeEdgeCreateBatch2(batchInputs, txBackend)
         );
+        await config.maybeRefreshStatisticsAfterBulk?.(results2.length);
         return narrowEdges(results2);
       }
       const results = await executeEdgeCreateBatch2(batchInputs, backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
       return narrowEdges(results);
     },
     async bulkUpsertById(items) {
@@ -10426,26 +10980,25 @@ function createEdgeCollection(config) {
           }
           itemIndex++;
         }
-        const results = Array.from({ length: items.length });
+        const results2 = Array.from({ length: items.length });
         if (toCreate.length > 0) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeEdgeCreateBatch2(createInputs, target);
           for (const [index, entry2] of toCreate.entries()) {
-            results[entry2.index] = narrowEdge(created[index]);
+            results2[entry2.index] = narrowEdge(created[index]);
           }
         }
         for (const entry2 of toUpdate) {
           const result = await executeEdgeUpsertUpdate2(entry2.input, target, {
             clearDeleted: entry2.clearDeleted
           });
-          results[entry2.index] = narrowEdge(result);
+          results2[entry2.index] = narrowEdge(result);
         }
-        return results;
+        return results2;
       };
-      if (backend.capabilities.transactions && "transaction" in backend) {
-        return backend.transaction(async (txBackend) => upsertAll(txBackend));
-      }
-      return upsertAll(backend);
+      const results = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
+      return results;
     },
     async bulkInsert(items) {
       const batchInputs = mapBulkEdgeInputs(kind, items);
@@ -10453,9 +11006,11 @@ function createEdgeCollection(config) {
         await backend.transaction(async (txBackend) => {
           await executeEdgeCreateNoReturnBatch2(batchInputs, txBackend);
         });
+        await config.maybeRefreshStatisticsAfterBulk?.(batchInputs.length);
         return;
       }
       await executeEdgeCreateNoReturnBatch2(batchInputs, backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(batchInputs.length);
     },
     async bulkDelete(ids) {
       if (ids.length === 0) return;
@@ -10683,9 +11238,11 @@ function createNodeCollection(config) {
         const results2 = await backend.transaction(
           async (txBackend) => executeNodeCreateBatch2(batchInputs, txBackend)
         );
+        await config.maybeRefreshStatisticsAfterBulk?.(results2.length);
         return narrowNodes(results2);
       }
       const results = await executeNodeCreateBatch2(batchInputs, backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
       return narrowNodes(results);
     },
     async bulkUpsertById(items) {
@@ -10725,26 +11282,25 @@ function createNodeCollection(config) {
           }
           itemIndex++;
         }
-        const results = Array.from({ length: items.length });
+        const results2 = Array.from({ length: items.length });
         if (toCreate.length > 0) {
           const createInputs = toCreate.map((entry2) => entry2.input);
           const created = await executeNodeCreateBatch2(createInputs, target);
           for (const [index, entry2] of toCreate.entries()) {
-            results[entry2.index] = narrowNode(created[index]);
+            results2[entry2.index] = narrowNode(created[index]);
           }
         }
         for (const entry2 of toUpdate) {
           const result = await executeNodeUpsertUpdate2(entry2.input, target, {
             clearDeleted: entry2.clearDeleted
           });
-          results[entry2.index] = narrowNode(result);
+          results2[entry2.index] = narrowNode(result);
         }
-        return results;
+        return results2;
       };
-      if (backend.capabilities.transactions && "transaction" in backend) {
-        return backend.transaction(async (txBackend) => upsertAll(txBackend));
-      }
-      return upsertAll(backend);
+      const results = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(results.length);
+      return results;
     },
     async bulkInsert(items) {
       const batchInputs = mapBulkNodeInputs(kind, items);
@@ -10752,9 +11308,11 @@ function createNodeCollection(config) {
         await backend.transaction(async (txBackend) => {
           await executeNodeCreateNoReturnBatch2(batchInputs, txBackend);
         });
+        await config.maybeRefreshStatisticsAfterBulk?.(batchInputs.length);
         return;
       }
       await executeNodeCreateNoReturnBatch2(batchInputs, backend);
+      await config.maybeRefreshStatisticsAfterBulk?.(batchInputs.length);
     },
     async bulkDelete(ids) {
       if (ids.length === 0) return;
@@ -10969,6 +11527,17 @@ async function runMaterialization(items, options, runOne) {
 }
 
 // src/store/materialize-indexes.ts
+var CLAIM_LEASE_MS = 15 * 6e4;
+var CLAIM_RETRY_DELAY_MS = 200;
+var CLAIM_WAIT_TIMEOUT_MS = CLAIM_LEASE_MS + 6e4;
+function hasIndexBuildClaimProtocol(backend) {
+  return backend.claimIndexMaterialization !== void 0 && backend.releaseIndexMaterializationClaim !== void 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 async function materializeIndexes(context, options = {}) {
   const { graph, graphId, backend, schemaVersion } = context;
   if (backend.executeDdl === void 0) {
@@ -11024,12 +11593,18 @@ async function materializeIndexes(context, options = {}) {
     backend,
     statusKeys
   );
+  const relationalPhysicalNames = candidates.filter((declaration) => declaration.entity !== "vector").map((declaration) => declaration.name);
+  const invalidLeftovers = await preloadInvalidIndexLeftovers(
+    backend,
+    relationalPhysicalNames
+  );
   const materializeEntry = (declaration) => declaration.entity === "vector" ? materializeVectorIndex(
     declaration,
     backend,
     graphId,
     schemaVersion,
-    existingByStatusKey
+    existingByStatusKey,
+    invalidLeftovers
   ) : materializeRelationalIndex(
     declaration,
     backend,
@@ -11037,16 +11612,23 @@ async function materializeIndexes(context, options = {}) {
     ddlOptions,
     graphId,
     schemaVersion,
-    existingByStatusKey
+    existingByStatusKey,
+    invalidLeftovers
   );
   if (options.stopOnError === true) {
-    const results = [];
+    const results2 = [];
     for (const declaration of candidates) {
       const entry2 = await materializeEntry(declaration);
-      results.push(entry2);
+      results2.push(entry2);
       if (entry2.status === "failed") break;
     }
-    return { results };
+    await refreshStatisticsAfterCreation(
+      backend,
+      results2,
+      options,
+      ddlOptions.concurrent
+    );
+    return { results: results2 };
   }
   const buckets = /* @__PURE__ */ new Map();
   for (const declaration of candidates) {
@@ -11073,14 +11655,46 @@ async function materializeIndexes(context, options = {}) {
     }
     bucketIndex += 1;
   }
-  return {
-    results: candidates.map((declaration) => byDeclaration.get(declaration))
-  };
+  const results = candidates.map(
+    (declaration) => byDeclaration.get(declaration)
+  );
+  await refreshStatisticsAfterCreation(
+    backend,
+    results,
+    options,
+    ddlOptions.concurrent
+  );
+  return { results };
+}
+async function refreshStatisticsAfterCreation(backend, results, options, usesConcurrentBuilds) {
+  if (options.refreshStatistics === false) return;
+  if (usesConcurrentBuilds && !hasIndexBuildClaimProtocol(backend)) return;
+  if (!results.some((entry2) => entry2.status === "created")) return;
+  try {
+    await backend.refreshStatistics();
+  } catch (error) {
+    if (typeof console === "undefined" || typeof console.warn !== "function") {
+      return;
+    }
+    console.warn(
+      "[typegraph] materializeIndexes created its indexes but the follow-up statistics refresh failed; run store.refreshStatistics() to give the planner fresh statistics.",
+      error
+    );
+  }
 }
 function parallelBucketKey(declaration) {
   return declaration.entity;
 }
-async function materializeRelationalIndex(declaration, backend, dialect, ddlOptions, graphId, schemaVersion, existingByStatusKey) {
+async function materializeRelationalIndex(declaration, backend, dialect, ddlOptions, graphId, schemaVersion, existingByStatusKey, invalidLeftovers) {
+  if (declaration.method !== void 0 && dialect !== "postgres") {
+    return {
+      indexName: declaration.name,
+      entity: declaration.entity,
+      kind: declaration.kind,
+      status: "skipped",
+      reason: `Index method "${declaration.method}" requires PostgreSQL (expression GIN${declaration.method === "trigram" ? " + pg_trgm" : ""}); SQLite serves substring search via FTS5 fulltext instead.`
+    };
+  }
   const ddl = generateIndexDDL(declaration, dialect, ddlOptions);
   const targetTable = declaration.entity === "node" ? ddlOptions.nodesTableName ?? "typegraph_nodes" : ddlOptions.edgesTableName ?? "typegraph_edges";
   const signature = await computeIndexSignature(
@@ -11092,11 +11706,17 @@ async function materializeRelationalIndex(declaration, backend, dialect, ddlOpti
     statusKey: declaration.name,
     signature,
     driftLabel: "Index",
-    run: () => backend.executeDdl(ddl),
-    existingByStatusKey
+    run: async () => {
+      if (declaration.method === "trigram") {
+        await backend.executeDdl("CREATE EXTENSION IF NOT EXISTS pg_trgm;");
+      }
+      await backend.executeDdl(ddl);
+    },
+    existingByStatusKey,
+    invalidLeftovers
   });
 }
-async function materializeVectorIndex(declaration, backend, graphId, schemaVersion, existingByStatusKey) {
+async function materializeVectorIndex(declaration, backend, graphId, schemaVersion, existingByStatusKey, invalidLeftovers) {
   if (declaration.indexType === "none") {
     return skippedEntry(
       declaration,
@@ -11150,33 +11770,35 @@ async function materializeVectorIndex(declaration, backend, graphId, schemaVersi
     signature,
     driftLabel: "Vector index",
     run: () => backend.createVectorIndex(params),
-    existingByStatusKey
+    existingByStatusKey,
+    invalidLeftovers
   });
 }
 async function materializeOne(declaration, backend, graphId, schemaVersion, action) {
   const recordIndexMaterialization = backend.recordIndexMaterialization;
   const { statusKey, signature, driftLabel, run, existingByStatusKey } = action;
   const statusOverride = statusKey === declaration.name ? void 0 : { statusName: statusKey };
-  const existing = existingByStatusKey.get(statusKey);
-  if (existing?.materializedAt !== void 0) {
-    if (existing.signature === signature) {
-      return entry(declaration, "alreadyMaterialized");
-    }
-    const error = new Error(
-      `${driftLabel} "${declaration.name}" already materialized with a different signature (recorded by graph "${existing.graphId}" at version ${existing.schemaVersion}). Drop the index manually and retry, or rename the new declaration.`
-    );
-    await recordIndexMaterialization(
-      buildAttempt({
-        declaration,
-        graphId,
-        signature,
-        schemaVersion,
-        materializedAt: void 0,
-        error,
-        ...statusOverride
-      })
-    );
-    return entry(declaration, "failed", error);
+  const settled = await settleAgainstExisting(
+    existingByStatusKey.get(statusKey),
+    declaration,
+    backend,
+    graphId,
+    schemaVersion,
+    {
+      statusKey,
+      signature,
+      driftLabel,
+      isInvalidLeftover: (physicalIndexName) => action.invalidLeftovers.has(physicalIndexName)
+    }
+  );
+  if (settled !== void 0) return settled;
+  if (hasIndexBuildClaimProtocol(backend)) {
+    return materializeWithClaim(declaration, backend, graphId, schemaVersion, {
+      statusKey,
+      signature,
+      driftLabel,
+      run
+    });
   }
   try {
     await run();
@@ -11210,6 +11832,161 @@ async function materializeOne(declaration, backend, graphId, schemaVersion, acti
     return entry(declaration, "failed", error);
   }
 }
+async function settleAgainstExisting(existing, declaration, backend, graphId, schemaVersion, action) {
+  if (existing?.materializedAt === void 0) return void 0;
+  const { statusKey, signature, driftLabel, isInvalidLeftover } = action;
+  if (existing.signature === signature) {
+    if (declaration.entity !== "vector" && hasIndexBuildClaimProtocol(backend) && await isInvalidLeftover(declaration.name)) {
+      return void 0;
+    }
+    return entry(declaration, "alreadyMaterialized");
+  }
+  const error = new Error(
+    `${driftLabel} "${declaration.name}" already materialized with a different signature (recorded by graph "${existing.graphId}" at version ${existing.schemaVersion}). Drop the index manually and retry, or rename the new declaration.`
+  );
+  await backend.recordIndexMaterialization(
+    buildAttempt({
+      declaration,
+      graphId,
+      signature,
+      schemaVersion,
+      materializedAt: void 0,
+      error,
+      ...statusKey === declaration.name ? {} : { statusName: statusKey }
+    })
+  );
+  return entry(declaration, "failed", error);
+}
+async function materializeWithClaim(declaration, backend, graphId, schemaVersion, action) {
+  const { statusKey, signature, driftLabel, run } = action;
+  const statusOverride = statusKey === declaration.name ? void 0 : { statusName: statusKey };
+  const recordIndexMaterialization = backend.recordIndexMaterialization;
+  const token = `${statusKey}:${nowIso()}:${Math.floor(performance.now() * 1e3)}`;
+  const deadline = Date.now() + CLAIM_WAIT_TIMEOUT_MS;
+  for (; ; ) {
+    const claimed = await backend.claimIndexMaterialization({
+      indexName: statusKey,
+      graphId,
+      entity: declaration.entity,
+      kind: declaration.kind,
+      signature,
+      schemaVersion,
+      token,
+      leaseMs: CLAIM_LEASE_MS
+    });
+    if (!claimed) {
+      if (Date.now() >= deadline) {
+        return entry(
+          declaration,
+          "failed",
+          new Error(
+            `Timed out waiting for a concurrent materializer's claim on "${statusKey}" (waited ${String(CLAIM_WAIT_TIMEOUT_MS)}ms). If its holder crashed, retry after the lease expires.`
+          )
+        );
+      }
+      await delay(CLAIM_RETRY_DELAY_MS);
+      continue;
+    }
+    try {
+      const fresh = await backend.getIndexMaterialization(statusKey);
+      const settled = await settleAgainstExisting(
+        fresh,
+        declaration,
+        backend,
+        graphId,
+        schemaVersion,
+        {
+          statusKey,
+          signature,
+          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)
+        }
+      );
+      if (settled !== void 0) return settled;
+      if (declaration.entity !== "vector") {
+        await dropInvalidIndexLeftover(backend, declaration.name);
+      }
+      try {
+        await run();
+        const attemptedAt = nowIso();
+        await recordIndexMaterialization(
+          buildAttempt({
+            declaration,
+            graphId,
+            signature,
+            schemaVersion,
+            materializedAt: attemptedAt,
+            error: void 0,
+            attemptedAt,
+            ...statusOverride
+          })
+        );
+        return entry(declaration, "created");
+      } catch (error_) {
+        const error = error_ instanceof Error ? error_ : new Error(String(error_));
+        await recordIndexMaterialization(
+          buildAttempt({
+            declaration,
+            graphId,
+            signature,
+            schemaVersion,
+            materializedAt: void 0,
+            error,
+            ...statusOverride
+          })
+        );
+        return entry(declaration, "failed", error);
+      }
+    } finally {
+      try {
+        await backend.releaseIndexMaterializationClaim({
+          indexName: statusKey,
+          token
+        });
+      } catch (releaseError) {
+        console.warn(
+          `typegraph: failed to release the index materialization claim for "${statusKey}"; it will expire on its lease and be reclaimed automatically.`,
+          releaseError
+        );
+      }
+    }
+  }
+}
+async function hasInvalidIndexLeftover(backend, physicalIndexName) {
+  if (backend.dialect !== "postgres") return false;
+  const rows = await backend.execute(
+    asCompiledRowsSql(sql`
+      SELECT NOT i.indisvalid AS invalid
+      FROM pg_class c
+      JOIN pg_index i ON i.indexrelid = c.oid
+      WHERE c.relname = ${physicalIndexName}
+    `)
+  );
+  return rows[0]?.invalid === true;
+}
+async function preloadInvalidIndexLeftovers(backend, physicalIndexNames) {
+  if (backend.dialect !== "postgres" || physicalIndexNames.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  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
+    `)
+  );
+  return new Set(rows.map((row) => row.name));
+}
+async function dropInvalidIndexLeftover(backend, physicalIndexName) {
+  if (backend.executeDdl === void 0) return;
+  if (!await hasInvalidIndexLeftover(backend, physicalIndexName)) return;
+  const quoted = `"${physicalIndexName.replaceAll('"', '""')}"`;
+  await backend.executeDdl(`DROP INDEX CONCURRENTLY IF EXISTS ${quoted};`);
+}
 function entry(declaration, status, error) {
   return {
     indexName: declaration.name,
@@ -11263,7 +12040,11 @@ function buildAttempt(args) {
   };
 }
 async function computeIndexSignature(dialect, targetTableName, declaration) {
-  const hashable = { dialect, targetTableName, declaration };
+  const hashable = {
+    dialect,
+    targetTableName,
+    declaration: serializeIndexDeclaration(declaration)
+  };
   const json = JSON.stringify(hashable, sortedReplacer);
   return sha256Hex(json, 16);
 }
@@ -11607,85 +12388,6 @@ function literal(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
 
-// src/store/constraints.ts
-async function checkDisjointnessConstraint(ctx, kind, id) {
-  const disjointKinds = ctx.registry.getDisjointKinds(kind);
-  for (const disjointKind of disjointKinds) {
-    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);
-    if (existing && !existing.deleted_at) {
-      const error = checkDisjointness(id, kind, [disjointKind], ctx.registry);
-      if (error) throw error;
-    }
-  }
-}
-async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
-  switch (cardinality) {
-    case "many": {
-      return;
-    }
-    case "one": {
-      const count2 = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId
-      });
-      const error = checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "one",
-        count2,
-        false
-      );
-      if (error) throw error;
-      return;
-    }
-    case "unique": {
-      const exists = await ctx.backend.edgeExistsBetween({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId
-      });
-      const error = checkUniqueEdge(
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId,
-        exists ? 1 : 0
-      );
-      if (error) throw error;
-      return;
-    }
-    case "oneActive": {
-      if (validTo !== void 0) {
-        return;
-      }
-      const count2 = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        activeOnly: true
-      });
-      const error = checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "oneActive",
-        count2,
-        count2 > 0
-      );
-      if (error) throw error;
-      return;
-    }
-  }
-}
-
 // src/store/operations/edge-operations.ts
 function getEdgeRegistration(graph, kind) {
   const registration = graph.edges[kind];
@@ -11740,6 +12442,11 @@ function createEdgeBatchValidationBackend(backend) {
     endpointCache.set(cacheKey, node);
     return node;
   }
+  function seedEndpointRow(graphId, kind, id, row) {
+    const cacheKey = buildEdgeEndpointCacheKey(graphId, kind, id);
+    if (endpointCache.has(cacheKey)) return;
+    endpointCache.set(cacheKey, row);
+  }
   async function countEdgesFromCached(params) {
     const cacheKey = buildCountEdgesFromCacheKey(params);
     let baseCount = countEdgesFromCache.get(cacheKey);
@@ -11811,7 +12518,8 @@ function createEdgeBatchValidationBackend(backend) {
   });
   return {
     backend: validationBackend,
-    registerPendingEdgeForCardinality
+    registerPendingEdgeForCardinality,
+    seedEndpointRow
   };
 }
 async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
@@ -11911,29 +12619,63 @@ async function executeEdgeCreate(ctx, input, backend) {
   }
   return result;
 }
+async function primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointRow) {
+  if (backend.getNodes === void 0) return;
+  const idsByKind = /* @__PURE__ */ new Map();
+  const addEndpoint = (kind, id) => {
+    const ids = idsByKind.get(kind) ?? /* @__PURE__ */ new Set();
+    ids.add(id);
+    idsByKind.set(kind, ids);
+  };
+  for (const input of inputs) {
+    addEndpoint(input.fromKind, input.fromId);
+    addEndpoint(input.toKind, input.toId);
+  }
+  for (const [kind, ids] of idsByKind) {
+    const orderedIds = [...ids];
+    const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);
+    const rowsById = new Map(rows.map((row) => [row.id, row]));
+    for (const id of orderedIds) {
+      seedEndpointRow(ctx.graphId, kind, id, rowsById.get(id));
+    }
+  }
+}
+async function prepareEdgeBatchCreates(ctx, inputs, backend) {
+  const {
+    backend: validationBackend,
+    registerPendingEdgeForCardinality,
+    seedEndpointRow
+  } = createEdgeBatchValidationBackend(backend);
+  await primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointRow);
+  const preparedCreates = [];
+  for (const input of inputs) {
+    const id = input.id ?? generateId();
+    const prepared = await validateAndPrepareEdgeCreate(
+      ctx,
+      input,
+      id,
+      validationBackend
+    );
+    preparedCreates.push(prepared);
+    registerPendingEdgeForCardinality(
+      prepared.insertParams,
+      prepared.cardinality
+    );
+  }
+  const batchInsertParams = preparedCreates.map(
+    (prepared) => prepared.insertParams
+  );
+  return { preparedCreates, batchInsertParams };
+}
 async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return;
   }
   await runInWriteTransaction(ctx, backend, async (target) => {
-    const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(target);
-    const preparedCreates = [];
-    for (const input of inputs) {
-      const id = input.id ?? generateId();
-      const prepared = await validateAndPrepareEdgeCreate(
-        ctx,
-        input,
-        id,
-        validationBackend
-      );
-      preparedCreates.push(prepared);
-      registerPendingEdgeForCardinality(
-        prepared.insertParams,
-        prepared.cardinality
-      );
-    }
-    const batchInsertParams = preparedCreates.map(
-      (prepared) => prepared.insertParams
+    const { batchInsertParams } = await prepareEdgeBatchCreates(
+      ctx,
+      inputs,
+      target
     );
     await runInsertBatch(edgeInsertDispatch(target), batchInsertParams);
   });
@@ -11943,24 +12685,10 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
     return [];
   }
   return runInWriteTransaction(ctx, backend, async (target) => {
-    const { backend: validationBackend, registerPendingEdgeForCardinality } = createEdgeBatchValidationBackend(target);
-    const preparedCreates = [];
-    for (const input of inputs) {
-      const id = input.id ?? generateId();
-      const prepared = await validateAndPrepareEdgeCreate(
-        ctx,
-        input,
-        id,
-        validationBackend
-      );
-      preparedCreates.push(prepared);
-      registerPendingEdgeForCardinality(
-        prepared.insertParams,
-        prepared.cardinality
-      );
-    }
-    const batchInsertParams = preparedCreates.map(
-      (prepared) => prepared.insertParams
+    const { batchInsertParams } = await prepareEdgeBatchCreates(
+      ctx,
+      inputs,
+      target
     );
     const rows = await runInsertBatchReturning(
       edgeInsertDispatch(target),
@@ -11977,7 +12705,7 @@ async function performEdgeUpdate(ctx, input, target, options) {
   }
   const registration = getEdgeRegistration(ctx.graph, existing.kind);
   const edgeKind = registration.type;
-  const existingProps = JSON.parse(existing.props);
+  const existingProps = rowPropsToObject(existing.props);
   const mergedProps = { ...existingProps, ...input.props };
   const validatedProps = validateEdgeProps(edgeKind.schema, mergedProps, {
     kind: existing.kind,
@@ -12021,10 +12749,6 @@ async function executeEdgeDelete(ctx, id, backend) {
   if (!gate || gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
   return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
-    const existing = await target.getEdge(ctx.graphId, id);
-    if (!existing || existing.deleted_at) {
-      return;
-    }
     await target.deleteEdge({
       graphId: ctx.graphId,
       id
@@ -12036,10 +12760,6 @@ async function executeEdgeHardDelete(ctx, id, backend) {
   if (!gate) return;
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
   return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
-    const existing = await target.getEdge(ctx.graphId, id);
-    if (!existing) {
-      return;
-    }
     await target.hardDeleteEdge({
       graphId: ctx.graphId,
       id
@@ -12109,7 +12829,7 @@ function findMatchingEdge(rows, matchOn, inputProps) {
   let deletedRow;
   for (const row of rows) {
     if (matchOn.length > 0) {
-      const rowProps = JSON.parse(row.props);
+      const rowProps = rowPropsToObject(row.props);
       const matches = matchOn.every(
         (field2) => stableStringify(rowProps[field2]) === stableStringify(inputProps[field2])
       );
@@ -12446,1033 +13166,64 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
     return results;
   });
 }
-function getNodeRegistration(graph, kind) {
-  const registration = graph.nodes[kind];
-  if (registration === void 0) throw new KindNotFoundError(kind, "node");
-  return registration;
+var RECORDED_POINT_READ_FIXED_BIND_PARAMS = 8;
+function recordedPointReadIdChunk(backend) {
+  const budget = recordedBindParamBudget(backend);
+  return Math.max(1, budget - RECORDED_POINT_READ_FIXED_BIND_PARAMS);
+}
+function recordedRelationErrorDetails(backend, surface) {
+  return { dialect: backend.dialect, surface };
+}
+function withRelationsPrecondition(backend, promise, surface) {
+  return withRecordedRelationsPrecondition(
+    promise,
+    recordedRelationErrorDetails(backend, surface)
+  );
 }
-var CACHE_KEY_SEPARATOR = "\0";
-function buildNodeCacheKey(graphId, kind, id) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
+function createRecordedReadBackend(backend, surface) {
+  return createBackendOverlay(backend, {
+    execute: (query) => withRelationsPrecondition(backend, backend.execute(query), surface),
+    ...backend.executeRaw === void 0 ? {} : {
+      executeRaw: (sqlText, params) => withRelationsPrecondition(
+        backend,
+        backend.executeRaw(sqlText, params),
+        surface
+      )
+    }
+  });
 }
-function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
+function recordedTemporalFilter(backend, coordinate, tableAlias) {
+  const recordedAsOf = coordinate.recorded?.asOf;
+  if (recordedAsOf === void 0) {
+    throw new ConfigurationError(
+      "Recorded point reads require a recorded-time coordinate.",
+      { code: "RECORDED_POINT_READ_MISSING_COORDINATE" }
+    );
+  }
+  return compileTemporalFilter({
+    mode: coordinate.valid.mode,
+    asOf: coordinate.valid.asOf,
+    recordedAsOf,
+    tableAlias,
+    currentTimestamp: currentReadInstant()
+  });
 }
-function createNodeAlreadyExistsError(kind, id) {
-  return new ValidationError(
-    `Node already exists: ${kind}/${id}`,
+function recordedRelationInvariantError(params) {
+  return new ConfigurationError(
+    "Recorded relation invariant violation: more than one recorded row matched the requested point read.",
     {
-      entityType: "node",
-      kind,
-      operation: "create",
-      id,
-      issues: [{ path: "id", message: "A node with this ID already exists" }]
+      code: "RECORDED_RELATION_INVARIANT_VIOLATION",
+      graphId: params.graphId,
+      entity: params.entity,
+      kind: params.kind,
+      id: params.id,
+      validMode: params.coordinate.valid.mode,
+      validAsOf: params.coordinate.valid.asOf,
+      recordedAsOf: params.coordinate.recorded?.asOf
     },
-    { suggestion: `Use a different ID or update the existing node.` }
-  );
-}
-function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
-  const insertParams = {
-    graphId,
-    kind,
-    id,
-    props
-  };
-  if (validFrom !== void 0) insertParams.validFrom = validFrom;
-  if (validTo !== void 0) insertParams.validTo = validTo;
-  return insertParams;
-}
-function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId) {
-  return {
-    graph_id: graphId,
-    node_kind: nodeKind,
-    constraint_name: constraintName,
-    key,
-    node_id: nodeId,
-    concrete_kind: nodeKind,
-    deleted_at: void 0
-  };
-}
-function resolveConstraint(graph, kind, constraintName) {
-  const registration = getNodeRegistration(graph, kind);
-  const constraints = registration.unique ?? [];
-  const constraint = constraints.find(
-    (candidate) => candidate.name === constraintName
-  );
-  if (constraint === void 0) {
-    throw new NodeConstraintNotFoundError(constraintName, kind);
-  }
-  return constraint;
-}
-function createNodeBatchValidationBackend(graphId, registry, backend) {
-  const nodeCache = /* @__PURE__ */ new Map();
-  const pendingNodes = /* @__PURE__ */ new Map();
-  const uniqueCache = /* @__PURE__ */ new Map();
-  const pendingUniqueOwners = /* @__PURE__ */ new Map();
-  async function getNodeCached(lookupGraphId, kind, id) {
-    const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);
-    const pendingNode = pendingNodes.get(cacheKey);
-    if (pendingNode !== void 0) return pendingNode;
-    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);
-    const existing = await backend.getNode(lookupGraphId, kind, id);
-    nodeCache.set(cacheKey, existing);
-    return existing;
-  }
-  async function checkUniqueCached(params) {
-    const cacheKey = buildUniqueCacheKey(
-      params.graphId,
-      params.nodeKind,
-      params.constraintName,
-      params.key
-    );
-    const pendingOwner = pendingUniqueOwners.get(cacheKey);
-    if (pendingOwner !== void 0) {
-      return createPendingUniqueRow(
-        params.graphId,
-        params.nodeKind,
-        params.constraintName,
-        params.key,
-        pendingOwner
-      );
-    }
-    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);
-    const existing = await backend.checkUnique(params);
-    uniqueCache.set(cacheKey, existing);
-    return existing;
-  }
-  function registerPendingNode(params) {
-    const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);
-    pendingNodes.set(cacheKey, {
-      graph_id: params.graphId,
-      kind: params.kind,
-      id: params.id,
-      props: JSON.stringify(params.props),
-      version: 1,
-      valid_from: params.validFrom,
-      valid_to: params.validTo,
-      created_at: "",
-      updated_at: "",
-      deleted_at: void 0
-    });
-  }
-  function registerPendingUniqueEntries(kind, id, props, constraints) {
-    for (const constraint of constraints) {
-      if (!checkWherePredicate(constraint, props)) continue;
-      const key = computeUniqueKey(
-        props,
-        constraint.fields,
-        constraint.collation
-      );
-      const concreteEntryKey = buildUniqueCacheKey(
-        graphId,
-        kind,
-        constraint.name,
-        key
-      );
-      pendingUniqueOwners.set(concreteEntryKey, id);
-      if (constraint.scope !== "kind") {
-        const kindsToCheck = getKindsForUniquenessCheck(
-          kind,
-          constraint.scope,
-          registry
-        );
-        for (const kindToCheck of kindsToCheck) {
-          const inheritedEntryKey = buildUniqueCacheKey(
-            graphId,
-            kindToCheck,
-            constraint.name,
-            key
-          );
-          pendingUniqueOwners.set(inheritedEntryKey, id);
-        }
-      }
-    }
-  }
-  const validationBackend = createBackendOverlay(backend, {
-    getNode: getNodeCached,
-    checkUnique: checkUniqueCached
-  });
-  return {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries
-  };
-}
-async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
-  const kind = input.kind;
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const validatedProps = validateNodeProps(nodeKind.schema, input.props, {
-    kind,
-    operation: "create"
-  });
-  const validFrom = validateOptionalCanonicalIsoDate(
-    input.validFrom,
-    "validFrom"
-  );
-  const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const existingNode = await backend.getNode(ctx.graphId, kind, id);
-  if (existingNode && !existingNode.deleted_at) {
-    throw createNodeAlreadyExistsError(kind, id);
-  }
-  const constraintContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
-  await checkDisjointnessConstraint(constraintContext, kind, id);
-  const uniqueConstraints = registration.unique ?? [];
-  await checkUniquenessConstraints(
-    createUniquenessContext(ctx.graphId, ctx.registry, backend),
-    kind,
-    id,
-    validatedProps,
-    uniqueConstraints
-  );
-  return {
-    kind,
-    id,
-    nodeKind,
-    validatedProps,
-    uniqueConstraints,
-    insertParams: buildInsertNodeParams(
-      ctx.graphId,
-      kind,
-      id,
-      validatedProps,
-      validFrom,
-      validTo
-    )
-  };
-}
-async function finalizeNodeCreate(ctx, prepared, backend, lock) {
-  await applyNodeInsertSideEffects(
-    createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-    {
-      kind: prepared.kind,
-      id: prepared.id,
-      schema: prepared.nodeKind.schema,
-      props: prepared.validatedProps,
-      uniqueConstraints: prepared.uniqueConstraints
-    },
-    backend
-  );
-}
-async function performNodeUpdate(ctx, input, backend, lock, options) {
-  const { kind, id } = input;
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing) throw new NodeNotFoundError(kind, id);
-  const existingProps = JSON.parse(existing.props);
-  const mergedProps = { ...existingProps, ...input.props };
-  const nodeKind = registration.type;
-  const validatedProps = validateNodeProps(nodeKind.schema, mergedProps, {
-    kind,
-    operation: "update",
-    id
-  });
-  const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const writeContext = createNodeWriteContext(ctx.graphId, ctx.registry, lock);
-  const shared = {
-    schema: nodeKind.schema,
-    validatedProps,
-    uniqueConstraints: registration.unique ?? [],
-    ...validTo !== void 0 && { validTo }
-  };
-  if (options?.clearDeleted) {
-    const row2 = await applyNodeUpdate(
-      writeContext,
-      { ...shared, existing, clearDeleted: true },
-      backend
-    );
-    return rowToNode(row2);
-  }
-  if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);
-  const row = await applyNodeUpdate(
-    writeContext,
-    { ...shared, existing },
-    backend
-  );
-  return rowToNode(row);
-}
-async function prepareBatchCreates(ctx, inputs, backend) {
-  const {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries
-  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
-  const preparedCreates = [];
-  for (const input of inputs) {
-    const id = input.id ?? generateId();
-    const prepared = await validateAndPrepareNodeCreate(
-      ctx,
-      input,
-      id,
-      validationBackend
-    );
-    preparedCreates.push(prepared);
-    registerPendingNode(prepared.insertParams);
-    registerPendingUniqueEntries(
-      prepared.kind,
-      prepared.id,
-      prepared.validatedProps,
-      prepared.uniqueConstraints
-    );
-  }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
-  );
-  return { preparedCreates, batchInsertParams };
-}
-async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, kindsToCheck, includeDeleted) {
-  for (const kindToCheck of kindsToCheck) {
-    const row = await backend.checkUnique({
-      graphId,
-      nodeKind: kindToCheck,
-      constraintName,
-      key,
-      includeDeleted
-    });
-    if (row !== void 0) return row;
-  }
-  return void 0;
-}
-async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uniqueKeys, kindsToCheck, includeDeleted) {
-  const existingByKey = /* @__PURE__ */ new Map();
-  for (const kindToCheck of kindsToCheck) {
-    if (backend.checkUniqueBatch === void 0) {
-      for (const key of uniqueKeys) {
-        if (existingByKey.has(key)) continue;
-        const row = await backend.checkUnique({
-          graphId,
-          nodeKind: kindToCheck,
-          constraintName,
-          key,
-          includeDeleted
-        });
-        if (row !== void 0) {
-          existingByKey.set(row.key, row);
-        }
-      }
-    } else {
-      const rows = await backend.checkUniqueBatch({
-        graphId,
-        nodeKind: kindToCheck,
-        constraintName,
-        keys: uniqueKeys,
-        includeDeleted
-      });
-      for (const row of rows) {
-        if (!existingByKey.has(row.key)) {
-          existingByKey.set(row.key, row);
-        }
-      }
-    }
-  }
-  return existingByKey;
-}
-async function executeNodeCreateInternal(ctx, input, backend, options) {
-  const kind = input.kind;
-  const id = input.id ?? generateId();
-  const opContext = ctx.createOperationContext("create", "node", kind, id);
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const prepared = await validateAndPrepareNodeCreate(
-        ctx,
-        input,
-        id,
-        target
-      );
-      let row;
-      {
-        row = await target.insertNode(prepared.insertParams);
-      }
-      await finalizeNodeCreate(ctx, prepared, target, lock);
-      if (row === void 0) return;
-      return rowToNode(row);
-    }
-  );
-}
-async function executeNodeCreate(ctx, input, backend) {
-  const result = await executeNodeCreateInternal(ctx, input, backend);
-  if (!result) {
-    throw new DatabaseOperationError(
-      "Node create failed: expected created node row",
-      { operation: "insert", entity: "node" }
-    );
-  }
-  return result;
-}
-async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) return;
-  await runInWriteTransaction(ctx, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    await runInsertBatch(nodeInsertDispatch(target), batchInsertParams);
-    for (const prepared of preparedCreates) {
-      await finalizeNodeCreate(ctx, prepared, target, lock);
-    }
-  });
-}
-async function executeNodeCreateBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) return [];
-  return runInWriteTransaction(ctx, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    const rows = await runInsertBatchReturning(
-      nodeInsertDispatch(target),
-      batchInsertParams
-    );
-    for (const prepared of preparedCreates) {
-      await finalizeNodeCreate(ctx, prepared, target, lock);
-    }
-    return rows.map((row) => rowToNode(row));
-  });
-}
-async function executeNodeUpdate(ctx, input, backend, options) {
-  const opContext = ctx.createOperationContext(
-    "update",
-    "node",
-    input.kind,
-    input.id
-  );
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
-  );
-}
-async function executeNodeUpsertUpdate(ctx, input, backend, options) {
-  return runInWriteTransaction(
-    ctx,
-    backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
-  );
-}
-async function executeNodeDelete(ctx, kind, id, backend) {
-  const gate = await backend.getNode(ctx.graphId, kind, id);
-  if (!gate || gate.deleted_at) return;
-  const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const registration = getNodeRegistration(ctx.graph, kind);
-      const preflight = await target.getNode(ctx.graphId, kind, id);
-      if (!preflight || !isLiveNodeRow(preflight)) return;
-      await applyNodeSoftDelete(
-        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          existing: preflight,
-          schema: registration.type.schema,
-          uniqueConstraints: registration.unique ?? [],
-          onDelete: registration.onDelete
-        },
-        target
-      );
-    }
-  );
-}
-async function executeNodeHardDelete(ctx, kind, id, backend) {
-  const gate = await backend.getNode(ctx.graphId, kind, id);
-  if (!gate) return;
-  const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const registration = getNodeRegistration(ctx.graph, kind);
-      const preflight = await target.getNode(ctx.graphId, kind, id);
-      if (!preflight) return;
-      await applyNodeHardDelete(
-        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          kind,
-          id,
-          schema: registration.type.schema,
-          onDelete: registration.onDelete
-        },
-        target
-      );
-    }
-  );
-}
-async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, props, backend, options) {
-  const ifExists = options?.ifExists ?? "return";
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const validatedProps = validateNodeProps(nodeKind.schema, props, {
-    kind,
-    operation: "create"
-  });
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!checkWherePredicate(constraint, validatedProps)) {
-    const node = await executeNodeCreate(
-      ctx,
-      { kind, props: validatedProps },
-      backend
-    );
-    return { node, action: "created" };
-  }
-  const key = computeUniqueKey(
-    validatedProps,
-    constraint.fields,
-    constraint.collation
-  );
-  const kindsToCheck = getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  async function attempt() {
-    const existingUniqueRow = await findUniqueRowAcrossKinds(
-      backend,
-      ctx.graphId,
-      constraint.name,
-      key,
-      kindsToCheck,
-      true
-    );
-    if (existingUniqueRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend
-      );
-      return { node, action: "created" };
-    }
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      existingUniqueRow.concrete_kind,
-      existingUniqueRow.node_id
-    );
-    if (existingRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend
-      );
-      return { node, action: "created" };
-    }
-    const isSoftDeleted = existingRow.deleted_at !== void 0;
-    if (isSoftDeleted || ifExists === "update") {
-      const concreteKind = existingUniqueRow.concrete_kind;
-      const node = await executeNodeUpsertUpdate(
-        ctx,
-        {
-          kind: concreteKind,
-          id: existingRow.id,
-          props: validatedProps
-        },
-        backend,
-        { clearDeleted: isSoftDeleted }
-      );
-      return { node, action: isSoftDeleted ? "resurrected" : "updated" };
-    }
-    return { node: rowToNode(existingRow), action: "found" };
-  }
-  try {
-    return await attempt();
-  } catch (error) {
-    if (!(error instanceof UniquenessError)) throw error;
-    return attempt();
-  }
-}
-async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const validatedProps = validateNodeProps(nodeKind.schema, props, {
-    kind,
-    operation: "create"
-  });
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!checkWherePredicate(constraint, validatedProps)) return void 0;
-  const key = computeUniqueKey(
-    validatedProps,
-    constraint.fields,
-    constraint.collation
-  );
-  const kindsToCheck = getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  const existingUniqueRow = await findUniqueRowAcrossKinds(
-    backend,
-    ctx.graphId,
-    constraint.name,
-    key,
-    kindsToCheck,
-    false
-  );
-  if (existingUniqueRow === void 0) return void 0;
-  const existingRow = await backend.getNode(
-    ctx.graphId,
-    existingUniqueRow.concrete_kind,
-    existingUniqueRow.node_id
-  );
-  if (existingRow === void 0 || existingRow.deleted_at !== void 0)
-    return void 0;
-  return rowToNode(existingRow);
-}
-function validateAndComputeKeys(nodeKind, kind, constraint, items) {
-  const validated = [];
-  for (const item of items) {
-    const validatedProps = validateNodeProps(nodeKind.schema, item.props, {
-      kind,
-      operation: "create"
-    });
-    const applies = checkWherePredicate(constraint, validatedProps);
-    const key = applies ? computeUniqueKey(
-      validatedProps,
-      constraint.fields,
-      constraint.collation
-    ) : void 0;
-    validated.push({ validatedProps, key });
-  }
-  return validated;
-}
-function collectUniqueKeys(validated) {
-  return [
-    ...new Set(
-      validated.map((entry2) => entry2.key).filter((key) => key !== void 0)
-    )
-  ];
-}
-async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
-  if (items.length === 0) return [];
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
-  const uniqueKeys = collectUniqueKeys(validated);
-  const kindsToCheck = getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
-    backend,
-    ctx.graphId,
-    constraint.name,
-    uniqueKeys,
-    kindsToCheck,
-    false
-  ) : /* @__PURE__ */ new Map();
-  const results = Array.from({ length: items.length });
-  const seenKeys = /* @__PURE__ */ new Map();
-  for (const [index, { key }] of validated.entries()) {
-    if (key === void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    const previousIndex = seenKeys.get(key);
-    if (previousIndex !== void 0) {
-      results[index] = results[previousIndex];
-      continue;
-    }
-    seenKeys.set(key, index);
-    const existing = existingByKey.get(key);
-    if (existing === void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      existing.concrete_kind,
-      existing.node_id
-    );
-    if (existingRow === void 0 || existingRow.deleted_at !== void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    results[index] = rowToNode(existingRow);
-  }
-  return results;
-}
-function resolveNodeIndex(graph, kind, indexName) {
-  getNodeRegistration(graph, kind);
-  const declaration = graph.indexes?.find(
-    (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
-  );
-  if (declaration?.entity !== "node") {
-    throw new NodeIndexNotFoundError(indexName, kind);
-  }
-  return declaration;
-}
-var INDEX_PROBE_EXPECTED_TYPEOF = {
-  string: "string",
-  number: "number",
-  boolean: "boolean"
-};
-function validateIndexProbeValue(value, valueType, pointer, kind) {
-  if (value === void 0 || value === null) return;
-  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !(value instanceof Date)) {
-    throw indexProbeTypeError(
-      pointer,
-      kind,
-      "a scalar (string, number, boolean, or Date)",
-      value
-    );
-  }
-  if (valueType === "date") {
-    if (value instanceof Date || typeof value === "string") return;
-    throw indexProbeTypeError(
-      pointer,
-      kind,
-      "date (Date or ISO string)",
-      value
-    );
-  }
-  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? "unknown"];
-  if (expected === void 0) return;
-  if (typeof value !== expected) {
-    throw indexProbeTypeError(pointer, kind, expected, value);
-  }
-}
-function indexProbeTypeError(pointer, kind, expected, value) {
-  return new ValidationError(
-    `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
-    {
-      entityType: "node",
-      kind,
-      issues: [
-        {
-          path: pointer,
-          message: `Expected ${expected}, received ${typeof value}`,
-          code: "invalid_type"
-        }
-      ]
-    }
-  );
-}
-function coerceIndexProbeBind(value, adapter) {
-  return adapter.bindValue(normalizeProbeScalar(value));
-}
-function normalizeProbeScalar(value) {
-  return value instanceof Date ? value.toISOString() : value;
-}
-var PROBE_NULL_TAG = 0;
-var PROBE_VALUE_TAG = 1;
-function canonicalIndexProbeKey(probe) {
-  return JSON.stringify(
-    probe.map(
-      (value) => value === void 0 || value === null ? [PROBE_NULL_TAG] : [PROBE_VALUE_TAG, normalizeProbeScalar(value)]
-    )
-  );
-}
-async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend, options) {
-  if (items.length === 0) return [];
-  const index = resolveNodeIndex(ctx.graph, kind, indexName);
-  if (index.fieldValueTypes.includes("date")) {
-    throw new ConfigurationError(
-      `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
-      { indexName, kind },
-      {
-        suggestion: "Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...)."
-      }
-    );
-  }
-  const limitPerInput = options?.limitPerInput;
-  if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
-    throw new ValidationError(
-      "bulkFindByIndex limitPerInput must be a positive integer",
-      {
-        entityType: "node",
-        kind,
-        issues: [
-          {
-            path: "limitPerInput",
-            message: `Expected a positive integer, received ${String(limitPerInput)}`,
-            code: "invalid_value"
-          }
-        ]
-      }
-    );
-  }
-  const adapter = getDialect(backend.dialect);
-  const probes = items.map(
-    (item) => index.fields.map((pointer, position) => {
-      const value = resolveJsonPointer(item.props, pointer);
-      validateIndexProbeValue(
-        value,
-        index.fieldValueTypes[position],
-        pointer,
-        kind
-      );
-      return value;
-    })
-  );
-  const groupByKey = /* @__PURE__ */ new Map();
-  const groupProbes = [];
-  const groupToInputs = [];
-  for (const [inputIndex, probe] of probes.entries()) {
-    const key = canonicalIndexProbeKey(probe);
-    const existing = groupByKey.get(key);
-    if (existing === void 0) {
-      groupByKey.set(key, groupProbes.length);
-      groupProbes.push(probe);
-      groupToInputs.push([inputIndex]);
-      continue;
-    }
-    groupToInputs[existing]?.push(inputIndex);
-  }
-  const schema = backend.tableNames ? createSqlSchema(backend.tableNames) : DEFAULT_SQL_SCHEMA;
-  const compileContext = {
-    dialect: backend.dialect,
-    propsColumn: sql.raw(`"props"`),
-    systemColumn: (column) => sql.raw(`"${column}"`)
-  };
-  const fieldKeys = compileNodeIndexFieldKeys(index, compileContext);
-  const groupPredicates = groupProbes.map(
-    (probe) => sql`(${sql.join(
-      fieldKeys.map((fieldKey, position) => {
-        const value = probe[position];
-        if (value === void 0 || value === null) {
-          return sql`${fieldKey} IS NULL`;
-        }
-        return adapter.nullSafeEquals(
-          fieldKey,
-          sql`${coerceIndexProbeBind(value, adapter)}`
-        );
-      }),
-      sql` AND `
-    )})`
-  );
-  const caseBranches = groupPredicates.map(
-    (predicate, group) => sql`WHEN ${predicate} THEN ${sql.raw(String(group))}`
-  );
-  const probeIndexExpr = sql`CASE ${sql.join(caseBranches, sql` `)} ELSE NULL END`;
-  const conditions = [
-    sql`"graph_id" = ${ctx.graphId}`,
-    sql`"kind" = ${kind}`,
-    sql`"deleted_at" IS NULL`
-  ];
-  if (index.where !== void 0) {
-    conditions.push(compileIndexWhere(compileContext, index.where));
-  }
-  conditions.push(sql`(${sql.join(groupPredicates, sql` OR `)})`);
-  const whereClause = sql.join(conditions, sql` AND `);
-  const probedSelect = sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
-  const capInSql = limitPerInput !== void 0 && backend.capabilities.windowFunctions;
-  const query = capInSql ? sql`SELECT "id", probe_idx FROM (SELECT "id", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY "id") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, "id"` : sql`${probedSelect} ORDER BY probe_idx, "id"`;
-  const rawMatches = await backend.execute(
-    asCompiledRowsSql(query)
-  );
-  const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
-  const nodesById = await hydrateNodesById(
-    backend,
-    ctx.graphId,
-    kind,
-    matches.map((match) => match.id)
-  );
-  const results = Array.from({ length: items.length }, () => []);
-  for (const match of matches) {
-    const node = nodesById.get(match.id);
-    if (node === void 0) continue;
-    const inputs = groupToInputs[match.probe_idx];
-    if (inputs === void 0) continue;
-    for (const inputIndex of inputs) {
-      results[inputIndex]?.push(node);
-    }
-  }
-  return results;
-}
-function capMatchesPerGroup(matches, limitPerInput) {
-  const perGroupCount = /* @__PURE__ */ new Map();
-  const capped = [];
-  for (const match of matches) {
-    const count2 = perGroupCount.get(match.probe_idx) ?? 0;
-    if (count2 >= limitPerInput) continue;
-    perGroupCount.set(match.probe_idx, count2 + 1);
-    capped.push(match);
-  }
-  return capped;
-}
-async function hydrateNodesById(backend, graphId, kind, ids) {
-  const rowsById = await getNodeRowsByIds(backend, graphId, kind, ids);
-  const nodesById = /* @__PURE__ */ new Map();
-  for (const [id, row] of rowsById) {
-    if (row.deleted_at !== void 0) continue;
-    nodesById.set(id, rowToNode(row));
-  }
-  return nodesById;
-}
-async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName, items, backend, options) {
-  if (items.length === 0) return [];
-  const ifExists = options?.ifExists ?? "return";
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
-  const uniqueKeys = collectUniqueKeys(validated);
-  const kindsToCheck = getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
-    backend,
-    ctx.graphId,
-    constraint.name,
-    uniqueKeys,
-    kindsToCheck,
-    true
-  ) : /* @__PURE__ */ new Map();
-  const toCreate = [];
-  const toFetch = [];
-  const duplicateOf = [];
-  const seenKeys = /* @__PURE__ */ new Map();
-  for (const [index, { validatedProps, key }] of validated.entries()) {
-    if (key === void 0) {
-      toCreate.push({ index, input: { kind, props: validatedProps } });
-      continue;
-    }
-    const previousIndex = seenKeys.get(key);
-    if (previousIndex !== void 0) {
-      duplicateOf.push({ index, sourceIndex: previousIndex });
-      continue;
-    }
-    seenKeys.set(key, index);
-    const existing = existingByKey.get(key);
-    if (existing === void 0) {
-      toCreate.push({ index, input: { kind, props: validatedProps } });
-    } else {
-      toFetch.push({
-        index,
-        nodeId: existing.node_id,
-        concreteKind: existing.concrete_kind,
-        validatedProps,
-        isSoftDeleted: existing.deleted_at !== void 0
-      });
-    }
-  }
-  const results = Array.from({ length: items.length });
-  if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry2) => entry2.input);
-    const createdNodes = await executeNodeCreateBatch(
-      ctx,
-      createInputs,
-      backend
-    );
-    for (const [batchIndex, entry2] of toCreate.entries()) {
-      results[entry2.index] = {
-        node: createdNodes[batchIndex],
-        action: "created"
-      };
-    }
-  }
-  for (const entry2 of toFetch) {
-    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry2;
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      concreteKind,
-      nodeId
-    );
-    if (existingRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend
-      );
-      results[index] = { node, action: "created" };
-      continue;
-    }
-    if (isSoftDeleted || ifExists === "update") {
-      const node = await executeNodeUpsertUpdate(
-        ctx,
-        {
-          kind: concreteKind,
-          id: existingRow.id,
-          props: validatedProps
-        },
-        backend,
-        { clearDeleted: isSoftDeleted }
-      );
-      results[index] = {
-        node,
-        action: isSoftDeleted ? "resurrected" : "updated"
-      };
-    } else {
-      results[index] = { node: rowToNode(existingRow), action: "found" };
-    }
-  }
-  for (const { index, sourceIndex } of duplicateOf) {
-    const sourceResult = results[sourceIndex];
-    results[index] = { node: sourceResult.node, action: "found" };
-  }
-  return results;
-}
-var RECORDED_POINT_READ_FIXED_BIND_PARAMS = 8;
-function recordedPointReadIdChunk(backend) {
-  const budget = recordedBindParamBudget(backend);
-  return Math.max(1, budget - RECORDED_POINT_READ_FIXED_BIND_PARAMS);
-}
-function recordedRelationErrorDetails(backend, surface) {
-  return { dialect: backend.dialect, surface };
-}
-function withRelationsPrecondition(backend, promise, surface) {
-  return withRecordedRelationsPrecondition(
-    promise,
-    recordedRelationErrorDetails(backend, surface)
-  );
-}
-function createRecordedReadBackend(backend, surface) {
-  return createBackendOverlay(backend, {
-    execute: (query) => withRelationsPrecondition(backend, backend.execute(query), surface),
-    ...backend.executeRaw === void 0 ? {} : {
-      executeRaw: (sqlText, params) => withRelationsPrecondition(
-        backend,
-        backend.executeRaw(sqlText, params),
-        surface
-      )
-    }
-  });
-}
-function recordedTemporalFilter(backend, coordinate, tableAlias) {
-  const recordedAsOf = coordinate.recorded?.asOf;
-  if (recordedAsOf === void 0) {
-    throw new ConfigurationError(
-      "Recorded point reads require a recorded-time coordinate.",
-      { code: "RECORDED_POINT_READ_MISSING_COORDINATE" }
-    );
-  }
-  return compileTemporalFilter({
-    mode: coordinate.valid.mode,
-    asOf: coordinate.valid.asOf,
-    recordedAsOf,
-    tableAlias,
-    currentTimestamp: getDialect(backend.dialect).currentTimestamp()
-  });
-}
-function recordedRelationInvariantError(params) {
-  return new ConfigurationError(
-    "Recorded relation invariant violation: more than one recorded row matched the requested point read.",
-    {
-      code: "RECORDED_RELATION_INVARIANT_VIOLATION",
-      graphId: params.graphId,
-      entity: params.entity,
-      kind: params.kind,
-      id: params.id,
-      validMode: params.coordinate.valid.mode,
-      validAsOf: params.coordinate.valid.asOf,
-      recordedAsOf: params.coordinate.recorded?.asOf
-    },
-    {
-      suggestion: "Repair overlapping recorded_from/recorded_to intervals for this entity before using recorded-time reads."
-    }
+    {
+      suggestion: "Repair overlapping recorded_from/recorded_to intervals for this entity before using recorded-time reads."
+    }
   );
 }
 function createRecordedReadService(params) {
@@ -13573,6 +13324,155 @@ function createRecordedReadService(params) {
   };
 }
 
+// src/store/transaction-receipt.ts
+function inputLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function countSingleWrite() {
+  return 1;
+}
+function countBulkInputAt(index) {
+  return (args) => inputLength(args[index]);
+}
+var NODE_WRITE_INTENT_COUNTERS = {
+  create: countSingleWrite,
+  createFromRecord: countSingleWrite,
+  update: countSingleWrite,
+  delete: countSingleWrite,
+  hardDelete: countSingleWrite,
+  upsertById: countSingleWrite,
+  upsertByIdFromRecord: countSingleWrite,
+  bulkCreate: countBulkInputAt(0),
+  bulkUpsertById: countBulkInputAt(0),
+  bulkInsert: countBulkInputAt(0),
+  bulkDelete: countBulkInputAt(0),
+  getOrCreateByConstraint: countSingleWrite,
+  bulkGetOrCreateByConstraint: countBulkInputAt(1)
+};
+var EDGE_WRITE_INTENT_COUNTERS = {
+  create: countSingleWrite,
+  update: countSingleWrite,
+  delete: countSingleWrite,
+  hardDelete: countSingleWrite,
+  bulkCreate: countBulkInputAt(0),
+  bulkUpsertById: countBulkInputAt(0),
+  bulkInsert: countBulkInputAt(0),
+  bulkDelete: countBulkInputAt(0),
+  getOrCreateByEndpoints: countSingleWrite,
+  bulkGetOrCreateByEndpoints: countBulkInputAt(0)
+};
+function createCountBucket() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function increment(counts, kind, count2) {
+  if (count2 === 0) return;
+  counts[kind] = (counts[kind] ?? 0) + count2;
+}
+function createTransactionReceiptRecorder() {
+  const nodes = createCountBucket();
+  const edges = createCountBucket();
+  let total = 0;
+  return {
+    recordNode(kind, count2) {
+      increment(nodes, kind, count2);
+      total += count2;
+    },
+    recordEdge(kind, count2) {
+      increment(edges, kind, count2);
+      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
+        }),
+        ...recorded === void 0 ? {} : { recorded }
+      });
+    }
+  };
+}
+function isWrappedMethod(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return typeof value === "object" && Boolean(value);
+}
+var NODE_WRITE_SURFACE = {
+  methodNames: new Set(NODE_WRITE_NAMES),
+  counters: NODE_WRITE_INTENT_COUNTERS
+};
+var EDGE_WRITE_SURFACE = {
+  methodNames: new Set(EDGE_WRITE_NAMES),
+  counters: EDGE_WRITE_INTENT_COUNTERS
+};
+function memoizedProxyGet(target, shouldWrap, wrap) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(target, {
+    get(proxyTarget, property, receiver) {
+      if (typeof property !== "string" || !shouldWrap(property)) {
+        return Reflect.get(proxyTarget, property, receiver);
+      }
+      const cached = cache.get(property);
+      if (cached !== void 0) return cached;
+      const value = Reflect.get(proxyTarget, property, receiver);
+      const wrapped = wrap(value, property);
+      cache.set(property, wrapped);
+      return wrapped;
+    }
+  });
+}
+function wrapWriteCollection(collection, kind, surface, record) {
+  return memoizedProxyGet(
+    collection,
+    (property) => surface.methodNames.has(property),
+    (value, property) => {
+      if (!isWrappedMethod(value)) return value;
+      const method = property;
+      const wrapped = async (...args) => {
+        const count2 = surface.counters[method](args);
+        const result = await Reflect.apply(value, collection, args);
+        record(kind, count2);
+        return result;
+      };
+      return wrapped;
+    }
+  );
+}
+function wrapCollections(collections, wrapOne) {
+  return memoizedProxyGet(
+    collections,
+    () => true,
+    (collection, kind) => isObject(collection) ? wrapOne(collection, kind) : collection
+  );
+}
+function wrapTransactionCollections(nodes, edges, recorder) {
+  return {
+    nodes: wrapCollections(
+      nodes,
+      (collection, kind) => wrapWriteCollection(
+        collection,
+        kind,
+        NODE_WRITE_SURFACE,
+        recorder.recordNode
+      )
+    ),
+    edges: wrapCollections(
+      edges,
+      (collection, kind) => wrapWriteCollection(
+        collection,
+        kind,
+        EDGE_WRITE_SURFACE,
+        recorder.recordEdge
+      )
+    )
+  };
+}
+
+// src/store/types.ts
+var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
+
 // src/store/store.ts
 var UNKNOWN_SCHEMA_METADATA = Object.freeze({
   schemaVersion: void 0,
@@ -13605,6 +13505,15 @@ function rowMapperConfigFor(backend) {
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
+function transactionOutcome(result, recorder, recordedByGraph, graphId) {
+  const recorded = recordedByGraph?.get(graphId);
+  return {
+    result,
+    receipt: recorder.snapshot(
+      recorded === void 0 ? void 0 : asRecordedInstant(recorded)
+    )
+  };
+}
 var Store = class _Store {
   #graph;
   /**
@@ -13614,6 +13523,8 @@ var Store = class _Store {
   #baseBackend;
   #backend;
   #captureEnabled;
+  #revisionTrackingEnabled;
+  #revisionOrigin;
   #recordedReadBinding;
   #registry;
   #hooks;
@@ -13634,6 +13545,10 @@ var Store = class _Store {
     this.#graph = graph;
     this.#baseBackend = asRawBackend(backend);
     this.#captureEnabled = options?.history === true;
+    this.#revisionTrackingEnabled = this.#captureEnabled || options?.revisionTracking === true;
+    if (this.#revisionTrackingEnabled) {
+      assertRevisionTrackableBackend(backend);
+    }
     const explicitSchema = options?.schema === void 0 ? void 0 : requireSqlSchema(options.schema, "store schema");
     const resolvedSchema = explicitSchema ?? (backend.tableNames ? createSqlSchema(backend.tableNames) : void 0);
     const readSchema = resolvedSchema ?? createSqlSchema(backend.tableNames);
@@ -13691,6 +13606,22 @@ var Store = class _Store {
   get historyEnabled() {
     return this.#captureEnabled;
   }
+  /**
+   * Whether this Store advances a durable revision anchor for graph writes.
+   *
+   * @internal
+   */
+  get revisionTrackingEnabled() {
+    return this.#revisionTrackingEnabled;
+  }
+  /**
+   * SQL schema that owns the durable revision clock relation.
+   *
+   * @internal
+   */
+  get revisionSchema() {
+    return this.#sqlSchema();
+  }
   /**
    * Whether this store has a recorded read relation bound for reconstruction.
    *
@@ -13780,6 +13711,8 @@ var Store = class _Store {
     if (this.#algorithms === void 0) {
       this.#algorithms = createGraphAlgorithms({
         graphId: this.graphId,
+        graph: this.#graph,
+        registry: this.#registry,
         backend: this.#backend,
         schema: this.#schema,
         recordedReadBinding: this.#recordedReadBinding,
@@ -13789,6 +13722,19 @@ var Store = class _Store {
     return this.#algorithms;
   }
   // === Dynamic Collection Access ===
+  /**
+   * Resolves `kind` against `collections` (either `this.nodes` or a
+   * transaction-scoped — and possibly receipt-wrapped — node collection map),
+   * or `undefined` when the kind is not registered in this graph. Shared by
+   * `getNodeCollection` and both transaction contexts' `getNodeCollection` so
+   * a receipt-wrapped transaction counts writes made through the dynamic
+   * lookup exactly like `this.#graph.nodes` membership is checked everywhere
+   * else.
+   */
+  #resolveDynamicNodeCollection(collections, kind) {
+    if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
+    return collections[kind];
+  }
   /**
    * Returns the node collection for the given kind, or undefined if the kind
    * is not registered in this graph.
@@ -13800,8 +13746,7 @@ var Store = class _Store {
    * throws `KindNotFoundError` instead of forcing a null-check.
    */
   getNodeCollection(kind) {
-    if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
-    return this.nodes[kind];
+    return this.#resolveDynamicNodeCollection(this.nodes, kind);
   }
   /**
    * Returns the node collection for the given kind. Throws
@@ -13920,10 +13865,30 @@ var Store = class _Store {
   get #nodeOperations() {
     return this.#buildNodeOperations(this.#createNodeOperationContext());
   }
+  /**
+   * Refreshes planner statistics after an autocommit bulk write that
+   * reached the configured row threshold. A refresh failure must never
+   * fail the (already committed) write — it degrades to a warning.
+   */
+  async #maybeRefreshStatisticsAfterBulk(rowCount) {
+    const configured = this.#options?.autoRefreshStatistics;
+    if (configured === false) return;
+    const threshold = configured ?? AUTO_REFRESH_STATISTICS_ROW_THRESHOLD;
+    if (rowCount < threshold) return;
+    try {
+      await this.refreshStatistics();
+    } catch (error) {
+      console.warn(
+        "typegraph: statistics refresh after bulk write failed; run store.refreshStatistics() to avoid stale planner statistics.",
+        error
+      );
+    }
+  }
   #buildNodeOperations(ctx) {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
       rowToNode: (row) => rowToNode(row),
+      maybeRefreshStatisticsAfterBulk: (rowCount) => this.#maybeRefreshStatisticsAfterBulk(rowCount),
       executeCreate: (input, backend) => executeNodeCreate(ctx, input, backend),
       executeCreateBatch: (inputs, backend) => executeNodeCreateBatch(ctx, inputs, backend),
       executeCreateNoReturnBatch: (inputs, backend) => executeNodeCreateNoReturnBatch(ctx, inputs, backend),
@@ -13982,6 +13947,7 @@ var Store = class _Store {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
       rowToEdge: (row) => rowToEdge(row),
+      maybeRefreshStatisticsAfterBulk: (rowCount) => this.#maybeRefreshStatisticsAfterBulk(rowCount),
       executeCreate: (input, backend) => executeEdgeCreate(ctx, input, backend),
       executeCreateBatch: (inputs, backend) => executeEdgeCreateBatch(ctx, inputs, backend),
       executeCreateNoReturnBatch: (inputs, backend) => executeEdgeCreateNoReturnBatch(ctx, inputs, backend),
@@ -14181,6 +14147,44 @@ var Store = class _Store {
     );
     return recordedAt === void 0 ? void 0 : asRecordedInstant(recordedAt);
   }
+  /**
+   * Returns the durable graph revision used by graph branching. It is undefined
+   * until the first successful tracked write, which is itself a stable initial
+   * anchor. Unlike {@link recordedNow}, this is also available on a live Store
+   * created with `{ revisionTracking: true }`.
+   *
+   * @internal
+   */
+  async revisionNow() {
+    if (!this.#revisionTrackingEnabled) return void 0;
+    return readRecordedClock(this.#backend, this.#sqlSchema(), this.graphId);
+  }
+  /**
+   * Returns the durable random namespace for this graph's revision clock. A
+   * tracked base token combines it with {@link revisionNow}, preventing a
+   * branch from one independent store from matching a coincident timestamp in
+   * another store.
+   *
+   * @internal
+   */
+  async revisionOriginNow() {
+    if (!this.#revisionTrackingEnabled) {
+      throw new ConfigurationError(
+        "revisionOriginNow() requires revisionTracking: true or history: true.",
+        { code: "REVISION_ORIGIN_REQUIRES_TRACKING" }
+      );
+    }
+    const pendingOrigin = this.#revisionOrigin ?? ensureRevisionOrigin(this.#baseBackend, this.#sqlSchema(), this.graphId);
+    this.#revisionOrigin = pendingOrigin;
+    try {
+      return await pendingOrigin;
+    } catch (error) {
+      if (this.#revisionOrigin === pendingOrigin) {
+        this.#revisionOrigin = void 0;
+      }
+      throw error;
+    }
+  }
   /**
    * Returns a read-only {@link StoreView} pinned to an arbitrary public
    * temporal mode. Use {@link Store.asOf} for the common valid-time case;
@@ -14251,7 +14255,8 @@ var Store = class _Store {
       this.#search = new StoreSearch({
         graphId: this.graphId,
         backend: this.#backend,
-        registry: this.#registry
+        registry: this.#registry,
+        createQuery: () => this.query()
       });
     }
     return this.#search;
@@ -14374,6 +14379,8 @@ var Store = class _Store {
   algorithmsAtCoordinate(coordinate) {
     return createGraphAlgorithms({
       graphId: this.graphId,
+      graph: this.#graph,
+      registry: this.#registry,
       backend: this.#recordedReads.backendForCoordinate(
         coordinate,
         "recorded-graph-algorithm"
@@ -14386,12 +14393,40 @@ var Store = class _Store {
   }
   async transaction(fn, options) {
     const invoke = fn;
+    const { result } = await this.#runTransaction(invoke, options, void 0);
+    return result;
+  }
+  async transactionWithReceipt(fn, options) {
+    const invoke = fn;
+    const receiptRecorder = createTransactionReceiptRecorder();
+    const { result, recordedByGraph } = await this.#runTransaction(
+      invoke,
+      options,
+      receiptRecorder
+    );
+    return transactionOutcome(
+      result,
+      receiptRecorder,
+      recordedByGraph,
+      this.graphId
+    );
+  }
+  async #runTransaction(invoke, backendOptions, receiptRecorder) {
     if (!this.#backend.capabilities.transactions) {
-      return invoke({
-        nodes: this.nodes,
-        edges: this.edges,
+      let nodes = this.nodes;
+      let edges = this.edges;
+      if (receiptRecorder !== void 0) {
+        ({ nodes, edges } = wrapTransactionCollections(
+          nodes,
+          edges,
+          receiptRecorder
+        ));
+      }
+      const result = await invoke({
+        nodes,
+        edges,
         backend: this.#backend,
-        getNodeCollection: (kind) => this.getNodeCollection(kind),
+        getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind),
         // No transaction, no deferral: operations apply as they happen, so
         // their hooks fire immediately.
         runNodeOperationHooks: (operation, kind, id, hookedFunction) => this.#withOperationHooks(
@@ -14399,20 +14434,32 @@ var Store = class _Store {
           hookedFunction
         )
       });
+      return { result, recordedByGraph: void 0 };
     }
     const pending = [];
     const runHooks = this.#createBufferedHookRunner(pending);
+    let recordedByGraph;
+    const transactionOptions = receiptRecorder !== void 0 && this.#captureEnabled ? withRecordedFlushObserver(backendOptions, (instants) => {
+      recordedByGraph = instants;
+    }) : backendOptions;
     try {
       const result = await this.#backend.transaction(
-        async (txBackend, sql17) => invoke(this.#buildTransactionContext(txBackend, sql17, runHooks)),
-        options
+        async (txBackend, sql17) => invoke(
+          this.#buildTransactionContext(
+            txBackend,
+            sql17,
+            runHooks,
+            receiptRecorder
+          )
+        ),
+        transactionOptions
       );
       for (const outcome of pending) {
         this.#hooks.onOperationEnd?.(outcome.ctx, {
           durationMs: outcome.durationMs
         });
       }
-      return result;
+      return { result, recordedByGraph };
     } catch (error) {
       const failure = asError(error);
       for (const outcome of pending) {
@@ -14463,6 +14510,14 @@ var Store = class _Store {
    * }); // 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`
@@ -14539,34 +14594,40 @@ 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()) {
+  #buildTransactionContext(txBackend, sql17, runHooks = this.#immediateHookRunner(), receiptRecorder) {
     const txNodeOperations = {
       ...this.#buildNodeOperations(this.#createNodeOperationContext(runHooks)),
-      createQuery: () => this.#createQueryForBackend(txBackend)
+      createQuery: () => this.#createQueryForBackend(txBackend),
+      maybeRefreshStatisticsAfterBulk: void 0
     };
     const txEdgeOperations = {
       ...this.#buildEdgeOperations(this.#createEdgeOperationContext(runHooks)),
-      createQuery: () => this.#createQueryForBackend(txBackend)
+      createQuery: () => this.#createQueryForBackend(txBackend),
+      maybeRefreshStatisticsAfterBulk: void 0
     };
     const runNodeOperationHooks = (operation, kind, id, fn) => runHooks(this.#createOperationContext(operation, "node", kind, id), fn);
-    const nodes = createNodeCollectionsProxy(
+    let nodes = createNodeCollectionsProxy(
       this.#graph,
       this.graphId,
       this.#registry,
       txBackend,
       txNodeOperations
     );
-    const edges = createEdgeCollectionsProxy(
+    let edges = createEdgeCollectionsProxy(
       this.#graph,
       this.graphId,
       this.#registry,
       txBackend,
       txEdgeOperations
     );
-    const getNodeCollection = (kind) => {
-      if (!Object.hasOwn(this.#graph.nodes, kind)) return void 0;
-      return nodes[kind];
-    };
+    if (receiptRecorder !== void 0) {
+      ({ nodes, edges } = wrapTransactionCollections(
+        nodes,
+        edges,
+        receiptRecorder
+      ));
+    }
+    const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
     if (sql17 === void 0) {
       return {
         nodes,
@@ -14576,7 +14637,7 @@ var Store = class _Store {
         runNodeOperationHooks
       };
     }
-    const exposedSql = this.#captureEnabled ? createHistoryUnsafeSqlRef() : sql17;
+    const exposedSql = this.#captureEnabled ? createHistoryUnsafeSqlRef() : this.#revisionTrackingEnabled ? createRevisionTrackingUnsafeSqlRef() : sql17;
     return {
       nodes,
       edges,
@@ -14598,7 +14659,20 @@ var Store = class _Store {
    */
   async clear() {
     const doClear = async (target) => {
+      if (this.#revisionTrackingEnabled) {
+        await lockRecordedGraphWrite(target, this.graphId);
+      }
+      const previousRevision = this.#revisionTrackingEnabled && !this.#captureEnabled ? await readRecordedClock(target, this.#sqlSchema(), this.graphId) : void 0;
       await target.clearGraph(this.graphId);
+      if (this.#revisionTrackingEnabled && !this.#captureEnabled) {
+        await advanceRevisionClock(
+          target,
+          this.#sqlSchema(),
+          this.graphId,
+          this.#baseBackend.capabilities.transactions,
+          previousRevision
+        );
+      }
     };
     await (this.#baseBackend.capabilities.transactions ? this.#baseBackend.transaction(async (tx) => doClear(tx)) : doClear(this.#baseBackend));
     await this.#clearVectorStorage();
@@ -15253,6 +15327,8 @@ var Store = class _Store {
       graph: this.#graph,
       graphId: this.graphId,
       historyEnabled: this.#captureEnabled,
+      revisionTrackingEnabled: this.#revisionTrackingEnabled,
+      revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
       withOperationHooks: runHooks
@@ -15263,6 +15339,8 @@ var Store = class _Store {
       graph: this.#graph,
       graphId: this.graphId,
       historyEnabled: this.#captureEnabled,
+      revisionTrackingEnabled: this.#revisionTrackingEnabled,
+      revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
       withOperationHooks: runHooks
@@ -15434,5 +15512,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-WLRIWYHQ.js.map
-//# sourceMappingURL=chunk-WLRIWYHQ.js.map
+//# sourceMappingURL=chunk-UES55P7G.js.map
+//# sourceMappingURL=chunk-UES55P7G.js.map