@nicia-ai/typegraph 0.36.0 → 0.37.1

package/dist/{store-view-DplHC3Nt.d.ts → store-view-ANL6mTph.d.ts}

@@ -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-ejUCB52T.js';
-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.js';
+import { G as GraphDef, K as KindRegistry, w as EdgeKinds, t as NodeKinds, v as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-D00_NXvT.js';
+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.js';
 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-B57yvC5Q.js';
-import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-te9TPMMJ.js';
+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-DebsMrqg.js';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult, c as MaterializeSystemIndexesOptions } from './materialize-indexes-zK2J_flP.js';
 
 /**
  * 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.
@@ -1296,13 +1306,19 @@ type BaseStoreOptions = Readonly<{
      * off.
      *
      * Enable this for at-least-once / replay materializers. An event log that
-     * re-delivers a byte-identical change, or a full replay that reprocesses an
-     * already-materialized log, would otherwise rewrite every row it touches:
+     * 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. A rebuild — the workload replay is recommended for — is
-     * the one that inflates recorded history most, with a dense band of
-     * "changes" that changed nothing.
+     * 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
@@ -3117,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;
 /**
@@ -3148,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>[];
     /**
@@ -3161,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>;
@@ -3198,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`.
  *
@@ -3217,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>;
@@ -3244,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`,
@@ -3278,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.
@@ -3285,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>;
     /**
@@ -3300,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<{
@@ -4043,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
@@ -4843,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.
@@ -5108,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
@@ -5137,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. */
@@ -5150,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
@@ -5201,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 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, param 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 TransactionReceipt as bA, type TraversalDirection as bB, type TypedEdgeCollection as bC, type TypedRecordedStoreViewEdgeCollection as bD, type TypedStoreViewEdgeCollection as bE, UnionableQuery as bF, type UpdateEdgeInput as bG, type UpdateNodeInput as bH, type VectorSearchHit as bI, type VectorSearchOptions as bJ, asRecordedInstant as bK, createQueryBuilder as bL, createStore as bM, createStoreWithSchema as bN, createVerifiedStore as bO, defineSubgraphProject as bP, embedding as bQ, exists as bR, fieldRef as bS, getEmbeddingDimensions as bT, getSearchableMetadata as bU, inSubquery as bV, isEmbeddingSchema as bW, isParameterRef as bX, isSearchableSchema as bY, notExists as bZ, notInSubquery 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 StoreViewNeighborsOptions as bk, type StoreViewNodeCollection as bl, type StoreViewNodeCollections as bm, type StoreViewReachableOptions as bn, type StoreViewShortestPathOptions as bo, type StoreViewSubgraphOptions as bp, type StreamOptions as bq, type SubgraphEdgeResult as br, type SubgraphNodeResult as bs, type SubgraphOptions as bt, type SubgraphResult as bu, type SubsetEdge as bv, type SubsetNode as bw, type TemporalAlgorithmOptions as bx, type TransactionContext as by, type TransactionOutcome as bz, QueryBuilder as c, searchable as c0, 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 };