@nicia-ai/typegraph 0.35.0 → 0.37.0

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

@@ -1,8 +1,8 @@
-import { K as KindRegistry, G as GraphDef, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-DwQi8eV0.cjs';
-import { T as TemporalMode, N as NodeType, A as AnyEdgeType, g as EdgeType, E as EdgeRegistration, d as NodeId, K as KindEntity, b as NodeRegistration, e as EdgeId, s as UniquenessScope, n as Collation, f as KindAnnotations, m as Cardinality, q as EndpointExistence, G as GraphExtension } from './extension-types-ixRpJVUp.cjs';
+import { 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 { z } from 'zod';
-import { bc as ValueType, bd as PredicateExpression, ag as FulltextQueryMode, be as VectorMetricType, Q as QueryAst, J as JsonPointer, P as FieldRef, az as ParameterRef, aq as JsonPointerInput, G as GraphBackend, aS as TransactionBackend, aT as TraversalExpansion, f as SqlDialect, aO as SqlSchema, bf as Traversal, bg as NodePredicate, bh as ProjectedField, ay as OrderSpec, bi as AggregateOrderSpec, bj as GroupBySpec, am as HybridFusionOptions, bk as RecursiveCyclePolicy, W as TraversalDirection$1, bl as NodeRow, aa as ExternalRecordedReadSource, bm as EdgeRow, X as AdoptedTransaction, L as AggregateExpr, aM as SortDirection, a3 as CompiledSelectSql, F as FulltextStrategy, V as VectorStrategy, bn as VectorSlotMap, bo as RecordedReadBinding, bp as SelectiveField, bq as ComposableQuery, br as SetOperationType, bs as SetOperation, bt as VectorMetric, z as JsonSchema, bu as TransactionOptions } from './fulltext-strategy-CDkSSYhq.cjs';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-B4e9360H.cjs';
+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.
@@ -145,6 +145,16 @@ declare function isEmbeddingSchema(value: unknown): value is EmbeddingSchema;
  * 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.
@@ -1290,6 +1300,55 @@ type BaseStoreOptions = Readonly<{
      * manually after commit. `importGraph` handles its own refresh.
      */
     autoRefreshStatistics?: false | number;
+    /**
+     * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose
+     * validated props are value-identical to the existing live row. Default
+     * off.
+     *
+     * Enable this for at-least-once / replay materializers. An event log that
+     * re-delivers a byte-identical change would otherwise rewrite the row anyway:
+     * today an `upsertById` on an existing id calls `updateNode`
+     * unconditionally, allocating a fresh recorded instant and a new history row
+     * per re-delivery.
+     *
+     * The win is scoped to re-delivery of the **current** value. A full
+     * replay-from-zero over the current state still writes wherever the stream
+     * superseded a value in place: re-applying an older value over the live row
+     * is a genuine change (and restoring the current value afterwards is
+     * another), so only streams whose rows never supersede each other replay
+     * without churn. A rebuild that should avoid that re-walk belongs in a fresh
+     * store — replay into it and publish it, rather than re-applying the log
+     * over current state.
+     *
+     * When enabled, an upsert that would not change the stored value performs
+     * **no write at all**: no `updateNode`, no recorded-time capture, no history
+     * row, no revision-anchor advance, and no `update` operation hooks (nothing
+     * happened, so nothing is reported). It resolves with the **existing** node,
+     * preserving its original `validFrom` / `updatedAt` / `version`.
+     *
+     * Receipt shape is unchanged and needs no new signal: a coalesced upsert
+     * still counts as one write intent (`writes.total` includes it), but
+     * captures nothing (`receipt.recorded` stays `undefined` when it is the only
+     * write) — the same shape a no-op delete already produces, so a consumer
+     * that carries the prior anchor forward on `recorded === undefined` handles
+     * it unchanged.
+     *
+     * A write is coalesced only when **all** of the following hold; otherwise the
+     * normal write happens:
+     *   1. An existing row is found for the id (else it is a create).
+     *   2. That row is not soft-deleted (a deleted row resurrects — a real
+     *      change — and is never coalesced).
+     *   3. The caller passed no explicit `validFrom` / `validTo` (an explicit
+     *      temporal override is a deliberate request and is never coalesced;
+     *      applied per item in the bulk path).
+     *   4. The new props, merged over the stored props and run through the
+     *      kind's Zod schema (defaults applied, values normalized), are deeply
+     *      value-identical to the stored props (key order aside).
+     *
+     * Default-off because some consumers *want* an audit row per re-delivery as
+     * proof the event was reprocessed; coalescing removes that signal.
+     */
+    coalesceUnchangedUpserts?: boolean;
     /** SQL schema configuration from createSqlSchema(...) for custom table names */
     schema?: SqlSchema;
     /** Query default behaviors. */
@@ -1350,7 +1409,9 @@ interface StoreRef<T> {
     current: T;
 }
 /**
- * Summary returned by `store.transactionWithReceipt(fn)`.
+ * Result plus write summary. Returned by `store.transactionWithReceipt(fn)`,
+ * `store.withRecordedTransaction(externalTx, fn)` (the adopted-commit path), and
+ * `tx.measure(fn)` (a scoped sub-receipt). See {@link TransactionReceipt}.
  */
 type TransactionOutcome<T> = Readonly<{
     result: T;
@@ -1394,7 +1455,10 @@ type TransactionReceipt = Readonly<{
     /**
      * The recorded commit instant allocated for this store's graph by this
      * transaction. Undefined when history capture is off, the transaction is
-     * read-only, or no captured writes were flushed.
+     * read-only, or no captured writes were flushed. **Always undefined on a
+     * scoped receipt from {@link ScopedMeasure}** (`tx.measure`) — the recorded
+     * instant is a per-transaction flush concern allocated once when the whole
+     * transaction's capture flushes, unknowable mid-transaction.
      */
     recorded?: RecordedInstant;
 }>;
@@ -2032,6 +2096,14 @@ type RecordedStoreViewNodeCollections<G extends GraphDef> = {
 type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
     [K in keyof G["edges"] & string]-?: TypedRecordedStoreViewEdgeCollection<G["edges"][K]>;
 };
+/**
+ * Whether — and why — `tx.sql` can be used on a transaction context. A single
+ * required discriminant covering exactly the four states raw-SQL access can be
+ * in, so 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.
+ */
+type SqlAvailability = "available" | "history" | "revisionTracking" | "unavailable";
 /**
  * A typed transaction context with collection API.
  *
@@ -2074,11 +2146,43 @@ type RecordedStoreViewEdgeCollections<G extends GraphDef> = {
  * Drizzle database type at the call site.
  *
  * When the store was created with `{ history: true }` or
- * `{ revisionTracking: true }`, `tx.sql` is present but replaced by a fail-loud
- * guard because raw SQL would bypass recorded-time capture or the revision
- * anchor. Use the typed `tx.nodes` / `tx.edges` collections inside
- * `transaction()`, or use `store.withRecordedTransaction(externalTx, fn)` when
- * the relational layer owns the transaction boundary.
+ * `{ 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"`).
  *
  * @example
  * ```typescript
@@ -2093,6 +2197,26 @@ type TransactionContext<G extends GraphDef> = Readonly<{
     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
@@ -2116,6 +2240,40 @@ type TransactionContext<G extends GraphDef> = Readonly<{
      */
     runNodeOperationHooks<T>(operation: "create" | "update" | "delete", kind: string, id: string, fn: () => Promise<T>): Promise<T>;
 }>;
+/**
+ * Scoped write measurement, available only on the receipt-enabled transaction
+ * contexts (`transactionWithReceipt`, `withRecordedTransaction`). Runs `fn`,
+ * passing it a **scoped context** — a second view over the same transaction — and
+ * returns a {@link TransactionOutcome} whose receipt counts exactly the writes
+ * made *through that scoped context* (`scoped.nodes` / `scoped.edges`).
+ *
+ * Attribution is by **which context you write through**, not by timing. A write
+ * through the scoped context counts in both the scope and the outer receipt (it
+ * happened in the transaction); a write through the outer `tx` during the scope
+ * counts only in the outer receipt. This makes overlapping and concurrent
+ * measures safe by construction — two scopes running under `Promise.all`, each
+ * writing through its own scoped context, never cross-count. Nesting composes:
+ * `scoped.measure(...)` opens a child scope that counts in itself, every
+ * ancestor scope, and the outer receipt.
+ *
+ * Counts otherwise inherit {@link TransactionReceipt} (bulk by input length, a
+ * rejected write counts 0). The returned receipt's `recorded` is **always
+ * `undefined`**: the recorded commit instant is a per-transaction flush concern,
+ * unknowable mid-transaction.
+ */
+type ScopedMeasure<Context> = <T>(fn: (scoped: Context) => Promise<T>) => Promise<TransactionOutcome<T>>;
+/**
+ * A {@link TransactionContext} that also exposes {@link ScopedMeasure}. Only the
+ * receipt-enabled entry points (`transactionWithReceipt`,
+ * `withRecordedTransaction`) hand a callback this type; plain `transaction()`
+ * contexts have no recorder and therefore no `measure`, keeping that path
+ * zero-overhead. Assignable to {@link TransactionContext}, so a projector helper
+ * typed `(tx: TransactionContext<G>) => ...` accepts a measurable context. The
+ * scoped context handed to `measure` is itself measurable, so scopes nest.
+ */
+type MeasurableTransactionContext<G extends GraphDef> = TransactionContext<G> & Readonly<{
+    measure: ScopedMeasure<MeasurableTransactionContext<G>>;
+}>;
 /**
  * Replace branded `NodeId` / `EdgeId` with plain `string` in each
  * method's parameter list. Return types are preserved unchanged.
@@ -2975,14 +3133,10 @@ declare function createQueryBuilder<G extends GraphDef>(graphId: string, registr
  */
 type TraversalDirection = "out" | "in" | "both";
 /**
- * Cycle-handling strategy during recursive traversal.
- *
- * - `"prevent"` — skip any node already on the current path (default).
- *   Guarantees termination even in cyclic graphs.
- * - `"allow"` — permit revisiting nodes. Only safe with a bounded `maxHops`.
- *
- * Aliased to `RecursiveCyclePolicy` so algorithms and query-builder traversals
- * share a single canonical union.
+ * Cycle-handling option retained for compatibility with recursive query-builder
+ * traversals. Store algorithms are set-based and visit each node once at its
+ * minimum depth, so `"prevent"` and `"allow"` produce the same algorithm
+ * result. Aliased to `RecursiveCyclePolicy` so both APIs share one union.
  */
 type AlgorithmCyclePolicy = RecursiveCyclePolicy;
 /**
@@ -3006,10 +3160,38 @@ type TemporalAlgorithmOptions = NoRecordedCoordinate & Readonly<{
 type InternalTemporalAlgorithmOptions = Omit<TemporalAlgorithmOptions, "recordedAsOf"> & Readonly<{
     recordedAsOf?: RecordedInstant;
 }>;
+/**
+ * Opt-in, transaction-scoped override of the session's working memory for
+ * iterative graph rounds.
+ *
+ * When set, PostgreSQL applies it with `SET LOCAL work_mem` semantics inside
+ * the operation's own transaction — the override ends with the transaction
+ * and the session and server settings are never modified. When omitted (the
+ * default), the operation inherits the server's configured `work_mem`.
+ *
+ * `work_mem` is a threshold each sort/hash operator (and each parallel
+ * worker) may allocate up to, NOT a per-operation budget: a single round can
+ * allocate several multiples of it, and concurrent algorithm calls multiply
+ * again. Raise it deliberately — e.g. `"64MB"` for large single-tenant
+ * analytical runs where the configured default spills whole-graph sorts to
+ * disk — not as a blanket setting on a shared cluster.
+ *
+ * The value must be a plain integer with a `kB`, `MB`, or `GB` suffix within
+ * PostgreSQL's accepted `work_mem` range (`64kB` to `2147483647kB`); both
+ * backends reject malformed or out-of-range values identically. SQLite has
+ * no equivalent setting and otherwise ignores the option.
+ */
+type IterativeMemoryOptions = Readonly<{
+    /**
+     * Transaction-scoped `work_mem` override, e.g. `"64MB"`. Omit to inherit
+     * the server's configured setting.
+     */
+    workingMemory?: string;
+}>;
 /**
  * Base options for traversal-style algorithms.
  */
-type BaseTraversalOptions<G extends GraphDef> = TemporalAlgorithmOptions & Readonly<{
+type BaseTraversalOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeMemoryOptions & Readonly<{
     /** Edge kinds to follow. At least one kind is required. */
     edges: readonly EdgeKinds<G>[];
     /**
@@ -3019,7 +3201,7 @@ type BaseTraversalOptions<G extends GraphDef> = TemporalAlgorithmOptions & Reado
     maxHops?: number;
     /** Direction of traversal (default: `"out"`). */
     direction?: TraversalDirection;
-    /** Cycle policy (default: `"prevent"`). */
+    /** Compatibility option; set-based algorithms always visit a node once. */
     cyclePolicy?: AlgorithmCyclePolicy;
 }>;
 type InternalBaseTraversalOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<BaseTraversalOptions<G>, keyof TemporalAlgorithmOptions>;
@@ -3056,6 +3238,56 @@ type ShortestPathResult = Readonly<{
  */
 type ShortestPathOptions<G extends GraphDef> = BaseTraversalOptions<G>;
 type InternalShortestPathOptions<G extends GraphDef> = InternalBaseTraversalOptions<G>;
+/**
+ * Options for `weightedShortestPath`.
+ *
+ * Each traversed edge contributes the value of `weightProperty` — a JSON
+ * number stored on the edge — to the path's total weight. The traversal
+ * fails fast with `InvalidEdgeWeightError` (before any rounds run) when any
+ * visible edge of the selected kinds has a negative, non-numeric, or
+ * out-of-range weight, or is missing the property with no `defaultWeight`
+ * configured. Weight arithmetic uses IEEE 754 doubles on both backends:
+ * total weights are always backend-identical, and — unless the `edges` list
+ * is large enough to exceed the backend's bind-parameter budget (hundreds
+ * of kinds in one call, where equal-weight predecessor ties may resolve
+ * differently) — so is the returned node sequence.
+ *
+ * Unlike `shortestPath`, there is no `maxHops`: cost-ordered discovery does
+ * not settle nodes in hop order, so a hop bound is not a natural stopping
+ * rule. `maxIterations` caps relaxation rounds purely as a runaway backstop
+ * — the algorithm normally converges (and prunes against the best known
+ * target distance) long before reaching it.
+ */
+type WeightedShortestPathOptions<G extends GraphDef> = Omit<BaseTraversalOptions<G>, "maxHops" | "cyclePolicy"> & Readonly<{
+    /**
+     * Top-level edge property supplying each edge's non-negative numeric
+     * weight.
+     */
+    weightProperty: string;
+    /**
+     * Weight substituted for edges missing `weightProperty`. Must be a
+     * non-negative number within the same upper bound the audit applies to
+     * stored weights (~9.7e289, so accumulated path sums can never
+     * overflow). Without it, a missing weight throws
+     * `InvalidEdgeWeightError`.
+     */
+    defaultWeight?: number;
+    /** Maximum relaxation rounds before throwing. Defaults to 1000. */
+    maxIterations?: number;
+}>;
+type InternalWeightedShortestPathOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<WeightedShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
+/**
+ * Result of `weightedShortestPath`: the minimum-total-weight node sequence
+ * from source to target.
+ */
+type WeightedShortestPathResult = Readonly<{
+    /** Ordered nodes from source to target (inclusive). */
+    nodes: readonly PathNode[];
+    /** Number of edges traversed. Equals `nodes.length - 1`. */
+    depth: number;
+    /** Sum of the traversed edges' weights. 0 for a self-path. */
+    totalWeight: number;
+}>;
 /**
  * Options for `reachable`.
  *
@@ -3075,14 +3307,14 @@ type InternalReachableOptions<G extends GraphDef> = InternalBaseTraversalOptions
  * "2-hop neighbors" reads more naturally than "reachable with maxHops=2".
  * The source is always excluded.
  */
-type NeighborsOptions<G extends GraphDef> = TemporalAlgorithmOptions & Readonly<{
+type NeighborsOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeMemoryOptions & Readonly<{
     /** Edge kinds to follow. At least one kind is required. */
     edges: readonly EdgeKinds<G>[];
     /** Maximum neighborhood depth (default: 1). Must be between 1 and 1000. */
     depth?: number;
     /** Direction of traversal (default: `"out"`). */
     direction?: TraversalDirection;
-    /** Cycle policy (default: `"prevent"`). */
+    /** Compatibility option; set-based algorithms always visit a node once. */
     cyclePolicy?: AlgorithmCyclePolicy;
 }>;
 type InternalNeighborsOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<NeighborsOptions<G>, keyof TemporalAlgorithmOptions>;
@@ -3102,6 +3334,34 @@ type DegreeOptions<G extends GraphDef> = TemporalAlgorithmOptions & Readonly<{
     direction?: TraversalDirection;
 }>;
 type InternalDegreeOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
+/**
+ * Options for exact weakly connected components.
+ *
+ * Selected edges are treated as undirected, regardless of their declared
+ * direction. By default every visible graph node is returned; `nodeKinds`
+ * restricts the operation to the induced subgraph over those kinds. Nodes in
+ * scope with no selected incident edge form singleton components.
+ */
+type WeaklyConnectedComponentsOptions<G extends GraphDef> = TemporalAlgorithmOptions & IterativeMemoryOptions & Readonly<{
+    /** Edge kinds whose undirected projection defines connectivity. */
+    edges: readonly EdgeKinds<G>[];
+    /** Optional node kinds defining the induced subgraph to analyze. */
+    nodeKinds?: readonly NodeKinds<G>[];
+    /** Maximum label-propagation rounds before throwing. Defaults to 1000. */
+    maxIterations?: number;
+}>;
+type InternalWeaklyConnectedComponentsOptions<G extends GraphDef> = InternalTemporalAlgorithmOptions & Omit<WeaklyConnectedComponentsOptions<G>, keyof TemporalAlgorithmOptions>;
+/** One node's membership in an exact weakly connected component. */
+type WeaklyConnectedComponentMembership = Readonly<{
+    id: string;
+    kind: string;
+    /** Deterministic minimum node id in this component. */
+    componentId: string;
+    /** Kind paired with `componentId`; node identity is `(kind, id)`. */
+    componentKind: string;
+    /** Number of visible nodes in this component. */
+    size: number;
+}>;
 
 /**
  * Raw node id or any object with an `id: string` field. Covers `Node`,
@@ -3136,6 +3396,27 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      * ```
      */
     shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: ShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
+    /**
+     * Finds the minimum-total-weight path from `from` to `to`, weighting each
+     * traversed edge by the numeric `weightProperty` stored on it. Returns
+     * `undefined` when no path exists. Weights must be non-negative; a
+     * negative, non-numeric, or (without `defaultWeight`) missing weight on
+     * any visible edge of the selected kinds throws `InvalidEdgeWeightError`
+     * before traversal starts.
+     *
+     * @example
+     * ```typescript
+     * const path = await store.algorithms.weightedShortestPath(alice, bob, {
+     *   edges: ["knows"],
+     *   weightProperty: "interactionCost",
+     *   direction: "both",
+     * });
+     * if (path) {
+     *   console.log(`total weight ${path.totalWeight} over ${path.depth} hops`);
+     * }
+     * ```
+     */
+    weightedShortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: WeightedShortestPathOptions<G>) => Promise<WeightedShortestPathResult | undefined>;
     /**
      * Returns every node reachable from `from` within `maxHops` edges of the
      * allowed kinds. Each node carries its minimum discovered depth.
@@ -3143,7 +3424,7 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
     reachable: (from: NodeIdentifier, options: ReachableOptions<G>) => Promise<readonly ReachableNode[]>;
     /**
      * Fast boolean check: is `to` reachable from `from` within `maxHops`
-     * edges? Short-circuits the underlying recursive CTE with `LIMIT 1`.
+     * edges? Uses bidirectional BFS and stops when the frontiers meet.
      */
     canReach: (from: NodeIdentifier, to: NodeIdentifier, options: BaseTraversalOptions<G>) => Promise<boolean>;
     /**
@@ -3158,13 +3439,22 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
      * With `direction: "both"` (default), self-loops contribute once.
      */
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
+    /**
+     * Computes exact weakly connected components over the selected edge kinds.
+     *
+     * Iterative: runs multiple SQL rounds in one snapshot and requires
+     * `backend.capabilities.graphAnalytics.supported`.
+     */
+    weaklyConnectedComponents: (options: WeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
 }>;
 type InternalGraphAlgorithms<G extends GraphDef> = Readonly<{
     shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: InternalShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
+    weightedShortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: InternalWeightedShortestPathOptions<G>) => Promise<WeightedShortestPathResult | undefined>;
     reachable: (from: NodeIdentifier, options: InternalReachableOptions<G>) => Promise<readonly ReachableNode[]>;
     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>;
+    weaklyConnectedComponents: (options: InternalWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
 }>;
 
 type RebuildFulltextOptions = Readonly<{
@@ -3901,9 +4191,11 @@ declare class Store<G extends GraphDef> {
      * Tier 1 graph algorithms: shortest path, reachability, neighborhoods, and
      * degree centrality.
      *
-     * Each call compiles to a single recursive-CTE query against the backend.
-     * The facade is built lazily on first access and cached for the lifetime
-     * of the store.
+     * 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
@@ -4277,13 +4569,16 @@ declare class Store<G extends GraphDef> {
      *   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; it is `undefined` only on the
-     *   non-transactional fallback.
-     *   When the store was created with `{ history: true }` or
-     *   `{ revisionTracking: true }`, `tx.sql` is replaced by a fail-loud guard
-     *   because raw SQL would bypass recorded-time capture or revision tracking;
-     *   use the typed collections inside
-     *   `transaction()` or {@link Store.withRecordedTransaction}.
+     *   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
@@ -4355,11 +4650,12 @@ declare class Store<G extends GraphDef> {
      *
      * The receipt does not count writes that bypass the `tx.nodes.*` /
      * `tx.edges.*` collections, such as direct backend writes, raw SQL, or
-     * import helpers. Adopted transactions (`withTransaction` /
-     * `withRecordedTransaction`) do not produce receipts in this version
-     * because their commit belongs to the caller. On non-transactional
-     * backends, the receipt is still returned, but it describes operations
-     * that individually committed rather than one atomic commit; if the
+     * 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.
      *
@@ -4367,6 +4663,12 @@ declare class Store<G extends GraphDef> {
      * 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) => {
@@ -4377,8 +4679,8 @@ declare class Store<G extends GraphDef> {
      * outcome.receipt.writes; // { nodes: { Person: 1 }, edges: {}, total: 1 }
      * ```
      */
-    transactionWithReceipt<T>(this: HistoryStore<G>, fn: (tx: HistoryTransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<TransactionOutcome<T>>;
-    transactionWithReceipt<T>(fn: (tx: TransactionContext<G>) => Promise<T>, options?: TransactionOptions): Promise<TransactionOutcome<T>>;
+    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
@@ -4431,11 +4733,14 @@ declare class Store<G extends GraphDef> {
      *
      * Not available when the store was created with `{ history: true }`: a
      * caller-owned transaction context would let writes happen after capture has
-     * lost its flush point, so this throws `ConfigurationError`
-     * (`RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`). Use
-     * {@link Store.withRecordedTransaction} on a history-enabled store, which
-     * adopts the same external transaction but flushes recorded-time capture
-     * before the caller commits.
+     * 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
@@ -4451,7 +4756,7 @@ declare class Store<G extends GraphDef> {
      *   `createStoreWithSchema`). Rolls back the caller's transaction
      *   without emitting any DDL.
      */
-    withTransaction(externalTx: AdoptedTransaction): TransactionContext<G>;
+    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
@@ -4462,16 +4767,55 @@ declare class Store<G extends GraphDef> {
      * 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.
+     * 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 }`:
      *
-     * Like {@link Store.withTransaction}, the graph writes and any raw `tx.sql`
-     * statements share the caller's one pinned connection. TypeGraph serializes
-     * the statements its collections issue; sequence your own raw statements (and
-     * don't `Promise.all` them with graph writes) so two queries never race on
-     * that connection.
+     * ```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: HistoryTransactionContext<G>) => Promise<T>): Promise<T>;
-    withRecordedTransaction<T>(externalTx: AdoptedTransaction, fn: (tx: TransactionContext<G>) => Promise<T>): Promise<T>;
+    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.
      *
@@ -4649,6 +4993,19 @@ declare class Store<G extends GraphDef> {
      *   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.
@@ -4729,6 +5086,17 @@ type HistoryTransactionContext<G extends GraphDef> = Omit<TransactionContext<G>,
     backend: HistorySafeTransactionBackend;
     sql?: never;
 }>;
+/**
+ * The {@link HistoryTransactionContext} handed to a `withRecordedTransaction`
+ * callback, extended with {@link ScopedMeasure}. Its `measure` scopes to a child
+ * {@link MeasurableHistoryTransactionContext} (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 RecordedReadStore<G extends GraphDef> = Store<G> & Readonly<{
     recordedReadBound: true;
 }>;
@@ -4737,6 +5105,15 @@ type HistoryStore<G extends GraphDef> = Store<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"]>;
 }>;
@@ -4894,12 +5271,29 @@ type StoreViewSubgraphOptions<G extends GraphDef, EK extends EdgeKinds<G>, NK ex
 type StoreViewReachableOptions<G extends GraphDef> = Omit<ReachableOptions<G>, keyof TemporalAlgorithmOptions>;
 /** `shortestPath` options with the temporal axis removed (the pin supplies it). */
 type StoreViewShortestPathOptions<G extends GraphDef> = Omit<ShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
+/**
+ * `weightedShortestPath` options with the temporal axis removed (the pin
+ * supplies it).
+ */
+type StoreViewWeightedShortestPathOptions<G extends GraphDef> = Omit<WeightedShortestPathOptions<G>, keyof TemporalAlgorithmOptions>;
 /** `canReach` options with the temporal axis removed (the pin supplies it). */
 type StoreViewCanReachOptions<G extends GraphDef> = Omit<BaseTraversalOptions<G>, keyof TemporalAlgorithmOptions>;
 /** `neighbors` options with the temporal axis removed (the pin supplies it). */
 type StoreViewNeighborsOptions<G extends GraphDef> = Omit<NeighborsOptions<G>, keyof TemporalAlgorithmOptions>;
 /** `degree` options with the temporal axis removed (the pin supplies it). */
 type StoreViewDegreeOptions<G extends GraphDef> = Omit<DegreeOptions<G>, keyof TemporalAlgorithmOptions>;
+/** WCC options with the temporal axis removed (the view's pin supplies it). */
+type StoreViewWeaklyConnectedComponentsOptions<G extends GraphDef> = Omit<WeaklyConnectedComponentsOptions<G>, keyof TemporalAlgorithmOptions>;
+/** Graph-algorithm facade sealed to a {@link StoreView}'s coordinate. */
+type StoreViewGraphAlgorithms<G extends GraphDef> = Readonly<{
+    shortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>) => Promise<ShortestPathResult | undefined>;
+    weightedShortestPath: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>) => Promise<WeightedShortestPathResult | undefined>;
+    reachable: (from: NodeIdentifier, options: StoreViewReachableOptions<G>) => Promise<readonly ReachableNode[]>;
+    canReach: (from: NodeIdentifier, to: NodeIdentifier, options: StoreViewCanReachOptions<G>) => Promise<boolean>;
+    neighbors: (node: NodeIdentifier, options: StoreViewNeighborsOptions<G>) => Promise<readonly ReachableNode[]>;
+    degree: (node: NodeIdentifier, options?: StoreViewDegreeOptions<G>) => Promise<number>;
+    weaklyConnectedComponents: (options: StoreViewWeaklyConnectedComponentsOptions<G>) => Promise<readonly WeaklyConnectedComponentMembership[]>;
+}>;
 /**
  * Shared base for the read-only views. Holds the pinned {@link ReadCoordinate}
  * and delegates the graph algorithms, `subgraph`, and `query` to the live store
@@ -4923,11 +5317,15 @@ declare abstract class CoordinatePinnedView<G extends GraphDef> {
      * view's coordinate cannot be overridden on a per-query basis.
      */
     query(): InitialQueryBuilder<G, "sealed">;
-    protected algorithms(): InternalGraphAlgorithms<G>;
+    protected internalAlgorithms(): InternalGraphAlgorithms<G>;
+    /** Graph algorithms pinned to this view's immutable temporal coordinate. */
+    get algorithms(): StoreViewGraphAlgorithms<G>;
     /** Extracts a subgraph at this view's pinned coordinate. */
     subgraph<const EK extends EdgeKinds<G>, const NK extends NodeKinds<G> = NodeKinds<G>, const P extends SubgraphProject<G, NK, EK> | undefined = undefined>(rootId: NodeId<AllNodeTypes<G>>, options: StoreViewSubgraphOptions<G, EK, NK, P>): Promise<SubgraphResult<G, NK, EK, P>>;
     /** Shortest path between two nodes at this view's pinned coordinate. */
     shortestPath(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewShortestPathOptions<G>): Promise<ShortestPathResult | undefined>;
+    /** Minimum-total-weight path at this view's pinned coordinate. */
+    weightedShortestPath(from: NodeIdentifier, to: NodeIdentifier, options: StoreViewWeightedShortestPathOptions<G>): Promise<WeightedShortestPathResult | undefined>;
     /** Nodes reachable from `from` at this view's pinned coordinate. */
     reachable(from: NodeIdentifier, options: StoreViewReachableOptions<G>): Promise<readonly ReachableNode[]>;
     /** Whether `to` is reachable from `from` at this view's pinned coordinate. */
@@ -4936,6 +5334,8 @@ 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>;
+    /** Exact WCC memberships at this view's pinned coordinate. */
+    weaklyConnectedComponents(options: StoreViewWeaklyConnectedComponentsOptions<G>): Promise<readonly WeaklyConnectedComponentMembership[]>;
 }
 /**
  * A read-only `(mode, asOf)` lens over a {@link Store}. Construct one via
@@ -4987,4 +5387,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 SelectContext as a$, type GraphAlgorithms as a0, type GraphEdgeCollections as a1, type GraphNodeCollections as a2, type HistorySafeBackend as a3, type HistorySafeTransactionBackend as a4, type HistoryStoreOptions as a5, type HistoryTransactionContext as a6, type HookContext as a7, type HybridFulltextOptions as a8, type HybridSearchHit as a9, type PathNode as aA, type Predicate as aB, PreparedQuery as aC, type PropsAccessor as aD, type QueryHookContext as aE, type QueryOptions as aF, type ReachableNode as aG, type ReachableOptions as aH, type RebuildFulltextOptions as aI, type RebuildFulltextResult as aJ, type ReclaimedVectorFieldEntry as aK, type RecordedInstant as aL, type RecordedReadStore as aM, RecordedStoreView as aN, type RecordedStoreViewEdgeCollection as aO, type RecordedStoreViewEdgeCollections as aP, type RecordedStoreViewNodeCollection as aQ, type RecordedStoreViewNodeCollections as aR, type RecursiveTraversalOptions as aS, type ReembedFunction as aT, type ReembedVectorFieldOptions as aU, type ReembedVectorFieldResult as aV, type SchemaIntrospection as aW, type SearchScopeOptions as aX, type SearchableMetadata as aY, type SearchableOptions as aZ, type SearchableSchema as a_, type HybridSearchOptions as aa, type HybridVectorOptions as ab, type IfExistsMode as ac, type InitialQueryBuilder as ad, type KindIntrospection as ae, type LiveStoreOptions as af, type MaterializeRemovalsEntry as ag, type MaterializeRemovalsOptions as ah, type MaterializeRemovalsResult as ai, type NeighborsOptions as aj, type NoRecordedCoordinate as ak, type NodeAccessor as al, type NodeAlias as am, type NodeBulkFindByIndexOptions as an, type NodeCollection as ao, type NodeCurrentReads as ap, type NodeGetOrCreateByConstraintOptions as aq, type NodeGetOrCreateByConstraintResult as ar, type NodeIdentifier as as, type NodeRef as at, type NodeTemporalReads as au, type NodeWrites as av, type OntologyIntrospection as aw, type OperationHookContext as ax, type PaginateOptions as ay, type PaginatedResult as az, type EdgeAliasMap as b, type SelectableEdge as b0, type SelectableNode as b1, type ShortestPathOptions as b2, type ShortestPathResult as b3, type StoreHooks as b4, type StoreOptions as b5, type StoreProjection as b6, type StoreRef as b7, StoreSearch as b8, StoreView as b9, UnionableQuery as bA, type UpdateEdgeInput as bB, type UpdateNodeInput as bC, type VectorSearchHit as bD, type VectorSearchOptions as bE, asRecordedInstant as bF, createQueryBuilder as bG, createStore as bH, createStoreWithSchema as bI, createVerifiedStore as bJ, defineSubgraphProject as bK, embedding as bL, exists as bM, fieldRef as bN, getEmbeddingDimensions as bO, getSearchableMetadata as bP, inSubquery as bQ, isEmbeddingSchema as bR, isParameterRef as bS, isSearchableSchema as bT, notExists as bU, notInSubquery as bV, param as bW, searchable as bX, type StoreViewCanReachOptions as ba, type StoreViewCoordinate as bb, type StoreViewDegreeOptions as bc, type StoreViewEdgeCollection as bd, type StoreViewEdgeCollections as be, type StoreViewNeighborsOptions as bf, type StoreViewNodeCollection as bg, type StoreViewNodeCollections as bh, type StoreViewReachableOptions as bi, type StoreViewShortestPathOptions as bj, type StoreViewSubgraphOptions as bk, type StreamOptions as bl, type SubgraphEdgeResult as bm, type SubgraphNodeResult as bn, type SubgraphOptions as bo, type SubgraphResult as bp, type SubsetEdge as bq, type SubsetNode as br, type TemporalAlgorithmOptions as bs, type TransactionContext as bt, type TransactionOutcome as bu, type TransactionReceipt as bv, type TraversalDirection as bw, type TypedEdgeCollection as bx, type TypedRecordedStoreViewEdgeCollection as by, type TypedStoreViewEdgeCollection as bz, QueryBuilder as c, type EmptyRecursiveAliasMap as d, type AggregateResult as e, type AlgorithmCyclePolicy as f, type AnyEdge as g, type AnyNode as h, type BatchResults as i, type BatchableQuery as j, type CreateEdgeInput as k, type CreateNodeInput as l, type DegreeOptions as m, type DynamicEdgeAccessor as n, type DynamicEdgeCollection as o, type DynamicEdgeType as p, type DynamicFieldBuilder as q, type DynamicNodeAccessor as r, type DynamicNodeCollection as s, type DynamicNodeType as t, type DynamicSelectableEdge as u, type DynamicSelectableNode as v, type Edge as w, type EdgeAccessor as x, type EdgeBatchReads as y, type EdgeCollection as z };
+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 };