@nicia-ai/typegraph 0.58.0 → 0.60.0

package/dist/{store-BzmMsCcw.d.ts → store-B5WZ8E5m.d.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { $ as NodeType, fp as EdgeType, _ as AnyEdgeType, G as GraphIdentityConfig, e9 as ValueType, hs as PredicateExpression, cm as FulltextQueryMode, ht as VectorMetricType, Q as QueryAst, J as JsonPointer, eP as FieldRef, go as ParameterRef, gQ as TraversalExpansion, f as GraphBackend, q as SqlDialect, gH as SqlSchema, hu as Traversal, hv as NodePredicate, hw as ProjectedField, gn as OrderSpec, hx as AggregateOrderSpec, dS as TemporalMode, R as RecordedInstant, hy as GroupBySpec, fI as HybridFusionOptions, fX as JsonPointerInput, hz as RecursiveCyclePolicy, e as GraphDef, eS as TraversalDirection$1, fm as EdgeRegistration, gf as NodeId, T as TransactionBackend, eO as AggregateExpr, gG as SortDirection, b2 as CompiledSelectSql, d as FulltextStrategy, V as VectorStrategy, hA as VectorSlotMap, hB as RecordedReadBinding, dr as RecursiveTraversalVerdict, hC as SelectiveField, hD as ComposableQuery, hE as SetOperationType, hF as SetOperation, gi as NodeKinds, n as NodeRow, K as KindEntity, fC as ExternalRecordedReadSource, ff as EdgeId, l as EdgeRow, hG as BackendValidityEndMutation, cQ as JsonScalar, gm as NodeRegistration, fg as EdgeKinds, dV as TransactionReadBackend, eV as AllNodeTypes, am as SchemaDiff, S as SchemaVersionRow, a5 as SerializedSchema, fG as GraphAnnotations, cS as KindAnnotations, ai as JsonSchema, d_ as UniquenessScope, aY as Collation, aR as Cardinality, bN as EndpointExistence, cs as GraphExtension, hH as ReadCoordinate, aN as BackendIdentity, cq as GraphEntityReadBackend, dD as SchemaReadBackend, dd as QueryExecutionBackend, dH as SqlCompilationBackend, de as RawQueryExecutionBackend, ec as VectorMetric, aG as TypeGraphError, Y as BackendCapabilities, b$ as ExtensionNodeDef, hI as ExtensionObjectSchema, bV as ExtensionEdgeDef, hJ as ExtensionEdgeProperties, g5 as MaterializeIndexesOptions, g6 as MaterializeIndexesResult, g7 as MaterializeSystemIndexesOptions, C as ContributionDiagnostic, c as ContributionRepairResult, be as ContributionProbeResult, bh as ContributionRebuildScope, bg as ContributionRebuildResult, dU as TransactionOptions, A as AdapterBackend } from './types-Blq8PG_N.js';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-CUWWphQI.js';
-import { b as BundleVerdictOf, U as UNIQUE_SIDECAR_BATCH, B as BATCH_POINT_READ } from './resolve-DgFSIK99.js';
+import { $ as NodeType, fp as EdgeType, _ as AnyEdgeType, G as GraphIdentityConfig, e9 as ValueType, hs as PredicateExpression, cm as FulltextQueryMode, ht as VectorMetricType, Q as QueryAst, J as JsonPointer, eP as FieldRef, go as ParameterRef, gQ as TraversalExpansion, f as GraphBackend, q as SqlDialect, gH as SqlSchema, hu as Traversal, hv as NodePredicate, hw as ProjectedField, gn as OrderSpec, hx as AggregateOrderSpec, dS as TemporalMode, R as RecordedInstant, hy as GroupBySpec, fI as HybridFusionOptions, fX as JsonPointerInput, hz as RecursiveCyclePolicy, e as GraphDef, eS as TraversalDirection$1, fm as EdgeRegistration, gf as NodeId, T as TransactionBackend, b2 as CompiledSelectSql, eO as AggregateExpr, gG as SortDirection, d as FulltextStrategy, V as VectorStrategy, hA as VectorSlotMap, hB as RecordedReadBinding, dr as RecursiveTraversalVerdict, hC as SelectiveField, hD as ComposableQuery, hE as SetOperationType, hF as SetOperation, fg as EdgeKinds, eV as AllNodeTypes, gi as NodeKinds, n as NodeRow, K as KindEntity, fC as ExternalRecordedReadSource, ff as EdgeId, l as EdgeRow, hG as BackendValidityEndMutation, cQ as JsonScalar, gm as NodeRegistration, dV as TransactionReadBackend, am as SchemaDiff, S as SchemaVersionRow, a5 as SerializedSchema, fG as GraphAnnotations, cS as KindAnnotations, ai as JsonSchema, d_ as UniquenessScope, aY as Collation, aR as Cardinality, bN as EndpointExistence, cs as GraphExtension, hH as ReadCoordinate, aN as BackendIdentity, cq as GraphEntityReadBackend, dD as SchemaReadBackend, dd as QueryExecutionBackend, dH as SqlCompilationBackend, de as RawQueryExecutionBackend, ec as VectorMetric, aG as TypeGraphError, Y as BackendCapabilities, b$ as ExtensionNodeDef, hI as ExtensionObjectSchema, bV as ExtensionEdgeDef, hJ as ExtensionEdgeProperties, g5 as MaterializeIndexesOptions, g6 as MaterializeIndexesResult, g7 as MaterializeSystemIndexesOptions, C as ContributionDiagnostic, c as ContributionRepairResult, be as ContributionProbeResult, bh as ContributionRebuildScope, bg as ContributionRebuildResult, dU as TransactionOptions, A as AdapterBackend } from './types-Dky3sCFz.js';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-Bg2lMPRm.js';
+import { b as BundleVerdictOf, U as UNIQUE_SIDECAR_BATCH, B as BATCH_POINT_READ } from './resolve-BbjZDYTw.js';
 
 /**
  * Who allocates recorded-time revisions for a backend: TypeGraph's own
@@ -593,6 +593,31 @@ type QueryCoordinateState = "open" | "sealed";
 type BatchableQuery<R = unknown> = Readonly<{
     executeOn: (backend: GraphBackend | TransactionBackend) => Promise<readonly R[]>;
 }>;
+/** A read whose result can be embedded in an exact-one-statement batch. */
+type OneStatementBatchableQuery<R = unknown> = Readonly<{
+    execute?: () => Promise<R>;
+    /** @internal Resolved by `store.batchOnce()` before execution. */
+    compileOneStatementBatchItem?: () => Readonly<{
+        query: CompiledSelectSql;
+        outputNames: readonly string[];
+        orderBy: readonly Readonly<{
+            column: string;
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }>[];
+        mapRows: (rows: readonly Record<string, unknown>[]) => R;
+    }>;
+}>;
+/** A cold read with a concrete one-statement batch compilation contract. */
+type CompiledOneStatementRead<R> = Required<Pick<OneStatementBatchableQuery<R>, "compileOneStatementBatchItem">>;
+/** A read that can be embedded in an exact-one-statement batch. */
+type EmbeddableOneStatementRead<R> = OneStatementBatchableQuery<R> & (BatchableQuery<unknown> | CompiledOneStatementRead<R>);
+/** An embeddable one-statement read that can also execute independently. */
+type ExecutableOneStatementRead<R> = CompiledOneStatementRead<R> & Required<Pick<OneStatementBatchableQuery<R>, "execute">>;
+/** Preserves each input query's result type in an exact-one-statement batch. */
+type OneStatementBatchResults<Queries extends readonly EmbeddableOneStatementRead<unknown>[]> = {
+    -readonly [K in keyof Queries]: Queries[K] extends (EmbeddableOneStatementRead<infer R>) ? R : never;
+};
 /**
  * Maps a tuple of BatchableQuery types to their result types.
  *
@@ -1347,6 +1372,17 @@ declare class UnionableQuery<G extends GraphDef, R> {
      * transaction support.
      */
     executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
+    /** @internal Embedding contract consumed by `store.batchOnce()`. */
+    compileOneStatementBatchItem?(): Readonly<{
+        query: CompiledSelectSql;
+        outputNames: readonly string[];
+        orderBy: readonly Readonly<{
+            column: string;
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }>[];
+        mapRows: (rows: readonly Record<string, unknown>[]) => readonly R[];
+    }>;
 }
 
 /**
@@ -1492,6 +1528,17 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
      * The fallback clears the fast path for this instance.
      */
     executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
+    /** @internal Embedding contract consumed by `store.batchOnce()`. */
+    compileOneStatementBatchItem?(): Readonly<{
+        query: CompiledSelectSql;
+        outputNames: readonly string[];
+        orderBy: readonly Readonly<{
+            column: string;
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }>[];
+        mapRows: (rows: readonly Record<string, unknown>[]) => readonly R[];
+    }>;
     /**
      * Executes a paginated query using cursor-based keyset pagination.
      *
@@ -1883,6 +1930,215 @@ declare const IDENTITY_READ_NAMES: readonly ["representativeOf", "membersOf", "n
 /** Recorded-time collection point reads that reconstruct safely by id. */
 declare const RECORDED_POINT_READ_NAMES: readonly ["getById", "getByIds"];
 
+/** Edge metadata fields accepted by bounded neighbor and subgraph reads. */
+type NeighborOrderField = "createdAt" | "id" | "updatedAt" | "validFrom" | "validTo";
+/** Node property names accepted by adjacent-node ordering. */
+type NeighborNodeOrderField<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]: Exclude<keyof Node<G["nodes"][K]["type"]>, "id" | "kind" | "meta"> & string;
+}[keyof G["nodes"] & string];
+type NeighborOrder<G extends GraphDef> = Readonly<{
+    by?: "edge";
+    field: NeighborOrderField;
+    direction?: "asc" | "desc";
+}> | Readonly<{
+    by: "node";
+    field: NeighborNodeOrderField<G>;
+    direction?: "asc" | "desc";
+}>;
+/** Per-edge-kind ordering and bound applied before traversal expands an edge. */
+type EdgeReadWindow = Readonly<{
+    limit: number;
+    /** Direction for this edge kind; defaults to the traversal direction. */
+    direction?: "both" | "in" | "out";
+    orderBy?: Readonly<{
+        field: NeighborOrderField;
+        direction?: "asc" | "desc";
+    }>;
+}>;
+/** Options for reading adjacent edge-node pairs without hydrating all targets. */
+type NeighborReadOptionsBoundary<G extends GraphDef, K extends EdgeKinds<G>> = Readonly<{
+    edges?: readonly K[];
+    direction?: "both" | "in" | "out";
+    orderBy?: NeighborOrder<G>;
+    limit?: number;
+    temporalMode?: TemporalMode;
+    asOf?: string;
+}>;
+type NeighborReadOptions<G extends GraphDef, K extends EdgeKinds<G>> = NeighborReadOptionsBoundary<G, K> & Required<Pick<NeighborReadOptionsBoundary<G, K>, "edges">>;
+/** One edge and the node it reaches from the requested source and direction. */
+type NeighborResult<G extends GraphDef, K extends EdgeKinds<G>> = Readonly<{
+    edge: GraphEdgeForKinds<G, K>;
+    node: Node<AllNodeTypes<G>>;
+}>;
+
+/**
+ * Discriminated union of all Node runtime types in a graph.
+ *
+ * Unlike `AllNodeTypes<G>` which gives the union of *type definitions*,
+ * `AnyNode<G>` gives the union of *runtime node instances*.
+ */
+type AnyNode<G extends GraphDef> = {
+    [K in NodeKinds<G>]: Node<G["nodes"][K]["type"]>;
+}[NodeKinds<G>];
+/**
+ * Discriminated union of all Edge runtime types in a graph.
+ */
+type AnyEdge<G extends GraphDef> = {
+    [K in EdgeKinds<G>]: Edge<G["edges"][K]["type"]>;
+}[EdgeKinds<G>];
+/**
+ * Discriminated union of Node runtime types narrowed to a subset of kinds.
+ */
+type SubsetNode<G extends GraphDef, K extends NodeKinds<G>> = {
+    [Kind in K]: Node<G["nodes"][Kind]["type"]>;
+}[K];
+/**
+ * Discriminated union of Edge runtime types narrowed to a subset of kinds.
+ */
+type SubsetEdge<G extends GraphDef, K extends EdgeKinds<G>> = {
+    [Kind in K]: Edge<G["edges"][Kind]["type"]>;
+}[K];
+type EmptyShape = Readonly<Record<never, never>>;
+type NodeProjectionPropertyKey<N extends NodeType> = Exclude<keyof Node<N>, "id" | "kind" | "meta"> & string;
+type EdgeProjectionPropertyKey<E extends AnyEdgeType> = Exclude<keyof Edge<E>, "id" | "kind" | "fromKind" | "fromId" | "toKind" | "toId" | "meta"> & string;
+type SubgraphNodeProjectionField<N extends NodeType = NodeType> = NodeProjectionPropertyKey<N> | "meta";
+type SubgraphEdgeProjectionField<E extends AnyEdgeType = AnyEdgeType> = EdgeProjectionPropertyKey<E> | "meta";
+type SubgraphNodeProjectionMap<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>> = Readonly<{
+    [K in NodeKinds<G>]?: K extends NK ? readonly SubgraphNodeProjectionField<G["nodes"][K]["type"]>[] : never;
+}>;
+type SubgraphEdgeProjectionMap<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>> = Readonly<{
+    [K in EdgeKinds<G>]?: K extends EK ? readonly SubgraphEdgeProjectionField<G["edges"][K]["type"]>[] : never;
+}>;
+type SubgraphProject<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>> = Readonly<{
+    /**
+     * Node fields to keep per kind.
+     *
+     * Projected nodes always retain `kind` and `id`.
+     * Use `"meta"` to include the full metadata object; omit it to exclude metadata entirely.
+     * Only kinds present in `includeKinds` (or all node kinds when omitted) are valid keys.
+     */
+    nodes?: SubgraphNodeProjectionMap<G, NK>;
+    /**
+     * Edge fields to keep per kind.
+     *
+     * Projected edges always retain `id`, `kind`, `fromKind`, `fromId`,
+     * `toKind`, and `toId`.
+     * Use `"meta"` to include the full metadata object; omit it to exclude metadata entirely.
+     * Only edge kinds listed in `edges` are valid keys.
+     */
+    edges?: SubgraphEdgeProjectionMap<G, EK>;
+}>;
+/**
+ * Identity function that preserves literal types for reusable projection configs.
+ *
+ * Without this helper, storing a projection in a typed variable widens the
+ * field arrays to `string[]`, defeating compile-time narrowing on results.
+ *
+ * @example
+ * ```ts
+ * const project = defineSubgraphProject(graph)({
+ *   nodes: { Task: ["title", "meta"] },
+ *   edges: { uses_skill: [] },
+ * });
+ * const result = await store.subgraph(rootId, { edges: ["uses_skill"], project });
+ * // result.nodes narrowed correctly — task.status is a type error
+ * ```
+ */
+declare function defineSubgraphProject<G extends GraphDef>(_graph: G): <const P extends SubgraphProject<G>>(project: P) => P;
+type HasMeta<Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? "meta" extends Selection[number] ? true : false : false;
+type SelectedNodeProps<N extends NodeType, Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? Pick<Node<N>, Extract<Selection[number], NodeProjectionPropertyKey<N>>> : EmptyShape;
+type SelectedEdgeProps<E extends AnyEdgeType, Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? Pick<Edge<E>, Extract<Selection[number], EdgeProjectionPropertyKey<E>>> : EmptyShape;
+type ProjectedNodeResult<N extends NodeType, Selection extends readonly string[] | undefined> = Readonly<Pick<Node<N>, "id" | "kind">> & Readonly<SelectedNodeProps<N, Selection>> & (HasMeta<Selection> extends true ? Readonly<{
+    meta: NodeMeta;
+}> : EmptyShape);
+type ProjectedEdgeResult<E extends AnyEdgeType, Selection extends readonly string[] | undefined> = Readonly<Pick<Edge<E>, "id" | "kind" | "fromKind" | "fromId" | "toKind" | "toId">> & Readonly<SelectedEdgeProps<E, Selection>> & (HasMeta<Selection> extends true ? Readonly<{
+    meta: EdgeMeta;
+}> : EmptyShape);
+type ProjectionSelection<P, Key extends "nodes" | "edges", Kind extends string> = P extends Readonly<{
+    [K in Key]?: infer Map;
+}> ? Map extends Readonly<Record<string, readonly string[] | undefined>> ? Kind extends keyof Map ? Map[Kind] : undefined : undefined : undefined;
+type SubgraphNodeResultForKind<G extends GraphDef, Kind extends NodeKinds<G>, P> = ProjectionSelection<P, "nodes", Kind> extends readonly string[] ? ProjectedNodeResult<G["nodes"][Kind]["type"], ProjectionSelection<P, "nodes", Kind>> : Node<G["nodes"][Kind]["type"]>;
+type SubgraphEdgeResultForKind<G extends GraphDef, Kind extends EdgeKinds<G>, P> = ProjectionSelection<P, "edges", Kind> extends readonly string[] ? ProjectedEdgeResult<G["edges"][Kind]["type"], ProjectionSelection<P, "edges", Kind>> : Edge<G["edges"][Kind]["type"]>;
+type SubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
+    /** Edge kinds to follow during traversal. Edges not listed are not traversed. */
+    edges: readonly EK[];
+    /** Maximum traversal depth from root (default: 10). */
+    maxDepth?: number;
+    /**
+     * Node kinds to include in the result. Nodes of other kinds are still
+     * traversed through but omitted from the output. When omitted, all
+     * reachable node kinds are included.
+     */
+    includeKinds?: readonly NK[];
+    /** Exclude the root node from the result (default: false). */
+    excludeRoot?: boolean;
+    /**
+     * Edge direction policy (default: "out").
+     * - "out": follow edges in their defined direction only
+     * - "both": follow edges in both directions (undirected traversal)
+     */
+    direction?: "out" | "both";
+    /** Cycle policy — reuse RecursiveCyclePolicy (default: "prevent"). */
+    cyclePolicy?: RecursiveCyclePolicy;
+    /**
+     * Temporal mode applied to both nodes and edges along the traversal and in
+     * the hydrated result. Defaults to `graph.defaults.temporalMode`.
+     */
+    temporalMode?: TemporalMode;
+    /** ISO-8601 timestamp used when `temporalMode === "asOf"`. */
+    asOf?: string;
+    /** @internal Recorded coordinates are supplied by StoreView only. */
+    recordedAsOf?: never;
+    /**
+     * Optional field-level projection per node/edge kind.
+     *
+     * Projected nodes keep `kind` and `id`; projected edges keep their structural
+     * endpoint fields. Kinds omitted from `project` remain fully hydrated.
+     * Projection applies to every returned entity, including the root node.
+     *
+     * Only kinds present in `includeKinds` (nodes) or `edges` (edges) are valid
+     * projection keys. Specifying a kind outside those sets is a compile-time error.
+     */
+    project?: P;
+    /**
+     * Per-edge-kind windows applied while traversing and hydrating. Each limit
+     * is partitioned by the current endpoint, so append-only edge histories can
+     * contribute only their newest N targets at every hop.
+     */
+    edgeWindows?: Readonly<Partial<Record<EK, EdgeReadWindow>>>;
+}>;
+/**
+ * Subgraph options as seen by the internal executor: identical to the public
+ * {@link SubgraphOptions} except the recorded/system-time pin is a branded
+ * instant the StoreView seam supplies. The public surface keeps
+ * `recordedAsOf?: never`;
+ * recorded reads reach the executor only through `store.subgraphAtCoordinate`.
+ */
+type InternalSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Omit<SubgraphOptions<G, EK, NK, P>, "recordedAsOf"> & Readonly<{
+    recordedAsOf?: RecordedInstant;
+}>;
+/**
+ * Union of all node result types in a subgraph, respecting projection.
+ */
+type SubgraphNodeResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, P = undefined> = {
+    [Kind in NK]: SubgraphNodeResultForKind<G, Kind, P>;
+}[NK];
+/**
+ * Union of all edge result types in a subgraph, respecting projection.
+ */
+type SubgraphEdgeResult<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>, P = undefined> = {
+    [Kind in EK]: SubgraphEdgeResultForKind<G, Kind, P>;
+}[EK];
+type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
+    /** The root node, or undefined if the root was not found or excluded. */
+    root: SubgraphNodeResult<G, NK, P> | undefined;
+    nodes: ReadonlyMap<string, SubgraphNodeResult<G, NK, P>>;
+    /** Forward adjacency: fromId → edgeKind → edges to targets. */
+    adjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
+    /** Reverse adjacency: toId → edgeKind → edges from sources. */
+    reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
+}>;
+
 /**
  * Store types for TypeGraph operations.
  */
@@ -3506,11 +3762,21 @@ type TransactionCollections<G extends GraphDef> = Readonly<{
     identity: IdentityFacade<G>;
 }> : Readonly<Record<never, never>>);
 /**
- * A portable transaction context containing only TypeGraph-owned graph
- * operations. Managed Stores use this surface so adapter-native handles never
- * enter their public contract.
+ * A portable transaction context containing TypeGraph-owned collections and
+ * transaction-bound graph reads. Managed Stores use this surface so
+ * adapter-native handles never enter their public contract.
  */
-type TransactionContext<G extends GraphDef> = TransactionCollections<G>;
+type TransactionContext<G extends GraphDef> = TransactionCollections<G> & Readonly<{
+    query: () => InitialQueryBuilder<G, "open">;
+    batchOnce: <const Queries extends readonly [
+        EmbeddableOneStatementRead<unknown>,
+        EmbeddableOneStatementRead<unknown>,
+        ...EmbeddableOneStatementRead<unknown>[]
+    ]>(build: (read: BatchReadBuilder<G>) => Queries) => Promise<OneStatementBatchResults<Queries>>;
+    neighbors: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: NeighborReadOptions<G, K>) => Promise<readonly NeighborResult<G, K>[]>;
+    countNeighbors: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: Omit<NeighborReadOptions<G, K>, "limit" | "orderBy">) => Promise<number>;
+    subgraph: <const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: SubgraphOptions<G, EK, NK, P>) => Promise<SubgraphResult<G, NK, EK, P>>;
+}>;
 /**
  * A transaction context exposed by an {@link AdapterStore}. In addition to the
  * portable graph collections, it carries the adapter-native handle when that
@@ -3518,7 +3784,7 @@ type TransactionContext<G extends GraphDef> = TransactionCollections<G>;
  * read projection as the portable context; adapter-native writes intentionally
  * go through `sql`, making that escape hatch explicit.
  */
-type AdapterTransactionContext<G extends GraphDef, TNativeTransaction> = TransactionCollections<G> & AdapterTransactionSqlAccess<TNativeTransaction>;
+type AdapterTransactionContext<G extends GraphDef, TNativeTransaction> = TransactionContext<G> & AdapterTransactionSqlAccess<TNativeTransaction>;
 /**
  * Scoped write measurement, available only on the receipt-enabled transaction
  * contexts (`transactionWithReceipt`, `withRecordedTransaction`). Runs `fn`,
@@ -4817,168 +5083,6 @@ type MaterializeRemovalsResult = Readonly<{
     reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
 }>;
 
-/**
- * Discriminated union of all Node runtime types in a graph.
- *
- * Unlike `AllNodeTypes<G>` which gives the union of *type definitions*,
- * `AnyNode<G>` gives the union of *runtime node instances*.
- */
-type AnyNode<G extends GraphDef> = {
-    [K in NodeKinds<G>]: Node<G["nodes"][K]["type"]>;
-}[NodeKinds<G>];
-/**
- * Discriminated union of all Edge runtime types in a graph.
- */
-type AnyEdge<G extends GraphDef> = {
-    [K in EdgeKinds<G>]: Edge<G["edges"][K]["type"]>;
-}[EdgeKinds<G>];
-/**
- * Discriminated union of Node runtime types narrowed to a subset of kinds.
- */
-type SubsetNode<G extends GraphDef, K extends NodeKinds<G>> = {
-    [Kind in K]: Node<G["nodes"][Kind]["type"]>;
-}[K];
-/**
- * Discriminated union of Edge runtime types narrowed to a subset of kinds.
- */
-type SubsetEdge<G extends GraphDef, K extends EdgeKinds<G>> = {
-    [Kind in K]: Edge<G["edges"][Kind]["type"]>;
-}[K];
-type EmptyShape = Readonly<Record<never, never>>;
-type NodeProjectionPropertyKey<N extends NodeType> = Exclude<keyof Node<N>, "id" | "kind" | "meta"> & string;
-type EdgeProjectionPropertyKey<E extends AnyEdgeType> = Exclude<keyof Edge<E>, "id" | "kind" | "fromKind" | "fromId" | "toKind" | "toId" | "meta"> & string;
-type SubgraphNodeProjectionField<N extends NodeType = NodeType> = NodeProjectionPropertyKey<N> | "meta";
-type SubgraphEdgeProjectionField<E extends AnyEdgeType = AnyEdgeType> = EdgeProjectionPropertyKey<E> | "meta";
-type SubgraphNodeProjectionMap<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>> = Readonly<{
-    [K in NodeKinds<G>]?: K extends NK ? readonly SubgraphNodeProjectionField<G["nodes"][K]["type"]>[] : never;
-}>;
-type SubgraphEdgeProjectionMap<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>> = Readonly<{
-    [K in EdgeKinds<G>]?: K extends EK ? readonly SubgraphEdgeProjectionField<G["edges"][K]["type"]>[] : never;
-}>;
-type SubgraphProject<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>> = Readonly<{
-    /**
-     * Node fields to keep per kind.
-     *
-     * Projected nodes always retain `kind` and `id`.
-     * Use `"meta"` to include the full metadata object; omit it to exclude metadata entirely.
-     * Only kinds present in `includeKinds` (or all node kinds when omitted) are valid keys.
-     */
-    nodes?: SubgraphNodeProjectionMap<G, NK>;
-    /**
-     * Edge fields to keep per kind.
-     *
-     * Projected edges always retain `id`, `kind`, `fromKind`, `fromId`,
-     * `toKind`, and `toId`.
-     * Use `"meta"` to include the full metadata object; omit it to exclude metadata entirely.
-     * Only edge kinds listed in `edges` are valid keys.
-     */
-    edges?: SubgraphEdgeProjectionMap<G, EK>;
-}>;
-/**
- * Identity function that preserves literal types for reusable projection configs.
- *
- * Without this helper, storing a projection in a typed variable widens the
- * field arrays to `string[]`, defeating compile-time narrowing on results.
- *
- * @example
- * ```ts
- * const project = defineSubgraphProject(graph)({
- *   nodes: { Task: ["title", "meta"] },
- *   edges: { uses_skill: [] },
- * });
- * const result = await store.subgraph(rootId, { edges: ["uses_skill"], project });
- * // result.nodes narrowed correctly — task.status is a type error
- * ```
- */
-declare function defineSubgraphProject<G extends GraphDef>(_graph: G): <const P extends SubgraphProject<G>>(project: P) => P;
-type HasMeta<Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? "meta" extends Selection[number] ? true : false : false;
-type SelectedNodeProps<N extends NodeType, Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? Pick<Node<N>, Extract<Selection[number], NodeProjectionPropertyKey<N>>> : EmptyShape;
-type SelectedEdgeProps<E extends AnyEdgeType, Selection extends readonly string[] | undefined> = Selection extends readonly string[] ? Pick<Edge<E>, Extract<Selection[number], EdgeProjectionPropertyKey<E>>> : EmptyShape;
-type ProjectedNodeResult<N extends NodeType, Selection extends readonly string[] | undefined> = Readonly<Pick<Node<N>, "id" | "kind">> & Readonly<SelectedNodeProps<N, Selection>> & (HasMeta<Selection> extends true ? Readonly<{
-    meta: NodeMeta;
-}> : EmptyShape);
-type ProjectedEdgeResult<E extends AnyEdgeType, Selection extends readonly string[] | undefined> = Readonly<Pick<Edge<E>, "id" | "kind" | "fromKind" | "fromId" | "toKind" | "toId">> & Readonly<SelectedEdgeProps<E, Selection>> & (HasMeta<Selection> extends true ? Readonly<{
-    meta: EdgeMeta;
-}> : EmptyShape);
-type ProjectionSelection<P, Key extends "nodes" | "edges", Kind extends string> = P extends Readonly<{
-    [K in Key]?: infer Map;
-}> ? Map extends Readonly<Record<string, readonly string[] | undefined>> ? Kind extends keyof Map ? Map[Kind] : undefined : undefined : undefined;
-type SubgraphNodeResultForKind<G extends GraphDef, Kind extends NodeKinds<G>, P> = ProjectionSelection<P, "nodes", Kind> extends readonly string[] ? ProjectedNodeResult<G["nodes"][Kind]["type"], ProjectionSelection<P, "nodes", Kind>> : Node<G["nodes"][Kind]["type"]>;
-type SubgraphEdgeResultForKind<G extends GraphDef, Kind extends EdgeKinds<G>, P> = ProjectionSelection<P, "edges", Kind> extends readonly string[] ? ProjectedEdgeResult<G["edges"][Kind]["type"], ProjectionSelection<P, "edges", Kind>> : Edge<G["edges"][Kind]["type"]>;
-type SubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
-    /** Edge kinds to follow during traversal. Edges not listed are not traversed. */
-    edges: readonly EK[];
-    /** Maximum traversal depth from root (default: 10). */
-    maxDepth?: number;
-    /**
-     * Node kinds to include in the result. Nodes of other kinds are still
-     * traversed through but omitted from the output. When omitted, all
-     * reachable node kinds are included.
-     */
-    includeKinds?: readonly NK[];
-    /** Exclude the root node from the result (default: false). */
-    excludeRoot?: boolean;
-    /**
-     * Edge direction policy (default: "out").
-     * - "out": follow edges in their defined direction only
-     * - "both": follow edges in both directions (undirected traversal)
-     */
-    direction?: "out" | "both";
-    /** Cycle policy — reuse RecursiveCyclePolicy (default: "prevent"). */
-    cyclePolicy?: RecursiveCyclePolicy;
-    /**
-     * Temporal mode applied to both nodes and edges along the traversal and in
-     * the hydrated result. Defaults to `graph.defaults.temporalMode`.
-     */
-    temporalMode?: TemporalMode;
-    /** ISO-8601 timestamp used when `temporalMode === "asOf"`. */
-    asOf?: string;
-    /** @internal Recorded coordinates are supplied by StoreView only. */
-    recordedAsOf?: never;
-    /**
-     * Optional field-level projection per node/edge kind.
-     *
-     * Projected nodes keep `kind` and `id`; projected edges keep their structural
-     * endpoint fields. Kinds omitted from `project` remain fully hydrated.
-     * Projection applies to every returned entity, including the root node.
-     *
-     * Only kinds present in `includeKinds` (nodes) or `edges` (edges) are valid
-     * projection keys. Specifying a kind outside those sets is a compile-time error.
-     */
-    project?: P;
-}>;
-/**
- * Subgraph options as seen by the internal executor: identical to the public
- * {@link SubgraphOptions} except the recorded/system-time pin is a branded
- * instant the StoreView seam supplies. The public surface keeps
- * `recordedAsOf?: never`;
- * recorded reads reach the executor only through `store.subgraphAtCoordinate`.
- */
-type InternalSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Omit<SubgraphOptions<G, EK, NK, P>, "recordedAsOf"> & Readonly<{
-    recordedAsOf?: RecordedInstant;
-}>;
-/**
- * Union of all node result types in a subgraph, respecting projection.
- */
-type SubgraphNodeResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, P = undefined> = {
-    [Kind in NK]: SubgraphNodeResultForKind<G, Kind, P>;
-}[NK];
-/**
- * Union of all edge result types in a subgraph, respecting projection.
- */
-type SubgraphEdgeResult<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>, P = undefined> = {
-    [Kind in EK]: SubgraphEdgeResultForKind<G, Kind, P>;
-}[EK];
-type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
-    /** The root node, or undefined if the root was not found or excluded. */
-    root: SubgraphNodeResult<G, NK, P> | undefined;
-    nodes: ReadonlyMap<string, SubgraphNodeResult<G, NK, P>>;
-    /** Forward adjacency: fromId → edgeKind → edges to targets. */
-    adjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
-    /** Reverse adjacency: toId → edgeKind → edges from sources. */
-    reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
-}>;
-
 declare const STORE_RUNTIME: unique symbol;
 /**
  * @internal Operations used by Store-owned views. The port is absent from the
@@ -5961,6 +6065,11 @@ interface RequiredEdgeCollectionLookup<G extends GraphDef = GraphDef> {
     <K extends EdgeKinds<G>>(kind: K): DynamicEdgeCollection<G["edges"][K]["type"]>;
     (kind: string): DynamicEdgeCollection;
 }
+type CheckedReadScopeBoundary<G extends GraphDef> = Readonly<{
+    query?: () => InitialQueryBuilder<G, "open">;
+}>;
+/** Read scope whose fluent-query executions all verify one schema version. */
+type CheckedReadScope<G extends GraphDef> = CheckedReadScopeBoundary<G> & Required<Pick<CheckedReadScopeBoundary<G>, "query">>;
 type StoreCore<G extends GraphDef> = Readonly<{
     [STORE_RUNTIME]: StoreRuntime<G>;
     graph: G;
@@ -5995,6 +6104,7 @@ type StoreCore<G extends GraphDef> = Readonly<{
     schemaChanges: () => Promise<SchemaDiff | undefined>;
     requiresMigration: () => Promise<boolean>;
     query: () => InitialQueryBuilder<G, "open">;
+    withCheckedReads?: <T>(expectedSchemaVersion: number | undefined, fn: (reads: CheckedReadScope<G>) => Promise<T>) => Promise<T>;
     asOf: (asOf: string) => StoreView<G>;
     asOfRecorded: (recordedAsOf: RecordedInstant) => RecordedStoreView<G>;
     recordedNow: () => Promise<RecordedInstant | undefined>;
@@ -6007,6 +6117,13 @@ type StoreCore<G extends GraphDef> = Readonly<{
         BatchableQuery<unknown>,
         ...BatchableQuery<unknown>[]
     ]>(...queries: Queries) => Promise<BatchResults<Queries>>;
+    batchOnce?: <const Queries extends readonly [
+        EmbeddableOneStatementRead<unknown>,
+        EmbeddableOneStatementRead<unknown>,
+        ...EmbeddableOneStatementRead<unknown>[]
+    ]>(build: (read: BatchReadBuilder<G>) => Queries) => Promise<OneStatementBatchResults<Queries>>;
+    neighbors?: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: NeighborReadOptions<G, K>) => Promise<readonly NeighborResult<G, K>[]>;
+    countNeighbors?: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: Omit<NeighborReadOptions<G, K>, "limit" | "orderBy">) => Promise<number>;
     bulkFindEdgesFrom: <const K extends EdgeKinds<G>>(params: BulkFindEdgesFromParams<G, K>, options?: EdgeBulkFindEndpointOptions) => Promise<readonly BulkFindEdgesFromResult<G, K>[]>;
     bulkFindEdgesTo: <const K extends EdgeKinds<G>>(params: BulkFindEdgesToParams<G, K>, options?: EdgeBulkFindEndpointOptions) => Promise<readonly BulkFindEdgesToResult<G, K>[]>;
     bulkFindRuntimeEdgesFrom: <NT extends RuntimeNodeKind, ET extends RuntimeEdgeKind>(params: BulkFindRuntimeEdgesFromParams<NT, ET>, options?: EdgeBulkFindEndpointOptions) => Promise<readonly BulkFindRuntimeEdgesFromResult<NT, ET>[]>;
@@ -6057,6 +6174,25 @@ type StoreTransactions<G extends GraphDef> = Readonly<{
     transaction: <T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: StoreTransactionOptions) => Promise<T>;
     transactionWithReceipt: <T>(fn: (tx: MeasurableTransactionContext<G>) => Promise<T>, options?: StoreTransactionOptions) => Promise<TransactionOutcome<T>>;
 }>;
+/** Builds cold reads that {@link Store.batchOnce} can compose in one statement. */
+type BatchReadBuilder<G extends GraphDef> = Readonly<{
+    neighbors: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: NeighborReadOptions<G, K>) => CompiledOneStatementRead<readonly NeighborResult<G, K>[]>;
+    countNeighbors: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: Omit<NeighborReadOptions<G, K>, "limit" | "orderBy">) => CompiledOneStatementRead<number>;
+    subgraph: <const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: SubgraphOptions<G, EK, NK, P>) => CompiledOneStatementRead<SubgraphResult<G, NK, EK, P>>;
+}>;
+type AddedStoreReadsBoundary<G extends GraphDef> = Readonly<{
+    withCheckedReads?: <T>(expectedSchemaVersion: number | undefined, fn: (reads: CheckedReadScope<G>) => Promise<T>) => Promise<T>;
+    batchOnce?: <const Queries extends readonly [
+        EmbeddableOneStatementRead<unknown>,
+        EmbeddableOneStatementRead<unknown>,
+        ...EmbeddableOneStatementRead<unknown>[]
+    ]>(build: (read: BatchReadBuilder<G>) => Queries) => Promise<OneStatementBatchResults<Queries>>;
+    neighbors?: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: NeighborReadOptions<G, K>) => Promise<readonly NeighborResult<G, K>[]>;
+    countNeighbors?: <const K extends EdgeKinds<G>>(source: GraphNodeReference<G>, options: Omit<NeighborReadOptions<G, K>, "limit" | "orderBy">) => Promise<number>;
+}>;
+type AddedStoreReadKey = keyof AddedStoreReadsBoundary<GraphDef>;
+type AddedStoreReads<G extends GraphDef> = AddedStoreReadsBoundary<G> & Required<Pick<AddedStoreReadsBoundary<G>, AddedStoreReadKey>>;
+type ResolvedStoreCore<G extends GraphDef> = StoreCore<G> & AddedStoreReads<G>;
 interface StoreEvolution<G extends GraphDef, TStore extends StoreCore<G>> {
     readonly evolve: <TRefStore extends StoreCore<G> = TStore>(extension: GraphExtension, options?: Readonly<{
         ref?: TStore extends TRefStore ? StoreRef<TRefStore> : never;
@@ -6078,7 +6214,7 @@ interface StoreEvolution<G extends GraphDef, TStore extends StoreCore<G>> {
  * graph-owned transactions while keeping adapter-native handles, backend
  * internals, and caller-owned transaction adoption out of the public surface.
  */
-type Store<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, Store<G>>;
+type Store<G extends GraphDef> = ResolvedStoreCore<G> & StoreTransactions<G> & StoreEvolution<G, Store<G>>;
 /**
  * An opaque, in-memory snapshot of a store's reconciled schema: the merged
  * compile-time + runtime-committed graph plus the committed schema version and
@@ -6135,7 +6271,7 @@ interface AdapterStoreReconciliation<G extends GraphDef, TNativeTransaction, Sel
  * this surface so native transaction handles remain precisely typed without
  * leaking into the default Store contract.
  */
-type AdapterStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterStore<G, TNativeTransaction>> & Readonly<{
+type AdapterStore<G extends GraphDef, TNativeTransaction> = ResolvedStoreCore<G> & StoreEvolution<G, AdapterStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterStore<G, TNativeTransaction>> & Readonly<{
     backend: GraphBackend;
 }>;
 type AdapterStoreTransactions<G extends GraphDef, TNativeTransaction> = Readonly<{
@@ -6158,18 +6294,18 @@ type AdapterHistoryTransactionContext<G extends GraphDef, TNativeTransaction> =
 type MeasurableAdapterHistoryTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterHistoryTransactionContext<G, TNativeTransaction> & Readonly<{
     measure: ScopedMeasure<MeasurableAdapterHistoryTransactionContext<G, TNativeTransaction>>;
 }>;
-type AdapterRecordedReadStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterRecordedReadStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterRecordedReadStore<G, TNativeTransaction>> & Readonly<{
+type AdapterRecordedReadStore<G extends GraphDef, TNativeTransaction> = ResolvedStoreCore<G> & StoreEvolution<G, AdapterRecordedReadStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterRecordedReadStore<G, TNativeTransaction>> & Readonly<{
     backend: GraphBackend;
     recordedReadBound: true;
 }>;
-type RecordedReadStore<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, RecordedReadStore<G>> & Readonly<{
+type RecordedReadStore<G extends GraphDef> = ResolvedStoreCore<G> & StoreTransactions<G> & StoreEvolution<G, RecordedReadStore<G>> & Readonly<{
     recordedReadBound: true;
 }>;
-type HistoryStore<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, HistoryStore<G>> & Readonly<{
+type HistoryStore<G extends GraphDef> = ResolvedStoreCore<G> & StoreTransactions<G> & StoreEvolution<G, HistoryStore<G>> & Readonly<{
     historyEnabled: true;
     recordedReadBound: true;
 }>;
-type AdapterHistoryStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterHistoryStore<G, TNativeTransaction>> & AdapterHistoryStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterHistoryStore<G, TNativeTransaction>> & Readonly<{
+type AdapterHistoryStore<G extends GraphDef, TNativeTransaction> = ResolvedStoreCore<G> & StoreEvolution<G, AdapterHistoryStore<G, TNativeTransaction>> & AdapterHistoryStoreTransactions<G, TNativeTransaction> & AdapterStoreReconciliation<G, TNativeTransaction, AdapterHistoryStore<G, TNativeTransaction>> & Readonly<{
     backend: HistoryStoreBackend;
     historyEnabled: true;
     recordedReadBound: true;
@@ -6348,4 +6484,4 @@ declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransacti
     SchemaValidationResult
 ]>;
 
-export { type AnyNode as $, migrateSchema as A, parseSerializedSchema as B, requiresMigration as C, rollbackSchema as D, type AliasMap as E, type EdgeAliasMap as F, type RecursiveAliasMap as G, type HistoryStoreOptions as H, type IdentityAssertion as I, QueryBuilder as J, KindRegistry as K, type LiveStoreOptions as L, type MigrateSchemaOptions as M, type EmptyRecursiveAliasMap as N, type AdapterHistoryStore as O, type AdapterHistoryTransactionContext as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type AdapterRecordedReadStore as V, type AdapterStore as W, type AdapterTransactionContext as X, type AggregateResult as Y, type AlgorithmCyclePolicy as Z, type AnyEdge as _, type SchemaManagerOptions as a, type HybridSearchHit as a$, type BaseStoreOptions as a0, type BaseTraversalOptions as a1, type BatchResults as a2, type BatchableQuery as a3, type BulkEdgeSourceGroup as a4, type BulkFindEdgesFromParams as a5, type BulkFindEdgesFromResult as a6, type BulkFindEdgesToParams as a7, type BulkFindEdgesToResult as a8, type BulkFindRuntimeEdgesFromParams as a9, type EdgeBatchReads as aA, type EdgeBulkFindEndpointOptions as aB, type EdgeBulkFindOptions as aC, type EdgeCollection as aD, type EdgeCollectionLookup as aE, type EdgeFindByEndpointsOptions as aF, type EdgeGetOrCreateByEndpointsOptions as aG, type EdgeGetOrCreateByEndpointsResult as aH, type EdgeIntrospection as aI, type EdgeTemporalReads as aJ, type EdgeWrites as aK, type EmptyAliasMap as aL, type EmptyEdgeAliasMap as aM, ExecutableAggregateQuery as aN, ExecutableQuery as aO, type FieldAccessor as aP, type FulltextSearchHit as aQ, type FulltextSearchOptions as aR, type GetOrCreateAction as aS, type GraphAlgorithms as aT, type GraphEdgeCollections as aU, type GraphEdgeForKinds as aV, type GraphNodeCollections as aW, type GraphNodeReference as aX, type HistoryStoreBackend as aY, type HookContext as aZ, type HybridFulltextOptions as a_, type BulkFindRuntimeEdgesFromResult as aa, type BulkOperationHookContext as ab, type ClaimOwner as ac, type ClaimTarget as ad, type CompareAndSetAbsent as ae, type CompareAndSetExpected as af, type ConstraintFenceViolation as ag, type ConstraintNames as ah, type CreateEdgeInput as ai, type CreateNodeInput as aj, type DegreeOptions as ak, type DynamicEdgeAccessor as al, type DynamicEdgeCollection as am, type DynamicEdgeType as an, type DynamicFieldBuilder as ao, type DynamicNode as ap, type DynamicNodeAccessor as aq, type DynamicNodeCollection as ar, type DynamicNodeKind as as, type DynamicNodeReference as at, type DynamicNodeType as au, type DynamicSelectableEdge as av, type DynamicSelectableNode as aw, type DynamicStoreViewEdgeCollection as ax, type Edge as ay, type EdgeAccessor as az, type Store as b, type ReembedVectorFieldOptions as b$, type HybridSearchOptions as b0, type HybridVectorOptions as b1, type IdentityAssertionWriteFacade as b2, type IdentityNodeReference as b3, type IdentityTraversalOption as b4, type IdentityValidityWindow as b5, type IfExistsMode as b6, type InitialQueryBuilder as b7, type KindIntrospection as b8, type KindPopulationStatistics as b9, type PageRankScore as bA, type PaginateOptions as bB, type PaginatedResult as bC, type PathNode as bD, type PersonalizedPageRankOptions as bE, type PersonalizedPageRankSeed as bF, type Predicate as bG, PreparedQuery as bH, type PropertyPopulationStatistics as bI, type PropsAccessor as bJ, type QueryHookContext as bK, type QueryOptions as bL, type ReachableNode as bM, type ReachableOptions as bN, type RebuildContributionOptions as bO, type RebuildFulltextOptions as bP, type RebuildFulltextResult as bQ, type ReclaimedVectorFieldEntry as bR, type RecordedScanOptions as bS, type RecordedScanPage as bT, RecordedStoreView as bU, type RecordedStoreViewEdgeCollection as bV, type RecordedStoreViewEdgeCollections as bW, type RecordedStoreViewNodeCollection as bX, type RecordedStoreViewNodeCollections as bY, type RecursiveTraversalOptions as bZ, type ReembedFunction as b_, type LabelPropagationMembership as ba, type LabelPropagationOptions as bb, type MaterializeRemovalsEntry as bc, type MaterializeRemovalsOptions as bd, type MaterializeRemovalsResult as be, type MeasurableAdapterHistoryTransactionContext as bf, type MeasurableAdapterTransactionContext as bg, type MeasurableTransactionContext as bh, type NeighborsOptions as bi, type NoRecordedCoordinate as bj, type Node as bk, type NodeAccessor as bl, type NodeAlias as bm, type NodeBulkFindByIndexOptions as bn, type NodeCollection as bo, type NodeCollectionLookup as bp, type NodeCurrentReads as bq, type NodeGetOrCreateByConstraintOptions as br, type NodeGetOrCreateByConstraintResult as bs, type NodeIdentifier as bt, type NodeRef as bu, type NodeTemporalReads as bv, type NodeWrites as bw, type OntologyIntrospection as bx, type OperationHookContext as by, type PageRankOptions as bz, type HistoryStore as c, type TypedEdgeCollection as c$, type ReembedVectorFieldResult as c0, type RequiredEdgeCollectionLookup as c1, type RequiredNodeCollectionLookup as c2, type RuntimeBulkEdgeSourceGroup as c3, type RuntimeEdgeCollection as c4, type RuntimeEdgeFor as c5, type RuntimeEdgeKind as c6, type RuntimeEdgeTypeFor as c7, type RuntimeNodeCollection as c8, type RuntimeNodeKind as c9, type StoreViewDegreeOptions as cA, type StoreViewEdgeCollection as cB, type StoreViewEdgeCollections as cC, type StoreViewGraphAlgorithms as cD, type StoreViewLabelPropagationOptions as cE, type StoreViewNeighborsOptions as cF, type StoreViewNodeCollection as cG, type StoreViewNodeCollections as cH, type StoreViewPageRankOptions as cI, type StoreViewPersonalizedPageRankOptions as cJ, type StoreViewReachableOptions as cK, type StoreViewShortestPathOptions as cL, type StoreViewSubgraphOptions as cM, type StoreViewWeaklyConnectedComponentsOptions as cN, type StoreViewWeightedShortestPathOptions as cO, type StreamOptions as cP, type SubgraphEdgeResult as cQ, type SubgraphNodeResult as cR, type SubgraphOptions as cS, type SubgraphResult as cT, type SubsetEdge as cU, type SubsetNode as cV, type TemporalAlgorithmOptions as cW, type TransactionContext as cX, type TransactionOutcome as cY, type TransactionReceipt as cZ, type TraversalDirection as c_, type RuntimeNodeReferenceFor as ca, type RuntimeNodeTypeFor as cb, type SchemaIntrospection as cc, type ScopedMeasure as cd, type SearchScopeOptions as ce, type SelectContext as cf, type SelectableEdge as cg, type SelectableNode as ch, type ShortestPathOptions as ci, type ShortestPathResult as cj, type SqlAvailability as ck, StoreAnalysisCursorStaleError as cl, type StoreAnalysisCursorStaleErrorDetails as cm, type StoreAnalysisSchemaCoordinate as cn, type StoreDescription as co, type StoreHooks as cp, type StorePopulationStatistics as cq, type StoreProjection as cr, type StoreRef as cs, StoreSearch as ct, type StoreTransactionOptions as cu, type StoreValidationFailure as cv, type StoreValidationPage as cw, StoreView as cx, type StoreViewCanReachOptions as cy, type StoreViewCoordinate as cz, type RecordedReadStore as d, type TypedRecordedStoreViewEdgeCollection as d0, type TypedStoreViewEdgeCollection as d1, UnionableQuery as d2, type UniqueIntrospection as d3, type UpdateEdgeInput as d4, type UpdateNodeInput as d5, type ValidateStoreOptions as d6, type ValidityEndMutation as d7, type VectorSearchHit as d8, type VectorSearchOptions as d9, type WeaklyConnectedComponentMembership as da, type WeaklyConnectedComponentsOptions as db, type WeightedShortestPathOptions as dc, type WeightedShortestPathResult as dd, type WorkingCopyOptions as de, asIdentityAssertionId as df, compareAndSetAbsent as dg, createAdapterStore as dh, createAdapterStoreWithSchema as di, createQueryBuilder as dj, createStore as dk, createStoreWithSchema as dl, createVerifiedAdapterStore as dm, createVerifiedStore as dn, defineSubgraphProject as dp, exists as dq, fieldRef as dr, inSubquery as ds, isParameterRef as dt, notExists as du, notInSubquery as dv, param as dw, EDGE_TEMPORAL_READ_NAMES as dx, IDENTITY_READ_NAMES as dy, type IdentityAssertionId as e, type IdentityAssertionResult as f, type IdentityFacade as g, type IdentityNode as h, type IdentityNodeRefInput as i, type IdentityPair as j, type IdentityReadFacade as k, type IdentityRelation as l, type IdentityWriteSummary as m, type ReconciledSchema as n, type MigrationHookContext as o, type SchemaValidationResult as p, applyDeprecatedKinds as q, assertSchemaCurrent as r, ensureSchema as s, getActiveSchema as t, getCommittedSchemaVersion as u, getSchemaChanges as v, initializeSchema as w, isSchemaInitialized as x, loadActiveSchemaWithBootstrap as y, loadAndMergeGraphExtensionDocument as z };
+export { type AlgorithmCyclePolicy as $, migrateSchema as A, type BatchReadBuilder as B, type CompiledOneStatementRead as C, parseSerializedSchema as D, requiresMigration as E, rollbackSchema as F, type AliasMap as G, type HistoryStoreOptions as H, type IdentityAssertion as I, type EdgeAliasMap as J, KindRegistry as K, type LiveStoreOptions as L, type MigrateSchemaOptions as M, type RecursiveAliasMap as N, QueryBuilder as O, type EmptyRecursiveAliasMap as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type AdapterHistoryStore as V, type AdapterHistoryTransactionContext as W, type AdapterRecordedReadStore as X, type AdapterStore as Y, type AdapterTransactionContext as Z, type AggregateResult as _, type SchemaManagerOptions as a, type GraphEdgeForKinds as a$, type AnyEdge as a0, type AnyNode as a1, type BaseStoreOptions as a2, type BaseTraversalOptions as a3, type BatchResults as a4, type BatchableQuery as a5, type BulkEdgeSourceGroup as a6, type BulkFindEdgesFromParams as a7, type BulkFindEdgesFromResult as a8, type BulkFindEdgesToParams as a9, type DynamicStoreViewEdgeCollection as aA, type Edge as aB, type EdgeAccessor as aC, type EdgeBatchReads as aD, type EdgeBulkFindEndpointOptions as aE, type EdgeBulkFindOptions as aF, type EdgeCollection as aG, type EdgeCollectionLookup as aH, type EdgeFindByEndpointsOptions as aI, type EdgeGetOrCreateByEndpointsOptions as aJ, type EdgeGetOrCreateByEndpointsResult as aK, type EdgeIntrospection as aL, type EdgeReadWindow as aM, type EdgeTemporalReads as aN, type EdgeWrites as aO, type EmbeddableOneStatementRead as aP, type EmptyAliasMap as aQ, type EmptyEdgeAliasMap as aR, ExecutableAggregateQuery as aS, type ExecutableOneStatementRead as aT, ExecutableQuery as aU, type FieldAccessor as aV, type FulltextSearchHit as aW, type FulltextSearchOptions as aX, type GetOrCreateAction as aY, type GraphAlgorithms as aZ, type GraphEdgeCollections as a_, type BulkFindEdgesToResult as aa, type BulkFindRuntimeEdgesFromParams as ab, type BulkFindRuntimeEdgesFromResult as ac, type BulkOperationHookContext as ad, type CheckedReadScope as ae, type ClaimOwner as af, type ClaimTarget as ag, type CompareAndSetAbsent as ah, type CompareAndSetExpected as ai, type ConstraintFenceViolation as aj, type ConstraintNames as ak, type CreateEdgeInput as al, type CreateNodeInput as am, type DegreeOptions as an, type DynamicEdgeAccessor as ao, type DynamicEdgeCollection as ap, type DynamicEdgeType as aq, type DynamicFieldBuilder as ar, type DynamicNode as as, type DynamicNodeAccessor as at, type DynamicNodeCollection as au, type DynamicNodeKind as av, type DynamicNodeReference as aw, type DynamicNodeType as ax, type DynamicSelectableEdge as ay, type DynamicSelectableNode as az, type Store as b, type RebuildContributionOptions as b$, type GraphNodeCollections as b0, type GraphNodeReference as b1, type HistoryStoreBackend as b2, type HookContext as b3, type HybridFulltextOptions as b4, type HybridSearchHit as b5, type HybridSearchOptions as b6, type HybridVectorOptions as b7, type IdentityAssertionWriteFacade as b8, type IdentityNodeReference as b9, type NodeCollectionLookup as bA, type NodeCurrentReads as bB, type NodeGetOrCreateByConstraintOptions as bC, type NodeGetOrCreateByConstraintResult as bD, type NodeIdentifier as bE, type NodeRef as bF, type NodeTemporalReads as bG, type NodeWrites as bH, type OneStatementBatchResults as bI, type OneStatementBatchableQuery as bJ, type OntologyIntrospection as bK, type OperationHookContext as bL, type PageRankOptions as bM, type PageRankScore as bN, type PaginateOptions as bO, type PaginatedResult as bP, type PathNode as bQ, type PersonalizedPageRankOptions as bR, type PersonalizedPageRankSeed as bS, type Predicate as bT, PreparedQuery as bU, type PropertyPopulationStatistics as bV, type PropsAccessor as bW, type QueryHookContext as bX, type QueryOptions as bY, type ReachableNode as bZ, type ReachableOptions as b_, type IdentityTraversalOption as ba, type IdentityValidityWindow as bb, type IfExistsMode as bc, type InitialQueryBuilder as bd, type KindIntrospection as be, type KindPopulationStatistics as bf, type LabelPropagationMembership as bg, type LabelPropagationOptions as bh, type MaterializeRemovalsEntry as bi, type MaterializeRemovalsOptions as bj, type MaterializeRemovalsResult as bk, type MeasurableAdapterHistoryTransactionContext as bl, type MeasurableAdapterTransactionContext as bm, type MeasurableTransactionContext as bn, type NeighborNodeOrderField as bo, type NeighborOrder as bp, type NeighborOrderField as bq, type NeighborReadOptions as br, type NeighborResult as bs, type NeighborsOptions as bt, type NoRecordedCoordinate as bu, type Node as bv, type NodeAccessor as bw, type NodeAlias as bx, type NodeBulkFindByIndexOptions as by, type NodeCollection as bz, type HistoryStore as c, type StoreViewWeightedShortestPathOptions as c$, type RebuildFulltextOptions as c0, type RebuildFulltextResult as c1, type ReclaimedVectorFieldEntry as c2, type RecordedScanOptions as c3, type RecordedScanPage as c4, RecordedStoreView as c5, type RecordedStoreViewEdgeCollection as c6, type RecordedStoreViewEdgeCollections as c7, type RecordedStoreViewNodeCollection as c8, type RecordedStoreViewNodeCollections as c9, type StoreAnalysisSchemaCoordinate as cA, type StoreDescription as cB, type StoreHooks as cC, type StorePopulationStatistics as cD, type StoreProjection as cE, type StoreRef as cF, StoreSearch as cG, type StoreTransactionOptions as cH, type StoreValidationFailure as cI, type StoreValidationPage as cJ, StoreView as cK, type StoreViewCanReachOptions as cL, type StoreViewCoordinate as cM, type StoreViewDegreeOptions as cN, type StoreViewEdgeCollection as cO, type StoreViewEdgeCollections as cP, type StoreViewGraphAlgorithms as cQ, type StoreViewLabelPropagationOptions as cR, type StoreViewNeighborsOptions as cS, type StoreViewNodeCollection as cT, type StoreViewNodeCollections as cU, type StoreViewPageRankOptions as cV, type StoreViewPersonalizedPageRankOptions as cW, type StoreViewReachableOptions as cX, type StoreViewShortestPathOptions as cY, type StoreViewSubgraphOptions as cZ, type StoreViewWeaklyConnectedComponentsOptions as c_, type RecursiveTraversalOptions as ca, type ReembedFunction as cb, type ReembedVectorFieldOptions as cc, type ReembedVectorFieldResult as cd, type RequiredEdgeCollectionLookup as ce, type RequiredNodeCollectionLookup as cf, type RuntimeBulkEdgeSourceGroup as cg, type RuntimeEdgeCollection as ch, type RuntimeEdgeFor as ci, type RuntimeEdgeKind as cj, type RuntimeEdgeTypeFor as ck, type RuntimeNodeCollection as cl, type RuntimeNodeKind as cm, type RuntimeNodeReferenceFor as cn, type RuntimeNodeTypeFor as co, type SchemaIntrospection as cp, type ScopedMeasure as cq, type SearchScopeOptions as cr, type SelectContext as cs, type SelectableEdge as ct, type SelectableNode as cu, type ShortestPathOptions as cv, type ShortestPathResult as cw, type SqlAvailability as cx, StoreAnalysisCursorStaleError as cy, type StoreAnalysisCursorStaleErrorDetails as cz, type RecordedReadStore as d, type StreamOptions as d0, type SubgraphEdgeResult as d1, type SubgraphNodeResult as d2, type SubgraphOptions as d3, type SubgraphResult as d4, type SubsetEdge as d5, type SubsetNode as d6, type TemporalAlgorithmOptions as d7, type TransactionContext as d8, type TransactionOutcome as d9, createVerifiedAdapterStore as dA, createVerifiedStore as dB, defineSubgraphProject as dC, exists as dD, fieldRef as dE, inSubquery as dF, isParameterRef as dG, notExists as dH, notInSubquery as dI, param as dJ, EDGE_TEMPORAL_READ_NAMES as dK, IDENTITY_READ_NAMES as dL, type TransactionReceipt as da, type TraversalDirection as db, type TypedEdgeCollection as dc, type TypedRecordedStoreViewEdgeCollection as dd, type TypedStoreViewEdgeCollection as de, UnionableQuery as df, type UniqueIntrospection as dg, type UpdateEdgeInput as dh, type UpdateNodeInput as di, type ValidateStoreOptions as dj, type ValidityEndMutation as dk, type VectorSearchHit as dl, type VectorSearchOptions as dm, type WeaklyConnectedComponentMembership as dn, type WeaklyConnectedComponentsOptions as dp, type WeightedShortestPathOptions as dq, type WeightedShortestPathResult as dr, type WorkingCopyOptions as ds, asIdentityAssertionId as dt, compareAndSetAbsent as du, createAdapterStore as dv, createAdapterStoreWithSchema as dw, createQueryBuilder as dx, createStore as dy, createStoreWithSchema as dz, type IdentityAssertionId as e, type IdentityAssertionResult as f, type IdentityFacade as g, type IdentityNode as h, type IdentityNodeRefInput as i, type IdentityPair as j, type IdentityReadFacade as k, type IdentityRelation as l, type IdentityWriteSummary as m, type ReconciledSchema as n, type MigrationHookContext as o, type SchemaValidationResult as p, applyDeprecatedKinds as q, assertSchemaCurrent as r, ensureSchema as s, getActiveSchema as t, getCommittedSchemaVersion as u, getSchemaChanges as v, initializeSchema as w, isSchemaInitialized as x, loadActiveSchemaWithBootstrap as y, loadAndMergeGraphExtensionDocument as z };