@nicia-ai/typegraph 0.43.0 → 0.45.0

package/dist/{store-view-DdwBNjZQ.d.ts → store-view-66p92IPi.d.ts}

@@ -1,10 +1,10 @@
-import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-DBFnc7u_.js';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-BtrTYTiB.js';
-import { bZ as ValueType, b_ as PredicateExpression, aw as FulltextQueryMode, b$ as VectorMetricType, Q as QueryAst, J as JsonPointer, a0 as FieldRef, aX as ParameterRef, a as NodeType, b as AnyEdgeType, _ as EdgeType, bq as TraversalExpansion, w as GraphBackend, S as SqlDialect, bh as SqlSchema, c0 as Traversal, c1 as NodePredicate, c2 as ProjectedField, aW as OrderSpec, c3 as AggregateOrderSpec, T as TemporalMode, c4 as GroupBySpec, aE as HybridFusionOptions, aI as JsonPointerInput, c5 as RecursiveCyclePolicy, a3 as TraversalDirection$1, E as EdgeRegistration, aU as NodeId, bn as TransactionBackend, K as KindEntity, aq as ExternalRecordedReadSource, c6 as NodeRow, am as EdgeId, c7 as EdgeRow, N as NodeRegistration, bp as TransactionReadBackend, $ as AggregateExpr, ba as SortDirection, af as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, c8 as VectorSlotMap, c9 as RecordedReadBinding, ca as SelectiveField, cb as ComposableQuery, cc as SetOperationType, cd as SetOperation, ce as VectorMetric, aN as KindAnnotations, W as JsonSchema, bu as UniquenessScope, ab as Collation, aa as Cardinality, ap as EndpointExistence, G as GraphExtension, B as BackendCapabilities, bo as TransactionOptions, A as AdapterBackend } from './types-Dh-EgT-w.js';
-import { K as KindRegistry, S as SchemaManagerOptions, a as SchemaValidationResult } from './manager-Dl0-er1G.js';
+import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-BGrJahvp.js';
+import { R as RecordedInstant, d as ReadCoordinate } from './temporal-Bob6Nfbp.js';
+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.js';
+import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-YoLEfcc1.js';
 import { z } from 'zod';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-C7jmPNLT.js';
-import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-BM3u0aXE.js';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-DLWEfC4a.js';
+import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-Bhhyb1B3.js';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -50,8 +50,10 @@ type Predicate = Readonly<{
  * Creates a named parameter reference for prepared queries.
  *
  * Use with `query.prepare()` to create reusable parameterized queries.
- * Only supported in scalar comparison positions (eq, neq, gt, etc.),
- * string operations, and between bounds. Not supported in `in()`/`notIn()`.
+ * Supported in scalar comparison positions (eq, neq, gt, etc.), string
+ * operations, between bounds, and as the WHOLE list of `in()`/`notIn()` —
+ * `field.in(param("ids"))` bound to an array at execute time. A `param()`
+ * among the individual elements of a literal list is rejected.
  *
  * @example
  * ```typescript
@@ -63,6 +65,18 @@ type Predicate = Readonly<{
  *
  * const results = await prepared.execute({ name: "Alice" });
  * ```
+ *
+ * @example List-valued parameter — one compiled statement, any list length.
+ * ```typescript
+ * const byIds = store.query()
+ *   .from("Person", "p")
+ *   .whereNode("p", (p) => p.id.in(param("ids")))
+ *   .select((ctx) => ctx.p)
+ *   .prepare();
+ *
+ * await byIds.execute({ ids: ["a", "b"] });
+ * await byIds.execute({ ids: ["c"] });
+ * ```
  */
 declare function param(name: string): ParameterRef;
 /**
@@ -305,10 +319,17 @@ type DynamicSelectableEdge = Readonly<{
 
 type QueryCoordinateState = "open" | "sealed";
 /**
- * A query that can be executed within a `store.batch()` call.
+ * A query deferred for execution inside a `store.batch()` call.
  *
  * Both `ExecutableQuery` and `UnionableQuery` satisfy this interface.
  * The result type `R` is preserved per-query in the batch return tuple.
+ *
+ * Deferring costs nothing and saves nothing on its own: `store.batch()` runs
+ * each query as its own statement (sometimes two — see `ExecutableQuery`'s
+ * `executeOn`), so it does not fold these into a single round trip. Whether
+ * they share one connection is up to the adapter, not to
+ * `backend.capabilities.transactions` — see `store.batch()` for the full cost
+ * model.
  */
 type BatchableQuery<R = unknown> = Readonly<{
     executeOn: (backend: GraphBackend | TransactionBackend) => Promise<readonly R[]>;
@@ -417,8 +438,8 @@ type BaseFieldAccessor = Readonly<{
     neq: (value: unknown) => Predicate;
     isNull: () => Predicate;
     isNotNull: () => Predicate;
-    in: (values: readonly unknown[]) => Predicate;
-    notIn: (values: readonly unknown[]) => Predicate;
+    in: (values: readonly unknown[] | ParameterRef) => Predicate;
+    notIn: (values: readonly unknown[] | ParameterRef) => Predicate;
 }>;
 type StringFieldAccessor = BaseFieldAccessor & Readonly<{
     gt: (value: string | ParameterRef) => Predicate;
@@ -744,2075 +765,2234 @@ type CreateQueryBuilderOptions = Readonly<{
 }>;
 
 /**
- * StoreView collection surface buckets.
- *
- * The live NodeCollection / EdgeCollection partition into buckets a StoreView
- * treats differently:
- *
- * - temporal reads honor the pinned coordinate;
- * - current reads have no temporal axis and are refused on temporal pins;
- * - writes are never available on a read-only view; and
- * - batch reads require store.batch() and are absent from a view.
- *
- * These arrays are the single runtime source of truth for the proxy routing and
- * the type-level source for the derived StoreView collection types. The
- * StoreView surface-classification test asserts they exactly partition the live
- * collection methods so new collection methods cannot be silently omitted.
- */
-/** Temporal-aware node read method names. */
-declare const NODE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count"];
-/** Current-state-only node reads (constraint / index lookups). */
-declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindByConstraint", "bulkFindByIndex"];
-/** Node write method names: never available on a read-only StoreView. */
-declare const NODE_WRITE_NAMES: readonly ["create", "createFromRecord", "update", "delete", "hardDelete", "upsertById", "upsertByIdFromRecord", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByConstraint", "bulkGetOrCreateByConstraint"];
-/** Temporal-aware edge read method names. */
-declare const EDGE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count", "findFrom", "findTo", "findByEndpoints"];
-/** Deferred edge batch-read method names. */
-declare const EDGE_BATCH_READ_NAMES: readonly ["batchFindFrom", "batchFindTo", "batchFindByEndpoints"];
-/** Edge write method names: never available on a read-only StoreView. */
-declare const EDGE_WRITE_NAMES: readonly ["create", "update", "delete", "hardDelete", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByEndpoints", "bulkGetOrCreateByEndpoints"];
-/** Recorded-time collection point reads that reconstruct safely by id. */
-declare const RECORDED_POINT_READ_NAMES: readonly ["getById", "getByIds"];
-
-/**
- * Store types for TypeGraph operations.
+ * ExecutableAggregateQuery - A query with aggregate functions that can be executed.
  */
 
 /**
- * Canonical mapping from snake_case row fields to camelCase meta fields.
- *
- * This is the single source of truth for which row columns become metadata.
- * Both the Meta types and the row-to-meta functions in row-mappers.ts must
- * stay in sync with this mapping. If you add a temporal/audit column to a
- * row type, add the mapping here — the compiler will then force you to
- * update the row mapper functions as well (since their return type is
- * NodeMeta/EdgeMeta, which is derived from this mapping).
+ * Result type for aggregate queries.
+ * Maps field refs to their value types and aggregates to numbers.
  */
-type TemporalMetaFieldMap = Readonly<{
-    valid_from: "validFrom";
-    valid_to: "validTo";
-    created_at: "createdAt";
-    updated_at: "updatedAt";
-    deleted_at: "deletedAt";
-}>;
+type AggregateResult<R extends Record<string, FieldRef | AggregateExpr>> = {
+    [K in keyof R]: R[K] extends AggregateExpr ? number : R[K] extends FieldRef ? unknown : never;
+};
 /**
- * Maps row fields to their camelCase meta counterparts, preserving types.
+ * An aggregate query that can be executed.
  */
-type MapRowToMeta<R extends Readonly<Record<string, unknown>>, M extends Readonly<Record<string, string>>> = Readonly<{
-    [SnakeKey in keyof M as M[SnakeKey] & string]: SnakeKey extends keyof R ? R[SnakeKey] : never;
-}>;
+declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends AliasMap, R extends Record<string, FieldRef | AggregateExpr>> {
+    #private;
+    constructor(config: QueryBuilderConfig, state: QueryBuilderState, fields: R);
+    /**
+     * Builds the query AST.
+     */
+    toAst(): QueryAst;
+    /**
+     * Orders results by a grouped field or aggregate alias.
+     *
+     * `key` is one of the output names passed to `.aggregate({...})` — either
+     * a grouped field (e.g. `genre`) or an aggregate alias (e.g. `bookCount`).
+     * Both are ordered the same way: by referencing the SELECT-list output
+     * column, since every `.aggregate()` field is projected with an alias.
+     *
+     * Chain multiple calls to sort by more than one key, in call order:
+     * `.orderBy("genre").orderBy("bookCount", "desc")` sorts by genre first,
+     * then by book count within each genre.
+     *
+     * @example
+     * ```typescript
+     * // Top 2 authors by book count
+     * store.query()
+     *   .from("Author", "a")
+     *   .traverse("wrote", "e")
+     *   .to("Book", "b")
+     *   .groupByNode("a")
+     *   .aggregate({ author: field("a", "name"), bookCount: count("b") })
+     *   .orderBy("bookCount", "desc")
+     *   .limit(2)
+     *   .execute();
+     * ```
+     */
+    orderBy<K extends keyof R & string>(key: K, direction?: SortDirection): ExecutableAggregateQuery<G, Aliases, R>;
+    /**
+     * Limits the number of results.
+     */
+    limit(n: number): ExecutableAggregateQuery<G, Aliases, R>;
+    /**
+     * Offsets the results.
+     */
+    offset(n: number): ExecutableAggregateQuery<G, Aliases, R>;
+    /**
+     * Compiles the query and returns the SQL text and parameters.
+     *
+     * Requires a backend to be configured (the backend determines the SQL dialect).
+     * Use this for debugging, logging, or running the query with a custom executor.
+     */
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
+    /**
+     * Compiles the query to TypeGraph's database-independent SQL fragment.
+     */
+    compile(): CompiledSelectSql;
+    /**
+     * Executes the query and returns typed results.
+     *
+     * @throws Error if no backend is configured
+     */
+    execute(): Promise<readonly AggregateResult<R>[]>;
+}
+
 /**
- * Metadata for a node instance.
- * Derived from NodeRow via TemporalMetaFieldMap + version.
+ * How a "current" valid-time read instant is emitted into compiled SQL:
  *
- * Adding a new metadata column requires:
- * 1. Add the column to NodeRow in backend/types.ts
- * 2. Add the mapping to TemporalMetaFieldMap above
- * 3. The compiler will error in rowToNodeMeta() until you add the field there
+ * - `"literal"` — bound as a concrete value at compile time
+ *   ({@link currentReadInstant}). The instant is frozen into the compiled
+ *   statement, so the statement must be recompiled to observe a newer "now".
+ * - `"placeholder"` — bound as a reserved execution-time placeholder
+ *   ({@link currentReadInstantPlaceholder}). The statement can be compiled
+ *   once and reused across executions, filling a fresh instant each call.
+ *
+ * Defaults to `"literal"` everywhere except the query builder's compiled
+ * template cache, which opts into `"placeholder"` so a reused/prepared query
+ * never freezes "now" the way a cached literal would (the #246 regression).
  */
-type NodeMeta = MapRowToMeta<NodeRow, TemporalMetaFieldMap> & Readonly<{
-    version: NodeRow["version"];
-}>;
+type ReadInstantMode = "literal" | "placeholder";
+
 /**
- * A node instance in the graph.
+ * Query Compiler Module
  *
- * Properties from the schema are spread at the top level for ergonomic access:
- * - `node.name` instead of `node.props.name`
- * - System metadata is under `node.meta.*`
+ * Main entry point for compiling query ASTs to SQL.
+ * Re-exports individual compiler modules and provides the main compile functions.
  */
-type Node<N extends NodeType = NodeType> = Readonly<{
-    kind: N["kind"];
-    id: NodeId<N>;
-    meta: NodeMeta;
-}> & Readonly<z.infer<N["schema"]>>;
+
 /**
- * Input for creating a node.
+ * Options for query compilation.
  */
-type CreateNodeInput<N extends NodeType = NodeType> = Readonly<{
-    kind: N["kind"];
-    id?: string;
-    props: z.infer<N["schema"]>;
-    validFrom?: string;
-    validTo?: string;
+type CompileQueryOptions = Readonly<{
+    /** SQL dialect ("sqlite" or "postgres"). Defaults to "sqlite". */
+    dialect?: SqlDialect | undefined;
+    /** SQL schema configuration from createSqlSchema(...). Defaults to standard names. */
+    schema?: SqlSchema | undefined;
+    /**
+     * Fulltext strategy override. When set, overrides the dialect's
+     * default fulltext strategy for `$fulltext.matches()` compilation.
+     * Callers typically read this from `backend.fulltextStrategy` so a
+     * backend-declared strategy (e.g. ParadeDB) wins over the dialect
+     * default (tsvector).
+     */
+    fulltextStrategy?: FulltextStrategy | undefined;
+    /**
+     * Vector strategy override. When set, `field.similarTo(...)`
+     * predicates compile against the strategy's per-`(kind, field)`
+     * tables and distance expression. Callers read it from
+     * `backend.vectorStrategy` so a backend-declared strategy (pgvector,
+     * libsql-native, sqlite-vec) drives the per-field relevance scan.
+     */
+    vectorStrategy?: VectorStrategy | undefined;
+    /**
+     * Whether the active backend supports SQL window functions such as
+     * `ROW_NUMBER()`. Defaults to true for direct compiler callers.
+     */
+    windowFunctions?: boolean | undefined;
+    /**
+     * Declared embedding slots `(kind, fieldPath) -> descriptor` used by
+     * the `field.similarTo(...)` CTE to know which kinds in an alias
+     * declare the field. Callers build it from the graph's node schemas.
+     */
+    vectorSlots?: VectorSlotMap | undefined;
+    /** Per-kind declared fulltext language (see buildFulltextLanguages). */
+    fulltextLanguages?: ReadonlyMap<string, string> | undefined;
+    /**
+     * Recorded read relation to use when the AST carries `recordedAsOf`.
+     * Supplying a recorded timestamp without this binding is rejected so the
+     * compiler never silently swaps to TypeGraph's built-in history tables when
+     * the store was only configured for live/valid-time reads.
+     */
+    recordedReadBinding?: RecordedReadBinding | undefined;
+    /**
+     * How the "current" valid-time read instant is emitted. Defaults to
+     * `"literal"` (a value frozen at compile time). The query builder's
+     * compiled template cache passes `"placeholder"` so the instant is a
+     * reserved execution-time slot, letting one compiled statement be reused
+     * across executions with a fresh "now" each call. See {@link ReadInstantMode}.
+     */
+    readInstant?: ReadInstantMode | undefined;
 }>;
+
 /**
- * Input for updating a node.
+ * PreparedQuery — a pre-validated, parameterized query.
+ *
+ * Created via `ExecutableQuery.prepare()`. Builds and structurally validates
+ * the query AST once at prepare time (so a malformed query fails fast, before
+ * the first `execute()`).
+ *
+ * Fast path: when the backend can compile and run raw SQL (`compileSql` +
+ * `executeRaw`) AND the statement is raw-executable, it is compiled ONCE
+ * into a cached template whose
+ * "current" read instant and user `param()` refs are reserved placeholders
+ * (see {@link buildReadInstantTemplate}). Every `execute()` fills those
+ * placeholders — a fresh instant plus the call's bindings — and runs the
+ * cached SQL text directly, so a reused prepared query never recompiles and
+ * never freezes "now" the way a cached literal instant would (the #246
+ * regression).
+ *
+ * Fallback: substitutes parameter refs into the AST, compiles fresh per call,
+ * and executes via the standard `backend.execute` path. Taken in two cases —
+ * a backend without raw execution (custom/async), and a statement that is not
+ * raw-executable because its execution semantics ride on the compiled SQL
+ * OBJECT rather than its text (approximate vector search's iterative-scan
+ * wrapper, `subgraph()`'s force-custom-plan fetches). The second applies even
+ * on PostgreSQL with `executeRaw` available; `isRawExecutable` in
+ * `sql-intent.ts` is the predicate that decides it.
  */
-type UpdateNodeInput<N extends NodeType = NodeType> = Readonly<{
-    kind: N["kind"];
-    id: NodeId<N>;
-    props: Partial<z.infer<N["schema"]>>;
-    validTo?: string;
+
+type PreparedQueryConfig<R> = Readonly<{
+    ast: QueryAst;
+    unoptimizedAst: QueryAst;
+    backend: GraphBackend;
+    dialect: SqlDialect;
+    graphId: string;
+    compileOptions: CompileQueryOptions;
+    state: QueryBuilderState;
+    selectiveFields: readonly SelectiveField[] | undefined;
+    selectFn: (context: SelectContext<AliasMap, EdgeAliasMap>) => R;
+    schemaIntrospector: SchemaIntrospector;
 }>;
 /**
- * Metadata for an edge instance.
- * Derived from EdgeRow via TemporalMetaFieldMap (edges have no version).
- */
-type EdgeMeta = MapRowToMeta<EdgeRow, TemporalMetaFieldMap>;
-/**
- * An edge instance in the graph.
+ * A pre-validated, parameterized query — see the module doc comment above for
+ * how a reused prepared query runs a cached SQL template with a fresh read
+ * instant filled per call.
  *
- * Properties from the schema are spread at the top level for ergonomic access:
- * - `edge.role` instead of `edge.props.role`
- * - System metadata is under `edge.meta.*`
- */
-type Edge<E extends AnyEdgeType = EdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
-    id: EdgeId<E>;
-    kind: E["kind"];
-    fromKind: From["kind"];
-    fromId: NodeId<From>;
-    toKind: To["kind"];
-    toId: NodeId<To>;
-    meta: EdgeMeta;
-}> & Readonly<z.infer<E["schema"]>>;
-/**
- * Input for creating an edge.
- */
-type CreateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
-    kind: E["kind"];
-    id?: string;
-    fromKind: string;
-    fromId: string;
-    toKind: string;
-    toId: string;
-    props: z.infer<E["schema"]>;
-    validFrom?: string;
-    validTo?: string;
-}>;
-/**
- * Input for updating an edge.
- */
-type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
-    id: EdgeId<E>;
-    props: Partial<z.infer<E["schema"]>>;
-    validTo?: string;
-}>;
-/**
- * Options for node and edge queries.
+ * @example
+ * ```typescript
+ * const prepared = store.query()
+ *   .from("Person", "p")
+ *   .whereNode("p", (p) => p.name.eq(param("name")))
+ *   .select((ctx) => ctx.p)
+ *   .prepare();
+ *
+ * // Execute with different bindings
+ * const alice = await prepared.execute({ name: "Alice" });
+ * const bob = await prepared.execute({ name: "Bob" });
+ * ```
  */
-type NoRecordedCoordinate = Readonly<{
+declare class PreparedQuery<R> {
+    #private;
+    constructor(config: PreparedQueryConfig<R>);
+    /** The set of parameter names required by this prepared query. */
+    get parameterNames(): ReadonlySet<string>;
     /**
-     * Recorded/system-time coordinates are internal-only and supplied by
-     * RecordedStoreView. A public options object carrying this key is a type
-     * error even when the object is pre-bound before the call site.
+     * Executes the prepared query with the given parameter bindings.
+     *
+     * @param bindings - A record mapping parameter names to their values
+     * @returns The query results
      */
-    recordedAsOf?: never;
-}>;
-type QueryOptions = NoRecordedCoordinate & Readonly<{
-    /** Temporal mode for the query */
-    temporalMode?: TemporalMode;
-    /** Specific timestamp for asOf queries */
-    asOf?: string;
-}>;
-/**
- * Context passed to observability hooks.
- */
-type HookContext = Readonly<{
-    /** Unique ID for this operation */
-    operationId: string;
-    /** Graph ID */
-    graphId: string;
-    /** Timestamp when operation started */
-    startedAt: Date;
-}>;
+    execute(bindings?: Readonly<Record<string, unknown>>): Promise<readonly R[]>;
+}
+
 /**
- * Query hook context with SQL information.
+ * UnionableQuery - A query formed by combining multiple queries with set operations.
  */
-type QueryHookContext = HookContext & Readonly<{
-    /** The SQL query being executed */
-    sql: string;
-    /** Query parameters */
-    params: readonly unknown[];
-}>;
+
+interface ExecutableQueryLike<G extends GraphDef, R> {
+    toAst(): QueryAst;
+}
 /**
- * Operation hook context for CRUD operations.
+ * Internal state for unionable query.
  */
-type OperationHookContext = HookContext & Readonly<{
-    /** Operation type */
-    operation: "create" | "update" | "delete";
-    /** Entity type */
-    entity: KindEntity;
-    /** Kind of node or edge */
-    kind: string;
-    /** Entity ID */
-    id: string;
+type UnionableQueryState = Readonly<{
+    left: ComposableQuery;
+    operator: SetOperationType;
+    right: ComposableQuery;
+    limit?: number;
+    offset?: number;
+    startAlias?: string;
+    traversals?: readonly Traversal[];
+    selectFn?: (context: SelectContext<AliasMap, EdgeAliasMap>) => unknown;
 }>;
-/**
- * Observability hooks for monitoring store operations.
- *
- * Note: Batch operations (`bulkCreate`, `bulkInsert`, `bulkUpsertById`) skip
- * per-item operation hooks for throughput. Query hooks still fire normally.
- *
- * @example
- * ```typescript
- * const hooks: StoreHooks = {
- *   onQueryStart: (ctx) => {
- *     console.log(`[${ctx.operationId}] Query: ${ctx.sql}`);
- *   },
- *   onQueryEnd: (ctx, result) => {
- *     const duration = Date.now() - ctx.startedAt.getTime();
- *     console.log(`[${ctx.operationId}] Completed in ${duration}ms`);
- *   },
- *   onError: (ctx, error) => {
- *     console.error(`[${ctx.operationId}] Error:`, error);
- *   },
- * };
- *
- * const store = createStore(graph, backend, { hooks });
- * ```
- */
-type StoreHooks = Readonly<{
-    /** Called before a query is executed */
-    onQueryStart?: (ctx: QueryHookContext) => void;
-    /** Called after a query completes successfully */
-    onQueryEnd?: (ctx: QueryHookContext, result: Readonly<{
-        rowCount: number;
-        durationMs: number;
-    }>) => void;
-    /** Called before a CRUD operation starts */
-    onOperationStart?: (ctx: OperationHookContext) => void;
+declare class UnionableQuery<G extends GraphDef, R> {
+    #private;
+    constructor(config: QueryBuilderConfig, state: UnionableQueryState);
     /**
-     * Called after a CRUD operation completes AND is durably committed. For a
-     * top-level operation that is when its own transaction commits; for an
-     * operation inside `store.transaction`, emission is deferred until the
-     * enclosing transaction commits — if that commit fails, the operation is
-     * reported through `onError` instead. (Inside an adopted transaction —
-     * `withTransaction` / `withRecordedTransaction` — the commit belongs to
-     * the caller and cannot be observed, so this fires when the operation
-     * completes within the still-open transaction.)
+     * Combines with another query using UNION.
      */
-    onOperationEnd?: (ctx: OperationHookContext, result: Readonly<{
-        durationMs: number;
-    }>) => void;
+    union(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
     /**
-     * Called when an operation fails — including an operation that completed
-     * inside a `store.transaction` whose commit then failed and rolled it
-     * back.
+     * Combines with another query using UNION ALL.
      */
-    onError?: (ctx: HookContext, error: Error) => void;
-}>;
-type BaseStoreOptions = Readonly<{
-    /** Observability hooks for monitoring */
-    hooks?: StoreHooks;
+    unionAll(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
     /**
-     * Maintain a durable, graph-wide revision anchor for TypeGraph writes:
-     * a random per-graph origin plus a monotonic revision clock. `branch()` uses
-     * this anchor to validate that its base has not moved without
-     * re-fingerprinting every live row, and cannot confuse a coincident clock in
-     * a separately created store for its original base. `history: true` enables
-     * the same tracking automatically through its recorded-time commit clock.
-     *
-     * This is intentionally opt-in for live stores: each successful graph write
-     * advances the anchor inside its write transaction. On PostgreSQL, those
-     * transactions take a graph-scoped advisory lock until commit; writes to the
-     * same graph therefore serialize. Enable it for branchable graphs, but size
-     * high-throughput multi-writer workloads for that trade-off.
-     *
-     * Writes performed directly through a backend — including raw graph-table
-     * writes through `tx.sql` — bypass the anchor and are outside the
-     * revision-tracking contract.
+     * Combines with another query using INTERSECT.
      */
-    revisionTracking?: boolean;
+    intersect(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
     /**
-     * Automatic planner-statistics refresh after large autocommit bulk
-     * writes (bulkCreate and bulkInsert on nodes and edges). Stale statistics after a
-     * bulk load are a whole class of planner cliffs: the planner keeps
-     * pre-load row estimates until ANALYZE runs. When a single
-     * autocommit bulk write reaches the threshold
-     * ({@link AUTO_REFRESH_STATISTICS_ROW_THRESHOLD} rows by default),
-     * the store runs `refreshStatistics()` after the write commits.
-     * Pass a number to change the threshold, or `false` to disable.
-     * Bulk writes inside a caller-provided transaction never
-     * auto-refresh (statistics cannot see uncommitted rows); refresh
-     * manually after commit. `importGraph` handles its own refresh.
+     * Combines with another query using EXCEPT.
      */
-    autoRefreshStatistics?: false | number;
+    except(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
     /**
-     * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose
-     * validated props are value-identical to the existing live row. Default
-     * off.
+     * Limits the number of results from the combined query.
+     */
+    limit(n: number): UnionableQuery<G, R>;
+    /**
+     * Offsets the results from the combined query.
+     */
+    offset(n: number): UnionableQuery<G, R>;
+    /**
+     * Builds the set operation AST.
+     */
+    toAst(): SetOperation;
+    /**
+     * Compiles the query and returns the SQL text and parameters.
      *
-     * Enable this for at-least-once / replay materializers. An event log that
-     * re-delivers a byte-identical change would otherwise rewrite the row anyway:
-     * today an `upsertById` on an existing id calls `updateNode`
-     * unconditionally, allocating a fresh recorded instant and a new history row
-     * per re-delivery.
+     * Requires a backend to be configured (the backend determines the SQL dialect).
+     * Use this for debugging, logging, or running the query with a custom executor.
+     */
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
+    /**
+     * Compiles the set operation to SQL.
+     */
+    compile(): CompiledSelectSql;
+    /**
+     * Executes the combined query.
+     */
+    execute(): Promise<readonly R[]>;
+    /**
+     * Executes the combined query against a provided backend.
      *
-     * The win is scoped to re-delivery of the **current** value. A full
-     * replay-from-zero over the current state still writes wherever the stream
-     * superseded a value in place: re-applying an older value over the live row
-     * is a genuine change (and restoring the current value afterwards is
-     * another), so only streams whose rows never supersede each other replay
-     * without churn. A rebuild that should avoid that re-walk belongs in a fresh
-     * store — replay into it and publish it, rather than re-applying the log
-     * over current state.
-     *
-     * When enabled, an upsert that would not change the stored value performs
-     * **no write at all**: no `updateNode`, no recorded-time capture, no history
-     * row, no revision-anchor advance, and no `update` operation hooks (nothing
-     * happened, so nothing is reported). It resolves with the **existing** node,
-     * preserving its original `validFrom` / `updatedAt` / `version`.
-     *
-     * Receipt shape is unchanged and needs no new signal: a coalesced upsert
-     * still counts as one write intent (`writes.total` includes it), but
-     * captures nothing (`receipt.recorded` stays `undefined` when it is the only
-     * write) — the same shape a no-op delete already produces, so a consumer
-     * that carries the prior anchor forward on `recorded === undefined` handles
-     * it unchanged.
-     *
-     * 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).
-     *   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
-     *      temporal override is a deliberate request and is never coalesced;
-     *      applied per item in the bulk path).
-     *   4. The new props, merged over the stored props and run through the
-     *      kind's Zod schema (defaults applied, values normalized), are deeply
-     *      value-identical to the stored props (key order aside).
-     *
-     * Default-off because some consumers *want* an audit row per re-delivery as
-     * proof the event was reprocessed; coalescing removes that signal.
+     * Used by `store.batch()` to run several queries in sequence against one
+     * target — a transaction on backends that have them, the backend itself
+     * otherwise. A set operation compiles to one statement; whether that target
+     * is a shared connection is the adapter's business, not a function of
+     * transaction support.
      */
-    coalesceUnchangedUpserts?: boolean;
-    /** SQL schema configuration from createSqlSchema(...) for custom table names */
-    schema?: SqlSchema;
-    /** Query default behaviors. */
-    queryDefaults?: Readonly<{
-        /** Default traversal ontology expansion mode (default: "inverse"). */
-        traversalExpansion?: TraversalExpansion;
-    }>;
-}>;
-/**
- * Store options without built-in recorded-time capture. A recorded read relation
- * can still be bound explicitly for hosts that populate history externally.
- */
-type LiveStoreOptions = BaseStoreOptions & Readonly<{
-    history?: false | undefined;
-    recordedRead?: ExternalRecordedReadSource | undefined;
-}>;
-/** Live-store options that do not bind a recorded-read relation. */
-type UnboundLiveStoreOptions = LiveStoreOptions & Readonly<{
-    recordedRead?: undefined;
-}>;
-/** Live-store options with an explicitly bound recorded-read relation. */
-type RecordedReadStoreOptions = LiveStoreOptions & Readonly<{
-    recordedRead: NonNullable<LiveStoreOptions["recordedRead"]>;
-}>;
-/**
- * Store options with TypeGraph-managed recorded-time capture. `history: true`
- * captures TypeGraph writes and binds TypeGraph's built-in recorded relation
- * internally. Externally populated recorded read sources are read-only bindings
- * and are intentionally accepted only by {@link LiveStoreOptions}.
- */
-type HistoryStoreOptions = BaseStoreOptions & Readonly<{
-    history: true;
-    recordedRead?: never;
-}>;
-/**
- * Options for creating a store.
- */
-type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
-/**
- * A mutable handle to the current `Store`, used by `store.evolve(...)`
- * so long-lived consumers can dereference through the ref and pick up
- * the new store after each evolve call. `current` is overwritten by
- * `evolve()` atomically with the schema commit when the ref is passed
- * via `evolve(extension, { ref })`.
- *
- * **Mid-request semantics.** `ref.current` flips on the *next* call
- * after evolve, not mid-handler. Dereference once at request entry and
- * reuse the captured `Store` for the duration:
- *
- * ```ts
- * async function handleRequest(): Promise<void> {
- *   const store = ref.current; // capture once
- *   const tag = await store.nodes.Tag?.create({ label: "..." });
- *   // ...further work on the same `store`...
- * }
- * ```
- *
- * Pure dereferenceable handle — no event/subscription machinery. If
- * consumers need eventing, they wrap the ref themselves.
- *
- * Generic over the held value (typically `Store<G>`) so the store
- * module can refer to it without importing the `Store` class into
- * `types.ts`. The type parameter is deliberately invariant: evolution writes
- * a replacement into `current`, so a ref for an adapter-only or history-only
- * Store must never be accepted by a Store that cannot preserve that surface.
- */
-interface StoreRef<in out T> {
-    current: T;
+    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
 }
+
 /**
- * Result plus write summary. Returned by `store.transactionWithReceipt(fn)`,
- * `store.withRecordedTransaction(externalTx, fn)` (the adopted-commit path), and
- * `tx.measure(fn)` (a scoped sub-receipt). See {@link TransactionReceipt}.
+ * ExecutableQuery - A query that can be executed, paginated, or streamed.
  */
-type TransactionOutcome<T> = Readonly<{
-    result: T;
-    receipt: TransactionReceipt;
-}>;
+
 /**
- * Transaction write summary.
- *
- * Receipt counts are completed write intents at the collection surface, not
- * rows affected:
- *
- * 1. Every successful completion of a write method on `tx.nodes.*` /
- *    `tx.edges.*` counts. The authoritative method list is
- *    {@link NodeWrites} / {@link EdgeWrites}.
- * 2. Bulk methods count by input length; an empty bulk call (`bulkCreate([])`)
- *    counts 0.
- * 3. Single-row methods count 1 on resolve — including `delete` of an absent
- *    id and `getOrCreate*` that found an existing row. Consumers that need
- *    "did anything actually change" semantics apply their own per-operation
- *    policy.
- * 4. A method that rejects counts 0 — even when the backend applied part of a
- *    bulk input before failing. On SQLite a failed statement does not abort
- *    the surrounding transaction, so a caller that catches the rejection and
- *    commits can persist rows the receipt never counted. Do not read the
- *    receipt as rows-affected in that scenario.
- * 5. A node `delete` under `cascade` / `disconnect` removes connected edges
- *    through the backend, not the edge-collection surface; those removals do
- *    not appear in `edges`.
- * 6. Rows-affected fidelity is intentionally out of scope for this first
- *    version; a future extension could ask backends to return row counts.
+ * A query that can be executed.
  */
-type TransactionReceipt = Readonly<{
-    writes: Readonly<{
-        /** Completed node write intents by node kind. */
-        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. */
-        total: number;
-    }>;
+declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap = {}, RecursiveAliases extends RecursiveAliasMap = {}, R = unknown> {
+    #private;
+    constructor(config: QueryBuilderConfig, state: QueryBuilderState, selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R);
     /**
-     * The recorded commit instant allocated for this store's graph by this
-     * transaction. Undefined when history capture is off, the transaction is
-     * read-only, or no captured writes were flushed. **Always undefined on a
-     * scoped receipt from {@link ScopedMeasure}** (`tx.measure`) — the recorded
-     * instant is a per-transaction flush concern allocated once when the whole
-     * transaction's capture flushes, unknowable mid-transaction.
+     * Builds the query AST (memoized — the instance is immutable).
      */
-    recorded?: RecordedInstant;
-}>;
-/**
- * Behavior when a get-or-create operation matches an existing record.
- */
-type IfExistsMode = "return" | "update";
-/**
- * Action taken by a get-or-create operation.
- */
-type GetOrCreateAction = "created" | "found" | "updated" | "resurrected";
-/**
- * Result of a node getOrCreateByConstraint operation.
- */
-type NodeGetOrCreateByConstraintResult<N extends NodeType> = Readonly<{
-    node: Node<N>;
-    action: GetOrCreateAction;
-}>;
-/**
- * Options for node getOrCreateByConstraint operations.
- */
-type NodeGetOrCreateByConstraintOptions = Readonly<{
-    /** Existing record behavior. Default: "return" */
-    ifExists?: IfExistsMode;
-}>;
-/**
- * Options for node bulkFindByIndex operations.
- */
-type NodeBulkFindByIndexOptions = Readonly<{
+    toAst(): QueryAst;
     /**
-     * Maximum number of candidate nodes returned per input item. When omitted,
-     * each input's candidate set is unbounded. Must be a positive integer.
-     *
-     * Candidates are ordered deterministically by node id, so the cap is stable
-     * across calls. Use this to bound fan-out on low-selectivity index keys.
+     * Orders results.
      */
-    limitPerInput?: number;
-}>;
-/**
- * Result of an edge getOrCreateByEndpoints operation.
- */
-type EdgeGetOrCreateByEndpointsResult<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
-    edge: Edge<E, From, To>;
-    action: GetOrCreateAction;
-}>;
-/**
- * Options for edge findByEndpoints operations.
- */
-type EdgeFindByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
+    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
     /**
-     * Edge property fields to include in the match alongside the (from, to) endpoints.
-     * When omitted, matches on endpoints only (returns the first edge at the read coordinate).
+     * Limits the number of results.
      */
-    matchOn?: readonly (keyof z.input<E["schema"]>)[];
-    /** Property values to match against when matchOn is specified. */
-    props?: Partial<z.input<E["schema"]>>;
-}>;
-/**
- * Options for edge getOrCreateByEndpoints operations.
- */
-type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
+    limit(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
     /**
-     * Edge property fields to include in the match key alongside the (from, to) endpoints.
-     * Default: `[]` — match on endpoints only.
+     * Offsets the results.
      */
-    matchOn?: readonly (keyof z.input<E["schema"]>)[];
-    /** Existing record behavior. Default: "return" */
-    ifExists?: IfExistsMode;
+    offset(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
     /**
-     * Valid-time start for a newly created edge. Ignored when an edge is found,
-     * updated, or resurrected.
+     * Applies a query fragment to transform this executable query.
+     *
+     * Useful for applying post-select transformations like ordering,
+     * limits, and offsets from reusable fragments.
+     *
+     * @example
+     * ```typescript
+     * const paginated = (q) => q.orderBy("u", "createdAt", "desc").limit(10);
+     *
+     * const results = await query()
+     *   .from("User", "u")
+     *   .select((ctx) => ctx.u)
+     *   .pipe(paginated)
+     *   .execute();
+     * ```
+     *
+     * @param fragment - A function that transforms the executable query
+     * @returns The transformed executable query
      */
-    validFrom?: string;
+    pipe<NewR = R>(fragment: (query: ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>) => ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>;
     /**
-     * Valid-time end for a created, updated, or resurrected edge. Ignored when
-     * the operation returns an existing edge without writing.
+     * Combines this query with another using UNION (removes duplicates).
      */
-    validTo?: string;
-}>;
-/**
- * A collection of nodes of a specific type.
- *
- * Provides ergonomic CRUD operations for a single node type.
- */
-type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
+    union(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * Create a new node.
-     *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * Combines this query with another using UNION ALL (keeps duplicates).
      */
-    create: (props: z.input<N["schema"]>, options?: Readonly<{
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
-    /** Get a node by ID */
-    getById: (id: NodeId<N>, options?: QueryOptions) => Promise<Node<N> | undefined>;
-    /** Get multiple nodes by ID, preserving input order (undefined for missing) */
-    getByIds: (ids: readonly NodeId<N>[], options?: QueryOptions) => Promise<readonly (Node<N> | undefined)[]>;
-    /** Update a node */
-    update: (id: NodeId<N>, props: Partial<z.input<N["schema"]>>, options?: Readonly<{
-        validTo?: string;
-    }>) => Promise<Node<N>>;
-    /** Delete a node (soft delete - sets deletedAt timestamp) */
-    delete: (id: NodeId<N>) => Promise<void>;
+    unionAll(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * Permanently delete a node from the database.
-     *
-     * Unlike `delete()` which performs a soft delete, this permanently
-     * removes the node and its associated data (uniqueness entries, embeddings).
-     *
-     * **Warning:** This operation is irreversible and should be used carefully.
-     * Consider using soft delete (`delete()`) for most use cases.
-     *
-     * @throws Error if edges are still connected to this node (delete edges first)
+     * Combines this query with another using INTERSECT.
      */
-    hardDelete: (id: NodeId<N>) => Promise<void>;
+    intersect(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * Find nodes matching criteria.
-     *
-     * Supports predicate filtering via the `where` option for SQL-level filtering.
-     * For simple queries. Use store.query() for complex traversals.
+     * Combines this query with another using EXCEPT.
      */
-    find: (filter?: Readonly<{
-        where?: (accessor: NodeAccessor<N>) => Predicate;
-        limit?: number;
-        offset?: number;
-    }>, temporal?: QueryOptions) => Promise<Node<N>[]>;
-    /** Count nodes matching criteria */
-    count: (temporal?: QueryOptions) => Promise<number>;
+    except(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * Create a node from untyped data, relying on runtime Zod validation.
-     *
-     * Use this for dynamic dispatch (changesets, migrations, imports) where
-     * the data shape is determined at runtime, not compile time.
-     * The return type is fully typed — only the input gate is relaxed.
+     * Compiles the query and returns the SQL text and parameters.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * Requires a backend to be configured (the backend determines the SQL dialect).
+     * Use this for debugging, logging, or running the query with a custom executor.
      */
-    createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
     /**
-     * Create or update a node.
-     *
-     * If a node with the given ID exists, updates it with the provided props.
-     * Otherwise, creates a new node with that ID.
+     * Compiles the query to TypeGraph's database-independent SQL fragment.
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * Pass the result to a GraphBackend, or use toSQL() to render SQL text and
+     * parameters for the configured dialect.
      */
-    upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    compile(): CompiledSelectSql;
     /**
-     * Upsert a node from untyped data, relying on runtime Zod validation.
-     *
-     * Use this for dynamic dispatch (changesets, migrations, imports) where
-     * the data shape is determined at runtime, not compile time.
-     * The return type is fully typed — only the input gate is relaxed.
+     * Creates a prepared (pre-validated) query that can be executed multiple
+     * times with different parameter bindings. Builds and structurally
+     * validates the AST once (a malformed query fails fast, here, instead of on
+     * first use); the prepared query then compiles once into a reusable template
+     * and fills a fresh read instant per execute() — see PreparedQuery's class
+     * doc comment, which also covers the two cases that recompile per call
+     * instead (no `executeRaw`, or a statement whose semantics ride on the SQL
+     * object rather than its text).
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
-     */
-    upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
-    /**
-     * Create multiple nodes in a batch.
+     * Use `param("name")` in predicates to create parameterized slots,
+     * then pass values via `prepared.execute({ name: "value" })`.
      *
-     * More efficient than calling create() multiple times.
-     * Use `bulkInsert` for the dedicated fast path that skips returning results.
+     * @example
+     * ```typescript
+     * import { param } from "@nicia-ai/typegraph";
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
-     */
-    bulkCreate: (items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Node<N>[]>;
-    /**
-     * Create or update multiple nodes in a batch.
+     * const prepared = store.query()
+     *   .from("Person", "p")
+     *   .whereNode("p", (p) => p.name.eq(param("name")))
+     *   .select((ctx) => ctx.p)
+     *   .prepare();
      *
-     * For each item, if a node with the given ID exists, updates it.
-     * Otherwise, creates a new node with that ID.
+     * const alice = await prepared.execute({ name: "Alice" });
+     * const bob = await prepared.execute({ name: "Bob" });
+     * ```
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * @throws Error if no backend is configured
      */
-    bulkUpsertById: (items: readonly Readonly<{
-        id: string;
-        props: z.input<N["schema"]>;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Node<N>[]>;
+    prepare(): PreparedQuery<R>;
     /**
-     * Insert multiple nodes without returning results.
-     *
-     * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`
-     * with `returnResults: false`, the intent is unambiguous: no results
-     * are returned and the operation is wrapped in a transaction.
+     * Executes the query and returns typed results.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
-     */
-    bulkInsert: (items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<void>;
-    /**
-     * Delete multiple nodes by ID.
+     * Uses smart optimization to detect when only specific fields are accessed
+     * in the select callback. If the callback only accesses simple field
+     * references (no method calls or computations), generates optimized SQL
+     * that only extracts those fields instead of the full props blob.
      *
-     * Atomic when the backend supports transactions. Silently ignores IDs
-     * that don't exist.
+     * @throws Error if no backend is configured
      */
-    bulkDelete: (ids: readonly NodeId<N>[]) => Promise<void>;
+    execute(): Promise<readonly R[]>;
     /**
-     * Find a node by uniqueness constraint.
-     *
-     * Looks up a live node by the named constraint key computed from `props`.
-     * Returns the node if found, or undefined. Soft-deleted nodes are excluded.
+     * Executes the query against a provided backend.
      *
-     * @param constraintName - Name of the uniqueness constraint to match on
-     * @param props - Properties to compute the constraint key from
-     */
-    findByConstraint: (constraintName: CN, props: z.input<N["schema"]>) => Promise<Node<N> | undefined>;
-    /**
-     * Batch version of findByConstraint.
+     * Used by `store.batch()` to run several queries in sequence against one
+     * target — a transaction on backends that have them, the backend itself
+     * otherwise. The full compile → execute → transform pipeline runs
+     * identically to `execute()`, but against the given backend.
      *
-     * Results are returned in the same order as the input items.
-     * Returns undefined for entries that don't match.
+     * Costs one statement, or two when the selective-field path runs and its
+     * mapping then falls back: `#tryOptimizedExecutionOn` detects that only
+     * after its statement has executed, and the caller re-runs the full fetch.
+     * The fallback clears the fast path for this instance.
      */
-    bulkFindByConstraint: (constraintName: CN, items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-    }>[]) => Promise<(Node<N> | undefined)[]>;
+    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
     /**
-     * Batched candidate retrieval against a declared node index.
-     *
-     * For each input item, TypeGraph computes the index lookup key from
-     * `index.fields` (JSON-pointer extraction, partial-`where` applied to
-     * stored rows, null-safe matching) and returns the live, non-soft-deleted
-     * nodes that share that key. Unlike {@link bulkFindByConstraint}, the index
-     * may be non-unique, so each input yields a (possibly empty) array.
+     * Executes a paginated query using cursor-based keyset pagination.
      *
-     * Results preserve input order; each inner array is ordered by node id.
-     * Empty input returns `[]`. An unknown index name throws
-     * `NodeIndexNotFoundError`; a type-incompatible indexed field throws
-     * `ValidationError`. This is candidate retrieval, not a uniqueness or
-     * identity guarantee.
+     * Cursor pagination is efficient for large datasets as it avoids OFFSET.
+     * Requires ORDER BY to be specified for deterministic results.
      *
-     * @param indexName - Name of the declared node index to match on
-     * @param items - Records whose `props` supply the indexed-field values
-     * @param options - Optional `limitPerInput` to bound per-input fan-out
+     * @param options - Pagination options (first/after for forward, last/before for backward)
+     * @throws ValidationError if ORDER BY is not specified
+     * @throws ValidationError if cursor columns don't match query ORDER BY columns
      */
-    bulkFindByIndex: (indexName: string, items: readonly Readonly<{
-        props: Partial<z.input<N["schema"]>>;
-    }>[], options?: NodeBulkFindByIndexOptions) => Promise<readonly Node<N>[][]>;
+    paginate(options: PaginateOptions): Promise<PaginatedResult<R>>;
     /**
-     * Get an existing node by uniqueness constraint, or create a new one.
-     *
-     * Looks up a node by the named constraint key computed from `props`.
-     * If found, returns it (optionally updating with `ifExists: "update"`).
-     * If not found, creates a new node. Soft-deleted matches are always resurrected.
+     * Returns an async iterator that streams results in batches.
      *
-     * @param constraintName - Name of the uniqueness constraint to match on
-     * @param props - Full properties for create, or merge source for update
-     * @param options - Existing record behavior (default: "return")
-     */
-    getOrCreateByConstraint: (constraintName: CN, props: z.input<N["schema"]>, options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>>;
-    /**
-     * Batch version of getOrCreateByConstraint.
+     * Uses cursor pagination internally for efficient memory usage.
+     * Requires ORDER BY to be specified for deterministic results.
      *
-     * Results are returned in the same order as the input items.
-     * Atomic when the backend supports transactions.
+     * @param options - Stream options (batchSize defaults to 1000)
+     * @throws ValidationError if ORDER BY is not specified
      */
-    bulkGetOrCreateByConstraint: (constraintName: CN, items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-    }>[], options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>[]>;
-}>;
+    stream(options?: StreamOptions): AsyncIterable<R>;
+}
+
 /**
- * Reference to a node of a specific kind.
- *
- * Accepts either:
- * - A Node instance of the correct kind
- * - An explicit { kind, id } object with the correct kind name
+ * TraversalBuilder - Intermediate builder for edge traversals.
+ */
+
+/**
+ * Resolves the edge type for an edge alias based on its kind type parameter.
  *
- * This provides compile-time checking that edge endpoints match the
- * allowed node kinds defined in the edge registration.
+ * For `traverse(...)`, `EK` is a literal like `"authoredBy"` and the
+ * type comes from the typed graph. For `traverseDynamic(...)`, `EK` is
+ * widened to `string` — `string extends EK` distinguishes that case and
+ * resolves to `DynamicEdgeType`, so the conditional accessor types fire.
  */
-type NodeRef<N extends NodeType = NodeType> = Node<N> | Readonly<{
-    kind: N["kind"];
-    id: string;
-}>;
+type EdgeTypeForKey<G extends GraphDef, EK> = string extends EK ? DynamicEdgeType : EK extends keyof G["edges"] & string ? G["edges"][EK]["type"] : DynamicEdgeType;
 /**
- * Options for creating an edge.
+ * State for variable-length traversal configuration.
  */
-type EdgeCreateOptions = Readonly<{
-    id?: string;
-    validFrom?: string;
-    validTo?: string;
-}>;
+interface VariableLengthState {
+    enabled: boolean;
+    minDepth: number;
+    maxDepth: number;
+    cyclePolicy: RecursiveCyclePolicy;
+    pathEnabled: boolean;
+    pathAlias?: string;
+    depthEnabled: boolean;
+    depthAlias?: string;
+}
 /**
- * Arguments for edge creation, with props optional when schema allows empty object.
+ * Intermediate builder for traversal operations.
  *
- * Uses `{}` to check if an empty object literal satisfies the schema input type.
- */
-type EdgeCreateArguments<E extends AnyEdgeType> = {} extends z.input<E["schema"]> ? [
-    props?: z.input<E["schema"]>,
-    options?: EdgeCreateOptions
-] : [props: z.input<E["schema"]>, options?: EdgeCreateOptions];
-/**
- * A collection of edges of a specific type.
- *
- * Provides ergonomic CRUD operations for a single edge type.
- * The From and To type parameters enforce that edge endpoints
- * match the allowed node types at compile time.
- *
- * @example
- * ```typescript
- * // Create an edge - pass Node objects directly
- * const edge = await store.edges.worksAt.create(alice, acme, { role: "Engineer" });
- *
- * // TypeScript error: Company is not a valid 'from' type for worksAt
- * // store.edges.worksAt.create(acme, alice, { role: "Engineer" });
- *
- * // For edges with empty schemas, props is optional
- * await store.edges.wrote.create(author, book);
- *
- * // Find edges from a node
- * const edges = await store.edges.worksAt.findFrom(alice);
- * ```
+ * Type parameters track the edge kind and direction to constrain
+ * which node kinds are valid targets in the `to()` method.
  */
-type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
+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[]);
     /**
-     * Create a new edge.
-     *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
-     *
-     * @param from - Source node (must be one of the allowed 'from' types)
-     * @param to - Target node (must be one of the allowed 'to' types)
-     * @param args - Edge properties (optional if schema is empty) and creation options
+     * Enables variable-length (recursive) traversal.
+     * Defaults to MAX_RECURSIVE_DEPTH (10) hops with cycle prevention.
+     * Use `maxHops` to override (up to MAX_EXPLICIT_RECURSIVE_DEPTH).
      */
-    create: (from: NodeRef<From>, to: NodeRef<To>, ...args: EdgeCreateArguments<E>) => Promise<Edge<E, From, To>>;
-    /** Get an edge by ID */
-    getById: (id: EdgeId<E>, options?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
-    /** Get multiple edges by ID, preserving input order (undefined for missing) */
-    getByIds: (ids: readonly EdgeId<E>[], options?: QueryOptions) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
-    /** Update an edge's properties */
-    update: (id: EdgeId<E>, props: Partial<z.input<E["schema"]>>, options?: Readonly<{
-        validTo?: string;
-    }>) => Promise<Edge<E, From, To>>;
+    recursive<const O extends RecursiveTraversalOptions = Record<string, never>>(options?: O): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, O extends {
+        depth: infer D extends boolean | string;
+    } ? D : DC, O extends {
+        path: infer P extends boolean | string;
+    } ? P : PC, RecAliases, CoordinateState>;
     /**
-     * Find edges from a specific node.
+     * Adds a WHERE clause for the edge being traversed.
      *
-     * Honors the same temporal model as `getById` / `find`: with no
-     * `options`, the graph's default `temporalMode` applies (excluding
-     * soft-deleted edges and, in `current` / `asOf` modes, edges outside
-     * their validity window). Pass `temporalMode` / `asOf` to read the
-     * endpoint's edges at another temporal coordinate.
+     * @param alias - The edge alias to filter on (must be the current edge alias)
+     * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    findFrom: (from: NodeRef<From>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
+    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases, CoordinateState>;
     /**
-     * Find edges to a specific node.
+     * Specifies the target node kind.
      *
-     * Temporal semantics mirror {@link EdgeCollection.findFrom}.
+     * The kind must be a valid target for this edge based on the traversal direction:
+     * - "out" direction: kind must be in the edge's "to" array
+     * - "in" direction: kind must be in the edge's "from" array
+     *
+     * @param kind - The target node kind
+     * @param alias - A unique alias for this node (compile-time error if duplicate)
      */
-    findTo: (to: NodeRef<To>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
+    to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: false;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"], Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
+    to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
+        includeSubClasses: true;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<NodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
     /**
-     * Deferred variant of `findFrom` for use with `store.batch()`.
-     *
-     * Returns a `BatchableQuery` instead of executing immediately. Accepts
-     * the same temporal `options` as {@link EdgeCollection.findFrom}.
+     * String-keyed sibling of `to` for runtime-declared target kinds.
+     * Throws `KindNotFoundError` if the kind is not registered.
      */
-    batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
+    toDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: boolean;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<EdgeTypeForKey<G, EK>, Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
+}
+
+/**
+ * QueryBuilder - The fluent query builder.
+ */
+
+type TemporalMethod<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState> = CoordinateState extends "open" ? (mode: TemporalMode, asOf?: string) => QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, "open"> : never;
+/**
+ * The fluent query builder.
+ *
+ * Type parameters accumulate as methods are chained:
+ * - G: The graph definition
+ * - Aliases: Map of alias names to their node kinds
+ * - EdgeAliases: Map of alias names to their edge kinds (accumulated during traversals)
+ */
+declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyAliasMap, EdgeAliases extends EdgeAliasMap = EmptyEdgeAliasMap, RecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, CoordinateState extends QueryCoordinateState = "open"> {
+    #private;
+    readonly temporal: TemporalMethod<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    constructor(config: QueryBuilderConfig, state: QueryBuilderState);
     /**
-     * Deferred variant of `findTo` for use with `store.batch()`.
+     * Starts a query from a node kind.
      *
-     * Returns a `BatchableQuery` instead of executing immediately. Accepts
-     * the same temporal `options` as {@link EdgeCollection.findTo}.
+     * @param kind - The node kind to start from
+     * @param alias - A unique alias for this node (compile-time error if duplicate)
      */
-    batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
+    from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: false;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"]>>, EdgeAliases, RecursiveAliases, CoordinateState>;
+    from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
+        includeSubClasses: true;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias>, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Deferred variant of `findByEndpoints` for use with `store.batch()`.
-     *
-     * Returns a `BatchableQuery` that yields a 0-or-1 element array
-     * (matching `findByEndpoints`' at-most-one semantics).
+     * String-keyed sibling of `from` for runtime-declared kinds. Throws
+     * `KindNotFoundError` if the kind is not registered. Predicates use
+     * the `n.field("name").number().gte(...)` discriminator.
      */
-    batchFindByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
-    /** Delete an edge (soft delete - sets deletedAt timestamp) */
-    delete: (id: EdgeId<E>) => Promise<void>;
+    fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: boolean;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Permanently delete an edge from the database.
-     *
-     * Unlike `delete()` which performs a soft delete, this permanently
-     * removes the edge record.
-     *
-     * **Warning:** This operation is irreversible and should be used carefully.
-     * Consider using soft delete (`delete()`) for most use cases.
+     * Adds a WHERE clause for a node.
      */
-    hardDelete: (id: EdgeId<E>) => Promise<void>;
-    /** Find edges matching endpoint and pagination criteria */
-    find: (filter?: Readonly<{
-        from?: NodeRef<From>;
-        to?: NodeRef<To>;
-        limit?: number;
-        offset?: number;
-    }>, temporal?: QueryOptions) => Promise<Edge<E, From, To>[]>;
-    /** Count edges matching criteria */
-    count: (filter?: Readonly<{
-        from?: NodeRef<From>;
-        to?: NodeRef<To>;
-    }>, temporal?: QueryOptions) => Promise<number>;
+    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Create multiple edges in a batch.
-     *
-     * More efficient than calling create() multiple times.
-     * Use `bulkInsert` for the dedicated fast path that skips returning results.
+     * Adds a WHERE clause for an edge.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * @param alias - The edge alias to filter on
+     * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    bulkCreate: (items: readonly Readonly<{
-        from: NodeRef<From>;
-        to: NodeRef<To>;
-        props?: z.input<E["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Edge<E, From, To>[]>;
+    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Create or update multiple edges in a batch.
+     * Traverses an edge to another node (outgoing direction).
      *
-     * For each item, if an edge with the given ID exists, updates it.
-     * Otherwise, creates a new edge with that ID.
+     * By default, traverses from the current node (last traversal target, or start node).
+     * Use the `from` option to traverse from a different alias (fan-out pattern).
      *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * @param options.expand - Ontology expansion mode for implying/inverse edges
+     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
      */
-    bulkUpsertById: (items: readonly Readonly<{
-        id: EdgeId<E>;
-        from: NodeRef<From>;
-        to: NodeRef<To>;
-        props?: z.input<E["schema"]>;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Edge<E, From, To>[]>;
+    traverse<EK extends keyof G["edges"] & string, EA extends string>(edgeKind: EK, edgeAlias: EA, options?: {
+        direction?: "out";
+        expand?: TraversalExpansion;
+        from?: keyof Aliases & string;
+    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases, CoordinateState>;
     /**
-     * Insert multiple edges without returning results.
+     * Traverses an edge to another node (incoming direction).
      *
-     * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`
-     * with `returnResults: false`, the intent is unambiguous: no results
-     * are returned and the operation is wrapped in a transaction.
+     * By default, traverses from the current node (last traversal target, or start node).
+     * Use the `from` option to traverse from a different alias (fan-out pattern).
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * @param options.direction - Set to "in" for incoming edge traversal
+     * @param options.expand - Ontology expansion mode for implying/inverse edges
+     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
      */
-    bulkInsert: (items: readonly Readonly<{
-        from: NodeRef<From>;
-        to: NodeRef<To>;
-        props?: z.input<E["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<void>;
+    traverse<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", false, false, false, RecursiveAliases, CoordinateState>;
     /**
-     * Delete multiple edges by ID.
-     *
-     * Atomic when the backend supports transactions. Silently ignores IDs
-     * that don't exist.
+     * String-keyed sibling of `traverse` for runtime-declared edge kinds.
+     * Throws `KindNotFoundError` if the edge kind is not registered.
      */
-    bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
+    traverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
+        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>;
     /**
-     * Find an edge by endpoints and optional property fields.
+     * Optionally traverses an edge to another node (LEFT JOIN semantics).
+     * If no matching edge/node exists, the result will include null values.
      *
-     * Returns the first matching edge at the read coordinate, or undefined.
-     * Honors the temporal model like `findFrom` / `findTo`: by default
-     * (`current` mode) soft-deleted and out-of-window edges are excluded; under
-     * `includeTombstones` a soft-deleted edge can be returned.
+     * By default, traverses from the current node (last traversal target, or start node).
+     * Use the `from` option to traverse from a different alias (fan-out pattern).
      *
-     * @param from - Source node
-     * @param to - Target node
-     * @param options - Match criteria (matchOn fields and property values)
-     * @param temporal - Temporal coordinate. With no `temporal`, the graph's
-     *   default `temporalMode` applies (so under the default `"current"` mode,
-     *   edges outside their validity window are excluded). Pass
-     *   `temporalMode` / `asOf` to read the edge as of another coordinate.
+     * @param options.direction - Direction of traversal: "out" (default) or "in"
+     * @param options.expand - Ontology expansion mode for implying/inverse edges
+     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
      */
-    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
-    /**
-     * Get an existing edge by endpoints and optional property fields, or create a new one.
+    optionalTraverse<EK extends keyof G["edges"] & string, EA extends string>(edgeKind: EK, edgeAlias: EA, options?: {
+        direction?: "out";
+        expand?: TraversalExpansion;
+        from?: keyof Aliases & string;
+    }): 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>;
+    /**
+     * String-keyed sibling of `optionalTraverse` for runtime-declared edge
+     * kinds. LEFT JOIN semantics — non-matching rows produce a null edge
+     * alias instead of dropping. Throws `KindNotFoundError` if the edge
+     * kind is not registered.
+     */
+    optionalTraverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
+        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>;
+    /**
+     * Selects fields to return.
+     */
+    select<R>(selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
+    /**
+     * Selects fields including aggregates.
+     * Use with groupBy() for aggregate queries.
      *
-     * Matches edges of this kind between `(from, to)`. When `matchOn` specifies
-     * property fields, only edges whose properties match on those fields are considered.
-     * Soft-deleted matches are resurrected when cardinality allows.
+     * @param fields - Object mapping output names to field refs or aggregate expressions
+     */
+    aggregate<R extends Record<string, FieldRef | AggregateExpr>>(fields: R): ExecutableAggregateQuery<G, Aliases, R>;
+    /**
+     * Orders results.
+     */
+    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Limits the number of results.
+     */
+    limit(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Offsets the results.
+     */
+    offset(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Groups results by the specified field.
+     * Use with aggregate functions like COUNT, SUM, AVG in select().
      *
-     * `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.
+     * @param alias - The node alias to group by
+     * @param field - The field name to group by
+     */
+    groupBy<A extends keyof Aliases & string>(alias: A, field: string): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Groups results by the node ID.
+     * Use when you want to group by a complete node rather than a specific field.
      *
-     * @param from - Source node
-     * @param to - Target node
-     * @param props - Full properties for create, or merge source for update
-     * @param options - Match criteria and conflict resolution
+     * @param alias - The node alias to group by (uses the node's ID)
      */
-    getOrCreateByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, props: z.input<E["schema"]>, options?: EdgeGetOrCreateByEndpointsOptions<E>) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>>;
+    groupByNode<A extends keyof Aliases & string>(alias: A): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Batch version of getOrCreateByEndpoints.
+     * Filters grouped results using aggregate conditions (HAVING clause).
+     * Use after groupBy() to filter based on aggregate values.
      *
-     * Results are returned in the same order as the input items.
-     * Atomic when the backend supports transactions.
+     * @param predicate - A predicate expression to filter groups
      */
-    bulkGetOrCreateByEndpoints: (items: readonly Readonly<{
-        from: NodeRef<From>;
-        to: NodeRef<To>;
-        props: z.input<E["schema"]>;
-        validFrom?: string;
-        validTo?: string;
-    }>[], options?: Pick<EdgeGetOrCreateByEndpointsOptions<E>, "matchOn" | "ifExists">) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>[]>;
-}>;
+    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Sets fusion parameters for hybrid (vector + fulltext) queries.
+     *
+     * Applies only when the query contains both a `.similarTo()` and a
+     * `.$fulltext.matches()` predicate. Without this call, the default is
+     * RRF with k=60 and equal weights. A mismatch between `.fuseWith()`
+     * configuration and the predicates on the query is caught during
+     * compilation, not here.
+     *
+     * @example
+     * ```typescript
+     * store.query()
+     *   .from("Document", "d")
+     *   .whereNode("d", d =>
+     *     d.$fulltext.matches("renewable energy", 50)
+     *       .and(d.embedding.similarTo(vec, 50))
+     *       .and(d.tenantId.eq(tenant))
+     *   )
+     *   .fuseWith({ k: 60, weights: { fulltext: 1.5 } })
+     *   .limit(10)
+     *   .execute();
+     * ```
+     */
+    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Applies a query fragment to transform this builder.
+     *
+     * Fragments are reusable query transformations that can add predicates,
+     * traversals, ordering, and other query operations. Use this for
+     * composing complex queries from simpler, reusable parts.
+     *
+     * @example
+     * ```typescript
+     * // Define a reusable fragment
+     * const activeUsers = createFragment<MyGraph>()((q) =>
+     *   q.whereNode("u", ({ status }) => status.eq("active"))
+     * );
+     *
+     * // Apply the fragment
+     * const results = await query()
+     *   .from("User", "u")
+     *   .pipe(activeUsers)
+     *   .select((ctx) => ctx.u)
+     *   .execute();
+     * ```
+     *
+     * @param fragment - A function that transforms the builder
+     * @returns The transformed builder
+     */
+    pipe<OutAliases extends AliasMap, OutEdgeAliases extends EdgeAliasMap = EdgeAliases, OutRecAliases extends RecursiveAliasMap = RecursiveAliases>(fragment: (builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>): QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>;
+}
+
 /**
- * Extract uniqueness constraint names from a NodeRegistration.
+ * Fluent query builder for TypeGraph.
  *
- * - Returns `never` when no uniqueness constraints are configured.
- * - Returns a literal union when names are inferred via `defineGraph` const params.
- * - Falls back to `string` when names are widened/dynamic.
+ * Provides a type-safe, chainable API for building queries.
+ * Each method returns a new builder instance with expanded type information.
+ *
+ * This module re-exports from the builder submodules and provides the
+ * createQueryBuilder factory function.
  */
-type ConstraintNames<R extends NodeRegistration> = "unique" extends keyof R ? R["unique"] extends readonly {
-    readonly name: infer N;
-}[] ? N & string : string : never;
+
+type InitialQueryBuilder<G extends GraphDef, CoordinateState extends QueryCoordinateState = "open"> = QueryBuilder<G, EmptyAliasMap, EmptyEdgeAliasMap, EmptyRecursiveAliasMap, CoordinateState>;
+declare function createQueryBuilder<G extends GraphDef>(graphId: string, registry: KindRegistry, options?: CreateQueryBuilderOptions): InitialQueryBuilder<G>;
+
 /**
- * Extract the union of 'from' node types from an EdgeRegistration.
+ * StoreView collection surface buckets.
+ *
+ * The live NodeCollection / EdgeCollection partition into buckets a StoreView
+ * treats differently:
+ *
+ * - temporal reads honor the pinned coordinate;
+ * - current reads have no temporal axis and are refused on temporal pins;
+ * - writes are never available on a read-only view; and
+ * - batch reads require store.batch() and are absent from a view.
+ *
+ * These arrays are the single runtime source of truth for the proxy routing and
+ * the type-level source for the derived StoreView collection types. The
+ * StoreView surface-classification test asserts they exactly partition the live
+ * collection methods so new collection methods cannot be silently omitted.
  */
-type EdgeFromTypes<R extends EdgeRegistration> = R["from"] extends readonly (infer N)[] ? N : never;
+/** Temporal-aware node read method names. */
+declare const NODE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count"];
+/** Current-state-only node reads (constraint / index lookups). */
+declare const CURRENT_ONLY_READ_NAMES: readonly ["findByConstraint", "bulkFindByConstraint", "bulkFindByIndex"];
+/** Node write method names: never available on a read-only StoreView. */
+declare const NODE_WRITE_NAMES: readonly ["create", "createFromRecord", "update", "updateWhere", "delete", "hardDelete", "upsertById", "upsertByIdFromRecord", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByConstraint", "bulkGetOrCreateByConstraint"];
+/** Temporal-aware edge read method names. */
+declare const EDGE_TEMPORAL_READ_NAMES: readonly ["getById", "getByIds", "find", "count", "findFrom", "findTo", "bulkFindFrom", "bulkFindTo", "findByEndpoints"];
+/** Deferred edge batch-read method names. */
+declare const EDGE_BATCH_READ_NAMES: readonly ["batchFindFrom", "batchFindTo", "batchFindByEndpoints"];
+/** Edge write method names: never available on a read-only StoreView. */
+declare const EDGE_WRITE_NAMES: readonly ["create", "update", "delete", "hardDelete", "bulkCreate", "bulkUpsertById", "bulkInsert", "bulkDelete", "getOrCreateByEndpoints", "bulkGetOrCreateByEndpoints"];
+/** Recorded-time collection point reads that reconstruct safely by id. */
+declare const RECORDED_POINT_READ_NAMES: readonly ["getById", "getByIds"];
+
 /**
- * Extract the union of 'to' node types from an EdgeRegistration.
+ * Store types for TypeGraph operations.
  */
-type EdgeToTypes<R extends EdgeRegistration> = R["to"] extends readonly (infer N)[] ? N : never;
+
 /**
- * Create a type-safe EdgeCollection from an EdgeRegistration.
- * Extracts the edge type and from/to node types automatically.
+ * Canonical mapping from snake_case row fields to camelCase meta fields.
+ *
+ * This is the single source of truth for which row columns become metadata.
+ * Both the Meta types and the row-to-meta functions in row-mappers.ts must
+ * stay in sync with this mapping. If you add a temporal/audit column to a
+ * row type, add the mapping here — the compiler will then force you to
+ * update the row mapper functions as well (since their return type is
+ * NodeMeta/EdgeMeta, which is derived from this mapping).
  */
-type TypedEdgeCollection<R extends EdgeRegistration> = EdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
-/** Mapped type of all node collections for a graph. */
-type GraphNodeCollections<G extends GraphDef> = {
-    [K in keyof G["nodes"] & string]-?: NodeCollection<G["nodes"][K]["type"], ConstraintNames<G["nodes"][K]>>;
-};
-/** Mapped type of all edge collections for a graph. */
-type GraphEdgeCollections<G extends GraphDef> = {
-    [K in keyof G["edges"] & string]-?: TypedEdgeCollection<G["edges"][K]>;
-};
-/** Temporal-aware node reads — a {@link StoreView} pins these. */
-type NodeTemporalReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_TEMPORAL_READ_NAMES)[number]>;
+type TemporalMetaFieldMap = Readonly<{
+    valid_from: "validFrom";
+    valid_to: "validTo";
+    created_at: "createdAt";
+    updated_at: "updatedAt";
+    deleted_at: "deletedAt";
+}>;
 /**
- * Current-state-only node reads (constraint / index lookups). No temporal
- * axis, so a {@link StoreView} delegates them on a `current` pin and refuses
- * them on a temporal pin.
+ * Maps row fields to their camelCase meta counterparts, preserving types.
  */
-type NodeCurrentReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof CURRENT_ONLY_READ_NAMES)[number]>;
-/** Node writes — never available on a read-only {@link StoreView}. */
-type NodeWrites<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_WRITE_NAMES)[number]>;
-/** Temporal-aware edge reads — a {@link StoreView} pins these. */
-type EdgeTemporalReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_TEMPORAL_READ_NAMES)[number]>;
+type MapRowToMeta<R extends Readonly<Record<string, unknown>>, M extends Readonly<Record<string, string>>> = Readonly<{
+    [SnakeKey in keyof M as M[SnakeKey] & string]: SnakeKey extends keyof R ? R[SnakeKey] : never;
+}>;
 /**
- * Deferred edge reads for `store.batch()` — absent from a {@link StoreView},
- * which has no batch context.
+ * Metadata for a node instance.
+ * Derived from NodeRow via TemporalMetaFieldMap + version.
+ *
+ * Adding a new metadata column requires:
+ * 1. Add the column to NodeRow in backend/types.ts
+ * 2. Add the mapping to TemporalMetaFieldMap above
+ * 3. The compiler will error in rowToNodeMeta() until you add the field there
  */
-type EdgeBatchReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_BATCH_READ_NAMES)[number]>;
-/** Edge writes — never available on a read-only {@link StoreView}. */
-type EdgeWrites<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_WRITE_NAMES)[number]>;
+type NodeMeta = MapRowToMeta<NodeRow, TemporalMetaFieldMap> & Readonly<{
+    version: NodeRow["version"];
+}>;
 /**
- * The read-only node surface a {@link StoreView} exposes for one node kind.
- * The temporal reads drop the per-call temporal argument — the pin owns the
- * axis; the current reads ({@link NodeCurrentReads}) are exposed as-is
- * (delegated on a `current` view, refused on a temporal pin). Writes live on
- * the live `Store`. The conformance test asserts the temporal part equals the
- * pinned form of {@link NodeTemporalReads}.
+ * A node instance in the graph.
+ *
+ * Properties from the schema are spread at the top level for ergonomic access:
+ * - `node.name` instead of `node.props.name`
+ * - System metadata is under `node.meta.*`
  */
-type StoreViewNodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
-    /** Get a node by ID at the view's pinned coordinate. */
-    getById: (id: NodeId<N>) => Promise<Node<N> | undefined>;
-    /** Get multiple nodes by ID, preserving input order (undefined for missing). */
-    getByIds: (ids: readonly NodeId<N>[]) => Promise<readonly (Node<N> | undefined)[]>;
-    /** Find nodes matching criteria at the view's pinned coordinate. */
-    find: (filter?: Readonly<{
-        where?: (accessor: NodeAccessor<N>) => Predicate;
-        limit?: number;
-        offset?: number;
-    }>) => Promise<Node<N>[]>;
-    /** Count nodes at the view's pinned coordinate. */
-    count: () => Promise<number>;
-}> & NodeCurrentReads<N, CN>;
+type Node<N extends NodeType = NodeType> = Readonly<{
+    kind: N["kind"];
+    id: NodeId<N>;
+    meta: NodeMeta;
+}> & Readonly<z.infer<N["schema"]>>;
 /**
- * The read-only edge surface a {@link StoreView} exposes for one edge
- * kind, mirroring {@link StoreViewNodeCollection}. Every edge read —
- * including `findByEndpoints` — honors the pin via the same temporal model,
- * so (unlike nodes) there are no current-state-only edge reads.
+ * Input for creating a node.
  */
-type StoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
-    /** Get an edge by ID at the view's pinned coordinate. */
-    getById: (id: EdgeId<E>) => Promise<Edge<E, From, To> | undefined>;
-    /** Get multiple edges by ID, preserving input order (undefined for missing). */
-    getByIds: (ids: readonly EdgeId<E>[]) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
-    /** Find edges matching endpoint and pagination criteria. */
-    find: (filter?: Readonly<{
-        from?: NodeRef<From>;
-        to?: NodeRef<To>;
-        limit?: number;
-        offset?: number;
-    }>) => Promise<Edge<E, From, To>[]>;
-    /** Count edges matching criteria at the view's pinned coordinate. */
-    count: (filter?: Readonly<{
-        from?: NodeRef<From>;
-        to?: NodeRef<To>;
-    }>) => Promise<number>;
-    /** Find edges from a specific node at the view's pinned coordinate. */
-    findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;
-    /** Find edges to a specific node at the view's pinned coordinate. */
-    findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;
-    /** Find the edge between two endpoints at the view's pinned coordinate. */
-    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => Promise<Edge<E, From, To> | undefined>;
+type CreateNodeInput<N extends NodeType = NodeType> = Readonly<{
+    kind: N["kind"];
+    id?: string;
+    props: z.infer<N["schema"]>;
+    validFrom?: string;
+    validTo?: string;
 }>;
 /**
- * Read-only view edge collection derived from an `EdgeRegistration`,
- * extracting the edge type and from/to node types — the read-only
- * counterpart of {@link TypedEdgeCollection}.
+ * Input for updating a node.
  */
-type TypedStoreViewEdgeCollection<R extends EdgeRegistration> = StoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
-/** Mapped type of all read-only view node collections for a graph. */
-type StoreViewNodeCollections<G extends GraphDef> = {
-    [K in keyof G["nodes"] & string]-?: StoreViewNodeCollection<G["nodes"][K]["type"]>;
-};
-/** Mapped type of all read-only view edge collections for a graph. */
-type StoreViewEdgeCollections<G extends GraphDef> = {
-    [K in keyof G["edges"] & string]-?: TypedStoreViewEdgeCollection<G["edges"][K]>;
-};
-/** Options for one bounded, forward-only recorded-time collection scan. */
-type RecordedScanOptions = Readonly<{
-    /** Maximum entities to return. Defaults to 1,000 and cannot exceed 1,000. */
-    limit?: number;
-    /** Opaque cursor returned by the preceding page. */
-    after?: string;
-}>;
-/** One page from a deterministic recorded-time collection scan. */
-type RecordedScanPage<T> = Readonly<{
-    /** Entities ordered by canonical id ascending. */
-    data: readonly T[];
-    /** Cursor for the next page, or `undefined` when the scan is complete. */
-    nextCursor: string | undefined;
-    /** Whether another page exists after this one. */
-    hasNextPage: boolean;
-}>;
-/** Recorded-time reconstructing reads for one node kind. */
-type RecordedStoreViewNodeCollection<N extends NodeType> = Pick<StoreViewNodeCollection<N>, (typeof RECORDED_POINT_READ_NAMES)[number]> & Readonly<{
-    /** Scan one bounded page at the view's pinned coordinate. */
-    scan: (options?: RecordedScanOptions) => Promise<RecordedScanPage<Node<N>>>;
-}>;
-/** Recorded-time reconstructing reads for one edge kind. */
-type RecordedStoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<StoreViewEdgeCollection<E, From, To>, (typeof RECORDED_POINT_READ_NAMES)[number]> & Readonly<{
-    /** Scan one bounded page at the view's pinned coordinate. */
-    scan: (options?: RecordedScanOptions) => Promise<RecordedScanPage<Edge<E, From, To>>>;
+type UpdateNodeInput<N extends NodeType = NodeType> = Readonly<{
+    kind: N["kind"];
+    id: NodeId<N>;
+    props: Partial<z.infer<N["schema"]>>;
+    validTo?: string;
 }>;
-/** Recorded-time edge collection derived from an `EdgeRegistration`. */
-type TypedRecordedStoreViewEdgeCollection<R extends EdgeRegistration> = RecordedStoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
-/** Mapped type of all recorded-time node reconstructing-read collections. */
-type RecordedStoreViewNodeCollections<G extends GraphDef> = {
-    [K in keyof G["nodes"] & string]-?: RecordedStoreViewNodeCollection<G["nodes"][K]["type"]>;
-};
-/** Mapped type of all recorded-time edge reconstructing-read collections. */
-type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
-    [K in keyof G["edges"] & string]-?: TypedRecordedStoreViewEdgeCollection<G["edges"][K]>;
-};
 /**
- * Whether — and why — `tx.sql` can be used on a transaction context. A single
- * required discriminant covering exactly the four states raw-SQL access can be
- * in, so an adapter caller branches on capability instead of truthiness-testing
- * `tx.sql`. The non-available variants omit `sql` entirely, so even reading the
- * handle requires first narrowing `sqlAvailability` to `"available"`. The
- * runtime object keeps a fail-loud getter under history / revision tracking for
- * JavaScript and type-suppressed callers. See
- * {@link AdapterTransactionContext} for the per-value semantics.
+ * Metadata for an edge instance.
+ * Derived from EdgeRow via TemporalMetaFieldMap (edges have no version).
  */
-type SqlAvailability = "available" | "history" | "revisionTracking" | "unavailable";
-type AdapterTransactionSqlAccess<TNativeTransaction> = Readonly<{
-    sql: TNativeTransaction;
-    sqlAvailability: "available";
-}> | Readonly<{
-    sqlAvailability: "history" | "revisionTracking";
-}> | Readonly<{
-    sqlAvailability: "unavailable";
-}>;
-declare const TRANSACTION_RUNTIME: unique symbol;
-type TransactionRuntime = Readonly<{
-    backend: TransactionBackend;
-    runNodeOperationHooks: <T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>) => Promise<T>;
-}>;
+type EdgeMeta = MapRowToMeta<EdgeRow, TemporalMetaFieldMap>;
 /**
- * The portable transaction context mirrors the Store's typed graph operations
- * while exposing only a read-only backend projection bound to the transaction.
- * Adapter-native handles are available only through
- * {@link AdapterTransactionContext}; arbitrary backend writes are absent from
- * every public transaction context. TypeGraph's non-enumerable symbol port is
- * an unsupported implementation detail, not a JavaScript security boundary:
- * reflective code can still discover symbol properties.
+ * An edge instance in the graph.
  *
- * @example
- * ```typescript
- * await store.transaction(async (tx) => {
- *   const person = await tx.nodes.Person.create({ name: "Alice" });
- *   const company = await tx.nodes.Company.create({ name: "Acme" });
- *   await tx.edges.worksAt.create(person, company, { role: "Engineer" });
- * });
- * ```
+ * Properties from the schema are spread at the top level for ergonomic access:
+ * - `edge.role` instead of `edge.props.role`
+ * - System metadata is under `edge.meta.*`
  */
-type TransactionCollections<G extends GraphDef> = Readonly<{
-    [TRANSACTION_RUNTIME]: TransactionRuntime;
-    nodes: GraphNodeCollections<G>;
-    edges: GraphEdgeCollections<G>;
-    /** Read-only backend projection bound to the same graph transaction. */
-    backend: TransactionReadBackend;
-    /**
-     * Runtime string-keyed node collection access, mirroring
-     * `Store.getNodeCollection`. Returns `undefined` when `kind` is not
-     * registered in this graph.
-     */
-    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
-}>;
+type Edge<E extends AnyEdgeType = EdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
+    id: EdgeId<E>;
+    kind: E["kind"];
+    fromKind: From["kind"];
+    fromId: NodeId<From>;
+    toKind: To["kind"];
+    toId: NodeId<To>;
+    meta: EdgeMeta;
+}> & Readonly<z.infer<E["schema"]>>;
 /**
- * A portable transaction context containing only TypeGraph-owned graph
- * operations. Managed Stores use this surface so adapter-native handles never
- * enter their public contract.
+ * Input for creating an edge.
  */
-type TransactionContext<G extends GraphDef> = TransactionCollections<G>;
+type CreateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
+    kind: E["kind"];
+    id?: string;
+    fromKind: string;
+    fromId: string;
+    toKind: string;
+    toId: string;
+    props: z.infer<E["schema"]>;
+    validFrom?: string;
+    validTo?: string;
+}>;
 /**
- * A transaction context exposed by an {@link AdapterStore}. In addition to the
- * portable graph collections, it carries the adapter-native handle when that
- * capability is available. The TypeGraph backend remains the same runtime
- * read projection as the portable context; adapter-native writes intentionally
- * go through `sql`, making that escape hatch explicit.
+ * Input for updating an edge.
  */
-type AdapterTransactionContext<G extends GraphDef, TNativeTransaction> = TransactionCollections<G> & AdapterTransactionSqlAccess<TNativeTransaction>;
+type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
+    id: EdgeId<E>;
+    props: Partial<z.infer<E["schema"]>>;
+    validTo?: string;
+}>;
 /**
- * Scoped write measurement, available only on the receipt-enabled transaction
- * contexts (`transactionWithReceipt`, `withRecordedTransaction`). Runs `fn`,
- * passing it a **scoped context** — a second view over the same transaction — and
- * returns a {@link TransactionOutcome} whose receipt counts exactly the writes
- * made *through that scoped context* (`scoped.nodes` / `scoped.edges`).
- *
- * Attribution is by **which context you write through**, not by timing. A write
- * through the scoped context counts in both the scope and the outer receipt (it
- * happened in the transaction); a write through the outer `tx` during the scope
- * counts only in the outer receipt. This makes overlapping and concurrent
- * measures safe by construction — two scopes running under `Promise.all`, each
- * writing through its own scoped context, never cross-count. Nesting composes:
- * `scoped.measure(...)` opens a child scope that counts in itself, every
- * ancestor scope, and the outer receipt.
- *
- * Counts otherwise inherit {@link TransactionReceipt} (bulk by input length, a
- * rejected write counts 0). The returned receipt's `recorded` is **always
- * `undefined`**: the recorded commit instant is a per-transaction flush concern,
- * unknowable mid-transaction.
+ * Options for node and edge queries.
  */
-type ScopedMeasure<Context> = <T>(fn: (scoped: Context) => Promise<T>) => Promise<TransactionOutcome<T>>;
+type NoRecordedCoordinate = Readonly<{
+    /**
+     * Recorded/system-time coordinates are internal-only and supplied by
+     * RecordedStoreView. A public options object carrying this key is a type
+     * error even when the object is pre-bound before the call site.
+     */
+    recordedAsOf?: never;
+}>;
+type QueryOptions = NoRecordedCoordinate & Readonly<{
+    /** Temporal mode for the query */
+    temporalMode?: TemporalMode;
+    /** Specific timestamp for asOf queries */
+    asOf?: string;
+}>;
 /**
- * A {@link TransactionContext} that also exposes {@link ScopedMeasure}. Only the
- * receipt-enabled entry points (`transactionWithReceipt`,
- * `withRecordedTransaction`) hand a callback this type; plain `transaction()`
- * contexts have no recorder and therefore no `measure`, keeping that path
- * zero-overhead. Assignable to {@link TransactionContext}, so a projector helper
- * typed `(tx: TransactionContext<G>) => ...` accepts a measurable context. The
- * scoped context handed to `measure` is itself measurable, so scopes nest.
+ * Context passed to observability hooks.
  */
-type MeasurableTransactionContext<G extends GraphDef> = TransactionContext<G> & Readonly<{
-    measure: ScopedMeasure<MeasurableTransactionContext<G>>;
-}>;
-/** Receipt-enabled transaction context for an {@link AdapterStore}. */
-type MeasurableAdapterTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterTransactionContext<G, TNativeTransaction> & Readonly<{
-    measure: ScopedMeasure<MeasurableAdapterTransactionContext<G, TNativeTransaction>>;
+type HookContext = Readonly<{
+    /** Unique ID for this operation */
+    operationId: string;
+    /** Graph ID */
+    graphId: string;
+    /** Timestamp when operation started */
+    startedAt: Date;
 }>;
 /**
- * Replace branded `NodeId` / `EdgeId` with plain `string` in each
- * method's parameter list. Return types are preserved unchanged.
+ * Context for one SQL statement a query builder submits to the backend.
  *
- * Handles three shapes:
- * 1. Direct branded ID parameter → `string`
- * 2. `readonly NodeId[]` / `readonly EdgeId[]` → `readonly string[]`
- * 3. Branded IDs nested one level inside bulk-item object arrays
- */
-type WidenBrandedIds<T> = {
-    readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: {
-        [P in keyof A]: UnbrandParam<A[P]>;
-    }) => R : T[K];
-};
-/** Replace a branded ID with `string`, recursing one level into arrays. */
-type UnbrandParam<T> = T extends NodeId<NodeType> ? string : T extends EdgeId<AnyEdgeType> ? string : T extends readonly NodeId<NodeType>[] ? readonly string[] : T extends readonly EdgeId<AnyEdgeType>[] ? readonly string[] : T extends readonly (infer Item extends Record<string, unknown>)[] ? readonly UnbrandRecord<Item>[] : T;
-/** Replace branded ID values in object properties (does not recurse into nested structures). */
-type UnbrandRecord<T extends Record<string, unknown>> = {
-    readonly [K in keyof T]: T[K] extends NodeId<NodeType> ? string : T[K] extends EdgeId<AnyEdgeType> ? string : T[K];
-};
-/**
- * A node collection with widened generics for runtime string-keyed access.
- *
- * This is the return type of `store.getNodeCollection(kind)`. It exposes
- * the full `NodeCollection` API but with `NodeType` and `string` constraint
- * names instead of the specific generic parameters, since the concrete type
- * is not known at compile time.
- *
- * ID parameters accept plain `string` instead of branded `NodeId<N>`, since
- * the dynamic path typically receives IDs from edge metadata, snapshots,
- * or external input where the brand is not available.
+ * A single logical query can emit more than one context, for example when a
+ * selective projection falls back to a full-row fetch. Backend-internal setup
+ * statements are not exposed as separate query-hook events.
  */
-type DynamicNodeCollection = WidenBrandedIds<NodeCollection<NodeType, string>>;
+type QueryHookContext = HookContext & Readonly<{
+    /** The SQL statement being executed */
+    sql: string;
+    /** Query parameters */
+    params: readonly unknown[];
+}>;
 /**
- * An edge collection with widened generics for runtime string-keyed access.
- *
- * This is the return type of `store.getEdgeCollection(kind)`. It exposes
- * the full `EdgeCollection` API but with `NodeType` endpoint types, since
- * the concrete from/to types are not known at compile time.
- *
- * ID parameters accept plain `string` instead of branded `EdgeId<E>`, since
- * the dynamic path typically receives IDs from edge metadata, snapshots,
- * or external input where the brand is not available.
+ * Operation hook context for CRUD operations.
  */
-type DynamicEdgeCollection = WidenBrandedIds<EdgeCollection<AnyEdgeType, NodeType, NodeType>>;
+type OperationHookContext = HookContext & Readonly<{
+    /** Operation type */
+    operation: "create" | "update" | "delete";
+    /** Entity type */
+    entity: KindEntity;
+    /** Kind of node or edge */
+    kind: string;
+    /** Entity ID */
+    id: string;
+}>;
+/** Context for one set-based collection mutation. */
+type BulkOperationHookContext = HookContext & Readonly<{
+    operation: "updateWhere";
+    entity: "node";
+    kind: string;
+}>;
 /**
- * A type-level projection of a store's surface onto a subset of its
- * node and edge collections.
+ * Observability hooks for monitoring store operations.
  *
- * Node collections are projected with constraint names erased (`never`),
- * so constraint-based methods like `findByConstraint` become uncallable.
- * This is intentional: unique constraints are graph-registration-level
- * details that differ between graphs sharing the same node types.
+ * Note: Batch operations (`bulkCreate`, `bulkInsert`, `bulkUpsertById`) skip
+ * per-item operation hooks for throughput. Query hooks still fire normally.
  *
  * @example
  * ```typescript
- * type CoreStore = StoreProjection<
- *   typeof myGraph,
- *   "Document" | "Chunk",
- *   "hasChunk"
- * >;
+ * const hooks: StoreHooks = {
+ *   onQueryStart: (ctx) => {
+ *     console.log(`[${ctx.operationId}] Query: ${ctx.sql}`);
+ *   },
+ *   onQueryEnd: (ctx, result) => {
+ *     const duration = Date.now() - ctx.startedAt.getTime();
+ *     console.log(`[${ctx.operationId}] Completed in ${duration}ms`);
+ *   },
+ *   onError: (ctx, error) => {
+ *     console.error(`[${ctx.operationId}] Error:`, error);
+ *   },
+ * };
  *
- * async function ingestChunk(
- *   store: CoreStore,
- *   document: Node<typeof Document>,
- *   text: string,
- * ) {
- *   const chunk = await store.nodes.Chunk.create({ text });
- *   await store.edges.hasChunk.create(document, chunk);
- *   return chunk;
- * }
+ * const store = createStore(graph, backend, { hooks });
  * ```
- *
- * Both `Store<G>` and `TransactionContext<G>` are structurally assignable
- * to a `StoreProjection` whose keys are a subset of `G`.
- */
-type StoreProjection<G extends GraphDef, N extends keyof G["nodes"] & string = never, E extends keyof G["edges"] & string = never> = Readonly<{
-    nodes: {
-        [K in N]-?: NodeCollection<G["nodes"][K]["type"], never>;
-    };
-    edges: Pick<GraphEdgeCollections<G>, E>;
-}>;
-
-/**
- * ExecutableAggregateQuery - A query with aggregate functions that can be executed.
- */
-
-/**
- * Result type for aggregate queries.
- * Maps field refs to their value types and aggregates to numbers.
- */
-type AggregateResult<R extends Record<string, FieldRef | AggregateExpr>> = {
-    [K in keyof R]: R[K] extends AggregateExpr ? number : R[K] extends FieldRef ? unknown : never;
-};
-/**
- * An aggregate query that can be executed.
  */
-declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends AliasMap, R extends Record<string, FieldRef | AggregateExpr>> {
-    #private;
-    constructor(config: QueryBuilderConfig, state: QueryBuilderState, fields: R);
-    /**
-     * Builds the query AST.
-     */
-    toAst(): QueryAst;
+type StoreHooks = Readonly<{
+    /** Called before each query-builder statement is submitted to the backend. */
+    onQueryStart?: (ctx: QueryHookContext) => void;
+    /** Called after each submitted query-builder statement succeeds. */
+    onQueryEnd?: (ctx: QueryHookContext, result: Readonly<{
+        rowCount: number;
+        durationMs: number;
+    }>) => void;
+    /** Called before a CRUD operation starts */
+    onOperationStart?: (ctx: OperationHookContext) => void;
+    /** Called before a set-based collection mutation starts. */
+    onBulkOperationStart?: (ctx: BulkOperationHookContext) => void;
     /**
-     * Orders results by a grouped field or aggregate alias.
-     *
-     * `key` is one of the output names passed to `.aggregate({...})` — either
-     * a grouped field (e.g. `genre`) or an aggregate alias (e.g. `bookCount`).
-     * Both are ordered the same way: by referencing the SELECT-list output
-     * column, since every `.aggregate()` field is projected with an alias.
-     *
-     * Chain multiple calls to sort by more than one key, in call order:
-     * `.orderBy("genre").orderBy("bookCount", "desc")` sorts by genre first,
-     * then by book count within each genre.
-     *
-     * @example
-     * ```typescript
-     * // Top 2 authors by book count
-     * store.query()
-     *   .from("Author", "a")
-     *   .traverse("wrote", "e")
-     *   .to("Book", "b")
-     *   .groupByNode("a")
-     *   .aggregate({ author: field("a", "name"), bookCount: count("b") })
-     *   .orderBy("bookCount", "desc")
-     *   .limit(2)
-     *   .execute();
-     * ```
+     * Called after a CRUD operation completes AND is durably committed. For a
+     * top-level operation that is when its own transaction commits; for an
+     * operation inside `store.transaction`, emission is deferred until the
+     * enclosing transaction commits — if that commit fails, the operation is
+     * reported through `onError` instead. (Inside an adopted transaction —
+     * `withTransaction` / `withRecordedTransaction` — the commit belongs to
+     * the caller and cannot be observed, so this fires when the operation
+     * completes within the still-open transaction.)
      */
-    orderBy<K extends keyof R & string>(key: K, direction?: SortDirection): ExecutableAggregateQuery<G, Aliases, R>;
+    onOperationEnd?: (ctx: OperationHookContext, result: Readonly<{
+        durationMs: number;
+    }>) => void;
     /**
-     * Limits the number of results.
+     * Called after a set-based mutation durably commits. Inside
+     * `store.transaction`, emission is deferred until the enclosing commit.
      */
-    limit(n: number): ExecutableAggregateQuery<G, Aliases, R>;
+    onBulkOperationEnd?: (ctx: BulkOperationHookContext, result: Readonly<{
+        affectedCount: number;
+        durationMs: number;
+    }>) => void;
     /**
-     * Offsets the results.
+     * Called when an operation fails — including an operation that completed
+     * inside a `store.transaction` whose commit then failed and rolled it
+     * back.
      */
-    offset(n: number): ExecutableAggregateQuery<G, Aliases, R>;
+    onError?: (ctx: HookContext, error: Error) => void;
+}>;
+type BaseStoreOptions = Readonly<{
+    /** Observability hooks for monitoring */
+    hooks?: StoreHooks;
     /**
-     * Compiles the query and returns the SQL text and parameters.
+     * Maintain a durable, graph-wide revision anchor for TypeGraph writes:
+     * a random per-graph origin plus a monotonic revision clock. `branch()` uses
+     * this anchor to validate that its base has not moved without
+     * re-fingerprinting every live row, and cannot confuse a coincident clock in
+     * a separately created store for its original base. `history: true` enables
+     * the same tracking automatically through its recorded-time commit clock.
      *
-     * Requires a backend to be configured (the backend determines the SQL dialect).
-     * Use this for debugging, logging, or running the query with a custom executor.
+     * This is intentionally opt-in for live stores: each successful graph write
+     * advances the anchor inside its write transaction. On PostgreSQL, those
+     * transactions take a graph-scoped advisory lock until commit; writes to the
+     * same graph therefore serialize. Enable it for branchable graphs, but size
+     * high-throughput multi-writer workloads for that trade-off.
+     *
+     * Writes performed directly through a backend — including raw graph-table
+     * writes through `tx.sql` — bypass the anchor and are outside the
+     * revision-tracking contract.
      */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
+    revisionTracking?: boolean;
     /**
-     * Compiles the query to TypeGraph's database-independent SQL fragment.
+     * Automatic planner-statistics refresh after large autocommit bulk
+     * writes (bulkCreate and bulkInsert on nodes and edges). Stale statistics after a
+     * bulk load are a whole class of planner cliffs: the planner keeps
+     * pre-load row estimates until ANALYZE runs. When a single
+     * autocommit bulk write reaches the threshold
+     * ({@link AUTO_REFRESH_STATISTICS_ROW_THRESHOLD} rows by default),
+     * the store runs `refreshStatistics()` after the write commits.
+     * Pass a number to change the threshold, or `false` to disable.
+     * Bulk writes inside a caller-provided transaction never
+     * auto-refresh (statistics cannot see uncommitted rows); refresh
+     * manually after commit. `importGraph` handles its own refresh.
      */
-    compile(): CompiledSelectSql;
+    autoRefreshStatistics?: false | number;
     /**
-     * Executes the query and returns typed results.
+     * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose
+     * validated props are value-identical to the existing live row. Default
+     * off.
      *
-     * @throws Error if no backend is configured
-     */
-    execute(): Promise<readonly AggregateResult<R>[]>;
-}
-
-/**
- * How a "current" valid-time read instant is emitted into compiled SQL:
- *
- * - `"literal"` — bound as a concrete value at compile time
- *   ({@link currentReadInstant}). The instant is frozen into the compiled
- *   statement, so the statement must be recompiled to observe a newer "now".
- * - `"placeholder"` — bound as a reserved execution-time placeholder
- *   ({@link currentReadInstantPlaceholder}). The statement can be compiled
- *   once and reused across executions, filling a fresh instant each call.
- *
- * Defaults to `"literal"` everywhere except the query builder's compiled
- * template cache, which opts into `"placeholder"` so a reused/prepared query
- * never freezes "now" the way a cached literal would (the #246 regression).
- */
-type ReadInstantMode = "literal" | "placeholder";
-
-/**
- * Query Compiler Module
- *
- * Main entry point for compiling query ASTs to SQL.
- * Re-exports individual compiler modules and provides the main compile functions.
- */
-
-/**
- * Options for query compilation.
- */
-type CompileQueryOptions = Readonly<{
-    /** SQL dialect ("sqlite" or "postgres"). Defaults to "sqlite". */
-    dialect?: SqlDialect | undefined;
-    /** SQL schema configuration from createSqlSchema(...). Defaults to standard names. */
-    schema?: SqlSchema | undefined;
-    /**
-     * Fulltext strategy override. When set, overrides the dialect's
-     * default fulltext strategy for `$fulltext.matches()` compilation.
-     * Callers typically read this from `backend.fulltextStrategy` so a
-     * backend-declared strategy (e.g. ParadeDB) wins over the dialect
-     * default (tsvector).
-     */
-    fulltextStrategy?: FulltextStrategy | undefined;
-    /**
-     * Vector strategy override. When set, `field.similarTo(...)`
-     * predicates compile against the strategy's per-`(kind, field)`
-     * tables and distance expression. Callers read it from
-     * `backend.vectorStrategy` so a backend-declared strategy (pgvector,
-     * libsql-native, sqlite-vec) drives the per-field relevance scan.
-     */
-    vectorStrategy?: VectorStrategy | undefined;
-    /**
-     * Whether the active backend supports SQL window functions such as
-     * `ROW_NUMBER()`. Defaults to true for direct compiler callers.
-     */
-    windowFunctions?: boolean | undefined;
-    /**
-     * Declared embedding slots `(kind, fieldPath) -> descriptor` used by
-     * the `field.similarTo(...)` CTE to know which kinds in an alias
-     * declare the field. Callers build it from the graph's node schemas.
-     */
-    vectorSlots?: VectorSlotMap | undefined;
-    /** Per-kind declared fulltext language (see buildFulltextLanguages). */
-    fulltextLanguages?: ReadonlyMap<string, string> | undefined;
-    /**
-     * Recorded read relation to use when the AST carries `recordedAsOf`.
-     * Supplying a recorded timestamp without this binding is rejected so the
-     * compiler never silently swaps to TypeGraph's built-in history tables when
-     * the store was only configured for live/valid-time reads.
-     */
-    recordedReadBinding?: RecordedReadBinding | undefined;
-    /**
-     * How the "current" valid-time read instant is emitted. Defaults to
-     * `"literal"` (a value frozen at compile time). The query builder's
-     * compiled template cache passes `"placeholder"` so the instant is a
-     * reserved execution-time slot, letting one compiled statement be reused
-     * across executions with a fresh "now" each call. See {@link ReadInstantMode}.
+     * Enable this for at-least-once / replay materializers. An event log that
+     * re-delivers a byte-identical change would otherwise rewrite the row anyway:
+     * today an `upsertById` on an existing id calls `updateNode`
+     * unconditionally, allocating a fresh recorded instant and a new history row
+     * per re-delivery.
+     *
+     * The win is scoped to re-delivery of the **current** value. A full
+     * replay-from-zero over the current state still writes wherever the stream
+     * superseded a value in place: re-applying an older value over the live row
+     * is a genuine change (and restoring the current value afterwards is
+     * another), so only streams whose rows never supersede each other replay
+     * without churn. A rebuild that should avoid that re-walk belongs in a fresh
+     * store — replay into it and publish it, rather than re-applying the log
+     * over current state.
+     *
+     * When enabled, an upsert that would not change the stored value performs
+     * **no write at all**: no `updateNode`, no recorded-time capture, no history
+     * row, no revision-anchor advance, and no `update` operation hooks (nothing
+     * happened, so nothing is reported). It resolves with the **existing** node,
+     * preserving its original `validFrom` / `updatedAt` / `version`.
+     *
+     * Receipt shape is unchanged and needs no new signal: a coalesced upsert
+     * still counts as one write intent (`writes.total` includes it), but
+     * captures nothing (`receipt.recorded` stays `undefined` when it is the only
+     * write) — the same shape a no-op delete already produces, so a consumer
+     * that carries the prior anchor forward on `recorded === undefined` handles
+     * it unchanged.
+     *
+     * 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).
+     *   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
+     *      temporal override is a deliberate request and is never coalesced;
+     *      applied per item in the bulk path).
+     *   4. The new props, merged over the stored props and run through the
+     *      kind's Zod schema (defaults applied, values normalized), are deeply
+     *      value-identical to the stored props (key order aside).
+     *
+     * Default-off because some consumers *want* an audit row per re-delivery as
+     * proof the event was reprocessed; coalescing removes that signal.
      */
-    readInstant?: ReadInstantMode | undefined;
+    coalesceUnchangedUpserts?: boolean;
+    /** SQL schema configuration from createSqlSchema(...) for custom table names */
+    schema?: SqlSchema;
+    /** Query default behaviors. */
+    queryDefaults?: Readonly<{
+        /** Default traversal ontology expansion mode (default: "inverse"). */
+        traversalExpansion?: TraversalExpansion;
+    }>;
 }>;
-
 /**
- * PreparedQuery — a pre-validated, parameterized query.
+ * Store options without built-in recorded-time capture. A recorded read relation
+ * can still be bound explicitly for hosts that populate history externally.
+ */
+type LiveStoreOptions = BaseStoreOptions & Readonly<{
+    history?: false | undefined;
+    recordedRead?: ExternalRecordedReadSource | undefined;
+}>;
+/** Live-store options that do not bind a recorded-read relation. */
+type UnboundLiveStoreOptions = LiveStoreOptions & Readonly<{
+    recordedRead?: undefined;
+}>;
+/** Live-store options with an explicitly bound recorded-read relation. */
+type RecordedReadStoreOptions = LiveStoreOptions & Readonly<{
+    recordedRead: NonNullable<LiveStoreOptions["recordedRead"]>;
+}>;
+/**
+ * Store options with TypeGraph-managed recorded-time capture. `history: true`
+ * captures TypeGraph writes and binds TypeGraph's built-in recorded relation
+ * internally. Externally populated recorded read sources are read-only bindings
+ * and are intentionally accepted only by {@link LiveStoreOptions}.
+ */
+type HistoryStoreOptions = BaseStoreOptions & Readonly<{
+    history: true;
+    recordedRead?: never;
+}>;
+/**
+ * Options for creating a store.
+ */
+type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
+/**
+ * A mutable handle to the current `Store`, used by `store.evolve(...)`
+ * so long-lived consumers can dereference through the ref and pick up
+ * the new Store after each evolve call. When the ref is passed via
+ * `evolve(extension, { ref })`, `current` is overwritten with the replacement
+ * before a successful call resolves.
  *
- * Created via `ExecutableQuery.prepare()`. Builds and structurally validates
- * the query AST once at prepare time (so a malformed query fails fast, before
- * the first `execute()`).
+ * **Request semantics.** Dereference once at request entry only when that
+ * request will not change the schema. A schema-changing call such as
+ * `evolve()` returns the Store for the resulting schema and updates
+ * `ref.current`; a Store captured before that call remains pinned to the old
+ * schema. Use the returned Store (or dereference `ref.current` again) for every
+ * subsequent operation in the same request:
  *
- * Fast path: when the backend can compile and run raw SQL (`compileSql` +
- * `executeRaw`), the statement is compiled ONCE into a cached template whose
- * "current" read instant and user `param()` refs are reserved placeholders
- * (see {@link buildReadInstantTemplate}). Every `execute()` fills those
- * placeholders — a fresh instant plus the call's bindings — and runs the
- * cached SQL text directly, so a reused prepared query never recompiles and
- * never freezes "now" the way a cached literal instant would (the #246
- * regression).
+ * ```ts
+ * async function handleRequest(): Promise<void> {
+ *   const store = ref.current;
+ *   const evolved = await store.evolve(extension, { ref });
+ *   await evolved.materializeIndexes();
+ *   // ref.current === evolved
+ * }
+ * ```
+ *
+ * A `StoreRef` tracks only schema changes made by calls that receive that ref.
+ * When another process or isolate can commit a schema version, compare
+ * `getCommittedSchemaVersion()` with the cached version before reuse and call
+ * `createVerifiedStore()` or `createVerifiedAdapterStore()` when it changes.
+ *
+ * Pure dereferenceable handle — no event/subscription machinery. If
+ * consumers need eventing, they wrap the ref themselves.
  *
- * Fallback: on a backend without raw execution (custom/async), substitutes
- * parameter refs into the AST, compiles fresh per call, and executes via the
- * standard `backend.execute` path.
+ * Generic over the held value (typically `Store<G>`) so the store
+ * module can refer to it without importing the `Store` class into
+ * `types.ts`. The type parameter is deliberately invariant: evolution writes
+ * a replacement into `current`, so a ref for an adapter-only or history-only
+ * Store must never be accepted by a Store that cannot preserve that surface.
  */
-
-type PreparedQueryConfig<R> = Readonly<{
-    ast: QueryAst;
-    unoptimizedAst: QueryAst;
-    backend: GraphBackend;
-    dialect: SqlDialect;
-    graphId: string;
-    compileOptions: CompileQueryOptions;
-    state: QueryBuilderState;
-    selectiveFields: readonly SelectiveField[] | undefined;
-    selectFn: (context: SelectContext<AliasMap, EdgeAliasMap>) => R;
-    schemaIntrospector: SchemaIntrospector;
+interface StoreRef<in out T> {
+    current: T;
+}
+/**
+ * Result plus write summary. Returned by `store.transactionWithReceipt(fn)`,
+ * `store.withRecordedTransaction(externalTx, fn)` (the adopted-commit path), and
+ * `tx.measure(fn)` (a scoped sub-receipt). See {@link TransactionReceipt}.
+ */
+type TransactionOutcome<T> = Readonly<{
+    result: T;
+    receipt: TransactionReceipt;
 }>;
 /**
- * A pre-validated, parameterized query — see the module doc comment above for
- * how a reused prepared query runs a cached SQL template with a fresh read
- * instant filled per call.
+ * Transaction write summary.
  *
- * @example
- * ```typescript
- * const prepared = store.query()
- *   .from("Person", "p")
- *   .whereNode("p", (p) => p.name.eq(param("name")))
- *   .select((ctx) => ctx.p)
- *   .prepare();
+ * Receipt counts are completed write intents at the collection surface, not
+ * rows affected:
  *
- * // Execute with different bindings
- * const alice = await prepared.execute({ name: "Alice" });
- * const bob = await prepared.execute({ name: "Bob" });
- * ```
+ * 1. Every successful completion of a write method on `tx.nodes.*` /
+ *    `tx.edges.*` counts. The authoritative method list is
+ *    {@link NodeWrites} / {@link EdgeWrites}.
+ * 2. Bulk methods count by input length; an empty bulk call (`bulkCreate([])`)
+ *    counts 0.
+ * 3. Single-row methods count 1 on resolve — including `delete` of an absent
+ *    id and `getOrCreate*` that found an existing row. Consumers that need
+ *    "did anything actually change" semantics apply their own per-operation
+ *    policy.
+ * 4. A method that rejects counts 0 — even when the backend applied part of a
+ *    bulk input before failing. On SQLite a failed statement does not abort
+ *    the surrounding transaction, so a caller that catches the rejection and
+ *    commits can persist rows the receipt never counted. Do not read the
+ *    receipt as rows-affected in that scenario.
+ * 5. A node `delete` under `cascade` / `disconnect` removes connected edges
+ *    through the backend, not the edge-collection surface; those removals do
+ *    not appear in `edges`.
+ * 6. Rows-affected fidelity is intentionally out of scope for this first
+ *    version; a future extension could ask backends to return row counts.
  */
-declare class PreparedQuery<R> {
-    #private;
-    constructor(config: PreparedQueryConfig<R>);
-    /** The set of parameter names required by this prepared query. */
-    get parameterNames(): ReadonlySet<string>;
+type TransactionReceipt = Readonly<{
+    writes: Readonly<{
+        /** Completed node write intents by node kind. */
+        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. */
+        total: number;
+    }>;
     /**
-     * Executes the prepared query with the given parameter bindings.
-     *
-     * @param bindings - A record mapping parameter names to their values
-     * @returns The query results
+     * The recorded commit instant allocated for this store's graph by this
+     * transaction. Undefined when history capture is off, the transaction is
+     * read-only, or no captured writes were flushed. **Always undefined on a
+     * scoped receipt from {@link ScopedMeasure}** (`tx.measure`) — the recorded
+     * instant is a per-transaction flush concern allocated once when the whole
+     * transaction's capture flushes, unknowable mid-transaction.
      */
-    execute(bindings?: Readonly<Record<string, unknown>>): Promise<readonly R[]>;
-}
-
+    recorded?: RecordedInstant;
+}>;
 /**
- * UnionableQuery - A query formed by combining multiple queries with set operations.
+ * Behavior when a get-or-create operation matches an existing record.
  */
-
-interface ExecutableQueryLike<G extends GraphDef, R> {
-    toAst(): QueryAst;
-}
+type IfExistsMode = "return" | "update";
 /**
- * Internal state for unionable query.
+ * Action taken by a get-or-create operation.
  */
-type UnionableQueryState = Readonly<{
-    left: ComposableQuery;
-    operator: SetOperationType;
-    right: ComposableQuery;
-    limit?: number;
-    offset?: number;
-    startAlias?: string;
-    traversals?: readonly Traversal[];
-    selectFn?: (context: SelectContext<AliasMap, EdgeAliasMap>) => unknown;
+type GetOrCreateAction = "created" | "found" | "updated" | "resurrected";
+/**
+ * Result of a node getOrCreateByConstraint operation.
+ */
+type NodeGetOrCreateByConstraintResult<N extends NodeType> = Readonly<{
+    node: Node<N>;
+    action: GetOrCreateAction;
 }>;
-declare class UnionableQuery<G extends GraphDef, R> {
-    #private;
-    constructor(config: QueryBuilderConfig, state: UnionableQueryState);
-    /**
-     * Combines with another query using UNION.
-     */
-    union(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
-    /**
-     * Combines with another query using UNION ALL.
-     */
-    unionAll(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
-    /**
-     * Combines with another query using INTERSECT.
-     */
-    intersect(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
-    /**
-     * Combines with another query using EXCEPT.
-     */
-    except(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
-    /**
-     * Limits the number of results from the combined query.
-     */
-    limit(n: number): UnionableQuery<G, R>;
-    /**
-     * Offsets the results from the combined query.
-     */
-    offset(n: number): UnionableQuery<G, R>;
-    /**
-     * Builds the set operation AST.
-     */
-    toAst(): SetOperation;
+/**
+ * Options for node getOrCreateByConstraint operations.
+ */
+type NodeGetOrCreateByConstraintOptions = Readonly<{
+    /** Existing record behavior. Default: "return" */
+    ifExists?: IfExistsMode;
+}>;
+/**
+ * Options for node bulkFindByIndex operations.
+ */
+type NodeBulkFindByIndexOptions = Readonly<{
     /**
-     * Compiles the query and returns the SQL text and parameters.
+     * Maximum number of candidate nodes returned per input item. When omitted,
+     * each input's candidate set is unbounded. Must be a positive integer.
      *
-     * Requires a backend to be configured (the backend determines the SQL dialect).
-     * Use this for debugging, logging, or running the query with a custom executor.
-     */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
-    /**
-     * Compiles the set operation to SQL.
-     */
-    compile(): CompiledSelectSql;
-    /**
-     * Executes the combined query.
+     * Candidates are ordered deterministically by node id, so the cap is stable
+     * across calls. Use this to bound fan-out on low-selectivity index keys.
      */
-    execute(): Promise<readonly R[]>;
+    limitPerInput?: number;
+}>;
+/**
+ * Per-endpoint fan-out cap shared by the live and view forms of the edge
+ * bulk endpoint reads.
+ */
+type EdgeBulkFindOptions = Readonly<{
     /**
-     * Executes the combined query against a provided backend.
+     * Maximum number of edges returned for each input endpoint. When omitted,
+     * every input's edge set is unbounded. Must be a positive integer.
      *
-     * Used by `store.batch()` to run multiple queries over a single connection.
+     * The cap keeps each input's leading edges under the same ordering
+     * `findFrom` / `findTo` return, so it bounds fan-out without reordering
+     * anything.
      */
-    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
-}
-
+    limitPerInput?: number;
+}>;
 /**
- * ExecutableQuery - A query that can be executed, paginated, or streamed.
+ * Options for the edge bulk endpoint reads: the temporal coordinate every
+ * edge read accepts, plus the per-endpoint fan-out cap.
  */
-
+type EdgeBulkFindEndpointOptions = QueryOptions & EdgeBulkFindOptions;
+/** A kind-grouped source list for a heterogeneous bulk edge read. */
+type BulkEdgeSourceGroup<G extends GraphDef> = {
+    [K in NodeKinds<G>]: Readonly<{
+        kind: K;
+        ids: readonly NodeId<G["nodes"][K]["type"]>[];
+    }>;
+}[NodeKinds<G>];
+/** A node reference whose kind and branded id remain correlated. */
+type GraphNodeReference<G extends GraphDef> = {
+    [K in NodeKinds<G>]: Readonly<{
+        kind: K;
+        id: NodeId<G["nodes"][K]["type"]>;
+    }>;
+}[NodeKinds<G>];
+/** Runtime edge union narrowed to the selected graph edge kinds. */
+type GraphEdgeForKinds<G extends GraphDef, K extends EdgeKinds<G>> = {
+    [P in K]: Edge<G["edges"][P]["type"], G["edges"][P]["from"][number], G["edges"][P]["to"][number]>;
+}[K];
+/** Input for {@link Store.bulkFindEdgesFrom}. */
+type BulkFindEdgesFromParams<G extends GraphDef, K extends EdgeKinds<G>> = Readonly<{
+    sources: readonly BulkEdgeSourceGroup<G>[];
+    edgeKinds: readonly K[];
+}>;
+/** One source bucket returned by {@link Store.bulkFindEdgesFrom}. */
+type BulkFindEdgesFromResult<G extends GraphDef, K extends EdgeKinds<G>> = Readonly<{
+    source: GraphNodeReference<G>;
+    edges: readonly GraphEdgeForKinds<G, K>[];
+}>;
 /**
- * A query that can be executed.
+ * Result of an edge getOrCreateByEndpoints operation.
  */
-declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap = {}, RecursiveAliases extends RecursiveAliasMap = {}, R = unknown> {
-    #private;
-    constructor(config: QueryBuilderConfig, state: QueryBuilderState, selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R);
-    /**
-     * Builds the query AST (memoized — the instance is immutable).
-     */
-    toAst(): QueryAst;
-    /**
-     * Orders results.
-     */
-    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
-    /**
-     * Limits the number of results.
-     */
-    limit(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
-    /**
-     * Offsets the results.
-     */
-    offset(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
+type EdgeGetOrCreateByEndpointsResult<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
+    edge: Edge<E, From, To>;
+    action: GetOrCreateAction;
+}>;
+/**
+ * Options for edge findByEndpoints operations.
+ */
+type EdgeFindByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
     /**
-     * Applies a query fragment to transform this executable query.
-     *
-     * Useful for applying post-select transformations like ordering,
-     * limits, and offsets from reusable fragments.
-     *
-     * @example
-     * ```typescript
-     * const paginated = (q) => q.orderBy("u", "createdAt", "desc").limit(10);
-     *
-     * const results = await query()
-     *   .from("User", "u")
-     *   .select((ctx) => ctx.u)
-     *   .pipe(paginated)
-     *   .execute();
-     * ```
-     *
-     * @param fragment - A function that transforms the executable query
-     * @returns The transformed executable query
+     * Edge property fields to include in the match alongside the (from, to) endpoints.
+     * When omitted, matches on endpoints only (returns the first edge at the read coordinate).
      */
-    pipe<NewR = R>(fragment: (query: ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>) => ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>;
+    matchOn?: readonly (keyof z.input<E["schema"]>)[];
+    /** Property values to match against when matchOn is specified. */
+    props?: Partial<z.input<E["schema"]>>;
+}>;
+/**
+ * Options for edge getOrCreateByEndpoints operations.
+ */
+type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
     /**
-     * Combines this query with another using UNION (removes duplicates).
+     * Edge property fields to include in the match key alongside the (from, to) endpoints.
+     * Default: `[]` — match on endpoints only.
      */
-    union(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    matchOn?: readonly (keyof z.input<E["schema"]>)[];
+    /** Existing record behavior. Default: "return" */
+    ifExists?: IfExistsMode;
     /**
-     * Combines this query with another using UNION ALL (keeps duplicates).
+     * Valid-time start for a newly created edge. Ignored when an edge is found,
+     * updated, or resurrected.
      */
-    unionAll(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    validFrom?: string;
     /**
-     * Combines this query with another using INTERSECT.
+     * Valid-time end for a created, updated, or resurrected edge. Ignored when
+     * the operation returns an existing edge without writing.
      */
-    intersect(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    validTo?: string;
+}>;
+/**
+ * A collection of nodes of a specific type.
+ *
+ * Provides ergonomic CRUD operations for a single node type.
+ */
+type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
     /**
-     * Combines this query with another using EXCEPT.
+     * Create a new node.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    except(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    create: (props: z.input<N["schema"]>, options?: Readonly<{
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
+    /** Get a node by ID */
+    getById: (id: NodeId<N>, options?: QueryOptions) => Promise<Node<N> | undefined>;
+    /** Get multiple nodes by ID, preserving input order (undefined for missing) */
+    getByIds: (ids: readonly NodeId<N>[], options?: QueryOptions) => Promise<readonly (Node<N> | undefined)[]>;
+    /** Update a node */
+    update: (id: NodeId<N>, props: Partial<z.input<N["schema"]>>, options?: Readonly<{
+        validTo?: string;
+    }>) => Promise<Node<N>>;
     /**
-     * Compiles the query and returns the SQL text and parameters.
+     * Updates every current node selected by the supplied predicates in one
+     * set-based write. Relationship clauses are independent EXISTS predicates
+     * and are ANDed with each other and with `where`.
+     */
+    updateWhere: (params: Readonly<{
+        patch: Partial<z.input<N["schema"]>>;
+        where?: (accessor: string extends N["kind"] ? DynamicNodeAccessor : NodeAccessor<N>) => Predicate;
+        exists?: readonly Readonly<{
+            edgeKind: string;
+            direction: "out" | "in";
+            relatedKind: string;
+            whereEdge?: (accessor: DynamicEdgeAccessor) => Predicate;
+            whereRelated?: (accessor: DynamicNodeAccessor) => Predicate;
+        }>[];
+        all?: true;
+    }>) => Promise<Readonly<{
+        affectedCount: number;
+    }>>;
+    /** Delete a node (soft delete - sets deletedAt timestamp) */
+    delete: (id: NodeId<N>) => Promise<void>;
+    /**
+     * Permanently delete a node from the database.
      *
-     * Requires a backend to be configured (the backend determines the SQL dialect).
-     * Use this for debugging, logging, or running the query with a custom executor.
+     * Unlike `delete()` which performs a soft delete, this permanently
+     * removes the node and its associated data (uniqueness entries, embeddings).
+     *
+     * **Warning:** This operation is irreversible and should be used carefully.
+     * Consider using soft delete (`delete()`) for most use cases.
+     *
+     * @throws Error if edges are still connected to this node (delete edges first)
      */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
+    hardDelete: (id: NodeId<N>) => Promise<void>;
     /**
-     * Compiles the query to TypeGraph's database-independent SQL fragment.
+     * Find nodes matching criteria.
      *
-     * Pass the result to a GraphBackend, or use toSQL() to render SQL text and
-     * parameters for the configured dialect.
+     * Supports predicate filtering via the `where` option for SQL-level filtering.
+     * For simple queries. Use store.query() for complex traversals.
      */
-    compile(): CompiledSelectSql;
+    find: (filter?: Readonly<{
+        where?: (accessor: NodeAccessor<N>) => Predicate;
+        limit?: number;
+        offset?: number;
+    }>, temporal?: QueryOptions) => Promise<Node<N>[]>;
+    /** Count nodes matching criteria */
+    count: (temporal?: QueryOptions) => Promise<number>;
     /**
-     * Creates a prepared (pre-validated) query that can be executed multiple
-     * times with different parameter bindings. Builds and structurally
-     * validates the AST once (a malformed query fails fast, here, instead of on
-     * first use); the prepared query then compiles once into a reusable template
-     * and fills a fresh read instant per execute() — see PreparedQuery's class
-     * doc comment.
+     * Create a node from untyped data, relying on runtime Zod validation.
      *
-     * Use `param("name")` in predicates to create parameterized slots,
-     * then pass values via `prepared.execute({ name: "value" })`.
+     * Use this for dynamic dispatch (changesets, migrations, imports) where
+     * the data shape is determined at runtime, not compile time.
+     * The return type is fully typed — only the input gate is relaxed.
      *
-     * @example
-     * ```typescript
-     * import { param } from "@nicia-ai/typegraph";
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     */
+    createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
+    /**
+     * Create or update a node.
      *
-     * const prepared = store.query()
-     *   .from("Person", "p")
-     *   .whereNode("p", (p) => p.name.eq(param("name")))
-     *   .select((ctx) => ctx.p)
-     *   .prepare();
+     * If a node with the given ID exists, updates it with the provided props.
+     * Otherwise, creates a new node with that ID.
      *
-     * const alice = await prepared.execute({ name: "Alice" });
-     * const bob = await prepared.execute({ name: "Bob" });
-     * ```
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
+     */
+    upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
+    /**
+     * Upsert a node from untyped data, relying on runtime Zod validation.
      *
-     * @throws Error if no backend is configured
+     * Use this for dynamic dispatch (changesets, migrations, imports) where
+     * 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.
      */
-    prepare(): PreparedQuery<R>;
+    upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
     /**
-     * Executes the query and returns typed results.
+     * Create multiple nodes in a batch.
      *
-     * Uses smart optimization to detect when only specific fields are accessed
-     * in the select callback. If the callback only accesses simple field
-     * references (no method calls or computations), generates optimized SQL
-     * that only extracts those fields instead of the full props blob.
+     * More efficient than calling create() multiple times.
+     * Use `bulkInsert` for the dedicated fast path that skips returning results.
      *
-     * @throws Error if no backend is configured
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    execute(): Promise<readonly R[]>;
+    bulkCreate: (items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Node<N>[]>;
     /**
-     * Executes the query against a provided backend.
+     * Create or update multiple nodes in a batch.
+     *
+     * For each item, if a node with the given ID exists, updates it.
+     * Otherwise, creates a new node with that ID.
      *
-     * Used by `store.batch()` to run multiple queries over a single connection
-     * (e.g., within a transaction). The full compile → execute → transform
-     * pipeline runs identically to `execute()`, but against the given backend.
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
-    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
+    bulkUpsertById: (items: readonly Readonly<{
+        id: string;
+        props: z.input<N["schema"]>;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Node<N>[]>;
     /**
-     * Executes a paginated query using cursor-based keyset pagination.
+     * Insert multiple nodes without returning results.
      *
-     * Cursor pagination is efficient for large datasets as it avoids OFFSET.
-     * Requires ORDER BY to be specified for deterministic results.
+     * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`
+     * with `returnResults: false`, the intent is unambiguous: no results
+     * are returned and the operation is wrapped in a transaction.
      *
-     * @param options - Pagination options (first/after for forward, last/before for backward)
-     * @throws ValidationError if ORDER BY is not specified
-     * @throws ValidationError if cursor columns don't match query ORDER BY columns
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    paginate(options: PaginateOptions): Promise<PaginatedResult<R>>;
+    bulkInsert: (items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<void>;
     /**
-     * Returns an async iterator that streams results in batches.
+     * Delete multiple nodes by ID.
      *
-     * Uses cursor pagination internally for efficient memory usage.
-     * Requires ORDER BY to be specified for deterministic results.
+     * Atomic when the backend supports transactions. Silently ignores IDs
+     * that don't exist.
+     */
+    bulkDelete: (ids: readonly NodeId<N>[]) => Promise<void>;
+    /**
+     * Find a node by uniqueness constraint.
      *
-     * @param options - Stream options (batchSize defaults to 1000)
-     * @throws ValidationError if ORDER BY is not specified
+     * Looks up a live node by the named constraint key computed from `props`.
+     * Returns the node if found, or undefined. Soft-deleted nodes are excluded.
+     *
+     * @param constraintName - Name of the uniqueness constraint to match on
+     * @param props - Properties to compute the constraint key from
      */
-    stream(options?: StreamOptions): AsyncIterable<R>;
-}
-
-/**
- * TraversalBuilder - Intermediate builder for edge traversals.
- */
-
-/**
- * Resolves the edge type for an edge alias based on its kind type parameter.
- *
- * For `traverse(...)`, `EK` is a literal like `"authoredBy"` and the
- * type comes from the typed graph. For `traverseDynamic(...)`, `EK` is
- * widened to `string` — `string extends EK` distinguishes that case and
- * resolves to `DynamicEdgeType`, so the conditional accessor types fire.
- */
-type EdgeTypeForKey<G extends GraphDef, EK> = string extends EK ? DynamicEdgeType : EK extends keyof G["edges"] & string ? G["edges"][EK]["type"] : DynamicEdgeType;
-/**
- * State for variable-length traversal configuration.
- */
-interface VariableLengthState {
-    enabled: boolean;
-    minDepth: number;
-    maxDepth: number;
-    cyclePolicy: RecursiveCyclePolicy;
-    pathEnabled: boolean;
-    pathAlias?: string;
-    depthEnabled: boolean;
-    depthAlias?: string;
-}
-/**
- * Intermediate builder for traversal operations.
- *
- * Type parameters track the edge kind and direction to constrain
- * which node kinds are valid targets in the `to()` method.
- */
-declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, EdgeAliases extends EdgeAliasMap = 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[]);
+    findByConstraint: (constraintName: CN, props: z.input<N["schema"]>) => Promise<Node<N> | undefined>;
     /**
-     * Enables variable-length (recursive) traversal.
-     * Defaults to MAX_RECURSIVE_DEPTH (10) hops with cycle prevention.
-     * Use `maxHops` to override (up to MAX_EXPLICIT_RECURSIVE_DEPTH).
+     * Batch version of findByConstraint.
+     *
+     * Results are returned in the same order as the input items.
+     * Returns undefined for entries that don't match.
      */
-    recursive<const O extends RecursiveTraversalOptions = Record<string, never>>(options?: O): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, O extends {
-        depth: infer D extends boolean | string;
-    } ? D : DC, O extends {
-        path: infer P extends boolean | string;
-    } ? P : PC, RecAliases, CoordinateState>;
+    bulkFindByConstraint: (constraintName: CN, items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+    }>[]) => Promise<(Node<N> | undefined)[]>;
     /**
-     * Adds a WHERE clause for the edge being traversed.
+     * Batched candidate retrieval against a declared node index.
+     *
+     * For each input item, TypeGraph computes the index lookup key from
+     * `index.fields` (JSON-pointer extraction, partial-`where` applied to
+     * stored rows, null-safe matching) and returns the live, non-soft-deleted
+     * nodes that share that key. Unlike {@link bulkFindByConstraint}, the index
+     * may be non-unique, so each input yields a (possibly empty) array.
      *
-     * @param alias - The edge alias to filter on (must be the current edge alias)
-     * @param predicateFunction - A function that builds predicates using the edge accessor
+     * Results preserve input order; each inner array is ordered by node id.
+     * Empty input returns `[]`. An unknown index name throws
+     * `NodeIndexNotFoundError`; a type-incompatible indexed field throws
+     * `ValidationError`. This is candidate retrieval, not a uniqueness or
+     * identity guarantee.
+     *
+     * @param indexName - Name of the declared node index to match on
+     * @param items - Records whose `props` supply the indexed-field values
+     * @param options - Optional `limitPerInput` to bound per-input fan-out
      */
-    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases, CoordinateState>;
+    bulkFindByIndex: (indexName: string, items: readonly Readonly<{
+        props: Partial<z.input<N["schema"]>>;
+    }>[], options?: NodeBulkFindByIndexOptions) => Promise<readonly Node<N>[][]>;
     /**
-     * Specifies the target node kind.
+     * Get an existing node by uniqueness constraint, or create a new one.
      *
-     * The kind must be a valid target for this edge based on the traversal direction:
-     * - "out" direction: kind must be in the edge's "to" array
-     * - "in" direction: kind must be in the edge's "from" array
+     * Looks up a node by the named constraint key computed from `props`.
+     * If found, returns it (optionally updating with `ifExists: "update"`).
+     * If not found, creates a new node. Soft-deleted matches are always resurrected.
      *
-     * @param kind - The target node kind
-     * @param alias - A unique alias for this node (compile-time error if duplicate)
+     * @param constraintName - Name of the uniqueness constraint to match on
+     * @param props - Full properties for create, or merge source for update
+     * @param options - Existing record behavior (default: "return")
      */
-    to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
-        includeSubClasses?: false;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"], Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
-    to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
-        includeSubClasses: true;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<NodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
+    getOrCreateByConstraint: (constraintName: CN, props: z.input<N["schema"]>, options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>>;
     /**
-     * String-keyed sibling of `to` for runtime-declared target kinds.
-     * Throws `KindNotFoundError` if the kind is not registered.
+     * Batch version of getOrCreateByConstraint.
+     *
+     * Results are returned in the same order as the input items.
+     * Atomic when the backend supports transactions.
      */
-    toDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
-        includeSubClasses?: boolean;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<EdgeTypeForKey<G, EK>, Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>, CoordinateState>;
-}
-
+    bulkGetOrCreateByConstraint: (constraintName: CN, items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+    }>[], options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>[]>;
+}>;
 /**
- * QueryBuilder - The fluent query builder.
+ * Reference to a node of a specific kind.
+ *
+ * Accepts either:
+ * - A Node instance of the correct kind
+ * - An explicit { kind, id } object with the correct kind name
+ *
+ * This provides compile-time checking that edge endpoints match the
+ * allowed node kinds defined in the edge registration.
  */
-
-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;
+type NodeRef<N extends NodeType = NodeType> = Node<N> | Readonly<{
+    kind: N["kind"];
+    id: string;
+}>;
 /**
- * The fluent query builder.
+ * Options for creating an edge.
+ */
+type EdgeCreateOptions = Readonly<{
+    id?: string;
+    validFrom?: string;
+    validTo?: string;
+}>;
+/**
+ * Arguments for edge creation, with props optional when schema allows empty object.
  *
- * Type parameters accumulate as methods are chained:
- * - G: The graph definition
- * - Aliases: Map of alias names to their node kinds
- * - EdgeAliases: Map of alias names to their edge kinds (accumulated during traversals)
+ * Uses `{}` to check if an empty object literal satisfies the schema input type.
  */
-declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = EmptyAliasMap, EdgeAliases extends EdgeAliasMap = EmptyEdgeAliasMap, RecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, CoordinateState extends QueryCoordinateState = "open"> {
-    #private;
-    readonly temporal: TemporalMethod<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
-    constructor(config: QueryBuilderConfig, state: QueryBuilderState);
+type EdgeCreateArguments<E extends AnyEdgeType> = {} extends z.input<E["schema"]> ? [
+    props?: z.input<E["schema"]>,
+    options?: EdgeCreateOptions
+] : [props: z.input<E["schema"]>, options?: EdgeCreateOptions];
+/**
+ * A collection of edges of a specific type.
+ *
+ * Provides ergonomic CRUD operations for a single edge type.
+ * The From and To type parameters enforce that edge endpoints
+ * match the allowed node types at compile time.
+ *
+ * @example
+ * ```typescript
+ * // Create an edge - pass Node objects directly
+ * const edge = await store.edges.worksAt.create(alice, acme, { role: "Engineer" });
+ *
+ * // TypeScript error: Company is not a valid 'from' type for worksAt
+ * // store.edges.worksAt.create(acme, alice, { role: "Engineer" });
+ *
+ * // For edges with empty schemas, props is optional
+ * await store.edges.wrote.create(author, book);
+ *
+ * // Find edges from a node
+ * const edges = await store.edges.worksAt.findFrom(alice);
+ * ```
+ */
+type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
     /**
-     * Starts a query from a node kind.
+     * Create a new edge.
      *
-     * @param kind - The node kind to start from
-     * @param alias - A unique alias for this node (compile-time error if duplicate)
-     */
-    from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options?: {
-        includeSubClasses?: false;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<G["nodes"][K]["type"]>>, EdgeAliases, RecursiveAliases, CoordinateState>;
-    from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
-        includeSubClasses: true;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias>, EdgeAliases, RecursiveAliases, CoordinateState>;
-    /**
-     * String-keyed sibling of `from` for runtime-declared kinds. Throws
-     * `KindNotFoundError` if the kind is not registered. Predicates use
-     * the `n.field("name").number().gte(...)` discriminator.
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     *
+     * @param from - Source node (must be one of the allowed 'from' types)
+     * @param to - Target node (must be one of the allowed 'to' types)
+     * @param args - Edge properties (optional if schema is empty) and creation options
      */
-    fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
-        includeSubClasses?: boolean;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases, CoordinateState>;
+    create: (from: NodeRef<From>, to: NodeRef<To>, ...args: EdgeCreateArguments<E>) => Promise<Edge<E, From, To>>;
+    /** Get an edge by ID */
+    getById: (id: EdgeId<E>, options?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
+    /** Get multiple edges by ID, preserving input order (undefined for missing) */
+    getByIds: (ids: readonly EdgeId<E>[], options?: QueryOptions) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
+    /** Update an edge's properties */
+    update: (id: EdgeId<E>, props: Partial<z.input<E["schema"]>>, options?: Readonly<{
+        validTo?: string;
+    }>) => Promise<Edge<E, From, To>>;
     /**
-     * Adds a WHERE clause for a node.
+     * Find edges from a specific node.
+     *
+     * Honors the same temporal model as `getById` / `find`: with no
+     * `options`, the graph's default `temporalMode` applies (excluding
+     * soft-deleted edges and, in `current` / `asOf` modes, edges outside
+     * their validity window). Pass `temporalMode` / `asOf` to read the
+     * endpoint's edges at another temporal coordinate.
      */
-    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    findFrom: (from: NodeRef<From>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /**
-     * Adds a WHERE clause for an edge.
+     * Find edges to a specific node.
      *
-     * @param alias - The edge alias to filter on
-     * @param predicateFunction - A function that builds predicates using the edge accessor
+     * Temporal semantics mirror {@link EdgeCollection.findFrom}.
      */
-    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    findTo: (to: NodeRef<To>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /**
-     * Traverses an edge to another node (outgoing direction).
+     * Find the edges from a SET of source nodes in one read.
      *
-     * By default, traverses from the current node (last traversal target, or start node).
-     * Use the `from` option to traverse from a different alias (fan-out pattern).
+     * `findFrom` with a widened endpoint predicate and nothing else: the same
+     * temporal model, the same soft-delete filtering, and the same per-source
+     * ordering — but `from_id IN (...)` instead of `from_id = ?`, so a page of
+     * N sources costs one statement per distinct source kind and bind-budget
+     * chunk rather than N singleton statements.
      *
-     * @param options.expand - Ontology expansion mode for implying/inverse edges
-     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
-     */
-    traverse<EK extends keyof G["edges"] & string, EA extends string>(edgeKind: EK, edgeAlias: EA, options?: {
-        direction?: "out";
-        expand?: TraversalExpansion;
-        from?: keyof Aliases & string;
-    }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "out", false, false, false, RecursiveAliases, CoordinateState>;
-    /**
-     * Traverses an edge to another node (incoming direction).
+     * Results are grouped per input: the outer array is parallel to `froms`
+     * (index `i` holds the edges of `froms[i]`), and repeated inputs each get
+     * their own copy of the same edge set. Empty input returns `[]`; a source
+     * with no edges gets an empty array. Large inputs are split across
+     * statements to respect the backend's bound-parameter budget, which is
+     * invisible in the result.
      *
-     * By default, traverses from the current node (last traversal target, or start node).
-     * Use the `from` option to traverse from a different alias (fan-out pattern).
+     * Requires a backend implementing `findEdgesByEndpointSet` — both bundled
+     * Drizzle backends do. On one that does not, this **refuses** with a
+     * `ConfigurationError` rather than looping `findFrom` per input: asking for
+     * a bulk read is asking for set-oriented statements, and silently issuing N
+     * singleton statements is the cost surprise the method exists to remove.
      *
-     * @param options.direction - Set to "in" for incoming edge traversal
-     * @param options.expand - Ontology expansion mode for implying/inverse edges
-     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
+     * @param froms - Source nodes to read the edges of
+     * @param options - Temporal coordinate plus optional `limitPerInput`
+     * @throws {ConfigurationError} when the backend cannot read an endpoint set
      */
-    traverse<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", false, false, false, RecursiveAliases, CoordinateState>;
+    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /**
-     * String-keyed sibling of `traverse` for runtime-declared edge kinds.
-     * Throws `KindNotFoundError` if the edge kind is not registered.
+     * Find the edges into a SET of target nodes in one read.
+     *
+     * Mirrors {@link EdgeCollection.bulkFindFrom} on the `to` endpoint.
      */
-    traverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
-        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>;
+    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /**
-     * Optionally traverses an edge to another node (LEFT JOIN semantics).
-     * If no matching edge/node exists, the result will include null values.
+     * Deferred variant of `findFrom` for use with `store.batch()`.
      *
-     * By default, traverses from the current node (last traversal target, or start node).
-     * Use the `from` option to traverse from a different alias (fan-out pattern).
+     * Returns a `BatchableQuery` instead of executing immediately. Accepts
+     * the same temporal `options` as {@link EdgeCollection.findFrom}.
      *
-     * @param options.direction - Direction of traversal: "out" (default) or "in"
-     * @param options.expand - Ontology expansion mode for implying/inverse edges
-     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
+     * Batching these still issues one statement per call — it does not merge
+     * the reads, and whether they share a connection is up to the adapter. It
+     * is not a snapshot: PostgreSQL's default read-committed isolation lets a
+     * later read observe a commit the earlier ones did not. To read edges for
+     * many sources in one statement, traverse from them in a single query.
      */
-    optionalTraverse<EK extends keyof G["edges"] & string, EA extends string>(edgeKind: EK, edgeAlias: EA, options?: {
-        direction?: "out";
-        expand?: TraversalExpansion;
-        from?: keyof Aliases & string;
-    }): 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>;
+    batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
-     * String-keyed sibling of `optionalTraverse` for runtime-declared edge
-     * kinds. LEFT JOIN semantics — non-matching rows produce a null edge
-     * alias instead of dropping. Throws `KindNotFoundError` if the edge
-     * kind is not registered.
+     * Deferred variant of `findTo` for use with `store.batch()`.
+     *
+     * Returns a `BatchableQuery` instead of executing immediately. Accepts
+     * the same temporal `options` as {@link EdgeCollection.findTo}. Costs one
+     * statement per call, like {@link EdgeCollection.batchFindFrom}.
      */
-    optionalTraverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
-        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>;
+    batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
-     * Selects fields to return.
+     * Deferred variant of `findByEndpoints` for use with `store.batch()`.
+     *
+     * Returns a `BatchableQuery` that yields a 0-or-1 element array
+     * (matching `findByEndpoints`' at-most-one semantics). Costs one statement
+     * per call, like {@link EdgeCollection.batchFindFrom}.
      */
-    select<R>(selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
+    batchFindByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
+    /** Delete an edge (soft delete - sets deletedAt timestamp) */
+    delete: (id: EdgeId<E>) => Promise<void>;
     /**
-     * Selects fields including aggregates.
-     * Use with groupBy() for aggregate queries.
+     * Permanently delete an edge from the database.
      *
-     * @param fields - Object mapping output names to field refs or aggregate expressions
+     * Unlike `delete()` which performs a soft delete, this permanently
+     * removes the edge record.
+     *
+     * **Warning:** This operation is irreversible and should be used carefully.
+     * Consider using soft delete (`delete()`) for most use cases.
      */
-    aggregate<R extends Record<string, FieldRef | AggregateExpr>>(fields: R): ExecutableAggregateQuery<G, Aliases, R>;
+    hardDelete: (id: EdgeId<E>) => Promise<void>;
+    /** Find edges matching endpoint and pagination criteria */
+    find: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+        limit?: number;
+        offset?: number;
+    }>, temporal?: QueryOptions) => Promise<Edge<E, From, To>[]>;
+    /** Count edges matching criteria */
+    count: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+    }>, temporal?: QueryOptions) => Promise<number>;
     /**
-     * Orders results.
+     * Create multiple edges in a batch.
+     *
+     * More efficient than calling create() multiple times.
+     * Use `bulkInsert` for the dedicated fast path that skips returning results.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    orderBy<A extends (keyof Aliases | keyof EdgeAliases) & string>(alias: A, field: string, direction?: SortDirection): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkCreate: (items: readonly Readonly<{
+        from: NodeRef<From>;
+        to: NodeRef<To>;
+        props?: z.input<E["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Edge<E, From, To>[]>;
     /**
-     * Limits the number of results.
+     * Create or update multiple edges in a batch.
+     *
+     * 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.
      */
-    limit(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkUpsertById: (items: readonly Readonly<{
+        id: EdgeId<E>;
+        from: NodeRef<From>;
+        to: NodeRef<To>;
+        props?: z.input<E["schema"]>;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Edge<E, From, To>[]>;
     /**
-     * Offsets the results.
+     * Insert multiple edges without returning results.
+     *
+     * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`
+     * with `returnResults: false`, the intent is unambiguous: no results
+     * are returned and the operation is wrapped in a transaction.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    offset(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkInsert: (items: readonly Readonly<{
+        from: NodeRef<From>;
+        to: NodeRef<To>;
+        props?: z.input<E["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<void>;
     /**
-     * Groups results by the specified field.
-     * Use with aggregate functions like COUNT, SUM, AVG in select().
+     * Delete multiple edges by ID.
      *
-     * @param alias - The node alias to group by
-     * @param field - The field name to group by
+     * Atomic when the backend supports transactions. Silently ignores IDs
+     * that don't exist.
      */
-    groupBy<A extends keyof Aliases & string>(alias: A, field: string): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
     /**
-     * Groups results by the node ID.
-     * Use when you want to group by a complete node rather than a specific field.
+     * Find an edge by endpoints and optional property fields.
      *
-     * @param alias - The node alias to group by (uses the node's ID)
+     * Returns the first matching edge at the read coordinate, or undefined.
+     * Honors the temporal model like `findFrom` / `findTo`: by default
+     * (`current` mode) soft-deleted and out-of-window edges are excluded; under
+     * `includeTombstones` a soft-deleted edge can be returned.
+     *
+     * @param from - Source node
+     * @param to - Target node
+     * @param options - Match criteria (matchOn fields and property values)
+     * @param temporal - Temporal coordinate. With no `temporal`, the graph's
+     *   default `temporalMode` applies (so under the default `"current"` mode,
+     *   edges outside their validity window are excluded). Pass
+     *   `temporalMode` / `asOf` to read the edge as of another coordinate.
      */
-    groupByNode<A extends keyof Aliases & string>(alias: A): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
     /**
-     * Filters grouped results using aggregate conditions (HAVING clause).
-     * Use after groupBy() to filter based on aggregate values.
+     * Get an existing edge by endpoints and optional property fields, or create a new one.
      *
-     * @param predicate - A predicate expression to filter groups
+     * Matches edges of this kind between `(from, to)`. When `matchOn` specifies
+     * 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.
+     *
+     * @param from - Source node
+     * @param to - Target node
+     * @param props - Full properties for create, or merge source for update
+     * @param options - Match criteria and conflict resolution
      */
-    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    getOrCreateByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, props: z.input<E["schema"]>, options?: EdgeGetOrCreateByEndpointsOptions<E>) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>>;
     /**
-     * Sets fusion parameters for hybrid (vector + fulltext) queries.
-     *
-     * Applies only when the query contains both a `.similarTo()` and a
-     * `.$fulltext.matches()` predicate. Without this call, the default is
-     * RRF with k=60 and equal weights. A mismatch between `.fuseWith()`
-     * configuration and the predicates on the query is caught during
-     * compilation, not here.
+     * Batch version of getOrCreateByEndpoints.
      *
-     * @example
-     * ```typescript
-     * store.query()
-     *   .from("Document", "d")
-     *   .whereNode("d", d =>
-     *     d.$fulltext.matches("renewable energy", 50)
-     *       .and(d.embedding.similarTo(vec, 50))
-     *       .and(d.tenantId.eq(tenant))
-     *   )
-     *   .fuseWith({ k: 60, weights: { fulltext: 1.5 } })
-     *   .limit(10)
-     *   .execute();
-     * ```
+     * Results are returned in the same order as the input items.
+     * Atomic when the backend supports transactions.
      */
-    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkGetOrCreateByEndpoints: (items: readonly Readonly<{
+        from: NodeRef<From>;
+        to: NodeRef<To>;
+        props: z.input<E["schema"]>;
+        validFrom?: string;
+        validTo?: string;
+    }>[], options?: Pick<EdgeGetOrCreateByEndpointsOptions<E>, "matchOn" | "ifExists">) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>[]>;
+}>;
+/**
+ * Extract uniqueness constraint names from a NodeRegistration.
+ *
+ * - Returns `never` when no uniqueness constraints are configured.
+ * - Returns a literal union when names are inferred via `defineGraph` const params.
+ * - Falls back to `string` when names are widened/dynamic.
+ */
+type ConstraintNames<R extends NodeRegistration> = "unique" extends keyof R ? R["unique"] extends readonly {
+    readonly name: infer N;
+}[] ? N & string : string : never;
+/**
+ * Extract the union of 'from' node types from an EdgeRegistration.
+ */
+type EdgeFromTypes<R extends EdgeRegistration> = R["from"] extends readonly (infer N)[] ? N : never;
+/**
+ * Extract the union of 'to' node types from an EdgeRegistration.
+ */
+type EdgeToTypes<R extends EdgeRegistration> = R["to"] extends readonly (infer N)[] ? N : never;
+/**
+ * Create a type-safe EdgeCollection from an EdgeRegistration.
+ * Extracts the edge type and from/to node types automatically.
+ */
+type TypedEdgeCollection<R extends EdgeRegistration> = EdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
+/** Mapped type of all node collections for a graph. */
+type GraphNodeCollections<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]-?: NodeCollection<G["nodes"][K]["type"], ConstraintNames<G["nodes"][K]>>;
+};
+/** Mapped type of all edge collections for a graph. */
+type GraphEdgeCollections<G extends GraphDef> = {
+    [K in keyof G["edges"] & string]-?: TypedEdgeCollection<G["edges"][K]>;
+};
+/** Temporal-aware node reads — a {@link StoreView} pins these. */
+type NodeTemporalReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_TEMPORAL_READ_NAMES)[number]>;
+/**
+ * Current-state-only node reads (constraint / index lookups). No temporal
+ * axis, so a {@link StoreView} delegates them on a `current` pin and refuses
+ * them on a temporal pin.
+ */
+type NodeCurrentReads<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof CURRENT_ONLY_READ_NAMES)[number]>;
+/** Node writes — never available on a read-only {@link StoreView}. */
+type NodeWrites<N extends NodeType, CN extends string = string> = Pick<NodeCollection<N, CN>, (typeof NODE_WRITE_NAMES)[number]>;
+/** Temporal-aware edge reads — a {@link StoreView} pins these. */
+type EdgeTemporalReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_TEMPORAL_READ_NAMES)[number]>;
+/**
+ * Deferred edge reads for `store.batch()` — absent from a {@link StoreView},
+ * which has no batch context.
+ */
+type EdgeBatchReads<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_BATCH_READ_NAMES)[number]>;
+/** Edge writes — never available on a read-only {@link StoreView}. */
+type EdgeWrites<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_WRITE_NAMES)[number]>;
+/**
+ * The read-only node surface a {@link StoreView} exposes for one node kind.
+ * The temporal reads drop the per-call temporal argument — the pin owns the
+ * axis; the current reads ({@link NodeCurrentReads}) are exposed as-is
+ * (delegated on a `current` view, refused on a temporal pin). Writes live on
+ * the live `Store`. The conformance test asserts the temporal part equals the
+ * pinned form of {@link NodeTemporalReads}.
+ */
+type StoreViewNodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
+    /** Get a node by ID at the view's pinned coordinate. */
+    getById: (id: NodeId<N>) => Promise<Node<N> | undefined>;
+    /** Get multiple nodes by ID, preserving input order (undefined for missing). */
+    getByIds: (ids: readonly NodeId<N>[]) => Promise<readonly (Node<N> | undefined)[]>;
+    /** Find nodes matching criteria at the view's pinned coordinate. */
+    find: (filter?: Readonly<{
+        where?: (accessor: NodeAccessor<N>) => Predicate;
+        limit?: number;
+        offset?: number;
+    }>) => Promise<Node<N>[]>;
+    /** Count nodes at the view's pinned coordinate. */
+    count: () => Promise<number>;
+}> & NodeCurrentReads<N, CN>;
+/**
+ * The read-only edge surface a {@link StoreView} exposes for one edge
+ * kind, mirroring {@link StoreViewNodeCollection}. Every edge read —
+ * including `findByEndpoints` — honors the pin via the same temporal model,
+ * so (unlike nodes) there are no current-state-only edge reads.
+ */
+type StoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Readonly<{
+    /** Get an edge by ID at the view's pinned coordinate. */
+    getById: (id: EdgeId<E>) => Promise<Edge<E, From, To> | undefined>;
+    /** Get multiple edges by ID, preserving input order (undefined for missing). */
+    getByIds: (ids: readonly EdgeId<E>[]) => Promise<readonly (Edge<E, From, To> | undefined)[]>;
+    /** Find edges matching endpoint and pagination criteria. */
+    find: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+        limit?: number;
+        offset?: number;
+    }>) => Promise<Edge<E, From, To>[]>;
+    /** Count edges matching criteria at the view's pinned coordinate. */
+    count: (filter?: Readonly<{
+        from?: NodeRef<From>;
+        to?: NodeRef<To>;
+    }>) => Promise<number>;
+    /** Find edges from a specific node at the view's pinned coordinate. */
+    findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;
+    /** Find edges to a specific node at the view's pinned coordinate. */
+    findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;
+    /** Find the edges from a set of source nodes at the view's pinned coordinate. */
+    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindOptions) => Promise<readonly Edge<E, From, To>[][]>;
+    /** Find the edges into a set of target nodes at the view's pinned coordinate. */
+    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindOptions) => Promise<readonly Edge<E, From, To>[][]>;
+    /** Find the edge between two endpoints at the view's pinned coordinate. */
+    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>) => Promise<Edge<E, From, To> | undefined>;
+}>;
+/**
+ * Read-only view edge collection derived from an `EdgeRegistration`,
+ * extracting the edge type and from/to node types — the read-only
+ * counterpart of {@link TypedEdgeCollection}.
+ */
+type TypedStoreViewEdgeCollection<R extends EdgeRegistration> = StoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
+/** Mapped type of all read-only view node collections for a graph. */
+type StoreViewNodeCollections<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]-?: StoreViewNodeCollection<G["nodes"][K]["type"]>;
+};
+/** Mapped type of all read-only view edge collections for a graph. */
+type StoreViewEdgeCollections<G extends GraphDef> = {
+    [K in keyof G["edges"] & string]-?: TypedStoreViewEdgeCollection<G["edges"][K]>;
+};
+/** Options for one bounded, forward-only recorded-time collection scan. */
+type RecordedScanOptions = Readonly<{
+    /** Maximum entities to return. Defaults to 1,000 and cannot exceed 1,000. */
+    limit?: number;
+    /** Opaque cursor returned by the preceding page. */
+    after?: string;
+}>;
+/** One page from a deterministic recorded-time collection scan. */
+type RecordedScanPage<T> = Readonly<{
+    /** Entities ordered by canonical id ascending. */
+    data: readonly T[];
+    /** Cursor for the next page, or `undefined` when the scan is complete. */
+    nextCursor: string | undefined;
+    /** Whether another page exists after this one. */
+    hasNextPage: boolean;
+}>;
+/** Recorded-time reconstructing reads for one node kind. */
+type RecordedStoreViewNodeCollection<N extends NodeType> = Pick<StoreViewNodeCollection<N>, (typeof RECORDED_POINT_READ_NAMES)[number]> & Readonly<{
+    /** Scan one bounded page at the view's pinned coordinate. */
+    scan: (options?: RecordedScanOptions) => Promise<RecordedScanPage<Node<N>>>;
+}>;
+/** Recorded-time reconstructing reads for one edge kind. */
+type RecordedStoreViewEdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To extends NodeType = NodeType> = Pick<StoreViewEdgeCollection<E, From, To>, (typeof RECORDED_POINT_READ_NAMES)[number]> & Readonly<{
+    /** Scan one bounded page at the view's pinned coordinate. */
+    scan: (options?: RecordedScanOptions) => Promise<RecordedScanPage<Edge<E, From, To>>>;
+}>;
+/** Recorded-time edge collection derived from an `EdgeRegistration`. */
+type TypedRecordedStoreViewEdgeCollection<R extends EdgeRegistration> = RecordedStoreViewEdgeCollection<R["type"], EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType, EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType>;
+/** Mapped type of all recorded-time node reconstructing-read collections. */
+type RecordedStoreViewNodeCollections<G extends GraphDef> = {
+    [K in keyof G["nodes"] & string]-?: RecordedStoreViewNodeCollection<G["nodes"][K]["type"]>;
+};
+/** Mapped type of all recorded-time edge reconstructing-read collections. */
+type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
+    [K in keyof G["edges"] & string]-?: TypedRecordedStoreViewEdgeCollection<G["edges"][K]>;
+};
+/**
+ * Whether — and why — `tx.sql` can be used on a transaction context. A single
+ * required discriminant covering exactly the four states raw-SQL access can be
+ * in, so an adapter caller branches on capability instead of truthiness-testing
+ * `tx.sql`. The non-available variants omit `sql` entirely, so even reading the
+ * handle requires first narrowing `sqlAvailability` to `"available"`. The
+ * runtime object keeps a fail-loud getter under history / revision tracking for
+ * JavaScript and type-suppressed callers. See
+ * {@link AdapterTransactionContext} for the per-value semantics.
+ */
+type SqlAvailability = "available" | "history" | "revisionTracking" | "unavailable";
+type AdapterTransactionSqlAccess<TNativeTransaction> = Readonly<{
+    sql: TNativeTransaction;
+    sqlAvailability: "available";
+}> | Readonly<{
+    sqlAvailability: "history" | "revisionTracking";
+}> | Readonly<{
+    sqlAvailability: "unavailable";
+}>;
+declare const TRANSACTION_RUNTIME: unique symbol;
+type TransactionRuntime = Readonly<{
+    backend: TransactionBackend;
+    runNodeOperationHooks: <T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>) => Promise<T>;
+}>;
+/**
+ * The portable transaction context mirrors the Store's typed graph operations
+ * while exposing only a read-only backend projection bound to the transaction.
+ * Adapter-native handles are available only through
+ * {@link AdapterTransactionContext}; arbitrary backend writes are absent from
+ * every public transaction context. TypeGraph's non-enumerable symbol port is
+ * an unsupported implementation detail, not a JavaScript security boundary:
+ * reflective code can still discover symbol properties.
+ *
+ * @example
+ * ```typescript
+ * await store.transaction(async (tx) => {
+ *   const person = await tx.nodes.Person.create({ name: "Alice" });
+ *   const company = await tx.nodes.Company.create({ name: "Acme" });
+ *   await tx.edges.worksAt.create(person, company, { role: "Engineer" });
+ * });
+ * ```
+ */
+type TransactionCollections<G extends GraphDef> = Readonly<{
+    [TRANSACTION_RUNTIME]: TransactionRuntime;
+    nodes: GraphNodeCollections<G>;
+    edges: GraphEdgeCollections<G>;
+    /** Read-only backend projection bound to the same graph transaction. */
+    backend: TransactionReadBackend;
     /**
-     * Applies a query fragment to transform this builder.
-     *
-     * Fragments are reusable query transformations that can add predicates,
-     * traversals, ordering, and other query operations. Use this for
-     * composing complex queries from simpler, reusable parts.
-     *
-     * @example
-     * ```typescript
-     * // Define a reusable fragment
-     * const activeUsers = createFragment<MyGraph>()((q) =>
-     *   q.whereNode("u", ({ status }) => status.eq("active"))
-     * );
-     *
-     * // Apply the fragment
-     * const results = await query()
-     *   .from("User", "u")
-     *   .pipe(activeUsers)
-     *   .select((ctx) => ctx.u)
-     *   .execute();
-     * ```
-     *
-     * @param fragment - A function that transforms the builder
-     * @returns The transformed builder
+     * Runtime string-keyed node collection access, mirroring
+     * `Store.getNodeCollection`. Returns `undefined` when `kind` is not
+     * registered in this graph.
      */
-    pipe<OutAliases extends AliasMap, OutEdgeAliases extends EdgeAliasMap = EdgeAliases, OutRecAliases extends RecursiveAliasMap = RecursiveAliases>(fragment: (builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>): QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecAliases, CoordinateState>;
-}
-
+    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
+}>;
 /**
- * Fluent query builder for TypeGraph.
+ * A portable transaction context containing only TypeGraph-owned graph
+ * operations. Managed Stores use this surface so adapter-native handles never
+ * enter their public contract.
+ */
+type TransactionContext<G extends GraphDef> = TransactionCollections<G>;
+/**
+ * A transaction context exposed by an {@link AdapterStore}. In addition to the
+ * portable graph collections, it carries the adapter-native handle when that
+ * capability is available. The TypeGraph backend remains the same runtime
+ * read projection as the portable context; adapter-native writes intentionally
+ * go through `sql`, making that escape hatch explicit.
+ */
+type AdapterTransactionContext<G extends GraphDef, TNativeTransaction> = TransactionCollections<G> & AdapterTransactionSqlAccess<TNativeTransaction>;
+/**
+ * Scoped write measurement, available only on the receipt-enabled transaction
+ * contexts (`transactionWithReceipt`, `withRecordedTransaction`). Runs `fn`,
+ * passing it a **scoped context** — a second view over the same transaction — and
+ * returns a {@link TransactionOutcome} whose receipt counts exactly the writes
+ * made *through that scoped context* (`scoped.nodes` / `scoped.edges`).
  *
- * Provides a type-safe, chainable API for building queries.
- * Each method returns a new builder instance with expanded type information.
+ * Attribution is by **which context you write through**, not by timing. A write
+ * through the scoped context counts in both the scope and the outer receipt (it
+ * happened in the transaction); a write through the outer `tx` during the scope
+ * counts only in the outer receipt. This makes overlapping and concurrent
+ * measures safe by construction — two scopes running under `Promise.all`, each
+ * writing through its own scoped context, never cross-count. Nesting composes:
+ * `scoped.measure(...)` opens a child scope that counts in itself, every
+ * ancestor scope, and the outer receipt.
  *
- * This module re-exports from the builder submodules and provides the
- * createQueryBuilder factory function.
+ * Counts otherwise inherit {@link TransactionReceipt} (bulk by input length, a
+ * rejected write counts 0). The returned receipt's `recorded` is **always
+ * `undefined`**: the recorded commit instant is a per-transaction flush concern,
+ * unknowable mid-transaction.
  */
-
-type InitialQueryBuilder<G extends GraphDef, CoordinateState extends QueryCoordinateState = "open"> = QueryBuilder<G, EmptyAliasMap, EmptyEdgeAliasMap, EmptyRecursiveAliasMap, CoordinateState>;
-declare function createQueryBuilder<G extends GraphDef>(graphId: string, registry: KindRegistry, options?: CreateQueryBuilderOptions): InitialQueryBuilder<G>;
+type ScopedMeasure<Context> = <T>(fn: (scoped: Context) => Promise<T>) => Promise<TransactionOutcome<T>>;
+/**
+ * A {@link TransactionContext} that also exposes {@link ScopedMeasure}. Only the
+ * receipt-enabled entry points (`transactionWithReceipt`,
+ * `withRecordedTransaction`) hand a callback this type; plain `transaction()`
+ * contexts have no recorder and therefore no `measure`, keeping that path
+ * zero-overhead. Assignable to {@link TransactionContext}, so a projector helper
+ * typed `(tx: TransactionContext<G>) => ...` accepts a measurable context. The
+ * scoped context handed to `measure` is itself measurable, so scopes nest.
+ */
+type MeasurableTransactionContext<G extends GraphDef> = TransactionContext<G> & Readonly<{
+    measure: ScopedMeasure<MeasurableTransactionContext<G>>;
+}>;
+/** Receipt-enabled transaction context for an {@link AdapterStore}. */
+type MeasurableAdapterTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterTransactionContext<G, TNativeTransaction> & Readonly<{
+    measure: ScopedMeasure<MeasurableAdapterTransactionContext<G, TNativeTransaction>>;
+}>;
+/**
+ * Replace branded `NodeId` / `EdgeId` with plain `string` in each
+ * method's parameter list. Return types are preserved unchanged.
+ *
+ * Handles three shapes:
+ * 1. Direct branded ID parameter → `string`
+ * 2. `readonly NodeId[]` / `readonly EdgeId[]` → `readonly string[]`
+ * 3. Branded IDs nested one level inside bulk-item object arrays
+ */
+type WidenBrandedIds<T> = {
+    readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: {
+        [P in keyof A]: UnbrandParam<A[P]>;
+    }) => R : T[K];
+};
+/** Replace a branded ID with `string`, recursing one level into arrays. */
+type UnbrandParam<T> = T extends NodeId<NodeType> ? string : T extends EdgeId<AnyEdgeType> ? string : T extends readonly NodeId<NodeType>[] ? readonly string[] : T extends readonly EdgeId<AnyEdgeType>[] ? readonly string[] : T extends readonly (infer Item extends Record<string, unknown>)[] ? readonly UnbrandRecord<Item>[] : T;
+/** Replace branded ID values in object properties (does not recurse into nested structures). */
+type UnbrandRecord<T extends Record<string, unknown>> = {
+    readonly [K in keyof T]: T[K] extends NodeId<NodeType> ? string : T[K] extends EdgeId<AnyEdgeType> ? string : T[K];
+};
+/**
+ * A node collection with widened generics for runtime string-keyed access.
+ *
+ * This is the return type of `store.getNodeCollection(kind)`. It exposes
+ * the full `NodeCollection` API but with `NodeType` and `string` constraint
+ * names instead of the specific generic parameters, since the concrete type
+ * is not known at compile time.
+ *
+ * ID parameters accept plain `string` instead of branded `NodeId<N>`, since
+ * the dynamic path typically receives IDs from edge metadata, snapshots,
+ * or external input where the brand is not available.
+ */
+type DynamicNodeCollection = WidenBrandedIds<NodeCollection<NodeType, string>>;
+/**
+ * An edge collection with widened generics for runtime string-keyed access.
+ *
+ * This is the return type of `store.getEdgeCollection(kind)`. It exposes
+ * the full `EdgeCollection` API but with `NodeType` endpoint types, since
+ * the concrete from/to types are not known at compile time.
+ *
+ * ID parameters accept plain `string` instead of branded `EdgeId<E>`, since
+ * the dynamic path typically receives IDs from edge metadata, snapshots,
+ * or external input where the brand is not available.
+ */
+type DynamicEdgeCollection = WidenBrandedIds<EdgeCollection<AnyEdgeType, NodeType, NodeType>>;
+/**
+ * A type-level projection of a store's surface onto a subset of its
+ * node and edge collections.
+ *
+ * Node collections are projected with constraint names erased (`never`),
+ * so constraint-based methods like `findByConstraint` become uncallable.
+ * This is intentional: unique constraints are graph-registration-level
+ * details that differ between graphs sharing the same node types.
+ *
+ * @example
+ * ```typescript
+ * type CoreStore = StoreProjection<
+ *   typeof myGraph,
+ *   "Document" | "Chunk",
+ *   "hasChunk"
+ * >;
+ *
+ * async function ingestChunk(
+ *   store: CoreStore,
+ *   document: Node<typeof Document>,
+ *   text: string,
+ * ) {
+ *   const chunk = await store.nodes.Chunk.create({ text });
+ *   await store.edges.hasChunk.create(document, chunk);
+ *   return chunk;
+ * }
+ * ```
+ *
+ * Both `Store<G>` and `TransactionContext<G>` are structurally assignable
+ * to a `StoreProjection` whose keys are a subset of `G`.
+ */
+type StoreProjection<G extends GraphDef, N extends keyof G["nodes"] & string = never, E extends keyof G["edges"] & string = never> = Readonly<{
+    nodes: {
+        [K in N]-?: NodeCollection<G["nodes"][K]["type"], never>;
+    };
+    edges: Pick<GraphEdgeCollections<G>, E>;
+}>;
 
 /**
  * Shared types for Tier 1 graph algorithms.
@@ -3574,9 +3754,9 @@ declare class StoreSearch<G extends GraphDef> {
  * 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", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy"];
+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" | "transaction" | "trustedImport";
+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;
 
@@ -3662,8 +3842,8 @@ type UniqueIntrospection = Readonly<{
  * budget); the data deletion happens here, scoped per-deployment via
  * the `typegraph_kind_removals` status table. Splitting the verbs
  * mirrors how `materializeIndexes` complements `evolve`: schema
- * commits are atomic and fast, data work is bounded by row count and
- * deferrable / parallelizable.
+ * 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<{
@@ -3672,11 +3852,40 @@ type MaterializeRemovalsOptions = Readonly<{
     /** 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" | "failed";
-    error?: Error;
+    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
@@ -4001,12 +4210,15 @@ type StoreCore<G extends GraphDef> = Readonly<{
         BatchableQuery<unknown>,
         ...BatchableQuery<unknown>[]
     ]>(...queries: Queries) => Promise<BatchResults<Queries>>;
+    bulkFindEdgesFrom: <const K extends EdgeKinds<G>>(params: BulkFindEdgesFromParams<G, K>, options?: EdgeBulkFindEndpointOptions) => Promise<readonly BulkFindEdgesFromResult<G, K>[]>;
     subgraph: <const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: SubgraphOptions<G, EK, NK, P>) => Promise<SubgraphResult<G, NK, EK, P>>;
     clear: () => Promise<void>;
     refreshStatistics: () => Promise<void>;
     materializeIndexes: (options?: MaterializeIndexesOptions) => Promise<MaterializeIndexesResult>;
     materializeSystemIndexes: (options?: MaterializeSystemIndexesOptions) => Promise<MaterializeIndexesResult>;
     reembedVectorField: (kind: string, fieldPath: string, options?: ReembedVectorFieldOptions) => Promise<ReembedVectorFieldResult>;
+    verifyContributions: () => Promise<readonly ContributionDiagnostic[]>;
+    repairContributions: () => Promise<ContributionRepairResult>;
     materializeRemovals: (options?: MaterializeRemovalsOptions) => Promise<MaterializeRemovalsResult>;
     close: () => Promise<void>;
 }>;
@@ -4185,6 +4397,10 @@ declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(grap
  * - Initializes the schema on first run (version 1)
  * - Auto-migrates safe changes (additive changes)
  * - Throws MigrationError for breaking changes
+ * - Fences managed writes against concurrent schema-version commits; a stale Store
+ *   fails before writing instead of landing rows against a replaced schema
+ *   (official transactional backends only; unsupported custom backends fail
+ *   closed on their first managed write)
  *
  * @param graph - The graph definition
  * @param backend - The database backend
@@ -4245,6 +4461,11 @@ declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransac
  *   initialized, or `StoreNotInitializedError` when the schema is
  *   current but the runtime-contribution markers are missing/stale.
  *   The runtime can use a least-privilege, DML-only database role.
+ *   Managed writes are fenced against concurrent schema-version commits just like
+ *   `createStoreWithSchema`; a stale verified Store fails before writing.
+ *   Runtime backends must support transactions and the schema-write fence;
+ *   unsupported custom or HTTP backends attach for reads but fail closed on a
+ *   managed write.
  * - **`createStore(graph, backend)`** is the same zero-DDL attach
  *   *without* the verification gate — fastest, but schema drift goes
  *   undetected until a hot-path operation trips.
@@ -4444,6 +4665,8 @@ declare class StoreView<G extends GraphDef> extends CoordinatePinnedView<G> {
     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`,
@@ -4472,4 +4695,4 @@ declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView
     get edges(): RecordedStoreViewEdgeCollections<G>;
 }
 
-export { ExecutableAggregateQuery as $, type AliasMap as A, type BaseStoreOptions as B, type ConstraintNames as C, type DegreeOptions as D, type EdgeAliasMap as E, type DynamicNodeType as F, type DynamicSelectableEdge as G, type HistoryStoreOptions as H, type DynamicSelectableNode as I, type Edge as J, type EdgeAccessor as K, type LiveStoreOptions as L, type EdgeBatchReads as M, type EdgeCollection as N, type EdgeFindByEndpointsOptions as O, type EdgeGetOrCreateByEndpointsOptions as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeGetOrCreateByEndpointsResult as V, type EdgeIntrospection as W, type EdgeTemporalReads as X, type EdgeWrites as Y, type EmptyAliasMap as Z, type EmptyEdgeAliasMap as _, type Store as a, type RecordedStoreViewEdgeCollections as a$, ExecutableQuery as a0, type FieldAccessor as a1, type FulltextSearchHit as a2, type FulltextSearchOptions as a3, type GetOrCreateAction as a4, type GraphAlgorithms as a5, type GraphEdgeCollections as a6, type GraphNodeCollections as a7, type HistoryStoreBackend as a8, type HookContext as a9, type NodeRef as aA, type NodeTemporalReads as aB, type NodeWrites as aC, type OntologyIntrospection as aD, type OperationHookContext as aE, type PageRankOptions as aF, type PageRankScore as aG, type PaginateOptions as aH, type PaginatedResult as aI, type PathNode as aJ, type PersonalizedPageRankOptions as aK, type PersonalizedPageRankSeed as aL, type Predicate as aM, PreparedQuery as aN, type PropsAccessor as aO, type QueryHookContext as aP, type QueryOptions as aQ, type ReachableNode as aR, type ReachableOptions as aS, type RebuildFulltextOptions as aT, type RebuildFulltextResult as aU, type ReclaimedVectorFieldEntry as aV, type ReconciledSchema as aW, type RecordedScanOptions as aX, type RecordedScanPage as aY, RecordedStoreView as aZ, type RecordedStoreViewEdgeCollection as a_, type HybridFulltextOptions as aa, type HybridSearchHit as ab, type HybridSearchOptions as ac, type HybridVectorOptions as ad, type IfExistsMode as ae, type InitialQueryBuilder as af, type KindIntrospection as ag, type LabelPropagationMembership as ah, type LabelPropagationOptions as ai, type MaterializeRemovalsEntry as aj, type MaterializeRemovalsOptions as ak, type MaterializeRemovalsResult as al, type MeasurableAdapterHistoryTransactionContext as am, type MeasurableAdapterTransactionContext as an, type MeasurableTransactionContext as ao, type NeighborsOptions as ap, type NoRecordedCoordinate as aq, type Node as ar, type NodeAccessor as as, type NodeAlias as at, type NodeBulkFindByIndexOptions as au, type NodeCollection as av, type NodeCurrentReads as aw, type NodeGetOrCreateByConstraintOptions as ax, type NodeGetOrCreateByConstraintResult as ay, type NodeIdentifier as az, type HistoryStore as b, createAdapterStoreWithSchema as b$, type RecordedStoreViewNodeCollection as b0, type RecordedStoreViewNodeCollections as b1, type RecursiveTraversalOptions as b2, type ReembedFunction as b3, type ReembedVectorFieldOptions as b4, type ReembedVectorFieldResult as b5, type SchemaIntrospection as b6, type ScopedMeasure as b7, type SearchScopeOptions as b8, type SelectContext as b9, type StoreViewWeightedShortestPathOptions as bA, type StreamOptions as bB, type SubgraphEdgeResult as bC, type SubgraphNodeResult as bD, type SubgraphOptions as bE, type SubgraphResult as bF, type SubsetEdge as bG, type SubsetNode as bH, type TemporalAlgorithmOptions as bI, type TransactionContext as bJ, type TransactionOutcome as bK, type TransactionReceipt as bL, type TraversalDirection as bM, type TypedEdgeCollection as bN, type TypedRecordedStoreViewEdgeCollection as bO, type TypedStoreViewEdgeCollection as bP, UnionableQuery as bQ, type UniqueIntrospection as bR, type UpdateEdgeInput as bS, type UpdateNodeInput as bT, type VectorSearchHit as bU, type VectorSearchOptions as bV, type WeaklyConnectedComponentMembership as bW, type WeaklyConnectedComponentsOptions as bX, type WeightedShortestPathOptions as bY, type WeightedShortestPathResult as bZ, createAdapterStore as b_, type SelectableEdge as ba, type SelectableNode as bb, type ShortestPathOptions as bc, type ShortestPathResult as bd, type SqlAvailability as be, type StoreHooks as bf, type StoreProjection as bg, type StoreRef as bh, StoreSearch as bi, StoreView as bj, type StoreViewCanReachOptions as bk, type StoreViewCoordinate as bl, type StoreViewDegreeOptions as bm, type StoreViewEdgeCollection as bn, type StoreViewEdgeCollections as bo, type StoreViewGraphAlgorithms as bp, type StoreViewLabelPropagationOptions as bq, type StoreViewNeighborsOptions as br, type StoreViewNodeCollection as bs, type StoreViewNodeCollections as bt, type StoreViewPageRankOptions as bu, type StoreViewPersonalizedPageRankOptions as bv, type StoreViewReachableOptions as bw, type StoreViewShortestPathOptions as bx, type StoreViewSubgraphOptions as by, type StoreViewWeaklyConnectedComponentsOptions as bz, type RecordedReadStore as c, createQueryBuilder as c0, createStore as c1, createStoreWithSchema as c2, createVerifiedAdapterStore as c3, createVerifiedStore as c4, defineSubgraphProject as c5, exists as c6, fieldRef as c7, inSubquery as c8, isParameterRef as c9, notExists as ca, notInSubquery as cb, param as cc, 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 CreateEdgeInput as s, type CreateNodeInput as t, type DynamicEdgeAccessor as u, type DynamicEdgeCollection as v, type DynamicEdgeType as w, type DynamicFieldBuilder as x, type DynamicNodeAccessor as y, type DynamicNodeCollection as z };
+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 };