@nicia-ai/typegraph 0.59.0 → 0.60.0

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

@@ -1,5 +1,5 @@
 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, 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, 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-Dky3sCFz.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';
 
@@ -1930,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.
  */
@@ -3553,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
@@ -3565,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`,
@@ -4864,215 +5083,6 @@ type MaterializeRemovalsResult = Readonly<{
     reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
 }>;
 
-/** 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>[]>>;
-}>;
-
 declare const STORE_RUNTIME: unique symbol;
 /**
  * @internal Operations used by Store-owned views. The port is absent from the