@nicia-ai/typegraph 0.31.0 → 0.33.0

package/dist/{store-MloRPwb9.d.ts → store-view-FfE5_7eo.d.ts}

@@ -1,9 +1,8 @@
+import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-C0_r0ALf.js';
+import { T as TemporalMode, A as AnyEdgeType, N as NodeType, g as EdgeType, E as EdgeRegistration, e as EdgeId, d as NodeId, b as NodeRegistration, K as KindEntity, m as Cardinality, q as EndpointExistence, f as KindAnnotations, s as UniquenessScope, n as Collation, G as GraphExtension } from './extension-types-YGFJPrzK.js';
 import { z } from 'zod';
-import { aA as ValueType, aB as PredicateExpression, aC as VectorMetricType, a1 as FulltextQueryMode, Q as QueryAst, J as JsonPointer, P as FieldRef, ad as ParameterRef, G as GraphBackend, am as TransactionBackend, a6 as JsonPointerInput, an as TraversalExpansion, p as SqlDialect, ai as SqlSchema, aD as Traversal, aE as NodePredicate, aF as ProjectedField, ac as OrderSpec, aG as GroupBySpec, a4 as HybridFusionOptions, aH as RecursiveCyclePolicy, aI as TraversalDirection$1, aJ as EdgeRow, aK as NodeRow, W as AdoptedTransaction, L as AggregateExpr, F as FulltextStrategy, V as VectorStrategy, aL as VectorSlotMap, aM as SelectiveField, aN as ComposableQuery, aO as SetOperationType, aP as SetOperation, ah as SortDirection, m as JsonSchema, aQ as VectorMetric } from './types-BKQljXom.js';
-import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-By-WEd8M.js';
-import { A as AnyEdgeType, N as NodeType, T as TemporalMode, g as EdgeType, E as EdgeRegistration, e as EdgeId, d as NodeId, b as NodeRegistration, K as KindEntity, m as Cardinality, n as EndpointExistence, f as KindAnnotations, U as UniquenessScope, C as Collation, G as GraphExtension } from './extension-types-D1k0inWU.js';
-import { SQL } from 'drizzle-orm';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-CAGhqPHQ.js';
+import { b7 as ValueType, b8 as PredicateExpression, b9 as VectorMetricType, ae as FulltextQueryMode, Q as QueryAst, J as JsonPointer, P as FieldRef, ax as ParameterRef, G as GraphBackend, aP as TransactionBackend, ao as JsonPointerInput, aQ as TraversalExpansion, p as SqlDialect, aL as SqlSchema, ba as Traversal, bb as NodePredicate, bc as ProjectedField, aw as OrderSpec, bd as GroupBySpec, ak as HybridFusionOptions, be as RecursiveCyclePolicy, W as TraversalDirection$1, bf as EdgeRow, bg as NodeRow, aa as ExternalRecordedReadSource, X as AdoptedTransaction, L as AggregateExpr, a3 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bh as VectorSlotMap, bi as RecordedReadBinding, bj as SelectiveField, bk as ComposableQuery, bl as SetOperationType, bm as SetOperation, aJ as SortDirection, bn as VectorMetric, m as JsonSchema, bo as TransactionOptions } from './types-DGylBhWo.js';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-CAkIYFV-.js';
 
 /**
  * Embedding type for vector search.
@@ -216,6 +215,60 @@ declare function searchable(options?: SearchableOptions): SearchableSchema;
 declare function isSearchableSchema(value: unknown): value is SearchableSchema;
 declare function getSearchableMetadata(schema: z.ZodType): SearchableMetadata | undefined;
 
+declare const RECORDED_INSTANT_BRAND: unique symbol;
+/**
+ * A canonical UTC ISO-8601 recorded-time instant (`YYYY-MM-DDTHH:mm:ss.sssZ`),
+ * nominally branded so it can only originate from a recorded-time source —
+ * {@link Store.recordedNow} or an explicit {@link asRecordedInstant} — never an
+ * ad-hoc wall-clock string.
+ *
+ * The recorded commit clock is a logical, monotonic per-graph instant that can
+ * run briefly ahead of wall time under bursty same-millisecond writes, so a raw
+ * `new Date().toISOString()` may sort *before* the most recent commits and
+ * silently omit them. The brand turns that footgun into a compile error:
+ * `store.asOfRecorded` accepts only a `RecordedInstant`, so a bare wall-clock
+ * string no longer type-checks — callers reach for `await store.recordedNow()`
+ * (the monotonic high-water mark) or {@link asRecordedInstant} instead.
+ */
+type RecordedInstant = string & {
+    readonly [RECORDED_INSTANT_BRAND]: "RecordedInstant";
+};
+/**
+ * Brands a canonical UTC ISO-8601 string as a {@link RecordedInstant}.
+ *
+ * The escape hatch for an instant that round-trips through untyped storage:
+ * captured from {@link Store.recordedNow}, persisted as a plain string, read
+ * back, and replayed into `asOfRecorded`. Validates the canonical form eagerly —
+ * the same check `asOfRecorded` applies — so a malformed value fails here, at the
+ * brand site, rather than deeper in a read. Does *not* assert the instant is a
+ * real captured commit; it only guarantees the value is well-formed enough to
+ * compare correctly against the recorded relations.
+ *
+ * @throws {ValidationError} when `value` is not a canonical UTC ISO-8601 string.
+ */
+declare function asRecordedInstant(value: string): RecordedInstant;
+/**
+ * The single opaque temporal coordinate every pinned read is resolved
+ * against. It carries the valid-time axis plus an optional recorded/system-time
+ * axis, so every surface can inject one coordinate object instead of threading
+ * each temporal dimension separately.
+ */
+type ReadCoordinate = Readonly<{
+    /**
+     * The valid-time axis: a resolved temporal mode and (only for `"asOf"`) the
+     * instant it is pinned to.
+     */
+    valid: Readonly<{
+        mode: TemporalMode;
+        /** Defined only when `mode` is `"asOf"`. */
+        asOf?: string;
+    }>;
+    /** The recorded/system-time axis. Defined only for recorded-pinned views. */
+    recorded?: Readonly<{
+        asOf: RecordedInstant;
+    }>;
+}>;
+
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
     elementType?: ValueType | undefined;
@@ -498,6 +551,7 @@ type DynamicSelectableEdge = Readonly<{
  * and ExecutableQuery classes.
  */
 
+type QueryCoordinateState = "open" | "sealed";
 /**
  * A query that can be executed within a `store.batch()` call.
  *
@@ -540,6 +594,7 @@ type NodeAlias<K extends NodeType = NodeType, Optional extends boolean = false>
  * A map of alias names to their node aliases.
  */
 type AliasMap = Readonly<Record<string, NodeAlias<NodeType, boolean>>>;
+type EmptyAliasMap = Readonly<Record<never, never>>;
 /**
  * An edge alias with its associated type and optional flag.
  */
@@ -552,6 +607,7 @@ type EdgeAlias<E extends AnyEdgeType = EdgeType, Optional extends boolean = fals
  * A map of alias names to their edge aliases.
  */
 type EdgeAliasMap = Readonly<Record<string, EdgeAlias<EdgeType, boolean>>>;
+type EmptyEdgeAliasMap = Readonly<Record<never, never>>;
 /**
  * A recursive alias marker with its associated type (depth or path).
  */
@@ -562,6 +618,7 @@ type RecursiveAlias<T extends "depth" | "path"> = Readonly<{
  * A map of recursive alias names to their types.
  */
 type RecursiveAliasMap = Readonly<Record<string, RecursiveAlias<"depth" | "path">>>;
+type EmptyRecursiveAliasMap = Readonly<Record<never, never>>;
 /**
  * Resolves a recursive alias marker to its runtime value type.
  */
@@ -841,7 +898,7 @@ type QueryBuilderConfig = Readonly<{
     defaultTraversalExpansion: TraversalExpansion;
     backend?: GraphBackend;
     dialect?: SqlDialect;
-    /** SQL schema configuration for custom table names. */
+    /** SQL schema configuration from createSqlSchema(...) for custom table names. */
     schema?: SqlSchema;
 }>;
 /**
@@ -861,6 +918,7 @@ type QueryBuilderState = Readonly<{
     offset: number | undefined;
     temporalMode: TemporalMode;
     asOf: string | undefined;
+    recordedAsOf?: RecordedInstant | undefined;
     groupBy: GroupBySpec | undefined;
     having: PredicateExpression | undefined;
     fusion: HybridFusionOptions | undefined;
@@ -881,12 +939,43 @@ type CreateQueryBuilderOptions = Readonly<{
     backend?: GraphBackend;
     /** SQL dialect for compilation */
     dialect?: SqlDialect;
-    /** SQL schema configuration for custom table names */
+    /** SQL schema configuration from createSqlSchema(...) for custom table names */
     schema?: SqlSchema;
     /** Default traversal ontology expansion mode (default: "inverse"). */
     defaultTraversalExpansion?: TraversalExpansion;
 }>;
 
+/**
+ * StoreView collection surface buckets.
+ *
+ * The live NodeCollection / EdgeCollection partition into buckets a StoreView
+ * treats differently:
+ *
+ * - temporal reads honor the pinned coordinate;
+ * - current reads have no temporal axis and are refused on temporal pins;
+ * - writes are never available on a read-only view; and
+ * - batch reads require store.batch() and are absent from a view.
+ *
+ * These arrays are the single runtime source of truth for the proxy routing and
+ * the type-level source for the derived StoreView collection types. The
+ * StoreView surface-classification test asserts they exactly partition the live
+ * collection methods so new collection methods cannot be silently omitted.
+ */
+/** Temporal-aware node read method names. */
+declare const NODE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count"];
+/** Current-state-only node reads (constraint / index lookups). */
+declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindByConstraint", "bulkFindByIndex"];
+/** Node write method names: never available on a read-only StoreView. */
+declare const NODE_WRITE_NAMES: readonly ["create", "createFromRecord", "update", "delete", "hardDelete", "upsertById", "upsertByIdFromRecord", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByConstraint", "bulkGetOrCreateByConstraint"];
+/** Temporal-aware edge read method names. */
+declare const EDGE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count", "findFrom", "findTo", "findByEndpoints"];
+/** Deferred edge batch-read method names. */
+declare const EDGE_BATCH_READ_NAMES: readonly ["batchFindFrom", "batchFindTo", "batchFindByEndpoints"];
+/** Edge write method names: never available on a read-only StoreView. */
+declare const EDGE_WRITE_NAMES: readonly ["create", "update", "delete", "hardDelete", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByEndpoints", "bulkGetOrCreateByEndpoints"];
+/** Recorded-time collection point reads that reconstruct safely by id. */
+declare const RECORDED_POINT_READ_NAMES: readonly ["getById", "getByIds"];
+
 /**
  * Store types for TypeGraph operations.
  */
@@ -1003,7 +1092,15 @@ type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
 /**
  * Options for node and edge queries.
  */
-type QueryOptions = Readonly<{
+type NoRecordedCoordinate = Readonly<{
+    /**
+     * Recorded/system-time coordinates are internal-only and supplied by
+     * RecordedStoreView. A public options object carrying this key is a type
+     * error even when the object is pre-bound before the call site.
+     */
+    recordedAsOf?: never;
+}>;
+type QueryOptions = NoRecordedCoordinate & Readonly<{
     /** Temporal mode for the query */
     temporalMode?: TemporalMode;
     /** Specific timestamp for asOf queries */
@@ -1083,13 +1180,10 @@ type StoreHooks = Readonly<{
     /** Called when an error occurs */
     onError?: (ctx: HookContext, error: Error) => void;
 }>;
-/**
- * Options for creating a store.
- */
-type StoreOptions = Readonly<{
+type BaseStoreOptions = Readonly<{
     /** Observability hooks for monitoring */
     hooks?: StoreHooks;
-    /** SQL schema configuration for custom table names */
+    /** SQL schema configuration from createSqlSchema(...) for custom table names */
     schema?: SqlSchema;
     /** Query default behaviors. */
     queryDefaults?: Readonly<{
@@ -1097,6 +1191,28 @@ type StoreOptions = Readonly<{
         traversalExpansion?: TraversalExpansion;
     }>;
 }>;
+/**
+ * Store options without built-in recorded-time capture. A recorded read relation
+ * can still be bound explicitly for hosts that populate history externally.
+ */
+type LiveStoreOptions = BaseStoreOptions & Readonly<{
+    history?: false | undefined;
+    recordedRead?: ExternalRecordedReadSource | undefined;
+}>;
+/**
+ * Store options with TypeGraph-managed recorded-time capture. `history: true`
+ * captures TypeGraph writes and binds TypeGraph's built-in recorded relation
+ * internally. Externally populated recorded read sources are read-only bindings
+ * and are intentionally accepted only by {@link LiveStoreOptions}.
+ */
+type HistoryStoreOptions = BaseStoreOptions & Readonly<{
+    history: true;
+    recordedRead?: never;
+}>;
+/**
+ * Options for creating a store.
+ */
+type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
 /**
  * A mutable handle to the current `Store`, used by `store.evolve(...)`
  * so long-lived consumers can dereference through the ref and pick up
@@ -1174,7 +1290,7 @@ type EdgeGetOrCreateByEndpointsResult<E extends AnyEdgeType, From extends NodeTy
 type EdgeFindByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
     /**
      * Edge property fields to include in the match alongside the (from, to) endpoints.
-     * When omitted, matches on endpoints only (returns first live edge).
+     * When omitted, matches on endpoints only (returns the first edge at the read coordinate).
      */
     matchOn?: readonly (keyof z.input<E["schema"]>)[];
     /** Property values to match against when matchOn is specified. */
@@ -1232,15 +1348,13 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * Supports predicate filtering via the `where` option for SQL-level filtering.
      * For simple queries. Use store.query() for complex traversals.
      */
-    find: (options?: Readonly<{
+    find: (filter?: Readonly<{
         where?: (accessor: NodeAccessor<N>) => Predicate;
         limit?: number;
         offset?: number;
-        temporalMode?: TemporalMode;
-        asOf?: string;
-    }>) => Promise<Node<N>[]>;
+    }>, temporal?: QueryOptions) => Promise<Node<N>[]>;
     /** Count nodes matching criteria */
-    count: (options?: QueryOptions) => Promise<number>;
+    count: (temporal?: QueryOptions) => Promise<number>;
     /**
      * Create a node from untyped data, relying on runtime Zod validation.
      *
@@ -1451,29 +1565,43 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
     update: (id: EdgeId<E>, props: Partial<z.input<E["schema"]>>, options?: Readonly<{
         validTo?: string;
     }>) => Promise<Edge<E, From, To>>;
-    /** Find edges from a specific node */
-    findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;
-    /** Find edges to a specific node */
-    findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;
+    /**
+     * Find edges from a specific node.
+     *
+     * Honors the same temporal model as `getById` / `find`: with no
+     * `options`, the graph's default `temporalMode` applies (excluding
+     * soft-deleted edges and, in `current` / `asOf` modes, edges outside
+     * their validity window). Pass `temporalMode` / `asOf` to read the
+     * endpoint's edges at another temporal coordinate.
+     */
+    findFrom: (from: NodeRef<From>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
+    /**
+     * Find edges to a specific node.
+     *
+     * Temporal semantics mirror {@link EdgeCollection.findFrom}.
+     */
+    findTo: (to: NodeRef<To>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /**
      * Deferred variant of `findFrom` for use with `store.batch()`.
      *
-     * Returns a `BatchableQuery` instead of executing immediately.
+     * Returns a `BatchableQuery` instead of executing immediately. Accepts
+     * the same temporal `options` as {@link EdgeCollection.findFrom}.
      */
-    batchFindFrom: (from: NodeRef<From>) => BatchableQuery<Edge<E, From, To>>;
+    batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
      * Deferred variant of `findTo` for use with `store.batch()`.
      *
-     * Returns a `BatchableQuery` instead of executing immediately.
+     * Returns a `BatchableQuery` instead of executing immediately. Accepts
+     * the same temporal `options` as {@link EdgeCollection.findTo}.
      */
-    batchFindTo: (to: NodeRef<To>) => BatchableQuery<Edge<E, From, To>>;
+    batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
      * Deferred variant of `findByEndpoints` for use with `store.batch()`.
      *
      * Returns a `BatchableQuery` that yields a 0-or-1 element array
      * (matching `findByEndpoints`' at-most-one semantics).
      */
-    batchFindByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => BatchableQuery<Edge<E, From, To>>;
+    batchFindByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /** Delete an edge (soft delete - sets deletedAt timestamp) */
     delete: (id: EdgeId<E>) => Promise<void>;
     /**
@@ -1487,21 +1615,17 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      */
     hardDelete: (id: EdgeId<E>) => Promise<void>;
     /** Find edges matching endpoint and pagination criteria */
-    find: (options?: Readonly<{
+    find: (filter?: Readonly<{
         from?: NodeRef<From>;
         to?: NodeRef<To>;
         limit?: number;
         offset?: number;
-        temporalMode?: TemporalMode;
-        asOf?: string;
-    }>) => Promise<Edge<E, From, To>[]>;
+    }>, temporal?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /** Count edges matching criteria */
-    count: (options?: Readonly<{
+    count: (filter?: Readonly<{
         from?: NodeRef<From>;
         to?: NodeRef<To>;
-        temporalMode?: TemporalMode;
-        asOf?: string;
-    }>) => Promise<number>;
+    }>, temporal?: QueryOptions) => Promise<number>;
     /**
      * Create multiple edges in a batch.
      *
@@ -1553,16 +1677,22 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      */
     bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
     /**
-     * Find a live edge by endpoints and optional property fields.
+     * Find an edge by endpoints and optional property fields.
      *
-     * Returns the first matching live edge, or undefined.
-     * Soft-deleted edges are excluded.
+     * Returns the first matching edge at the read coordinate, or undefined.
+     * Honors the temporal model like `findFrom` / `findTo`: by default
+     * (`current` mode) soft-deleted and out-of-window edges are excluded; under
+     * `includeTombstones` a soft-deleted edge can be returned.
      *
      * @param from - Source node
      * @param to - Target node
      * @param options - Match criteria (matchOn fields and property values)
+     * @param temporal - Temporal coordinate. With no `temporal`, the graph's
+     *   default `temporalMode` applies (so under the default `"current"` mode,
+     *   edges outside their validity window are excluded). Pass
+     *   `temporalMode` / `asOf` to read the edge as of another coordinate.
      */
-    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => Promise<Edge<E, From, To> | undefined>;
+    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
     /**
      * Get an existing edge by endpoints and optional property fields, or create a new one.
      *
@@ -1619,6 +1749,105 @@ type GraphNodeCollections<G extends GraphDef> = {
 type GraphEdgeCollections<G extends GraphDef> = {
     [K in keyof G["edges"] & string]-?: TypedEdgeCollection<G["edges"][K]>;
 };
+/** Temporal-aware node reads — a {@link StoreView} pins these. */
+type NodeTemporalReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_TEMPORAL_READ_NAMES)[number]>;
+/**
+ * Current-state-only node reads (constraint / index lookups). No temporal
+ * axis, so a {@link StoreView} delegates them on a `current` pin and refuses
+ * them on a temporal pin.
+ */
+type NodeCurrentReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof CURRENT_ONLY_READ_NAMES)[number]>;
+/** Node writes — never available on a read-only {@link StoreView}. */
+type NodeWrites<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_WRITE_NAMES)[number]>;
+/** Temporal-aware edge reads — a {@link StoreView} pins these. */
+type EdgeTemporalReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_TEMPORAL_READ_NAMES)[number]>;
+/**
+ * Deferred edge reads for `store.batch()` — absent from a {@link StoreView},
+ * which has no batch context.
+ */
+type EdgeBatchReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_BATCH_READ_NAMES)[number]>;
+/** Edge writes — never available on a read-only {@link StoreView}. */
+type EdgeWrites<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_WRITE_NAMES)[number]>;
+/**
+ * The read-only node surface a {@link StoreView} exposes for one node kind.
+ * The temporal reads drop the per-call temporal argument — the pin owns the
+ * axis; the current reads ({@link NodeCurrentReads}) are exposed as-is
+ * (delegated on a `current` view, refused on a temporal pin). Writes live on
+ * the live `Store`. The conformance test asserts the temporal part equals the
+ * pinned form of {@link NodeTemporalReads}.
+ */
+type StoreViewNodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
+    /** Get a node by ID at the view's pinned coordinate. */
+    getById: (id: NodeId<N>) => Promise<Node<N> | undefined>;
+    /** Get multiple nodes by ID, preserving input order (undefined for missing). */
+    getByIds: (ids: readonly NodeId<N>[]) => Promise<readonly (Node<N> | undefined)[]>;
+    /** Find nodes matching criteria at the view's pinned coordinate. */
+    find: (filter?: Readonly<{
+        where?: (accessor: NodeAccessor<N>) => Predicate;
+        limit?: number;
+        offset?: number;
+    }>) => Promise<Node<N>[]>;
+    /** Count nodes at the view's pinned coordinate. */
+    count: () => Promise<number>;
+}> & NodeCurrentReads<N, CN>;
+/**
+ * The read-only edge surface a {@link StoreView} exposes for one edge
+ * kind, mirroring {@link StoreViewNodeCollection}. Every edge read —
+ * including `findByEndpoints` — honors the pin via the same temporal model,
+ * so (unlike nodes) there are no current-state-only edge reads.
+ */
+type StoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
+    /** Get an edge by ID at the view's pinned coordinate. */
+    getById: (id: EdgeId<E>) => Promise<Edge<E, From, To> | undefined>;
+    /** Get multiple edges by ID, preserving input order (undefined for missing). */
+    getByIds: (ids: readonly EdgeId<E>[]) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
+    /** Find edges matching endpoint and pagination criteria. */
+    find: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+        limit?: number;
+        offset?: number;
+    }>) => Promise<Edge<E, From, To>[]>;
+    /** Count edges matching criteria at the view's pinned coordinate. */
+    count: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+    }>) => Promise<number>;
+    /** Find edges from a specific node at the view's pinned coordinate. */
+    findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;
+    /** Find edges to a specific node at the view's pinned coordinate. */
+    findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;
+    /** Find the edge between two endpoints at the view's pinned coordinate. */
+    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => Promise<Edge<E, From, To> | undefined>;
+}>;
+/**
+ * Read-only view edge collection derived from an `EdgeRegistration`,
+ * extracting the edge type and from/to node types — the read-only
+ * counterpart of {@link TypedEdgeCollection}.
+ */
+type TypedStoreViewEdgeCollection<R extends EdgeRegistration> = StoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
+/** Mapped type of all read-only view node collections for a graph. */
+type StoreViewNodeCollections<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]-?: StoreViewNodeCollection<G["nodes"][K]["type"]>;
+};
+/** Mapped type of all read-only view edge collections for a graph. */
+type StoreViewEdgeCollections<G extends GraphDef> = {
+    [K in keyof G["edges"] & string]-?: TypedStoreViewEdgeCollection<G["edges"][K]>;
+};
+/** Recorded-time node point reads for one node kind. */
+type RecordedStoreViewNodeCollection<N extends NodeType> = Pick<StoreViewNodeCollection<N>, (typeof RECORDED_POINT_READ_NAMES)[number]>;
+/** Recorded-time edge point reads for one edge kind. */
+type RecordedStoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<StoreViewEdgeCollection<E, From, To>, (typeof RECORDED_POINT_READ_NAMES)[number]>;
+/** Recorded-time edge collection derived from an `EdgeRegistration`. */
+type TypedRecordedStoreViewEdgeCollection<R extends EdgeRegistration> = RecordedStoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
+/** Mapped type of all recorded-time node point-read collections. */
+type RecordedStoreViewNodeCollections<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]-?: RecordedStoreViewNodeCollection<G["nodes"][K]["type"]>;
+};
+/** Mapped type of all recorded-time edge point-read collections. */
+type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
+    [K in keyof G["edges"] & string]-?: TypedRecordedStoreViewEdgeCollection<G["edges"][K]>;
+};
 /**
  * A typed transaction context with collection API.
  *
@@ -1660,6 +1889,12 @@ type GraphEdgeCollections<G extends GraphDef> = {
  * Its type is the `AdoptedTransaction` union; cast to your concrete
  * Drizzle database type at the call site.
  *
+ * When the store was created with `{ history: true }`, `tx.sql` is present but
+ * replaced by a fail-loud guard because raw SQL would bypass recorded-time
+ * capture. Use the typed `tx.nodes` / `tx.edges` collections inside
+ * `transaction()`, or use `store.withRecordedTransaction(externalTx, fn)` when
+ * the relational layer owns the transaction boundary.
+ *
  * @example
  * ```typescript
  * await store.transaction(async (tx) => {
@@ -1673,6 +1908,13 @@ type TransactionContext<G extends GraphDef> = Readonly<{
     nodes: GraphNodeCollections<G>;
     edges: GraphEdgeCollections<G>;
     sql?: AdoptedTransaction;
+    /**
+     * The transaction-scoped backend the collections are bound to, for advanced
+     * raw reads that must observe the transaction's snapshot (e.g. graph-merge's
+     * in-transaction base@V re-validation). On the non-transactional fallback it
+     * is the store's plain backend — reads work, but there is no snapshot.
+     */
+    backend: TransactionBackend;
 }>;
 /**
  * Replace branded `NodeId` / `EdgeId` with plain `string` in each
@@ -1758,268 +2000,70 @@ type StoreProjection<G extends GraphDef, N extends keyof G["nodes"] & string = n
 }>;
 
 /**
- * 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.
+ * ExecutableAggregateQuery - A query with aggregate functions that can be executed.
  */
-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.
+ * Result type for aggregate queries.
+ * Maps field refs to their value types and aggregates to numbers.
  */
-type SubsetNode<G extends GraphDef, K extends NodeKinds<G>> = {
-    [Kind in K]: Node<G["nodes"][Kind]["type"]>;
-}[K];
+type AggregateResult<R extends Record<string, FieldRef | AggregateExpr>> = {
+    [K in keyof R]: R[K] extends AggregateExpr ? number : R[K] extends FieldRef ? unknown : never;
+};
 /**
- * Discriminated union of Edge runtime types narrowed to a subset of kinds.
+ * An aggregate query that can be executed.
  */
-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<{
+declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends AliasMap, R extends Record<string, FieldRef | AggregateExpr>> {
+    #private;
+    constructor(config: QueryBuilderConfig, state: QueryBuilderState, fields: R);
     /**
-     * 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.
+     * Builds the query AST.
      */
-    nodes?: SubgraphNodeProjectionMap<G, NK>;
+    toAst(): QueryAst;
     /**
-     * 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.
+     * Limits the number of results.
      */
-    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;
+    limit(n: number): ExecutableAggregateQuery<G, Aliases, R>;
     /**
-     * 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.
+     * Offsets the results.
      */
-    includeKinds?: readonly NK[];
-    /** Exclude the root node from the result (default: false). */
-    excludeRoot?: boolean;
+    offset(n: number): ExecutableAggregateQuery<G, Aliases, R>;
     /**
-     * Edge direction policy (default: "out").
-     * - "out": follow edges in their defined direction only
-     * - "both": follow edges in both directions (undirected traversal)
+     * Compiles the query and returns the SQL text and parameters.
+     *
+     * Requires a backend to be configured (the backend determines the SQL dialect).
+     * Use this for debugging, logging, or running the query with a custom executor.
      */
-    direction?: "out" | "both";
-    /** Cycle policy — reuse RecursiveCyclePolicy (default: "prevent"). */
-    cyclePolicy?: RecursiveCyclePolicy;
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
     /**
-     * Temporal mode applied to both nodes and edges along the traversal and in
-     * the hydrated result. Defaults to `graph.defaults.temporalMode`.
+     * Compiles the query to a Drizzle SQL object.
      */
-    temporalMode?: TemporalMode;
-    /** ISO-8601 timestamp used when `temporalMode === "asOf"`. */
-    asOf?: string;
+    compile(): CompiledSelectSql;
     /**
-     * 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.
+     * Executes the query and returns typed results.
      *
-     * Only kinds present in `includeKinds` (nodes) or `edges` (edges) are valid
-     * projection keys. Specifying a kind outside those sets is a compile-time error.
+     * @throws Error if no backend is configured
      */
-    project?: P;
-}>;
-/**
- * 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>[]>>;
-}>;
+    execute(): Promise<readonly AggregateResult<R>[]>;
+}
 
 /**
- * Data-cleanup phase for `store.removeKinds()`.
+ * Query Compiler Module
  *
- * The removeKinds verb commits the new schema atomically (millisecond
- * budget); the data deletion happens here, scoped per-deployment via
- * the `typegraph_kind_removals` status table. Splitting the verbs
- * mirrors how `materializeIndexes` complements `evolve`: schema
- * commits are atomic and fast, data work is bounded by row count and
- * deferrable / parallelizable.
+ * Main entry point for compiling query ASTs to SQL.
+ * Re-exports individual compiler modules and provides the main compile functions.
  */
 
-type MaterializeRemovalsOptions = Readonly<{
-    /** Restrict to specific kind names. */
-    kinds?: readonly string[];
-    /** Halt on first failure. Default: false (best-effort). */
-    stopOnError?: boolean;
-}>;
-type MaterializeRemovalsEntry = Readonly<{
-    kind: string;
-    entity: KindEntity;
-    status: "removed" | "failed";
-    error?: Error;
-}>;
 /**
- * Outcome of reclaiming one per-`(graphId, kind, field)` vector table that
- * was orphaned when its embedding field was dropped from a *surviving*
- * kind's schema. Distinct from {@link MaterializeRemovalsEntry} (whole
- * kinds) because the unit is a single embedding field, not a kind.
- */
-type ReclaimedVectorFieldEntry = Readonly<{
-    kind: string;
-    fieldPath: string;
-    status: "reclaimed" | "failed";
-    error?: Error;
-}>;
-type MaterializeRemovalsResult = Readonly<{
-    results: readonly MaterializeRemovalsEntry[];
-    /**
-     * Embedding fields removed from a *surviving* kind whose per-field vector
-     * table this pass dropped (or confirmed already absent). Empty when the
-     * backend has no vector strategy or no embedding field has ever been
-     * dropped. Re-derived from immutable schema history each call, so it lists
-     * the same removed fields on repeat passes — the underlying drop is
-     * idempotent (`DROP ... IF EXISTS`). See {@link reclaimRemovedVectorFieldTables}.
-     */
-    reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
-}>;
-
-/**
- * ExecutableAggregateQuery - A query with aggregate functions that can be executed.
- */
-
-/**
- * Result type for aggregate queries.
- * Maps field refs to their value types and aggregates to numbers.
- */
-type AggregateResult<R extends Record<string, FieldRef | AggregateExpr>> = {
-    [K in keyof R]: R[K] extends AggregateExpr ? number : R[K] extends FieldRef ? unknown : never;
-};
-/**
- * An aggregate query that can be executed.
- */
-declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends AliasMap, R extends Record<string, FieldRef | AggregateExpr>> {
-    #private;
-    constructor(config: QueryBuilderConfig, state: QueryBuilderState, fields: R);
-    /**
-     * Builds the query AST.
-     */
-    toAst(): QueryAst;
-    /**
-     * Limits the number of results.
-     */
-    limit(n: number): ExecutableAggregateQuery<G, Aliases, R>;
-    /**
-     * Offsets the results.
-     */
-    offset(n: number): ExecutableAggregateQuery<G, Aliases, R>;
-    /**
-     * Compiles the query and returns the SQL text and parameters.
-     *
-     * Requires a backend to be configured (the backend determines the SQL dialect).
-     * Use this for debugging, logging, or running the query with a custom executor.
-     */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
-    /**
-     * Compiles the query to a Drizzle SQL object.
-     */
-    compile(): SQL;
-    /**
-     * Executes the query and returns typed results.
-     *
-     * @throws Error if no backend is configured
-     */
-    execute(): Promise<readonly AggregateResult<R>[]>;
-}
-
-/**
- * Query Compiler Module
- *
- * Main entry point for compiling query ASTs to SQL.
- * Re-exports individual compiler modules and provides the main compile functions.
- */
-
-/**
- * Options for query compilation.
+ * Options for query compilation.
  */
 type CompileQueryOptions = Readonly<{
     /** SQL dialect ("sqlite" or "postgres"). Defaults to "sqlite". */
     dialect?: SqlDialect | undefined;
-    /** SQL schema configuration for table names. Defaults to standard names. */
+    /** SQL schema configuration from createSqlSchema(...). Defaults to standard names. */
     schema?: SqlSchema | undefined;
     /**
      * Fulltext strategy override. When set, overrides the dialect's
@@ -2048,6 +2092,13 @@ type CompileQueryOptions = Readonly<{
      * declare the field. Callers build it from the graph's node schemas.
      */
     vectorSlots?: VectorSlotMap | undefined;
+    /**
+     * Recorded read relation to use when the AST carries `recordedAsOf`.
+     * Supplying a recorded timestamp without this binding is rejected so the
+     * compiler never silently swaps to TypeGraph's built-in history tables when
+     * the store was only configured for live/valid-time reads.
+     */
+    recordedReadBinding?: RecordedReadBinding | undefined;
 }>;
 
 type PreparedQueryConfig<R> = Readonly<{
@@ -2164,7 +2215,7 @@ declare class UnionableQuery<G extends GraphDef, R> {
     /**
      * Compiles the set operation to SQL.
      */
-    compile(): SQL;
+    compile(): CompiledSelectSql;
     /**
      * Executes the combined query.
      */
@@ -2256,7 +2307,7 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
      * Returns a Drizzle SQL object that can be executed directly
      * with db.all(), db.get(), etc.
      */
-    compile(): SQL;
+    compile(): CompiledSelectSql;
     /**
      * Creates a prepared (pre-compiled) query that can be executed
      * multiple times with different parameter bindings.
@@ -2355,7 +2406,7 @@ interface VariableLengthState {
  * Type parameters track the edge kind and direction to constrain
  * which node kinds are valid targets in the `to()` method.
  */
-declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap = {}, EK extends keyof G["edges"] & string = keyof G["edges"] & string, EA extends string = string, Dir extends TraversalDirection$1 = "out", Optional extends boolean = false, DC extends boolean | string = false, PC extends boolean | string = false, RecAliases extends RecursiveAliasMap = {}> {
+declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap = EmptyEdgeAliasMap, EK extends keyof G["edges"] & string = keyof G["edges"] & string, EA extends string = string, Dir extends TraversalDirection$1 = "out", Optional extends boolean = false, DC extends boolean | string = false, PC extends boolean | string = false, RecAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, CoordinateState extends QueryCoordinateState = "open"> {
     #private;
     constructor(config: QueryBuilderConfig, state: QueryBuilderState, edgeKinds: readonly string[], edgeAlias: EA, direction: Dir, fromAlias: string, inverseEdgeKinds?: readonly string[], optional?: Optional, variableLength?: VariableLengthState, pendingEdgePredicates?: readonly NodePredicate[]);
     /**
@@ -2367,14 +2418,14 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
         depth: infer D extends boolean | string;
     } ? D : DC, O extends {
         path: infer P extends boolean | string;
-    } ? P : PC, RecAliases>;
+    } ? P : PC, RecAliases, CoordinateState>;
     /**
      * Adds a WHERE clause for the edge being traversed.
      *
      * @param alias - The edge alias to filter on (must be the current edge alias)
      * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases>;
+    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases, CoordinateState>;
     /**
      * Specifies the target node kind.
      *
@@ -2387,23 +2438,24 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
      */
     to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
         includeSubClasses?: false;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"], Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"], Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
     to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
         includeSubClasses: true;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<NodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<NodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
     /**
      * String-keyed sibling of `to` for runtime-declared target kinds.
      * Throws `KindNotFoundError` if the kind is not registered.
      */
     toDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
         includeSubClasses?: boolean;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<EdgeTypeForKey<G, EK>, Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<EdgeTypeForKey<G, EK>, Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
 }
 
 /**
  * QueryBuilder - The fluent query builder.
  */
 
+type TemporalMethod<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState> = CoordinateState extends "open" ? (mode: TemporalMode, asOf?: string) => QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, "open"> : never;
 /**
  * The fluent query builder.
  *
@@ -2412,8 +2464,9 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
  * - Aliases: Map of alias names to their node kinds
  * - EdgeAliases: Map of alias names to their edge kinds (accumulated during traversals)
  */
-declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, EdgeAliases extends EdgeAliasMap = {}, RecursiveAliases extends RecursiveAliasMap = {}> {
+declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyAliasMap, EdgeAliases extends EdgeAliasMap = EmptyEdgeAliasMap, RecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, CoordinateState extends QueryCoordinateState = "open"> {
     #private;
+    readonly temporal: TemporalMethod<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     constructor(config: QueryBuilderConfig, state: QueryBuilderState);
     /**
      * Starts a query from a node kind.
@@ -2423,10 +2476,10 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      */
     from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
         includeSubClasses?: false;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"]>>, EdgeAliases, RecursiveAliases>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"]>>, EdgeAliases, RecursiveAliases, CoordinateState>;
     from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
         includeSubClasses: true;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias>, EdgeAliases, RecursiveAliases>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias>, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * String-keyed sibling of `from` for runtime-declared kinds. Throws
      * `KindNotFoundError` if the kind is not registered. Predicates use
@@ -2434,18 +2487,18 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      */
     fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
         includeSubClasses?: boolean;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases>;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Adds a WHERE clause for a node.
      */
-    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Adds a WHERE clause for an edge.
      *
      * @param alias - The edge alias to filter on
      * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Traverses an edge to another node (outgoing direction).
      *
@@ -2459,7 +2512,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         direction?: "out";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases, CoordinateState>;
     /**
      * Traverses an edge to another node (incoming direction).
      *
@@ -2474,7 +2527,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         direction: "in";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", false, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", false, false, false, RecursiveAliases, CoordinateState>;
     /**
      * String-keyed sibling of `traverse` for runtime-declared edge kinds.
      * Throws `KindNotFoundError` if the edge kind is not registered.
@@ -2483,7 +2536,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         direction?: TraversalDirection$1;
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType>>, string, EA, TraversalDirection$1, false, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType>>, string, EA, TraversalDirection$1, false, false, false, RecursiveAliases, CoordinateState>;
     /**
      * Optionally traverses an edge to another node (LEFT JOIN semantics).
      * If no matching edge/node exists, the result will include null values.
@@ -2499,12 +2552,12 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         direction?: "out";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", true, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", true, false, false, RecursiveAliases, CoordinateState>;
     optionalTraverse<EK extends keyof G["edges"] & string, EA extends string>(edgeKind: EK, edgeAlias: EA, options: {
         direction: "in";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", true, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", true, false, false, RecursiveAliases, CoordinateState>;
     /**
      * String-keyed sibling of `optionalTraverse` for runtime-declared edge
      * kinds. LEFT JOIN semantics — non-matching rows produce a null edge
@@ -2515,7 +2568,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         direction?: TraversalDirection$1;
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType, true>>, string, EA, TraversalDirection$1, true, false, false, RecursiveAliases>;
+    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType, true>>, string, EA, TraversalDirection$1, true, false, false, RecursiveAliases, CoordinateState>;
     /**
      * Selects fields to return.
      */
@@ -2530,23 +2583,15 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
     /**
      * Orders results.
      */
-    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Limits the number of results.
      */
-    limit(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    limit(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Offsets the results.
      */
-    offset(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
-    /**
-     * Sets temporal mode.
-     *
-     * @param mode - The temporal mode to use
-     * @param asOf - Required timestamp for "asOf" mode (ISO 8601 string)
-     * @throws ValidationError if mode is "asOf" but no timestamp is provided
-     */
-    temporal(mode: TemporalMode, asOf?: string): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    offset(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Groups results by the specified field.
      * Use with aggregate functions like COUNT, SUM, AVG in select().
@@ -2554,21 +2599,21 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      * @param alias - The node alias to group by
      * @param field - The field name to group by
      */
-    groupBy<A extends keyof Aliases & string>(alias: A, field: string): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    groupBy<A extends keyof Aliases & string>(alias: A, field: string): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Groups results by the node ID.
      * Use when you want to group by a complete node rather than a specific field.
      *
      * @param alias - The node alias to group by (uses the node's ID)
      */
-    groupByNode<A extends keyof Aliases & string>(alias: A): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    groupByNode<A extends keyof Aliases & string>(alias: A): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Filters grouped results using aggregate conditions (HAVING clause).
      * Use after groupBy() to filter based on aggregate values.
      *
      * @param predicate - A predicate expression to filter groups
      */
-    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Sets fusion parameters for hybrid (vector + fulltext) queries.
      *
@@ -2592,7 +2637,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      *   .execute();
      * ```
      */
-    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
      * Applies a query fragment to transform this builder.
      *
@@ -2618,9 +2663,22 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      * @param fragment - A function that transforms the builder
      * @returns The transformed builder
      */
-    pipe<OutAliases extends AliasMap, OutEdgeAliases extends EdgeAliasMap = EdgeAliases, OutRecAliases extends RecursiveAliasMap = RecursiveAliases>(fragment: (builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases>): QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases>;
+    pipe<OutAliases extends AliasMap, OutEdgeAliases extends EdgeAliasMap = EdgeAliases, OutRecAliases extends RecursiveAliasMap = RecursiveAliases>(fragment: (builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>): QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>;
 }
 
+/**
+ * Fluent query builder for TypeGraph.
+ *
+ * Provides a type-safe, chainable API for building queries.
+ * Each method returns a new builder instance with expanded type information.
+ *
+ * This module re-exports from the builder submodules and provides the
+ * createQueryBuilder factory function.
+ */
+
+type InitialQueryBuilder<G extends GraphDef, CoordinateState extends QueryCoordinateState = "open"> = QueryBuilder<G, EmptyAliasMap, EmptyEdgeAliasMap, EmptyRecursiveAliasMap, CoordinateState>;
+declare function createQueryBuilder<G extends GraphDef>(graphId: string, registry: KindRegistry, options?: CreateQueryBuilderOptions): InitialQueryBuilder<G>;
+
 /**
  * Shared types for Tier 1 graph algorithms.
  *
@@ -2652,18 +2710,22 @@ type AlgorithmCyclePolicy = RecursiveCyclePolicy;
  *
  * Algorithms honor the same temporal model as the rest of the store: both
  * nodes and edges are filtered according to the resolved mode. `asOf` is
- * only consulted when the resolved mode is `"asOf"`. If neither option is
- * supplied, the algorithm falls back to `graph.defaults.temporalMode`.
+ * required when the resolved mode is `"asOf"` and rejected for every other
+ * mode. If neither option is supplied, the algorithm falls back to
+ * `graph.defaults.temporalMode`.
  */
-type TemporalAlgorithmOptions = Readonly<{
+type TemporalAlgorithmOptions = NoRecordedCoordinate & Readonly<{
     /** Temporal mode. Defaults to the graph's configured default. */
     temporalMode?: TemporalMode;
     /**
-     * ISO-8601 timestamp used when `temporalMode` is `"asOf"`. Required in that
-     * mode; ignored in all others.
+     * ISO-8601 timestamp pinning the read. Required when `temporalMode` is
+     * `"asOf"`; rejected (throws `ValidationError`) for every other mode.
      */
     asOf?: string;
 }>;
+type InternalTemporalAlgorithmOptions = Omit<TemporalAlgorithmOptions, "recordedAsOf"> & Readonly<{
+    recordedAsOf?: RecordedInstant;
+}>;
 /**
  * Base options for traversal-style algorithms.
  */
@@ -2680,6 +2742,7 @@ type BaseTraversalOptions<G extends GraphDef> = TemporalAlgorithmOptions & Reado
     /** Cycle policy (default: `"prevent"`). */
     cyclePolicy?: AlgorithmCyclePolicy;
 }>;
+type InternalBaseTraversalOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<BaseTraversalOptions<G>, keyof TemporalAlgorithmOptions>;
 /**
  * A node reached during traversal, annotated with the shortest depth at which
  * it was first discovered.
@@ -2712,6 +2775,7 @@ type ShortestPathResult = Readonly<{
  * care about the first time a target is reached.
  */
 type ShortestPathOptions<G extends GraphDef> = BaseTraversalOptions<G>;
+type InternalShortestPathOptions<G extends GraphDef> = InternalBaseTraversalOptions<G>;
 /**
  * Options for `reachable`.
  *
@@ -2723,6 +2787,7 @@ type ReachableOptions<G extends GraphDef> = BaseTraversalOptions<G> & Readonly<{
     /** Exclude the source node from the result set (default: `false`). */
     excludeSource?: boolean;
 }>;
+type InternalReachableOptions<G extends GraphDef> = InternalBaseTraversalOptions<G> & Omit<ReachableOptions<G>, keyof BaseTraversalOptions<G>>;
 /**
  * Options for `neighbors`.
  *
@@ -2740,6 +2805,7 @@ type NeighborsOptions<G extends GraphDef> = TemporalAlgorithmOptions & Readonly<
     /** Cycle policy (default: `"prevent"`). */
     cyclePolicy?: AlgorithmCyclePolicy;
 }>;
+type InternalNeighborsOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<NeighborsOptions<G>, keyof TemporalAlgorithmOptions>;
 /**
  * Options for `degree`.
  *
@@ -2755,6 +2821,7 @@ type DegreeOptions<G extends GraphDef> = TemporalAlgorithmOptions & Readonly<{
     /** Direction (default: `"both"`). */
     direction?: TraversalDirection;
 }>;
+type InternalDegreeOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
 
 /**
  * Raw node id or any object with an `id: string` field. Covers `Node`,
@@ -2812,80 +2879,12 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      */
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
 }>;
-
-/**
- * `store.introspect()` — unified read of the merged schema.
- *
- * Returns a coherent snapshot of "what does my schema look like right
- * now" suitable for schema-management UIs, codegen, and IDE plugins.
- * The previous surface was fragmented across `registry.hasNodeType`,
- * `store.deprecatedKinds`, and direct graph poking; `introspect()`
- * unifies them with explicit `origin` markers distinguishing
- * compile-time from runtime declarations.
- *
- * Pure read — no I/O. Built from the in-memory `GraphDef` and the
- * persisted-but-already-merged `extension`. `schemaVersion` /
- * `schemaHash` are populated when the loader cached them at
- * construction time and `undefined` otherwise; consumers needing a
- * fresh read should call `backend.getActiveSchema(graphId)` directly.
- */
-
-type SchemaIntrospection = Readonly<{
-    graphId: string;
-    /** Active schema version on the backend, when known to the caller. */
-    schemaVersion: number | undefined;
-    /** Hash of the active schema document, when known to the caller. */
-    schemaHash: string | undefined;
-    kinds: readonly KindIntrospection[];
-    edges: readonly EdgeIntrospection[];
-    ontology: readonly OntologyIntrospection[];
-    deprecatedKinds: ReadonlySet<string>;
-    /**
-     * The persisted graph extension, or `undefined` when the store has
-     * no extensions. Round-trips: passing this value to
-     * `defineGraphExtension` and `evolve` against an empty graph yields
-     * a graph with the same extension kinds.
-     */
-    extension: GraphExtension | undefined;
-}>;
-type KindIntrospection = Readonly<{
-    name: string;
-    origin: "compile-time" | "runtime";
-    description: string | undefined;
-    annotations: KindAnnotations | undefined;
-    deprecated: boolean;
-    /**
-     * JSON-Schema view of the kind's properties. For extension kinds the
-     * lower-level `ExtensionPropertyType` shape (with first-class
-     * `searchable` / `embedding` modifiers) is reachable via
-     * `introspection.extension.nodes[name].properties`.
-     */
-    properties: JsonSchema;
-    unique: readonly UniqueIntrospection[];
-}>;
-type EdgeIntrospection = Readonly<{
-    name: string;
-    origin: "compile-time" | "runtime";
-    description: string | undefined;
-    from: readonly string[];
-    to: readonly string[];
-    cardinality: Cardinality;
-    endpointExistence: EndpointExistence;
-    properties: JsonSchema;
-    annotations: KindAnnotations | undefined;
-    deprecated: boolean;
-}>;
-type OntologyIntrospection = Readonly<{
-    metaEdge: string;
-    from: string;
-    to: string;
-    origin: "compile-time" | "runtime";
-}>;
-type UniqueIntrospection = Readonly<{
-    name: string;
-    fields: readonly string[];
-    scope: UniquenessScope;
-    collation: Collation;
+type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
+    shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: InternalShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
+    reachable: (from: NodeIdentifier, options: InternalReachableOptions<G>) => Promise<readonly ReachableNode[]>;
+    canReach: (from: NodeIdentifier, to: NodeIdentifier, options: InternalBaseTraversalOptions<G>) => Promise<boolean>;
+    neighbors: (node: NodeIdentifier, options: InternalNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
+    degree: (node: NodeIdentifier, options?: InternalDegreeOptions<G>) => Promise<number>;
 }>;
 
 type RebuildFulltextOptions = Readonly<{
@@ -3175,90 +3174,376 @@ declare class StoreSearch<G extends GraphDef> {
 }
 
 /**
- * Main Store implementation for TypeGraph.
+ * `store.introspect()` — unified read of the merged schema.
  *
- * The Store is the primary interface for interacting with a TypeGraph.
- * It coordinates:
- * - Node and edge CRUD operations
- * - Constraint validation
- * - Schema management
- * - Transaction handling
+ * Returns a coherent snapshot of "what does my schema look like right
+ * now" suitable for schema-management UIs, codegen, and IDE plugins.
+ * The previous surface was fragmented across `registry.hasNodeType`,
+ * `store.deprecatedKinds`, and direct graph poking; `introspect()`
+ * unifies them with explicit `origin` markers distinguishing
+ * compile-time from runtime declarations.
+ *
+ * Pure read — no I/O. Built from the in-memory `GraphDef` and the
+ * persisted-but-already-merged `extension`. `schemaVersion` /
+ * `schemaHash` are populated when the loader cached them at
+ * construction time and `undefined` otherwise; consumers needing a
+ * fresh read should call `backend.getActiveSchema(graphId)` directly.
  */
 
-type StoreSchemaMetadata = Readonly<{
+type SchemaIntrospection = Readonly<{
+    graphId: string;
+    /** Active schema version on the backend, when known to the caller. */
     schemaVersion: number | undefined;
+    /** Hash of the active schema document, when known to the caller. */
     schemaHash: string | undefined;
-}>;
-/**
- * The Store provides typed access to a TypeGraph database.
- *
- * @example
- * ```typescript
- * const store = createStore(myGraph, backend);
- *
- * // Create nodes using collection API
- * const person = await store.nodes.Person.create({
- *   name: "Alice",
- *   email: "alice@example.com",
- * });
- *
- * const company = await store.nodes.Company.create({
- *   name: "Acme",
- *   industry: "Technology",
- * });
- *
- * // Create edges
- * await store.edges.worksAt.create(
- *   { kind: "Person", id: person.id },
- *   { kind: "Company", id: company.id },
- *   { role: "Engineer" }
- * );
- *
- * // Query with the fluent API
- * const results = await store.query()
- *   .from("Person", "p")
- *   .whereNode("p", (p) => p.name.eq("Alice"))
- *   .select((ctx) => ctx.p)
- *   .execute();
- * ```
- */
-/**
- * Optional embedder for {@link Store.reembedVectorField}. Receives a batch of
- * the kind's nodes and returns a map of `nodeId → new embedding vector` (omit
- * an id to leave that node without an embedding). Called once per page; the
- * page size is `batchSize`.
- */
-type ReembedFunction = (nodes: readonly Node[]) => Promise<ReadonlyMap<string, readonly number[]>> | ReadonlyMap<string, readonly number[]>;
-/** Options for {@link Store.reembedVectorField}. */
-type ReembedVectorFieldOptions = Readonly<{
+    kinds: readonly KindIntrospection[];
+    edges: readonly EdgeIntrospection[];
+    ontology: readonly OntologyIntrospection[];
+    deprecatedKinds: ReadonlySet<string>;
     /**
-     * When supplied, drives a batched re-embed loop after recreating storage:
-     * pages the kind's nodes, calls `embed(batch)`, and upserts the returned
-     * vectors. When omitted, storage is recreated empty and the caller
-     * re-embeds via normal `update()` / `upsertEmbedding` writes.
+     * The persisted graph extension, or `undefined` when the store has
+     * no extensions. Round-trips: passing this value to
+     * `defineGraphExtension` and `evolve` against an empty graph yields
+     * a graph with the same extension kinds.
      */
-    embed?: ReembedFunction;
-    /** Re-embed page size. Default 200. */
-    batchSize?: number;
-}>;
-/** Result of {@link Store.reembedVectorField}. */
-type ReembedVectorFieldResult = Readonly<{
-    /** Whether the per-field storage was dropped and recreated. */
-    recreated: boolean;
-    /** Number of nodes whose embedding was re-written (0 without `embed`). */
-    reembedded: number;
+    extension: GraphExtension | undefined;
 }>;
-declare class Store<G extends GraphDef> {
-    #private;
-    constructor(graph: G, backend: GraphBackend, options?: StoreOptions, schemaMetadata?: StoreSchemaMetadata);
-    /** The graph definition */
-    get graph(): G;
+type KindIntrospection = Readonly<{
+    name: string;
+    origin: "compile-time" | "runtime";
+    description: string | undefined;
+    annotations: KindAnnotations | undefined;
+    deprecated: boolean;
+    /**
+     * JSON-Schema view of the kind's properties. For extension kinds the
+     * lower-level `ExtensionPropertyType` shape (with first-class
+     * `searchable` / `embedding` modifiers) is reachable via
+     * `introspection.extension.nodes[name].properties`.
+     */
+    properties: JsonSchema;
+    unique: readonly UniqueIntrospection[];
+}>;
+type EdgeIntrospection = Readonly<{
+    name: string;
+    origin: "compile-time" | "runtime";
+    description: string | undefined;
+    from: readonly string[];
+    to: readonly string[];
+    cardinality: Cardinality;
+    endpointExistence: EndpointExistence;
+    properties: JsonSchema;
+    annotations: KindAnnotations | undefined;
+    deprecated: boolean;
+}>;
+type OntologyIntrospection = Readonly<{
+    metaEdge: string;
+    from: string;
+    to: string;
+    origin: "compile-time" | "runtime";
+}>;
+type UniqueIntrospection = Readonly<{
+    name: string;
+    fields: readonly string[];
+    scope: UniquenessScope;
+    collation: Collation;
+}>;
+
+type MaterializeRemovalsOptions = Readonly<{
+    /** Restrict to specific kind names. */
+    kinds?: readonly string[];
+    /** Halt on first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+}>;
+type MaterializeRemovalsEntry = Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "removed" | "failed";
+    error?: Error;
+}>;
+/**
+ * Outcome of reclaiming one per-`(graphId, kind, field)` vector table that
+ * was orphaned when its embedding field was dropped from a *surviving*
+ * kind's schema. Distinct from {@link MaterializeRemovalsEntry} (whole
+ * kinds) because the unit is a single embedding field, not a kind.
+ */
+type ReclaimedVectorFieldEntry = Readonly<{
+    kind: string;
+    fieldPath: string;
+    status: "reclaimed" | "failed";
+    error?: Error;
+}>;
+type MaterializeRemovalsResult = Readonly<{
+    results: readonly MaterializeRemovalsEntry[];
+    /**
+     * Embedding fields removed from a *surviving* kind whose per-field vector
+     * table this pass dropped (or confirmed already absent). Empty when the
+     * backend has no vector strategy or no embedding field has ever been
+     * dropped. Re-derived from immutable schema history each call, so it lists
+     * the same removed fields on repeat passes — the underlying drop is
+     * idempotent (`DROP ... IF EXISTS`). See {@link reclaimRemovedVectorFieldTables}.
+     */
+    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>[]>>;
+}>;
+
+/**
+ * Main Store implementation for TypeGraph.
+ *
+ * The Store is the primary interface for interacting with a TypeGraph.
+ * It coordinates:
+ * - Node and edge CRUD operations
+ * - Constraint validation
+ * - Schema management
+ * - Transaction handling
+ */
+
+type StoreSchemaMetadata = Readonly<{
+    schemaVersion: number | undefined;
+    schemaHash: string | undefined;
+}>;
+/**
+ * The Store provides typed access to a TypeGraph database.
+ *
+ * @example
+ * ```typescript
+ * const store = createStore(myGraph, backend);
+ *
+ * // Create nodes using collection API
+ * const person = await store.nodes.Person.create({
+ *   name: "Alice",
+ *   email: "alice@example.com",
+ * });
+ *
+ * const company = await store.nodes.Company.create({
+ *   name: "Acme",
+ *   industry: "Technology",
+ * });
+ *
+ * // Create edges
+ * await store.edges.worksAt.create(
+ *   { kind: "Person", id: person.id },
+ *   { kind: "Company", id: company.id },
+ *   { role: "Engineer" }
+ * );
+ *
+ * // Query with the fluent API
+ * const results = await store.query()
+ *   .from("Person", "p")
+ *   .whereNode("p", (p) => p.name.eq("Alice"))
+ *   .select((ctx) => ctx.p)
+ *   .execute();
+ * ```
+ */
+/**
+ * Optional embedder for {@link Store.reembedVectorField}. Receives a batch of
+ * the kind's nodes and returns a map of `nodeId → new embedding vector` (omit
+ * an id to leave that node without an embedding). Called once per page; the
+ * page size is `batchSize`.
+ */
+type ReembedFunction = (nodes: readonly Node[]) => Promise<ReadonlyMap<string, readonly number[]>> | ReadonlyMap<string, readonly number[]>;
+/** Options for {@link Store.reembedVectorField}. */
+type ReembedVectorFieldOptions = Readonly<{
+    /**
+     * When supplied, drives a batched re-embed loop after recreating storage:
+     * pages the kind's nodes, calls `embed(batch)`, and upserts the returned
+     * vectors. When omitted, storage is recreated empty and the caller
+     * re-embeds via normal `update()` / `upsertEmbedding` writes.
+     */
+    embed?: ReembedFunction;
+    /** Re-embed page size. Default 200. */
+    batchSize?: number;
+}>;
+/** Result of {@link Store.reembedVectorField}. */
+type ReembedVectorFieldResult = Readonly<{
+    /** Whether the per-field storage was dropped and recreated. */
+    recreated: boolean;
+    /** Number of nodes whose embedding was re-written (0 without `embed`). */
+    reembedded: number;
+}>;
+declare class Store<G extends GraphDef> {
+    #private;
+    constructor(graph: G, backend: GraphBackend, options?: StoreOptions, schemaMetadata?: StoreSchemaMetadata);
+    /** The graph definition */
+    get graph(): G;
     /** The graph ID */
     get graphId(): string;
     /** The kind registry for ontology lookups */
     get registry(): KindRegistry;
     /** The database backend */
     get backend(): GraphBackend;
+    /**
+     * Whether recorded-time capture is enabled for this store.
+     *
+     * @internal
+     */
+    get historyEnabled(): boolean;
+    /**
+     * Whether this store has a recorded read relation bound for reconstruction.
+     *
+     * @internal
+     */
+    get recordedReadBound(): boolean;
     /**
      * Node collections for ergonomic CRUD operations.
      *
@@ -3399,7 +3684,140 @@ declare class Store<G extends GraphDef> {
      *   .execute();
      * ```
      */
-    query(): QueryBuilder<G>;
+    query(): InitialQueryBuilder<G, "open">;
+    /**
+     * Internal seam for {@link StoreView.query}: a query builder pinned to a
+     * view's {@link ReadCoordinate} with its temporal axis sealed
+     * (`.temporal()` throws). Not part of the stable public API — construct a
+     * view via {@link Store.view} / {@link Store.asOf} and call `.query()`.
+     */
+    sealedQuery(coordinate: ReadCoordinate): InitialQueryBuilder<G, "sealed">;
+    /**
+     * Internal seam for {@link RecordedStoreView}: reconstruct a node point read
+     * from the recorded-time relation while preserving live getById ordering and
+     * duplicate-input behavior.
+     *
+     * @internal
+     */
+    recordedNodeGetById<N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate): Promise<Node<N> | undefined>;
+    /**
+     * Internal seam for {@link RecordedStoreView}: reconstruct node point reads
+     * from the recorded-time relation while preserving input order.
+     *
+     * @internal
+     */
+    recordedNodeGetByIds<N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate): Promise<readonly (Node<N> | undefined)[]>;
+    /**
+     * Internal seam for {@link RecordedStoreView}: reconstruct an edge point read
+     * from the recorded-time relation while preserving live getById behavior.
+     *
+     * @internal
+     */
+    recordedEdgeGetById<E extends AnyEdgeType>(kind: string, id: EdgeId<E>, coordinate: ReadCoordinate): Promise<Edge<E> | undefined>;
+    /**
+     * Internal seam for {@link RecordedStoreView}: reconstruct edge point reads
+     * from the recorded-time relation while preserving input order.
+     *
+     * @internal
+     */
+    recordedEdgeGetByIds<E extends AnyEdgeType>(kind: string, ids: readonly EdgeId<E>[], coordinate: ReadCoordinate): Promise<readonly (Edge<E> | undefined)[]>;
+    /**
+     * Returns a read-only {@link StoreView} pinned to a valid-time instant.
+     *
+     * The view routes every supported read — `nodes` / `edges` collections,
+     * `query()`, `subgraph()`, and the graph algorithms — through the
+     * `asOf` coordinate, so they observe the graph as it was valid at `T`.
+     * Writes stay on the live `Store`. Mirrors Datomic's `(d/as-of db t)`.
+     *
+     * @example
+     * ```typescript
+     * const past = store.asOf("2026-01-01T00:00:00.000Z");
+     * const alice = await past.nodes.Person.getById(aliceId);
+     * const names = await past
+     *   .query()
+     *   .from("Person", "p")
+     *   .whereNode("p", (p) => p.name.eq("Alice"))
+     *   .select((ctx) => ctx.p.name)
+     *   .execute();
+     * ```
+     *
+     * @param asOf - ISO-8601 timestamp to pin the valid-time coordinate to.
+     */
+    asOf(asOf: string): StoreView<G>;
+    /**
+     * Returns a narrow read-only view pinned to a recorded/system-time instant.
+     *
+     * Direct `store.asOfRecorded(T)` is diagonal bitemporal sugar: it reads the
+     * recorded-time relation as of `T` and uses the same `T` for the valid-time
+     * axis. Use `store.asOf(validT).asOfRecorded(recordedT)` when the valid and
+     * recorded axes should differ.
+     *
+     * The returned view exposes only reconstructing-safe reads: query,
+     * subgraph, graph algorithms, and collection point reads.
+     *
+     * Prefer `await store.recordedNow()` as the anchor over a wall-clock
+     * timestamp: recorded instants are monotonic and can run briefly ahead of the
+     * wall clock under bursty writes, so a `new Date().toISOString()` passed here
+     * may sort before the most recent commits and silently omit them.
+     */
+    asOfRecorded(recordedAsOf: RecordedInstant): RecordedStoreView<G>;
+    /**
+     * Returns the latest recorded-time instant captured for this graph — the
+     * recorded high-water mark. After guarding the `undefined` case,
+     * `store.asOfRecorded(checkpoint)` reconstructs everything committed so far, a
+     * deterministic anchor that avoids guessing with the wall clock (recorded
+     * instants are monotonic and can run briefly ahead of wall-clock time under
+     * bursty writes). Capture each anchor right after the writes it should cover.
+     *
+     * Returns `undefined` until the first write has been captured, so on a
+     * brand-new graph guard the composition — `asOfRecorded(undefined)` rejects
+     * (an instant is required) rather than reconstructing an empty view. Read the
+     * value first and only pass it to `asOfRecorded` once it is defined.
+     *
+     * **Graph-global, not caller-scoped.** This is the single high-water mark for
+     * the whole graph, advanced by every committed capture from any writer — not
+     * a per-write or per-caller value. An advance between two reads means
+     * "something committed to this graph in between," *not* "the write this caller
+     * just made landed." Do not use a `recordedNow()` advance as a "did my write
+     * succeed?" signal: under any concurrent writer to the same graph it both
+     * misses dropped writes and misfires on no-op writes. Confirm a specific write
+     * by observing the write itself (its return value, or `store.transaction(...)`
+     * success), not the global clock.
+     */
+    recordedNow(): Promise<RecordedInstant | undefined>;
+    /**
+     * Returns a read-only {@link StoreView} pinned to an arbitrary public
+     * temporal mode. Use {@link Store.asOf} for the common valid-time case;
+     * reach for `view` to pin `"current"`, `"includeEnded"`, or
+     * `"includeTombstones"`.
+     *
+     * @example
+     * ```typescript
+     * const withTombstones = store.view({ mode: "includeTombstones" });
+     * const everyEverVersion = await withTombstones.nodes.Person.find();
+     * ```
+     *
+     * @param coordinate - The `(mode, asOf)` coordinate to pin. `asOf` is
+     *   required when `mode` is `"asOf"` and rejected for every other mode.
+     */
+    view(coordinate: StoreViewCoordinate): StoreView<G>;
+    /**
+     * Returns a read-only {@link StoreView} pinned to the current instant,
+     * captured once at construction — a stable point-in-time snapshot. Unlike
+     * `store.view({ mode: "current" })` (which tracks "now" live and can read
+     * different surfaces against slightly different clocks), a snapshot pins one
+     * `asOf` timestamp, so every surface observes the same instant. Sugar for
+     * `store.asOf(new Date().toISOString())`; mirrors Datomic's `(d/db conn)`.
+     *
+     * @example
+     * ```typescript
+     * const snap = store.snapshot();
+     * // Every read on `snap` sees the graph as of one fixed instant.
+     * const a = await snap.nodes.Person.find();
+     * const r = await snap.reachable(rootId, { edges: ["knows"] });
+     * ```
+     */
+    snapshot(): StoreView<G>;
     /**
      * Search-related operations (fulltext, hybrid, and rebuild).
      *
@@ -3496,6 +3914,21 @@ declare class Store<G extends GraphDef> {
      * ```
      */
     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>>;
+    /**
+     * Internal seam for {@link StoreView} / {@link RecordedStoreView}: runs a
+     * subgraph with a coordinate already flattened into the options (including a
+     * recorded/system-time pin). Trusted caller — the public {@link Store.subgraph}
+     * is the guarded entry point.
+     *
+     * @internal
+     */
+    subgraphAtCoordinate<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: InternalSubgraphOptions<G, EK, NK, P>): Promise<SubgraphResult<G, NK, EK, P>>;
+    /**
+     * Internal seam for StoreView graph algorithms at a pinned coordinate.
+     *
+     * @internal
+     */
+    algorithmsAtCoordinate(coordinate: ReadCoordinate): InternalGraphAlgorithms<G>;
     /**
      * Executes a function within a transaction.
      *
@@ -3508,6 +3941,10 @@ declare class Store<G extends GraphDef> {
      *   {@link Store.withTransaction}). See {@link TransactionContext}
      *   for per-backend semantics; it is `undefined` only on the
      *   non-transactional fallback.
+     *   When the store was created with `{ history: true }`, `tx.sql` is
+     *   replaced by a fail-loud guard because raw SQL would bypass
+     *   recorded-time capture; use the typed collections inside
+     *   `transaction()` or {@link Store.withRecordedTransaction}.
      *
      * @example
      * ```typescript
@@ -3546,8 +3983,17 @@ declare class Store<G extends GraphDef> {
      *   // sequential, non-atomic — handle partial-failure recovery yourself
      * }
      * ```
+     *
+     * @param fn The callback run inside the transaction boundary.
+     * @param options Optional {@link TransactionOptions} forwarded to the
+     *   backend (e.g. `isolationLevel: "serializable"` on Postgres). Backends
+     *   without isolation-level support ignore it; the non-transactional
+     *   fallback ignores it entirely. Stores created with `{ history: true }`
+     *   require read-committed semantics for PostgreSQL recorded-clock capture and
+     *   reject stronger snapshot isolation levels.
      */
-    transaction<T>(fn: (tx: TransactionContext<G>) => Promise<T>): Promise<T>;
+    transaction<T>(this: HistoryStore<G>, fn: (tx: HistoryTransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    transaction<T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<T>;
     /**
      * Adopts a caller-owned, already-open Drizzle transaction so the graph
      * store and the caller's relational writes commit or roll back as one
@@ -3590,9 +4036,18 @@ declare class Store<G extends GraphDef> {
      * }); // one COMMIT / ROLLBACK across both layers
      * ```
      *
-     * @throws {ConfigurationError} when the backend cannot adopt an
-     *   external transaction — either it is not a Drizzle Postgres/SQLite
-     *   backend, or `backend.capabilities.transactions` is `false`
+     * Not available when the store was created with `{ history: true }`: a
+     * caller-owned transaction context would let writes happen after capture has
+     * lost its flush point, so this throws `ConfigurationError`
+     * (`RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`). Use
+     * {@link Store.withRecordedTransaction} on a history-enabled store, which
+     * adopts the same external transaction but flushes recorded-time capture
+     * before the caller commits.
+     *
+     * @throws {ConfigurationError} when the store has history capture enabled
+     *   (use {@link Store.withRecordedTransaction} instead), or when the backend
+     *   cannot adopt an external transaction — either it is not a Drizzle
+     *   Postgres/SQLite backend, or `backend.capabilities.transactions` is `false`
      *   (`drizzle-orm/neon-http`, Cloudflare D1, SQLite
      *   `transactionMode: "none"`). A non-atomic fallback is deliberately
      *   not offered here: the caller's relational write *would* still
@@ -3604,6 +4059,20 @@ declare class Store<G extends GraphDef> {
      *   without emitting any DDL.
      */
     withTransaction(externalTx: AdoptedTransaction): TransactionContext<G>;
+    /**
+     * Adopts a caller-owned transaction while giving recorded-time capture a
+     * flush point before the caller commits. Required when `history: true` is
+     * enabled because returning a long-lived transaction context would let writes
+     * happen after TypeGraph has lost the chance to close/open recorded rows.
+     *
+     * Capture flushes once, when `fn` resolves. The flush seals the capture
+     * session, so a graph write made through the transaction context *after* `fn`
+     * returns (e.g. retaining `tx` and writing once more before the caller's
+     * COMMIT) throws rather than committing uncaptured — the post-flush write
+     * cannot silently diverge history from live state.
+     */
+    withRecordedTransaction<T>(this: HistoryStore<G>, externalTx: AdoptedTransaction, fn: (tx: HistoryTransactionContext<G>) => Promise<T>): Promise<T>;
+    withRecordedTransaction<T>(externalTx: AdoptedTransaction, fn: (tx: TransactionContext<G>) => Promise<T>): Promise<T>;
     /**
      * Hard-deletes all data for this graph from the database.
      *
@@ -3849,6 +4318,29 @@ declare class Store<G extends GraphDef> {
      */
     close(): Promise<void>;
 }
+type HistorySafeBackend = Omit<GraphBackend, "executeStatement" | "executeDdl"> & Readonly<{
+    executeStatement?: never;
+    executeDdl?: never;
+}>;
+type HistorySafeTransactionBackend = Omit<TransactionBackend, "executeStatement" | "executeDdl"> & Readonly<{
+    executeStatement?: never;
+    executeDdl?: never;
+}>;
+type HistoryTransactionContext<G extends GraphDef> = Omit<TransactionContext<G>, "backend" | "sql"> & Readonly<{
+    backend: HistorySafeTransactionBackend;
+    sql?: never;
+}>;
+type RecordedReadStore<G extends GraphDef> = Store<G> & Readonly<{
+    recordedReadBound: true;
+}>;
+type HistoryStore<G extends GraphDef> = Store<G> & Readonly<{
+    backend: HistorySafeBackend;
+    historyEnabled: true;
+    recordedReadBound: true;
+}>;
+type ExplicitRecordedReadLiveOptions = LiveStoreOptions & Readonly<{
+    recordedRead: NonNullable<LiveStoreOptions["recordedRead"]>;
+}>;
 /**
  * Creates a new Store instance.
  *
@@ -3878,6 +4370,8 @@ declare class Store<G extends GraphDef> {
  * });
  * ```
  */
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions): HistoryStore<G>;
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions): RecordedReadStore<G>;
 declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions): Store<G>;
 
 /**
@@ -3908,6 +4402,8 @@ declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend
  * }
  * ```
  */
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions & SchemaManagerOptions): Promise<[HistoryStore<G>, SchemaValidationResult]>;
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions & SchemaManagerOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
 declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions & SchemaManagerOptions): Promise<[Store<G>, SchemaValidationResult]>;
 /**
  * Creates a Store after **verifying** that the database is at the same
@@ -3950,6 +4446,146 @@ declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: Gr
  * @throws StoreNotInitializedError if runtime-contribution markers are
  *   missing/stale/failed for this graph on this connection.
  */
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions): Promise<[HistoryStore<G>, SchemaValidationResult]>;
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
 declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions): Promise<[Store<G>, SchemaValidationResult]>;
 
-export { type HybridVectorOptions as $, type AliasMap as A, type BaseTraversalOptions as B, type CreateQueryBuilderOptions as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EmbeddingMetric as E, type EdgeGetOrCreateByEndpointsResult as F, type EdgeIntrospection as G, type EmbeddingSchema as H, type EmbeddingValue as I, ExecutableAggregateQuery as J, ExecutableQuery as K, type FieldAccessor as L, type FulltextSearchHit as M, type Node as N, type FulltextSearchOptions as O, type GetOrCreateAction as P, QueryBuilder as Q, type GraphAlgorithms as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, type GraphEdgeCollections as V, type GraphNodeCollections as W, type HookContext as X, type HybridFulltextOptions as Y, type HybridSearchHit as Z, type HybridSearchOptions as _, type EmbeddingIndexType as a, createStore as a$, type IfExistsMode as a0, type KindIntrospection as a1, type MaterializeRemovalsEntry as a2, type MaterializeRemovalsOptions as a3, type MaterializeRemovalsResult as a4, type NeighborsOptions as a5, type NodeAccessor as a6, type NodeAlias as a7, type NodeBulkFindByIndexOptions as a8, type NodeCollection as a9, type SearchableSchema as aA, type SelectContext as aB, type SelectableEdge as aC, type SelectableNode as aD, type ShortestPathOptions as aE, type ShortestPathResult as aF, type StoreHooks as aG, type StoreOptions as aH, type StoreProjection as aI, type StoreRef as aJ, StoreSearch as aK, type StreamOptions as aL, type SubgraphEdgeResult as aM, type SubgraphNodeResult as aN, type SubgraphOptions as aO, type SubgraphResult as aP, type SubsetEdge as aQ, type SubsetNode as aR, type TemporalAlgorithmOptions as aS, type TransactionContext as aT, type TraversalDirection as aU, type TypedEdgeCollection as aV, UnionableQuery as aW, type UpdateEdgeInput as aX, type UpdateNodeInput as aY, type VectorSearchHit as aZ, type VectorSearchOptions as a_, type NodeGetOrCreateByConstraintOptions as aa, type NodeGetOrCreateByConstraintResult as ab, type NodeIdentifier as ac, type NodeRef as ad, type OntologyIntrospection as ae, type OperationHookContext as af, type PaginateOptions as ag, type PaginatedResult as ah, type PathNode as ai, type Predicate as aj, PreparedQuery as ak, type PropsAccessor as al, type QueryHookContext as am, type QueryOptions as an, type ReachableNode as ao, type ReachableOptions as ap, type RebuildFulltextOptions as aq, type RebuildFulltextResult as ar, type ReclaimedVectorFieldEntry as as, type RecursiveTraversalOptions as at, type ReembedFunction as au, type ReembedVectorFieldOptions as av, type ReembedVectorFieldResult as aw, type SchemaIntrospection as ax, type SearchableMetadata as ay, type SearchableOptions as az, type EdgeAliasMap as b, createStoreWithSchema as b0, createVerifiedStore as b1, defineSubgraphProject as b2, embedding as b3, exists as b4, fieldRef as b5, getEmbeddingDimensions as b6, getSearchableMetadata as b7, inSubquery as b8, isEmbeddingSchema as b9, isParameterRef as ba, isSearchableSchema as bb, notExists as bc, notInSubquery as bd, param as be, searchable as bf, type AggregateResult as c, type AlgorithmCyclePolicy as d, type AnyEdge as e, type AnyNode as f, type BatchResults as g, type BatchableQuery as h, type ConstraintNames as i, type CreateEdgeInput as j, type CreateNodeInput as k, type DegreeOptions as l, type DynamicEdgeAccessor as m, type DynamicEdgeCollection as n, type DynamicEdgeType as o, type DynamicFieldBuilder as p, type DynamicNodeAccessor as q, type DynamicNodeCollection as r, type DynamicNodeType as s, type DynamicSelectableEdge as t, type DynamicSelectableNode as u, type Edge as v, type EdgeAccessor as w, type EdgeCollection as x, type EdgeFindByEndpointsOptions as y, type EdgeGetOrCreateByEndpointsOptions as z };
+/**
+ * StoreView — a read-only `(mode, asOf)` lens over a {@link Store}.
+ *
+ * A `StoreView` pins a temporal coordinate and routes every supported
+ * read through it, mirroring Datomic's `(d/as-of db t)` database value
+ * and SQL:2011 `FOR SYSTEM_TIME AS OF`. It is *read-only by
+ * construction*: mutating "the graph as of last Tuesday" is incoherent,
+ * so writes stay on the live `Store`.
+ *
+ * The view is an explicit read context, not a single default flip — the
+ * temporal seam is not uniform across surfaces (the query builder
+ * hardcodes `"current"`, `subgraph` reads `graph.defaults` directly,
+ * collections apply a per-call default). The view therefore injects its
+ * pinned {@link ReadCoordinate} into each surface it hands out through one
+ * helper ({@link withCoordinate}), so a future temporal axis (recorded
+ * time) lands on every surface at once instead of splitting by surface.
+ *
+ * Built on the public `Store` surface (plus one internal sealed-query
+ * seam), so it composes the same reads `branch()` / `merge()` consume.
+ */
+
+/**
+ * The temporal coordinate a {@link StoreView} pins. A discriminated union on
+ * `mode`: `asOf` is *required* for `"asOf"` and *rejected* (`never`) for every
+ * other mode, so the type mirrors the runtime contract. `view({ mode: "asOf" })`
+ * (missing timestamp) and `view({ mode: "current", asOf })` (pinning an instant
+ * outside `"asOf"`) are both compile errors, not merely runtime
+ * `ValidationError`s.
+ */
+type StoreViewCoordinate = Readonly<{
+    mode: "asOf";
+    asOf: string;
+}> | Readonly<{
+    mode: Exclude<TemporalMode, "asOf">;
+    asOf?: never;
+}>;
+/**
+ * {@link Store.subgraph} options with the temporal axis removed — the
+ * view's pinned coordinate supplies it.
+ */
+type StoreViewSubgraphOptions<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>, "temporalMode" | "asOf" | "recordedAsOf">;
+/** `reachable` options with the temporal axis removed (the pin supplies it). */
+type StoreViewReachableOptions<G extends GraphDef> = Omit<ReachableOptions<G>, keyof TemporalAlgorithmOptions>;
+/** `shortestPath` options with the temporal axis removed (the pin supplies it). */
+type StoreViewShortestPathOptions<G extends GraphDef> = Omit<ShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
+/** `canReach` options with the temporal axis removed (the pin supplies it). */
+type StoreViewCanReachOptions<G extends GraphDef> = Omit<BaseTraversalOptions<G>, keyof TemporalAlgorithmOptions>;
+/** `neighbors` options with the temporal axis removed (the pin supplies it). */
+type StoreViewNeighborsOptions<G extends GraphDef> = Omit<NeighborsOptions<G>, keyof TemporalAlgorithmOptions>;
+/** `degree` options with the temporal axis removed (the pin supplies it). */
+type StoreViewDegreeOptions<G extends GraphDef> = Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
+/**
+ * Shared base for the read-only views. Holds the pinned {@link ReadCoordinate}
+ * and delegates the graph algorithms, `subgraph`, and `query` to the live store
+ * with that coordinate flattened into each call. {@link StoreView} (valid-time)
+ * and {@link RecordedStoreView} (recorded-time) extend it; only the surfaces
+ * that genuinely differ — collections, search, and the coordinate-changing
+ * helpers — live on the subclasses.
+ */
+declare abstract class CoordinatePinnedView<G extends GraphDef> {
+    #private;
+    protected readonly store: Store<G>;
+    protected readonly coordinate: ReadCoordinate;
+    constructor(store: Store<G>, coordinate: ReadCoordinate);
+    /** The temporal mode this view reads in. */
+    get mode(): TemporalMode;
+    /** The pinned valid-time `asOf` timestamp, or `undefined` for other modes. */
+    get asOf(): string | undefined;
+    /**
+     * A query builder pinned to this view's coordinate. The temporal axis is
+     * sealed: calling `.temporal(...)` on the returned builder throws, so the
+     * view's coordinate cannot be overridden on a per-query basis.
+     */
+    query(): InitialQueryBuilder<G, "sealed">;
+    protected algorithms(): InternalGraphAlgorithms<G>;
+    /** Extracts a subgraph at this view's pinned coordinate. */
+    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: StoreViewSubgraphOptions<G, EK, NK, P>): Promise<SubgraphResult<G, NK, EK, P>>;
+    /** Shortest path between two nodes at this view's pinned coordinate. */
+    shortestPath(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>): Promise<ShortestPathResult | undefined>;
+    /** Nodes reachable from `from` at this view's pinned coordinate. */
+    reachable(from: NodeIdentifier, options: StoreViewReachableOptions<G>): Promise<readonly ReachableNode[]>;
+    /** Whether `to` is reachable from `from` at this view's pinned coordinate. */
+    canReach(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewCanReachOptions<G>): Promise<boolean>;
+    /** The k-hop neighborhood of `node` at this view's pinned coordinate. */
+    neighbors(node: NodeIdentifier, options: StoreViewNeighborsOptions<G>): Promise<readonly ReachableNode[]>;
+    /** Counts active edges incident to `node` at this view's pinned coordinate. */
+    degree(node: NodeIdentifier, options?: StoreViewDegreeOptions<G>): Promise<number>;
+}
+/**
+ * A read-only `(mode, asOf)` lens over a {@link Store}. Construct one via
+ * {@link Store.asOf} (valid-time) or {@link Store.view} (any public
+ * mode), never directly.
+ *
+ * @example
+ * ```typescript
+ * const past = store.asOf("2026-01-01T00:00:00.000Z");
+ * const alice = await past.nodes.Person.getById(aliceId);
+ * const jobs = await past.edges.worksAt.findFrom(alice!);
+ * const reach = await past.reachable(alice!, { edges: ["knows"] });
+ * ```
+ */
+declare class StoreView<G extends GraphDef> extends CoordinatePinnedView<G> {
+    #private;
+    constructor(store: Store<G>, coordinate: StoreViewCoordinate | ReadCoordinate);
+    /** Adds a recorded-time pin, returning the narrow reconstructing view. */
+    asOfRecorded(recordedAsOf: RecordedInstant): RecordedStoreView<G>;
+    /** Read-only node collections pinned to this view's coordinate. */
+    get nodes(): StoreViewNodeCollections<G>;
+    /** Read-only edge collections pinned to this view's coordinate. */
+    get edges(): StoreViewEdgeCollections<G>;
+    /**
+     * Read-only search facade. On a `current` view the read methods
+     * (`fulltext` / `vector` / `hybrid`) delegate to the live `store.search`,
+     * while the mutating `rebuildFulltext` is refused — the view is read-only.
+     * On any non-`current` pin every search method refuses: the fulltext /
+     * vector index reflects current state only, so historical relevance is
+     * out of scope.
+     */
+    get search(): StoreSearch<G>;
+}
+/**
+ * A narrow recorded-time read lens. It preserves the valid-time coordinate
+ * carried by the source view and adds a recorded/system-time pin. Collection
+ * reads are intentionally limited to point reconstruction; broad collection
+ * predicates, endpoint reads, search, and further coordinate changes are absent
+ * from the typed surface and refused by the runtime proxies for JS callers.
+ */
+declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView<G> {
+    #private;
+    constructor(store: Store<G>, coordinate: ReadCoordinate);
+    /** The recorded/system-time timestamp this view reconstructs. */
+    get asOfRecorded(): string;
+    /** Recorded-time node point-read collections. */
+    get nodes(): RecordedStoreViewNodeCollections<G>;
+    /** Recorded-time edge point-read collections. */
+    get edges(): RecordedStoreViewEdgeCollections<G>;
+}
+
+export { type GraphAlgorithms as $, type AliasMap as A, type BaseTraversalOptions as B, type ConstraintNames as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EmbeddingMetric as E, type EdgeFindByEndpointsOptions as F, type EdgeGetOrCreateByEndpointsOptions as G, type EdgeGetOrCreateByEndpointsResult as H, type EdgeIntrospection as I, type EdgeTemporalReads as J, type EdgeWrites as K, type EmbeddingSchema as L, type EmbeddingValue as M, type Node as N, type EmptyAliasMap as O, type EmptyEdgeAliasMap as P, type QueryCoordinateState as Q, type RecursiveAliasMap as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, ExecutableAggregateQuery as V, ExecutableQuery as W, type FieldAccessor as X, type FulltextSearchHit as Y, type FulltextSearchOptions as Z, type GetOrCreateAction as _, type EmbeddingIndexType as a, type SelectableEdge as a$, type GraphEdgeCollections as a0, type GraphNodeCollections as a1, type HistorySafeBackend as a2, type HistorySafeTransactionBackend as a3, type HistoryStore as a4, type HistoryStoreOptions as a5, type HistoryTransactionContext as a6, type HookContext as a7, type HybridFulltextOptions as a8, type HybridSearchHit as a9, type PathNode as aA, type Predicate as aB, PreparedQuery as aC, type PropsAccessor as aD, type QueryHookContext as aE, type QueryOptions as aF, type ReachableNode as aG, type ReachableOptions as aH, type RebuildFulltextOptions as aI, type RebuildFulltextResult as aJ, type ReclaimedVectorFieldEntry as aK, type RecordedInstant as aL, type RecordedReadStore as aM, RecordedStoreView as aN, type RecordedStoreViewEdgeCollection as aO, type RecordedStoreViewEdgeCollections as aP, type RecordedStoreViewNodeCollection as aQ, type RecordedStoreViewNodeCollections as aR, type RecursiveTraversalOptions as aS, type ReembedFunction as aT, type ReembedVectorFieldOptions as aU, type ReembedVectorFieldResult as aV, type SchemaIntrospection as aW, type SearchableMetadata as aX, type SearchableOptions as aY, type SearchableSchema as aZ, type SelectContext as a_, type HybridSearchOptions as aa, type HybridVectorOptions as ab, type IfExistsMode as ac, type InitialQueryBuilder as ad, type KindIntrospection as ae, type LiveStoreOptions as af, type MaterializeRemovalsEntry as ag, type MaterializeRemovalsOptions as ah, type MaterializeRemovalsResult as ai, type NeighborsOptions as aj, type NoRecordedCoordinate as ak, type NodeAccessor as al, type NodeAlias as am, type NodeBulkFindByIndexOptions as an, type NodeCollection as ao, type NodeCurrentReads as ap, type NodeGetOrCreateByConstraintOptions as aq, type NodeGetOrCreateByConstraintResult as ar, type NodeIdentifier as as, type NodeRef as at, type NodeTemporalReads as au, type NodeWrites as av, type OntologyIntrospection as aw, type OperationHookContext as ax, type PaginateOptions as ay, type PaginatedResult as az, type EdgeAliasMap as b, type SelectableNode as b0, type ShortestPathOptions as b1, type ShortestPathResult as b2, type StoreHooks as b3, type StoreOptions as b4, type StoreProjection as b5, type StoreRef as b6, StoreSearch as b7, StoreView as b8, type StoreViewCanReachOptions as b9, type VectorSearchHit as bA, type VectorSearchOptions as bB, asRecordedInstant as bC, createQueryBuilder as bD, createStore as bE, createStoreWithSchema as bF, createVerifiedStore as bG, defineSubgraphProject as bH, embedding as bI, exists as bJ, fieldRef as bK, getEmbeddingDimensions as bL, getSearchableMetadata as bM, inSubquery as bN, isEmbeddingSchema as bO, isParameterRef as bP, isSearchableSchema as bQ, notExists as bR, notInSubquery as bS, param as bT, searchable as bU, type StoreViewCoordinate as ba, type StoreViewDegreeOptions as bb, type StoreViewEdgeCollection as bc, type StoreViewEdgeCollections as bd, type StoreViewNeighborsOptions as be, type StoreViewNodeCollection as bf, type StoreViewNodeCollections as bg, type StoreViewReachableOptions as bh, type StoreViewShortestPathOptions as bi, type StoreViewSubgraphOptions as bj, type StreamOptions as bk, type SubgraphEdgeResult as bl, type SubgraphNodeResult as bm, type SubgraphOptions as bn, type SubgraphResult as bo, type SubsetEdge as bp, type SubsetNode as bq, type TemporalAlgorithmOptions as br, type TransactionContext as bs, type TraversalDirection as bt, type TypedEdgeCollection as bu, type TypedRecordedStoreViewEdgeCollection as bv, type TypedStoreViewEdgeCollection as bw, UnionableQuery as bx, type UpdateEdgeInput as by, type UpdateNodeInput as bz, QueryBuilder as c, type EmptyRecursiveAliasMap as d, type AggregateResult as e, type AlgorithmCyclePolicy as f, type AnyEdge as g, type AnyNode as h, type BatchResults as i, type BatchableQuery as j, type CreateEdgeInput as k, type CreateNodeInput as l, type DegreeOptions as m, type DynamicEdgeAccessor as n, type DynamicEdgeCollection as o, type DynamicEdgeType as p, type DynamicFieldBuilder as q, type DynamicNodeAccessor as r, type DynamicNodeCollection as s, type DynamicNodeType as t, type DynamicSelectableEdge as u, type DynamicSelectableNode as v, type Edge as w, type EdgeAccessor as x, type EdgeBatchReads as y, type EdgeCollection as z };