@nicia-ai/typegraph 0.37.0 → 0.38.0

package/dist/{store-view-X96Rd00T.d.cts → store-view-BoHqdHjB.d.cts}

@@ -1,283 +1,10 @@
-import { G as GraphDef, K as KindRegistry, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-nU1vTJLy.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-BM2ACfYO.cjs';
+import { G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes } from './define-graph-CzEvA_8F.cjs';
+import { S as SearchableMetadata, R as RecordedInstant, c as EmbeddingValue, l as ReadCoordinate } from './temporal-BC_NQV5Y.cjs';
+import { a as NodeType, A as AnyEdgeType, d as EdgeType, T as TemporalMode, E as EdgeRegistration, m as NodeId, K as KindEntity, g as EdgeId, N as NodeRegistration, l as KindAnnotations, o as UniquenessScope, f as Collation, e as Cardinality, j as EndpointExistence, G as GraphExtension } from './extension-types-BLEVH4SG.cjs';
+import { K as KindRegistry, S as SchemaManagerOptions, d as SchemaValidationResult } from './manager-nCEJiYBb.cjs';
 import { z } from 'zod';
-import { a_ as VectorSlot, be as ValueType, bf as PredicateExpression, ag as FulltextQueryMode, bg as VectorMetricType, Q as QueryAst, J as JsonPointer, P as FieldRef, aA as ParameterRef, ar as JsonPointerInput, G as GraphBackend, aT as TransactionBackend, aU as TraversalExpansion, c as SqlDialect, aP as SqlSchema, bh as Traversal, bi as NodePredicate, bj as ProjectedField, az as OrderSpec, bk as AggregateOrderSpec, bl as GroupBySpec, an as HybridFusionOptions, bm as RecursiveCyclePolicy, W as TraversalDirection$1, bn as NodeRow, aa as ExternalRecordedReadSource, bo as EdgeRow, X as AdoptedTransaction, L as AggregateExpr, aN as SortDirection, a3 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bp as VectorSlotMap, bq as RecordedReadBinding, br as SelectiveField, bs as ComposableQuery, bt as SetOperationType, bu as SetOperation, bv as VectorMetric, z as JsonSchema, bw as TransactionOptions } from './fulltext-strategy-C27vXaeB.cjs';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult, c as MaterializeSystemIndexesOptions } from './materialize-indexes-CuR3gAZb.cjs';
-
-/**
- * Embedding type for vector search.
- *
- * Creates a Zod-compatible schema for vector embeddings with
- * dimension validation and metadata for query compilation.
- */
-
-/**
- * Symbol used to brand embedding values at the type level.
- * This allows TypeScript to distinguish embedding arrays from regular
- * number arrays in the query builder type system.
- */
-declare const EMBEDDING_BRAND: unique symbol;
-/**
- * Branded embedding type for type-level distinction.
- * At runtime this is just `readonly number[]`, but TypeScript can
- * distinguish it from regular arrays for query builder typing.
- */
-type EmbeddingValue = readonly number[] & {
-    readonly [EMBEDDING_BRAND]: true;
-};
-/**
- * Symbol key for storing embedding dimensions on the schema.
- * This allows the schema introspector to detect embedding types
- * and extract dimension information.
- */
-declare const EMBEDDING_DIMENSIONS_KEY: "_embeddingDimensions";
-/**
- * Symbol key for storing the embedding's preferred index configuration
- * on the schema. The schema introspector reads this when auto-deriving
- * `VectorIndexDeclaration` entries at `defineGraph()` time.
- */
-declare const EMBEDDING_INDEX_KEY: "_embeddingIndex";
-/**
- * Distance metric used for vector similarity. Pinned at the embedding
- * brand because changing the metric usually means generating different
- * model output (e.g. cosine-normalized vs. raw inner-product), and the
- * stored index needs the same metric to score correctly.
- *
- * - `cosine`: cosine similarity. The default — works for most
- *   sentence-transformer / OpenAI-style embeddings that are already
- *   length-normalized.
- * - `l2`: Euclidean distance. Use when your model outputs vectors
- *   trained for L2 (e.g. some image embedding models).
- * - `inner_product`: dot-product distance. Use when your model outputs
- *   pre-normalized vectors AND you want to skip the cosine
- *   normalization step at query time.
- */
-type EmbeddingMetric = "cosine" | "l2" | "inner_product";
-/**
- * Vector index implementation. `hnsw` is the default and what pgvector
- * recommends for most workloads. `ivfflat` is the alternative for
- * larger datasets where memory is the bottleneck. `none` disables
- * automatic index creation for this embedding (the operator can still
- * call `backend.createVectorIndex` manually).
- */
-type EmbeddingIndexType = "hnsw" | "ivfflat" | "none";
-/**
- * Per-embedding configuration for the auto-derived
- * `VectorIndexDeclaration`. All fields are optional with sensible
- * defaults (`cosine` / `hnsw` / pgvector defaults: `m=16`,
- * `ef_construction=64`). Override only when your model or dataset has
- * a known reason to.
- */
-type EmbeddingIndexOptions = Readonly<{
-    /** Distance metric. Default `"cosine"`. */
-    metric?: EmbeddingMetric;
-    /** Vector index implementation. Default `"hnsw"`. */
-    indexType?: EmbeddingIndexType;
-    /** HNSW `m` parameter — max connections per layer. Default `16`. */
-    m?: number;
-    /** HNSW `ef_construction` parameter — build-time search depth. Default `64`. */
-    efConstruction?: number;
-    /** IVFFlat `lists` parameter — number of inverted-list partitions. */
-    lists?: number;
-}>;
-/**
- * Resolved embedding index configuration with all defaults applied.
- * What gets attached to the brand and read by the auto-derivation pass.
- */
-type ResolvedEmbeddingIndex = Readonly<{
-    metric: EmbeddingMetric;
-    indexType: EmbeddingIndexType;
-    m: number;
-    efConstruction: number;
-    lists: number | undefined;
-}>;
-/**
- * A Zod schema for vector embeddings with attached dimension metadata.
- * Uses the branded EmbeddingValue type for type-level distinction.
- */
-type EmbeddingSchema<D extends number = number> = z.ZodType<EmbeddingValue> & Readonly<{
-    [EMBEDDING_DIMENSIONS_KEY]: D;
-    [EMBEDDING_INDEX_KEY]: ResolvedEmbeddingIndex;
-}>;
-/**
- * Creates a Zod schema for vector embeddings.
- *
- * The dimension is validated at runtime and attached as metadata
- * for the schema introspector and query compiler.
- *
- * @param dimensions - The number of dimensions (e.g., 384, 512, 768, 1536, 3072)
- * @returns A Zod schema that validates embedding arrays
- *
- * @example
- * ```typescript
- * // OpenAI ada-002 embeddings
- * const Document = defineNode("Document", {
- *   schema: z.object({
- *     title: z.string(),
- *     embedding: embedding(1536),
- *   }),
- * });
- *
- * // Sentence transformers
- * const Sentence = defineNode("Sentence", {
- *   schema: z.object({
- *     text: z.string(),
- *     embedding: embedding(384), // all-MiniLM-L6-v2
- *   }),
- * });
- *
- * // Optional embeddings are supported
- * const Article = defineNode("Article", {
- *   schema: z.object({
- *     content: z.string(),
- *     embedding: embedding(1536).optional(),
- *   }),
- * });
- * ```
- */
-declare function embedding<D extends number>(dimensions: D, options?: EmbeddingIndexOptions): EmbeddingSchema<D>;
-/**
- * Checks if a value is an embedding schema.
- */
-declare function isEmbeddingSchema(value: unknown): value is EmbeddingSchema;
-/**
- * Gets the dimensions from an embedding schema.
- * Returns undefined if the schema is not an embedding schema.
- */
-declare function getEmbeddingDimensions(schema: z.ZodType): number | undefined;
-/**
- * Enumerates every embedding `(kind, field)` slot a graph declares, as a
- * fully-resolved {@link VectorSlot}. The single source of truth for "what
- * vector slots does this graph have?", shared by the privileged boot
- * materializer (`materializeVectorContributions`) and the verified-attach
- * gate (`assertVectorContributionsInitialized`) so the two can never
- * provision and assert different sets. Walks `graph.nodes` and reuses
- * {@link resolveEmbeddingFields} per node schema.
- */
-declare function resolveGraphVectorSlots(graph: GraphDef): readonly VectorSlot[];
-
-/**
- * Searchable string type for fulltext search.
- *
- * `searchable()` attaches `SearchableMetadata` to a plain Zod string so
- * the schema introspector and fulltext-sync layer can keep the fulltext
- * index in sync with node data.
- *
- * The metadata is preserved by Zod's `.meta()` across refinements
- * (`.min(1)`, `.trim()`, `.regex(...)`) and wrapper types (`.optional()`,
- * `.nullable()`, `.default(...)`, pipes) — `getSearchableMetadata()` walks
- * these variants so runtime indexing works whether or not a user chains
- * additional modifiers.
- *
- * `$fulltext` is exposed on every `NodeAccessor` at the type level; a
- * runtime guard throws a clear error if you call `.matches()` on an
- * alias whose node kind has no `searchable()` fields. This is simpler
- * and more predictable than a type-level brand that silently disappears
- * behind `.min(1)`.
- *
- * @example
- * ```typescript
- * const Document = defineNode("Document", {
- *   schema: z.object({
- *     title: searchable({ language: "english" }),
- *     body: searchable().min(1),
- *     authorId: z.string(),
- *   }),
- * });
- * ```
- */
-
-declare const SEARCHABLE_FIELD_KEY: "_searchableField";
-declare const DEFAULT_SEARCHABLE_LANGUAGE: "english";
-/**
- * Searchable field metadata attached to a Zod schema.
- */
-type SearchableMetadata = Readonly<{
-    /**
-     * Language for stemming / tokenization.
-     * Postgres: passed to `to_tsvector(regconfig, ...)`.
-     * SQLite FTS5: tokenizer is fixed at table-create time, so the
-     * language is recorded but not applied per-row.
-     */
-    language: string;
-}>;
-/**
- * Branded Zod string schema. The `SEARCHABLE_FIELD_KEY` marker is
- * attached both as a direct property (fast runtime check) and via Zod's
- * `.meta()` (so it survives `.min()`, `.trim()`, etc.).
- */
-type SearchableSchema = z.ZodString & Readonly<{
-    [SEARCHABLE_FIELD_KEY]: SearchableMetadata;
-}>;
-type SearchableOptions = Readonly<{
-    language?: string;
-}>;
-/**
- * Creates a Zod string schema tagged as fulltext-searchable.
- *
- * The returned schema passes runtime validation unchanged — the tag only
- * affects how TypeGraph treats the field for indexing and search. Pair
- * with `.optional()` / `.nullable()` / `.min()` / `.trim()` exactly like
- * any other Zod string; `getSearchableMetadata()` finds the metadata
- * through all of them.
- */
-declare function searchable(options?: SearchableOptions): SearchableSchema;
-declare function isSearchableSchema(value: unknown): value is SearchableSchema;
-declare function getSearchableMetadata(schema: z.ZodType): SearchableMetadata | undefined;
-
-declare const RECORDED_INSTANT_BRAND: unique symbol;
-/**
- * A canonical UTC ISO-8601 recorded-time instant (`YYYY-MM-DDTHH:mm:ss.sssZ`),
- * nominally branded so it can only originate from a recorded-time source —
- * {@link Store.recordedNow} or an explicit {@link asRecordedInstant} — never an
- * ad-hoc wall-clock string.
- *
- * The recorded commit clock is a logical, monotonic per-graph instant that can
- * run briefly ahead of wall time under bursty same-millisecond writes, so a raw
- * `new Date().toISOString()` may sort *before* the most recent commits and
- * silently omit them. The brand turns that footgun into a compile error:
- * `store.asOfRecorded` accepts only a `RecordedInstant`, so a bare wall-clock
- * string no longer type-checks — callers reach for `await store.recordedNow()`
- * (the monotonic high-water mark) or {@link asRecordedInstant} instead.
- */
-type RecordedInstant = string & {
-    readonly [RECORDED_INSTANT_BRAND]: "RecordedInstant";
-};
-/**
- * Brands a canonical UTC ISO-8601 string as a {@link RecordedInstant}.
- *
- * The escape hatch for an instant that round-trips through untyped storage:
- * captured from {@link Store.recordedNow}, persisted as a plain string, read
- * back, and replayed into `asOfRecorded`. Validates the canonical form eagerly —
- * the same check `asOfRecorded` applies — so a malformed value fails here, at the
- * brand site, rather than deeper in a read. Does *not* assert the instant is a
- * real captured commit; it only guarantees the value is well-formed enough to
- * compare correctly against the recorded relations.
- *
- * @throws {ValidationError} when `value` is not a canonical UTC ISO-8601 string.
- */
-declare function asRecordedInstant(value: string): RecordedInstant;
-/**
- * The single opaque temporal coordinate every pinned read is resolved
- * against. It carries the valid-time axis plus an optional recorded/system-time
- * axis, so every surface can inject one coordinate object instead of threading
- * each temporal dimension separately.
- */
-type ReadCoordinate = Readonly<{
-    /**
-     * The valid-time axis: a resolved temporal mode and (only for `"asOf"`) the
-     * instant it is pinned to.
-     */
-    valid: Readonly<{
-        mode: TemporalMode;
-        /** Defined only when `mode` is `"asOf"`. */
-        asOf?: string;
-    }>;
-    /** The recorded/system-time axis. Defined only for recorded-pinned views. */
-    recorded?: Readonly<{
-        asOf: RecordedInstant;
-    }>;
-}>;
+import { bp as ValueType, bq as PredicateExpression, ad as FulltextQueryMode, br as VectorMetricType, Q as QueryAst, J as JsonPointer, K as FieldRef, ay as ParameterRef, b1 as TraversalExpansion, G as GraphBackend, S as SqlDialect, aU as SqlSchema, bs as Traversal, bt as NodePredicate, bu as ProjectedField, ax as OrderSpec, bv as AggregateOrderSpec, bw as GroupBySpec, ak as HybridFusionOptions, ao as JsonPointerInput, bx as RecursiveCyclePolicy, T as TraversalDirection$1, a_ as TransactionBackend, a7 as ExternalRecordedReadSource, by as NodeRow, bz as EdgeRow, b0 as TransactionReadBackend, H as AggregateExpr, aN as SortDirection, a0 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bA as VectorSlotMap, bB as RecordedReadBinding, bC as SelectiveField, bD as ComposableQuery, bE as SetOperationType, bF as SetOperation, bG as VectorMetric, x as JsonSchema, B as BackendCapabilities, a$ as TransactionOptions, A as AdapterBackend } from './index-CrFL_ENI.cjs';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult, c as MaterializeSystemIndexesOptions } from './materialize-indexes-ExQ6OrAh.cjs';
 
 type FieldTypeInfo = Readonly<{
     valueType: ValueType;
@@ -1365,6 +1092,14 @@ 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
@@ -1403,9 +1138,11 @@ type StoreOptions = LiveStoreOptions | HistoryStoreOptions;
  *
  * Generic over the held value (typically `Store<G>`) so the store
  * module can refer to it without importing the `Store` class into
- * `types.ts`.
+ * `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<T> {
+interface StoreRef<in out T> {
     current: T;
 }
 /**
@@ -2099,90 +1836,36 @@ type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
 /**
  * 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 a portable caller branches on capability instead of truthiness-testing
- * `tx.sql` (which is present-but-throwing under history / revision tracking).
- * See {@link TransactionContext.sqlAvailability} for the per-value semantics.
+ * in, so an adapter caller branches on capability instead of truthiness-testing
+ * `tx.sql`. Under history / revision tracking the public type makes `tx.sql`
+ * unusable (`sql?: never`), while the runtime object keeps a fail-loud getter
+ * 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<{
+    sql?: never;
+    sqlAvailability: "history" | "revisionTracking";
+}> | Readonly<{
+    sql?: undefined;
+    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>;
+}>;
 /**
- * A typed transaction context with collection API.
- *
- * Provides the same `tx.nodes.*` and `tx.edges.*` API as the Store,
- * but operations are executed within the transaction scope.
- *
- * `tx.sql` is the raw Drizzle handle **bound to this same
- * transaction** — use it to write the caller's own relational tables
- * inside the graph-owned transaction so both layers commit or roll
- * back together (the graph-owned counterpart of
- * {@link Store.withTransaction}, where the caller owns the boundary):
- *
- * ```typescript
- * await store.transaction(async (tx) => {
- *   await tx.nodes.Document.update(documentId, props);
- *   // `tx.sql` is the `AdoptedTransaction` union — cast to your
- *   // concrete Drizzle database type at the call site.
- *   const sqlTx = tx.sql as NodePgDatabase;
- *   await sqlTx.insert(documentVersions).values(versionRow);
- *   await sqlTx.insert(changeEvents).values(eventRow);
- * });
- * ```
- *
- * Per-backend semantics:
- * - **Postgres / libsql** (async drivers): `tx.sql` is the Drizzle
- *   transaction handle. Using the outer `db` instead would write on a
- *   *different* connection and silently escape the transaction — so
- *   `tx.sql` is a correctness requirement there.
- * - **better-sqlite3**: the single connection, framed by TypeGraph's
- *   `BEGIN`/`COMMIT`/`ROLLBACK`.
- * - **Durable Objects (`do-sqlite`)**: the bound Drizzle handle; the
- *   storage transaction is ambient, so writing the outer `db` also
- *   enlists — `tx.sql` is the explicit, portable form.
- *
- * It is `undefined` only on the non-transactional fallback
- * (`backend.capabilities.transactions === false` — e.g. Cloudflare
- * D1, `drizzle-orm/neon-http`), where `store.transaction()` runs the
- * callback with no atomicity and there is no transaction to enlist.
- * 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 }` or
- * `{ revisionTracking: true }`, `tx.sql` is **present but throwing**: every
- * access raises {@link ConfigurationError} because raw SQL would bypass
- * recorded-time capture or the revision anchor. The static type marks it
- * `sql?: never` so a mistaken `tx.sql.run(...)` fails to typecheck; at runtime
- * it is a fail-loud guard, not `undefined`. Use the typed `tx.nodes` /
- * `tx.edges` collections inside `transaction()`, or
- * `store.withRecordedTransaction(externalTx, fn)` when the relational layer
- * owns the transaction boundary.
- *
- * **Feature detection — branch on {@link sqlAvailability}, not on `tx.sql`'s
- * truthiness.** Because `tx.sql` is present-but-throwing under history or
- * revision tracking, `if (tx.sql)` reads truthy and then throws. The honest
- * discriminant is `tx.sqlAvailability`:
- *
- * ```typescript
- * await store.transaction(async (tx) => {
- *   switch (tx.sqlAvailability) {
- *     case "available": {
- *       const sqlTx = tx.sql as NodePgDatabase; // usable raw handle
- *       await sqlTx.insert(rows).values(row);
- *       break;
- *     }
- *     case "unavailable":
- *       // non-transactional backend: tx.sql === undefined, no atomicity
- *       await fallbackWithoutAtomicity();
- *       break;
- *     case "history":
- *     case "revisionTracking":
- *       // raw SQL disabled here — write your own tables through the external
- *       // handle passed to store.withRecordedTransaction instead
- *       break;
- *   }
- * });
- * ```
- *
- * `tx.sql === undefined` still means exactly "non-transactional fallback"
- * (`sqlAvailability === "unavailable"`).
+ * 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
@@ -2193,53 +1876,33 @@ type SqlAvailability = "available" | "history" | "revisionTracking" | "unavailab
  * });
  * ```
  */
-type TransactionContext<G extends GraphDef> = Readonly<{
+type TransactionCollections<G extends GraphDef> = Readonly<{
+    [TRANSACTION_RUNTIME]: TransactionRuntime;
     nodes: GraphNodeCollections<G>;
     edges: GraphEdgeCollections<G>;
-    sql?: AdoptedTransaction;
-    /**
-     * Honest capability discriminant for `tx.sql` on this transaction. Prefer
-     * this over truthiness-testing `tx.sql`, which is present-but-throwing under
-     * history capture or revision tracking.
-     *
-     * - `"available"` — `tx.sql` is the usable raw handle bound to this
-     *   transaction.
-     * - `"history"` — history capture is on; `tx.sql` is present but every access
-     *   throws {@link ConfigurationError} (`details.code`
-     *   `RECORDED_CAPTURE_RAW_SQL_DISABLED`). Use `tx.nodes` / `tx.edges`, or
-     *   `store.withRecordedTransaction` with your own external handle for
-     *   cross-store atomicity.
-     * - `"revisionTracking"` — same shape as `"history"` (`details.code`
-     *   `REVISION_TRACKING_RAW_SQL_DISABLED`).
-     * - `"unavailable"` — non-transactional fallback
-     *   (`backend.capabilities.transactions === false`, e.g. Cloudflare D1,
-     *   `drizzle-orm/neon-http`); `tx.sql` is `undefined` and there is no
-     *   atomicity.
-     */
-    sqlAvailability: SqlAvailability;
-    /**
-     * The transaction-scoped backend the collections are bound to, for advanced
-     * raw reads that must observe the transaction's snapshot (e.g. graph-merge's
-     * in-transaction base@V re-validation). On the non-transactional fallback it
-     * is the store's plain backend — reads work, but there is no snapshot.
-     */
-    backend: TransactionBackend;
+    /** Read-only backend projection bound to the same graph transaction. */
+    backend: TransactionReadBackend;
     /**
      * 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.
+     * `Store.getNodeCollection`. Returns `undefined` when `kind` is not
+     * registered in this graph.
      */
-    runNodeOperationHooks<T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>): Promise<T>;
+    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`,
@@ -2274,6 +1937,10 @@ type ScopedMeasure<Context> = <T>(fn: (scoped: Context) => Promise<T>) => Promis
 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.
@@ -2424,7 +2091,7 @@ declare class ExecutableAggregateQuery<G extends GraphDef, Aliases extends Alias
         params: readonly unknown[];
     }>;
     /**
-     * Compiles the query to a Drizzle SQL object.
+     * Compiles the query to TypeGraph's database-independent SQL fragment.
      */
     compile(): CompiledSelectSql;
     /**
@@ -2736,10 +2403,10 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
         params: readonly unknown[];
     }>;
     /**
-     * Compiles the query to a Drizzle SQL object.
+     * Compiles the query to TypeGraph's database-independent SQL fragment.
      *
-     * Returns a Drizzle SQL object that can be executed directly
-     * with db.all(), db.get(), etc.
+     * Pass the result to a GraphBackend, or use toSQL() to render SQL text and
+     * parameters for the configured dialect.
      */
     compile(): CompiledSelectSql;
     /**
@@ -3362,6 +3029,77 @@ type WeaklyConnectedComponentMembership = Readonly<{
     /** Number of visible nodes in this component. */
     size: number;
 }>;
+/**
+ * Options for deterministic Community Detection using Label Propagation
+ * (CDLP).
+ *
+ * Selected edges are treated as undirected. Every synchronous round assigns
+ * each node the most frequent label among its visible neighbors from the
+ * previous round; ties resolve to the minimum `(id, kind)` label under binary
+ * ordering. Isolated nodes retain their own identity as a singleton label.
+ */
+type LabelPropagationOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeMemoryOptions & Readonly<{
+    /** Edge kinds whose undirected projection supplies neighbor votes. */
+    edges: readonly EdgeKinds<G>[];
+    /** Optional node kinds defining the induced subgraph to analyze. */
+    nodeKinds?: readonly NodeKinds<G>[];
+    /** Maximum synchronous rounds. Defaults to `1000`. */
+    maxIterations?: number;
+    /**
+     * Completion contract when `maxIterations` rounds elapse without
+     * convergence. `"throw"` (default) raises
+     * `GraphAlgorithmConvergenceError` — immediately once a periodic
+     * oscillation is detected, since no budget can converge it. `"return"`
+     * yields the exact labeling after `maxIterations` synchronous rounds,
+     * matching fixed-round Graphalytics CDLP; synchronous rounds are
+     * deterministic, so that labeling is identical on every backend.
+     */
+    onMaxIterations?: "throw" | "return";
+}>;
+type InternalLabelPropagationOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<LabelPropagationOptions<G>, keyof TemporalAlgorithmOptions>;
+/** One visible node's membership in a deterministic CDLP community. */
+type LabelPropagationMembership = Readonly<{
+    id: string;
+    kind: string;
+    /** Final propagated label id. */
+    labelId: string;
+    /** Kind paired with `labelId`; node identity is `(kind, id)`. */
+    labelKind: string;
+}>;
+/** Options shared by global and personalized PageRank. */
+type PageRankOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeMemoryOptions & Readonly<{
+    /** Edge kinds defining the transition graph. */
+    edges: readonly EdgeKinds<G>[];
+    /** Optional node kinds defining the induced subgraph to rank. */
+    nodeKinds?: readonly NodeKinds<G>[];
+    /** Transition direction. Defaults to `"out"`. */
+    direction?: TraversalDirection;
+    /** Probability of following an edge. Defaults to `0.85`. */
+    dampingFactor?: number;
+    /** Maximum accepted per-node score change. Defaults to `1e-8`. */
+    tolerance?: number;
+    /** Maximum power-iteration rounds before throwing. Defaults to `1000`. */
+    maxIterations?: number;
+}>;
+type InternalPageRankOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<PageRankOptions<G>, keyof TemporalAlgorithmOptions>;
+/** One weighted teleport target for personalized PageRank. */
+type PersonalizedPageRankSeed<G extends GraphDef> = Readonly<{
+    id: string;
+    kind: NodeKinds<G>;
+    /** Relative teleport weight. Defaults to `1`; must be finite and positive. */
+    weight?: number;
+}>;
+/** Personalized PageRank options with one or more weighted teleport seeds. */
+type PersonalizedPageRankOptions<G extends GraphDef> = PageRankOptions<G> & Readonly<{
+    seeds: readonly PersonalizedPageRankSeed<G>[];
+}>;
+type InternalPersonalizedPageRankOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<PersonalizedPageRankOptions<G>, keyof TemporalAlgorithmOptions>;
+/** One visible node's normalized PageRank score. */
+type PageRankScore = Readonly<{
+    id: string;
+    kind: string;
+    score: number;
+}>;
 
 /**
  * Raw node id or any object with an `id: string` field. Covers `Node`,
@@ -3439,6 +3177,11 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      * With `direction: "both"` (default), self-loops contribute once.
      */
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
+    /**
+     * Runs deterministic synchronous label propagation over an undirected
+     * projection of the selected edge kinds.
+     */
+    labelPropagation: (options: LabelPropagationOptions<G>) => Promise<readonly LabelPropagationMembership[]>;
     /**
      * Computes exact weakly connected components over the selected edge kinds.
      *
@@ -3446,6 +3189,15 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      * `backend.capabilities.graphAnalytics.supported`.
      */
     weaklyConnectedComponents: (options: WeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
+    /**
+     * Computes global PageRank over the visible induced graph. Scores sum to
+     * approximately one and are returned from highest to lowest.
+     */
+    pageRank: (options: PageRankOptions<G>) => Promise<readonly PageRankScore[]>;
+    /**
+     * Computes PageRank with teleport mass distributed across weighted seeds.
+     */
+    personalizedPageRank: (options: PersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
 }>;
 type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
     shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: InternalShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
@@ -3454,7 +3206,10 @@ type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
     canReach: (from: NodeIdentifier, to: NodeIdentifier, options: InternalBaseTraversalOptions<G>) => Promise<boolean>;
     neighbors: (node: NodeIdentifier, options: InternalNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
     degree: (node: NodeIdentifier, options?: InternalDegreeOptions<G>) => Promise<number>;
+    labelPropagation: (options: InternalLabelPropagationOptions<G>) => Promise<readonly LabelPropagationMembership[]>;
     weaklyConnectedComponents: (options: InternalWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
+    pageRank: (options: InternalPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
+    personalizedPageRank: (options: InternalPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
 }>;
 
 type RebuildFulltextOptions = Readonly<{
@@ -3492,6 +3247,16 @@ 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
@@ -3771,6 +3536,20 @@ declare class StoreSearch<G extends GraphDef> {
     rebuildFulltext<K extends string>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
 }
 
+/**
+ * Members that are safe to expose through a history-enabled adapter Store.
+ *
+ * Graph entity writes remain because the source is the capture-wrapped
+ * backend. Direct raw SQL, native import, graph clearing, and nested backend
+ * transactions stay internal because each can mutate live rows without a
+ * corresponding capture flush.
+ */
+declare const HISTORY_STORE_BACKEND_KEYS: readonly ["assertRuntimeContributionsInitialized", "assertVectorSlotInitialized", "assertVectorSlotsInitialized", "bootstrapTables", "capabilities", "checkUnique", "checkUniqueBatch", "claimIndexMaterialization", "close", "commitSchemaVersion", "compileSql", "countEdgesByKind", "countEdgesFrom", "countNodesByKind", "createVectorIndex", "deleteEdge", "deleteEdgesBatch", "deleteEmbedding", "deleteFulltext", "deleteFulltextBatch", "deleteNode", "deleteUnique", "deleteVectorSlotContribution", "dialect", "dropVectorIndex", "edgeExistsBetween", "ensureContributionMaterializationsTable", "ensureFulltextTable", "ensureIndexMaterializationsTable", "ensureKindRemovalsTable", "ensureReconciliationMarkersTable", "ensureRevisionOriginsTable", "ensureRuntimeContributions", "ensureVectorSlotContribution", "ensureVectorSlotContributions", "execute", "executeTemporaryStatement", "findEdgesByKind", "findEdgesConnectedTo", "findNodesByKind", "fulltextSearch", "fulltextStrategy", "getActiveSchema", "getAllKindRemovals", "getContributionMaterialization", "getEdge", "getEdges", "getIndexMaterialization", "getIndexMaterializations", "getNode", "getNodes", "getPendingKindRemovals", "getReconciliationMarker", "getSchemaVersion", "hardDeleteEdge", "hardDeleteEdgesBatch", "hardDeleteNode", "hybridSearch", "insertEdge", "insertEdgeNoReturn", "insertEdgesBatch", "insertEdgesBatchReturning", "insertNode", "insertNodeNoReturn", "insertNodesBatch", "insertNodesBatchReturning", "insertUnique", "insertUniqueBatch", "recordContributionMaterialization", "recordIndexMaterialization", "recordKindRemoval", "refreshStatistics", "releaseIndexMaterializationClaim", "setActiveVersion", "setReconciliationMarker", "tableNames", "updateEdge", "updateNode", "upsertEmbedding", "upsertEmbeddingBatch", "upsertFulltext", "upsertFulltextBatch", "vectorSearch", "vectorStrategy"];
+type HistoryStoreBackendMember = (typeof HISTORY_STORE_BACKEND_KEYS)[number];
+type UnsafeHistoryStoreBackendMember = "clearGraph" | "executeDdl" | "executeRaw" | "executeStatement" | "transaction" | "trustedImport";
+type UnclassifiedHistoryStoreBackendMember = Exclude<keyof GraphBackend, HistoryStoreBackendMember | UnsafeHistoryStoreBackendMember>;
+type HistoryStoreBackend = UnclassifiedHistoryStoreBackendMember extends never ? Readonly<Pick<GraphBackend, HistoryStoreBackendMember>> : never;
+
 /**
  * `store.introspect()` — unified read of the merged schema.
  *
@@ -3846,6 +3625,17 @@ type UniqueIntrospection = Readonly<{
     collation: Collation;
 }>;
 
+/**
+ * Data-cleanup phase for `store.removeKinds()`.
+ *
+ * The removeKinds verb commits the new schema atomically (millisecond
+ * budget); the data deletion happens here, scoped per-deployment via
+ * the `typegraph_kind_removals` status table. Splitting the verbs
+ * mirrors how `materializeIndexes` complements `evolve`: schema
+ * commits are atomic and fast, data work is bounded by row count and
+ * deferrable / parallelizable.
+ */
+
 type MaterializeRemovalsOptions = Readonly<{
     /** Restrict to specific kind names. */
     kinds?: readonly string[];
@@ -3883,6 +3673,14 @@ type MaterializeRemovalsResult = Readonly<{
     reclaimedVectorFields: readonly ReclaimedVectorFieldEntry[];
 }>;
 
+/**
+ * Subgraph Extraction
+ *
+ * Extracts a typed subgraph from a root node by traversing a set of edge kinds.
+ * Uses a recursive CTE for BFS traversal with cycle detection, then hydrates
+ * the reachable nodes and connecting edges in two parallel queries.
+ */
+
 /**
  * Discriminated union of all Node runtime types in a graph.
  *
@@ -4045,6 +3843,24 @@ type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>,
     reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
 }>;
 
+declare const STORE_RUNTIME: unique symbol;
+/**
+ * @internal Operations used by Store-owned views. The port is absent from the
+ * public Store contract and non-enumerable at runtime. JavaScript reflection
+ * can still discover symbol properties, so this is an unsupported internal
+ * surface rather than a security boundary.
+ */
+type StoreRuntime<G extends GraphDef> = Readonly<{
+    backend: GraphBackend;
+    sealedQuery: (coordinate: ReadCoordinate) => InitialQueryBuilder<G, "sealed">;
+    recordedNodeGetById: <N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate) => Promise<Node<N> | undefined>;
+    recordedNodeGetByIds: <N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate) => Promise<readonly (Node<N> | undefined)[]>;
+    recordedEdgeGetById: <E extends AnyEdgeType>(kind: string, id: EdgeId<E>, coordinate: ReadCoordinate) => Promise<Edge<E> | undefined>;
+    recordedEdgeGetByIds: <E extends AnyEdgeType>(kind: string, ids: readonly EdgeId<E>[], coordinate: ReadCoordinate) => Promise<readonly (Edge<E> | undefined)[]>;
+    subgraphAtCoordinate: <const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: InternalSubgraphOptions<G, EK, NK, P>) => Promise<SubgraphResult<G, NK, EK, P>>;
+    algorithmsAtCoordinate: (coordinate: ReadCoordinate) => InternalGraphAlgorithms<G>;
+}>;
+
 /**
  * Main Store implementation for TypeGraph.
  *
@@ -4056,10 +3872,6 @@ type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>,
  * - Transaction handling
  */
 
-type StoreSchemaMetadata = Readonly<{
-    schemaVersion: number | undefined;
-    schemaHash: string | undefined;
-}>;
 /**
  * The Store provides typed access to a TypeGraph database.
  *
@@ -4119,1003 +3931,126 @@ type ReembedVectorFieldResult = Readonly<{
     /** Number of nodes whose embedding was re-written (0 without `embed`). */
     reembedded: number;
 }>;
-declare class Store<G extends GraphDef> {
-    #private;
-    constructor(graph: G, backend: GraphBackend, options?: StoreOptions, schemaMetadata?: StoreSchemaMetadata);
-    /** The graph definition */
-    get graph(): G;
-    /** The graph ID */
-    get graphId(): string;
-    /** The kind registry for ontology lookups */
-    get registry(): KindRegistry;
-    /** The database backend */
-    get backend(): GraphBackend;
-    /**
-     * Whether recorded-time capture is enabled for this store.
-     *
-     * @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.
-     *
-     * @internal
-     */
-    get recordedReadBound(): boolean;
-    /**
-     * Node collections for ergonomic CRUD operations.
-     *
-     * @example
-     * ```typescript
-     * // Create a node
-     * const person = await store.nodes.Person.create({ name: "Alice" });
-     *
-     * // Get by ID
-     * const fetched = await store.nodes.Person.getById(person.id);
-     *
-     * // Find all
-     * const people = await store.nodes.Person.find({ limit: 10 });
-     * ```
-     */
-    get nodes(): GraphNodeCollections<G>;
-    /**
-     * Edge collections for ergonomic CRUD operations.
-     *
-     * @example
-     * ```typescript
-     * // Create an edge
-     * const edge = await store.edges.worksAt.create(
-     *   { kind: "Person", id: person.id },
-     *   { kind: "Company", id: company.id },
-     *   { role: "Engineer" }
-     * );
-     *
-     * // Find edges from a node
-     * const edges = await store.edges.worksAt.findFrom({ kind: "Person", id: person.id });
-     * ```
-     */
-    get edges(): GraphEdgeCollections<G>;
-    /**
-     * Tier 1 graph algorithms: shortest path, reachability, neighborhoods, and
-     * degree centrality.
-     *
-     * Traversal calls use the iterative graph-operation substrate: a set-based
-     * breadth-first frontier backed by a temporary working table, or a chunked
-     * inline relation when the backend cannot pin a transactional connection.
-     * `degree` uses a single count query. The facade is built lazily on first
-     * access and cached for the lifetime of the store.
-     *
-     * @example
-     * ```typescript
-     * const path = await store.algorithms.shortestPath(alice, bob, {
-     *   edges: ["knows"],
-     * });
-     *
-     * const friends = await store.algorithms.neighbors(alice, {
-     *   edges: ["knows"],
-     *   depth: 2,
-     * });
-     * ```
-     */
-    get algorithms(): GraphAlgorithms<G>;
-    /**
-     * Returns the node collection for the given kind, or undefined if the kind
-     * is not registered in this graph.
-     *
-     * Use this for runtime string-keyed access when the kind is not known at
-     * compile time (e.g., iterating all kinds, resolving from edge metadata,
-     * dynamic admin UIs). For the post-evolve "I just added this kind, give
-     * me the collection" pattern, prefer `getNodeCollectionOrThrow` — it
-     * throws `KindNotFoundError` instead of forcing a null-check.
-     */
-    getNodeCollection(kind: string): DynamicNodeCollection | undefined;
-    /**
-     * Returns the node collection for the given kind. Throws
-     * `KindNotFoundError` when the kind is not registered.
-     *
-     * The dominant graph-extension-kind access pattern: `await store.evolve(...)`
-     * returns a new store, the caller immediately operates on the new
-     * kind, and the null-check the optional variant requires is busywork.
-     */
-    getNodeCollectionOrThrow(kind: string): DynamicNodeCollection;
-    /**
-     * Returns the edge collection for the given kind, or undefined if the kind
-     * is not registered in this graph.
-     *
-     * Use this for runtime string-keyed access when the kind is not known at
-     * compile time. For post-evolve access, prefer `getEdgeCollectionOrThrow`.
-     */
-    getEdgeCollection(kind: string): DynamicEdgeCollection | undefined;
-    /**
-     * Returns the edge collection for the given kind. Throws
-     * `KindNotFoundError` when the kind is not registered.
-     */
-    getEdgeCollectionOrThrow(kind: string): DynamicEdgeCollection;
-    /**
-     * Returns the Zod props schema for the given node kind, or `undefined`
-     * if the kind is not registered. Identity-preserving: returns the
-     * exact instance used by `.create()` / `.update()`, so a `parse()`
-     * surfaces the same underlying Zod issues that `ValidationError`
-     * wraps (operation-level checks like uniqueness and endpoints stay
-     * in `collection.create`).
-     */
-    getNodePropsSchema(kind: string): z.ZodObject<z.ZodRawShape> | undefined;
-    /**
-     * Returns the Zod props schema for the given node kind. Throws
-     * `KindNotFoundError` when the kind is not registered.
-     */
-    getNodePropsSchemaOrThrow(kind: string): z.ZodObject<z.ZodRawShape>;
-    /**
-     * Returns the Zod props schema for the given edge kind, or `undefined`
-     * if the kind is not registered. Symmetric with `getNodePropsSchema`.
-     */
-    getEdgePropsSchema(kind: string): z.ZodObject<z.ZodRawShape> | undefined;
-    /**
-     * Returns the Zod props schema for the given edge kind. Throws
-     * `KindNotFoundError` when the kind is not registered.
-     */
-    getEdgePropsSchemaOrThrow(kind: string): z.ZodObject<z.ZodRawShape>;
-    /**
-     * Returns a unified read of the merged schema — every compile-time
-     * and graph-extension kind, every edge, every ontology relation,
-     * with explicit `origin: "compile-time" | "runtime"` markers — plus
-     * the persisted `extension` for round-tripping.
-     *
-     * Pure synchronous read built from the in-memory graph and the
-     * already-merged graph-extension document. `schemaVersion` and `schemaHash`
-     * are populated when the loader cached them at construction or after
-     * `evolve` returns; consumers needing a fresh read should call
-     * `backend.getActiveSchema(graphId)`.
-     *
-     * The return shape is the canonical schema-introspection surface:
-     * the prior standalone `store.deprecatedKinds` accessor is replaced
-     * by `introspect().deprecatedKinds`.
-     */
-    introspect(): SchemaIntrospection;
-    /**
-     * Creates a query builder for this store.
-     *
-     * @example
-     * ```typescript
-     * const results = await store.query()
-     *   .from("Person", "p")
-     *   .whereNode("p", (p) => p.name.eq("Alice"))
-     *   .select((ctx) => ctx.p)
-     *   .execute();
-     * ```
-     */
-    query(): InitialQueryBuilder<G, "open">;
-    /**
-     * Internal seam for {@link StoreView.query}: a query builder pinned to a
-     * view's {@link ReadCoordinate} with its temporal axis sealed
-     * (`.temporal()` throws). Not part of the stable public API — construct a
-     * view via {@link Store.view} / {@link Store.asOf} and call `.query()`.
-     */
-    sealedQuery(coordinate: ReadCoordinate): InitialQueryBuilder<G, "sealed">;
-    /**
-     * Internal seam for {@link RecordedStoreView}: reconstruct a node point read
-     * from the recorded-time relation while preserving live getById ordering and
-     * duplicate-input behavior.
-     *
-     * @internal
-     */
-    recordedNodeGetById<N extends NodeType>(kind: string, id: NodeId<N>, coordinate: ReadCoordinate): Promise<Node<N> | undefined>;
-    /**
-     * Internal seam for {@link RecordedStoreView}: reconstruct node point reads
-     * from the recorded-time relation while preserving input order.
-     *
-     * @internal
-     */
-    recordedNodeGetByIds<N extends NodeType>(kind: string, ids: readonly NodeId<N>[], coordinate: ReadCoordinate): Promise<readonly (Node<N> | undefined)[]>;
-    /**
-     * Internal seam for {@link RecordedStoreView}: reconstruct an edge point read
-     * from the recorded-time relation while preserving live getById behavior.
-     *
-     * @internal
-     */
-    recordedEdgeGetById<E extends AnyEdgeType>(kind: string, id: EdgeId<E>, coordinate: ReadCoordinate): Promise<Edge<E> | undefined>;
-    /**
-     * Internal seam for {@link RecordedStoreView}: reconstruct edge point reads
-     * from the recorded-time relation while preserving input order.
-     *
-     * @internal
-     */
-    recordedEdgeGetByIds<E extends AnyEdgeType>(kind: string, ids: readonly EdgeId<E>[], coordinate: ReadCoordinate): Promise<readonly (Edge<E> | undefined)[]>;
-    /**
-     * Returns a read-only {@link StoreView} pinned to a valid-time instant.
-     *
-     * The view routes every supported read — `nodes` / `edges` collections,
-     * `query()`, `subgraph()`, and the graph algorithms — through the
-     * `asOf` coordinate, so they observe the graph as it was valid at `T`.
-     * Writes stay on the live `Store`. Mirrors Datomic's `(d/as-of db t)`.
-     *
-     * @example
-     * ```typescript
-     * const past = store.asOf("2026-01-01T00:00:00.000Z");
-     * const alice = await past.nodes.Person.getById(aliceId);
-     * const names = await past
-     *   .query()
-     *   .from("Person", "p")
-     *   .whereNode("p", (p) => p.name.eq("Alice"))
-     *   .select((ctx) => ctx.p.name)
-     *   .execute();
-     * ```
-     *
-     * @param asOf - ISO-8601 timestamp to pin the valid-time coordinate to.
-     */
-    asOf(asOf: string): StoreView<G>;
-    /**
-     * Returns a narrow read-only view pinned to a recorded/system-time instant.
-     *
-     * Direct `store.asOfRecorded(T)` is diagonal bitemporal sugar: it reads the
-     * recorded-time relation as of `T` and uses the same `T` for the valid-time
-     * axis. Use `store.asOf(validT).asOfRecorded(recordedT)` when the valid and
-     * recorded axes should differ.
-     *
-     * The returned view exposes only reconstructing-safe reads: query,
-     * subgraph, graph algorithms, and collection point reads.
-     *
-     * Prefer `await store.recordedNow()` as the anchor over a wall-clock
-     * timestamp: recorded instants are monotonic and can run briefly ahead of the
-     * wall clock under bursty writes, so a `new Date().toISOString()` passed here
-     * may sort before the most recent commits and silently omit them.
-     */
-    asOfRecorded(recordedAsOf: RecordedInstant): RecordedStoreView<G>;
-    /**
-     * Returns the latest recorded-time instant captured for this graph — the
-     * recorded high-water mark. After guarding the `undefined` case,
-     * `store.asOfRecorded(checkpoint)` reconstructs everything committed so far, a
-     * deterministic anchor that avoids guessing with the wall clock (recorded
-     * instants are monotonic and can run briefly ahead of wall-clock time under
-     * bursty writes). Capture each anchor right after the writes it should cover.
-     *
-     * Returns `undefined` until the first write has been captured, so on a
-     * brand-new graph guard the composition — `asOfRecorded(undefined)` rejects
-     * (an instant is required) rather than reconstructing an empty view. Read the
-     * value first and only pass it to `asOfRecorded` once it is defined.
-     *
-     * **Graph-global, not caller-scoped.** This is the single high-water mark for
-     * the whole graph, advanced by every committed capture from any writer — not
-     * a per-write or per-caller value. An advance between two reads means
-     * "something committed to this graph in between," *not* "the write this caller
-     * just made landed." Do not use a `recordedNow()` advance as a "did my write
-     * succeed?" signal: under any concurrent writer to the same graph it both
-     * misses dropped writes and misfires on no-op writes. Confirm a specific write
-     * by observing the write itself (its return value, or `store.transaction(...)`
-     * 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;
-     * reach for `view` to pin `"current"`, `"includeEnded"`, or
-     * `"includeTombstones"`.
-     *
-     * @example
-     * ```typescript
-     * const withTombstones = store.view({ mode: "includeTombstones" });
-     * const everyEverVersion = await withTombstones.nodes.Person.find();
-     * ```
-     *
-     * @param coordinate - The `(mode, asOf)` coordinate to pin. `asOf` is
-     *   required when `mode` is `"asOf"` and rejected for every other mode.
-     */
-    view(coordinate: StoreViewCoordinate): StoreView<G>;
-    /**
-     * Returns a read-only {@link StoreView} pinned to the current instant,
-     * captured once at construction — a stable point-in-time snapshot. Unlike
-     * `store.view({ mode: "current" })` (which tracks "now" live and can read
-     * different surfaces against slightly different clocks), a snapshot pins one
-     * `asOf` timestamp, so every surface observes the same instant. Sugar for
-     * `store.asOf(new Date().toISOString())`; mirrors Datomic's `(d/db conn)`.
-     *
-     * @example
-     * ```typescript
-     * const snap = store.snapshot();
-     * // Every read on `snap` sees the graph as of one fixed instant.
-     * const a = await snap.nodes.Person.find();
-     * const r = await snap.reachable(rootId, { edges: ["knows"] });
-     * ```
-     */
-    snapshot(): StoreView<G>;
-    /**
-     * Search-related operations (fulltext, hybrid, and rebuild).
-     *
-     * All search methods live under this facade to keep the top-level
-     * Store API focused on CRUD + graph traversal. The facade is
-     * lazy-initialized and cached for the lifetime of the store.
-     *
-     * @example
-     * ```typescript
-     * // Fulltext
-     * const hits = await store.search.fulltext("Document", {
-     *   query: "climate warming",
-     *   limit: 10,
-     *   includeSnippets: true,
-     * });
-     *
-     * // Hybrid (vector + fulltext fused with RRF)
-     * const ranked = await store.search.hybrid("Document", {
-     *   limit: 10,
-     *   vector: { fieldPath: "embedding", queryEmbedding: vec },
-     *   fulltext: { query: "climate warming" },
-     * });
-     *
-     * // Rebuild index after schema change
-     * const stats = await store.search.rebuildFulltext();
-     * ```
-     */
-    get search(): StoreSearch<G>;
-    /**
-     * Executes multiple queries and returns a typed tuple of results.
-     *
-     * Each query preserves its own result type, projection, filtering, sorting,
-     * and pagination.
-     *
-     * **Snapshot consistency is conditional.** When
-     * `backend.capabilities.transactions` is `true`, queries run sequentially
-     * on a single connection inside an implicit transaction and observe the
-     * same database snapshot. When transactions are unavailable
-     * (Cloudflare D1, `drizzle-orm/neon-http`), queries run sequentially over
-     * independent connections and may observe writes that landed between them.
-     * Branch on `backend.capabilities.transactions` if you need a guaranteed
-     * snapshot.
-     *
-     * Read-only — use `bulkCreate`, `bulkInsert`, etc. for write batching.
-     *
-     * @example
-     * ```typescript
-     * const [people, companies] = await store.batch(
-     *   store.query()
-     *     .from("Person", "p")
-     *     .select((ctx) => ({ id: ctx.p.id, name: ctx.p.name })),
-     *   store.query()
-     *     .from("Company", "c")
-     *     .select((ctx) => ({ id: ctx.c.id, name: ctx.c.name }))
-     *     .orderBy("c", "name", "asc")
-     *     .limit(5),
-     * );
-     * // people:    readonly { id: string; name: string }[]
-     * // companies: readonly { id: string; name: string }[]
-     * ```
-     *
-     * @param queries - Two or more executable queries (from `.select()` or set operations)
-     * @returns A tuple with per-query typed results, preserving input order
-     */
-    batch<const Queries extends readonly [
+type StoreCore<G extends GraphDef> = Readonly<{
+    [STORE_RUNTIME]: StoreRuntime<G>;
+    graph: G;
+    graphId: string;
+    capabilities: BackendCapabilities;
+    registry: KindRegistry;
+    historyEnabled: boolean;
+    revisionTrackingEnabled: boolean;
+    revisionSchema: SqlSchema;
+    recordedReadBound: boolean;
+    nodes: GraphNodeCollections<G>;
+    edges: GraphEdgeCollections<G>;
+    algorithms: GraphAlgorithms<G>;
+    search: StoreSearch<G>;
+    getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;
+    getNodeCollectionOrThrow: (kind: string) => DynamicNodeCollection;
+    getEdgeCollection: (kind: string) => DynamicEdgeCollection | undefined;
+    getEdgeCollectionOrThrow: (kind: string) => DynamicEdgeCollection;
+    getNodePropsSchema: (kind: string) => z.ZodObject<z.ZodRawShape> | undefined;
+    getNodePropsSchemaOrThrow: (kind: string) => z.ZodObject<z.ZodRawShape>;
+    getEdgePropsSchema: (kind: string) => z.ZodObject<z.ZodRawShape> | undefined;
+    getEdgePropsSchemaOrThrow: (kind: string) => z.ZodObject<z.ZodRawShape>;
+    introspect: () => SchemaIntrospection;
+    query: () => InitialQueryBuilder<G, "open">;
+    asOf: (asOf: string) => StoreView<G>;
+    asOfRecorded: (recordedAsOf: RecordedInstant) => RecordedStoreView<G>;
+    recordedNow: () => Promise<RecordedInstant | undefined>;
+    revisionNow: () => Promise<string | undefined>;
+    revisionOriginNow: () => Promise<string>;
+    view: (coordinate: StoreViewCoordinate) => StoreView<G>;
+    snapshot: () => StoreView<G>;
+    batch: <const Queries extends readonly [
         BatchableQuery<unknown>,
         BatchableQuery<unknown>,
         ...BatchableQuery<unknown>[]
-    ]>(...queries: Queries): Promise<BatchResults<Queries>>;
-    /**
-     * Extracts a typed subgraph by traversing from a root node.
-     *
-     * Performs a BFS traversal from `rootId` following the specified edge kinds,
-     * returning an indexed result with adjacency maps for immediate traversal.
-     *
-     * @example
-     * ```typescript
-     * const sg = await store.subgraph(run.id, {
-     *   edges: ["has_task", "runs_agent", "uses_skill"],
-     *   maxDepth: 4,
-     * });
-     *
-     * // Root node (the traversal starting point)
-     * console.log(sg.root?.kind);
-     *
-     * // Lookup by ID
-     * const task = sg.nodes.get(taskId);
-     *
-     * // Forward adjacency: edges of a kind from a node
-     * const taskEdges = sg.adjacency.get(run.id)?.get("has_task") ?? [];
-     *
-     * // Reverse adjacency: edges of a kind pointing to a node
-     * const parentEdges = sg.reverseAdjacency.get(taskId)?.get("has_task") ?? [];
-     * ```
-     */
-    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>>;
-    /**
-     * Internal seam for {@link StoreView} / {@link RecordedStoreView}: runs a
-     * subgraph with a coordinate already flattened into the options (including a
-     * recorded/system-time pin). Trusted caller — the public {@link Store.subgraph}
-     * is the guarded entry point.
-     *
-     * @internal
-     */
-    subgraphAtCoordinate<const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: InternalSubgraphOptions<G, EK, NK, P>): Promise<SubgraphResult<G, NK, EK, P>>;
-    /**
-     * Internal seam for StoreView graph algorithms at a pinned coordinate.
-     *
-     * @internal
-     */
-    algorithmsAtCoordinate(coordinate: ReadCoordinate): InternalGraphAlgorithms<G>;
-    /**
-     * Executes a function within a transaction.
-     *
-     * The transaction context provides the same collection API as the Store:
-     * - `tx.nodes.Person.create(...)` - Create a node
-     * - `tx.edges.worksAt.create(...)` - Create an edge
-     * - `tx.sql` - the raw Drizzle handle **bound to this same
-     *   transaction**, for writing the caller's own relational tables in
-     *   the same atomic boundary (the graph-owned counterpart of
-     *   {@link Store.withTransaction}). See {@link TransactionContext}
-     *   for per-backend semantics. To decide at runtime whether `tx.sql` is
-     *   usable, branch on `tx.sqlAvailability` rather than truthiness-testing
-     *   `tx.sql` — under history capture or revision tracking `tx.sql` is
-     *   present-but-throwing (`sqlAvailability` is `"history"` /
-     *   `"revisionTracking"`), and it is `undefined` only on the non-transactional
-     *   fallback (`sqlAvailability === "unavailable"`). When it reports
-     *   `"history"` / `"revisionTracking"`, raw SQL is disabled because it would
-     *   bypass recorded-time capture or the revision anchor; use the typed
-     *   collections inside `transaction()` or
-     *   {@link Store.withRecordedTransaction}.
-     *
-     * @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(
-     *     { kind: "Person", id: person.id },
-     *     { kind: "Company", id: company.id },
-     *     { role: "Engineer" }
-     *   );
-     * });
-     * ```
-     *
-     * @example Cross-store write via `tx.sql` (graph-owned boundary):
-     * ```typescript
-     * await store.transaction(async (tx) => {
-     *   await tx.nodes.Document.update(documentId, props);
-     *   // cast `tx.sql` to your concrete Drizzle database type
-     *   const sqlTx = tx.sql as NodePgDatabase;
-     *   await sqlTx.insert(documentVersions).values(versionRow);
-     * });
-     * ```
-     *
-     * **`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
-     * are applied as they happen and a thrown error does **not** roll back
-     * earlier writes inside the callback. Branch on
-     * `backend.capabilities.transactions` if you require atomicity:
-     *
-     * ```typescript
-     * if (backend.capabilities.transactions) {
-     *   await store.transaction(async (tx) => { ... });
-     * } else {
-     *   // sequential, non-atomic — handle partial-failure recovery yourself
-     * }
-     * ```
-     *
-     * @param fn The callback run inside the transaction boundary.
-     * @param options Optional {@link TransactionOptions} forwarded to the
-     *   backend (e.g. `isolationLevel: "serializable"` on Postgres). Backends
-     *   without isolation-level support ignore it; the non-transactional
-     *   fallback ignores it entirely. Stores created with `{ history: true }`
-     *   require read-committed semantics for PostgreSQL recorded-clock capture and
-     *   reject stronger snapshot isolation levels.
-     */
-    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. The adopted-commit sibling
-     * {@link Store.withRecordedTransaction} also returns a
-     * {@link TransactionOutcome}; only `withTransaction` (whose commit belongs
-     * entirely to the caller with no flush point) produces no receipt. 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.
-     *
-     * The callback receives a {@link MeasurableTransactionContext}: call
-     * `tx.measure((scoped) => ...)` to scope a sub-receipt to the writes made
-     * through the `scoped` context (e.g. to attribute writes to user code the
-     * caller invokes, excluding its own bookkeeping written through `tx`). See
-     * {@link MeasurableTransactionContext} for semantics.
-     *
-     * @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: MeasurableHistoryTransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<TransactionOutcome<T>>;
-    transactionWithReceipt<T>(fn: (tx: MeasurableTransactionContext<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
-     * Postgres/SQLite transaction (#134).
-     *
-     * Use this when the **relational layer owns the transaction**: the
-     * caller has opened a transaction and needs TypeGraph writes enlisted
-     * on the *same* connection. Unlike {@link transaction}, this opens no
-     * transaction — the caller's transaction is the single commit/rollback
-     * boundary.
-     *
-     * `withTransaction` is driver-agnostic; how the caller opens the
-     * transaction is not. **Async drivers** (node-postgres,
-     * `neon-serverless` Pool, libsql) use `db.transaction(async …)`.
-     * **Synchronous `better-sqlite3`** cannot — its driver rejects an
-     * `async` transaction callback (`Transaction function cannot return a
-     * promise`) and the async continuation would run outside the
-     * rolled-back transaction — so the caller opens the transaction with
-     * explicit `BEGIN`/`COMMIT`/`ROLLBACK` on the single connection
-     * instead. See the "Cross-Store Transactions" recipe for both shapes.
-     *
-     * The returned context reuses this store's already-resolved
-     * schema/registry: it runs **no** schema bootstrap, `evolve`, or
-     * migration, and emits **no DDL** inside the caller's transaction.
-     * Fulltext operations assert the durable materialization marker (a
-     * cached SELECT) and throw {@link StoreNotInitializedError} on a
-     * missing/stale/failed marker rather than migrating mid-transaction —
-     * so boot the parent store via `createStoreWithSchema` once at
-     * startup.
-     *
-     * @example
-     * ```typescript
-     * // Async driver (Postgres / libsql):
-     * await db.transaction(async (sqlTx) => {
-     *   const connector = await createConnectorRow(sqlTx, input); // Drizzle
-     *   const txStore = store.withTransaction(sqlTx);
-     *   await txStore.nodes.ArtifactSource.create({              // TypeGraph
-     *     connectorId: connector.id,
-     *   });
-     * }); // 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. On a {@link HistoryStore} this is a **compile error**
-     * at the call site (the `externalTx` argument is rejected against a message
-     * type naming {@link Store.withRecordedTransaction}); the runtime guard still
-     * throws `ConfigurationError`
-     * (`RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`) if the check is
-     * suppressed. Use {@link Store.withRecordedTransaction} on a history-enabled
-     * store, which adopts the same external transaction but flushes recorded-time
-     * capture before the caller commits.
-     *
-     * @throws {ConfigurationError} when the store has history capture enabled
-     *   (use {@link Store.withRecordedTransaction} instead), or when the backend
-     *   cannot adopt an external transaction — either it is not a Drizzle
-     *   Postgres/SQLite backend, or `backend.capabilities.transactions` is `false`
-     *   (`drizzle-orm/neon-http`, Cloudflare D1, SQLite
-     *   `transactionMode: "none"`). A non-atomic fallback is deliberately
-     *   not offered here: the caller's relational write *would* still
-     *   commit, defeating the purpose of cross-store atomicity.
-     * @throws {StoreNotInitializedError} at point of use, when a fulltext
-     *   operation on the returned context observes a missing/stale/failed
-     *   durable materialization marker (parent store not booted via
-     *   `createStoreWithSchema`). Rolls back the caller's transaction
-     *   without emitting any DDL.
-     */
-    withTransaction<This extends Store<G>>(this: This, externalTx: This extends HistoryStore<G> ? HistoryWithTransactionUnavailable : AdoptedTransaction): This extends HistoryStore<G> ? never : TransactionContext<G>;
-    /**
-     * Adopts a caller-owned transaction while giving recorded-time capture a
-     * flush point before the caller commits. Required when `history: true` is
-     * enabled because returning a long-lived transaction context would let writes
-     * happen after TypeGraph has lost the chance to close/open recorded rows.
-     *
-     * Capture flushes once, when `fn` resolves. The flush seals the capture
-     * session, so a graph write made through the transaction context *after* `fn`
-     * 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. This sealing behavior is
-     * unchanged by the receipt return.
-     *
-     * Returns a {@link TransactionOutcome} — the adopted path is the only way to
-     * get exactly-once cursors and graph writes atomically on a history store, so
-     * it surfaces the same receipt `transactionWithReceipt` does: `receipt.writes`
-     * for drop detection (a non-delete change that wrote nothing) and
-     * `receipt.recorded` as the per-transaction replay anchor. Destructure
-     * `{ result, receipt }`:
-     *
-     * ```typescript
-     * const { result, receipt } = await store.withRecordedTransaction(
-     *   externalTx,
-     *   async (tx) => tx.nodes.Document.update(documentId, props),
-     * );
-     * ```
-     *
-     * `receipt.recorded` is the recorded commit instant this transaction allocated
-     * for the store's graph at the flush point (when `fn` resolved), and is
-     * `undefined` when nothing was captured — a read-only `fn`, or a non-history
-     * store (where the receipt still counts write intents but there is no recorded
-     * time). To attribute writes when `fn` invokes user code that also
-     * bookkeeps, use `tx.measure((scoped) => ...)` and have that code write
-     * through the `scoped` context (see {@link MeasurableTransactionContext}).
-     *
-     * Write your own relational tables through the **external transaction handle
-     * you passed in** (`externalTx`) — it *is* the pinned connection. `tx.sql` is
-     * unavailable here (it is a fail-loud guard under history capture, since raw
-     * SQL bypasses recorded-time capture, and `HistoryTransactionContext` types it
-     * `sql?: never`). Writing through `externalTx` is the sanctioned way to get
-     * cross-store atomicity on a history-enabled store:
-     *
-     * ```typescript
-     * // Async driver (Postgres / libsql):
-     * await db.transaction(async (pgTx) => {
-     *   const { receipt } = await store.withRecordedTransaction(pgTx, async (tx) => {
-     *     await tx.nodes.Document.update(documentId, props); // graph write
-     *   });
-     *   await pgTx.insert(streamCursors).values(cursorRow);  // your own table
-     * }); // one COMMIT / ROLLBACK across both layers
-     * ```
-     *
-     * The graph writes and your `externalTx` 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: MeasurableHistoryTransactionContext<G>) => Promise<T>): Promise<TransactionOutcome<T>>;
-    withRecordedTransaction<T>(externalTx: AdoptedTransaction, fn: (tx: MeasurableTransactionContext<G>) => Promise<T>): Promise<TransactionOutcome<T>>;
-    /**
-     * Hard-deletes all data for this graph from the database.
-     *
-     * Removes all nodes, edges, uniqueness entries, embeddings, and schema versions
-     * for this graph's ID. No hooks, no per-row logic. Wrapped in a transaction
-     * when the backend supports it.
-     *
-     * The store is usable after clearing — new data can be created immediately.
-     */
-    clear(): Promise<void>;
-    /**
-     * Refreshes the backend's query-planner statistics.
-     *
-     * Call this once after a large initial import or bulk backfill. The
-     * planner uses table statistics to choose between TypeGraph's
-     * multi-column indexes; without fresh stats a forward traversal can
-     * pick a reverse index and run an order of magnitude slower than
-     * needed. Autovacuum / background statistics will catch up
-     * eventually, but calling this explicitly after a bulk load gives
-     * you correct latencies immediately.
-     *
-     * Implementations:
-     * - SQLite runs `ANALYZE`, populating `sqlite_stat1`
-     * - PostgreSQL runs `ANALYZE` on the TypeGraph-managed tables
-     *
-     * Costs a few tens of milliseconds at the sizes this library is
-     * designed for. Safe to call at any time.
-     *
-     * @example
-     * ```typescript
-     * // After a bulk import
-     * for (const batch of batches) {
-     *   await store.nodes.Document.bulkCreate(batch);
-     * }
-     * await store.refreshStatistics();
-     * ```
-     */
-    refreshStatistics(): Promise<void>;
-    /**
-     * Evolves the graph at runtime by merging a graph extension into the
-     * current schema, atomically committing a new schema version, and
-     * returning a fresh `Store` constructed against the merged graph.
-     *
-     * The `Store` is immutable — its registry, collections, and operation
-     * contexts close over the graph at construction time — so callers
-     * must use the returned store (or pass a `ref` to be re-pointed) for
-     * any work involving the new kinds.
-     *
-     * **Cost for purely additive extensions is proportional to schema
-     * document size, not row count.** The commit is a single CAS write.
-     * Tightening changes against existing graph-extension-declared kinds run
-     * row-count probes for those affected kinds so populated kinds can
-     * be rejected without a backfill.
-     *
-     * **Concurrent evolve recovery.** On `StaleVersionError`, refetch the
-     * current active schema (or dereference your `StoreRef`),
-     * reconstruct your `Store`, and re-call `evolve(extension)` against
-     * the new store. Re-validation may now surface deterministic errors
-     * (e.g., another caller just added a kind that collides with yours,
-     * or redeclared one of yours with a different shape). Don't loop
-     * blindly — surface the error.
-     *
-     * @param extension - Graph extension produced by
-     *   `defineGraphExtension(...)`.
-     * @param options.ref - Optional handle whose `current` is overwritten
-     *   atomically with the schema commit. Long-lived consumers
-     *   (request handlers, background workers) that dereference through
-     *   the ref see the new kinds on the *next* call.
-     *
-     * @throws {GraphExtensionValidationError} when the extension is
-     *   structurally invalid.
-     * @throws {KindCollisionError} when an extension kind shadows a
-     *   compile-time kind (code `KIND_COLLISION`).
-     * @throws {IncompatibleChangeError} when a redeclared kind narrows
-     *   in a way the existing rows can't satisfy
-     *   (code `INCOMPATIBLE_CHANGE`).
-     * @throws {GraphExtensionUnresolvedEndpointError} when an edge
-     *   endpoint references a kind that exists in neither the extension
-     *   nor the host graph
-     *   (code `GRAPH_EXTENSION_UNRESOLVED_ENDPOINT`).
-     * @throws {StaleVersionError} when another writer has advanced the
-     *   schema since this store was constructed; recovery as above.
-     * @throws {SchemaContentConflictError} when a row already exists at
-     *   the target version with a different content hash.
-     */
-    evolve(extension: GraphExtension, options?: Readonly<{
-        ref?: StoreRef<Store<G>>;
-        /**
-         * When set, automatically run `materializeIndexes()` on the new
-         * Store after the schema commit succeeds. Pass `{}` for default
-         * behavior (all declared indexes, best-effort) or a populated
-         * options object for finer control. Omit to defer materialization
-         * to a later `materializeIndexes()` call.
-         *
-         * The schema-version write is NOT rolled back if materialization
-         * produces failed entries — failure surfaces as
-         * `EagerMaterializationError` thrown AFTER the new Store is
-         * constructed and `ref.current` is updated, so the caller can
-         * recover via the ref handle.
-         */
+    ]>(...queries: Queries) => Promise<BatchResults<Queries>>;
+    subgraph: <const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: SubgraphOptions<G, EK, NK, P>) => Promise<SubgraphResult<G, NK, EK, P>>;
+    clear: () => Promise<void>;
+    refreshStatistics: () => Promise<void>;
+    materializeIndexes: (options?: MaterializeIndexesOptions) => Promise<MaterializeIndexesResult>;
+    materializeSystemIndexes: (options?: MaterializeSystemIndexesOptions) => Promise<MaterializeIndexesResult>;
+    reembedVectorField: (kind: string, fieldPath: string, options?: ReembedVectorFieldOptions) => Promise<ReembedVectorFieldResult>;
+    materializeRemovals: (options?: MaterializeRemovalsOptions) => Promise<MaterializeRemovalsResult>;
+    close: () => Promise<void>;
+}>;
+type StoreTransactions<G extends GraphDef> = Readonly<{
+    transaction: <T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+    transactionWithReceipt: <T>(fn: (tx: MeasurableTransactionContext<G>) => Promise<T>, options?: TransactionOptions) => Promise<TransactionOutcome<T>>;
+}>;
+interface StoreEvolution<G extends GraphDef, TStore extends StoreCore<G>> {
+    readonly evolve: <TRefStore extends StoreCore<G> = TStore>(extension: GraphExtension, options?: Readonly<{
+        ref?: TStore extends TRefStore ? StoreRef<TRefStore> : never;
         eager?: MaterializeIndexesOptions;
-    }>): Promise<Store<G>>;
-    /**
-     * Marks the named node and edge kinds as soft-deprecated. Surfaces in
-     * `store.introspect().deprecatedKinds` for introspection (codegen,
-     * UI tooling, lints) but does not gate reads, writes, or queries —
-     * deprecation is a signal, not a removal.
-     *
-     * Atomically commits a new schema version through the same primitive
-     * `evolve()` uses, so concurrent deprecate/evolve calls produce
-     * `StaleVersionError | SchemaContentConflictError` race losers that
-     * the caller refetches and retries. Idempotent: re-deprecating a
-     * kind that's already marked is a no-op (no version bump).
-     *
-     * @param names - Node or edge kind names to mark as deprecated.
-     * @param options.ref - Optional handle to be re-pointed atomically
-     *   with the schema commit, mirroring `evolve()`.
-     *
-     * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE` (no
-     *   schema yet) or `DEPRECATE_UNKNOWN_KIND` (name not on the graph).
-     * @throws {StaleVersionError} when another writer has advanced the
-     *   schema since this store was constructed; refetch and retry per
-     *   the same recipe `evolve()` documents.
-     * @throws {SchemaContentConflictError} when a row already exists at
-     *   the target version with a different content hash.
-     */
-    deprecateKinds(names: readonly string[], options?: Readonly<{
-        ref?: StoreRef<Store<G>>;
-    }>): Promise<Store<G>>;
-    /**
-     * Reverses `deprecateKinds(...)` for the named kinds. Same race +
-     * idempotency semantics: removing a name that isn't currently
-     * deprecated is a no-op for that name (the call as a whole is a
-     * no-op only if every name was already absent).
-     *
-     * @param names - Node or edge kind names to remove from the
-     *   deprecated set.
-     * @param options.ref - Optional handle to be re-pointed atomically
-     *   with the schema commit.
-     *
-     * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE`.
-     * @throws {StaleVersionError} on a CAS race with another writer.
-     * @throws {SchemaContentConflictError} on a same-version content
-     *   conflict.
-     */
-    undeprecateKinds(names: readonly string[], options?: Readonly<{
-        ref?: StoreRef<Store<G>>;
-    }>): Promise<Store<G>>;
-    /**
-     * Runs `CREATE INDEX` DDL for the indexes declared on this graph and
-     * records per-deployment status in `typegraph_index_materializations`.
-     * The status table is per-database (two replicas of the same
-     * `schema_doc` are still two different databases for DDL purposes),
-     * so the same call against two replicas materializes independently.
-     *
-     * Idempotent. Re-running the verb against an already-materialized
-     * index is a no-op (`status: "alreadyMaterialized"`). Postgres uses
-     * `CREATE INDEX CONCURRENTLY` so live tables never take an
-     * `AccessExclusiveLock`. SQLite is single-writer regardless.
-     *
-     * Best-effort by default: a failed index records `status: "failed"`
-     * with the error and the loop continues. Pass `{ stopOnError: true }`
-     * to halt on the first failure.
-     *
-     * @param options.kinds - Restrict to indexes whose `kind` is in this
-     *   set. Throws `ConfigurationError` (`code:
-     *   "MATERIALIZE_UNKNOWN_KIND"`) if any name doesn't match a known
-     *   compile-time or extension kind.
-     * @param options.stopOnError - Halt on first failure. Default false.
-     *
-     * @throws {ConfigurationError} `MATERIALIZE_BACKEND_UNSUPPORTED` if
-     *   the backend lacks `executeDdl`, `getIndexMaterialization`, or
-     *   `recordIndexMaterialization`; `MATERIALIZE_UNKNOWN_KIND` for an
-     *   unknown kind name; `MATERIALIZE_BEFORE_INITIALIZE` if the store
-     *   has no schema yet.
-     */
-    materializeIndexes(options?: MaterializeIndexesOptions): Promise<MaterializeIndexesResult>;
-    /**
-     * Materializes TypeGraph's own base-relation indexes
-     * (`SYSTEM_INDEX_DECLARATIONS`) against the live database.
-     *
-     * Bootstrap DDL runs only on first boot, so a system index shipped in a
-     * newer library version never reaches an already-initialized database on
-     * its own. `createStoreWithSchema` runs this automatically; deployments
-     * that boot with plain `createStore` / `createVerifiedStore` (zero-DDL by
-     * contract) adopt new system indexes by calling this once under a role
-     * that may run DDL. Same status-table, drift-signature, and Postgres
-     * `CREATE INDEX CONCURRENTLY` claim semantics as `materializeIndexes`.
-     */
-    materializeSystemIndexes(options?: MaterializeSystemIndexesOptions): Promise<MaterializeIndexesResult>;
-    /**
-     * Recreate a vector field's per-field storage at its current declared
-     * dimension, then optionally re-embed existing rows.
-     *
-     * Use this after changing a field's `embedding(N)` to `embedding(M)` (e.g. a
-     * new embedding model): the stored N-dim vectors are invalid under the new
-     * dimension and must be recomputed, not converted. This drops and recreates
-     * the per-`(graphId, kind, field)` table at the new dimension — a brief
-     * window where the field returns no vector hits — resets its materialization
-     * marker, then, when `options.embed` is supplied, pages the kind's nodes,
-     * calls `embed(batch)`, and upserts the returned vectors. Without `embed`,
-     * storage is recreated empty and the caller re-embeds via normal
-     * `update()` / `upsertEmbedding` writes.
-     *
-     * @throws {ConfigurationError} when the backend has no vector strategy or
-     *   cannot execute DDL, or `(kind, fieldPath)` is not a declared embedding.
-     */
-    reembedVectorField(kind: string, fieldPath: string, options?: ReembedVectorFieldOptions): Promise<ReembedVectorFieldResult>;
-    /**
-     * Removes extension kinds from the schema with cascading edge and
-     * ontology cleanup. Two-phase by design:
-     *
-     *   1. **Schema commit (this method).** Validates the removal,
-     *      rebuilds the persisted extension without the named kinds
-     *      (and without extension edges that lose their last endpoint),
-     *      CAS-commits the new schema version, and queues
-     *      per-deployment data-cleanup status. Millisecond budget.
-     *   2. **Data cleanup (`materializeRemovals`).** Deletes the orphan
-     *      rows from the nodes/edges tables. Bounded by row count.
-     *
-     * Pass `{ eager: {} }` to run the data-cleanup pass inline with
-     * default options, or `{ eager: { ... } }` to scope it; otherwise
-     * call `materializeRemovals()` later.
-     *
-     * Idempotent: removing a name that doesn't exist is a no-op (no
-     * version bump). Removing an extension kind referenced by a compile-
-     * time edge or ontology relation throws `KindHasReferentsError`.
-     * Removing a compile-time kind throws `RemoveCompileTimeKindError` —
-     * compile-time kinds are removed by recompiling and redeploying.
-     *
-     * @throws {RemoveCompileTimeKindError} when `names` includes a
-     *   compile-time kind.
-     * @throws {KindHasReferentsError} when an extension kind being
-     *   removed is referenced by a compile-time declaration.
-     * @throws {StaleVersionError} on a CAS race with another writer.
-     * @throws {SchemaContentConflictError} on a same-version content
-     *   conflict.
-     */
-    removeKinds(names: readonly string[], options?: Readonly<{
-        ref?: StoreRef<Store<G>>;
+    }>) => Promise<TStore>;
+    readonly deprecateKinds: <TRefStore extends StoreCore<G> = TStore>(names: readonly string[], options?: Readonly<{
+        ref?: TStore extends TRefStore ? StoreRef<TRefStore> : never;
+    }>) => Promise<TStore>;
+    readonly undeprecateKinds: <TRefStore extends StoreCore<G> = TStore>(names: readonly string[], options?: Readonly<{
+        ref?: TStore extends TRefStore ? StoreRef<TRefStore> : never;
+    }>) => Promise<TStore>;
+    readonly removeKinds: <TRefStore extends StoreCore<G> = TStore>(names: readonly string[], options?: Readonly<{
+        ref?: TStore extends TRefStore ? StoreRef<TRefStore> : never;
         eager?: MaterializeRemovalsOptions;
-    }>): Promise<Store<G>>;
-    /**
-     * Runs the data-cleanup phase for any kinds removed via
-     * `removeKinds()` whose data has not yet been deleted on this
-     * deployment. Safe to call repeatedly; idempotent.
-     */
-    materializeRemovals(options?: MaterializeRemovalsOptions): Promise<MaterializeRemovalsResult>;
-    /**
-     * Closes the store and releases underlying resources.
-     *
-     * Note: When using the Drizzle adapter, this method does not close the database
-     * connection itself, as Drizzle delegates connection management to the user.
-     * You should close the underlying database connection (e.g., better-sqlite3 or pg pool)
-     * using their respective APIs.
-     */
-    close(): Promise<void>;
+    }>) => Promise<TStore>;
 }
-type HistorySafeBackend = Omit<GraphBackend, "executeStatement" | "executeDdl"> & Readonly<{
-    executeStatement?: never;
-    executeDdl?: never;
+/**
+ * The default TypeGraph Store contract. It contains the complete graph API and
+ * graph-owned transactions while keeping adapter-native handles, backend
+ * internals, and caller-owned transaction adoption out of the public surface.
+ */
+type Store<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, Store<G>>;
+/**
+ * A Store with explicit adapter interoperability. Adapter entrypoints return
+ * this surface so native transaction handles remain precisely typed without
+ * leaking into the default Store contract.
+ */
+type AdapterStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & Readonly<{
+    backend: GraphBackend;
 }>;
-type HistorySafeTransactionBackend = Omit<TransactionBackend, "executeStatement" | "executeDdl"> & Readonly<{
-    executeStatement?: never;
-    executeDdl?: never;
+type AdapterStoreTransactions<G extends GraphDef, TNativeTransaction> = Readonly<{
+    transaction: <T>(fn: (tx: AdapterTransactionContext<G, TNativeTransaction>) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+    transactionWithReceipt: <T>(fn: (tx: MeasurableAdapterTransactionContext<G, TNativeTransaction>) => Promise<T>, options?: TransactionOptions) => Promise<TransactionOutcome<T>>;
+    withTransaction: (externalTransaction: TNativeTransaction) => AdapterTransactionContext<G, TNativeTransaction>;
+    withRecordedTransaction: <T>(externalTransaction: TNativeTransaction, fn: (tx: MeasurableAdapterTransactionContext<G, TNativeTransaction>) => Promise<T>) => Promise<TransactionOutcome<T>>;
 }>;
-type HistoryTransactionContext<G extends GraphDef> = Omit<TransactionContext<G>, "backend" | "sql"> & Readonly<{
-    backend: HistorySafeTransactionBackend;
+type AdapterHistoryTransactionContext<G extends GraphDef, TNativeTransaction> = Omit<AdapterTransactionContext<G, TNativeTransaction>, "sql" | "sqlAvailability"> & Readonly<{
     sql?: never;
+    sqlAvailability: "history";
 }>;
 /**
- * The {@link HistoryTransactionContext} handed to a `withRecordedTransaction`
+ * The {@link AdapterHistoryTransactionContext} handed to a `withRecordedTransaction`
  * callback, extended with {@link ScopedMeasure}. Its `measure` scopes to a child
- * {@link MeasurableHistoryTransactionContext} (so nested scopes keep the
+ * {@link MeasurableAdapterHistoryTransactionContext} (so nested scopes keep the
  * history-safe `sql?: never` / backend typing). Assignable to
  * {@link MeasurableTransactionContext} (and hence to {@link TransactionContext}),
  * so a projector helper typed against either still accepts it.
  */
-type MeasurableHistoryTransactionContext<G extends GraphDef> = HistoryTransactionContext<G> & Readonly<{
-    measure: ScopedMeasure<MeasurableHistoryTransactionContext<G>>;
+type MeasurableAdapterHistoryTransactionContext<G extends GraphDef, TNativeTransaction> = AdapterHistoryTransactionContext<G, TNativeTransaction> & Readonly<{
+    measure: ScopedMeasure<MeasurableAdapterHistoryTransactionContext<G, TNativeTransaction>>;
+}>;
+type AdapterRecordedReadStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterRecordedReadStore<G, TNativeTransaction>> & AdapterStoreTransactions<G, TNativeTransaction> & Readonly<{
+    backend: GraphBackend;
+    recordedReadBound: true;
 }>;
-type RecordedReadStore<G extends GraphDef> = Store<G> & Readonly<{
+type RecordedReadStore<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, RecordedReadStore<G>> & Readonly<{
     recordedReadBound: true;
 }>;
-type HistoryStore<G extends GraphDef> = Store<G> & Readonly<{
-    backend: HistorySafeBackend;
+type HistoryStore<G extends GraphDef> = StoreCore<G> & StoreTransactions<G> & StoreEvolution<G, HistoryStore<G>> & Readonly<{
     historyEnabled: true;
     recordedReadBound: true;
 }>;
-/**
- * The `externalTx` parameter type {@link Store.withTransaction} resolves to when
- * called on a {@link HistoryStore}. A real {@link AdoptedTransaction} is not
- * assignable to this string literal, so the call is a compile error whose
- * message names the working alternative. `HistoryStore` cannot be excluded from
- * the general signature by a `this` constraint alone — it is a subtype of
- * `Store<G>` — so the block is expressed on the argument instead.
- */
-type HistoryWithTransactionUnavailable = "withTransaction() is unavailable on a history-enabled store — use store.withRecordedTransaction() so recorded-time capture can flush before the caller commits";
-type ExplicitRecordedReadLiveOptions = LiveStoreOptions & Readonly<{
-    recordedRead: NonNullable<LiveStoreOptions["recordedRead"]>;
+type AdapterHistoryStore<G extends GraphDef, TNativeTransaction> = StoreCore<G> & StoreEvolution<G, AdapterHistoryStore<G, TNativeTransaction>> & AdapterHistoryStoreTransactions<G, TNativeTransaction> & Readonly<{
+    backend: HistoryStoreBackend;
+    historyEnabled: true;
+    recordedReadBound: true;
+}>;
+type AdapterHistoryStoreTransactions<G extends GraphDef, TNativeTransaction> = Readonly<{
+    transaction: <T>(fn: (tx: AdapterHistoryTransactionContext<G, TNativeTransaction>) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+    transactionWithReceipt: <T>(fn: (tx: MeasurableAdapterHistoryTransactionContext<G, TNativeTransaction>) => Promise<T>, options?: TransactionOptions) => Promise<TransactionOutcome<T>>;
+    withRecordedTransaction: <T>(externalTransaction: TNativeTransaction, fn: (tx: MeasurableAdapterHistoryTransactionContext<G, TNativeTransaction>) => Promise<T>) => Promise<TransactionOutcome<T>>;
 }>;
 /**
  * Creates a new Store instance.
@@ -5147,8 +4082,15 @@ type ExplicitRecordedReadLiveOptions = LiveStoreOptions & Readonly<{
  * ```
  */
 declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions): HistoryStore<G>;
-declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions): RecordedReadStore<G>;
-declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions): Store<G>;
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: RecordedReadStoreOptions): RecordedReadStore<G>;
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: UnboundLiveStoreOptions): Store<G>;
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: LiveStoreOptions | undefined): Store<G> | RecordedReadStore<G>;
+declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: StoreOptions | undefined): Store<G> | HistoryStore<G> | RecordedReadStore<G>;
+declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: HistoryStoreOptions): AdapterHistoryStore<G, TNativeTransaction>;
+declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: RecordedReadStoreOptions): AdapterRecordedReadStore<G, TNativeTransaction>;
+declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options?: UnboundLiveStoreOptions): AdapterStore<G, TNativeTransaction>;
+declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: LiveStoreOptions | undefined): AdapterStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>;
+declare function createAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: StoreOptions | undefined): AdapterStore<G, TNativeTransaction> | AdapterHistoryStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>;
 
 /**
  * Creates a store and ensures the schema is initialized/migrated.
@@ -5179,8 +4121,30 @@ declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend
  * ```
  */
 declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions & SchemaManagerOptions): Promise<[HistoryStore<G>, SchemaValidationResult]>;
-declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions & SchemaManagerOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
-declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions & SchemaManagerOptions): Promise<[Store<G>, SchemaValidationResult]>;
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: RecordedReadStoreOptions & SchemaManagerOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options?: UnboundLiveStoreOptions & SchemaManagerOptions): Promise<[Store<G>, SchemaValidationResult]>;
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: (LiveStoreOptions & SchemaManagerOptions) | undefined): Promise<[Store<G> | RecordedReadStore<G>, SchemaValidationResult]>;
+declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options: (StoreOptions & SchemaManagerOptions) | undefined): Promise<[
+    Store<G> | HistoryStore<G> | RecordedReadStore<G>,
+    SchemaValidationResult
+]>;
+declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: HistoryStoreOptions & SchemaManagerOptions): Promise<[
+    AdapterHistoryStore<G, TNativeTransaction>,
+    SchemaValidationResult
+]>;
+declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: RecordedReadStoreOptions & SchemaManagerOptions): Promise<[
+    AdapterRecordedReadStore<G, TNativeTransaction>,
+    SchemaValidationResult
+]>;
+declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options?: UnboundLiveStoreOptions & SchemaManagerOptions): Promise<[AdapterStore<G, TNativeTransaction>, SchemaValidationResult]>;
+declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: (LiveStoreOptions & SchemaManagerOptions) | undefined): Promise<[
+    (AdapterStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>),
+    SchemaValidationResult
+]>;
+declare function createAdapterStoreWithSchema<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: (StoreOptions & SchemaManagerOptions) | undefined): Promise<[
+    (AdapterStore<G, TNativeTransaction> | AdapterHistoryStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>),
+    SchemaValidationResult
+]>;
 /**
  * Creates a Store after **verifying** that the database is at the same
  * schema version as the code graph — without running any DDL, bootstrap,
@@ -5223,8 +4187,30 @@ declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: Gr
  *   missing/stale/failed for this graph on this connection.
  */
 declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: HistoryStoreOptions): Promise<[HistoryStore<G>, SchemaValidationResult]>;
-declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: ExplicitRecordedReadLiveOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
-declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions): Promise<[Store<G>, SchemaValidationResult]>;
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: RecordedReadStoreOptions): Promise<[RecordedReadStore<G>, SchemaValidationResult]>;
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options?: UnboundLiveStoreOptions): Promise<[Store<G>, SchemaValidationResult]>;
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: LiveStoreOptions | undefined): Promise<[Store<G> | RecordedReadStore<G>, SchemaValidationResult]>;
+declare function createVerifiedStore<G extends GraphDef>(graph: G, backend: GraphBackend, options: StoreOptions | undefined): Promise<[
+    Store<G> | HistoryStore<G> | RecordedReadStore<G>,
+    SchemaValidationResult
+]>;
+declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: HistoryStoreOptions): Promise<[
+    AdapterHistoryStore<G, TNativeTransaction>,
+    SchemaValidationResult
+]>;
+declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: RecordedReadStoreOptions): Promise<[
+    AdapterRecordedReadStore<G, TNativeTransaction>,
+    SchemaValidationResult
+]>;
+declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options?: UnboundLiveStoreOptions): Promise<[AdapterStore<G, TNativeTransaction>, SchemaValidationResult]>;
+declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: LiveStoreOptions | undefined): Promise<[
+    (AdapterStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>),
+    SchemaValidationResult
+]>;
+declare function createVerifiedAdapterStore<G extends GraphDef, TNativeTransaction>(graph: G, backend: AdapterBackend<TNativeTransaction>, options: StoreOptions | undefined): Promise<[
+    (AdapterStore<G, TNativeTransaction> | AdapterHistoryStore<G, TNativeTransaction> | AdapterRecordedReadStore<G, TNativeTransaction>),
+    SchemaValidationResult
+]>;
 
 /**
  * StoreView — a read-only `(mode, asOf)` lens over a {@link Store}.
@@ -5284,6 +4270,12 @@ type StoreViewNeighborsOptions<G extends GraphDef> = Omit<NeighborsOptions<G>, k
 type StoreViewDegreeOptions<G extends GraphDef> = Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
 /** WCC options with the temporal axis removed (the view's pin supplies it). */
 type StoreViewWeaklyConnectedComponentsOptions<G extends GraphDef> = Omit<WeaklyConnectedComponentsOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Label-propagation options pinned to the view's temporal coordinate. */
+type StoreViewLabelPropagationOptions<G extends GraphDef> = Omit<LabelPropagationOptions<G>, keyof TemporalAlgorithmOptions>;
+/** PageRank options with the temporal axis removed (the view supplies it). */
+type StoreViewPageRankOptions<G extends GraphDef> = Omit<PageRankOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Personalized PageRank options pinned to the view's temporal coordinate. */
+type StoreViewPersonalizedPageRankOptions<G extends GraphDef> = Omit<PersonalizedPageRankOptions<G>, keyof TemporalAlgorithmOptions>;
 /** Graph-algorithm facade sealed to a {@link StoreView}'s coordinate. */
 type StoreViewGraphAlgorithms<G extends GraphDef> = Readonly<{
     shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
@@ -5292,7 +4284,10 @@ type StoreViewGraphAlgorithms<G extends GraphDef> = Readonly<{
     canReach: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewCanReachOptions<G>) => Promise<boolean>;
     neighbors: (node: NodeIdentifier, options: StoreViewNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
     degree: (node: NodeIdentifier, options?: StoreViewDegreeOptions<G>) => Promise<number>;
+    labelPropagation: (options: StoreViewLabelPropagationOptions<G>) => Promise<readonly LabelPropagationMembership[]>;
     weaklyConnectedComponents: (options: StoreViewWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
+    pageRank: (options: StoreViewPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
+    personalizedPageRank: (options: StoreViewPersonalizedPageRankOptions<G>) => Promise<readonly PageRankScore[]>;
 }>;
 /**
  * Shared base for the read-only views. Holds the pinned {@link ReadCoordinate}
@@ -5334,8 +4329,14 @@ declare abstract class CoordinatePinnedView<G extends GraphDef> {
     neighbors(node: NodeIdentifier, options: StoreViewNeighborsOptions<G>): Promise<readonly ReachableNode[]>;
     /** Counts active edges incident to `node` at this view's pinned coordinate. */
     degree(node: NodeIdentifier, options?: StoreViewDegreeOptions<G>): Promise<number>;
+    /** Deterministic label-propagation memberships at this view's coordinate. */
+    labelPropagation(options: StoreViewLabelPropagationOptions<G>): Promise<readonly LabelPropagationMembership[]>;
     /** Exact WCC memberships at this view's pinned coordinate. */
     weaklyConnectedComponents(options: StoreViewWeaklyConnectedComponentsOptions<G>): Promise<readonly WeaklyConnectedComponentMembership[]>;
+    /** Global PageRank scores at this view's pinned coordinate. */
+    pageRank(options: StoreViewPageRankOptions<G>): Promise<readonly PageRankScore[]>;
+    /** Personalized PageRank scores at this view's pinned coordinate. */
+    personalizedPageRank(options: StoreViewPersonalizedPageRankOptions<G>): Promise<readonly PageRankScore[]>;
 }
 /**
  * A read-only `(mode, asOf)` lens over a {@link Store}. Construct one via
@@ -5387,4 +4388,4 @@ declare class RecordedStoreView<G extends GraphDef> extends CoordinatePinnedView
     get edges(): RecordedStoreViewEdgeCollections<G>;
 }
 
-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 SearchScopeOptions 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 HistoryWithTransactionUnavailable as a7, type HookContext as a8, type HybridFulltextOptions as a9, type OperationHookContext as aA, type PaginateOptions as aB, type PaginatedResult as aC, type PathNode as aD, type Predicate as aE, PreparedQuery as aF, type PropsAccessor as aG, type QueryHookContext as aH, type QueryOptions as aI, type ReachableNode as aJ, type ReachableOptions as aK, type RebuildFulltextOptions as aL, type RebuildFulltextResult as aM, type ReclaimedVectorFieldEntry as aN, type RecordedInstant as aO, type RecordedReadStore as aP, RecordedStoreView as aQ, type RecordedStoreViewEdgeCollection as aR, type RecordedStoreViewEdgeCollections as aS, type RecordedStoreViewNodeCollection as aT, type RecordedStoreViewNodeCollections as aU, type RecursiveTraversalOptions as aV, type ReembedFunction as aW, type ReembedVectorFieldOptions as aX, type ReembedVectorFieldResult as aY, type SchemaIntrospection as aZ, type ScopedMeasure as a_, type HybridSearchHit as aa, type HybridSearchOptions as ab, type HybridVectorOptions as ac, type IfExistsMode as ad, type InitialQueryBuilder as ae, type KindIntrospection as af, type LiveStoreOptions as ag, type MaterializeRemovalsEntry as ah, type MaterializeRemovalsOptions as ai, type MaterializeRemovalsResult as aj, type MeasurableHistoryTransactionContext as ak, type MeasurableTransactionContext as al, type NeighborsOptions as am, type NoRecordedCoordinate as an, type NodeAccessor as ao, type NodeAlias as ap, type NodeBulkFindByIndexOptions as aq, type NodeCollection as ar, type NodeCurrentReads as as, type NodeGetOrCreateByConstraintOptions as at, type NodeGetOrCreateByConstraintResult as au, type NodeIdentifier as av, type NodeRef as aw, type NodeTemporalReads as ax, type NodeWrites as ay, type OntologyIntrospection as az, type EdgeAliasMap as b, getSearchableMetadata as b$, type SearchableMetadata as b0, type SearchableOptions as b1, type SearchableSchema as b2, type SelectContext as b3, type SelectableEdge as b4, type SelectableNode as b5, type ShortestPathOptions as b6, type ShortestPathResult as b7, type SqlAvailability as b8, type StoreHooks as b9, type TemporalAlgorithmOptions as bA, type TransactionContext as bB, type TransactionOutcome as bC, type TransactionReceipt as bD, type TraversalDirection as bE, type TypedEdgeCollection as bF, type TypedRecordedStoreViewEdgeCollection as bG, type TypedStoreViewEdgeCollection as bH, UnionableQuery as bI, type UpdateEdgeInput as bJ, type UpdateNodeInput as bK, type VectorSearchHit as bL, type VectorSearchOptions as bM, type WeaklyConnectedComponentMembership as bN, type WeaklyConnectedComponentsOptions as bO, type WeightedShortestPathOptions as bP, type WeightedShortestPathResult as bQ, asRecordedInstant as bR, createQueryBuilder as bS, createStore as bT, createStoreWithSchema as bU, createVerifiedStore as bV, defineSubgraphProject as bW, embedding as bX, exists as bY, fieldRef as bZ, getEmbeddingDimensions as b_, type StoreOptions as ba, type StoreProjection as bb, type StoreRef as bc, StoreSearch as bd, StoreView as be, type StoreViewCanReachOptions as bf, type StoreViewCoordinate as bg, type StoreViewDegreeOptions as bh, type StoreViewEdgeCollection as bi, type StoreViewEdgeCollections as bj, type StoreViewGraphAlgorithms as bk, type StoreViewNeighborsOptions as bl, type StoreViewNodeCollection as bm, type StoreViewNodeCollections as bn, type StoreViewReachableOptions as bo, type StoreViewShortestPathOptions as bp, type StoreViewSubgraphOptions as bq, type StoreViewWeaklyConnectedComponentsOptions as br, type StoreViewWeightedShortestPathOptions as bs, type StreamOptions as bt, type SubgraphEdgeResult as bu, type SubgraphNodeResult as bv, type SubgraphOptions as bw, type SubgraphResult as bx, type SubsetEdge as by, type SubsetNode as bz, QueryBuilder as c, inSubquery as c0, isEmbeddingSchema as c1, isParameterRef as c2, isSearchableSchema as c3, notExists as c4, notInSubquery as c5, param as c6, resolveGraphVectorSlots as c7, searchable as c8, 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 { ExecutableAggregateQuery as $, type AliasMap as A, type BaseStoreOptions as B, type ConstraintNames as C, type DegreeOptions as D, type EdgeAliasMap as E, type DynamicNodeType as F, type DynamicSelectableEdge as G, type HistoryStoreOptions as H, type DynamicSelectableNode as I, type Edge as J, type EdgeAccessor as K, type LiveStoreOptions as L, type EdgeBatchReads as M, type EdgeCollection as N, type EdgeFindByEndpointsOptions as O, type EdgeGetOrCreateByEndpointsOptions as P, type QueryCoordinateState as Q, type RecordedReadStoreOptions as R, type StoreOptions as S, TraversalBuilder as T, type UnboundLiveStoreOptions as U, type EdgeGetOrCreateByEndpointsResult as V, type EdgeIntrospection as W, type EdgeTemporalReads as X, type EdgeWrites as Y, type EmptyAliasMap as Z, type EmptyEdgeAliasMap as _, type Store as a, type RecursiveTraversalOptions as a$, ExecutableQuery as a0, type FieldAccessor as a1, type FulltextSearchHit as a2, type FulltextSearchOptions as a3, type GetOrCreateAction as a4, type GraphAlgorithms as a5, type GraphEdgeCollections as a6, type GraphNodeCollections as a7, type HistoryStoreBackend as a8, type HookContext as a9, type NodeRef as aA, type NodeTemporalReads as aB, type NodeWrites as aC, type OntologyIntrospection as aD, type OperationHookContext as aE, type PageRankOptions as aF, type PageRankScore as aG, type PaginateOptions as aH, type PaginatedResult as aI, type PathNode as aJ, type PersonalizedPageRankOptions as aK, type PersonalizedPageRankSeed as aL, type Predicate as aM, PreparedQuery as aN, type PropsAccessor as aO, type QueryHookContext as aP, type QueryOptions as aQ, type ReachableNode as aR, type ReachableOptions as aS, type RebuildFulltextOptions as aT, type RebuildFulltextResult as aU, type ReclaimedVectorFieldEntry as aV, RecordedStoreView as aW, type RecordedStoreViewEdgeCollection as aX, type RecordedStoreViewEdgeCollections as aY, type RecordedStoreViewNodeCollection as aZ, type RecordedStoreViewNodeCollections as a_, type HybridFulltextOptions as aa, type HybridSearchHit as ab, type HybridSearchOptions as ac, type HybridVectorOptions as ad, type IfExistsMode as ae, type InitialQueryBuilder as af, type KindIntrospection as ag, type LabelPropagationMembership as ah, type LabelPropagationOptions as ai, type MaterializeRemovalsEntry as aj, type MaterializeRemovalsOptions as ak, type MaterializeRemovalsResult as al, type MeasurableAdapterHistoryTransactionContext as am, type MeasurableAdapterTransactionContext as an, type MeasurableTransactionContext as ao, type NeighborsOptions as ap, type NoRecordedCoordinate as aq, type Node as ar, type NodeAccessor as as, type NodeAlias as at, type NodeBulkFindByIndexOptions as au, type NodeCollection as av, type NodeCurrentReads as aw, type NodeGetOrCreateByConstraintOptions as ax, type NodeGetOrCreateByConstraintResult as ay, type NodeIdentifier as az, type HistoryStore as b, createStoreWithSchema as b$, type ReembedFunction as b0, type ReembedVectorFieldOptions as b1, type ReembedVectorFieldResult as b2, type SchemaIntrospection as b3, type ScopedMeasure as b4, type SearchScopeOptions as b5, type SelectContext as b6, type SelectableEdge as b7, type SelectableNode as b8, type ShortestPathOptions as b9, type SubgraphNodeResult as bA, type SubgraphOptions as bB, type SubgraphResult as bC, type SubsetEdge as bD, type SubsetNode as bE, type TemporalAlgorithmOptions as bF, type TransactionContext as bG, type TransactionOutcome as bH, type TransactionReceipt as bI, type TraversalDirection as bJ, type TypedEdgeCollection as bK, type TypedRecordedStoreViewEdgeCollection as bL, type TypedStoreViewEdgeCollection as bM, UnionableQuery as bN, type UniqueIntrospection as bO, type UpdateEdgeInput as bP, type UpdateNodeInput as bQ, type VectorSearchHit as bR, type VectorSearchOptions as bS, type WeaklyConnectedComponentMembership as bT, type WeaklyConnectedComponentsOptions as bU, type WeightedShortestPathOptions as bV, type WeightedShortestPathResult as bW, createAdapterStore as bX, createAdapterStoreWithSchema as bY, createQueryBuilder as bZ, createStore as b_, type ShortestPathResult as ba, type SqlAvailability as bb, type StoreHooks as bc, type StoreProjection as bd, type StoreRef as be, StoreSearch as bf, StoreView as bg, type StoreViewCanReachOptions as bh, type StoreViewCoordinate as bi, type StoreViewDegreeOptions as bj, type StoreViewEdgeCollection as bk, type StoreViewEdgeCollections as bl, type StoreViewGraphAlgorithms as bm, type StoreViewLabelPropagationOptions as bn, type StoreViewNeighborsOptions as bo, type StoreViewNodeCollection as bp, type StoreViewNodeCollections as bq, type StoreViewPageRankOptions as br, type StoreViewPersonalizedPageRankOptions as bs, type StoreViewReachableOptions as bt, type StoreViewShortestPathOptions as bu, type StoreViewSubgraphOptions as bv, type StoreViewWeaklyConnectedComponentsOptions as bw, type StoreViewWeightedShortestPathOptions as bx, type StreamOptions as by, type SubgraphEdgeResult as bz, type RecordedReadStore as c, createVerifiedAdapterStore as c0, createVerifiedStore as c1, defineSubgraphProject as c2, exists as c3, fieldRef as c4, inSubquery as c5, isParameterRef as c6, notExists as c7, notInSubquery as c8, param as c9, 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 };