@nicia-ai/typegraph 0.58.0 → 0.59.0

package/dist/{chunk-7JUD57B4.js → chunk-MKQY4ZLZ.js}

@@ -1,27 +1,27 @@
 import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteEdgeClaimsByEdgeKind } from './chunk-EFTVYPGQ.js';
 import { assertRecordedInstantOwnershipMatch, resolveRecordedTimeOwnership, requireRecordedTime, isEngineNativeRecordedReadBinding } from './chunk-7GZJ36LN.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToNodeMeta, rowToEdgeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-DV24YZHG.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToEdgeMeta, rowToNodeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-V3JKR2CN.js';
 import { applyResolvedNodeClaims, assertFulltextMember, getEmbeddingFields, computeFulltextContent } from './chunk-6BVZHDAZ.js';
 import { isBundledRootAutocommitEligible } from './chunk-AHRNKPEV.js';
 import { edgeCardinalityClaimTarget, edgeCardinalityClaimRefusal, edgeCardinalityClaim, edgeCardinalityClaimMode, claimEdgeCardinality } from './chunk-IM4X2ZOR.js';
 import { resolveBackendFulltext } from './chunk-N535PWMA.js';
 import { AtomicEdgeBatchEndpointRefusalError, AtomicEdgeConvergenceTombstoneRefusalError, AtomicEdgeDeleteIdentityRefusalError, AtomicEdgeBatchCardinalityRefusalError } from './chunk-2DNUADXX.js';
-import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, parseSerializedSchema, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-IV3FENV2.js';
+import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, parseSerializedSchema, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-E6PU35DE.js';
 import { countSchemaKindRows } from './chunk-RFMSZ7CF.js';
 import { getTypeName } from './chunk-YXT3CCTR.js';
-import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-CVO2ZPW5.js';
+import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-W4NT4IMI.js';
 import { storeRuntime, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, refuseEngineNativeRecordedIdentityRead, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, createMutationWitness, registerRecordedIdentityMutationWitness, TRANSACTION_RUNTIME, mintsOriginNamespacedAnchor, ensureRevisionOriginsRelation, generateId, runInWriteTransaction, assertCurrentRecordedSchema, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, withRecordedFlushObserver, withTransactionSchemaFenceLease, withWriteTransactionSession, resetRevisionOrigin, advanceRevisionClock, validateEdgeProps, diagnoseFusedSchemaFenceNoRow, getEdgeRowsByIds, memoizeLeasedSchemaFence, getNodeRowsByIds, hasLeasedSchemaFence, closeRecordedHardDeletedKind, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, recordedBindParamBudget, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess } from './chunk-HWWPL2YL.js';
 import { isParameterRef, resolveParameterValueType, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, withPinnedReadInstant, resolveBatchWriteVerdict, batchRefusalSuffix, batchRefusalDetails, canonicalEqual, runRetriedUnit, assertRecursiveTraversalSupported, baseField, objectField, arrayField, dateField, numberField, sortedReplacer, compileFieldValue, compileKindFilter, compileTemporalFilter, currentReadInstant, chunk, sqlValueList, buildPredicateIndex, requireRecursiveTraversalVerdict, getFieldPointer, groupBy, delay, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, isOptimisticRetryTier, OPTIMISTIC_RETRY_ATTEMPTS, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-XWMB3AFN.js';
 import { batchPointReadVerdict, statementExecutionVerdict, createClaimsVerdictThunk, uniqueSidecarBatchVerdict, contributionHealthVerdict, recordedRevisionOriginsVerdict, requireExtras, requireCatalog } from './chunk-ZQIDQHDR.js';
-import { assumeRecursiveTraversalSupported, withRecordedRelationsPrecondition, createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, resolveRecursiveTraversal, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, createEngineRecordedReadBinding, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, projectGraphBackend, deriveBackend, vectorSlotKey, requireRecordedReadBinding, projectBackend, rowPropsToObject, assertRecursiveTraversal, recordedReadSqlSchema, INTERNAL_TEMPORARY_WRITES, postgresReadWriteRefusedSqlState, assertGraphCommandConvergenceIsolation, isSchemaFencedInsertEligible, executeAuthoritativeGraphCommand, isMissingTableError, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-LI7JGO5B.js';
+import { assumeRecursiveTraversalSupported, withRecordedRelationsPrecondition, createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, resolveRecursiveTraversal, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, createEngineRecordedReadBinding, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, projectGraphBackend, deriveBackend, vectorSlotKey, requireRecordedReadBinding, projectBackend, rowPropsToObject, recordedReadSqlSchema, INTERNAL_TEMPORARY_WRITES, postgresReadWriteRefusedSqlState, assertGraphCommandConvergenceIsolation, isSchemaFencedInsertEligible, executeAuthoritativeGraphCommand, assertRecursiveTraversal, isMissingTableError, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-LI7JGO5B.js';
 import { isKnownKind } from './chunk-CYSXF3PS.js';
 import { isEdgeTargetMap, projectTargetKinds, validateEdgeEndpoints, compareClaimTargets, encodeTupleKey, uniquenessClaimTarget, subClassComponent, isSameClaimOwner, DISJOINT_CONSTRAINT_NAME, disjointnessClaimAxis } from './chunk-WUNSJGP6.js';
 import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, nowIso, recordedInstantWallTime, asRecordedInstant, createEngineRecordedInstant, validityWindowContainsInstant, validateStatedValidityLowerBound, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, preservesImmutableLowerBound, parseRecordedInstant, assertWritableValidityWindow, assertValidRecordedInstant, optionalRecordedInstantParts, isCanonicalIsoDate, statedBoundMatchesStored } from './chunk-6TIDSIPH.js';
-import { generateIndexDDL } from './chunk-GK62U3S5.js';
+import { generateIndexDDL } from './chunk-LOFUF6L7.js';
 import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-JANTPNIZ.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-QIKO6DL5.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-2QNFFAMF.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
-import { getDialect } from './chunk-YTYB5KCQ.js';
+import { getDialect } from './chunk-OH7QRGPQ.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 { assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpression, vectorMinScoreCondition } from './chunk-3MZTAXYX.js';
 import { isSqlPlaceholder, bindSqlValue, asCompiledSelectSql, sql, markAnnIndexScan, isRawExecutable, renderSql, annIndexScanTypes, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-CIYUFNZ6.js';
@@ -3473,6 +3473,344 @@ function decodeByValueType(value, valueType) {
   }
 }
 
+// src/store/neighbors.ts
+var NEIGHBOR_ORDER_FIELDS = [
+  "createdAt",
+  "id",
+  "updatedAt",
+  "validFrom",
+  "validTo"
+];
+var NEIGHBOR_ORDER_FIELD_SET = new Set(
+  NEIGHBOR_ORDER_FIELDS
+);
+function isNeighborOrderField(field2) {
+  return NEIGHBOR_ORDER_FIELD_SET.has(field2);
+}
+function mapNeighborCountRows(rows) {
+  return Number(rows[0]?.["count"] ?? 0);
+}
+function createNeighborRead(ctx, source, options) {
+  validateOptions(ctx, options);
+  const query = buildNeighborQuery(ctx, source, options, false);
+  function mapRows(rows) {
+    return rows.map((row) => ({
+      edge: mapEdge(row),
+      node: mapNode(row)
+    }));
+  }
+  return {
+    execute: async () => {
+      if (options.edges.length === 0) return [];
+      return mapRows(
+        await ctx.backend.execute(asCompiledRowsSql(query))
+      );
+    },
+    compileOneStatementBatchItem: () => ({
+      query: asCompiledRowsSql(query),
+      outputNames: neighborOutputNames(),
+      orderBy: neighborBatchOrder(options.orderBy),
+      mapRows
+    })
+  };
+}
+async function readNeighbors(ctx, source, options) {
+  return createNeighborRead(ctx, source, options).execute();
+}
+async function countNeighbors(ctx, source, options) {
+  return createNeighborCountRead(ctx, source, options).execute();
+}
+function createNeighborCountRead(ctx, source, options) {
+  validateEdgeReadBounds(options, "countNeighbors");
+  const query = buildNeighborQuery(ctx, source, options, true);
+  return {
+    execute: async () => {
+      if (options.edges.length === 0) return 0;
+      return mapNeighborCountRows(
+        await ctx.backend.execute(asCompiledRowsSql(query))
+      );
+    },
+    compileOneStatementBatchItem: () => ({
+      query: asCompiledRowsSql(query),
+      outputNames: ["count"],
+      orderBy: [],
+      mapRows: mapNeighborCountRows
+    })
+  };
+}
+function buildNeighborQuery(ctx, source, options, aggregate) {
+  const direction = options.direction ?? "out";
+  const instant = currentReadInstant();
+  const temporalMode = options.temporalMode ?? ctx.defaultTemporalMode;
+  const edgeTemporal = compileTemporalFilter({
+    mode: temporalMode,
+    asOf: options.asOf,
+    tableAlias: "e",
+    currentTimestamp: instant
+  });
+  const nodeTemporal = compileTemporalFilter({
+    mode: temporalMode,
+    asOf: options.asOf,
+    tableAlias: "n",
+    currentTimestamp: instant
+  });
+  const endpoint = endpointClauses(direction, source);
+  const where = sql.join(
+    [
+      sql`e.graph_id = ${ctx.graphId}`,
+      sql`n.graph_id = ${ctx.graphId}`,
+      compileKindFilter(sql.raw("e.kind"), options.edges),
+      edgeTemporal,
+      nodeTemporal,
+      endpoint.filter
+    ],
+    sql` AND `
+  );
+  if (aggregate) {
+    return sql`SELECT COUNT(DISTINCT e.id) AS count FROM ${ctx.schema.edgesTable} e JOIN ${ctx.schema.nodesTable} n ON ${endpoint.join} WHERE ${where}`;
+  }
+  const orderValue = buildOrderValue(ctx, options.orderBy);
+  const order = buildOrder(options.orderBy, orderValue);
+  const limit = options.limit === void 0 ? sql.empty() : sql` LIMIT ${options.limit}`;
+  return sql`SELECT ${neighborColumns()}, ${orderValue} AS typegraph_neighbor_order FROM ${ctx.schema.edgesTable} e JOIN ${ctx.schema.nodesTable} n ON ${endpoint.join} WHERE ${where} ORDER BY ${order}${limit}`;
+}
+function endpointClauses(direction, source) {
+  const outgoingFilter = sql`e.from_kind = ${source.kind} AND e.from_id = ${source.id}`;
+  const incomingFilter = sql`e.to_kind = ${source.kind} AND e.to_id = ${source.id}`;
+  switch (direction) {
+    case "out": {
+      return {
+        filter: outgoingFilter,
+        join: sql`n.kind = e.to_kind AND n.id = e.to_id`
+      };
+    }
+    case "in": {
+      return {
+        filter: incomingFilter,
+        join: sql`n.kind = e.from_kind AND n.id = e.from_id`
+      };
+    }
+    case "both": {
+      return {
+        filter: sql`((${outgoingFilter}) OR (${incomingFilter}))`,
+        join: sql`((e.from_kind = ${source.kind} AND e.from_id = ${source.id} AND n.kind = e.to_kind AND n.id = e.to_id) OR (e.to_kind = ${source.kind} AND e.to_id = ${source.id} AND n.kind = e.from_kind AND n.id = e.from_id))`
+      };
+    }
+  }
+}
+function edgeOrderColumnName(field2) {
+  switch (field2) {
+    case "id": {
+      return "id";
+    }
+    case "createdAt": {
+      return "created_at";
+    }
+    case "updatedAt": {
+      return "updated_at";
+    }
+    case "validFrom": {
+      return "valid_from";
+    }
+    case "validTo": {
+      return "valid_to";
+    }
+  }
+}
+function buildOrderValue(ctx, orderBy) {
+  if (orderBy?.by !== "node") {
+    return sql`e.${sql.raw(edgeOrderColumnName(orderBy?.field ?? "id"))}`;
+  }
+  return compileTypedJsonExtract({
+    column: sql.raw("n.props"),
+    dialect: getDialect(ctx.backend.dialect),
+    fallback: "text",
+    pointer: jsonPointer([orderBy.field]),
+    valueType: resolveNodeOrderFieldType(ctx, orderBy.field)?.valueType
+  });
+}
+function buildOrder(orderBy, value) {
+  const direction = orderBy?.direction ?? "asc";
+  return sql`CASE WHEN ${value} IS NULL THEN 1 ELSE 0 END ASC, ${value} ${sql.raw(direction.toUpperCase())}, e.id ASC`;
+}
+function neighborBatchOrder(orderBy) {
+  return [
+    {
+      column: "typegraph_neighbor_order",
+      direction: orderBy?.direction ?? "asc",
+      nulls: "last"
+    },
+    { column: "edge_id", direction: "asc", nulls: "last" }
+  ];
+}
+function validateOptions(ctx, options) {
+  validateEdgeReadBounds(options, "neighbors");
+  if (options.orderBy?.by !== "node") return;
+  resolveNodeOrderFieldType(ctx, options.orderBy.field);
+}
+function resolveNodeOrderFieldType(ctx, field2) {
+  const nodeKinds = [...ctx.registry.nodeKinds.keys()];
+  const introspector = createSchemaIntrospector(ctx.registry.nodeKinds);
+  const declaringKinds = nodeKinds.filter(
+    (kind) => introspector.getFieldTypeInfo(kind, field2) !== void 0
+  );
+  if (declaringKinds.length === 0) {
+    throw new ValidationError("Unknown adjacent-node ordering field", {
+      issues: [{ path: "neighbors.orderBy.field", message: "Invalid field" }]
+    });
+  }
+  return introspector.getSharedFieldTypeInfo(declaringKinds, field2);
+}
+function validateEdgeReadBounds(options, path) {
+  if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit <= 0)) {
+    throw new ValidationError(
+      "Neighbor limit must be a positive safe integer",
+      {
+        issues: [{ path: `${path}.limit`, message: "Invalid edge-read limit" }]
+      }
+    );
+  }
+  if (options.direction !== void 0 && options.direction !== "both" && options.direction !== "in" && options.direction !== "out") {
+    throw new ValidationError("Unknown edge traversal direction", {
+      issues: [{ path: `${path}.direction`, message: "Invalid direction" }]
+    });
+  }
+  const field2 = options.orderBy?.field;
+  if (field2 !== void 0 && options.orderBy?.by !== "node" && !isNeighborOrderField(field2)) {
+    throw new ValidationError("Unknown edge ordering field", {
+      issues: [{ path: `${path}.orderBy.field`, message: "Invalid field" }]
+    });
+  }
+  const direction = options.orderBy?.direction;
+  if (direction !== void 0 && direction !== "asc" && direction !== "desc") {
+    throw new ValidationError("Unknown edge ordering direction", {
+      issues: [
+        { path: `${path}.orderBy.direction`, message: "Invalid direction" }
+      ]
+    });
+  }
+}
+function neighborColumns() {
+  const edgeColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ];
+  const nodeColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "props",
+    "version",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ];
+  return sql.join(
+    [
+      ...edgeColumns.map(
+        (column) => sql`e.${sql.raw(column)} AS ${sql.identifier(`edge_${column}`)}`
+      ),
+      ...nodeColumns.map(
+        (column) => sql`n.${sql.raw(column)} AS ${sql.identifier(`node_${column}`)}`
+      )
+    ],
+    sql`, `
+  );
+}
+function neighborOutputNames() {
+  return [
+    "edge_graph_id",
+    "edge_id",
+    "edge_kind",
+    "edge_from_kind",
+    "edge_from_id",
+    "edge_to_kind",
+    "edge_to_id",
+    "edge_props",
+    "edge_valid_from",
+    "edge_valid_to",
+    "edge_created_at",
+    "edge_updated_at",
+    "edge_deleted_at",
+    "node_graph_id",
+    "node_id",
+    "node_kind",
+    "node_props",
+    "node_version",
+    "node_valid_from",
+    "node_valid_to",
+    "node_created_at",
+    "node_updated_at",
+    "node_deleted_at"
+  ];
+}
+function mapEdge(row) {
+  return rowToEdge({
+    id: String(row["edge_id"]),
+    kind: String(row["edge_kind"]),
+    from_kind: String(row["edge_from_kind"]),
+    from_id: String(row["edge_from_id"]),
+    to_kind: String(row["edge_to_kind"]),
+    to_id: String(row["edge_to_id"]),
+    props: row["edge_props"],
+    valid_from: normalizeRowTimestamp(
+      row["edge_valid_from"],
+      "edge_valid_from"
+    ),
+    valid_to: normalizeRowTimestamp(row["edge_valid_to"], "edge_valid_to"),
+    created_at: normalizeRequiredRowTimestamp(
+      row["edge_created_at"],
+      "edge_created_at"
+    ),
+    updated_at: normalizeRequiredRowTimestamp(
+      row["edge_updated_at"],
+      "edge_updated_at"
+    ),
+    deleted_at: normalizeRowTimestamp(
+      row["edge_deleted_at"],
+      "edge_deleted_at"
+    )
+  });
+}
+function mapNode(row) {
+  return rowToNode({
+    id: String(row["node_id"]),
+    kind: String(row["node_kind"]),
+    props: row["node_props"],
+    version: Number(row["node_version"]),
+    valid_from: normalizeRowTimestamp(
+      row["node_valid_from"],
+      "node_valid_from"
+    ),
+    valid_to: normalizeRowTimestamp(row["node_valid_to"], "node_valid_to"),
+    created_at: normalizeRequiredRowTimestamp(
+      row["node_created_at"],
+      "node_created_at"
+    ),
+    updated_at: normalizeRequiredRowTimestamp(
+      row["node_updated_at"],
+      "node_updated_at"
+    ),
+    deleted_at: normalizeRowTimestamp(
+      row["node_deleted_at"],
+      "node_deleted_at"
+    )
+  });
+}
+
 // src/store/recursive-cte.ts
 function buildReachableCte(options) {
   assertRecursiveTraversal(options.recursiveTraversal, options.operation);
@@ -3504,6 +3842,9 @@ function buildReachableCte(options) {
     options.recordedReadBinding,
     "recorded-recursive-cte"
   );
+  const edgeWindows = Object.entries(options.edgeWindows ?? {}).filter(
+    (entry2) => entry2[1] !== void 0
+  );
   const initialPath = trackPath ? options.dialect.initializePath(sql.raw("n.id")) : void 0;
   const pathExtension = trackPath ? options.dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
   const cycleCheck = options.cyclePolicy === "prevent" ? options.dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
@@ -3529,14 +3870,34 @@ function buildReachableCte(options) {
   ];
   if (cycleCheck !== void 0) recursiveWhere.push(cycleCheck);
   const forceWorktableOuterJoinOrder = options.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
+  const usesOrientedEdges = edgeWindows.length > 0;
   const recursiveCase = compileRecursiveBranch({
     recursiveColumns,
     whereClauses: recursiveWhere,
-    direction: options.direction,
+    direction: usesOrientedEdges ? "out" : options.direction,
     forceWorktableOuterJoinOrder,
-    schema
+    schema,
+    edgesTable: usesOrientedEdges ? sql.identifier("typegraph_windowed_edges") : schema.edgesTable,
+    ...usesOrientedEdges && {
+      joinField: "typegraph_source_id",
+      targetField: "typegraph_target_id",
+      targetKindField: "typegraph_target_kind"
+    }
   });
-  return sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
+  const windowedEdges = usesOrientedEdges ? buildWindowedEdgesCte(
+    schema.edgesTable,
+    options.direction,
+    options.edgeKinds.map((kind) => [kind, options.edgeWindows?.[kind]]),
+    sql.join(
+      [
+        sql`e.graph_id = ${options.graphId}`,
+        edgeKindFilter,
+        edgeTemporalFilter
+      ],
+      sql` AND `
+    )
+  ) : void 0;
+  return windowedEdges === void 0 ? sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})` : sql`WITH RECURSIVE typegraph_windowed_edges AS (${windowedEdges}), reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
 }
 function compileRecursiveBranch(options) {
   const selectClause = sql`SELECT ${sql.join([...options.recursiveColumns], sql`, `)}`;
@@ -3545,11 +3906,12 @@ function compileRecursiveBranch(options) {
       return buildDirectionalBranch({
         selectClause,
         whereClauses: options.whereClauses,
-        joinField: "from_id",
-        targetField: "to_id",
-        targetKindField: "to_kind",
+        joinField: options.joinField ?? "from_id",
+        targetField: options.targetField ?? "to_id",
+        targetKindField: options.targetKindField ?? "to_kind",
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
     case "in": {
@@ -3560,7 +3922,8 @@ function compileRecursiveBranch(options) {
         targetField: "from_id",
         targetKindField: "from_kind",
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
     case "both": {
@@ -3568,7 +3931,8 @@ function compileRecursiveBranch(options) {
         selectClause,
         whereClauses: options.whereClauses,
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
   }
@@ -3580,9 +3944,9 @@ function buildDirectionalBranch(options) {
       ...options.whereClauses,
       sql`e.${sql.raw(options.joinField)} = r.id`
     ];
-    return sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
+    return sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
   }
-  return sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON e.${sql.raw(options.joinField)} = r.id ${nodeJoin} WHERE ${sql.join([...options.whereClauses], sql` AND `)}`;
+  return sql`${options.selectClause} FROM reachable r JOIN ${options.edgesTable} e ON e.${sql.raw(options.joinField)} = r.id ${nodeJoin} WHERE ${sql.join([...options.whereClauses], sql` AND `)}`;
 }
 function buildBidirectionalBranch(options) {
   const nodeJoin = sql`JOIN ${options.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
@@ -3591,9 +3955,32 @@ function buildBidirectionalBranch(options) {
       ...options.whereClauses,
       sql`(e.from_id = r.id OR e.to_id = r.id)`
     ];
-    return sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
-  }
-  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 `)}`;
+    return sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
+  }
+  return sql`${options.selectClause} FROM reachable r JOIN ${options.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${sql.join([...options.whereClauses], sql` AND `)}`;
+}
+function buildWindowedEdgesCte(edgesTable, defaultDirection, edgeKinds, where) {
+  const branches = edgeKinds.flatMap(([kind, window]) => {
+    const direction = window?.direction ?? defaultDirection;
+    const directions = direction === "both" ? ["out", "in"] : [direction];
+    return directions.map((orientedDirection) => {
+      const sourceKind = orientedDirection === "out" ? "from_kind" : "to_kind";
+      const sourceId = orientedDirection === "out" ? "from_id" : "to_id";
+      const targetKind = orientedDirection === "out" ? "to_kind" : "from_kind";
+      const targetId = orientedDirection === "out" ? "to_id" : "from_id";
+      const column = edgeOrderColumnName(window?.orderBy?.field ?? "id");
+      const orderDirection = window?.orderBy?.direction ?? "asc";
+      const omitReverseSelfLoop = direction === "both" && orientedDirection === "in" ? sql` AND NOT (e.from_kind = e.to_kind AND e.from_id = e.to_id)` : sql.empty();
+      const oriented = sql`SELECT e.*, e.${sql.raw(sourceKind)} AS typegraph_source_kind, e.${sql.raw(sourceId)} AS typegraph_source_id, e.${sql.raw(targetKind)} AS typegraph_target_kind, e.${sql.raw(targetId)} AS typegraph_target_id`;
+      if (window === void 0) {
+        return sql`${oriented}, 1 AS typegraphedgerank FROM ${edgesTable} e WHERE ${where} AND e.kind = ${kind}${omitReverseSelfLoop}`;
+      }
+      const rank = sql`ROW_NUMBER() OVER (PARTITION BY e.kind, e.${sql.raw(sourceKind)}, e.${sql.raw(sourceId)} ORDER BY CASE WHEN e.${sql.raw(column)} IS NULL THEN 1 ELSE 0 END ASC, e.${sql.raw(column)} ${sql.raw(orderDirection.toUpperCase())}, e.id ASC)`;
+      const ranked = sql`${oriented}, ${rank} AS typegraphedgerank FROM ${edgesTable} e WHERE ${where} AND e.kind = ${kind}${omitReverseSelfLoop}`;
+      return sql`SELECT * FROM (${ranked}) ranked WHERE ranked.typegraphedgerank <= ${window.limit}`;
+    });
+  });
+  return sql.join(branches, sql` UNION ALL `);
 }
 
 // src/store/subgraph.ts
@@ -3612,52 +3999,53 @@ function normalizeProps(value) {
 function defineSubgraphProject(_graph) {
   return (project) => project;
 }
-async function executeSubgraph(params) {
+function buildSubgraphPlan(params, surface) {
   const { options } = params;
   const { valid: coordinate } = resolveReadCoordinate(
     options.temporalMode ?? params.graph.defaults.temporalMode,
     options.asOf
   );
-  const temporalMode = coordinate.mode;
-  const recordedAsOf = options.recordedAsOf;
+  validateEdgeWindows(options.edgeWindows, options.edges);
   const baseSchema = params.schema ?? DEFAULT_SQL_SCHEMA;
-  const maxDepth = Math.min(
-    options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
-    MAX_EXPLICIT_RECURSIVE_DEPTH
-  );
   const ctx = {
     graphId: params.graphId,
     rootId: params.rootId,
     edgeKinds: options.edges,
-    maxDepth,
+    maxDepth: Math.min(
+      options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
+      MAX_EXPLICIT_RECURSIVE_DEPTH
+    ),
     includeKinds: options.includeKinds,
     excludeRoot: options.excludeRoot ?? false,
     direction: options.direction ?? "out",
     cyclePolicy: options.cyclePolicy ?? "prevent",
-    temporalMode,
+    temporalMode: coordinate.mode,
     asOf: coordinate.asOf,
-    recordedAsOf,
+    // Recorded coordinates reach here only through the StoreView seam. The
+    // public API rejects them before either execution strategy is selected.
+    recordedAsOf: options.recordedAsOf,
     dialect: params.dialect,
     schema: recordedReadSchemaFor(
       baseSchema,
-      recordedAsOf,
+      options.recordedAsOf,
       params.recordedReadBinding,
-      "recorded-subgraph"
+      surface === "subgraph" ? "recorded-subgraph" : "recorded-subgraph-query"
     ),
     recordedReadBinding: params.recordedReadBinding,
-    backend: params.backend
+    backend: params.backend,
+    edgeWindows: options.edgeWindows
   };
-  const schemaIntrospector = getSubgraphSchemaIntrospector(params.graph);
+  const introspector = getSubgraphSchemaIntrospector(params.graph);
   const nodeProjectionPlan = buildProjectionPlan(
     getIncludedNodeKinds(params.graph, options.includeKinds),
     options.project?.nodes,
-    (kind, field2) => schemaIntrospector.getFieldTypeInfo(kind, field2),
+    (kind, field2) => introspector.getFieldTypeInfo(kind, field2),
     "node"
   );
   const edgeProjectionPlan = buildProjectionPlan(
     dedupeStrings(options.edges),
     options.project?.edges,
-    (kind, field2) => schemaIntrospector.getEdgeFieldTypeInfo(kind, field2),
+    (kind, field2) => introspector.getEdgeFieldTypeInfo(kind, field2),
     "edge"
   );
   const reachableCte = buildReachableCte({
@@ -3672,13 +4060,29 @@ async function executeSubgraph(params) {
     ...ctx.asOf !== void 0 && { asOf: ctx.asOf },
     ...ctx.recordedAsOf !== void 0 && { recordedAsOf: ctx.recordedAsOf },
     dialect: ctx.dialect,
-    // Base schema: buildReachableCte derives the recorded swap from recordedAsOf.
+    // The recursive compiler derives the recorded relation from the pin.
     schema: baseSchema,
     ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding },
     recursiveTraversal: resolveRecursiveTraversal(params.backend.capabilities),
-    operation: "subgraph"
+    operation: surface,
+    ...ctx.edgeWindows === void 0 ? {} : { edgeWindows: ctx.edgeWindows }
   });
-  const includedIdsCte = buildIncludedIdsCte(ctx);
+  return {
+    ctx,
+    reachableCte,
+    includedIdsCte: buildIncludedIdsCte(ctx),
+    nodeProjectionPlan,
+    edgeProjectionPlan
+  };
+}
+async function executeSubgraph(params) {
+  const {
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodeProjectionPlan,
+    edgeProjectionPlan
+  } = buildSubgraphPlan(params, "subgraph");
   let membership;
   const membershipStrategy = ctx.dialect.capabilities.subgraphMembershipStrategy;
   switch (membershipStrategy) {
@@ -3717,24 +4121,47 @@ async function executeSubgraph(params) {
     fetchSubgraphNodes(ctx, membership, nodeProjectionPlan),
     fetchSubgraphEdges(ctx, membership, edgeProjectionPlan)
   ]);
-  const nodesMap = /* @__PURE__ */ new Map();
-  for (const row of nodeRows) {
-    const node = mapSubgraphNodeRow(row, nodeProjectionPlan);
-    nodesMap.set(node.id, node);
-  }
-  const adjacency = /* @__PURE__ */ new Map();
-  const reverseAdjacency = /* @__PURE__ */ new Map();
-  for (const row of edgeRows) {
-    const edge = mapSubgraphEdgeRow(row, edgeProjectionPlan);
-    insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
-    insertAdjacencyEntry(reverseAdjacency, edge.toId, edge.kind, edge);
+  return assembleSubgraphResult(
+    ctx.rootId,
+    nodeRows.map((row) => mapSubgraphNodeRow(row, nodeProjectionPlan)),
+    edgeRows.map((row) => mapSubgraphEdgeRow(row, edgeProjectionPlan))
+  );
+}
+function createSubgraphRead(params) {
+  const {
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodeProjectionPlan: nodePlan,
+    edgeProjectionPlan: edgePlan
+  } = buildSubgraphPlan(params, "batchOnce.subgraph");
+  const query = buildOneStatementSubgraphQuery(
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodePlan,
+    edgePlan
+  );
+  function mapRows(rows) {
+    return mapOneStatementSubgraphRows(
+      ctx.rootId,
+      rows,
+      nodePlan,
+      edgePlan
+    );
   }
-  const root = nodesMap.get(ctx.rootId);
   return {
-    root,
-    nodes: nodesMap,
-    adjacency,
-    reverseAdjacency
+    execute: async () => mapRows(
+      await params.backend.execute(
+        asCompiledRowsSql(query)
+      )
+    ),
+    compileOneStatementBatchItem: () => ({
+      query: asCompiledRowsSql(query),
+      outputNames: oneStatementSubgraphOutputNames(nodePlan, edgePlan),
+      orderBy: [],
+      mapRows
+    })
   };
 }
 var introspectorCache = /* @__PURE__ */ new WeakMap();
@@ -3815,6 +4242,38 @@ 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})`;
 }
+function buildSubgraphEdgeSource(ctx, edgeTemporalFilter) {
+  const windows = Object.entries(ctx.edgeWindows ?? {}).filter(
+    (entry2) => entry2[1] !== void 0
+  );
+  if (windows.length === 0) return ctx.schema.edgesTable;
+  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
+  const windowedEdges = buildWindowedEdgesCte(
+    ctx.schema.edgesTable,
+    ctx.direction,
+    ctx.edgeKinds.map((kind) => [kind, ctx.edgeWindows?.[kind]]),
+    sql.join(
+      [sql`e.graph_id = ${ctx.graphId}`, edgeKindFilter, edgeTemporalFilter],
+      sql` AND `
+    )
+  );
+  const physicalColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ].map((column) => sql.raw(`windowed_edge.${column}`));
+  return sql`(SELECT DISTINCT ${sql.join(physicalColumns, sql`, `)} FROM (${windowedEdges}) windowed_edge)`;
+}
 function textArrayParam(values) {
   const elements = values.map(
     (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`
@@ -3829,6 +4288,125 @@ async function fetchIncludedIds(ctx, reachableCte, includedIdsCte) {
   );
   return rows.map((row) => row.id);
 }
+function projectionOutputNames(plan) {
+  return [...plan.projectedKinds.values()].flatMap(
+    (kindPlan) => kindPlan.propertyFields.map((field2) => field2.outputName)
+  );
+}
+function oneStatementSubgraphOutputNames(nodePlan, edgePlan) {
+  return [
+    "typegraph_entity",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "version",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at",
+    ...projectionOutputNames(nodePlan),
+    ...projectionOutputNames(edgePlan)
+  ];
+}
+function nullProjectionColumns(plan) {
+  return projectionOutputNames(plan).map(
+    (outputName) => sql`NULL AS ${quoteIdentifier(outputName)}`
+  );
+}
+function buildOneStatementSubgraphQuery(ctx, reachable, includedIds, nodePlan, edgePlan) {
+  const instant = currentReadInstant();
+  const nodeTemporal = compileTemporalFilter({
+    mode: ctx.temporalMode,
+    asOf: ctx.asOf,
+    recordedAsOf: ctx.recordedAsOf,
+    tableAlias: "n",
+    currentTimestamp: instant,
+    recordedReadBinding: ctx.recordedReadBinding
+  });
+  const edgeTemporal = compileTemporalFilter({
+    mode: ctx.temporalMode,
+    asOf: ctx.asOf,
+    recordedAsOf: ctx.recordedAsOf,
+    tableAlias: "e",
+    currentTimestamp: instant,
+    recordedReadBinding: ctx.recordedReadBinding
+  });
+  const nodeColumns = [
+    sql`'node' AS typegraph_entity`,
+    sql`n.id`,
+    sql`n.kind`,
+    sql`NULL AS from_kind`,
+    sql`NULL AS from_id`,
+    sql`NULL AS to_kind`,
+    sql`NULL AS to_id`,
+    buildFullPropsColumn("n", nodePlan),
+    ...buildMetadataColumns("n", nodePlan, [
+      "version",
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...buildProjectedPropertyColumns("n", nodePlan, ctx.dialect),
+    ...nullProjectionColumns(edgePlan)
+  ];
+  const edgeColumns = [
+    sql`'edge' AS typegraph_entity`,
+    sql`e.id`,
+    sql`e.kind`,
+    sql`e.from_kind`,
+    sql`e.from_id`,
+    sql`e.to_kind`,
+    sql`e.to_id`,
+    buildFullPropsColumn("e", edgePlan),
+    sql`NULL AS version`,
+    ...buildMetadataColumns("e", edgePlan, [
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...nullProjectionColumns(nodePlan),
+    ...buildProjectedPropertyColumns("e", edgePlan, ctx.dialect)
+  ];
+  const edgeSource = buildSubgraphEdgeSource(ctx, edgeTemporal);
+  return sql`${reachable}${includedIds} SELECT ${sql.join(nodeColumns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND ${nodeTemporal} AND n.id IN (SELECT id FROM included_ids) UNION ALL SELECT ${sql.join(edgeColumns, sql`, `)} FROM ${edgeSource} e WHERE e.graph_id = ${ctx.graphId} AND ${compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds)} AND ${edgeTemporal} AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
+}
+function mapOneStatementSubgraphRows(rootId, rows, nodePlan, edgePlan) {
+  const nodes = [];
+  const edges = [];
+  for (const row of rows) {
+    if (row.typegraph_entity === "node") {
+      nodes.push(mapSubgraphNodeRow(row, nodePlan));
+      continue;
+    }
+    edges.push(mapSubgraphEdgeRow(row, edgePlan));
+  }
+  return assembleSubgraphResult(rootId, nodes, edges);
+}
+function assembleSubgraphResult(rootId, nodeValues, edgeValues) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of nodeValues) nodes.set(node.id, node);
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverseAdjacency = /* @__PURE__ */ new Map();
+  for (const edge of edgeValues) {
+    insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
+    insertAdjacencyEntry(reverseAdjacency, edge.toId, edge.kind, edge);
+  }
+  return {
+    root: nodes.get(rootId),
+    nodes,
+    adjacency,
+    reverseAdjacency
+  };
+}
 async function fetchSubgraphNodes(ctx, membership, projectionPlan) {
   const nodeTemporalFilter = compileTemporalFilter({
     mode: ctx.temporalMode,
@@ -3885,12 +4463,33 @@ async function fetchSubgraphEdges(ctx, membership, projectionPlan) {
     ]),
     ...buildProjectedPropertyColumns("e", projectionPlan, ctx.dialect)
   ];
-  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"))}`;
+  const edgesSource = buildSubgraphEdgeSource(ctx, edgeTemporalFilter);
+  const query = sql`${membership.prefix}SELECT ${sql.join(columns, sql`, `)} FROM ${edgesSource} 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)
   );
 }
+function validateEdgeWindows(windows, selectedEdgeKinds) {
+  for (const [kind, window] of Object.entries(windows ?? {})) {
+    if (!selectedEdgeKinds.includes(kind)) {
+      throw new ValidationError(
+        "Subgraph edge windows must name a traversed edge kind",
+        {
+          issues: [
+            {
+              path: `edgeWindows.${kind}`,
+              message: "Edge kind is not present in options.edges"
+            }
+          ]
+        }
+      );
+    }
+    if (window !== void 0) {
+      validateEdgeReadBounds(window, `edgeWindows.${kind}`);
+    }
+  }
+}
 function buildMetadataColumns(alias, plan, columns) {
   if (plan.projectedKinds.size === 0) {
     return columns.map((col) => sql`${sql.raw(`${alias}.${col}`)}`);
@@ -3958,12 +4557,23 @@ function applyProjectedFields(target, row, kindPlan) {
     );
   }
 }
+function normalizeSubgraphRowTimestamps(row) {
+  return {
+    ...row,
+    valid_from: normalizeRowTimestamp(row.valid_from, "valid_from"),
+    valid_to: normalizeRowTimestamp(row.valid_to, "valid_to"),
+    created_at: normalizeRequiredRowTimestamp(row.created_at, "created_at"),
+    updated_at: normalizeRequiredRowTimestamp(row.updated_at, "updated_at"),
+    deleted_at: normalizeRowTimestamp(row.deleted_at, "deleted_at")
+  };
+}
 function mapSubgraphNodeRow(row, projectionPlan) {
   const kindPlan = projectionPlan.projectedKinds.get(row.kind);
   if (kindPlan === void 0) {
+    const normalizedRow = normalizeSubgraphRowTimestamps(row);
     return rowToNode({
-      ...row,
-      props: normalizeProps(row.props)
+      ...normalizedRow,
+      props: normalizeProps(normalizedRow.props)
     });
   }
   const projectedNode = {
@@ -3971,7 +4581,7 @@ function mapSubgraphNodeRow(row, projectionPlan) {
     id: row.id
   };
   if (kindPlan.includeMeta) {
-    projectedNode["meta"] = rowToNodeMeta(row);
+    projectedNode["meta"] = rowToNodeMeta(normalizeSubgraphRowTimestamps(row));
   }
   applyProjectedFields(projectedNode, row, kindPlan);
   return projectedNode;
@@ -3979,9 +4589,10 @@ function mapSubgraphNodeRow(row, projectionPlan) {
 function mapSubgraphEdgeRow(row, projectionPlan) {
   const kindPlan = projectionPlan.projectedKinds.get(row.kind);
   if (kindPlan === void 0) {
+    const normalizedRow = normalizeSubgraphRowTimestamps(row);
     return rowToEdge({
-      ...row,
-      props: normalizeProps(row.props)
+      ...normalizedRow,
+      props: normalizeProps(normalizedRow.props)
     });
   }
   const projectedEdge = {
@@ -3993,7 +4604,7 @@ function mapSubgraphEdgeRow(row, projectionPlan) {
     toId: row.to_id
   };
   if (kindPlan.includeMeta) {
-    projectedEdge["meta"] = rowToEdgeMeta(row);
+    projectedEdge["meta"] = rowToEdgeMeta(normalizeSubgraphRowTimestamps(row));
   }
   applyProjectedFields(projectedEdge, row, kindPlan);
   return projectedEdge;
@@ -7164,7 +7775,7 @@ function buildQueryAst(config, state) {
 // src/query/builder/internal-context.ts
 var contexts = /* @__PURE__ */ new WeakMap();
 function registerQueryBuilderInternalContext(config, context) {
-  if (context.recordedReadBinding === void 0 && context.sealedCoordinate === void 0 && context.runtimeKindTokenResolver === void 0) {
+  if (context.recordedReadBinding === void 0 && context.sealedCoordinate === void 0 && context.runtimeKindTokenResolver === void 0 && context.expectedSchemaVersion === void 0) {
     return;
   }
   contexts.set(config, context);
@@ -7222,6 +7833,97 @@ function buildVectorSlots(registry) {
   return slots;
 }
 
+// src/query/builder/one-statement-batch.ts
+var ORDER_COLUMN = "typegraphbatchordinal";
+var ORDER_KEY_PREFIX = "typegraphbatchorder";
+function oneStatementBatchOrderColumn(index) {
+  return `${ORDER_KEY_PREFIX}${index}`;
+}
+function buildOrdinalOrder(rowAlias, orderBy) {
+  if (orderBy.length === 0) return sql.empty();
+  const row = sql.identifier(rowAlias);
+  const terms = orderBy.flatMap((order) => {
+    const column = sql`${row}.${sql.identifier(order.column)}`;
+    const nullDirection = order.nulls === "first" ? sql.raw("DESC") : sql.raw("ASC");
+    return [
+      sql`(${column} IS NULL) ${nullDirection}`,
+      sql`${column} ${sql.raw(order.direction.toUpperCase())}`
+    ];
+  });
+  return sql`ORDER BY ${sql.join(terms, sql`, `)}`;
+}
+async function executeOneStatementBatch(backend, queries) {
+  const dialect = getDialect(backend.dialect);
+  const items = queries.map((query) => {
+    const compile = query.compileOneStatementBatchItem;
+    if (compile === void 0) {
+      throw new ConfigurationError(
+        "Read cannot be embedded in store.batchOnce().",
+        { operation: "batchOnce" },
+        {
+          suggestion: "Pass a fluent relational query or a set-oriented read returned by the store's query helpers."
+        }
+      );
+    }
+    return compile.call(query);
+  });
+  const ctes = [];
+  const branches = [];
+  for (const [index, item] of items.entries()) {
+    const reservedAlias = item.outputNames.find(
+      (outputName) => outputName === ORDER_COLUMN || outputName.startsWith(ORDER_KEY_PREFIX)
+    );
+    if (reservedAlias !== void 0) {
+      throw new ConfigurationError(
+        `Query output alias "${reservedAlias}" is reserved by store.batchOnce().`,
+        { operation: "batchOnce", alias: reservedAlias }
+      );
+    }
+    const sourceName = `typegraph_batch_source_${index}`;
+    const rowsName = `typegraph_batch_rows_${index}`;
+    const ordinalOrder = buildOrdinalOrder(sourceName, item.orderBy);
+    ctes.push(
+      sql`${sql.identifier(sourceName)} AS (${item.query})`,
+      sql`${sql.identifier(rowsName)} AS (SELECT ${sql.identifier(sourceName)}.*, ROW_NUMBER() OVER (${ordinalOrder}) AS ${sql.identifier(ORDER_COLUMN)} FROM ${sql.identifier(sourceName)})`
+    );
+    const payload = dialect.orderedRowsJsonArray(
+      rowsName,
+      item.outputNames,
+      ORDER_COLUMN
+    );
+    branches.push(sql`SELECT ${index} AS batch_index, ${payload} AS payload`);
+  }
+  const statement = asCompiledRowsSql(
+    sql`WITH ${sql.join(ctes, sql`, `)} SELECT * FROM (${sql.join(branches, sql` UNION ALL `)}) AS typegraph_batch_envelope ORDER BY batch_index`
+  );
+  const envelopes = await backend.execute(statement);
+  const payloads = /* @__PURE__ */ new Map();
+  for (const envelope of envelopes) {
+    payloads.set(Number(envelope.batch_index), parsePayload(envelope.payload));
+  }
+  return items.map(
+    (item, index) => item.mapRows(payloads.get(index) ?? [])
+  );
+}
+function parsePayload(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  if (!Array.isArray(parsed)) {
+    throw new ConfigurationError(
+      "One-statement batch returned a non-array JSON payload.",
+      { operation: "batchOnce" }
+    );
+  }
+  return parsed.map((row) => {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new ConfigurationError(
+        "One-statement batch returned a non-object row.",
+        { operation: "batchOnce" }
+      );
+    }
+    return row;
+  });
+}
+
 // src/query/builder/order-by-field.ts
 var COMMON_SYSTEM_ORDER_FIELDS = /* @__PURE__ */ new Map([
   ["id", "string"],
@@ -7511,6 +8213,12 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws Error if no backend is configured
    */
   prepare() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new ConfigurationError(
+        "Prepared queries are unavailable inside withCheckedReads().",
+        { operation: "withCheckedReads.prepare" }
+      );
+    }
     if (!this.#config.backend) {
       throw new Error(
         "Cannot prepare query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -7631,6 +8339,10 @@ var ExecutableQuery = class _ExecutableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
+    const checked = getQueryBuilderInternalContext(
+      this.#config
+    ).expectedSchemaVersion;
+    if (checked !== void 0) return this.executeChecked(checked.value);
     const optimizedResult = await this.#tryOptimizedExecution();
     if (optimizedResult !== void 0) {
       return optimizedResult;
@@ -7696,6 +8408,24 @@ var ExecutableQuery = class _ExecutableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
+    const checked = getQueryBuilderInternalContext(
+      this.#config
+    ).expectedSchemaVersion;
+    if (checked !== void 0) {
+      const rows2 = await executeSchemaCheckedRead({
+        backend,
+        ast,
+        graphId: this.#config.graphId,
+        expectedVersion: checked.value,
+        compile: () => compileQuery(ast, this.#config.graphId, this.#compileOptions())
+      });
+      return mapResults(
+        rows2,
+        this.#state.startAlias,
+        this.#state.traversals,
+        this.#selectFn
+      );
+    }
     const optimizedResult = await this.#tryOptimizedExecutionOn(backend);
     if (optimizedResult !== void 0) {
       return optimizedResult;
@@ -7713,6 +8443,53 @@ var ExecutableQuery = class _ExecutableQuery {
       this.#selectFn
     );
   }
+  /** @internal Embedding contract consumed by `store.batchOnce()`. */
+  compileOneStatementBatchItem() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new ConfigurationError(
+        "Queries from withCheckedReads() cannot be embedded in batchOnce().",
+        { operation: "withCheckedReads.batchOnce" }
+      );
+    }
+    if (this.#hasParameterReferences()) {
+      throw new Error(
+        "Query contains param() references. Bind prepared queries before batching."
+      );
+    }
+    const ast = this.toAst();
+    const batchOrderBy = (ast.orderBy ?? []).map((order, index) => ({
+      column: oneStatementBatchOrderColumn(index),
+      direction: order.direction,
+      nulls: order.nulls ?? (order.direction === "asc" ? "last" : "first")
+    }));
+    const batchAst = batchOrderBy.length === 0 ? ast : {
+      ...ast,
+      projection: {
+        fields: [
+          ...ast.projection.fields,
+          ...(ast.orderBy ?? []).map((order, index) => ({
+            outputName: oneStatementBatchOrderColumn(index),
+            source: order.field
+          }))
+        ]
+      }
+    };
+    return {
+      query: compileQuery(
+        batchAst,
+        this.#config.graphId,
+        this.#compileOptions()
+      ),
+      outputNames: ast.projection.fields.map((field2) => field2.outputName),
+      orderBy: batchOrderBy,
+      mapRows: (rows) => mapResults(
+        transformPathColumns(rows, this.#state, this.#dialect()),
+        this.#state.startAlias,
+        this.#state.traversals,
+        this.#selectFn
+      )
+    };
+  }
   /**
    * Attempts optimized execution by tracking which fields the select callback accesses.
    *
@@ -8135,6 +8912,7 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws ValidationError if cursor columns don't match query ORDER BY columns
    */
   async paginate(options) {
+    this.#refuseCheckedReadSurface("paginate");
     if (!this.#config.backend) {
       throw new Error(
         "Cannot execute query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -8216,6 +8994,7 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws ValidationError if ORDER BY is not specified
    */
   stream(options) {
+    this.#refuseCheckedReadSurface("stream");
     if (this.#state.orderBy.length === 0) {
       throw new ValidationError(
         "Streaming requires ORDER BY. Add .orderBy() before .stream()",
@@ -8235,6 +9014,15 @@ var ExecutableQuery = class _ExecutableQuery {
       (paginateOptions) => this.paginate(paginateOptions)
     );
   }
+  #refuseCheckedReadSurface(surface) {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion === void 0) {
+      return;
+    }
+    throw new ConfigurationError(
+      `${surface === "paginate" ? "Pagination" : "Streaming"} is unavailable inside withCheckedReads().`,
+      { operation: `withCheckedReads.${surface}` }
+    );
+  }
   /**
    * Executes a query with cursor conditions applied.
    */
@@ -8401,6 +9189,12 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
    * @throws Error if no backend is configured
    */
   async execute() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new ConfigurationError(
+        "Aggregate queries are unavailable inside withCheckedReads().",
+        { operation: "withCheckedReads.aggregate" }
+      );
+    }
     const backend = this.#config.backend;
     if (!backend) {
       throw new Error(
@@ -9928,6 +10722,7 @@ var UnionableQuery = class _UnionableQuery {
    * Executes the combined query.
    */
   async execute() {
+    this.#refuseCheckedScope();
     if (!this.#config.backend) {
       throw new Error(
         "Cannot execute query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -9952,6 +10747,7 @@ var UnionableQuery = class _UnionableQuery {
    * transaction support.
    */
   async executeOn(backend) {
+    this.#refuseCheckedScope();
     const ast = this.toAst();
     if (composableQueryHasParameterReferences(ast)) {
       throw new Error(
@@ -9962,7 +10758,40 @@ var UnionableQuery = class _UnionableQuery {
       await this.#fetchRows(backend, ast, "recorded-batch-query")
     );
   }
+  /** @internal Embedding contract consumed by `store.batchOnce()`. */
+  compileOneStatementBatchItem() {
+    this.#refuseCheckedScope();
+    const ast = this.toAst();
+    if (composableQueryHasParameterReferences(ast)) {
+      throw new Error(
+        "Query contains param() references. Bind prepared queries before batching."
+      );
+    }
+    return {
+      query: compileSetOperation2(
+        ast,
+        this.#config.graphId,
+        this.#compileOptions()
+      ),
+      outputNames: projectionOutputNames2(ast),
+      orderBy: [],
+      mapRows: (rows) => this.#mapRows(rows)
+    };
+  }
+  #refuseCheckedScope() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion === void 0) {
+      return;
+    }
+    throw new ConfigurationError(
+      "Set operations are unavailable inside withCheckedReads().",
+      { operation: "withCheckedReads.setOperation" }
+    );
+  }
 };
+function projectionOutputNames2(query) {
+  if ("__type" in query) return projectionOutputNames2(query.left);
+  return query.projection.fields.map((field2) => field2.outputName);
+}
 
 // src/query/builder/aggregates.ts
 function count(alias, field2) {
@@ -10190,6 +11019,9 @@ function createQueryBuilderWithContext(graphId, registry, options) {
     },
     ...options?.runtimeKindTokenResolver !== void 0 && {
       runtimeKindTokenResolver: options.runtimeKindTokenResolver
+    },
+    ...options?.expectedSchemaVersion !== void 0 && {
+      expectedSchemaVersion: options.expectedSchemaVersion
     }
   });
   const sealed = options?.sealedCoordinate?.valid;
@@ -21965,6 +22797,20 @@ var StoreImplementation = class _StoreImplementation {
   query() {
     return this.#createQueryForBackend(this.#backend);
   }
+  /**
+   * Runs a read block whose fluent queries automatically use
+   * `executeChecked(expectedSchemaVersion)` when `.execute()` is called.
+   * A schema mismatch aborts the block with `SchemaChangedError`, so callers
+   * can put one reload-and-retry boundary around the whole block.
+   */
+  withCheckedReads(expectedSchemaVersion, fn) {
+    const reads = {
+      query: () => this.#createQueryForBackend(this.#backend, void 0, 1, {
+        value: expectedSchemaVersion
+      })
+    };
+    return fn(reads);
+  }
   /**
    * Internal seam for {@link StoreView.query}: a query builder pinned to a
    * view's {@link ReadCoordinate} with its temporal axis sealed
@@ -22360,6 +23206,70 @@ var StoreImplementation = class _StoreImplementation {
       return results;
     });
   }
+  /**
+   * Executes two or more independent relational queries as exactly one SQL
+   * statement and returns their typed results in input order.
+   *
+   * Each read is embedded as a CTE and its rows are returned through a JSON
+   * envelope. Unlike {@link batch}, this method opens no transaction and has
+   * no sequential fallback: one call means one statement on every supported
+   * backend. Fluent queries and the reads built by the callback are composable
+   * here.
+   */
+  async batchOnce(build) {
+    const queries = build({
+      neighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return createNeighborRead(this.#neighborContext(), source, options);
+      },
+      countNeighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return createNeighborCountRead(
+          this.#neighborContext(),
+          source,
+          options
+        );
+      },
+      subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options)
+    });
+    return executeOneStatementBatch(
+      this.#createHookedQueryBackend(this.#baseBackend),
+      queries
+    );
+  }
+  /** Reads hydrated adjacent nodes and their connecting edges in one statement. */
+  async neighbors(source, options) {
+    this.#assertNeighborKinds(source, options.edges);
+    return readNeighbors(this.#neighborContext(), source, options);
+  }
+  /** Counts visible relationships to adjacent nodes without hydrating them. */
+  async countNeighbors(source, options) {
+    this.#assertNeighborKinds(source, options.edges);
+    return countNeighbors(this.#neighborContext(), source, options);
+  }
+  #neighborContext() {
+    return {
+      graphId: this.graphId,
+      backend: this.#createHookedQueryBackend(this.#backend),
+      schema: this.#sqlSchema(),
+      defaultTemporalMode: this.#graph.defaults.temporalMode,
+      registry: this.#registry
+    };
+  }
+  #assertNeighborKinds(source, edgeKinds) {
+    if (!Object.hasOwn(this.#graph.nodes, source.kind)) {
+      throw new KindNotFoundError(source.kind, "node", {
+        graphId: this.graphId
+      });
+    }
+    for (const edgeKind of edgeKinds) {
+      if (!Object.hasOwn(this.#graph.edges, edgeKind)) {
+        throw new KindNotFoundError(edgeKind, "edge", {
+          graphId: this.graphId
+        });
+      }
+    }
+  }
   /**
    * Reads several edge kinds from heterogeneous source nodes with round trips
    * independent of the number of licensed edge/source-kind combinations.
@@ -22520,6 +23430,23 @@ var StoreImplementation = class _StoreImplementation {
     });
     return this.subgraphAtCoordinate(rootId, options);
   }
+  #createSubgraphRead(rootId, options) {
+    assertNoRecordedCoordinate(options, {
+      code: "SUBGRAPH_RECORDED_ASOF_INTERNAL_ONLY",
+      message: "recordedAsOf is only available through store.asOfRecorded(...).subgraph(...).",
+      suggestion: "Use store.asOfRecorded(recordedAt).subgraph(rootId, options) instead of passing recordedAsOf directly."
+    });
+    return createSubgraphRead({
+      graph: this.#graph,
+      graphId: this.graphId,
+      rootId,
+      backend: this.#createHookedQueryBackend(this.#baseBackend),
+      dialect: getDialect(this.#backend.dialect),
+      schema: this.#schema,
+      recordedReadBinding: this.#recordedReadBinding,
+      options
+    });
+  }
   /**
    * Internal seam for {@link StoreView} / {@link RecordedStoreView}: runs a
    * subgraph with a coordinate already flattened into the options (including a
@@ -24463,7 +25390,7 @@ var StoreImplementation = class _StoreImplementation {
       }
     };
   }
-  #createQueryForBackend(backend, sealedCoordinate, attempt = 1) {
+  #createQueryForBackend(backend, sealedCoordinate, attempt = 1, expectedSchemaVersion) {
     const queryBackend = this.#createHookedQueryBackend(backend, attempt);
     return createInternalQueryBuilder(
       this.graphId,
@@ -24479,7 +25406,8 @@ var StoreImplementation = class _StoreImplementation {
         ...this.#recordedReadBinding !== void 0 && {
           recordedReadBinding: this.#recordedReadBinding
         },
-        ...sealedCoordinate !== void 0 && { sealedCoordinate }
+        ...sealedCoordinate !== void 0 && { sealedCoordinate },
+        ...expectedSchemaVersion !== void 0 && { expectedSchemaVersion }
       }
     );
   }
@@ -24920,5 +25848,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { CURRENT_ONLY_READ_NAMES, EDGE_TEMPORAL_READ_NAMES, ExecutableAggregateQuery, ExecutableQuery, IDENTITY_READ_NAMES, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, NODE_TEMPORAL_READ_NAMES, PreparedQuery, QueryBuilder, RecordedStoreView, StoreAnalysisCursorStaleError, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-7JUD57B4.js.map
-//# sourceMappingURL=chunk-7JUD57B4.js.map
+//# sourceMappingURL=chunk-MKQY4ZLZ.js.map
+//# sourceMappingURL=chunk-MKQY4ZLZ.js.map