@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/{store-view-A85FFRnk.d.cts → store-B0h6x7wo.d.cts}

@@ -1,10 +1,9 @@
-import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-alREY2wj.cjs';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-BNbjXqer.cjs';
-import { cb as ValueType, cc as PredicateExpression, aC as FulltextQueryMode, cd as VectorMetricType, Q as QueryAst, J as JsonPointer, a4 as FieldRef, b3 as ParameterRef, d as NodeType, e as AnyEdgeType, a2 as EdgeType, bB as TraversalExpansion, z as GraphBackend, S as SqlDialect, bs as SqlSchema, ce as Traversal, cf as NodePredicate, cg as ProjectedField, b2 as OrderSpec, ch as AggregateOrderSpec, T as TemporalMode, ci as GroupBySpec, aL as HybridFusionOptions, aP as JsonPointerInput, cj as RecursiveCyclePolicy, a7 as TraversalDirection$1, E as EdgeRegistration, b0 as NodeId, by as TransactionBackend, a3 as AggregateExpr, bl as SortDirection, ak as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, ck as VectorSlotMap, cl as RecordedReadBinding, cm as SelectiveField, cn as ComposableQuery, co as SetOperationType, cp as SetOperation, K as KindEntity, av as ExternalRecordedReadSource, cq as NodeRow, ar as EdgeId, cr as EdgeRow, N as NodeRegistration, bA as TransactionReadBackend, cs as VectorMetric, aU as KindAnnotations, _ as JsonSchema, bG as UniquenessScope, af as Collation, ae as Cardinality, au as EndpointExistence, G as GraphExtension, B as BackendCapabilities, C as ContributionDiagnostic, c as ContributionRepairResult, bz as TransactionOptions, A as AdapterBackend } from './types-Ch9a0Dx6.cjs';
-import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-KS7CGQQT.cjs';
 import { z } from 'zod';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-CIZL8Hyw.cjs';
-import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-OHRWypW6.cjs';
+import { cw as ValueType, cx as PredicateExpression, aY as FulltextQueryMode, cy as VectorMetricType, Q as QueryAst, J as JsonPointer, ad as FieldRef, bo as ParameterRef, u as NodeType, v as AnyEdgeType, a5 as EdgeType, bV as TraversalExpansion, y as GraphBackend, S as SqlDialect, w as SqlSchema, cz as Traversal, cA as NodePredicate, cB as ProjectedField, bn as OrderSpec, cC as AggregateOrderSpec, T as TemporalMode, cD as GroupBySpec, b7 as HybridFusionOptions, bb as JsonPointerInput, cE as RecursiveCyclePolicy, d as GraphDef, ag as TraversalDirection$1, aO as EdgeRegistration, _ as NodeId, bS as TransactionBackend, ac as AggregateExpr, bG as SortDirection, ax as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, cF as VectorSlotMap, cG as RecordedReadBinding, cH as SelectiveField, cI as ComposableQuery, cJ as SetOperationType, cK as SetOperation, G as GraphIdentityConfig, a1 as NodeKinds, cL as NodeRow, K as KindEntity, aR as ExternalRecordedReadSource, $ as EdgeId, cM as EdgeRow, bm as NodeRegistration, aM as EdgeKinds, bU as TransactionReadBackend, al as AllNodeTypes, a3 as KindAnnotations, X as JsonSchema, b_ as UniquenessScope, as as Collation, ar as Cardinality, aQ as EndpointExistence, b4 as GraphExtension, cN as VectorMetric, B as BackendCapabilities, C as ContributionDiagnostic, c as ContributionRepairResult, aD as ContributionProbeResult, aG as ContributionRebuildScope, aF as ContributionRebuildResult, bT as TransactionOptions, A as AdapterBackend } from './types-HkveCCx0.cjs';
+import { R as RecordedInstant, d as ReadCoordinate } from './temporal-Bn-Fi8FJ.cjs';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-CIje5XYD.cjs';
+import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-HGk6E_HW.cjs';
+import { S as SchemaDiff, j as MaterializeIndexesOptions, M as MaterializeIndexesResult, k as MaterializeSystemIndexesOptions } from './materialize-indexes-6A7dWGtb.cjs';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -22,6 +21,25 @@ type SchemaIntrospector = Readonly<{
     getSharedFieldTypeInfo: (kindNames: readonly string[], fieldName: string) => FieldTypeInfo | undefined;
     getEdgeFieldTypeInfo: (edgeKindName: string, fieldName: string) => FieldTypeInfo | undefined;
     getSharedEdgeFieldTypeInfo: (edgeKindNames: readonly string[], fieldName: string) => FieldTypeInfo | undefined;
+    /**
+     * True iff at least one kind in `kindNames` DECLARES `fieldName` as an own
+     * key of its schema shape.
+     *
+     * The single owner of "is this name a schema field?", asked by any layer that
+     * must tell a field access apart from something else the name could mean —
+     * today the select-tracking proxies, which would otherwise classify a
+     * DECLARED field named `toString` / `constructor` / `valueOf` as an inherited
+     * `Object.prototype` member and never track it.
+     *
+     * Deliberately ANY rather than every: a name one kind of a polymorphic alias
+     * declares is a field access, not a prototype access. Whether the field has a
+     * usable type across all of them is a separate question, answered by
+     * {@link SchemaIntrospector.getSharedFieldTypeInfo}, which stays `undefined`
+     * unless every kind agrees.
+     */
+    hasDeclaredField: (kindNames: readonly string[], fieldName: string) => boolean;
+    /** Edge counterpart of {@link SchemaIntrospector.hasDeclaredField}. */
+    hasDeclaredEdgeField: (edgeKindNames: readonly string[], fieldName: string) => boolean;
     /**
      * True iff every kind in `kindNames` has at least one `searchable()`
      * field. For polymorphic aliases, `$fulltext` is available only when
@@ -135,8 +153,21 @@ type SimilarToOptions = Readonly<{
      * distance scan. This is a SEMANTIC change — results are subject to the
      * index's recall, and predicates composed alongside constrain the ANN
      * candidate set (exact on pgvector/vec0; bounded by over-fetch on
-     * libSQL). A slot declared with `indexType: "none"` falls back to the
-     * exact scan. Default: exact.
+     * libSQL). Default: exact.
+     *
+     * Two states cannot serve it, and they are handled differently on purpose:
+     *
+     * - **A slot declared `indexType: "none"`** has no ANN structure, so the
+     *   opt-in compiles to the exact scan and results are unchanged. A
+     *   DECLARED degradation: the query is still exactly what was asked for,
+     *   only faster or slower.
+     * - **A `metric` override that differs from the field's declared metric**
+     *   is REFUSED with a `ConfigurationError` naming both metrics. An ANN
+     *   structure retrieves only under the metric it was built for, so the two
+     *   options state something that cannot both hold — and serving the exact
+     *   scan instead would silently drop one of them. Omit `metric` (or pass
+     *   the declared one) to keep approximate retrieval, or drop `approximate`
+     *   to scan exactly under the overriding metric.
      */
     approximate?: boolean;
 }>;
@@ -713,6 +744,10 @@ type QueryBuilderConfig = Readonly<{
     schemaIntrospector: SchemaIntrospector;
     /** Default traversal ontology expansion mode. */
     defaultTraversalExpansion: TraversalExpansion;
+    /** Whether this builder's graph enables Operational Identity. */
+    identityEnabled: boolean;
+    /** Equal-id behavior used by historical identity traversal compilation. */
+    identitySameIdAcrossKinds: "fold" | "ignore";
     backend?: GraphBackend;
     dialect?: SqlDialect;
     /** SQL schema configuration from createSqlSchema(...) for custom table names. */
@@ -762,6 +797,17 @@ type CreateQueryBuilderOptions = Readonly<{
     schema?: SqlSchema;
     /** Default traversal ontology expansion mode (default: "inverse"). */
     defaultTraversalExpansion?: TraversalExpansion;
+    /**
+     * Overrides whether a builder may compile identity-aware traversals
+     * (`traverse(..., { includeIdentityMembers: true })`).
+     *
+     * Defaults to the graph capability carried by `buildKindRegistry(graph)`.
+     * Passing `true` with a registry from a graph that does not enable identity
+     * throws a `ConfigurationError` instead of producing invalid SQL.
+     */
+    identityEnabled?: boolean;
+    /** Overrides the graph registry's same-id behavior. */
+    identitySameIdAcrossKinds?: "fold" | "ignore";
 }>;
 
 /**
@@ -917,6 +963,8 @@ type CompileQueryOptions = Readonly<{
      * across executions with a fresh "now" each call. See {@link ReadInstantMode}.
      */
     readInstant?: ReadInstantMode | undefined;
+    /** Equal-id behavior for historical identity traversal reconstruction. */
+    identitySameIdAcrossKinds?: "fold" | "ignore" | undefined;
 }>;
 
 /**
@@ -1263,7 +1311,7 @@ interface VariableLengthState {
  */
 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[]);
+    constructor(config: QueryBuilderConfig, state: QueryBuilderState, edgeKinds: readonly string[], edgeAlias: EA, direction: Dir, fromAlias: string, inverseEdgeKinds?: readonly string[], optional?: Optional, variableLength?: VariableLengthState, pendingEdgePredicates?: readonly NodePredicate[], includeIdentityMembers?: boolean);
     /**
      * Enables variable-length (recursive) traversal.
      * Defaults to MAX_RECURSIVE_DEPTH (10) hops with cycle prevention.
@@ -1310,6 +1358,32 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
  * QueryBuilder - The fluent query builder.
  */
 
+/**
+ * Identity-aware traversal option, available only on a graph that declares an
+ * identity configuration. On any other graph the property is typed `never`, so
+ * setting it is a compile error (and a runtime guard rejects it as well).
+ *
+ * When `includeIdentityMembers` is true, the traversal's source hop matches an
+ * edge attached to *any* coordinate-visible member of the source node's
+ * identity class, not just the source node itself. Semantics:
+ *
+ * - Results are physical rows: the nodes and edges returned are the ones
+ *   actually stored, never a synthesized merge of the class.
+ * - Identity-class membership is resolved at the query's own coordinate, so a
+ *   traversal under `asOf`/`asOfRecorded` follows only the assertions that were
+ *   in force at that instant; a retracted assertion stops conducting.
+ * - Within a step, physical edge ids are deduplicated. The one exception is a
+ *   self-inverse edge between two folded peers (same id, different kind), which
+ *   legitimately matches in both directions and is kept.
+ * - Under recursion, cycle detection keys on (kind, id) rather than id alone,
+ *   so passing through two folded peers is not mistaken for a revisit. Path
+ *   output is unaffected: it remains an array of bare node ids.
+ */
+type IdentityTraversalOption<G extends GraphDef> = G["identity"] extends GraphIdentityConfig ? Readonly<{
+    includeIdentityMembers?: boolean;
+}> : Readonly<{
+    includeIdentityMembers?: never;
+}>;
 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.
@@ -1367,7 +1441,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyA
         direction?: "out";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases, CoordinateState>;
+    } & IdentityTraversalOption<G>): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases, CoordinateState>;
     /**
      * Traverses an edge to another node (incoming direction).
      *
@@ -1382,7 +1456,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyA
         direction: "in";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", false, false, false, RecursiveAliases, CoordinateState>;
+    } & IdentityTraversalOption<G>): 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.
@@ -1391,7 +1465,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyA
         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, CoordinateState>;
+    } & IdentityTraversalOption<G>): 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.
@@ -1407,12 +1481,12 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyA
         direction?: "out";
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", true, false, false, RecursiveAliases, CoordinateState>;
+    } & IdentityTraversalOption<G>): 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, CoordinateState>;
+    } & IdentityTraversalOption<G>): 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
@@ -1423,7 +1497,7 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyA
         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, CoordinateState>;
+    } & IdentityTraversalOption<G>): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType, true>>, string, EA, TraversalDirection$1, true, false, false, RecursiveAliases, CoordinateState>;
     /**
      * Selects fields to return.
      */
@@ -1732,7 +1806,12 @@ type OperationHookContext = HookContext & Readonly<{
     /** Entity ID */
     id: string;
 }>;
-/** Context for one set-based collection mutation. */
+/**
+ * Context for one set-based collection mutation. Node `updateWhere` is the only
+ * mutation that reports one: the `operation` union is the exhaustive list of
+ * what `onBulkOperationStart` / `onBulkOperationEnd` observe, so a batch method
+ * absent from it (every `bulk*`, including `bulkDelete`) emits no bulk event.
+ */
 type BulkOperationHookContext = HookContext & Readonly<{
     operation: "updateWhere";
     entity: "node";
@@ -1741,8 +1820,11 @@ type BulkOperationHookContext = HookContext & Readonly<{
 /**
  * Observability hooks for monitoring store operations.
  *
- * Note: Batch operations (`bulkCreate`, `bulkInsert`, `bulkUpsertById`) skip
- * per-item operation hooks for throughput. Query hooks still fire normally.
+ * Note: Batch operations (`bulkCreate`, `bulkInsert`, `bulkUpsertById`,
+ * `bulkDelete`) skip per-item operation hooks for throughput, and the bulk
+ * hooks below do not stand in for them — those fire only for node
+ * `updateWhere`, so a batch method emits no hook events at all, neither
+ * per-item nor bulk. Query hooks still fire normally.
  *
  * @example
  * ```typescript
@@ -1873,7 +1955,9 @@ type BaseStoreOptions = Readonly<{
      *
      * A write is coalesced only when **all** of the following hold; otherwise the
      * normal write happens:
-     *   1. An existing row is found for the id (else it is a create).
+     *   1. A value to compare against is known for the id: an existing row, or —
+     *      for a repeated id in one bulk batch — the value an earlier item in that
+     *      batch already queued (a create or an update).
      *   2. That row is not soft-deleted (a deleted row resurrects — a real
      *      change — and is never coalesced).
      *   3. The caller passed no explicit `validFrom` / `validTo` (an explicit
@@ -2006,7 +2090,9 @@ type TransactionReceipt = Readonly<{
         nodes: Readonly<Record<string, number>>;
         /** Completed edge write intents by edge kind. */
         edges: Readonly<Record<string, number>>;
-        /** Sum of all node and edge write intents. */
+        /** Completed identity assertion and retraction write intents. */
+        identity: IdentityWriteSummary;
+        /** Sum of all node, edge, and identity write intents. */
         total: number;
     }>;
     /**
@@ -2133,13 +2219,22 @@ type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
     /** Existing record behavior. Default: "return" */
     ifExists?: IfExistsMode;
     /**
-     * Valid-time start for a newly created edge. Ignored when an edge is found,
-     * updated, or resurrected.
+     * Valid-time start for a created or RESURRECTED edge — on a resurrection it
+     * asserts the complete window, so an omitted `validTo` reopens the revived
+     * row.
+     *
+     * A live edge's stored lower bound is history, so an in-place update
+     * (`ifExists: "update"`) cannot store this: one naming a different instant is
+     * REFUSED with `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`, and one restating the
+     * bound the edge holds is accepted. Ignored when an existing edge is returned
+     * (`ifExists: "return"`), which writes nothing at all — there the window
+     * describes the edge to create if none is found.
      */
     validFrom?: string;
     /**
      * Valid-time end for a created, updated, or resurrected edge. Ignored when
-     * the operation returns an existing edge without writing.
+     * the operation returns an existing edge without writing. May not precede
+     * the row's effective start; see `INVERTED_VALIDITY_WINDOW_CODE`.
      */
     validTo?: string;
 }>;
@@ -2233,12 +2328,21 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * If a node with the given ID exists, updates it with the provided props.
      * Otherwise, creates a new node with that ID.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
+     * a tombstoned one — both write a fresh validity window — defaulting to the
+     * operation's timestamp when omitted. An update to a LIVE row stores no lower
+     * bound, because that row's is already history, so one naming a different
+     * instant is REFUSED (`ValidationError` carrying
+     * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
+     * bound the row already holds is accepted and changes nothing. Set
+     * `onImmutableLowerBound: "preserve"` for event materializers whose
+     * `validFrom` is create/resurrection input: a live update then preserves the
+     * stored lower bound while still applying props and `validTo`.
      */
     upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
         validFrom?: string;
         validTo?: string;
+        onImmutableLowerBound?: "preserve" | "refuse";
     }>) => Promise<Node<N>>;
     /**
      * Upsert a node from untyped data, relying on runtime Zod validation.
@@ -2247,12 +2351,19 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * the data shape is determined at runtime, not compile time.
      * The return type is fully typed — only the input gate is relaxed.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
+     * a tombstoned one — both write a fresh validity window — defaulting to the
+     * operation's timestamp when omitted. An update to a LIVE row stores no lower
+     * bound, because that row's is already history, so one naming a different
+     * instant is REFUSED (`ValidationError` carrying
+     * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
+     * bound the row already holds is accepted and changes nothing. Set
+     * `onImmutableLowerBound: "preserve"` for create/resurrection-only input.
      */
     upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
         validFrom?: string;
         validTo?: string;
+        onImmutableLowerBound?: "preserve" | "refuse";
     }>) => Promise<Node<N>>;
     /**
      * Create multiple nodes in a batch.
@@ -2274,14 +2385,41 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * For each item, if a node with the given ID exists, updates it.
      * Otherwise, creates a new node with that ID.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * Items are applied in order, so a **repeated id** within one batch is
+     * last-write-wins: the first item creates or updates the row, and every later
+     * copy is an update over the value the earlier item wrote — the same final row
+     * the equivalent sequence of `upsertById` calls produces. This holds whether
+     * or not the row existed before the batch.
+     *
+     * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
+     * a tombstoned one — both write a fresh validity window — defaulting to the
+     * operation's timestamp when omitted. An update to a LIVE row stores no lower
+     * bound, because that row's is already history, so one naming a different
+     * instant is REFUSED (`ValidationError` carrying
+     * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
+     * bound the row already holds is accepted and changes nothing. Per-item
+     * `onImmutableLowerBound: "preserve"` makes the bound create/resurrection
+     * input while a live update preserves the stored lower bound.
+     *
+     * **Limitation — a batch cannot hand a unique value from one row to
+     * another.** Item order settles which value each id ends up with, but the
+     * writes themselves are grouped: every create runs before every update. So a
+     * batch where one item RELEASES a `unique` constraint value and a later item
+     * CLAIMS it — `[{ id: "a", props: { email: "moved@x" } }, { id: "b", props:
+     * { email: "shared@x" } }]` where `a` currently holds `"shared@x"` and `b` is
+     * new — checks `b`'s create while `a` still reserves the value, and the whole
+     * batch fails with a `UniquenessError`. The equivalent sequence of
+     * single `upsertById` calls succeeds. A batch states the set of rows it wants,
+     * not a script to reach them by; the failure is loud rather than silent, and
+     * the workaround is to split the handoff across two batches (release, then
+     * claim) or to apply those items as sequential `upsertById` calls.
      */
     bulkUpsertById: (items: readonly Readonly<{
         id: string;
         props: z.input<N["schema"]>;
         validFrom?: string;
         validTo?: string;
+        onImmutableLowerBound?: "preserve" | "refuse";
     }>[]) => Promise<Node<N>[]>;
     /**
      * Insert multiple nodes without returning results.
@@ -2564,8 +2702,34 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * For each item, if an edge with the given ID exists, updates it.
      * Otherwise, creates a new edge with that ID.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * Items are applied in order, so a **repeated id** within one batch is
+     * last-write-wins: the first item creates or updates the edge, and every later
+     * copy is an update over the value the earlier item wrote. This holds whether
+     * or not the edge existed before the batch. An update never repoints an edge,
+     * so every item's `from` / `to` must exactly restate the endpoints already
+     * owned by that id (including an earlier item in the same batch). A mismatch
+     * is refused with `ValidationError` carrying
+     * `EDGE_IDENTITY_MISMATCH_CODE`; it is never silently ignored.
+     *
+     * `validFrom` applies when the upsert CREATES the row and when it RESURRECTS
+     * a tombstoned one — both write a fresh validity window — defaulting to the
+     * operation's timestamp when omitted. An update to a LIVE row stores no lower
+     * bound, because that row's is already history, so one naming a different
+     * instant is REFUSED (`ValidationError` carrying
+     * `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`) rather than ignored. Restating the
+     * bound the row already holds is accepted and changes nothing.
+     *
+     * **Limitation — a batch cannot hand a constrained slot from one edge to
+     * another.** Item order settles the final props, but the writes are grouped:
+     * every create runs before every update. So a batch where one item frees the
+     * slot a `cardinality` constraint allows and a later item claims it — ending
+     * the lone `oneActive` edge from a source while creating its replacement —
+     * checks the create while the old edge is still active, and the whole batch
+     * fails with a `CardinalityError`. Applying the update first, as
+     * separate `update` / `create` calls, succeeds. A batch states the set of
+     * edges it wants, not a script to reach them by; the failure is loud rather
+     * than silent, and the workaround is to split the handoff across two batches
+     * (free the slot, then claim it) or to apply those items individually.
      */
     bulkUpsertById: (items: readonly Readonly<{
         id: EdgeId<E>;
@@ -2597,6 +2761,12 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      *
      * Atomic when the backend supports transactions. Silently ignores IDs
      * that don't exist.
+     *
+     * The batch runs as one transaction, checking each id's kind against the
+     * authoritative row as it goes. An id owned by another edge kind is
+     * refused with `ValidationError` carrying `EDGE_IDENTITY_MISMATCH_CODE`;
+     * because the whole batch is one transaction, that refusal rolls back
+     * every delete already applied for an earlier id in the same batch.
      */
     bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
     /**
@@ -2623,10 +2793,15 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * property fields, only edges whose properties match on those fields are considered.
      * Soft-deleted matches are resurrected when cardinality allows.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted. `validTo` applies on create,
-     * update, and resurrection, but not when an existing edge is returned
-     * without a write.
+     * `validFrom` applies on the create and RESURRECT branches, defaulting to the
+     * operation's creation timestamp when omitted. On the `ifExists: "update"`
+     * branch a live edge's lower bound is history and cannot be stored, so a
+     * `validFrom` naming a different instant is REFUSED (`ValidationError`
+     * carrying `IMMUTABLE_VALIDITY_LOWER_BOUND_CODE`); restating the bound the
+     * edge holds is accepted. A returned existing edge (`ifExists: "return"`)
+     * writes nothing and judges nothing — the window options describe the row to
+     * create if none is found. `validTo` applies on create, update, and
+     * resurrection, but not when an existing edge is returned without a write.
      *
      * @param from - Source node
      * @param to - Target node
@@ -2858,7 +3033,9 @@ type TransactionCollections<G extends GraphDef> = Readonly<{
      * registered in this graph.
      */
     getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
-}>;
+}> & (G["identity"] extends GraphIdentityConfig ? Readonly<{
+    identity: IdentityFacade<G>;
+}> : Readonly<Record<never, never>>);
 /**
  * A portable transaction context containing only TypeGraph-owned graph
  * operations. Managed Stores use this surface so adapter-native handles never
@@ -2994,6 +3171,110 @@ type StoreProjection<G extends GraphDef, N extends keyof G["nodes"] & string = n
     edges: Pick<GraphEdgeCollections<G>, E>;
 }>;
 
+/**
+ * The loose *input* form every identity facade method accepts: a whole node, a
+ * bare id, or a `{ kind, id }` pair, for any node kind in the graph. Its kind
+ * and id are independent, so a caller can pass what it already has without
+ * re-correlating them.
+ *
+ * Identity *results* use the strict {@link GraphNodeReference} instead, whose
+ * `kind` and branded `id` stay correlated.
+ */
+type IdentityNodeRefInput<G extends GraphDef> = NodeRef<AllNodeTypes<G>>;
+/** A hydrated identity member, discriminated by its registered node kind. */
+type IdentityNode<G extends GraphDef> = {
+    [K in NodeKinds<G>]: Node<G["nodes"][K]["type"]>;
+}[NodeKinds<G>];
+declare const __identityAssertionId: unique symbol;
+type IdentityAssertionId = string & Readonly<{
+    [__identityAssertionId]: true;
+}>;
+/**
+ * Brands a non-empty string as an {@link IdentityAssertionId}.
+ *
+ * Use this when a persisted identity assertion id has round-tripped through
+ * untyped storage or an external boundary and must be passed back to a
+ * retraction surface such as `retractAssertion` or `bulkRetractAssertions`.
+ * Mirrors the `asNodeId` / `asEdgeId` precedent.
+ *
+ * @throws {ValidationError} when `value` is empty.
+ */
+declare function asIdentityAssertionId(value: string): IdentityAssertionId;
+/**
+ * What one assertion claims about a pair of nodes: `"same"` merges them into
+ * one equivalence set, `"different"` records a disjointness that a later
+ * `"same"` claim must not contradict.
+ */
+type IdentityRelation = "same" | "different";
+/**
+ * One persisted identity claim about an ordered pair of nodes. Returned by the
+ * assertion writers and by `identity.assertionsOf(...)`; `validTo` is set when
+ * the assertion has been retracted, so a historical read can still see it.
+ */
+type IdentityAssertion<G extends GraphDef> = Readonly<{
+    id: IdentityAssertionId;
+    relation: IdentityRelation;
+    a: GraphNodeReference<G>;
+    b: GraphNodeReference<G>;
+    validFrom: string;
+    validTo?: string;
+}>;
+/** Result of an idempotent assertion write. */
+type IdentityAssertionResult<G extends GraphDef> = Readonly<{
+    assertion: IdentityAssertion<G>;
+    action: "created" | "existing";
+}>;
+/** One ordered node pair handed to `bulkAssertSame` / `bulkAssertDifferent`. */
+type IdentityPair<G extends GraphDef> = Readonly<{
+    a: IdentityNodeRefInput<G>;
+    b: IdentityNodeRefInput<G>;
+}>;
+/**
+ * The read half of the identity surface: equivalence-set membership,
+ * representative selection, and the assertions behind them.
+ *
+ * Obtained from a read-only lens — `store.asOf(...).identity`,
+ * `store.snapshot().identity` — where it answers at that view's coordinate.
+ * The full read+write surface is {@link IdentityFacade}.
+ */
+type IdentityReadFacade<G extends GraphDef> = Readonly<{
+    representativeOf: (ref: IdentityNodeRefInput<G>) => Promise<GraphNodeReference<G> | undefined>;
+    membersOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly GraphNodeReference<G>[]>;
+    nodesOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly IdentityNode<G>[]>;
+    areSame: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<boolean>;
+    areDifferent: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<boolean>;
+    assertionsOf: (ref: IdentityNodeRefInput<G>) => Promise<readonly IdentityAssertion<G>[]>;
+}>;
+/**
+ * The full TypeGraph Identity Profile surface: {@link IdentityReadFacade} plus
+ * the assertion writers and retractions.
+ *
+ * Obtained from `store.identity` or `tx.identity`, and present only on graphs
+ * that declared `identity: { ... }` in `defineGraph`. Every writer is
+ * idempotent — re-asserting an existing claim returns it with
+ * `action: "existing"` rather than duplicating it.
+ */
+type IdentityFacade<G extends GraphDef> = IdentityReadFacade<G> & Readonly<{
+    assertSame: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertionResult<G>>;
+    assertDifferent: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertionResult<G>>;
+    bulkAssertSame: (pairs: readonly IdentityPair<G>[]) => Promise<readonly IdentityAssertionResult<G>[]>;
+    bulkAssertDifferent: (pairs: readonly IdentityPair<G>[]) => Promise<readonly IdentityAssertionResult<G>[]>;
+    retractAssertion: (id: IdentityAssertionId) => Promise<IdentityAssertion<G> | undefined>;
+    retractSameAssertion: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertion<G> | undefined>;
+    retractDifferentAssertion: (a: IdentityNodeRefInput<G>, b: IdentityNodeRefInput<G>) => Promise<IdentityAssertion<G> | undefined>;
+    bulkRetractAssertions: (ids: readonly IdentityAssertionId[]) => Promise<readonly IdentityAssertion<G>[]>;
+}>;
+/**
+ * Per-transaction identity write counts carried by a transaction receipt.
+ * `total` is the sum of the three preceding counters.
+ */
+type IdentityWriteSummary = Readonly<{
+    sameAssertions: number;
+    differentAssertions: number;
+    retractions: number;
+    total: number;
+}>;
+
 /**
  * Shared types for Tier 1 graph algorithms.
  *
@@ -3224,6 +3505,11 @@ type WeaklyConnectedComponentsOptions<G extends GraphDef> = TemporalAlgorithmOpt
     edges: readonly EdgeKinds<G>[];
     /** Optional node kinds defining the induced subgraph to analyze. */
     nodeKinds?: readonly NodeKinds<G>[];
+    /**
+     * Return only components containing at least this many nodes. Must be a
+     * positive safe integer.
+     */
+    minComponentSize?: number;
     /** Maximum label-propagation rounds before throwing. Defaults to 1000. */
     maxIterations?: number;
 }>;
@@ -3290,6 +3576,11 @@ type PageRankOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeM
     tolerance?: number;
     /** Maximum power-iteration rounds before throwing. Defaults to `1000`. */
     maxIterations?: number;
+    /**
+     * Return only the first this many scores after deterministic ordering.
+     * Must be a positive safe integer.
+     */
+    topK?: number;
 }>;
 type InternalPageRankOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<PageRankOptions<G>, keyof TemporalAlgorithmOptions>;
 /** One weighted teleport target for personalized PageRank. */
@@ -3422,558 +3713,234 @@ type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
     personalizedPageRank: (options: InternalPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
 }>;
 
-type RebuildFulltextOptions = Readonly<{
-    /** Page size. Must be a positive integer. Default: 500. */
-    pageSize?: number;
+/**
+ * Members that are safe to expose through a history-enabled adapter Store.
+ *
+ * Graph entity writes remain because the source is the capture-wrapped
+ * backend. Direct raw SQL, native import, graph clearing, and nested backend
+ * transactions stay internal because each can mutate live rows without a
+ * corresponding capture flush.
+ */
+declare const HISTORY_STORE_BACKEND_KEYS: readonly ["assertRuntimeContributionsInitialized", "assertVectorSlotInitialized", "assertVectorSlotsInitialized", "bootstrapTables", "capabilities", "checkUnique", "checkUniqueBatch", "claimIndexMaterialization", "close", "commitSchemaVersion", "commitSchemaVersionIfKindsEmpty", "lockSchemaVersionForWrite", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteEmbeddingBatch", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "hardDeleteUniquesByNodeIds", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesByEndpointSet", "findEdgesByHeterogeneousEndpointSet", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hardDeleteUniquesByNodeIds", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "probeContributions", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "updateNodeSet", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy", "verifyContributions"];
+type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
+type UnsafeHistoryStoreBackendMember = "clearGraph" | "commitSchemaVersionWithPreflight" | "executeDdl" | "executeRaw" | "executeStatement" | "ensureIdentityTables" | "identityTableDdl" | "rebuildContribution" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
+type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
+type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
+
+/**
+ * `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>;
     /**
-     * Maximum number of skipped node IDs to include in the `skippedIds`
-     * array. Default: 10,000. Set higher to collect the full list when
-     * investigating systemic corruption; set lower when `processed` is
-     * all you care about. The `skipped` total is always accurate.
+     * 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.
      */
-    maxSkippedIds?: number;
+    extension: GraphExtension | undefined;
 }>;
-type RebuildFulltextResult = Readonly<{
-    /** Node kinds that were rebuilt (those with at least one searchable field). */
-    kinds: readonly string[];
-    /** Total nodes scanned. */
-    processed: number;
-    /** Fulltext upsert operations executed. */
-    upserted: number;
-    /** Fulltext delete operations executed (soft-deleted or all-empty nodes). */
-    cleared: number;
-    /**
-     * Nodes skipped due to corrupt or non-object `props` (not counted in
-     * upserted/cleared).
-     */
-    skipped: number;
+type KindIntrospection = Readonly<{
+    name: string;
+    origin: "compile-time" | "runtime";
+    description: string | undefined;
+    annotations: KindAnnotations | undefined;
+    deprecated: boolean;
     /**
-     * IDs of skipped nodes, capped at 10,000 entries so pathological
-     * corruption doesn't turn rebuild into an OOM. See `skippedTruncated`
-     * to tell whether the cap was hit. Empty when `skipped === 0`.
+     * 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`.
      */
-    skippedIds: readonly string[];
-    /** True when `skipped > skippedIds.length` (the cap was reached). */
-    skippedTruncated: boolean;
+    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;
 }>;
 
 /**
- * Store-level search helpers.
+ * Data-cleanup phase for `store.removeKinds()`.
  *
- * `fulltextSearch` is a thin typed wrapper over `backend.fulltextSearch`.
- * `hybridSearch` runs a vector and a fulltext query in parallel and
- * fuses the two ranked lists with Reciprocal Rank Fusion. RRF is
- * rank-based, so it papers over score-scale differences between
- * pgvector/sqlite-vec (distance-derived) and tsvector/FTS5 (BM25-style).
+ * 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, while data work is bounded by row count and
+ * deferrable. Candidates run sequentially because they share one graph lock.
  */
 
-/**
- * A fulltext search hit. `N` defaults to the generic `Node`; the
- * `store.search.fulltext<K>(kind)` facade narrows it to the concrete
- * typed node for that kind so callers get `hit.node.title` without a cast.
- */
-type FulltextSearchHit<N = Node> = Readonly<{
-    node: N;
-    /** Backend-native relevance score; higher is better. */
-    score: number;
-    /** 1-based rank within the result set. */
-    rank: number;
-    /** Highlighted snippet (only present when `includeSnippets: true`). */
-    snippet?: string;
-}>;
-type VectorSearchHit<N = Node> = Readonly<{
-    node: N;
-    score: number;
-    rank: number;
+type MaterializeRemovalsOptions = Readonly<{
+    /** Restrict to specific kind names. */
+    kinds?: readonly string[];
+    /** Halt on first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
 }>;
 /**
- * A hybrid search hit. Both sub-results (`vector`, `fulltext`) carry the
- * same narrowed node type as the top-level `node` for ergonomic access.
+ * Outcome of one queued kind removal, discriminated on `status`.
+ *
+ * A union rather than one shape with optional fields, so each outcome carries
+ * exactly its own payload: `"failed"` always has an `error`, `"skipped"`
+ * always has a `reason`, and `"removed"` has neither. The flat form permitted
+ * impossible states — a `"skipped"` with no reason, or a `"removed"` carrying
+ * `reason: "kind-is-live"` — and narrowing on `status` still left both fields
+ * optional at the use site.
  */
-type HybridSearchHit<N = Node> = Readonly<{
-    node: N;
-    /** Fused RRF score (higher is better). */
-    score: number;
-    /** 1-based rank in the fused list. */
-    rank: number;
-    /** Sub-result from the vector half, if it ranked this node. */
-    vector?: VectorSearchHit<N>;
-    /** Sub-result from the fulltext half, if it ranked this node. */
-    fulltext?: FulltextSearchHit<N>;
+type MaterializeRemovalsEntry = Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "removed";
+}> | Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "failed";
+    error: Error;
+}> | Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "skipped";
+    /**
+     * `"kind-is-live"`: the active schema declares this kind again — it was
+     * dropped, then re-added — so deleting its rows would destroy live
+     * data. The queue row stays pending, so a later removal of the same
+     * kind still reclaims it.
+     *
+     * Reported rather than silent: an empty `results` array would otherwise
+     * be indistinguishable from "nothing was pending", leaving the queue at
+     * a non-zero depth with nothing explaining why.
+     */
+    reason: "kind-is-live";
 }>;
 /**
- * Scope options shared by every facade search leg.
- *
- * `where` and `includeSubClasses` compile into the search statement's
- * candidate set (a subquery produced by the store's own query compiler), so
- * filtering happens INSIDE the engine's top-k — never by post-filtering a
- * ranked list. `offset` is rank-relative pagination: the engine fetches
- * `limit + offset` ranked candidates and discards the leading page.
+ * 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 SearchScopeOptions<N extends NodeType = NodeType> = Readonly<{
+type ReclaimedVectorFieldEntry = Readonly<{
+    kind: string;
+    fieldPath: string;
+    status: "reclaimed" | "failed";
+    error?: Error;
+}>;
+type MaterializeRemovalsResult = Readonly<{
+    results: readonly MaterializeRemovalsEntry[];
     /**
-     * Predicate over the node's properties, compiled by the shared query
-     * compiler into the candidate subquery. Requires a query-capable store.
-     * The facade instantiates `N` to the searched kind's node type, so the
-     * accessor is fully typed at the call site; the base instantiation
-     * exposes the system accessors (`id`, `kind`) for standalone option
-     * values.
-     */
-    where?: (accessor: NodeAccessor<N>) => Predicate;
-    /** Rows to skip after ranking (rank-relative pagination). */
-    offset?: number;
-    /**
-     * Expand the searched kind to include its `subClassOf` descendants.
-     * Vector legs search each declaring kind's storage and merge by score;
-     * kinds that don't declare the embedding field are skipped (mirroring
-     * the query builder). Requires a query-capable store.
-     */
-    includeSubClasses?: boolean;
-}>;
-type FulltextSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
-    /** The user-supplied query string. */
-    query: string;
-    /** Max results. Required. */
-    limit: number;
-    /** Query parser mode. Default: "websearch". */
-    mode?: FulltextQueryMode;
-    /**
-     * Language override for query parsing. Default: the kind's
-     * declared language (the same config rows were indexed with),
-     * which keeps the parsed tsquery a plan-time constant on
-     * PostgreSQL so the GIN index can serve the match.
-     */
-    language?: string;
-    /** Minimum relevance score to include in results. */
-    minScore?: number;
-    /** Return a highlighted snippet alongside each hit. */
-    includeSnippets?: boolean;
-}>;
-type HybridVectorOptions = Readonly<{
-    /** Field path of the embedding column on the node kind. */
-    fieldPath: string;
-    /** Query embedding to compare against. */
-    queryEmbedding: readonly number[];
-    /** Distance metric. Default: "cosine". */
-    metric?: VectorMetric;
-    /** How many candidates to retrieve from the vector side. Default: 4 * limit. */
-    k?: number;
-    /** Minimum similarity to include (units depend on metric). */
-    minScore?: number;
-    /**
-     * HNSW search frontier for this query (pgvector `hnsw.ef_search`).
-     * The vector side over-fetches `k` (default `4 * limit`) candidates;
-     * `efSearch` must be `>= k` for the index to surface that many
-     * neighbors, and ~2–4× `k` is the high-recall target. Postgres HNSW
-     * only — no-op elsewhere. See `VectorSearchOptions.efSearch`.
-     */
-    efSearch?: number;
-}>;
-/**
- * Options for the standalone `store.search.vector` path. Mirrors the
- * vector half of `HybridSearchOptions` but flattens it because the
- * standalone path doesn't fuse against fulltext.
- */
-type VectorSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
-    /** Field path of the embedding column on the node kind. */
-    fieldPath: string;
-    /** Query embedding to compare against. */
-    queryEmbedding: readonly number[];
-    /** Max results. Required. */
-    limit: number;
-    /** Distance metric. Default: "cosine". */
-    metric?: VectorMetric;
-    /** Minimum similarity to include (units depend on metric). */
-    minScore?: number;
-    /**
-     * HNSW search frontier for this query (pgvector `hnsw.ef_search`).
-     * Sizes the dynamic candidate list the index scan maintains — higher
-     * trades latency for recall. The floor for the index to surface
-     * `limit` neighbors is `efSearch >= limit`; ~2–4× is the high-recall
-     * target on million-scale corpora. Lets a latency-sensitive
-     * interactive path and a recall-sensitive batch path share one
-     * connection pool, tuning per query rather than per session.
-     *
-     * Postgres HNSW only: applied transaction-locally via `SET LOCAL`.
-     * sqlite-vec has no equivalent frontier knob and ignores it; Postgres
-     * backends without transactions (`drizzle-orm/neon-http`) ignore it
-     * with a one-time warning. Must be a positive integer; pgvector caps
-     * it at 1000.
+     * 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}.
      */
-    efSearch?: number;
-}>;
-type HybridFulltextOptions = Readonly<{
-    query: string;
-    /** How many candidates to retrieve from the fulltext side. Default: 4 * limit. */
-    k?: number;
-    mode?: FulltextQueryMode;
-    language?: string;
-    minScore?: number;
-    includeSnippets?: boolean;
-}>;
-type HybridSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
-    vector: HybridVectorOptions;
-    fulltext: HybridFulltextOptions;
-    fusion?: HybridFusionOptions;
-    /** Final number of fused results to return. Required. */
-    limit: number;
+    reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
 }>;
 
 /**
- * StoreSearch — store.search facade.
+ * Subgraph Extraction
  *
- * Groups fulltext, vector, hybrid, and maintenance operations under one
- * namespace so the top-level Store API stays focused on CRUD + graph
- * traversal. The methods delegate to their respective execution
- * modules; this class exists to shape the surface and to gate kind
- * names through the registry — the kind argument is `string` so
- * graph-extension kinds (added via `store.evolve()`) work without a
- * type cast, with a runtime guard rejecting misspellings at the call
- * site.
+ * Extracts a typed subgraph from a root node by traversing a set of edge kinds.
+ * Uses a recursive CTE for BFS traversal with cycle detection, then hydrates
+ * the reachable nodes and connecting edges in two parallel queries.
  */
 
 /**
- * Resolves the hit's `node` type. Compile-time kinds keep their
- * narrowed `Node<N>`; kinds outside `G` (added via graph extension through
- * `store.evolve()`, or string variables the type system can't see)
- * widen to the base `Node` so callers don't need a cast.
+ * Discriminated union of all Node runtime types in a graph.
  *
- * This is the same shape as `getNodeCollection` — the dynamic form
- * works for any registered kind, and the type narrows when (and only
- * when) the literal is statically known.
+ * Unlike `AllNodeTypes<G>` which gives the union of *type definitions*,
+ * `AnyNode<G>` gives the union of *runtime node instances*.
  */
-type ResolveNode<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node : Node;
+type AnyNode<G extends GraphDef> = {
+    [K in NodeKinds<G>]: Node<G["nodes"][K]["type"]>;
+}[NodeKinds<G>];
 /**
- * The registered `NodeType` behind a kind literal — the accessor-level
- * companion of {@link ResolveNode}, used to type `where` predicates.
- * Falls back to the base `NodeType` for dynamic (string) kinds.
+ * Discriminated union of all Edge runtime types in a graph.
  */
-type ResolveNodeType<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? N : NodeType : NodeType;
-type StoreSearchContext = Readonly<{
-    graphId: string;
-    backend: GraphBackend;
-    registry: KindRegistry;
-    createQuery?: () => QueryBuilder<GraphDef>;
-}>;
+type AnyEdge<G extends GraphDef> = {
+    [K in EdgeKinds<G>]: Edge<G["edges"][K]["type"]>;
+}[EdgeKinds<G>];
 /**
- * Search-related operations exposed via `store.search`.
- *
- * @example
- * ```typescript
- * // Fulltext only
- * const hits = await store.search.fulltext("Document", {
- *   query: "climate change",
- *   limit: 10,
- *   includeSnippets: true,
- * });
- *
- * // Vector only — for extension kinds with embedding() modifiers,
- * // the auto-derived index serves this query.
- * const nearest = await store.search.vector("Document", {
- *   fieldPath: "embedding",
- *   queryEmbedding: vec,
- *   limit: 10,
- * });
- *
- * // Hybrid: vector + fulltext, fused with RRF
- * const ranked = await store.search.hybrid("Document", {
- *   limit: 10,
- *   vector: { fieldPath: "embedding", queryEmbedding: vec },
- *   fulltext: { query: "climate change" },
- * });
- *
- * // Rebuild after backfill / schema change
- * const stats = await store.search.rebuildFulltext();
- * ```
- *
- * Extension kinds added via `store.evolve(...)` work with all four
- * methods without a type cast — the kind argument is `string` and a
- * registry check rejects misspellings at the call site.
+ * Discriminated union of Node runtime types narrowed to a subset of kinds.
  */
-declare class StoreSearch<G extends GraphDef> {
-    #private;
-    constructor(context: StoreSearchContext);
-    /**
-     * Runs a fulltext search against nodes of the given kind.
-     *
-     * Requires fields on the node schema declared with `searchable()`.
-     * The search hits the backend's fulltext index (tsvector + GIN on
-     * Postgres, FTS5 on SQLite — or whatever strategy the backend is
-     * configured with) and resolves the matching node IDs back to typed
-     * `Node` objects.
-     */
-    fulltext<K extends string>(nodeKind: K, options: FulltextSearchOptions<ResolveNodeType<G, K>>): Promise<readonly FulltextSearchHit<ResolveNode<G, K>>[]>;
+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<{
     /**
-     * Runs a vector similarity search against nodes of the given kind.
-     *
-     * Requires a field on the node schema declared with `embedding()`,
-     * either at compile time or via a graph extension (the auto-derived
-     * `VectorIndexDeclaration` flows through `materializeIndexes()` on
-     * the same path either way).
+     * Node fields to keep per kind.
      *
-     * Pure vector — no fulltext leg, no fusion. For combined
-     * vector+fulltext ranking, use `hybrid`.
+     * 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.
      */
-    vector<K extends string>(nodeKind: K, options: VectorSearchOptions<ResolveNodeType<G, K>>): Promise<readonly VectorSearchHit<ResolveNode<G, K>>[]>;
+    nodes?: SubgraphNodeProjectionMap<G, NK>;
     /**
-     * Runs a vector + fulltext hybrid search and fuses the results with
-     * Reciprocal Rank Fusion.
+     * Edge fields to keep per kind.
      *
-     * RRF is rank-based, so it composes well across heterogeneous score
-     * scales (cosine similarity vs ts_rank_cd vs FTS5 BM25). Default
-     * over-fetch is 4× `limit` from each source — tune via `vector.k` /
-     * `fulltext.k` for higher-recall corpora.
-     */
-    hybrid<K extends string>(nodeKind: K, options: HybridSearchOptions<ResolveNodeType<G, K>>): Promise<readonly HybridSearchHit<ResolveNode<G, K>>[]>;
-    /**
-     * Rebuilds the fulltext index from existing node data.
-     *
-     * Use when:
-     * - A node kind gained a `searchable()` field after data was already
-     *   written and existing rows were never indexed.
-     * - The fulltext table was dropped / truncated.
-     * - `language` was changed on a `searchable()` field.
-     *
-     * Iterates nodes with keyset pagination (stable under shared
-     * timestamps and light concurrent writes), transacts per page, skips
-     * kinds with no searchable fields, and cleans up stale rows for
-     * soft-deleted nodes. Corrupt or non-object `props` are counted in
-     * `skipped` with their node IDs surfaced via `skippedIds` so operators
-     * can investigate. Concurrent hard-deletes between page fetches can
-     * be missed by a single pass — run during a maintenance window for
-     * full consistency.
-     */
-    rebuildFulltext<K extends string>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
-}
-
-/**
- * Members that are safe to expose through a history-enabled adapter Store.
- *
- * Graph entity writes remain because the source is the capture-wrapped
- * backend. Direct raw SQL, native import, graph clearing, and nested backend
- * transactions stay internal because each can mutate live rows without a
- * corresponding capture flush.
- */
-declare const HISTORY_STORE_BACKEND_KEYS: readonly ["assertRuntimeContributionsInitialized", "assertVectorSlotInitialized", "assertVectorSlotsInitialized", "bootstrapTables", "capabilities", "checkUnique", "checkUniqueBatch", "claimIndexMaterialization", "close", "commitSchemaVersion", "commitSchemaVersionIfKindsEmpty", "lockSchemaVersionForWrite", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteEmbeddingBatch", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "hardDeleteUniquesByNodeIds", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesByEndpointSet", "findEdgesByHeterogeneousEndpointSet", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hardDeleteUniquesByNodeIds", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "updateNodeSet", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy", "verifyContributions"];
-type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
-type UnsafeHistoryStoreBackendMember = "clearGraph" | "executeDdl" | "executeRaw" | "executeStatement" | "repairContributions" | "schemaWriteTransaction" | "transaction" | "trustedImport";
-type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
-type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
-
-/**
- * `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, while data work is bounded by row count and
- * deferrable. Candidates run sequentially because they share one graph lock.
- */
-
-type MaterializeRemovalsOptions = Readonly<{
-    /** Restrict to specific kind names. */
-    kinds?: readonly string[];
-    /** Halt on first failure. Default: false (best-effort). */
-    stopOnError?: boolean;
-}>;
-/**
- * Outcome of one queued kind removal, discriminated on `status`.
- *
- * A union rather than one shape with optional fields, so each outcome carries
- * exactly its own payload: `"failed"` always has an `error`, `"skipped"`
- * always has a `reason`, and `"removed"` has neither. The flat form permitted
- * impossible states — a `"skipped"` with no reason, or a `"removed"` carrying
- * `reason: "kind-is-live"` — and narrowing on `status` still left both fields
- * optional at the use site.
- */
-type MaterializeRemovalsEntry = Readonly<{
-    kind: string;
-    entity: KindEntity;
-    status: "removed";
-}> | Readonly<{
-    kind: string;
-    entity: KindEntity;
-    status: "failed";
-    error: Error;
-}> | Readonly<{
-    kind: string;
-    entity: KindEntity;
-    status: "skipped";
-    /**
-     * `"kind-is-live"`: the active schema declares this kind again — it was
-     * dropped, then re-added — so deleting its rows would destroy live
-     * data. The queue row stays pending, so a later removal of the same
-     * kind still reclaims it.
-     *
-     * Reported rather than silent: an empty `results` array would otherwise
-     * be indistinguishable from "nothing was pending", leaving the queue at
-     * a non-zero depth with nothing explaining why.
-     */
-    reason: "kind-is-live";
-}>;
-/**
- * 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[];
-}>;
-
-/**
- * Subgraph Extraction
- *
- * Extracts a typed subgraph from a root node by traversing a set of edge kinds.
- * Uses a recursive CTE for BFS traversal with cycle detection, then hydrates
- * the reachable nodes and connecting edges in two parallel queries.
- */
-
-/**
- * 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.
+     * 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>;
 }>;
@@ -4061,46 +4028,752 @@ type InternalSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK ext
     recordedAsOf?: RecordedInstant;
 }>;
 /**
- * Union of all node result types in a subgraph, respecting projection.
+ * Union of all node result types in a subgraph, respecting projection.
+ */
+type SubgraphNodeResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, P = undefined> = {
+    [Kind in NK]: SubgraphNodeResultForKind<G, Kind, P>;
+}[NK];
+/**
+ * Union of all edge result types in a subgraph, respecting projection.
+ */
+type SubgraphEdgeResult<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>, P = undefined> = {
+    [Kind in EK]: SubgraphEdgeResultForKind<G, Kind, P>;
+}[EK];
+type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
+    /** The root node, or undefined if the root was not found or excluded. */
+    root: SubgraphNodeResult<G, NK, P> | undefined;
+    nodes: ReadonlyMap<string, SubgraphNodeResult<G, NK, P>>;
+    /** Forward adjacency: fromId → edgeKind → edges to targets. */
+    adjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
+    /** Reverse adjacency: toId → edgeKind → edges from sources. */
+    reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
+}>;
+
+declare const STORE_RUNTIME: unique symbol;
+/**
+ * @internal Operations used by Store-owned views. The port is absent from the
+ * public Store contract and non-enumerable at runtime. JavaScript reflection
+ * can still discover symbol properties, so this is an unsupported internal
+ * surface rather than a security boundary.
+ */
+type StoreRuntime<G extends GraphDef> = Readonly<{
+    backend: GraphBackend;
+    sealedQuery: (coordinate: ReadCoordinate) => InitialQueryBuilder<G, "sealed">;
+    recordedNodeGetById: <N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate) => Promise<Node<N> | undefined>;
+    recordedNodeGetByIds: <N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate) => Promise<readonly (Node<N> | undefined)[]>;
+    recordedNodeScan: <N extends NodeType>(kind: string, coordinate: ReadCoordinate, options?: RecordedScanOptions) => Promise<RecordedScanPage<Node<N>>>;
+    recordedEdgeGetById: <E extends AnyEdgeType>(kind: string, id: EdgeId<E>, coordinate: ReadCoordinate) => Promise<Edge<E> | undefined>;
+    recordedEdgeGetByIds: <E extends AnyEdgeType>(kind: string, ids: readonly EdgeId<E>[], coordinate: ReadCoordinate) => Promise<readonly (Edge<E> | undefined)[]>;
+    recordedEdgeScan: <E extends AnyEdgeType>(kind: string, coordinate: ReadCoordinate, options?: RecordedScanOptions) => Promise<RecordedScanPage<Edge<E>>>;
+    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>>;
+    algorithmsAtCoordinate: (coordinate: ReadCoordinate) => InternalGraphAlgorithms<G>;
+    identityAtCoordinate: (coordinate: ReadCoordinate) => IdentityReadFacade<G>;
+    rebuildIdentityClosure: () => Promise<void>;
+    validateIdentity: () => Promise<void>;
+    /**
+     * @internal Reads the graph's identity assertions in transfer shape, honoring
+     * this store's SQL binding. Used by interchange export, base-version
+     * fingerprinting, and merge staging/diff.
+     */
+    readCurrentIdentityAssertions: (mode: "state" | "archival", options?: Readonly<{
+        nodeKinds?: readonly string[];
+        includeDeleted?: boolean;
+    }>) => Promise<readonly Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>[]>;
+    /**
+     * Live nodes (registry kinds only) sharing any of the given bare ids —
+     * the cross-kind peer set same-id folding would join. Used by graph-merge's
+     * plan-time contradiction simulation to seed its node universe.
+     */
+    liveNodesSharingIds: (ids: readonly string[], target?: GraphBackend | TransactionBackend) => Promise<readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[]>;
+    /**
+     * Every stored assertion row (ended rows included) for the given assertion
+     * ids — the rows the import coordinator's id-conflict check compares
+     * against. Used by graph-merge to validate the one-id-one-truth invariant
+     * at plan time and inside the commit transaction.
+     */
+    identityAssertionRowsByIds: (ids: readonly string[], target?: GraphBackend | TransactionBackend) => Promise<ReadonlyMap<string, Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>>>;
+    /**
+     * The CURRENT structural identity class (materialized closure: folds plus
+     * asserted links) of each reference, keyed by `refKey` — the
+     * `JSON.stringify([kind, id])` serialization exported from
+     * `identity/service`, which callers must use to probe the returned map. A
+     * missing node coalesces to its singleton. Used by graph-merge's fold-peer
+     * window guard to detect class-transitive drift in the plan→commit window.
+     */
+    structuralIdentityClasses: (references: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[], target?: GraphBackend | TransactionBackend) => Promise<ReadonlyMap<string, readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[]>>;
+    identityAssertionsAtTarget: (target: GraphBackend | TransactionBackend, mode?: "state" | "archival") => Promise<readonly Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>[]>;
+    readIdentityAssertionPageAtTarget: (target: GraphBackend | TransactionBackend, mode: "state" | "archival", options: Readonly<{
+        nodeKinds?: readonly string[];
+        includeDeleted?: boolean;
+        after?: string;
+        limit: number;
+    }>) => Promise<Readonly<{
+        assertions: readonly Readonly<{
+            id: string;
+            relation: "same" | "different";
+            a: Readonly<{
+                kind: string;
+                id: string;
+            }>;
+            b: Readonly<{
+                kind: string;
+                id: string;
+            }>;
+            validFrom: string;
+            validTo?: string | undefined;
+            endedBy?: Readonly<{
+                kind: string;
+                id: string;
+            }> | undefined;
+        }>[];
+        nextAfter?: string;
+        done: boolean;
+    }>>;
+    lockIdentityImportTarget: (target: GraphBackend | TransactionBackend) => Promise<void>;
+    foldImportedIdentityNodes: (target: GraphBackend | TransactionBackend, references: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[]) => Promise<void>;
+    importIdentityAssertionsAtTarget: (target: GraphBackend | TransactionBackend, assertions: readonly Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>[], mode: "state" | "archival") => Promise<Readonly<{
+        created: number;
+        skipped: number;
+    }>>;
+    applyIdentityMergeAtTarget: (target: GraphBackend | TransactionBackend, retractionIds: readonly string[], assertions: readonly Readonly<{
+        id: string;
+        relation: "same" | "different";
+        a: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        b: Readonly<{
+            kind: string;
+            id: string;
+        }>;
+        validFrom: string;
+        validTo?: string | undefined;
+        endedBy?: Readonly<{
+            kind: string;
+            id: string;
+        }> | undefined;
+    }>[]) => Promise<Readonly<{
+        created: number;
+        retracted: number;
+    }>>;
+    /**
+     * Proves the identity classes of `seeds` carry no contradiction in the state
+     * the caller's transaction has just written — the post-write half of
+     * graph-merge's identity correctness, scoped to the classes the merge
+     * touched. A refusal aborts the caller's transaction; identity-disabled
+     * graphs resolve immediately.
+     */
+    assertIdentityClassesConsistentAtTarget: (target: GraphBackend | TransactionBackend, seeds: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[]) => Promise<void>;
+}>;
+
+type RebuildFulltextOptions = Readonly<{
+    /** Page size. Must be a positive integer. Default: 500. */
+    pageSize?: number;
+    /**
+     * Maximum number of skipped node IDs to include in the `skippedIds`
+     * array. Default: 10,000. Set higher to collect the full list when
+     * investigating systemic corruption; set lower when `processed` is
+     * all you care about. The `skipped` total is always accurate.
+     */
+    maxSkippedIds?: number;
+}>;
+type RebuildFulltextResult = Readonly<{
+    /** Node kinds that were rebuilt (those with at least one searchable field). */
+    kinds: readonly string[];
+    /** Total nodes scanned. */
+    processed: number;
+    /** Fulltext upsert operations executed. */
+    upserted: number;
+    /** Fulltext delete operations executed (soft-deleted or all-empty nodes). */
+    cleared: number;
+    /**
+     * Nodes skipped due to corrupt or non-object `props` (not counted in
+     * upserted/cleared).
+     */
+    skipped: number;
+    /**
+     * IDs of skipped nodes, capped at 10,000 entries so pathological
+     * corruption doesn't turn rebuild into an OOM. See `skippedTruncated`
+     * to tell whether the cap was hit. Empty when `skipped === 0`.
+     */
+    skippedIds: readonly string[];
+    /** True when `skipped > skippedIds.length` (the cap was reached). */
+    skippedTruncated: boolean;
+}>;
+
+/**
+ * Store-level search helpers.
+ *
+ * `fulltextSearch` is a thin typed wrapper over `backend.fulltextSearch`.
+ * `hybridSearch` runs a vector and a fulltext query in parallel and
+ * fuses the two ranked lists with Reciprocal Rank Fusion. RRF is
+ * rank-based, so it papers over score-scale differences between
+ * pgvector/sqlite-vec (distance-derived) and tsvector/FTS5 (BM25-style).
+ */
+
+/**
+ * A fulltext search hit. `N` defaults to the generic `Node`; the
+ * `store.search.fulltext<K>(kind)` facade narrows it to the concrete
+ * typed node for that kind so callers get `hit.node.title` without a cast.
+ */
+type FulltextSearchHit<N = Node> = Readonly<{
+    node: N;
+    /** Backend-native relevance score; higher is better. */
+    score: number;
+    /** 1-based rank within the result set. */
+    rank: number;
+    /** Highlighted snippet (only present when `includeSnippets: true`). */
+    snippet?: string;
+}>;
+type VectorSearchHit<N = Node> = Readonly<{
+    node: N;
+    score: number;
+    rank: number;
+}>;
+/**
+ * A hybrid search hit. Both sub-results (`vector`, `fulltext`) carry the
+ * same narrowed node type as the top-level `node` for ergonomic access.
+ */
+type HybridSearchHit<N = Node> = Readonly<{
+    node: N;
+    /** Fused RRF score (higher is better). */
+    score: number;
+    /** 1-based rank in the fused list. */
+    rank: number;
+    /** Sub-result from the vector half, if it ranked this node. */
+    vector?: VectorSearchHit<N>;
+    /** Sub-result from the fulltext half, if it ranked this node. */
+    fulltext?: FulltextSearchHit<N>;
+}>;
+/**
+ * Scope options shared by every facade search leg.
+ *
+ * `where` and `includeSubClasses` compile into the search statement's
+ * candidate set (a subquery produced by the store's own query compiler), so
+ * filtering happens INSIDE the engine's top-k — never by post-filtering a
+ * ranked list. `offset` is rank-relative pagination: the engine fetches
+ * `limit + offset` ranked candidates and discards the leading page.
+ */
+type SearchScopeOptions<N extends NodeType = NodeType> = Readonly<{
+    /**
+     * Predicate over the node's properties, compiled by the shared query
+     * compiler into the candidate subquery. Requires a query-capable store.
+     * The facade instantiates `N` to the searched kind's node type, so the
+     * accessor is fully typed at the call site; the base instantiation
+     * exposes the system accessors (`id`, `kind`) for standalone option
+     * values.
+     */
+    where?: (accessor: NodeAccessor<N>) => Predicate;
+    /** Rows to skip after ranking (rank-relative pagination). */
+    offset?: number;
+    /**
+     * Expand the searched kind to include its `subClassOf` descendants.
+     * Vector legs search each declaring kind's storage and merge by score;
+     * kinds that don't declare the embedding field are skipped (mirroring
+     * the query builder). Requires a query-capable store.
+     */
+    includeSubClasses?: boolean;
+}>;
+type FulltextSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
+    /** The user-supplied query string. */
+    query: string;
+    /** Max results. Required. */
+    limit: number;
+    /** Query parser mode. Default: "websearch". */
+    mode?: FulltextQueryMode;
+    /**
+     * Language override for query parsing. Default: the kind's
+     * declared language (the same config rows were indexed with),
+     * which keeps the parsed tsquery a plan-time constant on
+     * PostgreSQL so the GIN index can serve the match.
+     */
+    language?: string;
+    /** Minimum relevance score to include in results. */
+    minScore?: number;
+    /** Return a highlighted snippet alongside each hit. */
+    includeSnippets?: boolean;
+}>;
+type HybridVectorOptions = Readonly<{
+    /** Field path of the embedding column on the node kind. */
+    fieldPath: string;
+    /** Query embedding to compare against. */
+    queryEmbedding: readonly number[];
+    /** Distance metric. Default: "cosine". */
+    metric?: VectorMetric;
+    /** How many candidates to retrieve from the vector side. Default: 4 * limit. */
+    k?: number;
+    /** Minimum similarity to include (units depend on metric). */
+    minScore?: number;
+    /**
+     * HNSW search frontier for this query (pgvector `hnsw.ef_search`).
+     * The vector side over-fetches `k` (default `4 * limit`) candidates;
+     * `efSearch` must be `>= k` for the index to surface that many
+     * neighbors, and ~2–4× `k` is the high-recall target. PostgreSQL
+     * requires an HNSW index and a transaction-capable driver, refusing the
+     * option with a typed error otherwise. Engines with no frontier knob at
+     * all (sqlite-vec, libSQL DiskANN) refuse it too, rather than searching
+     * as if it had not been passed. See `VectorSearchOptions.efSearch`.
+     */
+    efSearch?: number;
+}>;
+/**
+ * Options for the standalone `store.search.vector` path. Mirrors the
+ * vector half of `HybridSearchOptions` but flattens it because the
+ * standalone path doesn't fuse against fulltext.
+ */
+type VectorSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
+    /** Field path of the embedding column on the node kind. */
+    fieldPath: string;
+    /** Query embedding to compare against. */
+    queryEmbedding: readonly number[];
+    /** Max results. Required. */
+    limit: number;
+    /** Distance metric. Default: "cosine". */
+    metric?: VectorMetric;
+    /** Minimum similarity to include (units depend on metric). */
+    minScore?: number;
+    /**
+     * HNSW search frontier for this query (pgvector `hnsw.ef_search`).
+     * Sizes the dynamic candidate list the index scan maintains — higher
+     * trades latency for recall. The floor for the index to surface
+     * `limit` neighbors is `efSearch >= limit`; ~2–4× is the high-recall
+     * target on million-scale corpora. Lets a latency-sensitive
+     * interactive path and a recall-sensitive batch path share one
+     * connection pool, tuning per query rather than per session.
+     *
+     * PostgreSQL HNSW only: applied transaction-locally via `SET LOCAL`.
+     * Everywhere else the option is REFUSED with a typed error naming the
+     * state, never silently ignored — a non-HNSW slot or a driver that
+     * cannot hold a transaction (for example `drizzle-orm/neon-http`) on
+     * PostgreSQL, and any SQLite backend, since neither sqlite-vec's vec0
+     * KNN nor libSQL's `vector_top_k` has a per-search frontier to set.
+     * `backend.capabilities.vector.searchFrontierTuning` states which you
+     * have. Must be a positive integer; pgvector caps it at 1000.
+     */
+    efSearch?: number;
+}>;
+type HybridFulltextOptions = Readonly<{
+    query: string;
+    /** How many candidates to retrieve from the fulltext side. Default: 4 * limit. */
+    k?: number;
+    mode?: FulltextQueryMode;
+    language?: string;
+    minScore?: number;
+    includeSnippets?: boolean;
+}>;
+type HybridSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
+    vector: HybridVectorOptions;
+    fulltext: HybridFulltextOptions;
+    fusion?: HybridFusionOptions;
+    /** Final number of fused results to return. Required. */
+    limit: number;
+}>;
+
+/**
+ * StoreSearch — store.search facade.
+ *
+ * Groups fulltext, vector, hybrid, and maintenance operations under one
+ * namespace so the top-level Store API stays focused on CRUD + graph
+ * traversal. The methods delegate to their respective execution
+ * modules; this class exists to shape the surface and to gate kind
+ * names through the registry — the kind argument is `string` so
+ * graph-extension kinds (added via `store.evolve()`) work without a
+ * type cast, with a runtime guard rejecting misspellings at the call
+ * site.
+ */
+
+/**
+ * Resolves the hit's `node` type. Compile-time kinds keep their
+ * narrowed `Node<N>`; kinds outside `G` (added via graph extension through
+ * `store.evolve()`, or string variables the type system can't see)
+ * widen to the base `Node` so callers don't need a cast.
+ *
+ * This is the same shape as `getNodeCollection` — the dynamic form
+ * works for any registered kind, and the type narrows when (and only
+ * when) the literal is statically known.
+ */
+type ResolveNode<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node : Node;
+/**
+ * The registered `NodeType` behind a kind literal — the accessor-level
+ * companion of {@link ResolveNode}, used to type `where` predicates.
+ * Falls back to the base `NodeType` for dynamic (string) kinds.
+ */
+type ResolveNodeType<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? N : NodeType : NodeType;
+type StoreSearchContext = Readonly<{
+    graphId: string;
+    backend: GraphBackend;
+    registry: KindRegistry;
+    createQuery?: () => QueryBuilder<GraphDef>;
+}>;
+/**
+ * Search-related operations exposed via `store.search`.
+ *
+ * @example
+ * ```typescript
+ * // Fulltext only
+ * const hits = await store.search.fulltext("Document", {
+ *   query: "climate change",
+ *   limit: 10,
+ *   includeSnippets: true,
+ * });
+ *
+ * // Vector only — for extension kinds with embedding() modifiers,
+ * // the auto-derived index serves this query.
+ * const nearest = await store.search.vector("Document", {
+ *   fieldPath: "embedding",
+ *   queryEmbedding: vec,
+ *   limit: 10,
+ * });
+ *
+ * // Hybrid: vector + fulltext, fused with RRF
+ * const ranked = await store.search.hybrid("Document", {
+ *   limit: 10,
+ *   vector: { fieldPath: "embedding", queryEmbedding: vec },
+ *   fulltext: { query: "climate change" },
+ * });
+ *
+ * // Rebuild after backfill / schema change
+ * const stats = await store.search.rebuildFulltext();
+ * ```
+ *
+ * Extension kinds added via `store.evolve(...)` work with all four
+ * methods without a type cast — the kind argument is `string` and a
+ * registry check rejects misspellings at the call site.
+ */
+declare class StoreSearch<G extends GraphDef> {
+    #private;
+    constructor(context: StoreSearchContext);
+    /**
+     * Runs a fulltext search against nodes of the given kind.
+     *
+     * Requires fields on the node schema declared with `searchable()`.
+     * The search hits the backend's fulltext index (tsvector + GIN on
+     * Postgres, FTS5 on SQLite — or whatever strategy the backend is
+     * configured with) and resolves the matching node IDs back to typed
+     * `Node` objects.
+     */
+    fulltext<K extends string>(nodeKind: K, options: FulltextSearchOptions<ResolveNodeType<G, K>>): Promise<readonly FulltextSearchHit<ResolveNode<G, K>>[]>;
+    /**
+     * Runs a vector similarity search against nodes of the given kind.
+     *
+     * Requires a field on the node schema declared with `embedding()`,
+     * either at compile time or via a graph extension (the auto-derived
+     * `VectorIndexDeclaration` flows through `materializeIndexes()` on
+     * the same path either way).
+     *
+     * Pure vector — no fulltext leg, no fusion. For combined
+     * vector+fulltext ranking, use `hybrid`.
+     */
+    vector<K extends string>(nodeKind: K, options: VectorSearchOptions<ResolveNodeType<G, K>>): Promise<readonly VectorSearchHit<ResolveNode<G, K>>[]>;
+    /**
+     * Runs a vector + fulltext hybrid search and fuses the results with
+     * Reciprocal Rank Fusion.
+     *
+     * RRF is rank-based, so it composes well across heterogeneous score
+     * scales (cosine similarity vs ts_rank_cd vs FTS5 BM25). Default
+     * over-fetch is 4× `limit` from each source — tune via `vector.k` /
+     * `fulltext.k` for higher-recall corpora.
+     */
+    hybrid<K extends string>(nodeKind: K, options: HybridSearchOptions<ResolveNodeType<G, K>>): Promise<readonly HybridSearchHit<ResolveNode<G, K>>[]>;
+    /**
+     * Rebuilds the fulltext index from existing node data.
+     *
+     * Use when:
+     * - A node kind gained a `searchable()` field after data was already
+     *   written and existing rows were never indexed.
+     * - The fulltext table was dropped / truncated.
+     * - `language` was changed on a `searchable()` field.
+     *
+     * Iterates nodes with keyset pagination (stable under shared
+     * timestamps and light concurrent writes), transacts per page, skips
+     * kinds with no searchable fields, and cleans up stale rows for
+     * soft-deleted nodes. Corrupt or non-object `props` are counted in
+     * `skipped` with their node IDs surfaced via `skippedIds` so operators
+     * can investigate. Concurrent hard-deletes between page fetches can
+     * be missed by a single pass — run during a maintenance window for
+     * full consistency.
+     */
+    rebuildFulltext<K extends string>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
+}
+
+/**
+ * StoreView — a read-only `(mode, asOf)` lens over a {@link Store}.
+ *
+ * A `StoreView` pins a temporal coordinate and routes every supported
+ * read through it, mirroring Datomic's `(d/as-of db t)` database value
+ * and SQL:2011 `FOR SYSTEM_TIME AS OF`. It is *read-only by
+ * construction*: mutating "the graph as of last Tuesday" is incoherent,
+ * so writes stay on the live `Store`.
+ *
+ * The view is an explicit read context, not a single default flip — the
+ * temporal seam is not uniform across surfaces (the query builder
+ * hardcodes `"current"`, `subgraph` reads `graph.defaults` directly,
+ * collections apply a per-call default). The view therefore injects its
+ * pinned {@link ReadCoordinate} into each surface it hands out through one
+ * helper ({@link withCoordinate}), so a future temporal axis (recorded
+ * time) lands on every surface at once instead of splitting by surface.
+ *
+ * Built on the public `Store` surface (plus one internal sealed-query
+ * seam), so it composes the same reads `branch()` / `merge()` consume.
+ */
+
+/**
+ * The temporal coordinate a {@link StoreView} pins. A discriminated union on
+ * `mode`: `asOf` is *required* for `"asOf"` and *rejected* (`never`) for every
+ * other mode, so the type mirrors the runtime contract. `view({ mode: "asOf" })`
+ * (missing timestamp) and `view({ mode: "current", asOf })` (pinning an instant
+ * outside `"asOf"`) are both compile errors, not merely runtime
+ * `ValidationError`s.
+ */
+type StoreViewCoordinate = Readonly<{
+    mode: "asOf";
+    asOf: string;
+}> | Readonly<{
+    mode: Exclude<TemporalMode, "asOf">;
+    asOf?: never;
+}>;
+/**
+ * {@link Store.subgraph} options with the temporal axis removed — the
+ * view's pinned coordinate supplies it.
+ */
+type StoreViewSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Omit<SubgraphOptions<G, EK, NK, P>, "temporalMode" | "asOf" | "recordedAsOf">;
+/** `reachable` options with the temporal axis removed (the pin supplies it). */
+type StoreViewReachableOptions<G extends GraphDef> = Omit<ReachableOptions<G>, keyof TemporalAlgorithmOptions>;
+/** `shortestPath` options with the temporal axis removed (the pin supplies it). */
+type StoreViewShortestPathOptions<G extends GraphDef> = Omit<ShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
+/**
+ * `weightedShortestPath` options with the temporal axis removed (the pin
+ * supplies it).
+ */
+type StoreViewWeightedShortestPathOptions<G extends GraphDef> = Omit<WeightedShortestPathOptions<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>;
+/** WCC options with the temporal axis removed (the view's pin supplies it). */
+type StoreViewWeaklyConnectedComponentsOptions<G extends GraphDef> = Omit<WeaklyConnectedComponentsOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Label-propagation options pinned to the view's temporal coordinate. */
+type StoreViewLabelPropagationOptions<G extends GraphDef> = Omit<LabelPropagationOptions<G>, keyof TemporalAlgorithmOptions>;
+/** PageRank options with the temporal axis removed (the view supplies it). */
+type StoreViewPageRankOptions<G extends GraphDef> = Omit<PageRankOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Personalized PageRank options pinned to the view's temporal coordinate. */
+type StoreViewPersonalizedPageRankOptions<G extends GraphDef> = Omit<PersonalizedPageRankOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Graph-algorithm facade sealed to a {@link StoreView}'s coordinate. */
+type StoreViewGraphAlgorithms<G extends GraphDef> = Readonly<{
+    shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
+    weightedShortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>) => Promise<WeightedShortestPathResult | undefined>;
+    reachable: (from: NodeIdentifier, options: StoreViewReachableOptions<G>) => Promise<readonly ReachableNode[]>;
+    canReach: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewCanReachOptions<G>) => Promise<boolean>;
+    neighbors: (node: NodeIdentifier, options: StoreViewNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
+    degree: (node: NodeIdentifier, options?: StoreViewDegreeOptions<G>) => Promise<number>;
+    labelPropagation: (options: StoreViewLabelPropagationOptions<G>) => Promise<readonly LabelPropagationMembership[]>;
+    weaklyConnectedComponents: (options: StoreViewWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
+    pageRank: (options: StoreViewPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
+    personalizedPageRank: (options: StoreViewPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
+}>;
+/**
+ * Shared base for the read-only views. Holds the pinned {@link ReadCoordinate}
+ * and delegates the graph algorithms, `subgraph`, and `query` to the live store
+ * with that coordinate flattened into each call. {@link StoreView} (valid-time)
+ * and {@link RecordedStoreView} (recorded-time) extend it; only the surfaces
+ * that genuinely differ — collections, search, and the coordinate-changing
+ * helpers — live on the subclasses.
+ */
+declare abstract class CoordinatePinnedView<G extends GraphDef> {
+    #private;
+    protected readonly store: Store<G>;
+    protected readonly coordinate: ReadCoordinate;
+    constructor(store: Store<G>, coordinate: ReadCoordinate);
+    /** The temporal mode this view reads in. */
+    get mode(): TemporalMode;
+    /** The pinned valid-time `asOf` timestamp, or `undefined` for other modes. */
+    get asOf(): string | undefined;
+    /**
+     * A query builder pinned to this view's coordinate. The temporal axis is
+     * sealed: calling `.temporal(...)` on the returned builder throws, so the
+     * view's coordinate cannot be overridden on a per-query basis.
+     */
+    query(): InitialQueryBuilder<G, "sealed">;
+    protected internalAlgorithms(): InternalGraphAlgorithms<G>;
+    /** Graph algorithms pinned to this view's immutable temporal coordinate. */
+    get algorithms(): StoreViewGraphAlgorithms<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>;
+    /** Minimum-total-weight path at this view's pinned coordinate. */
+    weightedShortestPath(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>): Promise<WeightedShortestPathResult | 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>;
+    /** Deterministic label-propagation memberships at this view's coordinate. */
+    labelPropagation(options: StoreViewLabelPropagationOptions<G>): Promise<readonly LabelPropagationMembership[]>;
+    /** Exact WCC memberships at this view's pinned coordinate. */
+    weaklyConnectedComponents(options: StoreViewWeaklyConnectedComponentsOptions<G>): Promise<readonly WeaklyConnectedComponentMembership[]>;
+    /** Global PageRank scores at this view's pinned coordinate. */
+    pageRank(options: StoreViewPageRankOptions<G>): Promise<readonly PageRankScore[]>;
+    /** Personalized PageRank scores at this view's pinned coordinate. */
+    personalizedPageRank(options: StoreViewPersonalizedPageRankOptions<G>): Promise<readonly PageRankScore[]>;
+}
+/** The runtime half of {@link StoreView}; see that alias for the contract. */
+declare class StoreViewImplementation<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>;
+    /** Heterogeneous multi-kind edge read pinned to this view's coordinate. */
+    bulkFindEdgesFrom<const K extends EdgeKinds<G>>(params: BulkFindEdgesFromParams<G, K>, options?: Omit<EdgeBulkFindEndpointOptions, "temporalMode" | "asOf">): Promise<readonly BulkFindEdgesFromResult<G, K>[]>;
+    /**
+     * Read-only search facade. On a `current` view the read methods
+     * (`fulltext` / `vector` / `hybrid`) delegate to the live `store.search`,
+     * while the mutating `rebuildFulltext` is refused — the view is read-only.
+     * On any non-`current` pin every search method refuses: the fulltext /
+     * vector index reflects current state only, so historical relevance is
+     * out of scope.
+     */
+    get search(): StoreSearch<G>;
+}
+/**
+ * A 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.
+ *
+ * Carries `identity` — pinned identity reads — only when the graph declared
+ * `identity: { ... }`. That conditional presence is why this is a type alias
+ * over an implementation class plus {@link ViewIdentityAccess} rather than a
+ * class declaration, which would put the member on every graph's view.
+ * `instanceof StoreView` still works.
+ *
+ * @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"] });
+ * ```
  */
-type SubgraphNodeResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, P = undefined> = {
-    [Kind in NK]: SubgraphNodeResultForKind<G, Kind, P>;
-}[NK];
+type StoreView<G extends GraphDef> = StoreViewImplementation<G> & ViewIdentityAccess<G>;
+declare const StoreView: new <G extends GraphDef>(store: Store<G>, coordinate: StoreViewCoordinate | ReadCoordinate) => StoreView<G>;
 /**
- * Union of all edge result types in a subgraph, respecting projection.
+ * The runtime half of {@link RecordedStoreView}; see that alias for the
+ * contract.
  */
-type SubgraphEdgeResult<G extends GraphDef, EK extends EdgeKinds<G> = EdgeKinds<G>, P = undefined> = {
-    [Kind in EK]: SubgraphEdgeResultForKind<G, Kind, P>;
-}[EK];
-type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>, EK extends EdgeKinds<G> = EdgeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Readonly<{
-    /** The root node, or undefined if the root was not found or excluded. */
-    root: SubgraphNodeResult<G, NK, P> | undefined;
-    nodes: ReadonlyMap<string, SubgraphNodeResult<G, NK, P>>;
-    /** Forward adjacency: fromId → edgeKind → edges to targets. */
-    adjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
-    /** Reverse adjacency: toId → edgeKind → edges from sources. */
-    reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
-}>;
-
-declare const STORE_RUNTIME: unique symbol;
+declare class RecordedStoreViewImplementation<G extends GraphDef> extends CoordinatePinnedView<G> {
+    #private;
+    constructor(store: Store<G>, coordinate: ReadCoordinate);
+    /** The recorded/system-time anchor this view reconstructs. */
+    get asOfRecorded(): RecordedInstant;
+    /** Recorded-time node reconstructing-read collections. */
+    get nodes(): RecordedStoreViewNodeCollections<G>;
+    /** Recorded-time edge reconstructing-read collections. */
+    get edges(): RecordedStoreViewEdgeCollections<G>;
+}
 /**
- * @internal Operations used by Store-owned views. The port is absent from the
- * public Store contract and non-enumerable at runtime. JavaScript reflection
- * can still discover symbol properties, so this is an unsupported internal
- * surface rather than a security boundary.
+ * 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 expose point reconstruction and bounded scans; 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.
+ *
+ * Like {@link StoreView}, an alias over an implementation class so `identity`
+ * is present only for identity-enabled graphs.
  */
-type StoreRuntime<G extends GraphDef> = Readonly<{
-    backend: GraphBackend;
-    sealedQuery: (coordinate: ReadCoordinate) => InitialQueryBuilder<G, "sealed">;
-    recordedNodeGetById: <N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate) => Promise<Node<N> | undefined>;
-    recordedNodeGetByIds: <N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate) => Promise<readonly (Node<N> | undefined)[]>;
-    recordedNodeScan: <N extends NodeType>(kind: string, coordinate: ReadCoordinate, options?: RecordedScanOptions) => Promise<RecordedScanPage<Node<N>>>;
-    recordedEdgeGetById: <E extends AnyEdgeType>(kind: string, id: EdgeId<E>, coordinate: ReadCoordinate) => Promise<Edge<E> | undefined>;
-    recordedEdgeGetByIds: <E extends AnyEdgeType>(kind: string, ids: readonly EdgeId<E>[], coordinate: ReadCoordinate) => Promise<readonly (Edge<E> | undefined)[]>;
-    recordedEdgeScan: <E extends AnyEdgeType>(kind: string, coordinate: ReadCoordinate, options?: RecordedScanOptions) => Promise<RecordedScanPage<Edge<E>>>;
-    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>>;
-    algorithmsAtCoordinate: (coordinate: ReadCoordinate) => InternalGraphAlgorithms<G>;
-}>;
+type RecordedStoreView<G extends GraphDef> = RecordedStoreViewImplementation<G> & ViewIdentityAccess<G>;
+declare const RecordedStoreView: new <G extends GraphDef>(store: Store<G>, coordinate: ReadCoordinate) => RecordedStoreView<G>;
 
 /**
  * Main Store implementation for TypeGraph.
@@ -4172,6 +4845,31 @@ type ReembedVectorFieldResult = Readonly<{
     /** Number of nodes whose embedding was re-written (0 without `embed`). */
     reembedded: number;
 }>;
+/** Options for {@link Store.rebuildContribution}. */
+type RebuildContributionOptions = Readonly<{
+    /**
+     * Page size for the content reconstruction pass. Default 500.
+     *
+     * Every page runs inside the rebuild's single transaction, so this
+     * trades statement count against per-statement size rather than
+     * bounding how long the transaction is held — that is set by the graph.
+     */
+    pageSize?: number;
+}>;
+/**
+ * The identity surface a store carries, present only when the graph declared
+ * `identity: { ... }`. Conditional *presence* (not a `never`-typed property) is
+ * the encoding used everywhere identity is exposed — `tx.identity` and the
+ * read-only views included — so an identity-disabled graph simply has no
+ * `identity` member to reach for.
+ */
+type StoreIdentityAccess<G extends GraphDef> = G["identity"] extends GraphIdentityConfig ? Readonly<{
+    identity: IdentityFacade<G>;
+}> : Readonly<Record<never, never>>;
+/** The same conditional presence for the read-only pinned views. */
+type ViewIdentityAccess<G extends GraphDef> = G["identity"] extends GraphIdentityConfig ? Readonly<{
+    identity: IdentityReadFacade<G>;
+}> : Readonly<Record<never, never>>;
 type StoreCore<G extends GraphDef> = Readonly<{
     [STORE_RUNTIME]: StoreRuntime<G>;
     graph: G;
@@ -4201,7 +4899,7 @@ type StoreCore<G extends GraphDef> = Readonly<{
     asOf: (asOf: string) => StoreView<G>;
     asOfRecorded: (recordedAsOf: RecordedInstant) => RecordedStoreView<G>;
     recordedNow: () => Promise<RecordedInstant | undefined>;
-    revisionNow: () => Promise<string | undefined>;
+    revisionNow: () => Promise<RecordedInstant | undefined>;
     revisionOriginNow: () => Promise<string>;
     view: (coordinate: StoreViewCoordinate) => StoreView<G>;
     snapshot: () => StoreView<G>;
@@ -4219,9 +4917,11 @@ type StoreCore<G extends GraphDef> = Readonly<{
     reembedVectorField: (kind: string, fieldPath: string, options?: ReembedVectorFieldOptions) => Promise<ReembedVectorFieldResult>;
     verifyContributions: () => Promise<readonly ContributionDiagnostic[]>;
     repairContributions: () => Promise<ContributionRepairResult>;
+    probeContributions: () => Promise<ContributionProbeResult>;
+    rebuildContribution: (scope: ContributionRebuildScope, options?: RebuildContributionOptions) => Promise<ContributionRebuildResult>;
     materializeRemovals: (options?: MaterializeRemovalsOptions) => Promise<MaterializeRemovalsResult>;
     close: () => Promise<void>;
-}>;
+}> & StoreIdentityAccess<G>;
 type StoreTransactions<G extends GraphDef> = Readonly<{
     transaction: <T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions) => Promise<T>;
     transactionWithReceipt: <T>(fn: (tx: MeasurableTransactionContext<G>) => Promise<T>, options?: TransactionOptions) => Promise<TransactionOutcome<T>>;
@@ -4517,182 +5217,4 @@ declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransacti
     SchemaValidationResult
 ]>;
 
-/**
- * StoreView — a read-only `(mode, asOf)` lens over a {@link Store}.
- *
- * A `StoreView` pins a temporal coordinate and routes every supported
- * read through it, mirroring Datomic's `(d/as-of db t)` database value
- * and SQL:2011 `FOR SYSTEM_TIME AS OF`. It is *read-only by
- * construction*: mutating "the graph as of last Tuesday" is incoherent,
- * so writes stay on the live `Store`.
- *
- * The view is an explicit read context, not a single default flip — the
- * temporal seam is not uniform across surfaces (the query builder
- * hardcodes `"current"`, `subgraph` reads `graph.defaults` directly,
- * collections apply a per-call default). The view therefore injects its
- * pinned {@link ReadCoordinate} into each surface it hands out through one
- * helper ({@link withCoordinate}), so a future temporal axis (recorded
- * time) lands on every surface at once instead of splitting by surface.
- *
- * Built on the public `Store` surface (plus one internal sealed-query
- * seam), so it composes the same reads `branch()` / `merge()` consume.
- */
-
-/**
- * The temporal coordinate a {@link StoreView} pins. A discriminated union on
- * `mode`: `asOf` is *required* for `"asOf"` and *rejected* (`never`) for every
- * other mode, so the type mirrors the runtime contract. `view({ mode: "asOf" })`
- * (missing timestamp) and `view({ mode: "current", asOf })` (pinning an instant
- * outside `"asOf"`) are both compile errors, not merely runtime
- * `ValidationError`s.
- */
-type StoreViewCoordinate = Readonly<{
-    mode: "asOf";
-    asOf: string;
-}> | Readonly<{
-    mode: Exclude<TemporalMode, "asOf">;
-    asOf?: never;
-}>;
-/**
- * {@link Store.subgraph} options with the temporal axis removed — the
- * view's pinned coordinate supplies it.
- */
-type StoreViewSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK extends NodeKinds<G>, P extends SubgraphProject<G, NK, EK> | undefined = undefined> = Omit<SubgraphOptions<G, EK, NK, P>, "temporalMode" | "asOf" | "recordedAsOf">;
-/** `reachable` options with the temporal axis removed (the pin supplies it). */
-type StoreViewReachableOptions<G extends GraphDef> = Omit<ReachableOptions<G>, keyof TemporalAlgorithmOptions>;
-/** `shortestPath` options with the temporal axis removed (the pin supplies it). */
-type StoreViewShortestPathOptions<G extends GraphDef> = Omit<ShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
-/**
- * `weightedShortestPath` options with the temporal axis removed (the pin
- * supplies it).
- */
-type StoreViewWeightedShortestPathOptions<G extends GraphDef> = Omit<WeightedShortestPathOptions<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>;
-/** WCC options with the temporal axis removed (the view's pin supplies it). */
-type StoreViewWeaklyConnectedComponentsOptions<G extends GraphDef> = Omit<WeaklyConnectedComponentsOptions<G>, keyof TemporalAlgorithmOptions>;
-/** Label-propagation options pinned to the view's temporal coordinate. */
-type StoreViewLabelPropagationOptions<G extends GraphDef> = Omit<LabelPropagationOptions<G>, keyof TemporalAlgorithmOptions>;
-/** PageRank options with the temporal axis removed (the view supplies it). */
-type StoreViewPageRankOptions<G extends GraphDef> = Omit<PageRankOptions<G>, keyof TemporalAlgorithmOptions>;
-/** Personalized PageRank options pinned to the view's temporal coordinate. */
-type StoreViewPersonalizedPageRankOptions<G extends GraphDef> = Omit<PersonalizedPageRankOptions<G>, keyof TemporalAlgorithmOptions>;
-/** Graph-algorithm facade sealed to a {@link StoreView}'s coordinate. */
-type StoreViewGraphAlgorithms<G extends GraphDef> = Readonly<{
-    shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
-    weightedShortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>) => Promise<WeightedShortestPathResult | undefined>;
-    reachable: (from: NodeIdentifier, options: StoreViewReachableOptions<G>) => Promise<readonly ReachableNode[]>;
-    canReach: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewCanReachOptions<G>) => Promise<boolean>;
-    neighbors: (node: NodeIdentifier, options: StoreViewNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
-    degree: (node: NodeIdentifier, options?: StoreViewDegreeOptions<G>) => Promise<number>;
-    labelPropagation: (options: StoreViewLabelPropagationOptions<G>) => Promise<readonly LabelPropagationMembership[]>;
-    weaklyConnectedComponents: (options: StoreViewWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
-    pageRank: (options: StoreViewPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
-    personalizedPageRank: (options: StoreViewPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
-}>;
-/**
- * Shared base for the read-only views. Holds the pinned {@link ReadCoordinate}
- * and delegates the graph algorithms, `subgraph`, and `query` to the live store
- * with that coordinate flattened into each call. {@link StoreView} (valid-time)
- * and {@link RecordedStoreView} (recorded-time) extend it; only the surfaces
- * that genuinely differ — collections, search, and the coordinate-changing
- * helpers — live on the subclasses.
- */
-declare abstract class CoordinatePinnedView<G extends GraphDef> {
-    #private;
-    protected readonly store: Store<G>;
-    protected readonly coordinate: ReadCoordinate;
-    constructor(store: Store<G>, coordinate: ReadCoordinate);
-    /** The temporal mode this view reads in. */
-    get mode(): TemporalMode;
-    /** The pinned valid-time `asOf` timestamp, or `undefined` for other modes. */
-    get asOf(): string | undefined;
-    /**
-     * A query builder pinned to this view's coordinate. The temporal axis is
-     * sealed: calling `.temporal(...)` on the returned builder throws, so the
-     * view's coordinate cannot be overridden on a per-query basis.
-     */
-    query(): InitialQueryBuilder<G, "sealed">;
-    protected internalAlgorithms(): InternalGraphAlgorithms<G>;
-    /** Graph algorithms pinned to this view's immutable temporal coordinate. */
-    get algorithms(): StoreViewGraphAlgorithms<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>;
-    /** Minimum-total-weight path at this view's pinned coordinate. */
-    weightedShortestPath(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>): Promise<WeightedShortestPathResult | 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>;
-    /** Deterministic label-propagation memberships at this view's coordinate. */
-    labelPropagation(options: StoreViewLabelPropagationOptions<G>): Promise<readonly LabelPropagationMembership[]>;
-    /** Exact WCC memberships at this view's pinned coordinate. */
-    weaklyConnectedComponents(options: StoreViewWeaklyConnectedComponentsOptions<G>): Promise<readonly WeaklyConnectedComponentMembership[]>;
-    /** Global PageRank scores at this view's pinned coordinate. */
-    pageRank(options: StoreViewPageRankOptions<G>): Promise<readonly PageRankScore[]>;
-    /** Personalized PageRank scores at this view's pinned coordinate. */
-    personalizedPageRank(options: StoreViewPersonalizedPageRankOptions<G>): Promise<readonly PageRankScore[]>;
-}
-/**
- * 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>;
-    /** Heterogeneous multi-kind edge read pinned to this view's coordinate. */
-    bulkFindEdgesFrom<const K extends EdgeKinds<G>>(params: BulkFindEdgesFromParams<G, K>, options?: Omit<EdgeBulkFindEndpointOptions, "temporalMode" | "asOf">): Promise<readonly BulkFindEdgesFromResult<G, K>[]>;
-    /**
-     * Read-only search facade. On a `current` view the read methods
-     * (`fulltext` / `vector` / `hybrid`) delegate to the live `store.search`,
-     * while the mutating `rebuildFulltext` is refused — the view is read-only.
-     * On any non-`current` pin every search method refuses: the fulltext /
-     * vector index reflects current state only, so historical relevance is
-     * out of scope.
-     */
-    get search(): StoreSearch<G>;
-}
-/**
- * A narrow recorded-time read lens. It preserves the valid-time coordinate
- * carried by the source view and adds a recorded/system-time pin. Collection
- * reads expose point reconstruction and bounded scans; 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 anchor this view reconstructs. */
-    get asOfRecorded(): RecordedInstant;
-    /** Recorded-time node reconstructing-read collections. */
-    get nodes(): RecordedStoreViewNodeCollections<G>;
-    /** Recorded-time edge reconstructing-read collections. */
-    get edges(): RecordedStoreViewEdgeCollections<G>;
-}
-
-export { type EdgeGetOrCreateByEndpointsResult as $, type AliasMap as A, type BaseStoreOptions as B, type ConstraintNames as C, type DegreeOptions as D, type EdgeAliasMap as E, type DynamicEdgeType as F, type DynamicFieldBuilder as G, type HistoryStoreOptions as H, type DynamicNodeAccessor as I, type DynamicNodeCollection as J, type DynamicNodeType as K, type LiveStoreOptions as L, type DynamicSelectableEdge as M, type DynamicSelectableNode as N, type Edge as O, type EdgeAccessor as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeBatchReads as V, type EdgeBulkFindEndpointOptions as W, type EdgeBulkFindOptions as X, type EdgeCollection as Y, type EdgeFindByEndpointsOptions as Z, type EdgeGetOrCreateByEndpointsOptions as _, type Store as a, type RebuildFulltextOptions as a$, type EdgeIntrospection as a0, type EdgeTemporalReads as a1, type EdgeWrites as a2, type EmptyAliasMap as a3, type EmptyEdgeAliasMap as a4, ExecutableAggregateQuery as a5, ExecutableQuery as a6, type FieldAccessor as a7, type FulltextSearchHit as a8, type FulltextSearchOptions as a9, type NodeAccessor as aA, type NodeAlias as aB, type NodeBulkFindByIndexOptions as aC, type NodeCollection as aD, type NodeCurrentReads as aE, type NodeGetOrCreateByConstraintOptions as aF, type NodeGetOrCreateByConstraintResult as aG, type NodeIdentifier as aH, type NodeRef as aI, type NodeTemporalReads as aJ, type NodeWrites as aK, type OntologyIntrospection as aL, type OperationHookContext as aM, type PageRankOptions as aN, type PageRankScore as aO, type PaginateOptions as aP, type PaginatedResult as aQ, type PathNode as aR, type PersonalizedPageRankOptions as aS, type PersonalizedPageRankSeed as aT, type Predicate as aU, PreparedQuery as aV, type PropsAccessor as aW, type QueryHookContext as aX, type QueryOptions as aY, type ReachableNode as aZ, type ReachableOptions as a_, type GetOrCreateAction as aa, type GraphAlgorithms as ab, type GraphEdgeCollections as ac, type GraphEdgeForKinds as ad, type GraphNodeCollections as ae, type GraphNodeReference as af, type HistoryStoreBackend as ag, type HookContext as ah, type HybridFulltextOptions as ai, type HybridSearchHit as aj, type HybridSearchOptions as ak, type HybridVectorOptions as al, type IfExistsMode as am, type InitialQueryBuilder as an, type KindIntrospection as ao, type LabelPropagationMembership as ap, type LabelPropagationOptions as aq, type MaterializeRemovalsEntry as ar, type MaterializeRemovalsOptions as as, type MaterializeRemovalsResult as at, type MeasurableAdapterHistoryTransactionContext as au, type MeasurableAdapterTransactionContext as av, type MeasurableTransactionContext as aw, type NeighborsOptions as ax, type NoRecordedCoordinate as ay, type Node as az, type HistoryStore as b, type UpdateNodeInput as b$, type RebuildFulltextResult as b0, type ReclaimedVectorFieldEntry as b1, type ReconciledSchema as b2, type RecordedScanOptions as b3, type RecordedScanPage as b4, RecordedStoreView as b5, type RecordedStoreViewEdgeCollection as b6, type RecordedStoreViewEdgeCollections as b7, type RecordedStoreViewNodeCollection as b8, type RecordedStoreViewNodeCollections as b9, type StoreViewNodeCollection as bA, type StoreViewNodeCollections as bB, type StoreViewPageRankOptions as bC, type StoreViewPersonalizedPageRankOptions as bD, type StoreViewReachableOptions as bE, type StoreViewShortestPathOptions as bF, type StoreViewSubgraphOptions as bG, type StoreViewWeaklyConnectedComponentsOptions as bH, type StoreViewWeightedShortestPathOptions as bI, type StreamOptions as bJ, type SubgraphEdgeResult as bK, type SubgraphNodeResult as bL, type SubgraphOptions as bM, type SubgraphResult as bN, type SubsetEdge as bO, type SubsetNode as bP, type TemporalAlgorithmOptions as bQ, type TransactionContext as bR, type TransactionOutcome as bS, type TransactionReceipt as bT, type TraversalDirection as bU, type TypedEdgeCollection as bV, type TypedRecordedStoreViewEdgeCollection as bW, type TypedStoreViewEdgeCollection as bX, UnionableQuery as bY, type UniqueIntrospection as bZ, type UpdateEdgeInput as b_, type RecursiveTraversalOptions as ba, type ReembedFunction as bb, type ReembedVectorFieldOptions as bc, type ReembedVectorFieldResult as bd, type SchemaIntrospection as be, type ScopedMeasure as bf, type SearchScopeOptions as bg, type SelectContext as bh, type SelectableEdge as bi, type SelectableNode as bj, type ShortestPathOptions as bk, type ShortestPathResult as bl, type SqlAvailability as bm, type StoreHooks as bn, type StoreProjection as bo, type StoreRef as bp, StoreSearch as bq, StoreView as br, type StoreViewCanReachOptions as bs, type StoreViewCoordinate as bt, type StoreViewDegreeOptions as bu, type StoreViewEdgeCollection as bv, type StoreViewEdgeCollections as bw, type StoreViewGraphAlgorithms as bx, type StoreViewLabelPropagationOptions as by, type StoreViewNeighborsOptions as bz, type RecordedReadStore as c, type VectorSearchHit as c0, type VectorSearchOptions as c1, type WeaklyConnectedComponentMembership as c2, type WeaklyConnectedComponentsOptions as c3, type WeightedShortestPathOptions as c4, type WeightedShortestPathResult as c5, createAdapterStore as c6, createAdapterStoreWithSchema as c7, createQueryBuilder as c8, createStore as c9, createStoreWithSchema as ca, createVerifiedAdapterStore as cb, createVerifiedStore as cc, defineSubgraphProject as cd, exists as ce, fieldRef as cf, inSubquery as cg, isParameterRef as ch, notExists as ci, notInSubquery as cj, param as ck, type RecursiveAliasMap as d, QueryBuilder as e, type EmptyRecursiveAliasMap as f, type AdapterHistoryStore as g, type AdapterHistoryTransactionContext as h, type AdapterRecordedReadStore as i, type AdapterStore as j, type AdapterTransactionContext as k, type AggregateResult as l, type AlgorithmCyclePolicy as m, type AnyEdge as n, type AnyNode as o, type BaseTraversalOptions as p, type BatchResults as q, type BatchableQuery as r, type BulkEdgeSourceGroup as s, type BulkFindEdgesFromParams as t, type BulkFindEdgesFromResult as u, type BulkOperationHookContext as v, type CreateEdgeInput as w, type CreateNodeInput as x, type DynamicEdgeAccessor as y, type DynamicEdgeCollection as z };
+export { type DynamicNodeCollection as $, type AliasMap as A, type BaseStoreOptions as B, type BatchResults as C, type BatchableQuery as D, type EdgeAliasMap as E, type BulkEdgeSourceGroup as F, type BulkFindEdgesFromParams as G, type HistoryStoreOptions as H, type IdentityAssertion as I, type BulkFindEdgesFromResult as J, type BulkOperationHookContext as K, type LiveStoreOptions as L, type ConstraintNames as M, type Node as N, type CreateEdgeInput as O, type CreateNodeInput as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type DegreeOptions as V, type DynamicEdgeAccessor as W, type DynamicEdgeCollection as X, type DynamicEdgeType as Y, type DynamicFieldBuilder as Z, type DynamicNodeAccessor as _, type Store as a, type PaginateOptions as a$, type DynamicNodeType as a0, type DynamicSelectableEdge as a1, type DynamicSelectableNode as a2, type Edge as a3, type EdgeAccessor as a4, type EdgeBatchReads as a5, type EdgeBulkFindEndpointOptions as a6, type EdgeBulkFindOptions as a7, type EdgeCollection as a8, type EdgeFindByEndpointsOptions as a9, type InitialQueryBuilder as aA, type KindIntrospection as aB, type LabelPropagationMembership as aC, type LabelPropagationOptions as aD, type MaterializeRemovalsEntry as aE, type MaterializeRemovalsOptions as aF, type MaterializeRemovalsResult as aG, type MeasurableAdapterHistoryTransactionContext as aH, type MeasurableAdapterTransactionContext as aI, type MeasurableTransactionContext as aJ, type NeighborsOptions as aK, type NoRecordedCoordinate as aL, type NodeAccessor as aM, type NodeAlias as aN, type NodeBulkFindByIndexOptions as aO, type NodeCollection as aP, type NodeCurrentReads as aQ, type NodeGetOrCreateByConstraintOptions as aR, type NodeGetOrCreateByConstraintResult as aS, type NodeIdentifier as aT, type NodeRef as aU, type NodeTemporalReads as aV, type NodeWrites as aW, type OntologyIntrospection as aX, type OperationHookContext as aY, type PageRankOptions as aZ, type PageRankScore as a_, type EdgeGetOrCreateByEndpointsOptions as aa, type EdgeGetOrCreateByEndpointsResult as ab, type EdgeIntrospection as ac, type EdgeTemporalReads as ad, type EdgeWrites as ae, type EmptyAliasMap as af, type EmptyEdgeAliasMap as ag, ExecutableAggregateQuery as ah, ExecutableQuery as ai, type FieldAccessor as aj, type FulltextSearchHit as ak, type FulltextSearchOptions as al, type GetOrCreateAction as am, type GraphAlgorithms as an, type GraphEdgeCollections as ao, type GraphEdgeForKinds as ap, type GraphNodeCollections as aq, type GraphNodeReference as ar, type HistoryStoreBackend as as, type HookContext as at, type HybridFulltextOptions as au, type HybridSearchHit as av, type HybridSearchOptions as aw, type HybridVectorOptions as ax, type IdentityTraversalOption as ay, type IfExistsMode as az, type HistoryStore as b, type SubsetEdge as b$, type PaginatedResult as b0, type PathNode as b1, type PersonalizedPageRankOptions as b2, type PersonalizedPageRankSeed as b3, type Predicate as b4, PreparedQuery as b5, type PropsAccessor as b6, type QueryHookContext as b7, type QueryOptions as b8, type ReachableNode as b9, type StoreHooks as bA, type StoreProjection as bB, type StoreRef as bC, StoreSearch as bD, StoreView as bE, type StoreViewCanReachOptions as bF, type StoreViewCoordinate as bG, type StoreViewDegreeOptions as bH, type StoreViewEdgeCollection as bI, type StoreViewEdgeCollections as bJ, type StoreViewGraphAlgorithms as bK, type StoreViewLabelPropagationOptions as bL, type StoreViewNeighborsOptions as bM, type StoreViewNodeCollection as bN, type StoreViewNodeCollections as bO, type StoreViewPageRankOptions as bP, type StoreViewPersonalizedPageRankOptions as bQ, type StoreViewReachableOptions as bR, type StoreViewShortestPathOptions as bS, type StoreViewSubgraphOptions as bT, type StoreViewWeaklyConnectedComponentsOptions as bU, type StoreViewWeightedShortestPathOptions as bV, type StreamOptions as bW, type SubgraphEdgeResult as bX, type SubgraphNodeResult as bY, type SubgraphOptions as bZ, type SubgraphResult as b_, type ReachableOptions as ba, type RebuildContributionOptions as bb, type RebuildFulltextOptions as bc, type RebuildFulltextResult as bd, type ReclaimedVectorFieldEntry as be, type ReconciledSchema as bf, type RecordedScanOptions as bg, type RecordedScanPage as bh, RecordedStoreView as bi, type RecordedStoreViewEdgeCollection as bj, type RecordedStoreViewEdgeCollections as bk, type RecordedStoreViewNodeCollection as bl, type RecordedStoreViewNodeCollections as bm, type RecursiveTraversalOptions as bn, type ReembedFunction as bo, type ReembedVectorFieldOptions as bp, type ReembedVectorFieldResult as bq, type SchemaIntrospection as br, type ScopedMeasure as bs, type SearchScopeOptions as bt, type SelectContext as bu, type SelectableEdge as bv, type SelectableNode as bw, type ShortestPathOptions as bx, type ShortestPathResult as by, type SqlAvailability as bz, type RecordedReadStore as c, type SubsetNode as c0, type TemporalAlgorithmOptions as c1, type TransactionContext as c2, type TransactionOutcome as c3, type TransactionReceipt as c4, type TraversalDirection as c5, type TypedEdgeCollection as c6, type TypedRecordedStoreViewEdgeCollection as c7, type TypedStoreViewEdgeCollection as c8, UnionableQuery as c9, type UpdateEdgeInput as ca, type UpdateNodeInput as cb, type VectorSearchHit as cc, type VectorSearchOptions as cd, type WeaklyConnectedComponentMembership as ce, type WeaklyConnectedComponentsOptions as cf, type WeightedShortestPathOptions as cg, type WeightedShortestPathResult as ch, asIdentityAssertionId as ci, createAdapterStore as cj, createAdapterStoreWithSchema as ck, createQueryBuilder as cl, createStore as cm, createStoreWithSchema as cn, createVerifiedAdapterStore as co, createVerifiedStore as cp, defineSubgraphProject as cq, exists as cr, fieldRef as cs, inSubquery as ct, isParameterRef as cu, notExists as cv, notInSubquery as cw, param as cx, type IdentityAssertionId as d, type IdentityAssertionResult as e, type IdentityFacade as f, type IdentityNode as g, type IdentityNodeRefInput as h, type IdentityPair as i, type IdentityReadFacade as j, type IdentityRelation as k, type IdentityWriteSummary as l, type UniqueIntrospection as m, type RecursiveAliasMap as n, QueryBuilder as o, type EmptyRecursiveAliasMap as p, type AdapterHistoryStore as q, type AdapterHistoryTransactionContext as r, type AdapterRecordedReadStore as s, type AdapterStore as t, type AdapterTransactionContext as u, type AggregateResult as v, type AlgorithmCyclePolicy as w, type AnyEdge as x, type AnyNode as y, type BaseTraversalOptions as z };