@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/{store-view-FfE5_7eo.d.ts → store-view-BSpqvAxK.d.cts}

@@ -1,8 +1,8 @@
-import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-C0_r0ALf.js';
-import { T as TemporalMode, A as AnyEdgeType, N as NodeType, g as EdgeType, E as EdgeRegistration, e as EdgeId, d as NodeId, b as NodeRegistration, K as KindEntity, m as Cardinality, q as EndpointExistence, f as KindAnnotations, s as UniquenessScope, n as Collation, G as GraphExtension } from './extension-types-YGFJPrzK.js';
+import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-DwQi8eV0.cjs';
+import { T as TemporalMode, N as NodeType, A as AnyEdgeType, g as EdgeType, E as EdgeRegistration, d as NodeId, K as KindEntity, b as NodeRegistration, e as EdgeId, s as UniquenessScope, n as Collation, f as KindAnnotations, m as Cardinality, q as EndpointExistence, G as GraphExtension } from './extension-types-ixRpJVUp.cjs';
 import { z } from 'zod';
-import { b7 as ValueType, b8 as PredicateExpression, b9 as VectorMetricType, ae as FulltextQueryMode, Q as QueryAst, J as JsonPointer, P as FieldRef, ax as ParameterRef, G as GraphBackend, aP as TransactionBackend, ao as JsonPointerInput, aQ as TraversalExpansion, p as SqlDialect, aL as SqlSchema, ba as Traversal, bb as NodePredicate, bc as ProjectedField, aw as OrderSpec, bd as GroupBySpec, ak as HybridFusionOptions, be as RecursiveCyclePolicy, W as TraversalDirection$1, bf as EdgeRow, bg as NodeRow, aa as ExternalRecordedReadSource, X as AdoptedTransaction, L as AggregateExpr, a3 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bh as VectorSlotMap, bi as RecordedReadBinding, bj as SelectiveField, bk as ComposableQuery, bl as SetOperationType, bm as SetOperation, aJ as SortDirection, bn as VectorMetric, m as JsonSchema, bo as TransactionOptions } from './types-DGylBhWo.js';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-CAkIYFV-.js';
+import { bc as ValueType, bd as PredicateExpression, ag as FulltextQueryMode, be as VectorMetricType, Q as QueryAst, J as JsonPointer, P as FieldRef, az as ParameterRef, aq as JsonPointerInput, G as GraphBackend, aS as TransactionBackend, aT as TraversalExpansion, f as SqlDialect, aO as SqlSchema, bf as Traversal, bg as NodePredicate, bh as ProjectedField, ay as OrderSpec, bi as AggregateOrderSpec, bj as GroupBySpec, am as HybridFusionOptions, bk as RecursiveCyclePolicy, W as TraversalDirection$1, bl as NodeRow, aa as ExternalRecordedReadSource, bm as EdgeRow, X as AdoptedTransaction, L as AggregateExpr, aM as SortDirection, a3 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bn as VectorSlotMap, bo as RecordedReadBinding, bp as SelectiveField, bq as ComposableQuery, br as SetOperationType, bs as SetOperation, bt as VectorMetric, z as JsonSchema, bu as TransactionOptions } from './fulltext-strategy-CDkSSYhq.cjs';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-B4e9360H.cjs';
 
 /**
  * Embedding type for vector search.
@@ -354,7 +354,11 @@ type MatchesOptions = Readonly<{
      */
     mode?: FulltextQueryMode;
     /**
-     * Language override. Default: per-row language as stored at insert time.
+     * Language override for query parsing. Default: the kind's declared
+     * language when every kind in the alias shares one (a plan-time
+     * constant, so PostgreSQL can serve the match from the GIN index);
+     * mixed-language subclass aliases fall back to the per-row language
+     * column.
      */
     language?: string;
     /** Minimum relevance score to include. */
@@ -373,6 +377,17 @@ type SimilarToOptions = Readonly<{
      * For inner_product: minimum inner product value.
      */
     minScore?: number;
+    /**
+     * Opt into approximate retrieval: each declaring kind's candidates come
+     * from the engine's native ANN structure (pgvector HNSW/IVFFlat scans,
+     * vec0 `MATCH … k=`, libSQL `vector_top_k`) instead of an exact
+     * distance scan. This is a SEMANTIC change — results are subject to the
+     * index's recall, and predicates composed alongside constrain the ANN
+     * candidate set (exact on pgvector/vec0; bounded by over-fetch on
+     * libSQL). A slot declared with `indexType: "none"` falls back to the
+     * exact scan. Default: exact.
+     */
+    approximate?: boolean;
 }>;
 /**
  * Creates a field reference.
@@ -789,9 +804,13 @@ type SelectableNodeMeta = Readonly<{
  * For aliases declared via `fromDynamic` / `toDynamic` this resolves to
  * `DynamicSelectableNode` — same wire shape, schema properties typed
  * `unknown` for narrowing at the call site.
+ *
+ * `id` carries the same `NodeId<N>` brand as `Node<N>` (see `store/types.ts`)
+ * so a projected id can be passed straight back into `getById`/`getByIds`
+ * without a cast.
  */
 type SelectableNode<N extends NodeType> = IsDynamicNodeType<N> extends true ? DynamicSelectableNode : Readonly<{
-    id: string;
+    id: NodeId<N>;
     kind: N["kind"];
     meta: SelectableNodeMeta;
 }> & Readonly<z.infer<N["schema"]>>;
@@ -813,6 +832,46 @@ type SelectableEdgeMeta = Readonly<{
  * - System metadata is under `edge.meta.*`
  *
  * Dynamic-mode counterpart: see `SelectableNode`.
+ *
+ * `traverse(edgeKind, alias)` defaults to `expand: "inverse"` (see
+ * `GraphAlgorithms`/`QueryBuilder.traverse`'s `defaultTraversalExpansion`),
+ * which UNIONs in rows for the *registered inverse* edge kind alongside the
+ * requested one — `EdgeAlias<E>`'s `E` stays pinned to the single requested
+ * kind regardless, so under the default expansion mode the row backing
+ * `alias` can genuinely be a different edge kind (with different endpoint
+ * kinds and a different props schema — `inverseOf(edgeA, edgeB)` doesn't
+ * require `edgeA`/`edgeB` to share a schema) than `E` says. Three distinct
+ * consequences follow:
+ *
+ * - `kind: E["kind"]` is a **literal type that can already be wrong today**
+ *   — not a branding gap, a plain type-accuracy gap. It's typed as the
+ *   requested kind (e.g. `"manages"`) but the runtime value can be the
+ *   inverse kind (e.g. `"managedBy"`); see the `"proves why edge
+ *   id/kind/schema props can't be trusted"` test in
+ *   `tests/query-execution.test.ts` for a concrete repro. This predates
+ *   and is independent of the id/endpoint branding question below.
+ * - The flattened `z.infer<E["schema"]>` properties have the same
+ *   type-accuracy gap as `kind`, for the same reason: `ctx.e.role` is typed
+ *   against the requested kind's schema, but an inverse-branch row's real
+ *   props came from a different schema and may not have a `role` field at
+ *   all (reading it returns `undefined`, not a type error).
+ * - `id`/`fromId`/`toId` stay plain `string`, unlike `SelectableNode`'s
+ *   `id: NodeId<N>` — a real ergonomics gap, but not an accuracy one: `string`
+ *   never overclaims. Branding them would compile but be actively wrong:
+ *   e.g. `store.edges.<E>.getById()` filters on `row.kind !== kind` and
+ *   silently returns `undefined` for a mismatched-kind id — worse than the
+ *   unsafe cast it would have replaced.
+ *
+ * Proving any of these safe requires tracking `expand` mode (`"none"` vs
+ * not) at the type level through `TraversalBuilder`/`EdgeAlias` — evaluated
+ * for #235 and deliberately not built: the machinery would touch every
+ * traversal-entry overload for a benefit that only applies when a caller
+ * opts out of the default expansion. When you know a traversal is
+ * single-kind (e.g. via `expand: "none"`), re-brand `id`/`fromId`/`toId`
+ * explicitly with `asNodeId`/`asEdgeId` (see #223) — e.g.
+ * `asNodeId<typeof Person>(edge.fromId)` for a `Person -> Company` edge —
+ * and don't trust `kind` or schema properties without independently
+ * verifying the traversal can't have expanded.
  */
 type SelectableEdge<E extends AnyEdgeType = EdgeType> = IsDynamicEdgeType<E> extends true ? DynamicSelectableEdge : Readonly<{
     id: string;
@@ -914,6 +973,8 @@ type QueryBuilderState = Readonly<{
     predicates: readonly NodePredicate[];
     projection: readonly ProjectedField[];
     orderBy: readonly OrderSpec[];
+    /** ORDER BY entries added via `ExecutableAggregateQuery.orderBy()`. */
+    aggregateOrderBy: readonly AggregateOrderSpec[];
     limit: number | undefined;
     offset: number | undefined;
     temporalMode: TemporalMode;
@@ -1173,16 +1234,62 @@ type StoreHooks = Readonly<{
     }>) => void;
     /** Called before a CRUD operation starts */
     onOperationStart?: (ctx: OperationHookContext) => void;
-    /** Called after a CRUD operation completes */
+    /**
+     * Called after a CRUD operation completes AND is durably committed. For a
+     * top-level operation that is when its own transaction commits; for an
+     * operation inside `store.transaction`, emission is deferred until the
+     * enclosing transaction commits — if that commit fails, the operation is
+     * reported through `onError` instead. (Inside an adopted transaction —
+     * `withTransaction` / `withRecordedTransaction` — the commit belongs to
+     * the caller and cannot be observed, so this fires when the operation
+     * completes within the still-open transaction.)
+     */
     onOperationEnd?: (ctx: OperationHookContext, result: Readonly<{
         durationMs: number;
     }>) => void;
-    /** Called when an error occurs */
+    /**
+     * Called when an operation fails — including an operation that completed
+     * inside a `store.transaction` whose commit then failed and rolled it
+     * back.
+     */
     onError?: (ctx: HookContext, error: Error) => void;
 }>;
 type BaseStoreOptions = Readonly<{
     /** Observability hooks for monitoring */
     hooks?: StoreHooks;
+    /**
+     * Maintain a durable, graph-wide revision anchor for TypeGraph writes:
+     * a random per-graph origin plus a monotonic revision clock. `branch()` uses
+     * this anchor to validate that its base has not moved without
+     * re-fingerprinting every live row, and cannot confuse a coincident clock in
+     * a separately created store for its original base. `history: true` enables
+     * the same tracking automatically through its recorded-time commit clock.
+     *
+     * This is intentionally opt-in for live stores: each successful graph write
+     * advances the anchor inside its write transaction. On PostgreSQL, those
+     * transactions take a graph-scoped advisory lock until commit; writes to the
+     * same graph therefore serialize. Enable it for branchable graphs, but size
+     * high-throughput multi-writer workloads for that trade-off.
+     *
+     * Writes performed directly through a backend — including raw graph-table
+     * writes through `tx.sql` — bypass the anchor and are outside the
+     * revision-tracking contract.
+     */
+    revisionTracking?: boolean;
+    /**
+     * 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.
+     */
+    autoRefreshStatistics?: false | number;
     /** SQL schema configuration from createSqlSchema(...) for custom table names */
     schema?: SqlSchema;
     /** Query default behaviors. */
@@ -1242,6 +1349,55 @@ type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
 interface StoreRef<T> {
     current: T;
 }
+/**
+ * Summary returned by `store.transactionWithReceipt(fn)`.
+ */
+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.
+     */
+    recorded?: RecordedInstant;
+}>;
 /**
  * Behavior when a get-or-create operation matches an existing record.
  */
@@ -1314,7 +1470,11 @@ type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> = Readonly<{
  * Provides ergonomic CRUD operations for a single node type.
  */
 type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
-    /** Create a new node */
+    /**
+     * Create a new node.
+     *
+     * `validFrom` defaults to the operation's creation timestamp when omitted.
+     */
     create: (props: z.input<N["schema"]>, options?: Readonly<{
         id?: string;
         validFrom?: string;
@@ -1361,6 +1521,8 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * 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.
      */
     createFromRecord: (data: Record<string, unknown>, options?: Readonly<{
         id?: string;
@@ -1372,6 +1534,9 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * If a node with the given ID exists, updates it with the provided props.
      * Otherwise, creates a new node with that ID.
+     *
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
     upsertById: (id: string, props: z.input<N["schema"]>, options?: Readonly<{
         validFrom?: string;
@@ -1383,6 +1548,9 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * 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.
      */
     upsertByIdFromRecord: (id: string, data: Record<string, unknown>, options?: Readonly<{
         validFrom?: string;
@@ -1393,6 +1561,8 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * 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.
      */
     bulkCreate: (items: readonly Readonly<{
         props: z.input<N["schema"]>;
@@ -1405,6 +1575,9 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      *
      * For each item, if a node with the given ID exists, updates it.
      * Otherwise, creates a new node with that ID.
+     *
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
     bulkUpsertById: (items: readonly Readonly<{
         id: string;
@@ -1418,6 +1591,8 @@ type NodeCollection<N extends NodeType, CN extends string = string> = Readonly<{
      * 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.
      */
     bulkInsert: (items: readonly Readonly<{
         props: z.input<N["schema"]>;
@@ -1552,6 +1727,8 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
     /**
      * 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
@@ -1631,6 +1808,8 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      *
      * 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.
      */
     bulkCreate: (items: readonly Readonly<{
         from: NodeRef<From>;
@@ -1645,6 +1824,9 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      *
      * For each item, if an edge with the given ID exists, updates it.
      * Otherwise, creates a new edge with that ID.
+     *
+     * `validFrom` only applies on the create branch, defaulting to the
+     * operation's creation timestamp when omitted; it has no effect on update.
      */
     bulkUpsertById: (items: readonly Readonly<{
         id: EdgeId<E>;
@@ -1660,6 +1842,8 @@ type EdgeCollection<E extends AnyEdgeType, From extends NodeType = NodeType, To
      * 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.
      */
     bulkInsert: (items: readonly Readonly<{
         from: NodeRef<From>;
@@ -1889,9 +2073,10 @@ type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
  * Its type is the `AdoptedTransaction` union; cast to your concrete
  * Drizzle database type at the call site.
  *
- * When the store was created with `{ history: true }`, `tx.sql` is present but
- * replaced by a fail-loud guard because raw SQL would bypass recorded-time
- * capture. Use the typed `tx.nodes` / `tx.edges` collections inside
+ * When the store was created with `{ history: true }` or
+ * `{ revisionTracking: true }`, `tx.sql` is present but replaced by a fail-loud
+ * guard because raw SQL would bypass recorded-time capture or the revision
+ * anchor. Use the typed `tx.nodes` / `tx.edges` collections inside
  * `transaction()`, or use `store.withRecordedTransaction(externalTx, fn)` when
  * the relational layer owns the transaction boundary.
  *
@@ -1915,6 +2100,21 @@ type TransactionContext<G extends GraphDef> = Readonly<{
      * is the store's plain backend — reads work, but there is no snapshot.
      */
     backend: TransactionBackend;
+    /**
+     * Runtime string-keyed node collection access, mirroring
+     * `Store.getNodeCollection` — for callers (e.g. provenance) that resolve a
+     * kind dynamically rather than through the static `nodes.<Kind>` property.
+     * Returns `undefined` when `kind` is not registered in this graph.
+     */
+    getNodeCollection(kind: string): DynamicNodeCollection | undefined;
+    /**
+     * @internal Runs a graph-owned node mutation through this transaction's
+     * operation-hook lifecycle when the mutation cannot use a public collection
+     * verb directly (provenance fact close/reopen). Routed through the
+     * transaction's hook runner, so a successful operation's `onOperationEnd`
+     * is deferred until the transaction commits.
+     */
+    runNodeOperationHooks<T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>): Promise<T>;
 }>;
 /**
  * Replace branded `NodeId` / `EdgeId` with plain `string` in each
@@ -2020,6 +2220,33 @@ declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends Alias
      * 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.
      */
@@ -2050,6 +2277,30 @@ declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends Alias
     execute(): Promise<readonly AggregateResult<R>[]>;
 }
 
+/**
+ * Temporal Filter Compilation
+ *
+ * Generates SQL clauses for temporal filtering based on valid_from/valid_to
+ * and deleted_at timestamps. Consolidates the previously duplicated temporal
+ * filter functions into a single, parameterized implementation.
+ */
+
+/**
+ * How a "current" valid-time read instant is emitted into compiled SQL:
+ *
+ * - `"literal"` — bound as a concrete value at compile time
+ *   ({@link currentReadInstant}). The instant is frozen into the compiled
+ *   statement, so the statement must be recompiled to observe a newer "now".
+ * - `"placeholder"` — bound as a reserved execution-time placeholder
+ *   ({@link currentReadInstantPlaceholder}). The statement can be compiled
+ *   once and reused across executions, filling a fresh instant each call.
+ *
+ * Defaults to `"literal"` everywhere except the query builder's compiled
+ * template cache, which opts into `"placeholder"` so a reused/prepared query
+ * never freezes "now" the way a cached literal would (the #246 regression).
+ */
+type ReadInstantMode = "literal" | "placeholder";
+
 /**
  * Query Compiler Module
  *
@@ -2092,6 +2343,8 @@ type CompileQueryOptions = Readonly<{
      * 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
@@ -2099,15 +2352,40 @@ type CompileQueryOptions = Readonly<{
      * 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;
 }>;
 
+/**
+ * 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`), the statement is compiled ONCE into a cached template whose
+ * "current" read instant and user `param()` refs are reserved placeholders
+ * (see {@link buildReadInstantTemplate}). Every `execute()` fills those
+ * placeholders — a fresh instant plus the call's bindings — and runs the
+ * cached SQL text directly, so a reused prepared query never recompiles and
+ * never freezes "now" the way a cached literal instant would (the #246
+ * regression).
+ *
+ * Fallback: on a backend without raw execution (custom/async), substitutes
+ * parameter refs into the AST, compiles fresh per call, and executes via the
+ * standard `backend.execute` path.
+ */
+
 type PreparedQueryConfig<R> = Readonly<{
     ast: QueryAst;
     unoptimizedAst: QueryAst;
-    sqlText: string | undefined;
-    sqlParams: readonly unknown[] | undefined;
-    unoptimizedSqlText: string | undefined;
-    unoptimizedSqlParams: readonly unknown[] | undefined;
     backend: GraphBackend;
     dialect: SqlDialect;
     graphId: string;
@@ -2118,7 +2396,9 @@ type PreparedQueryConfig<R> = Readonly<{
     schemaIntrospector: SchemaIntrospector;
 }>;
 /**
- * A pre-compiled, parameterized query.
+ * 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.
  *
  * @example
  * ```typescript
@@ -2167,10 +2447,6 @@ type UnionableQueryState = Readonly<{
     traversals?: readonly Traversal[];
     selectFn?: (context: SelectContext<AliasMap, EdgeAliasMap>) => unknown;
 }>;
-/**
- * A query formed by combining multiple queries with set operations.
- * Supports chaining: q1.union(q2).intersect(q3)
- */
 declare class UnionableQuery<G extends GraphDef, R> {
     #private;
     constructor(config: QueryBuilderConfig, state: UnionableQueryState);
@@ -2239,7 +2515,7 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
     #private;
     constructor(config: QueryBuilderConfig, state: QueryBuilderState, selectFunction: (context: SelectContext<Aliases, EdgeAliases, RecursiveAliases>) => R);
     /**
-     * Builds the query AST.
+     * Builds the query AST (memoized — the instance is immutable).
      */
     toAst(): QueryAst;
     /**
@@ -2309,8 +2585,12 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
      */
     compile(): CompiledSelectSql;
     /**
-     * Creates a prepared (pre-compiled) query that can be executed
-     * multiple times with different parameter bindings.
+     * 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.
      *
      * Use `param("name")` in predicates to create parameterized slots,
      * then pass values via `prepared.execute({ name: "value" })`.
@@ -2922,16 +3202,6 @@ type RebuildFulltextResult = Readonly<{
     skippedTruncated: boolean;
 }>;
 
-/**
- * Store-level search helpers.
- *
- * `fulltextSearch` is a thin typed wrapper over `backend.fulltextSearch`.
- * `hybridSearch` runs a vector and a fulltext query in parallel and
- * fuses the two ranked lists with Reciprocal Rank Fusion. RRF is
- * rank-based, so it papers over score-scale differences between
- * pgvector/sqlite-vec (distance-derived) and tsvector/FTS5 (BM25-style).
- */
-
 /**
  * A fulltext search hit. `N` defaults to the generic `Node`; the
  * `store.search.fulltext<K>(kind)` facade narrows it to the concrete
@@ -2966,7 +3236,36 @@ type HybridSearchHit<N = Node> = Readonly<{
     /** Sub-result from the fulltext half, if it ranked this node. */
     fulltext?: FulltextSearchHit<N>;
 }>;
-type FulltextSearchOptions = Readonly<{
+/**
+ * Scope options shared by every facade search leg.
+ *
+ * `where` and `includeSubClasses` compile into the search statement's
+ * candidate set (a subquery produced by the store's own query compiler), so
+ * filtering happens INSIDE the engine's top-k — never by post-filtering a
+ * ranked list. `offset` is rank-relative pagination: the engine fetches
+ * `limit + offset` ranked candidates and discards the leading page.
+ */
+type SearchScopeOptions<N extends NodeType = NodeType> = Readonly<{
+    /**
+     * Predicate over the node's properties, compiled by the shared query
+     * compiler into the candidate subquery. Requires a query-capable store.
+     * The facade instantiates `N` to the searched kind's node type, so the
+     * accessor is fully typed at the call site; the base instantiation
+     * exposes the system accessors (`id`, `kind`) for standalone option
+     * values.
+     */
+    where?: (accessor: NodeAccessor<N>) => Predicate;
+    /** Rows to skip after ranking (rank-relative pagination). */
+    offset?: number;
+    /**
+     * Expand the searched kind to include its `subClassOf` descendants.
+     * Vector legs search each declaring kind's storage and merge by score;
+     * kinds that don't declare the embedding field are skipped (mirroring
+     * the query builder). Requires a query-capable store.
+     */
+    includeSubClasses?: boolean;
+}>;
+type FulltextSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
     /** The user-supplied query string. */
     query: string;
     /** Max results. Required. */
@@ -2974,8 +3273,10 @@ type FulltextSearchOptions = Readonly<{
     /** Query parser mode. Default: "websearch". */
     mode?: FulltextQueryMode;
     /**
-     * Language override for query parsing. Default: per-row language as
-     * stored at insert time.
+     * Language override for query parsing. Default: the kind's
+     * declared language (the same config rows were indexed with),
+     * which keeps the parsed tsquery a plan-time constant on
+     * PostgreSQL so the GIN index can serve the match.
      */
     language?: string;
     /** Minimum relevance score to include in results. */
@@ -3008,7 +3309,7 @@ type HybridVectorOptions = Readonly<{
  * vector half of `HybridSearchOptions` but flattens it because the
  * standalone path doesn't fuse against fulltext.
  */
-type VectorSearchOptions = Readonly<{
+type VectorSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
     /** Field path of the embedding column on the node kind. */
     fieldPath: string;
     /** Query embedding to compare against. */
@@ -3045,7 +3346,7 @@ type HybridFulltextOptions = Readonly<{
     minScore?: number;
     includeSnippets?: boolean;
 }>;
-type HybridSearchOptions = Readonly<{
+type HybridSearchOptions<N extends NodeType = NodeType> = SearchScopeOptions<N> & Readonly<{
     vector: HybridVectorOptions;
     fulltext: HybridFulltextOptions;
     fusion?: HybridFusionOptions;
@@ -3077,10 +3378,17 @@ type HybridSearchOptions = Readonly<{
  * when) the literal is statically known.
  */
 type ResolveNode<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node : Node;
+/**
+ * The registered `NodeType` behind a kind literal — the accessor-level
+ * companion of {@link ResolveNode}, used to type `where` predicates.
+ * Falls back to the base `NodeType` for dynamic (string) kinds.
+ */
+type ResolveNodeType<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? N : NodeType : NodeType;
 type StoreSearchContext = Readonly<{
     graphId: string;
     backend: GraphBackend;
     registry: KindRegistry;
+    createQuery?: () => QueryBuilder<GraphDef>;
 }>;
 /**
  * Search-related operations exposed via `store.search`.
@@ -3129,7 +3437,7 @@ declare class StoreSearch<G extends GraphDef> {
      * configured with) and resolves the matching node IDs back to typed
      * `Node` objects.
      */
-    fulltext<K extends string>(nodeKind: K, options: FulltextSearchOptions): Promise<readonly FulltextSearchHit<ResolveNode<G, K>>[]>;
+    fulltext<K extends string>(nodeKind: K, options: FulltextSearchOptions<ResolveNodeType<G, K>>): Promise<readonly FulltextSearchHit<ResolveNode<G, K>>[]>;
     /**
      * Runs a vector similarity search against nodes of the given kind.
      *
@@ -3141,7 +3449,7 @@ declare class StoreSearch<G extends GraphDef> {
      * Pure vector — no fulltext leg, no fusion. For combined
      * vector+fulltext ranking, use `hybrid`.
      */
-    vector<K extends string>(nodeKind: K, options: VectorSearchOptions): Promise<readonly VectorSearchHit<ResolveNode<G, K>>[]>;
+    vector<K extends string>(nodeKind: K, options: VectorSearchOptions<ResolveNodeType<G, K>>): Promise<readonly VectorSearchHit<ResolveNode<G, K>>[]>;
     /**
      * Runs a vector + fulltext hybrid search and fuses the results with
      * Reciprocal Rank Fusion.
@@ -3151,7 +3459,7 @@ declare class StoreSearch<G extends GraphDef> {
      * over-fetch is 4× `limit` from each source — tune via `vector.k` /
      * `fulltext.k` for higher-recall corpora.
      */
-    hybrid<K extends string>(nodeKind: K, options: HybridSearchOptions): Promise<readonly HybridSearchHit<ResolveNode<G, K>>[]>;
+    hybrid<K extends string>(nodeKind: K, options: HybridSearchOptions<ResolveNodeType<G, K>>): Promise<readonly HybridSearchHit<ResolveNode<G, K>>[]>;
     /**
      * Rebuilds the fulltext index from existing node data.
      *
@@ -3538,6 +3846,18 @@ declare class Store<G extends GraphDef> {
      * @internal
      */
     get historyEnabled(): boolean;
+    /**
+     * Whether this Store advances a durable revision anchor for graph writes.
+     *
+     * @internal
+     */
+    get revisionTrackingEnabled(): boolean;
+    /**
+     * SQL schema that owns the durable revision clock relation.
+     *
+     * @internal
+     */
+    get revisionSchema(): SqlSchema;
     /**
      * Whether this store has a recorded read relation bound for reconstruction.
      *
@@ -3785,6 +4105,24 @@ declare class Store<G extends GraphDef> {
      * success), not the global clock.
      */
     recordedNow(): Promise<RecordedInstant | undefined>;
+    /**
+     * Returns the durable graph revision used by graph branching. It is undefined
+     * until the first successful tracked write, which is itself a stable initial
+     * anchor. Unlike {@link recordedNow}, this is also available on a live Store
+     * created with `{ revisionTracking: true }`.
+     *
+     * @internal
+     */
+    revisionNow(): Promise<string | undefined>;
+    /**
+     * Returns the durable random namespace for this graph's revision clock. A
+     * tracked base token combines it with {@link revisionNow}, preventing a
+     * branch from one independent store from matching a coincident timestamp in
+     * another store.
+     *
+     * @internal
+     */
+    revisionOriginNow(): Promise<string>;
     /**
      * Returns a read-only {@link StoreView} pinned to an arbitrary public
      * temporal mode. Use {@link Store.asOf} for the common valid-time case;
@@ -3941,9 +4279,10 @@ declare class Store<G extends GraphDef> {
      *   {@link Store.withTransaction}). See {@link TransactionContext}
      *   for per-backend semantics; it is `undefined` only on the
      *   non-transactional fallback.
-     *   When the store was created with `{ history: true }`, `tx.sql` is
-     *   replaced by a fail-loud guard because raw SQL would bypass
-     *   recorded-time capture; use the typed collections inside
+     *   When the store was created with `{ history: true }` or
+     *   `{ revisionTracking: true }`, `tx.sql` is replaced by a fail-loud guard
+     *   because raw SQL would bypass recorded-time capture or revision tracking;
+     *   use the typed collections inside
      *   `transaction()` or {@link Store.withRecordedTransaction}.
      *
      * @example
@@ -3969,6 +4308,16 @@ declare class Store<G extends GraphDef> {
      * });
      * ```
      *
+     * **`tx.sql` shares the one pinned connection — await it, don't overlap it.**
+     * TypeGraph serializes the statements *its own* collections issue, so a
+     * `Promise.all` of graph writes is safe. A statement you issue through
+     * `tx.sql` bypasses that queue: run it concurrently with a graph write (or
+     * with another `tx.sql` statement) and two queries race on the one
+     * transaction connection — the exact overlap Postgres removes in `pg@9`.
+     * Await each `tx.sql` statement before starting the next write. TypeGraph
+     * cannot police this: it never sees the raw handle's traffic, so it also
+     * cannot drain a raw statement still in flight when the transaction commits.
+     *
      * **Backends without transactions.** When `backend.capabilities.transactions`
      * is `false` (Cloudflare D1, `drizzle-orm/neon-http`), this method runs the
      * callback against the same backend used outside `transaction()` — writes
@@ -3994,6 +4343,42 @@ declare class Store<G extends GraphDef> {
      */
     transaction<T>(this: HistoryStore<G>, fn: (tx: HistoryTransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<T>;
     transaction<T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Runs a transaction exactly like {@link transaction} and additionally
+     * returns a {@link TransactionOutcome} whose receipt summarizes the
+     * completed write intents on the transaction-scoped collection surface.
+     *
+     * A dedicated method (rather than an option on `transaction()`) keeps the
+     * return type tied to static dispatch: forwarding options through wrappers
+     * can never change what a call returns. See {@link TransactionReceipt} for
+     * exact count semantics.
+     *
+     * The receipt does not count writes that bypass the `tx.nodes.*` /
+     * `tx.edges.*` collections, such as direct backend writes, raw SQL, or
+     * import helpers. Adopted transactions (`withTransaction` /
+     * `withRecordedTransaction`) do not produce receipts in this version
+     * because their commit belongs to the caller. On non-transactional
+     * backends, the receipt is still returned, but it describes operations
+     * that individually committed rather than one atomic commit; if the
+     * callback rejects on such a backend, no receipt is returned even though
+     * earlier operations committed individually.
+     *
+     * For stores created with `{ history: true }`, `receipt.recorded` is the
+     * recorded commit instant this transaction allocated for the store's
+     * graph, or `undefined` when nothing was captured.
+     *
+     * @example
+     * ```typescript
+     * const outcome = await store.transactionWithReceipt(async (tx) => {
+     *   const alice = await tx.nodes.Person.create({ name: "Alice" });
+     *   return alice.id;
+     * });
+     * outcome.result; // Alice's id
+     * outcome.receipt.writes; // { nodes: { Person: 1 }, edges: {}, total: 1 }
+     * ```
+     */
+    transactionWithReceipt<T>(this: HistoryStore<G>, fn: (tx: HistoryTransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<TransactionOutcome<T>>;
+    transactionWithReceipt<T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<TransactionOutcome<T>>;
     /**
      * Adopts a caller-owned, already-open Drizzle transaction so the graph
      * store and the caller's relational writes commit or roll back as one
@@ -4036,6 +4421,14 @@ declare class Store<G extends GraphDef> {
      * }); // one COMMIT / ROLLBACK across both layers
      * ```
      *
+     * **The caller owns the connection — don't overlap writes on it.** The graph
+     * store and your Drizzle writes share the one connection the caller's
+     * transaction pinned. TypeGraph serializes the statements *its* collections
+     * issue, but your raw Drizzle statements (and any graph write run alongside
+     * them) are yours to sequence: a `Promise.all` mixing the two races two
+     * queries on that connection — the overlap Postgres removes in `pg@9`. Await
+     * each write before starting the next.
+     *
      * Not available when the store was created with `{ history: true }`: a
      * caller-owned transaction context would let writes happen after capture has
      * lost its flush point, so this throws `ConfigurationError`
@@ -4070,6 +4463,12 @@ declare class Store<G extends GraphDef> {
      * returns (e.g. retaining `tx` and writing once more before the caller's
      * COMMIT) throws rather than committing uncaptured — the post-flush write
      * cannot silently diverge history from live state.
+     *
+     * Like {@link Store.withTransaction}, the graph writes and any raw `tx.sql`
+     * statements share the caller's one pinned connection. TypeGraph serializes
+     * the statements its collections issue; sequence your own raw statements (and
+     * don't `Promise.all` them with graph writes) so two queries never race on
+     * that connection.
      */
     withRecordedTransaction<T>(this: HistoryStore<G>, externalTx: AdoptedTransaction, fn: (tx: HistoryTransactionContext<G>) => Promise<T>): Promise<T>;
     withRecordedTransaction<T>(externalTx: AdoptedTransaction, fn: (tx: TransactionContext<G>) => Promise<T>): Promise<T>;
@@ -4588,4 +4987,4 @@ declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView
     get edges(): RecordedStoreViewEdgeCollections<G>;
 }
 
-export { type GraphAlgorithms as $, type AliasMap as A, type BaseTraversalOptions as B, type ConstraintNames as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EmbeddingMetric as E, type EdgeFindByEndpointsOptions as F, type EdgeGetOrCreateByEndpointsOptions as G, type EdgeGetOrCreateByEndpointsResult as H, type EdgeIntrospection as I, type EdgeTemporalReads as J, type EdgeWrites as K, type EmbeddingSchema as L, type EmbeddingValue as M, type Node as N, type EmptyAliasMap as O, type EmptyEdgeAliasMap as P, type QueryCoordinateState as Q, type RecursiveAliasMap as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, ExecutableAggregateQuery as V, ExecutableQuery as W, type FieldAccessor as X, type FulltextSearchHit as Y, type FulltextSearchOptions as Z, type GetOrCreateAction as _, type EmbeddingIndexType as a, type SelectableEdge as a$, type GraphEdgeCollections as a0, type GraphNodeCollections as a1, type HistorySafeBackend as a2, type HistorySafeTransactionBackend as a3, type HistoryStore as a4, type HistoryStoreOptions as a5, type HistoryTransactionContext as a6, type HookContext as a7, type HybridFulltextOptions as a8, type HybridSearchHit as a9, type PathNode as aA, type Predicate as aB, PreparedQuery as aC, type PropsAccessor as aD, type QueryHookContext as aE, type QueryOptions as aF, type ReachableNode as aG, type ReachableOptions as aH, type RebuildFulltextOptions as aI, type RebuildFulltextResult as aJ, type ReclaimedVectorFieldEntry as aK, type RecordedInstant as aL, type RecordedReadStore as aM, RecordedStoreView as aN, type RecordedStoreViewEdgeCollection as aO, type RecordedStoreViewEdgeCollections as aP, type RecordedStoreViewNodeCollection as aQ, type RecordedStoreViewNodeCollections as aR, type RecursiveTraversalOptions as aS, type ReembedFunction as aT, type ReembedVectorFieldOptions as aU, type ReembedVectorFieldResult as aV, type SchemaIntrospection as aW, type SearchableMetadata as aX, type SearchableOptions as aY, type SearchableSchema as aZ, type SelectContext as a_, type HybridSearchOptions as aa, type HybridVectorOptions as ab, type IfExistsMode as ac, type InitialQueryBuilder as ad, type KindIntrospection as ae, type LiveStoreOptions as af, type MaterializeRemovalsEntry as ag, type MaterializeRemovalsOptions as ah, type MaterializeRemovalsResult as ai, type NeighborsOptions as aj, type NoRecordedCoordinate as ak, type NodeAccessor as al, type NodeAlias as am, type NodeBulkFindByIndexOptions as an, type NodeCollection as ao, type NodeCurrentReads as ap, type NodeGetOrCreateByConstraintOptions as aq, type NodeGetOrCreateByConstraintResult as ar, type NodeIdentifier as as, type NodeRef as at, type NodeTemporalReads as au, type NodeWrites as av, type OntologyIntrospection as aw, type OperationHookContext as ax, type PaginateOptions as ay, type PaginatedResult as az, type EdgeAliasMap as b, type SelectableNode as b0, type ShortestPathOptions as b1, type ShortestPathResult as b2, type StoreHooks as b3, type StoreOptions as b4, type StoreProjection as b5, type StoreRef as b6, StoreSearch as b7, StoreView as b8, type StoreViewCanReachOptions as b9, type VectorSearchHit as bA, type VectorSearchOptions as bB, asRecordedInstant as bC, createQueryBuilder as bD, createStore as bE, createStoreWithSchema as bF, createVerifiedStore as bG, defineSubgraphProject as bH, embedding as bI, exists as bJ, fieldRef as bK, getEmbeddingDimensions as bL, getSearchableMetadata as bM, inSubquery as bN, isEmbeddingSchema as bO, isParameterRef as bP, isSearchableSchema as bQ, notExists as bR, notInSubquery as bS, param as bT, searchable as bU, type StoreViewCoordinate as ba, type StoreViewDegreeOptions as bb, type StoreViewEdgeCollection as bc, type StoreViewEdgeCollections as bd, type StoreViewNeighborsOptions as be, type StoreViewNodeCollection as bf, type StoreViewNodeCollections as bg, type StoreViewReachableOptions as bh, type StoreViewShortestPathOptions as bi, type StoreViewSubgraphOptions as bj, type StreamOptions as bk, type SubgraphEdgeResult as bl, type SubgraphNodeResult as bm, type SubgraphOptions as bn, type SubgraphResult as bo, type SubsetEdge as bp, type SubsetNode as bq, type TemporalAlgorithmOptions as br, type TransactionContext as bs, type TraversalDirection as bt, type TypedEdgeCollection as bu, type TypedRecordedStoreViewEdgeCollection as bv, type TypedStoreViewEdgeCollection as bw, UnionableQuery as bx, type UpdateEdgeInput as by, type UpdateNodeInput as bz, QueryBuilder as c, type EmptyRecursiveAliasMap as d, type AggregateResult as e, type AlgorithmCyclePolicy as f, type AnyEdge as g, type AnyNode as h, type BatchResults as i, type BatchableQuery as j, type CreateEdgeInput as k, type CreateNodeInput as l, type DegreeOptions as m, type DynamicEdgeAccessor as n, type DynamicEdgeCollection as o, type DynamicEdgeType as p, type DynamicFieldBuilder as q, type DynamicNodeAccessor as r, type DynamicNodeCollection as s, type DynamicNodeType as t, type DynamicSelectableEdge as u, type DynamicSelectableNode as v, type Edge as w, type EdgeAccessor as x, type EdgeBatchReads as y, type EdgeCollection as z };
+export { type GetOrCreateAction as $, type AliasMap as A, type BaseTraversalOptions as B, type ConstraintNames as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EmbeddingMetric as E, type EdgeFindByEndpointsOptions as F, type EdgeGetOrCreateByEndpointsOptions as G, type HistoryStore as H, type EdgeGetOrCreateByEndpointsResult as I, type EdgeIntrospection as J, type EdgeTemporalReads as K, type EdgeWrites as L, type EmbeddingSchema as M, type Node as N, type EmbeddingValue as O, type EmptyAliasMap as P, type QueryCoordinateState as Q, type RecursiveAliasMap as R, Store as S, TraversalBuilder as T, type UniqueIntrospection as U, type EmptyEdgeAliasMap as V, ExecutableAggregateQuery as W, ExecutableQuery as X, type FieldAccessor as Y, type FulltextSearchHit as Z, type FulltextSearchOptions as _, type EmbeddingIndexType as a, type SelectContext as a$, type GraphAlgorithms as a0, type GraphEdgeCollections as a1, type GraphNodeCollections as a2, type HistorySafeBackend as a3, type HistorySafeTransactionBackend as a4, type HistoryStoreOptions as a5, type HistoryTransactionContext as a6, type HookContext as a7, type HybridFulltextOptions as a8, type HybridSearchHit as a9, type PathNode as aA, type Predicate as aB, PreparedQuery as aC, type PropsAccessor as aD, type QueryHookContext as aE, type QueryOptions as aF, type ReachableNode as aG, type ReachableOptions as aH, type RebuildFulltextOptions as aI, type RebuildFulltextResult as aJ, type ReclaimedVectorFieldEntry as aK, type RecordedInstant as aL, type RecordedReadStore as aM, RecordedStoreView as aN, type RecordedStoreViewEdgeCollection as aO, type RecordedStoreViewEdgeCollections as aP, type RecordedStoreViewNodeCollection as aQ, type RecordedStoreViewNodeCollections as aR, type RecursiveTraversalOptions as aS, type ReembedFunction as aT, type ReembedVectorFieldOptions as aU, type ReembedVectorFieldResult as aV, type SchemaIntrospection as aW, type SearchScopeOptions as aX, type SearchableMetadata as aY, type SearchableOptions as aZ, type SearchableSchema as a_, type HybridSearchOptions as aa, type HybridVectorOptions as ab, type IfExistsMode as ac, type InitialQueryBuilder as ad, type KindIntrospection as ae, type LiveStoreOptions as af, type MaterializeRemovalsEntry as ag, type MaterializeRemovalsOptions as ah, type MaterializeRemovalsResult as ai, type NeighborsOptions as aj, type NoRecordedCoordinate as ak, type NodeAccessor as al, type NodeAlias as am, type NodeBulkFindByIndexOptions as an, type NodeCollection as ao, type NodeCurrentReads as ap, type NodeGetOrCreateByConstraintOptions as aq, type NodeGetOrCreateByConstraintResult as ar, type NodeIdentifier as as, type NodeRef as at, type NodeTemporalReads as au, type NodeWrites as av, type OntologyIntrospection as aw, type OperationHookContext as ax, type PaginateOptions as ay, type PaginatedResult as az, type EdgeAliasMap as b, type SelectableEdge as b0, type SelectableNode as b1, type ShortestPathOptions as b2, type ShortestPathResult as b3, type StoreHooks as b4, type StoreOptions as b5, type StoreProjection as b6, type StoreRef as b7, StoreSearch as b8, StoreView as b9, UnionableQuery as bA, type UpdateEdgeInput as bB, type UpdateNodeInput as bC, type VectorSearchHit as bD, type VectorSearchOptions as bE, asRecordedInstant as bF, createQueryBuilder as bG, createStore as bH, createStoreWithSchema as bI, createVerifiedStore as bJ, defineSubgraphProject as bK, embedding as bL, exists as bM, fieldRef as bN, getEmbeddingDimensions as bO, getSearchableMetadata as bP, inSubquery as bQ, isEmbeddingSchema as bR, isParameterRef as bS, isSearchableSchema as bT, notExists as bU, notInSubquery as bV, param as bW, searchable as bX, type StoreViewCanReachOptions as ba, type StoreViewCoordinate as bb, type StoreViewDegreeOptions as bc, type StoreViewEdgeCollection as bd, type StoreViewEdgeCollections as be, type StoreViewNeighborsOptions as bf, type StoreViewNodeCollection as bg, type StoreViewNodeCollections as bh, type StoreViewReachableOptions as bi, type StoreViewShortestPathOptions as bj, type StoreViewSubgraphOptions as bk, type StreamOptions as bl, type SubgraphEdgeResult as bm, type SubgraphNodeResult as bn, type SubgraphOptions as bo, type SubgraphResult as bp, type SubsetEdge as bq, type SubsetNode as br, type TemporalAlgorithmOptions as bs, type TransactionContext as bt, type TransactionOutcome as bu, type TransactionReceipt as bv, type TraversalDirection as bw, type TypedEdgeCollection as bx, type TypedRecordedStoreViewEdgeCollection as by, type TypedStoreViewEdgeCollection as bz, QueryBuilder as c, type EmptyRecursiveAliasMap as d, type AggregateResult as e, type AlgorithmCyclePolicy as f, type AnyEdge as g, type AnyNode as h, type BatchResults as i, type BatchableQuery as j, type CreateEdgeInput as k, type CreateNodeInput as l, type DegreeOptions as m, type DynamicEdgeAccessor as n, type DynamicEdgeCollection as o, type DynamicEdgeType as p, type DynamicFieldBuilder as q, type DynamicNodeAccessor as r, type DynamicNodeCollection as s, type DynamicNodeType as t, type DynamicSelectableEdge as u, type DynamicSelectableNode as v, type Edge as w, type EdgeAccessor as x, type EdgeBatchReads as y, type EdgeCollection as z };