@nicia-ai/typegraph 0.30.0 → 0.32.0

package/dist/{store--z1Tmk7U.d.cts → store-view-pBOUrQte.d.ts}

@@ -1,9 +1,9 @@
+import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-8htmuGr-.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, n as EndpointExistence, f as KindAnnotations, U as UniquenessScope, C as Collation, G as GraphExtension } from './extension-types-D1k0inWU.js';
 import { z } from 'zod';
-import { p as SqlDialect, ai as SqlSchema, F as FulltextStrategy, V as VectorStrategy, aA as VectorSlotMap, aB as ValueType, aC as PredicateExpression, aD 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, aE as Traversal, aF as NodePredicate, aG as ProjectedField, ac as OrderSpec, aH as GroupBySpec, a4 as HybridFusionOptions, aI as RecursiveCyclePolicy, aJ as TraversalDirection$1, aK as EdgeRow, aL as NodeRow, W as AdoptedTransaction, L as AggregateExpr, aM as SelectiveField, aN as ComposableQuery, aO as SetOperationType, aP as SetOperation, ah as SortDirection, m as JsonSchema, aQ as VectorMetric } from './types-dL-clxO3.cjs';
-import { K as KindRegistry, G as GraphDef, u as EdgeKinds, x as NodeKinds, t as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-wTDgjoXG.cjs';
-import { A as AnyEdgeType, N as NodeType, T as TemporalMode, d as EdgeType, E as EdgeRegistration, i as EdgeId, m as NodeId, b as NodeRegistration, K as KindEntity, f as Cardinality, g as EndpointExistence, e as KindAnnotations, U as UniquenessScope, C as Collation, G as GraphExtension } from './extension-types-CwHV-Uk4.cjs';
+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-Dk8r09KY.js';
 import { SQL } from 'drizzle-orm';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-oanE3RU0.cjs';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-CAGhqPHQ.js';
 
 /**
  * Embedding type for vector search.
@@ -217,47 +217,22 @@ declare function isSearchableSchema(value: unknown): value is SearchableSchema;
 declare function getSearchableMetadata(schema: z.ZodType): SearchableMetadata | undefined;
 
 /**
- * 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.
+ * 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.
  */
-type CompileQueryOptions = Readonly<{
-    /** SQL dialect ("sqlite" or "postgres"). Defaults to "sqlite". */
-    dialect?: SqlDialect | undefined;
-    /** SQL schema configuration for table names. Defaults to standard names. */
-    schema?: SqlSchema | undefined;
-    /**
-     * Fulltext strategy override. When set, overrides the dialect's
-     * default fulltext strategy for `$fulltext.matches()` compilation.
-     * Callers typically read this from `backend.fulltextStrategy` so a
-     * backend-declared strategy (e.g. ParadeDB) wins over the dialect
-     * default (tsvector).
-     */
-    fulltextStrategy?: FulltextStrategy | undefined;
-    /**
-     * Vector strategy override. When set, `field.similarTo(...)`
-     * predicates compile against the strategy's per-`(kind, field)`
-     * tables and distance expression. Callers read it from
-     * `backend.vectorStrategy` so a backend-declared strategy (pgvector,
-     * libsql-native, sqlite-vec) drives the per-field relevance scan.
-     */
-    vectorStrategy?: VectorStrategy | undefined;
-    /**
-     * Whether the active backend supports SQL window functions such as
-     * `ROW_NUMBER()`. Defaults to true for direct compiler callers.
-     */
-    windowFunctions?: boolean | undefined;
+type ReadCoordinate = Readonly<{
     /**
-     * Declared embedding slots `(kind, fieldPath) -> descriptor` used by
-     * the `field.similarTo(...)` CTE to know which kinds in an alias
-     * declare the field. Callers build it from the graph's node schemas.
+     * The valid-time axis: a resolved temporal mode and (only for `"asOf"`) the
+     * instant it is pinned to.
      */
-    vectorSlots?: VectorSlotMap | undefined;
+    valid: Readonly<{
+        mode: TemporalMode;
+        /** Defined only when `mode` is `"asOf"`. */
+        asOf?: string;
+    }>;
 }>;
 
 type FieldTypeInfo = Readonly<{
@@ -887,6 +862,12 @@ type QueryBuilderConfig = Readonly<{
     dialect?: SqlDialect;
     /** SQL schema configuration 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.
@@ -929,6 +910,12 @@ type CreateQueryBuilderOptions = Readonly<{
     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;
 }>;
 
 /**
@@ -1218,7 +1205,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. */
@@ -1276,15 +1263,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.
      *
@@ -1495,29 +1480,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>;
     /**
@@ -1531,21 +1530,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.
      *
@@ -1597,16 +1592,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.
      *
@@ -1663,6 +1664,104 @@ 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>, "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"];
+/**
+ * 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>, "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">;
+/**
+ * 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">;
+/** 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">;
+/**
+ * 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]>;
+};
 /**
  * A typed transaction context with collection API.
  *
@@ -1717,6 +1816,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
@@ -1802,253 +1908,99 @@ 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(): SQL;
     /**
-     * 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.
+ * Options for query compilation.
  */
-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>;
+type CompileQueryOptions = Readonly<{
+    /** SQL dialect ("sqlite" or "postgres"). Defaults to "sqlite". */
+    dialect?: SqlDialect | undefined;
+    /** SQL schema configuration for table names. Defaults to standard names. */
+    schema?: SqlSchema | undefined;
     /**
-     * Offsets the results.
+     * Fulltext strategy override. When set, overrides the dialect's
+     * default fulltext strategy for `$fulltext.matches()` compilation.
+     * Callers typically read this from `backend.fulltextStrategy` so a
+     * backend-declared strategy (e.g. ParadeDB) wins over the dialect
+     * default (tsvector).
      */
-    offset(n: number): ExecutableAggregateQuery<G, Aliases, R>;
+    fulltextStrategy?: FulltextStrategy | undefined;
     /**
-     * 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.
+     * Vector strategy override. When set, `field.similarTo(...)`
+     * predicates compile against the strategy's per-`(kind, field)`
+     * tables and distance expression. Callers read it from
+     * `backend.vectorStrategy` so a backend-declared strategy (pgvector,
+     * libsql-native, sqlite-vec) drives the per-field relevance scan.
      */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
+    vectorStrategy?: VectorStrategy | undefined;
     /**
-     * Compiles the query to a Drizzle SQL object.
+     * Whether the active backend supports SQL window functions such as
+     * `ROW_NUMBER()`. Defaults to true for direct compiler callers.
      */
-    compile(): SQL;
+    windowFunctions?: boolean | undefined;
     /**
-     * Executes the query and returns typed results.
-     *
-     * @throws Error if no backend is configured
+     * Declared embedding slots `(kind, fieldPath) -> descriptor` used by
+     * the `field.similarTo(...)` CTE to know which kinds in an alias
+     * declare the field. Callers build it from the graph's node schemas.
      */
-    execute(): Promise<readonly AggregateResult<R>[]>;
-}
+    vectorSlots?: VectorSlotMap | undefined;
+}>;
 
 type PreparedQueryConfig<R> = Readonly<{
     ast: QueryAst;
@@ -2543,8 +2495,12 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      * 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
+     * @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>;
     /**
@@ -2652,15 +2608,16 @@ 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<{
     /** 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;
 }>;
@@ -2813,81 +2770,6 @@ 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 RebuildFulltextOptions = Readonly<{
     /** Page size. Must be a positive integer. Default: 500. */
     pageSize?: number;
@@ -3174,6 +3056,279 @@ declare class StoreSearch<G extends GraphDef> {
     rebuildFulltext<K extends string>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
 }
 
+/**
+ * `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;
+}>;
+
+/**
+ * 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[];
+    /** 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;
+    /**
+     * 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;
+}>;
+/**
+ * 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.
  *
@@ -3400,6 +3555,69 @@ declare class Store<G extends GraphDef> {
      * ```
      */
     query(): QueryBuilder<G>;
+    /**
+     * 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>;
+    /**
+     * 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 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).
      *
@@ -3546,8 +3764,14 @@ 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.
      */
-    transaction<T>(fn: (tx: TransactionContext<G>) => Promise<T>): 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
@@ -3952,4 +4176,108 @@ declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: Gr
  */
 declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions): Promise<[Store<G>, SchemaValidationResult]>;
 
-export { type KindIntrospection 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 FulltextSearchOptions as N, type GetOrCreateAction as O, type GraphAlgorithms as P, QueryBuilder as Q, type GraphEdgeCollections as R, Store as S, TraversalBuilder as T, type GraphNodeCollections as U, type HookContext as V, type HybridFulltextOptions as W, type HybridSearchHit as X, type HybridSearchOptions as Y, type HybridVectorOptions as Z, type IfExistsMode as _, type EmbeddingIndexType as a, createStore as a$, type MaterializeRemovalsEntry as a0, type MaterializeRemovalsOptions as a1, type MaterializeRemovalsResult as a2, type NeighborsOptions as a3, type Node as a4, type NodeAccessor as a5, type NodeAlias as a6, type NodeBulkFindByIndexOptions as a7, type NodeCollection as a8, type NodeGetOrCreateByConstraintOptions as a9, type SelectContext as aA, type SelectableEdge as aB, type SelectableNode as aC, type ShortestPathOptions as aD, type ShortestPathResult as aE, type StoreHooks as aF, type StoreOptions as aG, type StoreProjection as aH, type StoreRef as aI, StoreSearch as aJ, type StreamOptions as aK, type SubgraphEdgeResult as aL, type SubgraphNodeResult as aM, type SubgraphOptions as aN, type SubgraphResult as aO, type SubsetEdge as aP, type SubsetNode as aQ, type TemporalAlgorithmOptions as aR, type TransactionContext as aS, type TraversalDirection as aT, type TypedEdgeCollection as aU, UnionableQuery as aV, type UniqueIntrospection as aW, type UpdateEdgeInput as aX, type UpdateNodeInput as aY, type VectorSearchHit as aZ, type VectorSearchOptions as a_, type NodeGetOrCreateByConstraintResult as aa, type NodeIdentifier as ab, type NodeRef as ac, type OntologyIntrospection as ad, type OperationHookContext as ae, type PaginateOptions as af, type PaginatedResult as ag, type PathNode as ah, type Predicate as ai, PreparedQuery as aj, type PropsAccessor as ak, type QueryHookContext as al, type QueryOptions as am, type ReachableNode as an, type ReachableOptions as ao, type RebuildFulltextOptions as ap, type RebuildFulltextResult as aq, type ReclaimedVectorFieldEntry 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 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">;
+/** `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>;
+/**
+ * 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> {
+    #private;
+    constructor(store: Store<G>, coordinate: StoreViewCoordinate);
+    /** The temporal mode this view reads in. */
+    get mode(): TemporalMode;
+    /** The pinned `asOf` timestamp, or `undefined` for non-`asOf` 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>;
+    /** 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>;
+    /**
+     * 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>;
+}
+
+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 };