@nicia-ai/typegraph 0.44.0 → 0.45.0

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

@@ -1,10 +1,10 @@
-import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-DVF-oN1i.cjs';
-import { R as RecordedInstant, d as ReadCoordinate } from './temporal-BCORwUau.cjs';
-import { c5 as ValueType, c6 as PredicateExpression, az as FulltextQueryMode, c7 as VectorMetricType, Q as QueryAst, J as JsonPointer, a2 as FieldRef, a$ as ParameterRef, b as NodeType, c as AnyEdgeType, a0 as EdgeType, bx as TraversalExpansion, x as GraphBackend, S as SqlDialect, bo as SqlSchema, c8 as Traversal, c9 as NodePredicate, ca as ProjectedField, a_ as OrderSpec, cb as AggregateOrderSpec, T as TemporalMode, cc as GroupBySpec, aH as HybridFusionOptions, aL as JsonPointerInput, cd as RecursiveCyclePolicy, a5 as TraversalDirection$1, E as EdgeRegistration, aY as NodeId, bu as TransactionBackend, K as KindEntity, at as ExternalRecordedReadSource, ce as NodeRow, ap as EdgeId, cf as EdgeRow, N as NodeRegistration, bw as TransactionReadBackend, a1 as AggregateExpr, bh as SortDirection, ai as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, cg as VectorSlotMap, ch as RecordedReadBinding, ci as SelectiveField, cj as ComposableQuery, ck as SetOperationType, cl as SetOperation, cm as VectorMetric, aQ as KindAnnotations, Y as JsonSchema, bC as UniquenessScope, ad as Collation, ac as Cardinality, as as EndpointExistence, G as GraphExtension, B as BackendCapabilities, C as ContributionDiagnostic, bv as TransactionOptions, A as AdapterBackend } from './types-Cjvkj0jA.cjs';
-import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-Cn0NFIhN.cjs';
+import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-alREY2wj.cjs';
+import { R as RecordedInstant, d as ReadCoordinate } from './temporal-BNbjXqer.cjs';
+import { cb as ValueType, cc as PredicateExpression, aC as FulltextQueryMode, cd as VectorMetricType, Q as QueryAst, J as JsonPointer, a4 as FieldRef, b3 as ParameterRef, d as NodeType, e as AnyEdgeType, a2 as EdgeType, bB as TraversalExpansion, z as GraphBackend, S as SqlDialect, bs as SqlSchema, ce as Traversal, cf as NodePredicate, cg as ProjectedField, b2 as OrderSpec, ch as AggregateOrderSpec, T as TemporalMode, ci as GroupBySpec, aL as HybridFusionOptions, aP as JsonPointerInput, cj as RecursiveCyclePolicy, a7 as TraversalDirection$1, E as EdgeRegistration, b0 as NodeId, by as TransactionBackend, a3 as AggregateExpr, bl as SortDirection, ak as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, ck as VectorSlotMap, cl as RecordedReadBinding, cm as SelectiveField, cn as ComposableQuery, co as SetOperationType, cp as SetOperation, K as KindEntity, av as ExternalRecordedReadSource, cq as NodeRow, ar as EdgeId, cr as EdgeRow, N as NodeRegistration, bA as TransactionReadBackend, cs as VectorMetric, aU as KindAnnotations, _ as JsonSchema, bG as UniquenessScope, af as Collation, ae as Cardinality, au as EndpointExistence, G as GraphExtension, B as BackendCapabilities, C as ContributionDiagnostic, c as ContributionRepairResult, bz as TransactionOptions, A as AdapterBackend } from './types-Ch9a0Dx6.cjs';
+import { K as KindRegistry, S as SchemaManagerOptions, b as SchemaValidationResult } from './manager-KS7CGQQT.cjs';
 import { z } from 'zod';
-import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-BT7j9_IK.cjs';
-import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-DVRhd5h4.cjs';
+import { S as SearchableMetadata, c as EmbeddingValue } from './searchable-CIZL8Hyw.cjs';
+import { S as SchemaDiff, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-OHRWypW6.cjs';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -765,2162 +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", "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"];
-
-/**
- * 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[]>;
+}
+
 /**
- * Context for one SQL statement a query builder submits to the backend.
- *
- * 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.
+ * UnionableQuery - A query formed by combining multiple queries with set operations.
  */
-type QueryHookContext = HookContext & Readonly<{
-    /** The SQL statement 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 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;
+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.
+     * 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;
+    /**
+     * Compiles the query and returns the SQL text and parameters.
      *
-     * Writes performed directly through a backend — including raw graph-table
-     * writes through `tx.sql` — bypass the anchor and are outside the
-     * revision-tracking contract.
+     * 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.
      */
-    revisionTracking?: boolean;
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
     /**
-     * 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.
+     * Compiles the set operation to SQL.
      */
-    autoRefreshStatistics?: false | number;
+    compile(): CompiledSelectSql;
     /**
-     * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose
-     * validated props are value-identical to the existing live row. Default
-     * off.
+     * Executes the combined query.
+     */
+    execute(): Promise<readonly R[]>;
+    /**
+     * Executes the combined query against a provided backend.
      *
-     * 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.
+     * 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}.
- */
-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.
- */
-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;
-    }>;
-    /**
-     * 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.
-     */
-    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.
+ * ExecutableQuery - A query that can be executed, paginated, or streamed.
  */
-type NodeBulkFindByIndexOptions = Readonly<{
-    /**
-     * 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.
-     */
-    limitPerInput?: number;
-}>;
+
 /**
- * Per-endpoint fan-out cap shared by the live and view forms of the edge
- * bulk endpoint reads.
+ * A query that can be executed.
  */
-type EdgeBulkFindOptions = Readonly<{
+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);
     /**
-     * Maximum number of edges returned for each input endpoint. When omitted,
-     * every input's edge set is unbounded. Must be a positive integer.
-     *
-     * The cap keeps each input's leading edges under the same ordering
-     * `findFrom` / `findTo` return, so it bounds fan-out without reordering
-     * anything.
+     * Builds the query AST (memoized — the instance is immutable).
      */
-    limitPerInput?: number;
-}>;
-/**
- * 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;
-/**
- * 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<{
+    toAst(): QueryAst;
     /**
-     * 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).
+     * Orders 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<{
+    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 key alongside the (from, to) endpoints.
-     * Default: `[]` — match on endpoints only.
+     * Limits the number of results.
      */
-    matchOn?: readonly (keyof z.input<E["schema"]>)[];
-    /** Existing record behavior. Default: "return" */
-    ifExists?: IfExistsMode;
+    limit(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.
+     * Offsets the results.
      */
-    validFrom?: string;
+    offset(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
     /**
-     * Valid-time end for a created, updated, or resurrected edge. Ignored when
-     * the operation returns an existing edge without writing.
-     */
-    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<{
-    /**
-     * Create a new node.
+     * Applies a query fragment to transform this executable query.
      *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
-     */
-    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>;
-    /**
-     * Permanently delete a node from the database.
+     * Useful for applying post-select transformations like ordering,
+     * limits, and offsets from reusable fragments.
      *
-     * Unlike `delete()` which performs a soft delete, this permanently
-     * removes the node and its associated data (uniqueness entries, embeddings).
+     * @example
+     * ```typescript
+     * const paginated = (q) => q.orderBy("u", "createdAt", "desc").limit(10);
      *
-     * **Warning:** This operation is irreversible and should be used carefully.
-     * Consider using soft delete (`delete()`) for most use cases.
+     * const results = await query()
+     *   .from("User", "u")
+     *   .select((ctx) => ctx.u)
+     *   .pipe(paginated)
+     *   .execute();
+     * ```
      *
-     * @throws Error if edges are still connected to this node (delete edges first)
+     * @param fragment - A function that transforms the executable query
+     * @returns The transformed executable query
      */
-    hardDelete: (id: NodeId<N>) => Promise<void>;
+    pipe<NewR = R>(fragment: (query: ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>) => ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>;
     /**
-     * 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 UNION (removes duplicates).
      */
-    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>;
+    union(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.
-     *
-     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     * Combines this query with another using UNION ALL (keeps duplicates).
      */
-    createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    unionAll(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * 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.
-     *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * Combines this query with another using INTERSECT.
      */
-    upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    intersect(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * 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.
-     *
-     * `validFrom` only applies on the create branch, defaulting to the
-     * operation's creation timestamp when omitted; it has no effect on update.
+     * Combines this query with another using EXCEPT.
      */
-    upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
-        validFrom?: string;
-        validTo?: string;
-    }>) => Promise<Node<N>>;
+    except(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
     /**
-     * Create multiple nodes in a batch.
-     *
-     * More efficient than calling create() multiple times.
-     * Use `bulkInsert` for the dedicated fast path that skips returning results.
+     * 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.
      */
-    bulkCreate: (items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Node<N>[]>;
+    toSQL(): Readonly<{
+        sql: string;
+        params: readonly unknown[];
+    }>;
     /**
-     * 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.
+     * 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.
      */
-    bulkUpsertById: (items: readonly Readonly<{
-        id: string;
-        props: z.input<N["schema"]>;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<Node<N>[]>;
+    compile(): CompiledSelectSql;
     /**
-     * Insert multiple nodes without returning results.
+     * 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).
      *
-     * 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.
+     * Use `param("name")` in predicates to create parameterized slots,
+     * then pass values via `prepared.execute({ name: "value" })`.
      *
-     * `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.
+     * @example
+     * ```typescript
+     * import { param } from "@nicia-ai/typegraph";
      *
-     * 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.
+     * const prepared = store.query()
+     *   .from("Person", "p")
+     *   .whereNode("p", (p) => p.name.eq(param("name")))
+     *   .select((ctx) => ctx.p)
+     *   .prepare();
      *
-     * 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.
+     * const alice = await prepared.execute({ name: "Alice" });
+     * const bob = await prepared.execute({ name: "Bob" });
+     * ```
      *
-     * @param constraintName - Name of the uniqueness constraint to match on
-     * @param props - Properties to compute the constraint key from
+     * @throws Error if no backend is configured
      */
-    findByConstraint: (constraintName: CN, props: z.input<N["schema"]>) => Promise<Node<N> | undefined>;
+    prepare(): PreparedQuery<R>;
     /**
-     * Batch version of findByConstraint.
+     * Executes the query and returns typed results.
      *
-     * Results are returned in the same order as the input items.
-     * Returns undefined for entries that don't match.
+     * 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.
+     *
+     * @throws Error if no backend is configured
      */
-    bulkFindByConstraint: (constraintName: CN, items: readonly Readonly<{
-        props: z.input<N["schema"]>;
-    }>[]) => Promise<(Node<N> | undefined)[]>;
+    execute(): 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 the query against a provided backend.
      *
-     * 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.
+     * 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.
      *
-     * @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
+     * 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.
      */
-    bulkFindByIndex: (indexName: string, items: readonly Readonly<{
-        props: Partial<z.input<N["schema"]>>;
-    }>[], options?: NodeBulkFindByIndexOptions) => Promise<readonly Node<N>[][]>;
+    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
     /**
-     * Get an existing node by uniqueness constraint, or create a new one.
+     * Executes a paginated query using cursor-based keyset pagination.
      *
-     * 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.
+     * Cursor pagination is efficient for large datasets as it avoids OFFSET.
+     * Requires ORDER BY to be specified for deterministic results.
      *
-     * @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")
+     * @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
      */
-    getOrCreateByConstraint: (constraintName: CN, props: z.input<N["schema"]>, options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>>;
+    paginate(options: PaginateOptions): Promise<PaginatedResult<R>>;
     /**
-     * Batch version of getOrCreateByConstraint.
+     * Returns an async iterator that streams results in batches.
      *
-     * Results are returned in the same order as the input items.
-     * Atomic when the backend supports transactions.
+     * Uses cursor pagination internally for efficient memory usage.
+     * Requires ORDER BY to be specified for deterministic results.
+     *
+     * @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
- *
- * This provides compile-time checking that edge endpoints match the
- * allowed node kinds defined in the edge registration.
+ * TraversalBuilder - Intermediate builder for edge traversals.
  */
-type NodeRef<N extends NodeType = NodeType> = Node<N> | Readonly<{
-    kind: N["kind"];
-    id: string;
-}>;
+
 /**
- * Options for creating an edge.
+ * 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 EdgeCreateOptions = Readonly<{
-    id?: string;
-    validFrom?: string;
-    validTo?: string;
-}>;
+type EdgeTypeForKey<G extends GraphDef, EK> = string extends EK ? DynamicEdgeType : EK extends keyof G["edges"] & string ? G["edges"][EK]["type"] : DynamicEdgeType;
 /**
- * Arguments for edge creation, with props optional when schema allows empty object.
- *
- * Uses `{}` to check if an empty object literal satisfies the schema input type.
+ * State for variable-length traversal configuration.
  */
-type EdgeCreateArguments<E extends AnyEdgeType> = {} extends z.input<E["schema"]> ? [
-    props?: z.input<E["schema"]>,
-    options?: EdgeCreateOptions
-] : [props: z.input<E["schema"]>, options?: EdgeCreateOptions];
+interface VariableLengthState {
+    enabled: boolean;
+    minDepth: number;
+    maxDepth: number;
+    cyclePolicy: RecursiveCyclePolicy;
+    pathEnabled: boolean;
+    pathAlias?: string;
+    depthEnabled: boolean;
+    depthAlias?: string;
+}
 /**
- * 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);
+ * Intermediate builder for traversal operations.
  *
- * // 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>;
     /**
-     * Find the edges from a SET of source nodes in one read.
-     *
-     * `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.
-     *
-     * 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.
-     *
-     * 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 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
+     * String-keyed sibling of `to` for runtime-declared target kinds.
+     * Throws `KindNotFoundError` if the kind is not registered.
      */
-    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly 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);
     /**
-     * Find the edges into a SET of target nodes in one read.
+     * Starts a query from a node kind.
      *
-     * Mirrors {@link EdgeCollection.bulkFindFrom} on the `to` endpoint.
+     * @param kind - The node kind to start from
+     * @param alias - A unique alias for this node (compile-time error if duplicate)
      */
-    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly 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 `findFrom` for use with `store.batch()`.
-     *
-     * Returns a `BatchableQuery` instead of executing immediately. Accepts
-     * the same temporal `options` as {@link EdgeCollection.findFrom}.
-     *
-     * 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.
+     * 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.
      */
-    batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
+    fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: boolean;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * 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}.
+     * Adds a WHERE clause for a node.
      */
-    batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
+    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Deferred variant of `findByEndpoints` for use with `store.batch()`.
+     * Adds a WHERE clause for an edge.
      *
-     * 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}.
+     * @param alias - The edge alias to filter on
+     * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    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>;
+    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Permanently delete an edge from the database.
+     * Traverses an edge to another node (outgoing direction).
      *
-     * Unlike `delete()` which performs a soft delete, this permanently
-     * removes the edge record.
+     * 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).
      *
-     * **Warning:** This operation is irreversible and should be used carefully.
-     * Consider using soft delete (`delete()`) for most use cases.
+     * @param options.expand - Ontology expansion mode for implying/inverse edges
+     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
      */
-    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>;
+    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>;
     /**
-     * Create multiple edges in a batch.
+     * Traverses an edge to another node (incoming direction).
      *
-     * More efficient than calling create() multiple times.
-     * Use `bulkInsert` for the dedicated fast path that skips returning results.
+     * 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)
      */
-    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>[]>;
+    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>;
     /**
-     * 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.
+     * String-keyed sibling of `traverse` for runtime-declared edge kinds.
+     * Throws `KindNotFoundError` if the edge kind is not registered.
      */
-    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>[]>;
+    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>;
     /**
-     * Insert multiple edges without returning results.
+     * Optionally traverses an edge to another node (LEFT JOIN semantics).
+     * If no matching edge/node exists, the result will include null values.
      *
-     * 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 - 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)
      */
-    bulkInsert: (items: readonly Readonly<{
-        from: NodeRef<From>;
-        to: NodeRef<To>;
-        props?: z.input<E["schema"]>;
-        id?: string;
-        validFrom?: string;
-        validTo?: string;
-    }>[]) => Promise<void>;
+    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>;
     /**
-     * Delete multiple edges by ID.
+     * 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.
      *
-     * Atomic when the backend supports transactions. Silently ignores IDs
-     * that don't exist.
+     * @param fields - Object mapping output names to field refs or aggregate expressions
      */
-    bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
+    aggregate<R extends Record<string, FieldRef | AggregateExpr>>(fields: R): ExecutableAggregateQuery<G, Aliases, R>;
     /**
-     * Find an edge by endpoints and optional property fields.
+     * 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().
      *
-     * 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 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 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 alias - The node alias to group by (uses the node's ID)
      */
-    findByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, options?: EdgeFindByEndpointsOptions<E>, temporal?: QueryOptions) => Promise<Edge<E, From, To> | undefined>;
+    groupByNode<A extends keyof Aliases & string>(alias: A): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Get an existing edge by endpoints and optional property fields, or create a new one.
+     * Filters grouped results using aggregate conditions (HAVING clause).
+     * Use after groupBy() to filter based on aggregate values.
      *
-     * 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 predicate - A predicate expression to filter groups
+     */
+    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    /**
+     * Sets fusion parameters for hybrid (vector + fulltext) queries.
      *
-     * `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.
+     * 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.
      *
-     * @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
+     * @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();
+     * ```
      */
-    getOrCreateByEndpoints: (from: NodeRef<From>, to: NodeRef<To>, props: z.input<E["schema"]>, options?: EdgeGetOrCreateByEndpointsOptions<E>) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>>;
+    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
     /**
-     * Batch version of getOrCreateByEndpoints.
+     * Applies a query fragment to transform this builder.
      *
-     * Results are returned in the same order as the input items.
-     * Atomic when the backend supports transactions.
+     * 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
      */
-    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>[]>;
-}>;
+    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 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>;
+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.
- */
-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`).
- *
- * 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.
+ * Input for updating an edge.
  */
-type ScopedMeasure<Context> = <T>(fn: (scoped: Context) => Promise<T>) => Promise<TransactionOutcome<T>>;
+type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{
+    id: EdgeId<E>;
+    props: Partial<z.infer<E["schema"]>>;
+    validTo?: 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.
+ * Options for node and edge queries.
  */
-type MeasurableTransactionContext<G extends GraphDef> = TransactionContext<G> & Readonly<{
-    measure: ScopedMeasure<MeasurableTransactionContext<G>>;
+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;
 }>;
-/** Receipt-enabled transaction context for an {@link AdapterStore}. */
-type MeasurableAdapterTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterTransactionContext<G, TNativeTransaction> & Readonly<{
-    measure: ScopedMeasure<MeasurableAdapterTransactionContext<G, TNativeTransaction>>;
+type QueryOptions = NoRecordedCoordinate & Readonly<{
+    /** Temporal mode for the query */
+    temporalMode?: TemporalMode;
+    /** Specific timestamp for asOf queries */
+    asOf?: string;
 }>;
 /**
- * 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
+ * Context passed to observability hooks.
  */
-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];
-};
+type HookContext = Readonly<{
+    /** Unique ID for this operation */
+    operationId: string;
+    /** Graph ID */
+    graphId: string;
+    /** Timestamp when operation started */
+    startedAt: Date;
+}>;
 /**
- * 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.
+ * Context for one SQL statement a query builder submits to the backend.
  *
- * 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
+     * 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.
      */
-    execute(): Promise<readonly AggregateResult<R>[]>;
-}
-
+    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;
+    }>;
+}>;
 /**
- * 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).
+ * Store options without built-in recorded-time capture. A recorded read relation
+ * can still be bound explicitly for hosts that populate history externally.
  */
-type ReadInstantMode = "literal" | "placeholder";
-
+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"]>;
+}>;
 /**
- * Query Compiler Module
- *
- * Main entry point for compiling query ASTs to SQL.
- * Re-exports individual compiler modules and provides the main compile functions.
+ * 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 query compilation.
+ * Options for creating a store.
  */
-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;
-}>;
-
+type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
 /**
- * PreparedQuery — a pre-validated, parameterized query.
+ * 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`) 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).
+ * ```ts
+ * async function handleRequest(): Promise<void> {
+ *   const store = ref.current;
+ *   const evolved = await store.evolve(extension, { ref });
+ *   await evolved.materializeIndexes();
+ *   // ref.current === evolved
+ * }
+ * ```
  *
- * 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.
+ * 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.
+ *
+ * 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);
+/**
+ * Options for node getOrCreateByConstraint operations.
+ */
+type NodeGetOrCreateByConstraintOptions = Readonly<{
+    /** Existing record behavior. Default: "return" */
+    ifExists?: IfExistsMode;
+}>;
+/**
+ * Options for node bulkFindByIndex operations.
+ */
+type NodeBulkFindByIndexOptions = Readonly<{
     /**
-     * Combines with another query using UNION.
+     * 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.
      */
-    union(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
+    limitPerInput?: number;
+}>;
+/**
+ * Per-endpoint fan-out cap shared by the live and view forms of the edge
+ * bulk endpoint reads.
+ */
+type EdgeBulkFindOptions = Readonly<{
     /**
-     * Combines with another query using UNION ALL.
+     * Maximum number of edges returned for each input endpoint. When omitted,
+     * every input's edge set is unbounded. Must be a positive integer.
+     *
+     * The cap keeps each input's leading edges under the same ordering
+     * `findFrom` / `findTo` return, so it bounds fan-out without reordering
+     * anything.
      */
-    unionAll(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
+    limitPerInput?: number;
+}>;
+/**
+ * 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>[];
+}>;
+/**
+ * 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<{
     /**
-     * Combines with another query using INTERSECT.
+     * 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).
      */
-    intersect(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
+    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 with another query using EXCEPT.
+     * Edge property fields to include in the match key alongside the (from, to) endpoints.
+     * Default: `[]` — match on endpoints only.
      */
-    except(other: ExecutableQueryLike<G, R>): UnionableQuery<G, R>;
+    matchOn?: readonly (keyof z.input<E["schema"]>)[];
+    /** Existing record behavior. Default: "return" */
+    ifExists?: IfExistsMode;
     /**
-     * Limits the number of results from the combined query.
+     * Valid-time start for a newly created edge. Ignored when an edge is found,
+     * updated, or resurrected.
      */
-    limit(n: number): UnionableQuery<G, R>;
+    validFrom?: string;
     /**
-     * Offsets the results from the combined query.
+     * Valid-time end for a created, updated, or resurrected edge. Ignored when
+     * the operation returns an existing edge without writing.
      */
-    offset(n: number): 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<{
     /**
-     * Builds the set operation AST.
+     * Create a new node.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    toAst(): SetOperation;
+    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 set operation to SQL.
+     * Find nodes matching criteria.
+     *
+     * 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>;
     /**
-     * Executes the combined query.
+     * 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.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    execute(): Promise<readonly R[]>;
+    createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
     /**
-     * Executes the combined query against a provided backend.
+     * Create or update a node.
      *
-     * 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.
-     */
-    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
-}
-
-/**
- * ExecutableQuery - A query that can be executed, paginated, or streamed.
- */
-
-/**
- * A query that can be executed.
- */
-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.
+     * If a node with the given ID exists, updates it with the provided props.
+     * Otherwise, creates a new node with that ID.
+     *
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
-    offset(n: number): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
+    upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
     /**
-     * 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);
+     * Upsert a node from untyped data, relying on runtime Zod validation.
      *
-     * const results = await query()
-     *   .from("User", "u")
-     *   .select((ctx) => ctx.u)
-     *   .pipe(paginated)
-     *   .execute();
-     * ```
+     * 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.
      *
-     * @param fragment - A function that transforms the executable query
-     * @returns The transformed executable query
-     */
-    pipe<NewR = R>(fragment: (query: ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>) => ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, NewR>;
-    /**
-     * Combines this query with another using UNION (removes duplicates).
-     */
-    union(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
-    /**
-     * Combines this query with another using UNION ALL (keeps duplicates).
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
-    unionAll(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
+        validFrom?: string;
+        validTo?: string;
+    }>) => Promise<Node<N>>;
     /**
-     * Combines this query with another using INTERSECT.
+     * Create multiple nodes 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.
      */
-    intersect(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    bulkCreate: (items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Node<N>[]>;
     /**
-     * Combines this query with another using EXCEPT.
+     * 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.
+     *
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
-    except(other: ExecutableQuery<G, any, any, any, R>): UnionableQuery<G, R>;
+    bulkUpsertById: (items: readonly Readonly<{
+        id: string;
+        props: z.input<N["schema"]>;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<Node<N>[]>;
     /**
-     * Compiles the query and returns the SQL text and parameters.
+     * Insert multiple nodes without returning results.
      *
-     * 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 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.
      */
-    toSQL(): Readonly<{
-        sql: string;
-        params: readonly unknown[];
-    }>;
+    bulkInsert: (items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<void>;
     /**
-     * Compiles the query to TypeGraph's database-independent SQL fragment.
+     * Delete multiple nodes by ID.
      *
-     * Pass the result to a GraphBackend, or use toSQL() to render SQL text and
-     * parameters for the configured dialect.
+     * Atomic when the backend supports transactions. Silently ignores IDs
+     * that don't exist.
      */
-    compile(): CompiledSelectSql;
+    bulkDelete: (ids: readonly NodeId<N>[]) => Promise<void>;
     /**
-     * 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).
-     *
-     * Use `param("name")` in predicates to create parameterized slots,
-     * then pass values via `prepared.execute({ name: "value" })`.
-     *
-     * @example
-     * ```typescript
-     * import { param } from "@nicia-ai/typegraph";
-     *
-     * const prepared = store.query()
-     *   .from("Person", "p")
-     *   .whereNode("p", (p) => p.name.eq(param("name")))
-     *   .select((ctx) => ctx.p)
-     *   .prepare();
+     * Find a node by uniqueness constraint.
      *
-     * const alice = await prepared.execute({ name: "Alice" });
-     * const bob = await prepared.execute({ name: "Bob" });
-     * ```
+     * 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.
      *
-     * @throws Error if no backend is configured
+     * @param constraintName - Name of the uniqueness constraint to match on
+     * @param props - Properties to compute the constraint key from
      */
-    prepare(): PreparedQuery<R>;
+    findByConstraint: (constraintName: CN, props: z.input<N["schema"]>) => Promise<Node<N> | undefined>;
     /**
-     * Executes the query and returns typed results.
-     *
-     * 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.
+     * Batch version of findByConstraint.
      *
-     * @throws Error if no backend is configured
+     * Results are returned in the same order as the input items.
+     * Returns undefined for entries that don't match.
      */
-    execute(): Promise<readonly R[]>;
+    bulkFindByConstraint: (constraintName: CN, items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+    }>[]) => Promise<(Node<N> | undefined)[]>;
     /**
-     * Executes the query against a provided backend.
+     * Batched candidate retrieval against a declared node index.
      *
-     * 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.
+     * 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.
      *
-     * 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.
+     * 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
      */
-    executeOn(backend: GraphBackend | TransactionBackend): Promise<readonly R[]>;
+    bulkFindByIndex: (indexName: string, items: readonly Readonly<{
+        props: Partial<z.input<N["schema"]>>;
+    }>[], options?: NodeBulkFindByIndexOptions) => Promise<readonly Node<N>[][]>;
     /**
-     * Executes a paginated query using cursor-based keyset pagination.
+     * Get an existing node by uniqueness constraint, or create a new one.
      *
-     * Cursor pagination is efficient for large datasets as it avoids OFFSET.
-     * Requires ORDER BY to be specified for deterministic results.
+     * 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 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
+     * @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")
      */
-    paginate(options: PaginateOptions): Promise<PaginatedResult<R>>;
+    getOrCreateByConstraint: (constraintName: CN, props: z.input<N["schema"]>, options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>>;
     /**
-     * Returns an async iterator that streams results in batches.
-     *
-     * Uses cursor pagination internally for efficient memory usage.
-     * Requires ORDER BY to be specified for deterministic results.
+     * Batch version of getOrCreateByConstraint.
      *
-     * @param options - Stream options (batchSize defaults to 1000)
-     * @throws ValidationError if ORDER BY is not specified
+     * Results are returned in the same order as the input items.
+     * Atomic when the backend supports transactions.
      */
-    stream(options?: StreamOptions): AsyncIterable<R>;
-}
-
-/**
- * TraversalBuilder - Intermediate builder for edge traversals.
- */
-
+    bulkGetOrCreateByConstraint: (constraintName: CN, items: readonly Readonly<{
+        props: z.input<N["schema"]>;
+    }>[], options?: NodeGetOrCreateByConstraintOptions) => Promise<NodeGetOrCreateByConstraintResult<N>[]>;
+}>;
 /**
- * Resolves the edge type for an edge alias based on its kind type parameter.
+ * Reference to a node of a specific kind.
  *
- * 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.
+ * 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 EdgeTypeForKey<G extends GraphDef, EK> = string extends EK ? DynamicEdgeType : EK extends keyof G["edges"] & string ? G["edges"][EK]["type"] : DynamicEdgeType;
+type NodeRef<N extends NodeType = NodeType> = Node<N> | Readonly<{
+    kind: N["kind"];
+    id: string;
+}>;
 /**
- * State for variable-length traversal configuration.
+ * Options for creating an edge.
  */
-interface VariableLengthState {
-    enabled: boolean;
-    minDepth: number;
-    maxDepth: number;
-    cyclePolicy: RecursiveCyclePolicy;
-    pathEnabled: boolean;
-    pathAlias?: string;
-    depthEnabled: boolean;
-    depthAlias?: string;
-}
+type EdgeCreateOptions = Readonly<{
+    id?: string;
+    validFrom?: string;
+    validTo?: string;
+}>;
 /**
- * Intermediate builder for traversal operations.
+ * Arguments for edge creation, with props optional when schema allows empty object.
  *
- * Type parameters track the edge kind and direction to constrain
- * which node kinds are valid targets in the `to()` method.
+ * Uses `{}` to check if an empty object literal satisfies the schema input type.
  */
-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[]);
+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<{
     /**
-     * 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 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
      */
-    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>;
+    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 the edge being traversed.
+     * Find edges from a specific node.
      *
-     * @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
+     * 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.
      */
-    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases, CoordinateState>;
+    findFrom: (from: NodeRef<From>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /**
-     * Specifies the target node kind.
-     *
-     * 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
+     * Find edges to a specific node.
      *
-     * @param kind - The target node kind
-     * @param alias - A unique alias for this node (compile-time error if duplicate)
+     * Temporal semantics mirror {@link EdgeCollection.findFrom}.
      */
-    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>;
+    findTo: (to: NodeRef<To>, options?: QueryOptions) => Promise<Edge<E, From, To>[]>;
     /**
-     * String-keyed sibling of `to` for runtime-declared target kinds.
-     * Throws `KindNotFoundError` if the kind is not registered.
+     * Find the edges from a SET of source nodes in one read.
+     *
+     * `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.
+     *
+     * 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.
+     *
+     * 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 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
      */
-    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);
+    bulkFindFrom: (froms: readonly NodeRef<From>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /**
-     * Starts a query from a node kind.
+     * Find the edges into a SET of target nodes in one read.
      *
-     * @param kind - The node kind to start from
-     * @param alias - A unique alias for this node (compile-time error if duplicate)
+     * Mirrors {@link EdgeCollection.bulkFindFrom} on the `to` endpoint.
      */
-    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>;
+    bulkFindTo: (tos: readonly NodeRef<To>[], options?: EdgeBulkFindEndpointOptions) => Promise<readonly Edge<E, From, To>[][]>;
     /**
-     * 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.
+     * 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}.
+     *
+     * 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.
      */
-    fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
-        includeSubClasses?: boolean;
-    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases, CoordinateState>;
+    batchFindFrom: (from: NodeRef<From>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
-     * Adds a WHERE clause for a node.
+     * 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}.
      */
-    whereNode<A extends keyof Aliases & string>(alias: A, predicateFunction: (n: NodeAccessor<Aliases[A]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    batchFindTo: (to: NodeRef<To>, options?: QueryOptions) => BatchableQuery<Edge<E, From, To>>;
     /**
-     * Adds a WHERE clause for an edge.
+     * Deferred variant of `findByEndpoints` for use with `store.batch()`.
      *
-     * @param alias - The edge alias to filter on
-     * @param predicateFunction - A function that builds predicates using the edge accessor
+     * 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}.
      */
-    whereEdge<EA extends keyof EdgeAliases & string>(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeAliases[EA]["type"]>) => Predicate): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    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>;
     /**
-     * Traverses an edge to another node (outgoing direction).
+     * Permanently delete an edge from the database.
      *
-     * 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).
+     * Unlike `delete()` which performs a soft delete, this permanently
+     * removes the edge record.
      *
-     * @param options.expand - Ontology expansion mode for implying/inverse edges
-     * @param options.from - Alias to traverse from (defaults to current/last traversal target)
+     * **Warning:** This operation is irreversible and should be used carefully.
+     * Consider using soft delete (`delete()`) for most use cases.
      */
-    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>;
+    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>;
     /**
-     * Traverses an edge to another node (incoming direction).
+     * Create multiple edges in a 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).
+     * More efficient than calling create() multiple times.
+     * Use `bulkInsert` for the dedicated fast path that skips returning results.
      *
-     * @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)
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    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>;
+    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>[]>;
     /**
-     * String-keyed sibling of `traverse` for runtime-declared edge kinds.
-     * Throws `KindNotFoundError` if the edge kind is not registered.
+     * 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.
      */
-    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>;
+    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>[]>;
     /**
-     * Optionally traverses an edge to another node (LEFT JOIN semantics).
-     * If no matching edge/node exists, the result will include null values.
+     * Insert multiple edges without returning results.
      *
-     * 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).
+     * 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.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)
-     */
-    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.
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
      */
-    select<R>(selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R): ExecutableQuery<G, Aliases, EdgeAliases, RecursiveAliases, R>;
+    bulkInsert: (items: readonly Readonly<{
+        from: NodeRef<From>;
+        to: NodeRef<To>;
+        props?: z.input<E["schema"]>;
+        id?: string;
+        validFrom?: string;
+        validTo?: string;
+    }>[]) => Promise<void>;
     /**
-     * Selects fields including aggregates.
-     * Use with groupBy() for aggregate queries.
+     * Delete multiple edges by ID.
      *
-     * @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.
+     * Atomic when the backend supports transactions. Silently ignores IDs
+     * that don't exist.
      */
-    offset(n: number): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
+    bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;
     /**
-     * Groups results by the specified field.
-     * Use with aggregate functions like COUNT, SUM, AVG in select().
+     * Find an edge by endpoints and optional property fields.
      *
-     * @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.
+     * 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 alias - The node alias to group by (uses the node's ID)
+     * @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
-     */
-    having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>;
-    /**
-     * Sets fusion parameters for hybrid (vector + fulltext) 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.
      *
-     * 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.
+     * `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.
      *
-     * @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();
-     * ```
+     * @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
      */
-    fuseWith(options: HybridFusionOptions): 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>>;
     /**
-     * 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();
-     * ```
+     * Batch version of getOrCreateByEndpoints.
      *
-     * @param fragment - A function that transforms the builder
-     * @returns The transformed builder
+     * Results are returned in the same order as the input items.
+     * Atomic when the backend supports transactions.
      */
-    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>;
-}
-
+    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>[]>;
+}>;
 /**
- * Fluent query builder for TypeGraph.
- *
- * Provides a type-safe, chainable API for building queries.
- * Each method returns a new builder instance with expanded type information.
+ * Extract uniqueness constraint names from a NodeRegistration.
  *
- * This module re-exports from the builder submodules and provides the
- * createQueryBuilder factory function.
+ * - 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 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 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;
+    /**
+     * Runtime string-keyed node collection access, mirroring
+     * `Store.getNodeCollection`. Returns `undefined` when `kind` is not
+     * registered in this graph.
+     */
+    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
+}>;
+/**
+ * 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`).
+ *
+ * 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.
+ */
+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.
@@ -3682,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", "commitSchemaVersionIfKindsEmpty", "lockSchemaVersionForWrite", "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", "findEdgesByEndpointSet", "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", "verifyContributions"];
+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" | "schemaWriteTransaction" | "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;
 
@@ -4138,6 +4210,7 @@ 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>;
@@ -4145,6 +4218,7 @@ type StoreCore<G extends GraphDef> = Readonly<{
     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>;
 }>;
@@ -4591,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`,
@@ -4619,4 +4695,4 @@ declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView
     get edges(): RecordedStoreViewEdgeCollections<G>;
 }
 
-export { type EmptyAliasMap 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 EdgeBulkFindEndpointOptions as N, type EdgeBulkFindOptions as O, type EdgeCollection as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeFindByEndpointsOptions as V, type EdgeGetOrCreateByEndpointsOptions as W, type EdgeGetOrCreateByEndpointsResult as X, type EdgeIntrospection as Y, type EdgeTemporalReads as Z, type EdgeWrites as _, type Store as a, RecordedStoreView as a$, type EmptyEdgeAliasMap as a0, ExecutableAggregateQuery as a1, ExecutableQuery as a2, type FieldAccessor as a3, type FulltextSearchHit as a4, type FulltextSearchOptions as a5, type GetOrCreateAction as a6, type GraphAlgorithms as a7, type GraphEdgeCollections as a8, type GraphNodeCollections as a9, type NodeGetOrCreateByConstraintResult as aA, type NodeIdentifier as aB, type NodeRef as aC, type NodeTemporalReads as aD, type NodeWrites as aE, type OntologyIntrospection as aF, type OperationHookContext as aG, type PageRankOptions as aH, type PageRankScore as aI, type PaginateOptions as aJ, type PaginatedResult as aK, type PathNode as aL, type PersonalizedPageRankOptions as aM, type PersonalizedPageRankSeed as aN, type Predicate as aO, PreparedQuery as aP, type PropsAccessor as aQ, type QueryHookContext as aR, type QueryOptions as aS, type ReachableNode as aT, type ReachableOptions as aU, type RebuildFulltextOptions as aV, type RebuildFulltextResult as aW, type ReclaimedVectorFieldEntry as aX, type ReconciledSchema as aY, type RecordedScanOptions as aZ, type RecordedScanPage as a_, type HistoryStoreBackend as aa, type HookContext as ab, type HybridFulltextOptions as ac, type HybridSearchHit as ad, type HybridSearchOptions as ae, type HybridVectorOptions as af, type IfExistsMode as ag, type InitialQueryBuilder as ah, type KindIntrospection as ai, type LabelPropagationMembership as aj, type LabelPropagationOptions as ak, type MaterializeRemovalsEntry as al, type MaterializeRemovalsOptions as am, type MaterializeRemovalsResult as an, type MeasurableAdapterHistoryTransactionContext as ao, type MeasurableAdapterTransactionContext as ap, type MeasurableTransactionContext as aq, type NeighborsOptions as ar, type NoRecordedCoordinate as as, type Node as at, type NodeAccessor as au, type NodeAlias as av, type NodeBulkFindByIndexOptions as aw, type NodeCollection as ax, type NodeCurrentReads as ay, type NodeGetOrCreateByConstraintOptions as az, type HistoryStore as b, type WeightedShortestPathResult as b$, type RecordedStoreViewEdgeCollection as b0, type RecordedStoreViewEdgeCollections as b1, type RecordedStoreViewNodeCollection as b2, type RecordedStoreViewNodeCollections as b3, type RecursiveTraversalOptions as b4, type ReembedFunction as b5, type ReembedVectorFieldOptions as b6, type ReembedVectorFieldResult as b7, type SchemaIntrospection as b8, type ScopedMeasure as b9, type StoreViewSubgraphOptions as bA, type StoreViewWeaklyConnectedComponentsOptions as bB, type StoreViewWeightedShortestPathOptions as bC, type StreamOptions as bD, type SubgraphEdgeResult as bE, type SubgraphNodeResult as bF, type SubgraphOptions as bG, type SubgraphResult as bH, type SubsetEdge as bI, type SubsetNode as bJ, type TemporalAlgorithmOptions as bK, type TransactionContext as bL, type TransactionOutcome as bM, type TransactionReceipt as bN, type TraversalDirection as bO, type TypedEdgeCollection as bP, type TypedRecordedStoreViewEdgeCollection as bQ, type TypedStoreViewEdgeCollection as bR, UnionableQuery as bS, type UniqueIntrospection as bT, type UpdateEdgeInput as bU, type UpdateNodeInput as bV, type VectorSearchHit as bW, type VectorSearchOptions as bX, type WeaklyConnectedComponentMembership as bY, type WeaklyConnectedComponentsOptions as bZ, type WeightedShortestPathOptions as b_, type SearchScopeOptions as ba, type SelectContext as bb, type SelectableEdge as bc, type SelectableNode as bd, type ShortestPathOptions as be, type ShortestPathResult as bf, type SqlAvailability as bg, type StoreHooks as bh, type StoreProjection as bi, type StoreRef as bj, StoreSearch as bk, StoreView as bl, type StoreViewCanReachOptions as bm, type StoreViewCoordinate as bn, type StoreViewDegreeOptions as bo, type StoreViewEdgeCollection as bp, type StoreViewEdgeCollections as bq, type StoreViewGraphAlgorithms as br, type StoreViewLabelPropagationOptions as bs, type StoreViewNeighborsOptions as bt, type StoreViewNodeCollection as bu, type StoreViewNodeCollections as bv, type StoreViewPageRankOptions as bw, type StoreViewPersonalizedPageRankOptions as bx, type StoreViewReachableOptions as by, type StoreViewShortestPathOptions as bz, type RecordedReadStore as c, createAdapterStore as c0, createAdapterStoreWithSchema as c1, createQueryBuilder as c2, createStore as c3, createStoreWithSchema as c4, createVerifiedAdapterStore as c5, createVerifiedStore as c6, defineSubgraphProject as c7, exists as c8, fieldRef as c9, inSubquery as ca, isParameterRef as cb, notExists as cc, notInSubquery as cd, param as ce, 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 };