@nicia-ai/typegraph 0.32.0 → 0.34.0

package/dist/{store-view-lTcb_cnp.d.cts → store-view-D09po4H6.d.cts}

@@ -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-aVgxbGt-.cjs';
-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, n as EndpointExistence, f as KindAnnotations, U as UniquenessScope, C as Collation, G as GraphExtension } from './extension-types-D1k0inWU.cjs';
+import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-ms9cKdc6.cjs';
+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.cjs';
 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, aQ as VectorMetric, m as JsonSchema, aR as TransactionOptions } from './types-Dvmn-eal.cjs';
-import { SQL } from 'drizzle-orm';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-DEYkU-wr.cjs';
+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-DkNnF-7K.cjs';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-D20xNluI.cjs';
 
 /**
  * Embedding type for vector search.
@@ -216,12 +215,43 @@ 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. Today it carries only the valid-time axis; Unit 2 adds a sibling
- * `recorded` axis here, and because every surface injects the coordinate
- * through one helper ({@link withCoordinate}), a new axis lands on all
- * surfaces at once instead of splitting by surface.
+ * 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<{
     /**
@@ -233,6 +263,10 @@ type ReadCoordinate = Readonly<{
         /** 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<{
@@ -517,6 +551,7 @@ type DynamicSelectableEdge = Readonly<{
  * and ExecutableQuery classes.
  */
 
+type QueryCoordinateState = "open" | "sealed";
 /**
  * A query that can be executed within a `store.batch()` call.
  *
@@ -559,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.
  */
@@ -571,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).
  */
@@ -581,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.
  */
@@ -860,14 +898,8 @@ 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;
-    /**
-     * When set, the builder is pinned to a {@link StoreView}'s coordinate and
-     * its temporal axis is sealed: `.temporal(...)` throws. Threaded verbatim
-     * through every builder clone, so the seal survives the whole fluent chain.
-     */
-    sealedCoordinate?: ReadCoordinate;
 }>;
 /**
  * Internal state of the query builder.
@@ -886,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;
@@ -906,18 +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;
-    /**
-     * Pin the builder to a {@link StoreView} coordinate and seal its temporal
-     * axis. Seeds the initial `temporalMode` / `asOf` and makes `.temporal(...)`
-     * throw. Used by `store.view(...).query()`.
-     */
-    sealedCoordinate?: ReadCoordinate;
 }>;
 
+/**
+ * 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.
  */
@@ -1034,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 */
@@ -1107,20 +1173,30 @@ type StoreHooks = Readonly<{
     }>) => void;
     /** Called before a CRUD operation starts */
     onOperationStart?: (ctx: OperationHookContext) => void;
-    /** Called after a CRUD operation completes */
+    /**
+     * Called after a CRUD operation completes AND is durably committed. For a
+     * top-level operation that is when its own transaction commits; for an
+     * operation inside `store.transaction`, emission is deferred until the
+     * enclosing transaction commits — if that commit fails, the operation is
+     * reported through `onError` instead. (Inside an adopted transaction —
+     * `withTransaction` / `withRecordedTransaction` — the commit belongs to
+     * the caller and cannot be observed, so this fires when the operation
+     * completes within the still-open transaction.)
+     */
     onOperationEnd?: (ctx: OperationHookContext, result: Readonly<{
         durationMs: number;
     }>) => void;
-    /** Called when an error occurs */
+    /**
+     * Called when an operation fails — including an operation that completed
+     * inside a `store.transaction` whose commit then failed and rolled it
+     * back.
+     */
     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<{
@@ -1128,6 +1204,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
@@ -1665,15 +1763,7 @@ 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>, "getById" | "getByIds" | "find" | "count">;
-/**
- * The method names of the current-state-only node reads (constraint / index
- * lookups). Single source of truth: {@link NodeCurrentReads} (the type) and the
- * `StoreView`'s runtime routing Set are both derived from this array, so adding
- * a current-only read here updates both at once — a new read cannot pass the
- * type partition yet be misrouted at runtime (refused as a write).
- */
-declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindByConstraint", "bulkFindByIndex"];
+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
@@ -1681,21 +1771,16 @@ declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindBy
  */
 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>, "create" | "createFromRecord" | "update" | "delete" | "hardDelete" | "upsertById" | "upsertByIdFromRecord" | "bulkCreate" | "bulkUpsertById" | "bulkInsert" | "bulkDelete" | "getOrCreateByConstraint" | "bulkGetOrCreateByConstraint">;
-/**
- * Temporal-aware edge reads — a {@link StoreView} pins these. Unlike the node
- * collection, edges have no current-state-only reads: `findByEndpoints` honors
- * the temporal coordinate like `findFrom` / `findTo`, so every edge read is
- * pinnable.
- */
-type EdgeTemporalReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, "getById" | "getByIds" | "find" | "count" | "findFrom" | "findTo" | "findByEndpoints">;
+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>, "batchFindFrom" | "batchFindTo" | "batchFindByEndpoints">;
+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>, "create" | "update" | "delete" | "hardDelete" | "bulkCreate" | "bulkUpsertById" | "bulkInsert" | "bulkDelete" | "getOrCreateByEndpoints" | "bulkGetOrCreateByEndpoints">;
+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
@@ -1762,6 +1847,20 @@ type StoreViewNodeCollections<G extends GraphDef> = {
 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.
  *
@@ -1803,6 +1902,12 @@ type StoreViewEdgeCollections<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) => {
@@ -1823,6 +1928,21 @@ type TransactionContext<G extends GraphDef> = Readonly<{
      * is the store's plain backend — reads work, but there is no snapshot.
      */
     backend: TransactionBackend;
+    /**
+     * Runtime string-keyed node collection access, mirroring
+     * `Store.getNodeCollection` — for callers (e.g. provenance) that resolve a
+     * kind dynamically rather than through the static `nodes.<Kind>` property.
+     * Returns `undefined` when `kind` is not registered in this graph.
+     */
+    getNodeCollection(kind: string): DynamicNodeCollection | undefined;
+    /**
+     * @internal Runs a graph-owned node mutation through this transaction's
+     * operation-hook lifecycle when the mutation cannot use a public collection
+     * verb directly (provenance fact close/reopen). Routed through the
+     * transaction's hook runner, so a successful operation's `onOperationEnd`
+     * is deferred until the transaction commits.
+     */
+    runNodeOperationHooks<T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>): Promise<T>;
 }>;
 /**
  * Replace branded `NodeId` / `EdgeId` with plain `string` in each
@@ -1949,7 +2069,7 @@ declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends Alias
     /**
      * Compiles the query to a Drizzle SQL object.
      */
-    compile(): SQL;
+    compile(): CompiledSelectSql;
     /**
      * Executes the query and returns typed results.
      *
@@ -1971,7 +2091,7 @@ declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends Alias
 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
@@ -2000,6 +2120,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<{
@@ -2116,7 +2243,7 @@ declare class UnionableQuery<G extends GraphDef, R> {
     /**
      * Compiles the set operation to SQL.
      */
-    compile(): SQL;
+    compile(): CompiledSelectSql;
     /**
      * Executes the combined query.
      */
@@ -2208,7 +2335,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.
@@ -2307,7 +2434,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[]);
     /**
@@ -2319,14 +2446,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.
      *
@@ -2339,23 +2466,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.
  *
@@ -2364,8 +2492,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.
@@ -2375,10 +2504,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
@@ -2386,18 +2515,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).
      *
@@ -2411,7 +2540,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).
      *
@@ -2426,7 +2555,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.
@@ -2435,7 +2564,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.
@@ -2451,12 +2580,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
@@ -2467,7 +2596,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.
      */
@@ -2482,27 +2611,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).
-     *   Rejected for every other mode — pinning an instant is only meaningful
-     *   in "asOf" mode, so `temporal("current", t)` is a caller error, not a
-     *   silently-dropped argument.
-     * @throws ValidationError if mode is "asOf" but no timestamp is provided, or
-     *   if an asOf is supplied with a non-"asOf" mode.
-     */
-    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().
@@ -2510,21 +2627,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.
      *
@@ -2548,7 +2665,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.
      *
@@ -2574,9 +2691,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.
  *
@@ -2612,7 +2742,7 @@ type AlgorithmCyclePolicy = RecursiveCyclePolicy;
  * 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;
     /**
@@ -2621,6 +2751,9 @@ type TemporalAlgorithmOptions = Readonly<{
      */
     asOf?: string;
 }>;
+type InternalTemporalAlgorithmOptions = Omit<TemporalAlgorithmOptions, "recordedAsOf"> & Readonly<{
+    recordedAsOf?: RecordedInstant;
+}>;
 /**
  * Base options for traversal-style algorithms.
  */
@@ -2637,6 +2770,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.
@@ -2669,6 +2803,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`.
  *
@@ -2680,6 +2815,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`.
  *
@@ -2697,6 +2833,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`.
  *
@@ -2712,6 +2849,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`,
@@ -2769,6 +2907,13 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      */
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
 }>;
+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<{
     /** Page size. Must be a positive integer. Default: 500. */
@@ -3131,17 +3276,6 @@ type UniqueIntrospection = Readonly<{
     collation: Collation;
 }>;
 
-/**
- * Data-cleanup phase for `store.removeKinds()`.
- *
- * 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.
- */
-
 type MaterializeRemovalsOptions = Readonly<{
     /** Restrict to specific kind names. */
     kinds?: readonly string[];
@@ -3295,6 +3429,8 @@ type SubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends Nod
     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.
      *
@@ -3307,6 +3443,16 @@ type SubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends Nod
      */
     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.
  */
@@ -3414,6 +3560,18 @@ declare class Store<G extends GraphDef> {
     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.
      *
@@ -3554,14 +3712,43 @@ 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): QueryBuilder<G>;
+    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.
      *
@@ -3585,6 +3772,47 @@ declare class Store<G extends GraphDef> {
      * @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;
@@ -3714,6 +3942,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.
      *
@@ -3726,6 +3969,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
@@ -3769,8 +4016,11 @@ declare class Store<G extends GraphDef> {
      * @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.
+     *   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>(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
@@ -3814,9 +4064,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
@@ -3828,6 +4087,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.
      *
@@ -4073,6 +4346,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.
  *
@@ -4102,6 +4398,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>;
 
 /**
@@ -4132,6 +4430,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
@@ -4174,6 +4474,8 @@ 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]>;
 
 /**
@@ -4216,7 +4518,7 @@ type StoreViewCoordinate = Readonly<{
  * {@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">;
+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). */
@@ -4228,35 +4530,29 @@ type StoreViewNeighborsOptions<G extends GraphDef> = Omit<NeighborsOptions<G>, k
 /** `degree` options with the temporal axis removed (the pin supplies it). */
 type StoreViewDegreeOptions<G extends GraphDef> = Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
 /**
- * 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"] });
- * ```
+ * 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 class StoreView<G extends GraphDef> {
+declare abstract class CoordinatePinnedView<G extends GraphDef> {
     #private;
-    constructor(store: Store<G>, coordinate: StoreViewCoordinate);
+    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 `asOf` timestamp, or `undefined` for non-`asOf` modes. */
+    /** The pinned valid-time `asOf` timestamp, or `undefined` for other modes. */
     get asOf(): string | undefined;
-    /** 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>;
     /**
      * 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(): QueryBuilder<G>;
+    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. */
@@ -4269,6 +4565,29 @@ declare class StoreView<G extends GraphDef> {
     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`,
@@ -4279,5 +4598,22 @@ declare class StoreView<G extends GraphDef> {
      */
     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 HybridFulltextOptions as $, type AliasMap as A, type BaseTraversalOptions as B, type CreateQueryBuilderOptions as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EmbeddingMetric as E, type EdgeGetOrCreateByEndpointsOptions as F, type EdgeGetOrCreateByEndpointsResult as G, type EdgeIntrospection as H, type EdgeTemporalReads as I, type EdgeWrites as J, type EmbeddingSchema as K, type EmbeddingValue as L, ExecutableAggregateQuery as M, type Node as N, ExecutableQuery as O, type FieldAccessor as P, QueryBuilder as Q, type FulltextSearchHit as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, type FulltextSearchOptions as V, type GetOrCreateAction as W, type GraphAlgorithms as X, type GraphEdgeCollections as Y, type GraphNodeCollections as Z, type HookContext as _, type EmbeddingIndexType as a, type StoreViewShortestPathOptions as a$, type HybridSearchHit as a0, type HybridSearchOptions as a1, type HybridVectorOptions as a2, type IfExistsMode as a3, type KindIntrospection as a4, type MaterializeRemovalsEntry as a5, type MaterializeRemovalsOptions as a6, type MaterializeRemovalsResult as a7, type NeighborsOptions as a8, type NodeAccessor as a9, type ReembedFunction as aA, type ReembedVectorFieldOptions as aB, type ReembedVectorFieldResult as aC, type SchemaIntrospection as aD, type SearchableMetadata as aE, type SearchableOptions as aF, type SearchableSchema as aG, type SelectContext as aH, type SelectableEdge as aI, type SelectableNode as aJ, type ShortestPathOptions as aK, type ShortestPathResult as aL, type StoreHooks as aM, type StoreOptions as aN, type StoreProjection as aO, type StoreRef as aP, StoreSearch as aQ, StoreView as aR, type StoreViewCanReachOptions as aS, type StoreViewCoordinate as aT, type StoreViewDegreeOptions as aU, type StoreViewEdgeCollection as aV, type StoreViewEdgeCollections as aW, type StoreViewNeighborsOptions as aX, type StoreViewNodeCollection as aY, type StoreViewNodeCollections as aZ, type StoreViewReachableOptions as a_, type NodeAlias as aa, type NodeBulkFindByIndexOptions as ab, type NodeCollection as ac, type NodeCurrentReads as ad, type NodeGetOrCreateByConstraintOptions as ae, type NodeGetOrCreateByConstraintResult as af, type NodeIdentifier as ag, type NodeRef as ah, type NodeTemporalReads as ai, type NodeWrites as aj, type OntologyIntrospection as ak, type OperationHookContext as al, type PaginateOptions as am, type PaginatedResult as an, type PathNode as ao, type Predicate as ap, PreparedQuery as aq, type PropsAccessor as ar, type QueryHookContext as as, type QueryOptions as at, type ReachableNode as au, type ReachableOptions as av, type RebuildFulltextOptions as aw, type RebuildFulltextResult as ax, type ReclaimedVectorFieldEntry as ay, type RecursiveTraversalOptions as az, type EdgeAliasMap as b, type StoreViewSubgraphOptions as b0, type StreamOptions as b1, type SubgraphEdgeResult as b2, type SubgraphNodeResult as b3, type SubgraphOptions as b4, type SubgraphResult as b5, type SubsetEdge as b6, type SubsetNode as b7, type TemporalAlgorithmOptions as b8, type TransactionContext as b9, type TraversalDirection as ba, type TypedEdgeCollection as bb, type TypedStoreViewEdgeCollection as bc, UnionableQuery as bd, type UpdateEdgeInput as be, type UpdateNodeInput as bf, type VectorSearchHit as bg, type VectorSearchOptions as bh, createStore as bi, createStoreWithSchema as bj, createVerifiedStore as bk, defineSubgraphProject as bl, embedding as bm, exists as bn, fieldRef as bo, getEmbeddingDimensions as bp, getSearchableMetadata as bq, inSubquery as br, isEmbeddingSchema as bs, isParameterRef as bt, isSearchableSchema as bu, notExists as bv, notInSubquery as bw, param as bx, searchable as by, 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 EdgeBatchReads as x, type EdgeCollection as y, type EdgeFindByEndpointsOptions as z };
+export { type GetOrCreateAction 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 HistoryStore as H, type EdgeGetOrCreateByEndpointsResult as I, type EdgeIntrospection as J, type EdgeTemporalReads as K, type EdgeWrites as L, type EmbeddingSchema as M, type Node as N, type EmbeddingValue as O, type EmptyAliasMap as P, type QueryCoordinateState as Q, type RecursiveAliasMap as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, type EmptyEdgeAliasMap as V, ExecutableAggregateQuery as W, ExecutableQuery as X, type FieldAccessor as Y, type FulltextSearchHit as Z, type FulltextSearchOptions as _, type EmbeddingIndexType as a, type SelectableEdge as a$, type GraphAlgorithms as a0, type GraphEdgeCollections as a1, type GraphNodeCollections as a2, type HistorySafeBackend as a3, type HistorySafeTransactionBackend 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 };