effect 4.0.0-beta.98 → 4.0.0-rc.108

package/dist/Graph.d.ts

@@ -13,6 +13,7 @@ import * as Equal from "./Equal.ts";
 import type { Inspectable } from "./Inspectable.ts";
 import * as Option from "./Option.ts";
 import type { Pipeable } from "./Pipeable.ts";
+import type { Covariant, Invariant } from "./Types.ts";
 declare const TypeId = "~effect/collections/Graph";
 /**
  * Node index for node identification using plain numbers.
@@ -97,25 +98,19 @@ export declare class Edge<E> extends Data.Class<{
  */
 export type Kind = "directed" | "undirected";
 /**
- * Common structural interface shared by immutable and mutable graphs.
+ * Common public protocol for graph values.
  *
  * **Details**
  *
- * Contains the node and edge maps, adjacency indexes, allocation counters, and
- * shared protocols used by both `Graph` and `MutableGraph`.
+ * Contains only the runtime marker and shared protocols. Graph storage is kept
+ * internal; use module functions such as `nodes`, `edges`, `getNode`, and
+ * `getEdge` to inspect graph contents.
  *
  * @category models
  * @since 3.18.0
  */
 export interface Proto<out N, out E> extends Iterable<readonly [NodeIndex, N]>, Equal.Equal, Pipeable, Inspectable {
-    readonly [TypeId]: typeof TypeId;
-    readonly nodes: Map<NodeIndex, N>;
-    readonly edges: Map<EdgeIndex, Edge<E>>;
-    readonly adjacency: Map<NodeIndex, Array<EdgeIndex>>;
-    readonly reverseAdjacency: Map<NodeIndex, Array<EdgeIndex>>;
-    nextNodeIndex: NodeIndex;
-    nextEdgeIndex: EdgeIndex;
-    acyclic: Option.Option<boolean>;
+    readonly [TypeId]: Graph.Variance<N, E>;
 }
 /**
  * Immutable graph interface.
@@ -136,6 +131,24 @@ export interface Graph<out N, out E, T extends Kind = "directed"> extends Proto<
     readonly type: T;
     readonly mutable: false;
 }
+/**
+ * Companion namespace containing type-level metadata for immutable graphs.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export declare namespace Graph {
+    /**
+     * Type-level variance marker for immutable graphs.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface Variance<out N, out E> {
+        readonly _N: Covariant<N>;
+        readonly _E: Covariant<E>;
+    }
+}
 /**
  * Mutable graph interface.
  *
@@ -152,10 +165,29 @@ export interface Graph<out N, out E, T extends Kind = "directed"> extends Proto<
  * @category models
  * @since 3.18.0
  */
-export interface MutableGraph<out N, out E, T extends Kind = "directed"> extends Proto<N, E> {
+export interface MutableGraph<in out N, in out E, T extends Kind = "directed"> extends Iterable<readonly [NodeIndex, N]>, Equal.Equal, Pipeable, Inspectable {
+    readonly [TypeId]: MutableGraph.Variance<N, E>;
     readonly type: T;
     readonly mutable: true;
 }
+/**
+ * Companion namespace containing type-level metadata for scoped mutable graphs.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export declare namespace MutableGraph {
+    /**
+     * Type-level variance marker for scoped mutable graphs.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface Variance<in out N, in out E> {
+        readonly _N: Invariant<N>;
+        readonly _E: Invariant<E>;
+    }
+}
 /**
  * Immutable graph type for source-to-target relationships.
  *
@@ -252,7 +284,7 @@ export declare class GraphError extends GraphError_base<{
 }
 /**
  * Returns `true` if a value has the graph runtime type identifier, narrowing
- * it to a `Graph`.
+ * it to an immutable or mutable graph.
  *
  * **When to use**
  *
@@ -261,18 +293,46 @@ export declare class GraphError extends GraphError_base<{
  * **Gotchas**
  *
  * This guard checks the shared graph runtime type identifier and does not
- * distinguish immutable graphs from mutable graphs.
+ * distinguish immutable graphs from mutable graphs or directed graphs from
+ * undirected graphs.
  *
  * @category guards
  * @since 4.0.0
  */
-export declare const isGraph: (u: unknown) => u is Graph<unknown, unknown>;
+export declare const isGraph: <N = unknown, E = unknown, T extends Kind = Kind, U = never>(u: U | Graph<N, E, T> | MutableGraph<N, E, T>) => u is Graph<N, E, T> | MutableGraph<N, E, T>;
+/**
+ * Creates a graph constructor for the specified graph kind.
+ *
+ * **When to use**
+ *
+ * Use when the graph kind is selected dynamically. Prefer `directed` or
+ * `undirected` when the kind is known statically.
+ *
+ * **Example** (Constructing by kind)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const makeGraph = Graph.make("directed")
+ * const graph = makeGraph<string, number>((mutable) => {
+ *   Graph.addNode(mutable, "A")
+ * })
+ *
+ * graph.type // => "directed"
+ * ```
+ *
+ * @see {@link directed} for constructing a directed graph directly
+ * @see {@link undirected} for constructing an undirected graph directly
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: <T extends Kind>(type: T) => <N, E>(mutate?: (mutable: MutableGraph<N, E, T>) => undefined) => Graph<N, E, T>;
 /**
  * Creates a directed graph, optionally with initial mutations.
  *
  * **Example** (Creating a directed graph)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Directed graph with initial nodes and edges
@@ -283,18 +343,19 @@ export declare const isGraph: (u: unknown) => u is Graph<unknown, unknown>;
  *   Graph.addEdge(mutable, a, b, "A->B")
  *   Graph.addEdge(mutable, b, c, "B->C")
  * })
+ * Array.of(Graph.nodeCount(graph), Graph.edgeCount(graph)) // => [3, 2]
  * ```
  *
  * @category constructors
  * @since 3.18.0
  */
-export declare const directed: <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void) => DirectedGraph<N, E>;
+export declare const directed: <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => undefined) => DirectedGraph<N, E>;
 /**
  * Creates an undirected graph, optionally with initial mutations.
  *
  * **Example** (Creating an undirected graph)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Undirected graph with initial nodes and edges
@@ -305,23 +366,25 @@ export declare const directed: <N, E>(mutate?: (mutable: MutableDirectedGraph<N,
  *   Graph.addEdge(mutable, a, b, "A-B")
  *   Graph.addEdge(mutable, b, c, "B-C")
  * })
+ * Array.of(Graph.nodeCount(graph), Graph.edgeCount(graph)) // => [3, 2]
  * ```
  *
  * @category constructors
  * @since 3.18.0
  */
-export declare const undirected: <N, E>(mutate?: (mutable: MutableUndirectedGraph<N, E>) => void) => UndirectedGraph<N, E>;
+export declare const undirected: <N, E>(mutate?: (mutable: MutableUndirectedGraph<N, E>) => undefined) => UndirectedGraph<N, E>;
 /**
  * Creates a mutable scope for safe graph mutations by copying the data structure.
  *
  * **Example** (Beginning a mutation scope)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>()
  * const mutable = Graph.beginMutation(graph)
  * // Now mutable can be safely modified without affecting original graph
+ * Array.of(Graph.nodeCount(mutable), Graph.nodeCount(graph)) // => [0, 0]
  * ```
  *
  * @category mutations
@@ -331,15 +394,20 @@ export declare const beginMutation: <N, E, T extends Kind = "directed">(graph: G
 /**
  * Converts a mutable graph back to an immutable graph, ending the mutation scope.
  *
+ * **Details**
+ *
+ * Finalizes the mutable handle. Later public mutation operations on that handle
+ * fail with a `GraphError`.
+ *
  * **Example** (Ending a mutation scope)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>()
  * const mutable = Graph.beginMutation(graph)
  * // ... perform mutations on mutable ...
- * const newGraph = Graph.endMutation(mutable)
+ * Graph.nodeCount(Graph.endMutation(mutable)) // => 0
  * ```
  *
  * @category mutations
@@ -347,74 +415,934 @@ export declare const beginMutation: <N, E, T extends Kind = "directed">(graph: G
  */
 export declare const endMutation: <N, E, T extends Kind = "directed">(mutable: MutableGraph<N, E, T>) => Graph<N, E, T>;
 /**
- * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+ * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+ *
+ * **Example** (Applying scoped mutations)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed<string, number>()
+ * const newGraph = Graph.mutate(graph, (mutable) => {
+ *   const nodeA = Graph.addNode(mutable, "A")
+ *   const nodeB = Graph.addNode(mutable, "B")
+ *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+ * })
+ *
+ * Graph.nodeCount(newGraph) // => 2
+ * Graph.edgeCount(newGraph) // => 1
+ * ```
+ *
+ * @category mutations
+ * @since 3.18.0
+ */
+export declare const mutate: {
+    /**
+     * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+     *
+     * **Example** (Applying scoped mutations)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const graph = Graph.directed<string, number>()
+     * const newGraph = Graph.mutate(graph, (mutable) => {
+     *   const nodeA = Graph.addNode(mutable, "A")
+     *   const nodeB = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+     * })
+     *
+     * Graph.nodeCount(newGraph) // => 2
+     * Graph.edgeCount(newGraph) // => 1
+     * ```
+     *
+     * @category mutations
+     * @since 3.18.0
+     */
+    <N, E, T extends Kind = "directed">(f: (mutable: MutableGraph<N, E, T>) => undefined): (graph: Graph<N, E, T>) => Graph<N, E, T>;
+    /**
+     * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+     *
+     * **Example** (Applying scoped mutations)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const graph = Graph.directed<string, number>()
+     * const newGraph = Graph.mutate(graph, (mutable) => {
+     *   const nodeA = Graph.addNode(mutable, "A")
+     *   const nodeB = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+     * })
+     *
+     * Graph.nodeCount(newGraph) // => 2
+     * Graph.edgeCount(newGraph) // => 1
+     * ```
+     *
+     * @category mutations
+     * @since 3.18.0
+     */
+    <N, E, T extends Kind = "directed">(graph: Graph<N, E, T>, f: (mutable: MutableGraph<N, E, T>) => undefined): Graph<N, E, T>;
+};
+/**
+ * Configures node and edge identity for graph set operations.
+ *
+ * **Details**
+ *
+ * Both functions default to using the complete node or edge data. Edge identity
+ * also includes the identities of its endpoint nodes and the graph kind.
+ *
+ * **Gotchas**
+ *
+ * Edge identity defines set membership, not edge multiplicity. Parallel edges
+ * with the same endpoint identities and projected edge identity are treated as
+ * the same member by graph set operations.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface IdentityOptions<N, E, NI = N, EI = E> {
+    readonly nodeIdentity?: (node: N) => NI;
+    readonly edgeIdentity?: (edge: E) => EI;
+}
+/**
+ * Composes two graphs, merging nodes by identity.
+ *
+ * **Details**
+ *
+ * Nodes and edges present in both graphs use data from `that`. The result has
+ * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+ * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+ * edge data. Edge identity also includes the endpoint identities.
+ *
+ * `G1 ∪ G2 = {V1 ∪ V2, E1 ∪ E2}`
+ *
+ * **Gotchas**
+ *
+ * Nodes with equal identities in one input graph are coalesced. The last node
+ * supplies the data, and redirected edges can collapse or become self-loops.
+ * Parallel edges with equal identities are also coalesced, with the last edge
+ * supplying the data.
+ *
+ * **Example** (Combining graphs)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const left = Graph.directed<{ id: string }, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, { id: "A" })
+ *   const b = Graph.addNode(mutable, { id: "B" })
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ * })
+ *
+ * const right = Graph.directed<{ id: string }, string>((mutable) => {
+ *   const b = Graph.addNode(mutable, { id: "B" })
+ *   const c = Graph.addNode(mutable, { id: "C" })
+ *   Graph.addEdge(mutable, b, c, "B-C")
+ * })
+ *
+ * const result = Graph.compose(left, right, {
+ *   nodeIdentity: (node) => node.id
+ * })
+ *
+ * Graph.nodeCount(result) // => 3
+ * Graph.edgeCount(result) // => 2
+ * ```
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const compose: {
+    /**
+     * Composes two graphs, merging nodes by identity.
+     *
+     * **Details**
+     *
+     * Nodes and edges present in both graphs use data from `that`. The result has
+     * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+     * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+     * edge data. Edge identity also includes the endpoint identities.
+     *
+     * `G1 ∪ G2 = {V1 ∪ V2, E1 ∪ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * Parallel edges with equal identities are also coalesced, with the last edge
+     * supplying the data.
+     *
+     * **Example** (Combining graphs)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<{ id: string }, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, { id: "A" })
+     *   const b = Graph.addNode(mutable, { id: "B" })
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     * })
+     *
+     * const right = Graph.directed<{ id: string }, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, { id: "B" })
+     *   const c = Graph.addNode(mutable, { id: "C" })
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const result = Graph.compose(left, right, {
+     *   nodeIdentity: (node) => node.id
+     * })
+     *
+     * Graph.nodeCount(result) // => 3
+     * Graph.edgeCount(result) // => 2
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(that: Graph<N, E, T>, options?: IdentityOptions<N, E, NI, EI>): (self: Graph<N, E, NoInfer<T>>) => Graph<N, E, T>;
+    /**
+     * Composes two graphs, merging nodes by identity.
+     *
+     * **Details**
+     *
+     * Nodes and edges present in both graphs use data from `that`. The result has
+     * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+     * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+     * edge data. Edge identity also includes the endpoint identities.
+     *
+     * `G1 ∪ G2 = {V1 ∪ V2, E1 ∪ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * Parallel edges with equal identities are also coalesced, with the last edge
+     * supplying the data.
+     *
+     * **Example** (Combining graphs)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<{ id: string }, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, { id: "A" })
+     *   const b = Graph.addNode(mutable, { id: "B" })
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     * })
+     *
+     * const right = Graph.directed<{ id: string }, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, { id: "B" })
+     *   const c = Graph.addNode(mutable, { id: "C" })
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const result = Graph.compose(left, right, {
+     *   nodeIdentity: (node) => node.id
+     * })
+     *
+     * Graph.nodeCount(result) // => 3
+     * Graph.edgeCount(result) // => 2
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(self: Graph<N, E, T>, that: Graph<N, E, NoInfer<T>>, options?: IdentityOptions<N, E, NI, EI>): Graph<N, E, T>;
+};
+/**
+ * Returns the intersection of two graphs, matching nodes by identity.
+ *
+ * **Details**
+ *
+ * Node data comes from `self`, and edge data comes from `that`. The result has
+ * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+ * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+ * edge data. Edge identity also includes the endpoint identities.
+ *
+ * `G1 ∩ G2 = {V1 ∩ V2, E1 ∩ E2}`
+ *
+ * **Gotchas**
+ *
+ * Nodes with equal identities in one input graph are coalesced. The last node
+ * supplies the data, and redirected edges can collapse or become self-loops.
+ * The result contains at most one edge for each shared edge identity.
+ *
+ * **Example** (Finding shared structure)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const left = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   Graph.addEdge(mutable, a, b, "shared")
+ * })
+ *
+ * const right = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   Graph.addEdge(mutable, a, b, "shared")
+ * })
+ *
+ * const result = Graph.intersection(left, right)
+ *
+ * Graph.nodeCount(result) // => 2
+ * Graph.edgeCount(result) // => 1
+ * ```
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const intersection: {
+    /**
+     * Returns the intersection of two graphs, matching nodes by identity.
+     *
+     * **Details**
+     *
+     * Node data comes from `self`, and edge data comes from `that`. The result has
+     * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+     * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+     * edge data. Edge identity also includes the endpoint identities.
+     *
+     * `G1 ∩ G2 = {V1 ∩ V2, E1 ∩ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * The result contains at most one edge for each shared edge identity.
+     *
+     * **Example** (Finding shared structure)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "shared")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "shared")
+     * })
+     *
+     * const result = Graph.intersection(left, right)
+     *
+     * Graph.nodeCount(result) // => 2
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(that: Graph<N, E, T>, options?: IdentityOptions<N, E, NI, EI>): (self: Graph<N, E, NoInfer<T>>) => Graph<N, E, T>;
+    /**
+     * Returns the intersection of two graphs, matching nodes by identity.
+     *
+     * **Details**
+     *
+     * Node data comes from `self`, and edge data comes from `that`. The result has
+     * the same graph kind as `self`. Throws a `GraphError` when the graph kinds do
+     * not match. `nodeIdentity` and `edgeIdentity` default to the complete node and
+     * edge data. Edge identity also includes the endpoint identities.
+     *
+     * `G1 ∩ G2 = {V1 ∩ V2, E1 ∩ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * The result contains at most one edge for each shared edge identity.
+     *
+     * **Example** (Finding shared structure)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "shared")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "shared")
+     * })
+     *
+     * const result = Graph.intersection(left, right)
+     *
+     * Graph.nodeCount(result) // => 2
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(self: Graph<N, E, T>, that: Graph<N, E, NoInfer<T>>, options?: IdentityOptions<N, E, NI, EI>): Graph<N, E, T>;
+};
+/**
+ * Returns `self` without edges also present in `that`.
+ *
+ * **Details**
+ *
+ * All nodes from `self` are preserved. Edges are matched by endpoint and edge
+ * identities. The result has the same graph kind as `self`. Throws a
+ * `GraphError` when the graph kinds do not match. `nodeIdentity` and
+ * `edgeIdentity` default to the complete node and edge data.
+ *
+ * `G1 \ G2 = {V1, E1 \ E2}`
+ *
+ * **Gotchas**
+ *
+ * Nodes with equal identities in one input graph are coalesced. The last node
+ * supplies the data, and redirected edges can collapse or become self-loops.
+ * If `that` contains an edge identity, every parallel edge with that identity
+ * is removed from `self`.
+ *
+ * **Example** (Removing shared edges)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const left = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ *   Graph.addEdge(mutable, b, c, "B-C")
+ * })
+ *
+ * const right = Graph.directed<string, string>((mutable) => {
+ *   const b = Graph.addNode(mutable, "B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   Graph.addEdge(mutable, b, c, "B-C")
+ * })
+ *
+ * const result = Graph.difference(left, right)
+ *
+ * Graph.nodeCount(result) // => 3
+ * Graph.edgeCount(result) // => 1
+ * ```
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const difference: {
+    /**
+     * Returns `self` without edges also present in `that`.
+     *
+     * **Details**
+     *
+     * All nodes from `self` are preserved. Edges are matched by endpoint and edge
+     * identities. The result has the same graph kind as `self`. Throws a
+     * `GraphError` when the graph kinds do not match. `nodeIdentity` and
+     * `edgeIdentity` default to the complete node and edge data.
+     *
+     * `G1 \ G2 = {V1, E1 \ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * If `that` contains an edge identity, every parallel edge with that identity
+     * is removed from `self`.
+     *
+     * **Example** (Removing shared edges)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const result = Graph.difference(left, right)
+     *
+     * Graph.nodeCount(result) // => 3
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(that: Graph<N, E, T>, options?: IdentityOptions<N, E, NI, EI>): (self: Graph<N, E, NoInfer<T>>) => Graph<N, E, T>;
+    /**
+     * Returns `self` without edges also present in `that`.
+     *
+     * **Details**
+     *
+     * All nodes from `self` are preserved. Edges are matched by endpoint and edge
+     * identities. The result has the same graph kind as `self`. Throws a
+     * `GraphError` when the graph kinds do not match. `nodeIdentity` and
+     * `edgeIdentity` default to the complete node and edge data.
+     *
+     * `G1 \ G2 = {V1, E1 \ E2}`
+     *
+     * **Gotchas**
+     *
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * If `that` contains an edge identity, every parallel edge with that identity
+     * is removed from `self`.
+     *
+     * **Example** (Removing shared edges)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const result = Graph.difference(left, right)
+     *
+     * Graph.nodeCount(result) // => 3
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(self: Graph<N, E, T>, that: Graph<N, E, NoInfer<T>>, options?: IdentityOptions<N, E, NI, EI>): Graph<N, E, T>;
+};
+/**
+ * Returns edges present in exactly one of two graphs.
+ *
+ * **Details**
+ *
+ * Keeps nodes from both graphs. Overlapping nodes use data from `that`. The
+ * result has the same graph kind as `self`. Throws a `GraphError` when the
+ * graph kinds do not match. `nodeIdentity` and `edgeIdentity` default to the
+ * complete node and edge data. Edge identity also includes the endpoint
+ * identities.
+ *
+ * `G1 Δ G2 = {V1 ∪ V2, (E1 ∪ E2) \ (E1 ∩ E2)}`
+ *
+ * **Gotchas**
+ *
+ * Edges with different projected identities are distinct.
+ * Nodes with equal identities in one input graph are coalesced. The last node
+ * supplies the data, and redirected edges can collapse or become self-loops.
+ * Parallel edges with equal identities are coalesced before the graphs are
+ * compared.
+ *
+ * **Example** (Finding differing edges)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const left = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ *   Graph.addEdge(mutable, b, c, "B-C")
+ * })
+ *
+ * const right = Graph.directed<string, string>((mutable) => {
+ *   const b = Graph.addNode(mutable, "B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   const d = Graph.addNode(mutable, "D")
+ *   Graph.addEdge(mutable, b, c, "B-C")
+ *   Graph.addEdge(mutable, c, d, "C-D")
+ * })
+ *
+ * const result = Graph.symmetricDifference(left, right)
+ *
+ * Graph.nodeCount(result) // => 4
+ * Graph.edgeCount(result) // => 2
+ * ```
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const symmetricDifference: {
+    /**
+     * Returns edges present in exactly one of two graphs.
+     *
+     * **Details**
+     *
+     * Keeps nodes from both graphs. Overlapping nodes use data from `that`. The
+     * result has the same graph kind as `self`. Throws a `GraphError` when the
+     * graph kinds do not match. `nodeIdentity` and `edgeIdentity` default to the
+     * complete node and edge data. Edge identity also includes the endpoint
+     * identities.
+     *
+     * `G1 Δ G2 = {V1 ∪ V2, (E1 ∪ E2) \ (E1 ∩ E2)}`
+     *
+     * **Gotchas**
+     *
+     * Edges with different projected identities are distinct.
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * Parallel edges with equal identities are coalesced before the graphs are
+     * compared.
+     *
+     * **Example** (Finding differing edges)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   const d = Graph.addNode(mutable, "D")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     *   Graph.addEdge(mutable, c, d, "C-D")
+     * })
+     *
+     * const result = Graph.symmetricDifference(left, right)
+     *
+     * Graph.nodeCount(result) // => 4
+     * Graph.edgeCount(result) // => 2
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(that: Graph<N, E, T>, options?: IdentityOptions<N, E, NI, EI>): (self: Graph<N, E, NoInfer<T>>) => Graph<N, E, T>;
+    /**
+     * Returns edges present in exactly one of two graphs.
+     *
+     * **Details**
+     *
+     * Keeps nodes from both graphs. Overlapping nodes use data from `that`. The
+     * result has the same graph kind as `self`. Throws a `GraphError` when the
+     * graph kinds do not match. `nodeIdentity` and `edgeIdentity` default to the
+     * complete node and edge data. Edge identity also includes the endpoint
+     * identities.
+     *
+     * `G1 Δ G2 = {V1 ∪ V2, (E1 ∪ E2) \ (E1 ∩ E2)}`
+     *
+     * **Gotchas**
+     *
+     * Edges with different projected identities are distinct.
+     * Nodes with equal identities in one input graph are coalesced. The last node
+     * supplies the data, and redirected edges can collapse or become self-loops.
+     * Parallel edges with equal identities are coalesced before the graphs are
+     * compared.
+     *
+     * **Example** (Finding differing edges)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const left = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     * })
+     *
+     * const right = Graph.directed<string, string>((mutable) => {
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   const d = Graph.addNode(mutable, "D")
+     *   Graph.addEdge(mutable, b, c, "B-C")
+     *   Graph.addEdge(mutable, c, d, "C-D")
+     * })
+     *
+     * const result = Graph.symmetricDifference(left, right)
+     *
+     * Graph.nodeCount(result) // => 4
+     * Graph.edgeCount(result) // => 2
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed", NI = N, EI = E>(self: Graph<N, E, T>, that: Graph<N, E, NoInfer<T>>, options?: IdentityOptions<N, E, NI, EI>): Graph<N, E, T>;
+};
+/**
+ * Returns the complement over the existing node set.
+ *
+ * **Details**
+ *
+ * Adds every missing edge between distinct nodes. The `createEdge` function
+ * receives the source and target node data for each added edge. The result has
+ * the same graph kind as `self`.
+ *
+ * `G' = {V, (V x V) \ E}`
+ *
+ * **Example** (Finding missing relationships)
+ *
+ * ```ts import.meta.vitest
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ * })
+ *
+ * const result = Graph.complement(graph, (source, target) => `${source}-${target}`)
+ *
+ * Graph.edgeCount(result) // => 1
+ * ```
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const complement: {
+    /**
+     * Returns the complement over the existing node set.
+     *
+     * **Details**
+     *
+     * Adds every missing edge between distinct nodes. The `createEdge` function
+     * receives the source and target node data for each added edge. The result has
+     * the same graph kind as `self`.
+     *
+     * `G' = {V, (V x V) \ E}`
+     *
+     * **Example** (Finding missing relationships)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const graph = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     * })
+     *
+     * const result = Graph.complement(graph, (source, target) => `${source}-${target}`)
+     *
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E>(createEdge: (source: N, target: N) => E): <T extends Kind = "directed">(self: Graph<N, E, T>) => Graph<N, E, T>;
+    /**
+     * Returns the complement over the existing node set.
+     *
+     * **Details**
+     *
+     * Adds every missing edge between distinct nodes. The `createEdge` function
+     * receives the source and target node data for each added edge. The result has
+     * the same graph kind as `self`.
+     *
+     * `G' = {V, (V x V) \ E}`
+     *
+     * **Example** (Finding missing relationships)
+     *
+     * ```ts import.meta.vitest
+     * import { Graph } from "effect"
+     *
+     * const graph = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     * })
+     *
+     * const result = Graph.complement(graph, (source, target) => `${source}-${target}`)
+     *
+     * Graph.edgeCount(result) // => 1
+     * ```
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed">(self: Graph<N, E, T>, createEdge: (source: N, target: N) => E): Graph<N, E, T>;
+};
+/**
+ * Configuration for selecting a graph neighborhood.
+ *
+ * **Details**
+ *
+ * `radius` limits the edge distance from the center node and defaults to `1`.
+ * `direction` controls how directed edges are traversed and defaults to
+ * `"outgoing"`.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface NeighborhoodConfig {
+    readonly radius?: number;
+    readonly direction?: TraversalDirection;
+}
+/**
+ * Returns the induced subgraph containing nodes within a radius of a node.
  *
- * **Example** (Applying scoped mutations)
+ * **Details**
+ *
+ * The `radius` option is the maximum edge distance from `nodeIndex` and
+ * defaults to `1`. The `direction` option controls directed graph traversal and
+ * defaults to `"outgoing"`. The result has the same graph kind as `self` and
+ * keeps all original edges whose endpoints are both reached. `"undirected"`
+ * ignores edge direction while finding reachable nodes.
  *
- * ```ts
+ * **Example** (Getting a local neighborhood)
+ *
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
- * const graph = Graph.directed<string, number>()
- * const newGraph = Graph.mutate(graph, (mutable) => {
- *   const nodeA = Graph.addNode(mutable, "A")
- *   const nodeB = Graph.addNode(mutable, "B")
- *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+ * const graph = Graph.directed<string, string>((mutable) => {
+ *   const a = Graph.addNode(mutable, "A")
+ *   const b = Graph.addNode(mutable, "B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ *   Graph.addEdge(mutable, b, c, "B-C")
  * })
  *
- * console.log(Graph.nodeCount(newGraph)) // 2
- * console.log(Graph.edgeCount(newGraph)) // 1
+ * const result = Graph.neighborhood(graph, 1, { radius: 1 })
+ *
+ * Graph.nodeCount(result) // => 2
  * ```
  *
- * @category mutations
- * @since 3.18.0
+ * @category set operations
+ * @since 4.0.0
  */
-export declare const mutate: {
+export declare const neighborhood: {
     /**
-     * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+     * Returns the induced subgraph containing nodes within a radius of a node.
      *
-     * **Example** (Applying scoped mutations)
+     * **Details**
      *
-     * ```ts
+     * The `radius` option is the maximum edge distance from `nodeIndex` and
+     * defaults to `1`. The `direction` option controls directed graph traversal and
+     * defaults to `"outgoing"`. The result has the same graph kind as `self` and
+     * keeps all original edges whose endpoints are both reached. `"undirected"`
+     * ignores edge direction while finding reachable nodes.
+     *
+     * **Example** (Getting a local neighborhood)
+     *
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
-     * const graph = Graph.directed<string, number>()
-     * const newGraph = Graph.mutate(graph, (mutable) => {
-     *   const nodeA = Graph.addNode(mutable, "A")
-     *   const nodeB = Graph.addNode(mutable, "B")
-     *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+     * const graph = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
      * })
      *
-     * console.log(Graph.nodeCount(newGraph)) // 2
-     * console.log(Graph.edgeCount(newGraph)) // 1
+     * const result = Graph.neighborhood(graph, 1, { radius: 1 })
+     *
+     * Graph.nodeCount(result) // => 2
      * ```
      *
-     * @category mutations
-     * @since 3.18.0
+     * @category set operations
+     * @since 4.0.0
      */
-    <N, E, T extends Kind = "directed">(f: (mutable: MutableGraph<N, E, T>) => void): (graph: Graph<N, E, T>) => Graph<N, E, T>;
+    (nodeIndex: NodeIndex, options?: NeighborhoodConfig): <N, E, T extends Kind = "directed">(self: Graph<N, E, T>) => Graph<N, E, T>;
     /**
-     * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+     * Returns the induced subgraph containing nodes within a radius of a node.
      *
-     * **Example** (Applying scoped mutations)
+     * **Details**
+     *
+     * The `radius` option is the maximum edge distance from `nodeIndex` and
+     * defaults to `1`. The `direction` option controls directed graph traversal and
+     * defaults to `"outgoing"`. The result has the same graph kind as `self` and
+     * keeps all original edges whose endpoints are both reached. `"undirected"`
+     * ignores edge direction while finding reachable nodes.
+     *
+     * **Example** (Getting a local neighborhood)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
-     * const graph = Graph.directed<string, number>()
-     * const newGraph = Graph.mutate(graph, (mutable) => {
-     *   const nodeA = Graph.addNode(mutable, "A")
-     *   const nodeB = Graph.addNode(mutable, "B")
-     *   Graph.addEdge(mutable, nodeA, nodeB, 1)
+     * const graph = Graph.directed<string, string>((mutable) => {
+     *   const a = Graph.addNode(mutable, "A")
+     *   const b = Graph.addNode(mutable, "B")
+     *   const c = Graph.addNode(mutable, "C")
+     *   Graph.addEdge(mutable, a, b, "A-B")
+     *   Graph.addEdge(mutable, b, c, "B-C")
      * })
      *
-     * console.log(Graph.nodeCount(newGraph)) // 2
-     * console.log(Graph.edgeCount(newGraph)) // 1
+     * const result = Graph.neighborhood(graph, 1, { radius: 1 })
+     *
+     * Graph.nodeCount(result) // => 2
      * ```
      *
-     * @category mutations
-     * @since 3.18.0
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind = "directed">(self: Graph<N, E, T>, nodeIndex: NodeIndex, options?: NeighborhoodConfig): Graph<N, E, T>;
+};
+/**
+ * Returns the disjoint union of two graphs.
+ *
+ * **Details**
+ *
+ * Copies all nodes and edges from both graphs without merging equal node data.
+ * The result has the same graph kind as `self`. Throws a `GraphError` when the
+ * graph kinds do not match.
+ *
+ * `G1 + G2 = {disjoint V1 + V2, disjoint E1 + E2}`
+ *
+ * @category set operations
+ * @since 4.0.0
+ */
+export declare const sum: {
+    /**
+     * Returns the disjoint union of two graphs.
+     *
+     * **Details**
+     *
+     * Copies all nodes and edges from both graphs without merging equal node data.
+     * The result has the same graph kind as `self`. Throws a `GraphError` when the
+     * graph kinds do not match.
+     *
+     * `G1 + G2 = {disjoint V1 + V2, disjoint E1 + E2}`
+     *
+     * @category set operations
+     * @since 4.0.0
+     */
+    <N, E, T extends Kind>(that: Graph<N, E, T>): (self: Graph<N, E, NoInfer<T>>) => Graph<N, E, T>;
+    /**
+     * Returns the disjoint union of two graphs.
+     *
+     * **Details**
+     *
+     * Copies all nodes and edges from both graphs without merging equal node data.
+     * The result has the same graph kind as `self`. Throws a `GraphError` when the
+     * graph kinds do not match.
+     *
+     * `G1 + G2 = {disjoint V1 + V2, disjoint E1 + E2}`
+     *
+     * @category set operations
+     * @since 4.0.0
      */
-    <N, E, T extends Kind = "directed">(graph: Graph<N, E, T>, f: (mutable: MutableGraph<N, E, T>) => void): Graph<N, E, T>;
+    <N, E, T extends Kind>(self: Graph<N, E, T>, that: Graph<N, E, NoInfer<T>>): Graph<N, E, T>;
 };
 /**
  * Adds a new node to a mutable graph and returns its index.
@@ -436,14 +1364,12 @@ export declare const mutate: {
  *
  * **Example** (Adding nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
- * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
- *   const nodeA = Graph.addNode(mutable, "Node A")
- *   const nodeB = Graph.addNode(mutable, "Node B")
- *   console.log(nodeA) // NodeIndex with value 0
- *   console.log(nodeB) // NodeIndex with value 1
+ * Graph.mutate(Graph.directed<string, number>(), (mutable) => {
+ *   Graph.addNode(mutable, "Node A") // => 0
+ *   Graph.addNode(mutable, "Node B") // => 1
  * })
  * ```
  *
@@ -460,19 +1386,14 @@ export declare const addNode: <N, E, T extends Kind = "directed">(mutable: Mutab
  *
  * **Example** (Getting node data)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph, Option } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   Graph.addNode(mutable, "Node A")
  * })
  *
- * const nodeIndex = 0
- * const nodeData = Graph.getNode(graph, nodeIndex)
- *
- * if (Option.isSome(nodeData)) {
- *   console.log(nodeData.value) // "Node A"
- * }
+ * Graph.getNode(graph, 0) // => Option.some("Node A")
  * ```
  *
  * @category getters
@@ -484,43 +1405,33 @@ export declare const getNode: {
      *
      * **Example** (Getting node data)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
      * })
      *
-     * const nodeIndex = 0
-     * const nodeData = Graph.getNode(graph, nodeIndex)
-     *
-     * if (Option.isSome(nodeData)) {
-     *   console.log(nodeData.value) // "Node A"
-     * }
+     * Graph.getNode(graph, 0) // => Option.some("Node A")
      * ```
      *
      * @category getters
      * @since 3.18.0
      */
-    <N, E, T extends Kind = "directed">(nodeIndex: NodeIndex): (graph: Graph<N, E, T> | MutableGraph<N, E, T>) => Option.Option<N>;
+    (nodeIndex: NodeIndex): <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>) => Option.Option<N>;
     /**
      * Gets the data associated with a node index safely, if it exists.
      *
      * **Example** (Getting node data)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
      * })
      *
-     * const nodeIndex = 0
-     * const nodeData = Graph.getNode(graph, nodeIndex)
-     *
-     * if (Option.isSome(nodeData)) {
-     *   console.log(nodeData.value) // "Node A"
-     * }
+     * Graph.getNode(graph, 0) // => Option.some("Node A")
      * ```
      *
      * @category getters
@@ -533,20 +1444,15 @@ export declare const getNode: {
  *
  * **Example** (Checking node existence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   Graph.addNode(mutable, "Node A")
  * })
  *
- * const nodeIndex = 0
- * const exists = Graph.hasNode(graph, nodeIndex)
- * console.log(exists) // true
- *
- * const nonExistentIndex = 999
- * const notExists = Graph.hasNode(graph, nonExistentIndex)
- * console.log(notExists) // false
+ * Graph.hasNode(graph, 0) // => true
+ * Graph.hasNode(graph, 999) // => false
  * ```
  *
  * @category getters
@@ -558,20 +1464,15 @@ export declare const hasNode: {
      *
      * **Example** (Checking node existence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
      * })
      *
-     * const nodeIndex = 0
-     * const exists = Graph.hasNode(graph, nodeIndex)
-     * console.log(exists) // true
-     *
-     * const nonExistentIndex = 999
-     * const notExists = Graph.hasNode(graph, nonExistentIndex)
-     * console.log(notExists) // false
+     * Graph.hasNode(graph, 0) // => true
+     * Graph.hasNode(graph, 999) // => false
      * ```
      *
      * @category getters
@@ -583,20 +1484,15 @@ export declare const hasNode: {
      *
      * **Example** (Checking node existence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
      * })
      *
-     * const nodeIndex = 0
-     * const exists = Graph.hasNode(graph, nodeIndex)
-     * console.log(exists) // true
-     *
-     * const nonExistentIndex = 999
-     * const notExists = Graph.hasNode(graph, nonExistentIndex)
-     * console.log(notExists) // false
+     * Graph.hasNode(graph, 0) // => true
+     * Graph.hasNode(graph, 999) // => false
      * ```
      *
      * @category getters
@@ -609,11 +1505,11 @@ export declare const hasNode: {
  *
  * **Example** (Counting nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const emptyGraph = Graph.directed<string, number>()
- * console.log(Graph.nodeCount(emptyGraph)) // 0
+ * Graph.nodeCount(emptyGraph) // => 0
  *
  * const graphWithNodes = Graph.mutate(emptyGraph, (mutable) => {
  *   Graph.addNode(mutable, "Node A")
@@ -621,7 +1517,7 @@ export declare const hasNode: {
  *   Graph.addNode(mutable, "Node C")
  * })
  *
- * console.log(Graph.nodeCount(graphWithNodes)) // 3
+ * Graph.nodeCount(graphWithNodes) // => 3
  * ```
  *
  * @category getters
@@ -633,8 +1529,8 @@ export declare const nodeCount: <N, E, T extends Kind = "directed">(graph: Graph
  *
  * **Example** (Finding the first matching node)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   Graph.addNode(mutable, "Node A")
@@ -642,11 +1538,8 @@ export declare const nodeCount: <N, E, T extends Kind = "directed">(graph: Graph
  *   Graph.addNode(mutable, "Node C")
  * })
  *
- * const result = Graph.findNode(graph, (data) => data.startsWith("Node B"))
- * console.log(result) // Option.some(1)
- *
- * const notFound = Graph.findNode(graph, (data) => data === "Node D")
- * console.log(notFound) // Option.none()
+ * Graph.findNode(graph, (data) => data.startsWith("Node B")) // => Option.some(1)
+ * Graph.findNode(graph, (data) => data === "Node D") // => Option.none()
  * ```
  *
  * @category getters
@@ -658,8 +1551,8 @@ export declare const findNode: {
      *
      * **Example** (Finding the first matching node)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
@@ -667,11 +1560,8 @@ export declare const findNode: {
      *   Graph.addNode(mutable, "Node C")
      * })
      *
-     * const result = Graph.findNode(graph, (data) => data.startsWith("Node B"))
-     * console.log(result) // Option.some(1)
-     *
-     * const notFound = Graph.findNode(graph, (data) => data === "Node D")
-     * console.log(notFound) // Option.none()
+     * Graph.findNode(graph, (data) => data.startsWith("Node B")) // => Option.some(1)
+     * Graph.findNode(graph, (data) => data === "Node D") // => Option.none()
      * ```
      *
      * @category getters
@@ -683,8 +1573,8 @@ export declare const findNode: {
      *
      * **Example** (Finding the first matching node)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   Graph.addNode(mutable, "Node A")
@@ -692,11 +1582,8 @@ export declare const findNode: {
      *   Graph.addNode(mutable, "Node C")
      * })
      *
-     * const result = Graph.findNode(graph, (data) => data.startsWith("Node B"))
-     * console.log(result) // Option.some(1)
-     *
-     * const notFound = Graph.findNode(graph, (data) => data === "Node D")
-     * console.log(notFound) // Option.none()
+     * Graph.findNode(graph, (data) => data.startsWith("Node B")) // => Option.some(1)
+     * Graph.findNode(graph, (data) => data === "Node D") // => Option.none()
      * ```
      *
      * @category getters
@@ -709,7 +1596,7 @@ export declare const findNode: {
  *
  * **Example** (Finding matching nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -718,11 +1605,8 @@ export declare const findNode: {
  *   Graph.addNode(mutable, "Start C")
  * })
  *
- * const result = Graph.findNodes(graph, (data) => data.startsWith("Start"))
- * console.log(result) // [0, 2]
- *
- * const empty = Graph.findNodes(graph, (data) => data === "Not Found")
- * console.log(empty) // []
+ * Graph.findNodes(graph, (data) => data.startsWith("Start")) // => [0, 2]
+ * Graph.findNodes(graph, (data) => data === "Not Found") // => []
  * ```
  *
  * @category getters
@@ -734,7 +1618,7 @@ export declare const findNodes: {
      *
      * **Example** (Finding matching nodes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -743,11 +1627,8 @@ export declare const findNodes: {
      *   Graph.addNode(mutable, "Start C")
      * })
      *
-     * const result = Graph.findNodes(graph, (data) => data.startsWith("Start"))
-     * console.log(result) // [0, 2]
-     *
-     * const empty = Graph.findNodes(graph, (data) => data === "Not Found")
-     * console.log(empty) // []
+     * Graph.findNodes(graph, (data) => data.startsWith("Start")) // => [0, 2]
+     * Graph.findNodes(graph, (data) => data === "Not Found") // => []
      * ```
      *
      * @category getters
@@ -759,7 +1640,7 @@ export declare const findNodes: {
      *
      * **Example** (Finding matching nodes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -768,11 +1649,8 @@ export declare const findNodes: {
      *   Graph.addNode(mutable, "Start C")
      * })
      *
-     * const result = Graph.findNodes(graph, (data) => data.startsWith("Start"))
-     * console.log(result) // [0, 2]
-     *
-     * const empty = Graph.findNodes(graph, (data) => data === "Not Found")
-     * console.log(empty) // []
+     * Graph.findNodes(graph, (data) => data.startsWith("Start")) // => [0, 2]
+     * Graph.findNodes(graph, (data) => data === "Not Found") // => []
      * ```
      *
      * @category getters
@@ -785,8 +1663,8 @@ export declare const findNodes: {
  *
  * **Example** (Finding the first matching edge)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -796,11 +1674,8 @@ export declare const findNodes: {
  *   Graph.addEdge(mutable, nodeB, nodeC, 20)
  * })
  *
- * const result = Graph.findEdge(graph, (data) => data > 15)
- * console.log(result) // Option.some(1)
- *
- * const notFound = Graph.findEdge(graph, (data) => data > 100)
- * console.log(notFound) // Option.none()
+ * Graph.findEdge(graph, (data) => data > 15) // => Option.some(1)
+ * Graph.findEdge(graph, (data) => data > 100) // => Option.none()
  * ```
  *
  * @category getters
@@ -812,8 +1687,8 @@ export declare const findEdge: {
      *
      * **Example** (Finding the first matching edge)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -823,11 +1698,8 @@ export declare const findEdge: {
      *   Graph.addEdge(mutable, nodeB, nodeC, 20)
      * })
      *
-     * const result = Graph.findEdge(graph, (data) => data > 15)
-     * console.log(result) // Option.some(1)
-     *
-     * const notFound = Graph.findEdge(graph, (data) => data > 100)
-     * console.log(notFound) // Option.none()
+     * Graph.findEdge(graph, (data) => data > 15) // => Option.some(1)
+     * Graph.findEdge(graph, (data) => data > 100) // => Option.none()
      * ```
      *
      * @category getters
@@ -839,8 +1711,8 @@ export declare const findEdge: {
      *
      * **Example** (Finding the first matching edge)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -850,11 +1722,8 @@ export declare const findEdge: {
      *   Graph.addEdge(mutable, nodeB, nodeC, 20)
      * })
      *
-     * const result = Graph.findEdge(graph, (data) => data > 15)
-     * console.log(result) // Option.some(1)
-     *
-     * const notFound = Graph.findEdge(graph, (data) => data > 100)
-     * console.log(notFound) // Option.none()
+     * Graph.findEdge(graph, (data) => data > 15) // => Option.some(1)
+     * Graph.findEdge(graph, (data) => data > 100) // => Option.none()
      * ```
      *
      * @category getters
@@ -867,7 +1736,7 @@ export declare const findEdge: {
  *
  * **Example** (Finding matching edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -879,11 +1748,8 @@ export declare const findEdge: {
  *   Graph.addEdge(mutable, nodeC, nodeA, 30)
  * })
  *
- * const result = Graph.findEdges(graph, (data) => data >= 20)
- * console.log(result) // [1, 2]
- *
- * const empty = Graph.findEdges(graph, (data) => data > 100)
- * console.log(empty) // []
+ * Graph.findEdges(graph, (data) => data >= 20) // => [1, 2]
+ * Graph.findEdges(graph, (data) => data > 100) // => []
  * ```
  *
  * @category getters
@@ -895,7 +1761,7 @@ export declare const findEdges: {
      *
      * **Example** (Finding matching edges)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -907,11 +1773,8 @@ export declare const findEdges: {
      *   Graph.addEdge(mutable, nodeC, nodeA, 30)
      * })
      *
-     * const result = Graph.findEdges(graph, (data) => data >= 20)
-     * console.log(result) // [1, 2]
-     *
-     * const empty = Graph.findEdges(graph, (data) => data > 100)
-     * console.log(empty) // []
+     * Graph.findEdges(graph, (data) => data >= 20) // => [1, 2]
+     * Graph.findEdges(graph, (data) => data > 100) // => []
      * ```
      *
      * @category getters
@@ -923,7 +1786,7 @@ export declare const findEdges: {
      *
      * **Example** (Finding matching edges)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -935,11 +1798,8 @@ export declare const findEdges: {
      *   Graph.addEdge(mutable, nodeC, nodeA, 30)
      * })
      *
-     * const result = Graph.findEdges(graph, (data) => data >= 20)
-     * console.log(result) // [1, 2]
-     *
-     * const empty = Graph.findEdges(graph, (data) => data > 100)
-     * console.log(empty) // []
+     * Graph.findEdges(graph, (data) => data >= 20) // => [1, 2]
+     * Graph.findEdges(graph, (data) => data > 100) // => []
      * ```
      *
      * @category getters
@@ -952,8 +1812,8 @@ export declare const findEdges: {
  *
  * **Example** (Updating node data)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   Graph.addNode(mutable, "Node A")
@@ -961,8 +1821,7 @@ export declare const findEdges: {
  *   Graph.updateNode(mutable, 0, (data) => data.toUpperCase())
  * })
  *
- * const nodeData = Graph.getNode(graph, 0)
- * console.log(nodeData) // Option.some("NODE A")
+ * Graph.getNode(graph, 0) // => Option.some("NODE A")
  * ```
  *
  * @category transforming
@@ -974,8 +1833,8 @@ export declare const updateNode: <N, E, T extends Kind = "directed">(mutable: Mu
  *
  * **Example** (Updating edge data)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -984,8 +1843,7 @@ export declare const updateNode: <N, E, T extends Kind = "directed">(mutable: Mu
  *   Graph.updateEdge(mutable, edgeIndex, (data) => data * 2)
  * })
  *
- * const edgeData = Graph.getEdge(result, 0)
- * console.log(edgeData) // Option.some(new Graph.Edge({ source: 0, target: 1, data: 20 }))
+ * Option.map(Graph.getEdge(result, 0), (edge) => edge.data) // => Option.some(20)
  * ```
  *
  * @category mutations
@@ -1002,8 +1860,8 @@ export declare const updateEdge: <N, E, T extends Kind = "directed">(mutable: Mu
  *
  * **Example** (Mapping node data)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   Graph.addNode(mutable, "node a")
@@ -1012,8 +1870,7 @@ export declare const updateEdge: <N, E, T extends Kind = "directed">(mutable: Mu
  *   Graph.mapNodes(mutable, (data) => data.toUpperCase())
  * })
  *
- * const nodeData = Graph.getNode(graph, 0)
- * console.log(nodeData) // Option.some("NODE A")
+ * Graph.getNode(graph, 0) // => Option.some("NODE A")
  * ```
  *
  * @category transforming
@@ -1025,8 +1882,8 @@ export declare const mapNodes: <N, E, T extends Kind = "directed">(mutable: Muta
  *
  * **Example** (Mapping edge data)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   const a = Graph.addNode(mutable, "A")
@@ -1037,8 +1894,7 @@ export declare const mapNodes: <N, E, T extends Kind = "directed">(mutable: Muta
  *   Graph.mapEdges(mutable, (data) => data * 2)
  * })
  *
- * const edgeData = Graph.getEdge(graph, 0)
- * console.log(edgeData) // Option.some(new Graph.Edge({ source: 0, target: 1, data: 20 }))
+ * Option.map(Graph.getEdge(graph, 0), (edge) => edge.data) // => Option.some(20)
  * ```
  *
  * @category transforming
@@ -1050,8 +1906,8 @@ export declare const mapEdges: <N, E, T extends Kind = "directed">(mutable: Muta
  *
  * **Example** (Reversing edge directions)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   const a = Graph.addNode(mutable, "A")
@@ -1062,8 +1918,7 @@ export declare const mapEdges: <N, E, T extends Kind = "directed">(mutable: Muta
  *   Graph.reverse(mutable) // Now B -> A, C -> B
  * })
  *
- * const edge0 = Graph.getEdge(graph, 0)
- * console.log(edge0) // Option.some(new Graph.Edge({ source: 1, target: 0, data: 1 }))
+ * Option.map(Graph.getEdge(graph, 0), (edge) => edge.source) // => Option.some(1)
  * ```
  *
  * @category transforming
@@ -1076,7 +1931,7 @@ export declare const reverse: <N, E, T extends Kind = "directed">(mutable: Mutab
  *
  * **Example** (Filtering and mapping nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1094,7 +1949,7 @@ export declare const reverse: <N, E, T extends Kind = "directed">(mutable: Mutab
  *   )
  * })
  *
- * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * Graph.nodeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1107,7 +1962,7 @@ export declare const filterMapNodes: <N, E, T extends Kind = "directed">(mutable
  *
  * **Example** (Filtering and mapping edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1125,7 +1980,7 @@ export declare const filterMapNodes: <N, E, T extends Kind = "directed">(mutable
  *   )
  * })
  *
- * console.log(Graph.edgeCount(graph)) // 2 (edges with weight 5 removed)
+ * Graph.edgeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1138,7 +1993,7 @@ export declare const filterMapEdges: <N, E, T extends Kind = "directed">(mutable
  *
  * **Example** (Filtering nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1151,7 +2006,7 @@ export declare const filterMapEdges: <N, E, T extends Kind = "directed">(mutable
  *   Graph.filterNodes(mutable, (data) => data === "active")
  * })
  *
- * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * Graph.nodeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1164,7 +2019,7 @@ export declare const filterNodes: <N, E, T extends Kind = "directed">(mutable: M
  *
  * **Example** (Filtering edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1180,7 +2035,7 @@ export declare const filterNodes: <N, E, T extends Kind = "directed">(mutable: M
  *   Graph.filterEdges(mutable, (data) => data >= 10)
  * })
  *
- * console.log(Graph.edgeCount(graph)) // 2 (edge with weight 5 removed)
+ * Graph.edgeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1208,14 +2063,13 @@ export declare const filterEdges: <N, E, T extends Kind = "directed">(mutable: M
  *
  * **Example** (Adding edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
- * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
+ * Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   const nodeA = Graph.addNode(mutable, "Node A")
  *   const nodeB = Graph.addNode(mutable, "Node B")
- *   const edge = Graph.addEdge(mutable, nodeA, nodeB, 42)
- *   console.log(edge) // EdgeIndex with value 0
+ *   Graph.addEdge(mutable, nodeA, nodeB, 42) // => 0
  * })
  * ```
  *
@@ -1233,7 +2087,7 @@ export declare const addEdge: <N, E, T extends Kind = "directed">(mutable: Mutab
  *
  * **Example** (Removing a node)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1244,6 +2098,7 @@ export declare const addEdge: <N, E, T extends Kind = "directed">(mutable: Mutab
  *   // Remove nodeA and all edges connected to it
  *   Graph.removeNode(mutable, nodeA)
  * })
+ * Array.of(Graph.nodeCount(result), Graph.edgeCount(result)) // => [1, 0]
  * ```
  *
  * @category mutations
@@ -1255,7 +2110,7 @@ export declare const removeNode: <N, E, T extends Kind = "directed">(mutable: Mu
  *
  * **Example** (Removing an edge)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1266,6 +2121,7 @@ export declare const removeNode: <N, E, T extends Kind = "directed">(mutable: Mu
  *   // Remove the edge
  *   Graph.removeEdge(mutable, edge)
  * })
+ * Array.of(Graph.nodeCount(result), Graph.edgeCount(result)) // => [2, 0]
  * ```
  *
  * @category mutations
@@ -1277,8 +2133,8 @@ export declare const removeEdge: <N, E, T extends Kind = "directed">(mutable: Mu
  *
  * **Example** (Getting edge data)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
  *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -1286,14 +2142,7 @@ export declare const removeEdge: <N, E, T extends Kind = "directed">(mutable: Mu
  *   Graph.addEdge(mutable, nodeA, nodeB, 42)
  * })
  *
- * const edgeIndex = 0
- * const edgeData = Graph.getEdge(graph, edgeIndex)
- *
- * if (edgeData._tag === "Some") {
- *   console.log(edgeData.value.data) // 42
- *   console.log(edgeData.value.source) // 0
- *   console.log(edgeData.value.target) // 1
- * }
+ * Graph.getEdge(graph, 0) // => Option.some(new Graph.Edge({ source: 0, target: 1, data: 42 }))
  * ```
  *
  * @category getters
@@ -1305,8 +2154,8 @@ export declare const getEdge: {
      *
      * **Example** (Getting edge data)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -1314,27 +2163,20 @@ export declare const getEdge: {
      *   Graph.addEdge(mutable, nodeA, nodeB, 42)
      * })
      *
-     * const edgeIndex = 0
-     * const edgeData = Graph.getEdge(graph, edgeIndex)
-     *
-     * if (edgeData._tag === "Some") {
-     *   console.log(edgeData.value.data) // 42
-     *   console.log(edgeData.value.source) // 0
-     *   console.log(edgeData.value.target) // 1
-     * }
+     * Graph.getEdge(graph, 0) // => Option.some(new Graph.Edge({ source: 0, target: 1, data: 42 }))
      * ```
      *
      * @category getters
      * @since 3.18.0
      */
-    <E>(edgeIndex: EdgeIndex): <N, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>) => Option.Option<Edge<E>>;
+    (edgeIndex: EdgeIndex): <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>) => Option.Option<Edge<E>>;
     /**
      * Gets the edge data associated with an edge index safely, if it exists.
      *
      * **Example** (Getting edge data)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
      *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -1342,14 +2184,7 @@ export declare const getEdge: {
      *   Graph.addEdge(mutable, nodeA, nodeB, 42)
      * })
      *
-     * const edgeIndex = 0
-     * const edgeData = Graph.getEdge(graph, edgeIndex)
-     *
-     * if (edgeData._tag === "Some") {
-     *   console.log(edgeData.value.data) // 42
-     *   console.log(edgeData.value.source) // 0
-     *   console.log(edgeData.value.target) // 1
-     * }
+     * Graph.getEdge(graph, 0) // => Option.some(new Graph.Edge({ source: 0, target: 1, data: 42 }))
      * ```
      *
      * @category getters
@@ -1362,7 +2197,7 @@ export declare const getEdge: {
  *
  * **Example** (Checking edge existence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1372,15 +2207,8 @@ export declare const getEdge: {
  *   Graph.addEdge(mutable, nodeA, nodeB, 42)
  * })
  *
- * const nodeA = 0
- * const nodeB = 1
- * const nodeC = 2
- *
- * const hasAB = Graph.hasEdge(graph, nodeA, nodeB)
- * console.log(hasAB) // true
- *
- * const hasAC = Graph.hasEdge(graph, nodeA, nodeC)
- * console.log(hasAC) // false
+ * Graph.hasEdge(graph, 0, 1) // => true
+ * Graph.hasEdge(graph, 0, 2) // => false
  * ```
  *
  * @category getters
@@ -1392,7 +2220,7 @@ export declare const hasEdge: {
      *
      * **Example** (Checking edge existence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1402,15 +2230,8 @@ export declare const hasEdge: {
      *   Graph.addEdge(mutable, nodeA, nodeB, 42)
      * })
      *
-     * const nodeA = 0
-     * const nodeB = 1
-     * const nodeC = 2
-     *
-     * const hasAB = Graph.hasEdge(graph, nodeA, nodeB)
-     * console.log(hasAB) // true
-     *
-     * const hasAC = Graph.hasEdge(graph, nodeA, nodeC)
-     * console.log(hasAC) // false
+     * Graph.hasEdge(graph, 0, 1) // => true
+     * Graph.hasEdge(graph, 0, 2) // => false
      * ```
      *
      * @category getters
@@ -1422,7 +2243,7 @@ export declare const hasEdge: {
      *
      * **Example** (Checking edge existence)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1432,15 +2253,8 @@ export declare const hasEdge: {
      *   Graph.addEdge(mutable, nodeA, nodeB, 42)
      * })
      *
-     * const nodeA = 0
-     * const nodeB = 1
-     * const nodeC = 2
-     *
-     * const hasAB = Graph.hasEdge(graph, nodeA, nodeB)
-     * console.log(hasAB) // true
-     *
-     * const hasAC = Graph.hasEdge(graph, nodeA, nodeC)
-     * console.log(hasAC) // false
+     * Graph.hasEdge(graph, 0, 1) // => true
+     * Graph.hasEdge(graph, 0, 2) // => false
      * ```
      *
      * @category getters
@@ -1453,11 +2267,11 @@ export declare const hasEdge: {
  *
  * **Example** (Counting edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const emptyGraph = Graph.directed<string, number>()
- * console.log(Graph.edgeCount(emptyGraph)) // 0
+ * Graph.edgeCount(emptyGraph) // => 0
  *
  * const graphWithEdges = Graph.mutate(emptyGraph, (mutable) => {
  *   const nodeA = Graph.addNode(mutable, "Node A")
@@ -1468,7 +2282,7 @@ export declare const hasEdge: {
  *   Graph.addEdge(mutable, nodeC, nodeA, 3)
  * })
  *
- * console.log(Graph.edgeCount(graphWithEdges)) // 3
+ * Graph.edgeCount(graphWithEdges) // => 3
  * ```
  *
  * @category getters
@@ -1485,7 +2299,7 @@ export declare const edgeCount: <N, E, T extends Kind = "directed">(graph: Graph
  *
  * **Example** (Getting outgoing neighbors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1496,15 +2310,8 @@ export declare const edgeCount: <N, E, T extends Kind = "directed">(graph: Graph
  *   Graph.addEdge(mutable, nodeA, nodeC, 2)
  * })
  *
- * const nodeA = 0
- * const nodeB = 1
- * const nodeC = 2
- *
- * const neighborsA = Graph.neighbors(graph, nodeA)
- * console.log(neighborsA) // [1, 2]
- *
- * const neighborsB = Graph.neighbors(graph, nodeB)
- * console.log(neighborsB) // []
+ * Graph.neighbors(graph, 0) // => [1, 2]
+ * Graph.neighbors(graph, 1) // => []
  * ```
  *
  * @category getters
@@ -1521,7 +2328,7 @@ export declare const neighbors: {
      *
      * **Example** (Getting outgoing neighbors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1532,15 +2339,8 @@ export declare const neighbors: {
      *   Graph.addEdge(mutable, nodeA, nodeC, 2)
      * })
      *
-     * const nodeA = 0
-     * const nodeB = 1
-     * const nodeC = 2
-     *
-     * const neighborsA = Graph.neighbors(graph, nodeA)
-     * console.log(neighborsA) // [1, 2]
-     *
-     * const neighborsB = Graph.neighbors(graph, nodeB)
-     * console.log(neighborsB) // []
+     * Graph.neighbors(graph, 0) // => [1, 2]
+     * Graph.neighbors(graph, 1) // => []
      * ```
      *
      * @category getters
@@ -1557,7 +2357,7 @@ export declare const neighbors: {
      *
      * **Example** (Getting outgoing neighbors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1568,15 +2368,8 @@ export declare const neighbors: {
      *   Graph.addEdge(mutable, nodeA, nodeC, 2)
      * })
      *
-     * const nodeA = 0
-     * const nodeB = 1
-     * const nodeC = 2
-     *
-     * const neighborsA = Graph.neighbors(graph, nodeA)
-     * console.log(neighborsA) // [1, 2]
-     *
-     * const neighborsB = Graph.neighbors(graph, nodeB)
-     * console.log(neighborsB) // []
+     * Graph.neighbors(graph, 0) // => [1, 2]
+     * Graph.neighbors(graph, 1) // => []
      * ```
      *
      * @category getters
@@ -1599,7 +2392,7 @@ export declare const neighbors: {
  * @see {@link predecessors} for incoming neighbors in a directed graph
  * @see {@link neighbors} for generic neighbor lookup across graph kinds
  *
- * @category queries
+ * @category getters
  * @since 4.0.0
  */
 export declare const successors: {
@@ -1618,7 +2411,7 @@ export declare const successors: {
      * @see {@link predecessors} for incoming neighbors in a directed graph
      * @see {@link neighbors} for generic neighbor lookup across graph kinds
      *
-     * @category queries
+     * @category getters
      * @since 4.0.0
      */
     (nodeIndex: NodeIndex): <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">) => Array<NodeIndex>;
@@ -1637,7 +2430,7 @@ export declare const successors: {
      * @see {@link predecessors} for incoming neighbors in a directed graph
      * @see {@link neighbors} for generic neighbor lookup across graph kinds
      *
-     * @category queries
+     * @category getters
      * @since 4.0.0
      */
     <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, nodeIndex: NodeIndex): Array<NodeIndex>;
@@ -1657,7 +2450,7 @@ export declare const successors: {
  * @see {@link successors} for outgoing neighbors in a directed graph
  * @see {@link neighbors} for generic neighbor lookup across graph kinds
  *
- * @category queries
+ * @category getters
  * @since 4.0.0
  */
 export declare const predecessors: {
@@ -1676,7 +2469,7 @@ export declare const predecessors: {
      * @see {@link successors} for outgoing neighbors in a directed graph
      * @see {@link neighbors} for generic neighbor lookup across graph kinds
      *
-     * @category queries
+     * @category getters
      * @since 4.0.0
      */
     (nodeIndex: NodeIndex): <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">) => Array<NodeIndex>;
@@ -1695,7 +2488,7 @@ export declare const predecessors: {
      * @see {@link successors} for outgoing neighbors in a directed graph
      * @see {@link neighbors} for generic neighbor lookup across graph kinds
      *
-     * @category queries
+     * @category getters
      * @since 4.0.0
      */
     <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, nodeIndex: NodeIndex): Array<NodeIndex>;
@@ -1714,7 +2507,7 @@ export declare const predecessors: {
  *
  * **Example** (Traversing directed neighbors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -1731,12 +2524,13 @@ export declare const predecessors: {
  *
  * // Get incoming neighbors (nodes that point to nodeB)
  * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming")
+ * Array.of(outgoing, incoming) // => [[1], [0]]
  * ```
  *
  * @deprecated Use {@link successors} for outgoing neighbors or {@link predecessors} for incoming neighbors.
  * @see {@link successors} for outgoing neighbors in a directed graph
  * @see {@link predecessors} for incoming neighbors in a directed graph
- * @category queries
+ * @category getters
  * @since 3.18.0
  */
 export declare const neighborsDirected: {
@@ -1754,7 +2548,7 @@ export declare const neighborsDirected: {
      *
      * **Example** (Traversing directed neighbors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, string>((mutable) => {
@@ -1771,12 +2565,13 @@ export declare const neighborsDirected: {
      *
      * // Get incoming neighbors (nodes that point to nodeB)
      * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming")
+     * Array.of(outgoing, incoming) // => [[1], [0]]
      * ```
      *
      * @deprecated Use {@link successors} for outgoing neighbors or {@link predecessors} for incoming neighbors.
      * @see {@link successors} for outgoing neighbors in a directed graph
      * @see {@link predecessors} for incoming neighbors in a directed graph
-     * @category queries
+     * @category getters
      * @since 3.18.0
      */
     (nodeIndex: NodeIndex, direction: Direction): <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">) => Array<NodeIndex>;
@@ -1794,7 +2589,7 @@ export declare const neighborsDirected: {
      *
      * **Example** (Traversing directed neighbors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, string>((mutable) => {
@@ -1811,12 +2606,13 @@ export declare const neighborsDirected: {
      *
      * // Get incoming neighbors (nodes that point to nodeB)
      * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming")
+     * Array.of(outgoing, incoming) // => [[1], [0]]
      * ```
      *
      * @deprecated Use {@link successors} for outgoing neighbors or {@link predecessors} for incoming neighbors.
      * @see {@link successors} for outgoing neighbors in a directed graph
      * @see {@link predecessors} for incoming neighbors in a directed graph
-     * @category queries
+     * @category getters
      * @since 3.18.0
      */
     <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, nodeIndex: NodeIndex, direction: Direction): Array<NodeIndex>;
@@ -1831,7 +2627,7 @@ export declare const neighborsDirected: {
  *
  * **Example** (Configuring GraphViz labels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Graph } from "effect"
  *
  * // Basic options with custom labels
@@ -1846,6 +2642,7 @@ export declare const neighborsDirected: {
  *   edgeLabel: (data) => data,
  *   graphName: "MyDependencyGraph"
  * }
+ * Array.of(basicOptions.nodeLabel?.("A"), namedOptions.graphName) // => ["Node: A", "MyDependencyGraph"]
  * ```
  *
  * @category options
@@ -1873,7 +2670,7 @@ export interface GraphVizOptions<N, E> {
  *
  * **Example** (Exporting GraphViz DOT)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1885,16 +2682,7 @@ export interface GraphVizOptions<N, E> {
  *   Graph.addEdge(mutable, nodeC, nodeA, 3)
  * })
  *
- * const dot = Graph.toGraphViz(graph)
- * console.log(dot)
- * // digraph G {
- * //   "0" [label="Node A"];
- * //   "1" [label="Node B"];
- * //   "2" [label="Node C"];
- * //   "0" -> "1" [label="1"];
- * //   "1" -> "2" [label="2"];
- * //   "2" -> "0" [label="3"];
- * // }
+ * Graph.toGraphViz(graph).split("\n") // => ['digraph "G" {', '  "0" [label="Node A"];', '  "1" [label="Node B"];', '  "2" [label="Node C"];', '  "0" -> "1" [label="1"];', '  "1" -> "2" [label="2"];', '  "2" -> "0" [label="3"];', "}"]
  * ```
  *
  * @category converting
@@ -1906,7 +2694,7 @@ export declare const toGraphViz: {
      *
      * **Example** (Exporting GraphViz DOT)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1918,16 +2706,7 @@ export declare const toGraphViz: {
      *   Graph.addEdge(mutable, nodeC, nodeA, 3)
      * })
      *
-     * const dot = Graph.toGraphViz(graph)
-     * console.log(dot)
-     * // digraph G {
-     * //   "0" [label="Node A"];
-     * //   "1" [label="Node B"];
-     * //   "2" [label="Node C"];
-     * //   "0" -> "1" [label="1"];
-     * //   "1" -> "2" [label="2"];
-     * //   "2" -> "0" [label="3"];
-     * // }
+     * Graph.toGraphViz(graph).split("\n") // => ['digraph "G" {', '  "0" [label="Node A"];', '  "1" [label="Node B"];', '  "2" [label="Node C"];', '  "0" -> "1" [label="1"];', '  "1" -> "2" [label="2"];', '  "2" -> "0" [label="3"];', "}"]
      * ```
      *
      * @category converting
@@ -1939,7 +2718,7 @@ export declare const toGraphViz: {
      *
      * **Example** (Exporting GraphViz DOT)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1951,16 +2730,7 @@ export declare const toGraphViz: {
      *   Graph.addEdge(mutable, nodeC, nodeA, 3)
      * })
      *
-     * const dot = Graph.toGraphViz(graph)
-     * console.log(dot)
-     * // digraph G {
-     * //   "0" [label="Node A"];
-     * //   "1" [label="Node B"];
-     * //   "2" [label="Node C"];
-     * //   "0" -> "1" [label="1"];
-     * //   "1" -> "2" [label="2"];
-     * //   "2" -> "0" [label="3"];
-     * // }
+     * Graph.toGraphViz(graph).split("\n") // => ['digraph "G" {', '  "0" [label="Node A"];', '  "1" [label="Node B"];', '  "2" [label="Node C"];', '  "0" -> "1" [label="1"];', '  "1" -> "2" [label="2"];', '  "2" -> "0" [label="3"];', "}"]
      * ```
      *
      * @category converting
@@ -1985,7 +2755,7 @@ export declare const toGraphViz: {
  *
  * **Example** (Selecting Mermaid node shapes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Graph } from "effect"
  *
  * // Shape selector function for different node types
@@ -2000,6 +2770,7 @@ export declare const toGraphViz: {
  * const options: Graph.MermaidOptions<string, string> = {
  *   nodeShape: shapeSelector
  * }
+ * options.nodeShape?.("decision") // => "diamond"
  * ```
  *
  * @category models
@@ -2019,7 +2790,7 @@ export type MermaidNodeShape = "rectangle" | "rounded" | "circle" | "diamond" |
  *
  * **Example** (Configuring Mermaid directions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Graph } from "effect"
  *
  * // Horizontal workflow diagram
@@ -2036,6 +2807,7 @@ export type MermaidNodeShape = "rectangle" | "rounded" | "circle" | "diamond" |
  * const bottomUpOptions: Graph.MermaidOptions<string, string> = {
  *   direction: "BT"
  * }
+ * Array.of(horizontalOptions.direction, verticalOptions.direction, bottomUpOptions.direction) // => ["LR", "TB", "BT"]
  * ```
  *
  * @category models
@@ -2056,7 +2828,7 @@ export type MermaidDirection = "TB" | "TD" | "BT" | "RL" | "LR";
  *
  * **Example** (Selecting Mermaid diagram types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Graph } from "effect"
  *
  * // Force flowchart format (even for undirected graphs)
@@ -2071,6 +2843,7 @@ export type MermaidDirection = "TB" | "TD" | "BT" | "RL" | "LR";
  *
  * // Auto-detection (recommended, default behavior)
  * const autoOptions: Graph.MermaidOptions<string, string> = {}
+ * Array.of(flowchartOptions.diagramType, graphOptions.diagramType, autoOptions.diagramType) // => ["flowchart", "graph", undefined]
  * ```
  *
  * @category models
@@ -2093,7 +2866,7 @@ export type MermaidDiagramType = "flowchart" | "graph";
  *
  * **Example** (Configuring Mermaid output)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Graph } from "effect"
  *
  * // Basic options with custom labels
@@ -2110,6 +2883,7 @@ export type MermaidDiagramType = "flowchart" | "graph";
  *   direction: "LR",
  *   nodeShape: (data) => data.includes("start") ? "circle" : "rectangle"
  * }
+ * Array.of(basicOptions.nodeLabel?.("A"), advancedOptions.nodeShape?.("start")) // => ["Node: A", "circle"]
  * ```
  *
  * @category options
@@ -2155,7 +2929,7 @@ export interface MermaidOptions<N, E> {
  *
  * **Example** (Exporting a directed Mermaid diagram)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Basic directed graph export
@@ -2167,19 +2941,12 @@ export interface MermaidOptions<N, E> {
  *   Graph.addEdge(mutable, app, cache, 2)
  * })
  *
- * const mermaid = Graph.toMermaid(graph)
- * console.log(mermaid)
- * // flowchart TD
- * //   0["App"]
- * //   1["Database"]
- * //   2["Cache"]
- * //   0 -->|"1"| 1
- * //   0 -->|"2"| 2
+ * Graph.toMermaid(graph).split("\n") // => ["flowchart TD", '  0["App"]', '  1["Database"]', '  2["Cache"]', '  0 -->|"1"| 1', '  0 -->|"2"| 2']
  * ```
  *
  * **Example** (Exporting an undirected Mermaid diagram)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Undirected graph with custom labels and direction
@@ -2196,18 +2963,12 @@ export interface MermaidOptions<N, E> {
  *   edgeLabel: (relationship) => relationship,
  *   direction: "LR"
  * })
- * console.log(mermaid)
- * // graph LR
- * //   0["Alice"]
- * //   1["Bob"]
- * //   2["Charlie"]
- * //   0 ---|"friends"| 1
- * //   1 ---|"colleagues"| 2
+ * mermaid.split("\n") // => ["graph LR", '  0["Alice"]', '  1["Bob"]', '  2["Charlie"]', '  0 ---|"friends"| 1', '  1 ---|"colleagues"| 2']
  * ```
  *
  * **Example** (Customizing Mermaid node shapes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Advanced styling with node shapes for flowchart
@@ -2246,20 +3007,12 @@ export interface MermaidOptions<N, E> {
  *     }
  *   }
  * })
- * console.log(mermaid)
- * // flowchart TD
- * //   0(["Begin"])
- * //   1["Process Data"]
- * //   2{"Valid?"}
- * //   3(["Complete"])
- * //   0 --> 1
- * //   1 --> 2
- * //   2 --> 3
+ * mermaid.split("\n") // => ["flowchart TD", '  0(["Begin"])', '  1["Process Data"]', '  2{"Valid?"}', '  3(["Complete"])', "  0 --> 1", "  1 --> 2", '  2 -->|"yes"| 3']
  * ```
  *
  * **Example** (Visualizing dependency graphs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Real-world example: Software dependency graph
@@ -2274,22 +3027,22 @@ export interface MermaidOptions<N, E> {
  *     name: "MyApp",
  *     version: "1.0.0",
  *     type: "library"
- *   })
+ *   } satisfies Dependency)
  *   const react = Graph.addNode(mutable, {
  *     name: "React",
  *     version: "18.0.0",
  *     type: "framework"
- *   })
+ *   } satisfies Dependency)
  *   const lodash = Graph.addNode(mutable, {
  *     name: "Lodash",
  *     version: "4.17.0",
  *     type: "library"
- *   })
+ *   } satisfies Dependency)
  *   const webpack = Graph.addNode(mutable, {
  *     name: "Webpack",
  *     version: "5.0.0",
  *     type: "tool"
- *   })
+ *   } satisfies Dependency)
  *
  *   Graph.addEdge(mutable, app, react, "depends on")
  *   Graph.addEdge(mutable, app, lodash, "depends on")
@@ -2308,15 +3061,7 @@ export interface MermaidOptions<N, E> {
  *   direction: "TB"
  * })
  *
- * console.log(dependencyDiagram)
- * // flowchart TB
- * //   0["MyApp\nv1.0.0"]
- * //   1{{"React\nv18.0.0"}}
- * //   2["Lodash\nv4.17.0"]
- * //   3{"Webpack\nv5.0.0"}
- * //   0 -->|"depends on"| 1
- * //   0 -->|"depends on"| 2
- * //   0 -->|"builds with"| 3
+ * dependencyDiagram.split("\n") // => ["flowchart TB", '  0["MyApp#92;nv1.0.0"]', '  1{{"React#92;nv18.0.0"}}', '  2["Lodash#92;nv4.17.0"]', '  3{"Webpack#92;nv5.0.0"}', '  0 -->|"depends on"| 1', '  0 -->|"depends on"| 2', '  0 -->|"builds with"| 3']
  * ```
  *
  * @category converting
@@ -2335,7 +3080,7 @@ export declare const toMermaid: {
      *
      * **Example** (Exporting a directed Mermaid diagram)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Basic directed graph export
@@ -2347,19 +3092,12 @@ export declare const toMermaid: {
      *   Graph.addEdge(mutable, app, cache, 2)
      * })
      *
-     * const mermaid = Graph.toMermaid(graph)
-     * console.log(mermaid)
-     * // flowchart TD
-     * //   0["App"]
-     * //   1["Database"]
-     * //   2["Cache"]
-     * //   0 -->|"1"| 1
-     * //   0 -->|"2"| 2
+     * Graph.toMermaid(graph).split("\n") // => ["flowchart TD", '  0["App"]', '  1["Database"]', '  2["Cache"]', '  0 -->|"1"| 1', '  0 -->|"2"| 2']
      * ```
      *
      * **Example** (Exporting an undirected Mermaid diagram)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Undirected graph with custom labels and direction
@@ -2376,18 +3114,12 @@ export declare const toMermaid: {
      *   edgeLabel: (relationship) => relationship,
      *   direction: "LR"
      * })
-     * console.log(mermaid)
-     * // graph LR
-     * //   0["Alice"]
-     * //   1["Bob"]
-     * //   2["Charlie"]
-     * //   0 ---|"friends"| 1
-     * //   1 ---|"colleagues"| 2
+     * mermaid.split("\n") // => ["graph LR", '  0["Alice"]', '  1["Bob"]', '  2["Charlie"]', '  0 ---|"friends"| 1', '  1 ---|"colleagues"| 2']
      * ```
      *
      * **Example** (Customizing Mermaid node shapes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Advanced styling with node shapes for flowchart
@@ -2426,20 +3158,12 @@ export declare const toMermaid: {
      *     }
      *   }
      * })
-     * console.log(mermaid)
-     * // flowchart TD
-     * //   0(["Begin"])
-     * //   1["Process Data"]
-     * //   2{"Valid?"}
-     * //   3(["Complete"])
-     * //   0 --> 1
-     * //   1 --> 2
-     * //   2 --> 3
+     * mermaid.split("\n") // => ["flowchart TD", '  0(["Begin"])', '  1["Process Data"]', '  2{"Valid?"}', '  3(["Complete"])', "  0 --> 1", "  1 --> 2", '  2 -->|"yes"| 3']
      * ```
      *
      * **Example** (Visualizing dependency graphs)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Real-world example: Software dependency graph
@@ -2454,22 +3178,22 @@ export declare const toMermaid: {
      *     name: "MyApp",
      *     version: "1.0.0",
      *     type: "library"
-     *   })
+     *   } satisfies Dependency)
      *   const react = Graph.addNode(mutable, {
      *     name: "React",
      *     version: "18.0.0",
      *     type: "framework"
-     *   })
+     *   } satisfies Dependency)
      *   const lodash = Graph.addNode(mutable, {
      *     name: "Lodash",
      *     version: "4.17.0",
      *     type: "library"
-     *   })
+     *   } satisfies Dependency)
      *   const webpack = Graph.addNode(mutable, {
      *     name: "Webpack",
      *     version: "5.0.0",
      *     type: "tool"
-     *   })
+     *   } satisfies Dependency)
      *
      *   Graph.addEdge(mutable, app, react, "depends on")
      *   Graph.addEdge(mutable, app, lodash, "depends on")
@@ -2488,15 +3212,7 @@ export declare const toMermaid: {
      *   direction: "TB"
      * })
      *
-     * console.log(dependencyDiagram)
-     * // flowchart TB
-     * //   0["MyApp\nv1.0.0"]
-     * //   1{{"React\nv18.0.0"}}
-     * //   2["Lodash\nv4.17.0"]
-     * //   3{"Webpack\nv5.0.0"}
-     * //   0 -->|"depends on"| 1
-     * //   0 -->|"depends on"| 2
-     * //   0 -->|"builds with"| 3
+     * dependencyDiagram.split("\n") // => ["flowchart TB", '  0["MyApp#92;nv1.0.0"]', '  1{{"React#92;nv18.0.0"}}', '  2["Lodash#92;nv4.17.0"]', '  3{"Webpack#92;nv5.0.0"}', '  0 -->|"depends on"| 1', '  0 -->|"depends on"| 2', '  0 -->|"builds with"| 3']
      * ```
      *
      * @category converting
@@ -2515,7 +3231,7 @@ export declare const toMermaid: {
      *
      * **Example** (Exporting a directed Mermaid diagram)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Basic directed graph export
@@ -2527,19 +3243,12 @@ export declare const toMermaid: {
      *   Graph.addEdge(mutable, app, cache, 2)
      * })
      *
-     * const mermaid = Graph.toMermaid(graph)
-     * console.log(mermaid)
-     * // flowchart TD
-     * //   0["App"]
-     * //   1["Database"]
-     * //   2["Cache"]
-     * //   0 -->|"1"| 1
-     * //   0 -->|"2"| 2
+     * Graph.toMermaid(graph).split("\n") // => ["flowchart TD", '  0["App"]', '  1["Database"]', '  2["Cache"]', '  0 -->|"1"| 1', '  0 -->|"2"| 2']
      * ```
      *
      * **Example** (Exporting an undirected Mermaid diagram)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Undirected graph with custom labels and direction
@@ -2556,18 +3265,12 @@ export declare const toMermaid: {
      *   edgeLabel: (relationship) => relationship,
      *   direction: "LR"
      * })
-     * console.log(mermaid)
-     * // graph LR
-     * //   0["Alice"]
-     * //   1["Bob"]
-     * //   2["Charlie"]
-     * //   0 ---|"friends"| 1
-     * //   1 ---|"colleagues"| 2
+     * mermaid.split("\n") // => ["graph LR", '  0["Alice"]', '  1["Bob"]', '  2["Charlie"]', '  0 ---|"friends"| 1', '  1 ---|"colleagues"| 2']
      * ```
      *
      * **Example** (Customizing Mermaid node shapes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Advanced styling with node shapes for flowchart
@@ -2606,20 +3309,12 @@ export declare const toMermaid: {
      *     }
      *   }
      * })
-     * console.log(mermaid)
-     * // flowchart TD
-     * //   0(["Begin"])
-     * //   1["Process Data"]
-     * //   2{"Valid?"}
-     * //   3(["Complete"])
-     * //   0 --> 1
-     * //   1 --> 2
-     * //   2 --> 3
+     * mermaid.split("\n") // => ["flowchart TD", '  0(["Begin"])', '  1["Process Data"]', '  2{"Valid?"}', '  3(["Complete"])', "  0 --> 1", "  1 --> 2", '  2 -->|"yes"| 3']
      * ```
      *
      * **Example** (Visualizing dependency graphs)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * // Real-world example: Software dependency graph
@@ -2634,22 +3329,22 @@ export declare const toMermaid: {
      *     name: "MyApp",
      *     version: "1.0.0",
      *     type: "library"
-     *   })
+     *   } satisfies Dependency)
      *   const react = Graph.addNode(mutable, {
      *     name: "React",
      *     version: "18.0.0",
      *     type: "framework"
-     *   })
+     *   } satisfies Dependency)
      *   const lodash = Graph.addNode(mutable, {
      *     name: "Lodash",
      *     version: "4.17.0",
      *     type: "library"
-     *   })
+     *   } satisfies Dependency)
      *   const webpack = Graph.addNode(mutable, {
      *     name: "Webpack",
      *     version: "5.0.0",
      *     type: "tool"
-     *   })
+     *   } satisfies Dependency)
      *
      *   Graph.addEdge(mutable, app, react, "depends on")
      *   Graph.addEdge(mutable, app, lodash, "depends on")
@@ -2668,15 +3363,7 @@ export declare const toMermaid: {
      *   direction: "TB"
      * })
      *
-     * console.log(dependencyDiagram)
-     * // flowchart TB
-     * //   0["MyApp\nv1.0.0"]
-     * //   1{{"React\nv18.0.0"}}
-     * //   2["Lodash\nv4.17.0"]
-     * //   3{"Webpack\nv5.0.0"}
-     * //   0 -->|"depends on"| 1
-     * //   0 -->|"depends on"| 2
-     * //   0 -->|"builds with"| 3
+     * dependencyDiagram.split("\n") // => ["flowchart TB", '  0["MyApp#92;nv1.0.0"]', '  1{{"React#92;nv18.0.0"}}', '  2["Lodash#92;nv4.17.0"]', '  3{"Webpack#92;nv5.0.0"}', '  0 -->|"depends on"| 1', '  0 -->|"depends on"| 2', '  0 -->|"builds with"| 3']
      * ```
      *
      * @category converting
@@ -2685,34 +3372,48 @@ export declare const toMermaid: {
     <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>, options?: MermaidOptions<N, E>): string;
 };
 /**
- * Direction for graph traversal, indicating which edges to follow.
+ * Direction of directed edges relative to a node.
+ *
+ * **Details**
+ *
+ * `"outgoing"` selects edges whose source is the node, while `"incoming"`
+ * selects edges whose target is the node.
+ *
+ * @category models
+ * @since 3.18.0
+ */
+export type Direction = "outgoing" | "incoming";
+/**
+ * Controls how traversal follows directed edges.
+ *
+ * **Details**
+ *
+ * `"outgoing"` follows edges from source to target, `"incoming"` follows them
+ * from target to source, and `"undirected"` allows traversal in either
+ * direction.
  *
  * **Example** (Traversing by direction)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
  *   const a = Graph.addNode(mutable, "A")
  *   const b = Graph.addNode(mutable, "B")
- *   Graph.addEdge(mutable, a, b, "A->B")
+ *   const c = Graph.addNode(mutable, "C")
+ *   Graph.addEdge(mutable, a, b, "A-B")
+ *   Graph.addEdge(mutable, a, c, "A-C")
  * })
  *
- * // Follow outgoing edges (normal direction)
- * const outgoingNodes = Array.from(
- *   Graph.indices(Graph.dfs(graph, { start: [0], direction: "outgoing" }))
- * )
- *
- * // Follow incoming edges (reverse direction)
- * const incomingNodes = Array.from(
- *   Graph.indices(Graph.dfs(graph, { start: [1], direction: "incoming" }))
- * )
+ * Array.from(Graph.indices(Graph.bfs(graph, { start: [0], direction: "outgoing" }))) // => [0, 1, 2]
+ * Array.from(Graph.indices(Graph.bfs(graph, { start: [1], direction: "incoming" }))) // => [1, 0]
+ * Array.from(Graph.indices(Graph.bfs(graph, { start: [1], direction: "undirected" }))) // => [1, 0, 2]
  * ```
  *
  * @category models
- * @since 3.18.0
+ * @since 4.0.0
  */
-export type Direction = "outgoing" | "incoming";
+export type TraversalDirection = Direction | "undirected";
 /**
  * Checks whether the graph is acyclic (contains no cycles).
  *
@@ -2720,11 +3421,12 @@ export type Direction = "outgoing" | "incoming";
  *
  * Uses depth-first search to detect back edges, which indicate cycles.
  * For directed graphs, any back edge creates a cycle. For undirected graphs,
- * a back edge that doesn't go to the immediate parent creates a cycle.
+ * a back edge that doesn't use the same edge used to enter the current node
+ * creates a cycle.
  *
  * **Example** (Checking cycles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Acyclic directed graph (DAG)
@@ -2735,7 +3437,7 @@ export type Direction = "outgoing" | "incoming";
  *   Graph.addEdge(mutable, a, b, "A->B")
  *   Graph.addEdge(mutable, b, c, "B->C")
  * })
- * console.log(Graph.isAcyclic(dag)) // true
+ * Graph.isAcyclic(dag) // => true
  *
  * // Cyclic directed graph
  * const cyclic = Graph.directed<string, string>((mutable) => {
@@ -2744,7 +3446,7 @@ export type Direction = "outgoing" | "incoming";
  *   Graph.addEdge(mutable, a, b, "A->B")
  *   Graph.addEdge(mutable, b, a, "B->A") // Creates cycle
  * })
- * console.log(Graph.isAcyclic(cyclic)) // false
+ * Graph.isAcyclic(cyclic) // => false
  * ```
  *
  * @category algorithms
@@ -2762,7 +3464,7 @@ export declare const isAcyclic: <N, E, T extends Kind = "directed">(graph: Graph
  *
  * **Example** (Checking bipartite graphs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Bipartite graph (alternating coloring possible)
@@ -2775,7 +3477,7 @@ export declare const isAcyclic: <N, E, T extends Kind = "directed">(graph: Graph
  *   Graph.addEdge(mutable, b, c, "edge")
  *   Graph.addEdge(mutable, c, d, "edge")
  * })
- * console.log(Graph.isBipartite(bipartite)) // true
+ * Graph.isBipartite(bipartite) // => true
  *
  * // Non-bipartite graph (odd cycle)
  * const triangle = Graph.undirected<string, string>((mutable) => {
@@ -2786,7 +3488,7 @@ export declare const isAcyclic: <N, E, T extends Kind = "directed">(graph: Graph
  *   Graph.addEdge(mutable, b, c, "edge")
  *   Graph.addEdge(mutable, c, a, "edge") // Triangle (3-cycle)
  * })
- * console.log(Graph.isBipartite(triangle)) // false
+ * Graph.isBipartite(triangle) // => false
  * ```
  *
  * @category algorithms
@@ -2799,7 +3501,7 @@ export declare const isBipartite: <N, E>(graph: Graph<N, E, "undirected"> | Muta
  *
  * **Example** (Finding connected components)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.undirected<string, string>((mutable) => {
@@ -2811,8 +3513,7 @@ export declare const isBipartite: <N, E>(graph: Graph<N, E, "undirected"> | Muta
  *   Graph.addEdge(mutable, c, d, "edge") // Component 2: C-D
  * })
  *
- * const components = Graph.connectedComponents(graph)
- * console.log(components) // [[0, 1], [2, 3]]
+ * Graph.connectedComponents(graph) // => [[0, 1], [2, 3]]
  * ```
  *
  * @category algorithms
@@ -2829,7 +3530,7 @@ export declare const connectedComponents: <N, E>(graph: Graph<N, E, "undirected"
  *
  * **Example** (Finding strongly connected components)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -2841,8 +3542,7 @@ export declare const connectedComponents: <N, E>(graph: Graph<N, E, "undirected"
  *   Graph.addEdge(mutable, c, a, "C->A") // Creates SCC: A-B-C
  * })
  *
- * const sccs = Graph.stronglyConnectedComponents(graph)
- * console.log(sccs) // [[0, 1, 2]]
+ * Graph.stronglyConnectedComponents(graph) // => [[0, 2, 1]]
  * ```
  *
  * @category algorithms
@@ -2892,12 +3592,13 @@ export interface PathResult<E> {
  * **Details**
  *
  * Specifies the source and target node indices, plus a cost function that maps
- * each edge's data to a non-negative numeric weight.
+ * each edge's data to a non-negative numeric weight. `Infinity` is allowed and
+ * behaves like an impassable edge.
  *
  * **Gotchas**
  *
  * `dijkstra` throws a `GraphError` when either endpoint does not exist or when
- * the cost function returns a negative weight.
+ * the cost function returns a negative weight or `NaN`.
  *
  * @see {@link dijkstra} for the algorithm that consumes this configuration
  * @see {@link AstarConfig} for heuristic shortest-path search
@@ -2917,14 +3618,15 @@ export interface DijkstraConfig<E> {
  *
  * **Details**
  *
- * Edge costs must be non-negative. Returns `Option.none()` when the target is
- * not reachable, and throws a `GraphError` when either endpoint is missing or a
- * negative edge cost is encountered.
+ * Edge costs must be non-negative and not `NaN`. `Infinity` is allowed and
+ * behaves like an impassable edge. Returns `Option.none()` when the target is
+ * not reachable, and throws a `GraphError` when either endpoint is missing or an
+ * edge cost is negative or `NaN`.
  *
  * **Example** (Finding shortest paths with Dijkstra)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   const a = Graph.addNode(mutable, "A")
@@ -2941,10 +3643,7 @@ export interface DijkstraConfig<E> {
  *   cost: (edgeData) => edgeData
  * })
  *
- * if (result._tag === "Some") {
- *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
- *   console.log(result.value.distance) // 7 - total distance
- * }
+ * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([7, [0, 1, 2]])
  * ```
  *
  * @category algorithms
@@ -2957,14 +3656,15 @@ export declare const dijkstra: {
      *
      * **Details**
      *
-     * Edge costs must be non-negative. Returns `Option.none()` when the target is
-     * not reachable, and throws a `GraphError` when either endpoint is missing or a
-     * negative edge cost is encountered.
+     * Edge costs must be non-negative and not `NaN`. `Infinity` is allowed and
+     * behaves like an impassable edge. Returns `Option.none()` when the target is
+     * not reachable, and throws a `GraphError` when either endpoint is missing or an
+     * edge cost is negative or `NaN`.
      *
      * **Example** (Finding shortest paths with Dijkstra)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
      *   const a = Graph.addNode(mutable, "A")
@@ -2981,10 +3681,7 @@ export declare const dijkstra: {
      *   cost: (edgeData) => edgeData
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
-     *   console.log(result.value.distance) // 7 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([7, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -2997,14 +3694,15 @@ export declare const dijkstra: {
      *
      * **Details**
      *
-     * Edge costs must be non-negative. Returns `Option.none()` when the target is
-     * not reachable, and throws a `GraphError` when either endpoint is missing or a
-     * negative edge cost is encountered.
+     * Edge costs must be non-negative and not `NaN`. `Infinity` is allowed and
+     * behaves like an impassable edge. Returns `Option.none()` when the target is
+     * not reachable, and throws a `GraphError` when either endpoint is missing or an
+     * edge cost is negative or `NaN`.
      *
      * **Example** (Finding shortest paths with Dijkstra)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
      *   const a = Graph.addNode(mutable, "A")
@@ -3021,10 +3719,7 @@ export declare const dijkstra: {
      *   cost: (edgeData) => edgeData
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
-     *   console.log(result.value.distance) // 7 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([7, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -3064,12 +3759,13 @@ export interface AllPairsResult<E> {
  * **Details**
  *
  * Computes distances, reconstructed node paths, and edge-data paths for every
- * source and target pair in O(V^3) time. Negative edge weights are allowed, but
- * a `GraphError` is thrown if any negative cycle is detected.
+ * source and target pair in O(V^3) time. Negative edge weights are allowed, and
+ * `Infinity` behaves like an impassable edge. A `GraphError` is thrown if any
+ * edge weight is `NaN` or `-Infinity`, or if any negative cycle is detected.
  *
  * **Example** (Finding all-pairs shortest paths)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3082,8 +3778,8 @@ export interface AllPairsResult<E> {
  * })
  *
  * const result = Graph.floydWarshall(graph, (edgeData) => edgeData)
- * const distanceAToC = result.distances.get(0)?.get(2) // 5 (A->B->C)
- * const pathAToC = result.paths.get(0)?.get(2) // [0, 1, 2]
+ * const shortest = { distance: result.distances.get(0)?.get(2), path: result.paths.get(0)?.get(2) }
+ * shortest // => { distance: 5, path: [0, 1, 2] }
  * ```
  *
  * @category algorithms
@@ -3097,12 +3793,13 @@ export declare const floydWarshall: {
      * **Details**
      *
      * Computes distances, reconstructed node paths, and edge-data paths for every
-     * source and target pair in O(V^3) time. Negative edge weights are allowed, but
-     * a `GraphError` is thrown if any negative cycle is detected.
+     * source and target pair in O(V^3) time. Negative edge weights are allowed, and
+     * `Infinity` behaves like an impassable edge. A `GraphError` is thrown if any
+     * edge weight is `NaN` or `-Infinity`, or if any negative cycle is detected.
      *
      * **Example** (Finding all-pairs shortest paths)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3115,8 +3812,8 @@ export declare const floydWarshall: {
      * })
      *
      * const result = Graph.floydWarshall(graph, (edgeData) => edgeData)
-     * const distanceAToC = result.distances.get(0)?.get(2) // 5 (A->B->C)
-     * const pathAToC = result.paths.get(0)?.get(2) // [0, 1, 2]
+     * const shortest = { distance: result.distances.get(0)?.get(2), path: result.paths.get(0)?.get(2) }
+     * shortest // => { distance: 5, path: [0, 1, 2] }
      * ```
      *
      * @category algorithms
@@ -3130,12 +3827,13 @@ export declare const floydWarshall: {
      * **Details**
      *
      * Computes distances, reconstructed node paths, and edge-data paths for every
-     * source and target pair in O(V^3) time. Negative edge weights are allowed, but
-     * a `GraphError` is thrown if any negative cycle is detected.
+     * source and target pair in O(V^3) time. Negative edge weights are allowed, and
+     * `Infinity` behaves like an impassable edge. A `GraphError` is thrown if any
+     * edge weight is `NaN` or `-Infinity`, or if any negative cycle is detected.
      *
      * **Example** (Finding all-pairs shortest paths)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3148,8 +3846,8 @@ export declare const floydWarshall: {
      * })
      *
      * const result = Graph.floydWarshall(graph, (edgeData) => edgeData)
-     * const distanceAToC = result.distances.get(0)?.get(2) // 5 (A->B->C)
-     * const pathAToC = result.paths.get(0)?.get(2) // [0, 1, 2]
+     * const shortest = { distance: result.distances.get(0)?.get(2), path: result.paths.get(0)?.get(2) }
+     * shortest // => { distance: 5, path: [0, 1, 2] }
      * ```
      *
      * @category algorithms
@@ -3167,8 +3865,9 @@ export declare const floydWarshall: {
  *
  * **Details**
  *
- * Specifies the source and target node indices, an edge-cost function, and a
- * heuristic that estimates the remaining cost from a node to the target.
+ * Specifies the source and target node indices, an edge-cost function that maps
+ * edge data to non-negative weights, and a heuristic that estimates the
+ * remaining cost from a node to the target.
  *
  * @see {@link astar} for the algorithm that consumes this configuration
  * @see {@link DijkstraConfig} for shortest paths without a heuristic
@@ -3189,15 +3888,16 @@ export interface AstarConfig<E, N> {
  *
  * **Details**
  *
- * The edge-cost function must return non-negative weights, and the heuristic
+ * The edge-cost function must return non-negative weights and not `NaN`.
+ * `Infinity` is allowed and behaves like an impassable edge. The heuristic
  * should be consistent to preserve shortest-path guarantees. Returns
  * `Option.none()` when the target is not reachable, and throws a `GraphError`
- * when either endpoint is missing or a negative edge cost is encountered.
+ * when either endpoint is missing or an edge cost is negative or `NaN`.
  *
  * **Example** (Finding shortest paths with A-star)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<{ x: number; y: number }, number>((mutable) => {
  *   const a = Graph.addNode(mutable, { x: 0, y: 0 })
@@ -3220,10 +3920,7 @@ export interface AstarConfig<E, N> {
  *   heuristic
  * })
  *
- * if (result._tag === "Some") {
- *   console.log(result.value.path) // [0, 1, 2] - shortest path
- *   console.log(result.value.distance) // 2 - total distance
- * }
+ * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
  * ```
  *
  * @category algorithms
@@ -3236,15 +3933,16 @@ export declare const astar: {
      *
      * **Details**
      *
-     * The edge-cost function must return non-negative weights, and the heuristic
+     * The edge-cost function must return non-negative weights and not `NaN`.
+     * `Infinity` is allowed and behaves like an impassable edge. The heuristic
      * should be consistent to preserve shortest-path guarantees. Returns
      * `Option.none()` when the target is not reachable, and throws a `GraphError`
-     * when either endpoint is missing or a negative edge cost is encountered.
+     * when either endpoint is missing or an edge cost is negative or `NaN`.
      *
      * **Example** (Finding shortest paths with A-star)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<{ x: number; y: number }, number>((mutable) => {
      *   const a = Graph.addNode(mutable, { x: 0, y: 0 })
@@ -3267,10 +3965,7 @@ export declare const astar: {
      *   heuristic
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path
-     *   console.log(result.value.distance) // 2 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -3283,15 +3978,16 @@ export declare const astar: {
      *
      * **Details**
      *
-     * The edge-cost function must return non-negative weights, and the heuristic
+     * The edge-cost function must return non-negative weights and not `NaN`.
+     * `Infinity` is allowed and behaves like an impassable edge. The heuristic
      * should be consistent to preserve shortest-path guarantees. Returns
      * `Option.none()` when the target is not reachable, and throws a `GraphError`
-     * when either endpoint is missing or a negative edge cost is encountered.
+     * when either endpoint is missing or an edge cost is negative or `NaN`.
      *
      * **Example** (Finding shortest paths with A-star)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<{ x: number; y: number }, number>((mutable) => {
      *   const a = Graph.addNode(mutable, { x: 0, y: 0 })
@@ -3314,10 +4010,7 @@ export declare const astar: {
      *   heuristic
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path
-     *   console.log(result.value.distance) // 2 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -3356,14 +4049,15 @@ export interface BellmanFordConfig<E> {
  *
  * **Details**
  *
- * Negative edge weights are allowed. Returns `Option.none()` when the target is
- * unreachable or when a negative cycle affects the path to the target. Throws a
- * `GraphError` when either endpoint is missing.
+ * Negative edge weights are allowed, and `Infinity` behaves like an impassable
+ * edge. Returns `Option.none()` when the target is unreachable or when a
+ * negative cycle affects the path to the target. Throws a `GraphError` when
+ * either endpoint is missing or an edge weight is `NaN` or `-Infinity`.
  *
  * **Example** (Finding shortest paths with Bellman-Ford)
  *
- * ```ts
- * import { Graph } from "effect"
+ * ```ts import.meta.vitest
+ * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
  *   const a = Graph.addNode(mutable, "A")
@@ -3380,10 +4074,7 @@ export interface BellmanFordConfig<E> {
  *   cost: (edgeData) => edgeData
  * })
  *
- * if (result._tag === "Some") {
- *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
- *   console.log(result.value.distance) // 2 - total distance
- * }
+ * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
  * ```
  *
  * @category algorithms
@@ -3396,14 +4087,15 @@ export declare const bellmanFord: {
      *
      * **Details**
      *
-     * Negative edge weights are allowed. Returns `Option.none()` when the target is
-     * unreachable or when a negative cycle affects the path to the target. Throws a
-     * `GraphError` when either endpoint is missing.
+     * Negative edge weights are allowed, and `Infinity` behaves like an impassable
+     * edge. Returns `Option.none()` when the target is unreachable or when a
+     * negative cycle affects the path to the target. Throws a `GraphError` when
+     * either endpoint is missing or an edge weight is `NaN` or `-Infinity`.
      *
      * **Example** (Finding shortest paths with Bellman-Ford)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
      *   const a = Graph.addNode(mutable, "A")
@@ -3420,10 +4112,7 @@ export declare const bellmanFord: {
      *   cost: (edgeData) => edgeData
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
-     *   console.log(result.value.distance) // 2 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -3436,14 +4125,15 @@ export declare const bellmanFord: {
      *
      * **Details**
      *
-     * Negative edge weights are allowed. Returns `Option.none()` when the target is
-     * unreachable or when a negative cycle affects the path to the target. Throws a
-     * `GraphError` when either endpoint is missing.
+     * Negative edge weights are allowed, and `Infinity` behaves like an impassable
+     * edge. Returns `Option.none()` when the target is unreachable or when a
+     * negative cycle affects the path to the target. Throws a `GraphError` when
+     * either endpoint is missing or an edge weight is `NaN` or `-Infinity`.
      *
      * **Example** (Finding shortest paths with Bellman-Ford)
      *
-     * ```ts
-     * import { Graph } from "effect"
+     * ```ts import.meta.vitest
+     * import { Graph, Option } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
      *   const a = Graph.addNode(mutable, "A")
@@ -3460,10 +4150,7 @@ export declare const bellmanFord: {
      *   cost: (edgeData) => edgeData
      * })
      *
-     * if (result._tag === "Some") {
-     *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
-     *   console.log(result.value.distance) // 2 - total distance
-     * }
+     * Option.map(result, ({ distance, path }) => [distance, path] as const) // => Option.some([2, [0, 1, 2]])
      * ```
      *
      * @category algorithms
@@ -3482,7 +4169,7 @@ export declare const bellmanFord: {
  *
  * **Example** (Working with node walkers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3501,8 +4188,8 @@ export declare const bellmanFord: {
  * }
  *
  * // Access node data using values() or entries()
- * const nodeData = Array.from(Graph.values(dfsNodes)) // ["A", "B"]
- * const nodeEntries = Array.from(Graph.entries(allNodes)) // [[0, "A"], [1, "B"]]
+ * Array.from(Graph.values(dfsNodes)) // => ["A", "B"]
+ * Array.from(Graph.entries(allNodes)) // => [[0, "A"], [1, "B"]]
  * ```
  *
  * @category models
@@ -3521,7 +4208,7 @@ export declare class Walker<T, N> implements Iterable<[T, N]> {
      *
      * **Example** (Visiting walker elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3533,14 +4220,10 @@ export declare class Walker<T, N> implements Iterable<[T, N]> {
      * const dfs = Graph.dfs(graph, { start: [0] })
      *
      * // Map to just the node data
-     * const values = Array.from(dfs.visit((index, data) => data))
-     * console.log(values) // ["A", "B"]
+     * Array.from(dfs.visit((index, data) => data)) // => ["A", "B"]
      *
      * // Map to custom objects
-     * const custom = Array.from(
-     *   dfs.visit((index, data) => ({ id: index, name: data }))
-     * )
-     * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }]
+     * Array.from(dfs.visit((index, data) => ({ id: index, name: data }))) // => [{ id: 0, name: "A" }, { id: 1, name: "B" }]
      * ```
      *
      * @since 4.0.0
@@ -3556,7 +4239,7 @@ export declare class Walker<T, N> implements Iterable<[T, N]> {
      *
      * **Example** (Visiting walker elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3568,14 +4251,10 @@ export declare class Walker<T, N> implements Iterable<[T, N]> {
      * const dfs = Graph.dfs(graph, { start: [0] })
      *
      * // Map to just the node data
-     * const values = Array.from(dfs.visit((index, data) => data))
-     * console.log(values) // ["A", "B"]
+     * Array.from(dfs.visit((index, data) => data)) // => ["A", "B"]
      *
      * // Map to custom objects
-     * const custom = Array.from(
-     *   dfs.visit((index, data) => ({ id: index, name: data }))
-     * )
-     * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }]
+     * Array.from(dfs.visit((index, data) => ({ id: index, name: data }))) // => [{ id: 0, name: "A" }, { id: 1, name: "B" }]
      * ```
      *
      * @category iterators
@@ -3622,7 +4301,7 @@ export type EdgeWalker<E> = Walker<EdgeIndex, Edge<E>>;
  *
  * **Example** (Iterating walker indices)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3632,8 +4311,7 @@ export type EdgeWalker<E> = Walker<EdgeIndex, Edge<E>>;
  * })
  *
  * const dfs = Graph.dfs(graph, { start: [0] })
- * const indices = Array.from(Graph.indices(dfs))
- * console.log(indices) // [0, 1]
+ * Array.from(Graph.indices(dfs)) // => [0, 1]
  * ```
  *
  * @category iterators
@@ -3645,7 +4323,7 @@ export declare const indices: <T, N>(walker: Walker<T, N>) => Iterable<T>;
  *
  * **Example** (Iterating walker values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3655,8 +4333,7 @@ export declare const indices: <T, N>(walker: Walker<T, N>) => Iterable<T>;
  * })
  *
  * const dfs = Graph.dfs(graph, { start: [0] })
- * const values = Array.from(Graph.values(dfs))
- * console.log(values) // ["A", "B"]
+ * Array.from(Graph.values(dfs)) // => ["A", "B"]
  * ```
  *
  * @category iterators
@@ -3668,7 +4345,7 @@ export declare const values: <T, N>(walker: Walker<T, N>) => Iterable<N>;
  *
  * **Example** (Iterating walker entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3678,8 +4355,7 @@ export declare const values: <T, N>(walker: Walker<T, N>) => Iterable<N>;
  * })
  *
  * const dfs = Graph.dfs(graph, { start: [0] })
- * const entries = Array.from(Graph.entries(dfs))
- * console.log(entries) // [[0, "A"], [1, "B"]]
+ * Array.from(Graph.entries(dfs)) // => [[0, "A"], [1, "B"]]
  * ```
  *
  * @category iterators
@@ -3698,7 +4374,8 @@ export declare const entries: <T, N>(walker: Walker<T, N>) => Iterable<[T, N]>;
  *
  * `start` supplies the node indices where traversal begins. If it is omitted,
  * the iterator is empty. `direction` chooses whether traversal follows
- * outgoing or incoming edges.
+ * outgoing edges, incoming edges, or ignores edge direction. `radius` limits
+ * traversal by edge distance from the nearest start node.
  *
  * **Gotchas**
  *
@@ -3714,7 +4391,8 @@ export declare const entries: <T, N>(walker: Walker<T, N>) => Iterable<[T, N]>;
  */
 export interface SearchConfig {
     readonly start?: Array<NodeIndex>;
-    readonly direction?: Direction;
+    readonly direction?: TraversalDirection;
+    readonly radius?: number;
 }
 /**
  * Creates a lazy depth-first traversal iterator from the configured start
@@ -3723,12 +4401,13 @@ export interface SearchConfig {
  * **Details**
  *
  * If no start nodes are supplied, the iterator is empty. The `direction` option
- * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+ * chooses whether to follow outgoing or incoming edges. The `radius` option
+ * limits traversal by edge distance from the start nodes. Throws a `GraphError`
  * if any configured start node does not exist.
  *
  * **Example** (Traversing depth-first)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3740,14 +4419,10 @@ export interface SearchConfig {
  * })
  *
  * // Start from a specific node
- * const dfs1 = Graph.dfs(graph, { start: [0] })
- * for (const nodeIndex of Graph.indices(dfs1)) {
- *   console.log(nodeIndex) // Traverses in DFS order: 0, 1, 2
- * }
+ * Array.from(Graph.indices(Graph.dfs(graph, { start: [0] }))) // => [0, 1, 2]
  *
  * // Empty iterator (no starting nodes)
- * const dfs2 = Graph.dfs(graph)
- * // Can be used programmatically
+ * Graph.dfs(graph)
  * ```
  *
  * @category iterators
@@ -3761,12 +4436,13 @@ export declare const dfs: {
      * **Details**
      *
      * If no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes. Throws a `GraphError`
      * if any configured start node does not exist.
      *
      * **Example** (Traversing depth-first)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3778,14 +4454,10 @@ export declare const dfs: {
      * })
      *
      * // Start from a specific node
-     * const dfs1 = Graph.dfs(graph, { start: [0] })
-     * for (const nodeIndex of Graph.indices(dfs1)) {
-     *   console.log(nodeIndex) // Traverses in DFS order: 0, 1, 2
-     * }
+     * Array.from(Graph.indices(Graph.dfs(graph, { start: [0] }))) // => [0, 1, 2]
      *
      * // Empty iterator (no starting nodes)
-     * const dfs2 = Graph.dfs(graph)
-     * // Can be used programmatically
+     * Graph.dfs(graph)
      * ```
      *
      * @category iterators
@@ -3799,12 +4471,13 @@ export declare const dfs: {
      * **Details**
      *
      * If no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes. Throws a `GraphError`
      * if any configured start node does not exist.
      *
      * **Example** (Traversing depth-first)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3816,14 +4489,10 @@ export declare const dfs: {
      * })
      *
      * // Start from a specific node
-     * const dfs1 = Graph.dfs(graph, { start: [0] })
-     * for (const nodeIndex of Graph.indices(dfs1)) {
-     *   console.log(nodeIndex) // Traverses in DFS order: 0, 1, 2
-     * }
+     * Array.from(Graph.indices(Graph.dfs(graph, { start: [0] }))) // => [0, 1, 2]
      *
      * // Empty iterator (no starting nodes)
-     * const dfs2 = Graph.dfs(graph)
-     * // Can be used programmatically
+     * Graph.dfs(graph)
      * ```
      *
      * @category iterators
@@ -3838,12 +4507,13 @@ export declare const dfs: {
  * **Details**
  *
  * If no start nodes are supplied, the iterator is empty. The `direction` option
- * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+ * chooses whether to follow outgoing or incoming edges. The `radius` option
+ * limits traversal by edge distance from the start nodes. Throws a `GraphError`
  * if any configured start node does not exist.
  *
  * **Example** (Traversing breadth-first)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3855,14 +4525,10 @@ export declare const dfs: {
  * })
  *
  * // Start from a specific node
- * const bfs1 = Graph.bfs(graph, { start: [0] })
- * for (const nodeIndex of Graph.indices(bfs1)) {
- *   console.log(nodeIndex) // Traverses in BFS order: 0, 1, 2
- * }
+ * Array.from(Graph.indices(Graph.bfs(graph, { start: [0] }))) // => [0, 1, 2]
  *
  * // Empty iterator (no starting nodes)
- * const bfs2 = Graph.bfs(graph)
- * // Can be used programmatically
+ * Graph.bfs(graph)
  * ```
  *
  * @category iterators
@@ -3876,12 +4542,13 @@ export declare const bfs: {
      * **Details**
      *
      * If no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes. Throws a `GraphError`
      * if any configured start node does not exist.
      *
      * **Example** (Traversing breadth-first)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3893,14 +4560,10 @@ export declare const bfs: {
      * })
      *
      * // Start from a specific node
-     * const bfs1 = Graph.bfs(graph, { start: [0] })
-     * for (const nodeIndex of Graph.indices(bfs1)) {
-     *   console.log(nodeIndex) // Traverses in BFS order: 0, 1, 2
-     * }
+     * Array.from(Graph.indices(Graph.bfs(graph, { start: [0] }))) // => [0, 1, 2]
      *
      * // Empty iterator (no starting nodes)
-     * const bfs2 = Graph.bfs(graph)
-     * // Can be used programmatically
+     * Graph.bfs(graph)
      * ```
      *
      * @category iterators
@@ -3914,12 +4577,13 @@ export declare const bfs: {
      * **Details**
      *
      * If no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges. Throws a `GraphError`
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes. Throws a `GraphError`
      * if any configured start node does not exist.
      *
      * **Example** (Traversing breadth-first)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -3931,14 +4595,10 @@ export declare const bfs: {
      * })
      *
      * // Start from a specific node
-     * const bfs1 = Graph.bfs(graph, { start: [0] })
-     * for (const nodeIndex of Graph.indices(bfs1)) {
-     *   console.log(nodeIndex) // Traverses in BFS order: 0, 1, 2
-     * }
+     * Array.from(Graph.indices(Graph.bfs(graph, { start: [0] }))) // => [0, 1, 2]
      *
      * // Empty iterator (no starting nodes)
-     * const bfs2 = Graph.bfs(graph)
-     * // Can be used programmatically
+     * Graph.bfs(graph)
      * ```
      *
      * @category iterators
@@ -3981,7 +4641,7 @@ export interface TopoConfig {
  *
  * **Example** (Sorting topologically)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3993,13 +4653,10 @@ export interface TopoConfig {
  * })
  *
  * // Standard topological sort
- * const topo1 = Graph.topo(graph)
- * for (const nodeIndex of Graph.indices(topo1)) {
- *   console.log(nodeIndex) // 0, 1, 2 (topological order)
- * }
+ * Array.from(Graph.indices(Graph.topo(graph))) // => [0, 1, 2]
  *
  * // With initial nodes
- * const topo2 = Graph.topo(graph, { initials: [0] })
+ * Graph.topo(graph, { initials: [0] })
  *
  * // Check before sorting a cyclic graph
  * const cyclicGraph = Graph.directed<string, number>((mutable) => {
@@ -4009,9 +4666,7 @@ export interface TopoConfig {
  *   Graph.addEdge(mutable, b, a, 2) // Creates cycle
  * })
  *
- * if (!Graph.isAcyclic(cyclicGraph)) {
- *   console.log("cyclic graph") // cyclic graph
- * }
+ * Graph.isAcyclic(cyclicGraph) // => false
  * ```
  *
  * @category iterators
@@ -4028,7 +4683,7 @@ export declare const topo: {
      *
      * **Example** (Sorting topologically)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4040,13 +4695,10 @@ export declare const topo: {
      * })
      *
      * // Standard topological sort
-     * const topo1 = Graph.topo(graph)
-     * for (const nodeIndex of Graph.indices(topo1)) {
-     *   console.log(nodeIndex) // 0, 1, 2 (topological order)
-     * }
+     * Array.from(Graph.indices(Graph.topo(graph))) // => [0, 1, 2]
      *
      * // With initial nodes
-     * const topo2 = Graph.topo(graph, { initials: [0] })
+     * Graph.topo(graph, { initials: [0] })
      *
      * // Check before sorting a cyclic graph
      * const cyclicGraph = Graph.directed<string, number>((mutable) => {
@@ -4056,15 +4708,13 @@ export declare const topo: {
      *   Graph.addEdge(mutable, b, a, 2) // Creates cycle
      * })
      *
-     * if (!Graph.isAcyclic(cyclicGraph)) {
-     *   console.log("cyclic graph") // cyclic graph
-     * }
+     * Graph.isAcyclic(cyclicGraph) // => false
      * ```
      *
      * @category iterators
      * @since 3.18.0
      */
-    (config?: TopoConfig): <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>) => NodeWalker<N>;
+    (config?: TopoConfig): <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">) => NodeWalker<N>;
     /**
      * Creates a new topological sort iterator with optional configuration.
      *
@@ -4075,7 +4725,7 @@ export declare const topo: {
      *
      * **Example** (Sorting topologically)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4087,13 +4737,10 @@ export declare const topo: {
      * })
      *
      * // Standard topological sort
-     * const topo1 = Graph.topo(graph)
-     * for (const nodeIndex of Graph.indices(topo1)) {
-     *   console.log(nodeIndex) // 0, 1, 2 (topological order)
-     * }
+     * Array.from(Graph.indices(Graph.topo(graph))) // => [0, 1, 2]
      *
      * // With initial nodes
-     * const topo2 = Graph.topo(graph, { initials: [0] })
+     * Graph.topo(graph, { initials: [0] })
      *
      * // Check before sorting a cyclic graph
      * const cyclicGraph = Graph.directed<string, number>((mutable) => {
@@ -4103,15 +4750,13 @@ export declare const topo: {
      *   Graph.addEdge(mutable, b, a, 2) // Creates cycle
      * })
      *
-     * if (!Graph.isAcyclic(cyclicGraph)) {
-     *   console.log("cyclic graph") // cyclic graph
-     * }
+     * Graph.isAcyclic(cyclicGraph) // => false
      * ```
      *
      * @category iterators
      * @since 3.18.0
      */
-    <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>, config?: TopoConfig): NodeWalker<N>;
+    <N, E>(graph: Graph<N, E, "directed"> | MutableGraph<N, E, "directed">, config?: TopoConfig): NodeWalker<N>;
 };
 /**
  * Creates a lazy depth-first postorder traversal iterator from the configured
@@ -4121,11 +4766,18 @@ export declare const topo: {
  *
  * Nodes are emitted after their reachable descendants have been processed. If
  * no start nodes are supplied, the iterator is empty. The `direction` option
- * chooses whether to follow outgoing or incoming edges.
+ * chooses whether to follow outgoing or incoming edges. The `radius` option
+ * limits traversal by edge distance from the start nodes.
+ *
+ * **Gotchas**
+ *
+ * With a finite `radius`, iteration first performs a bounded breadth-first
+ * traversal to determine shortest-distance membership before emitting nodes in
+ * postorder.
  *
  * **Example** (Traversing in postorder)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4137,10 +4789,7 @@ export declare const topo: {
  * })
  *
  * // Postorder: children before parents
- * const postOrder = Graph.dfsPostOrder(graph, { start: [0] })
- * for (const node of postOrder) {
- *   console.log(node) // 1, 2, 0
- * }
+ * Array.from(Graph.indices(Graph.dfsPostOrder(graph, { start: [0] }))) // => [1, 2, 0]
  * ```
  *
  * @category iterators
@@ -4155,11 +4804,18 @@ export declare const dfsPostOrder: {
      *
      * Nodes are emitted after their reachable descendants have been processed. If
      * no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges.
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes.
+     *
+     * **Gotchas**
+     *
+     * With a finite `radius`, iteration first performs a bounded breadth-first
+     * traversal to determine shortest-distance membership before emitting nodes in
+     * postorder.
      *
      * **Example** (Traversing in postorder)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4171,10 +4827,7 @@ export declare const dfsPostOrder: {
      * })
      *
      * // Postorder: children before parents
-     * const postOrder = Graph.dfsPostOrder(graph, { start: [0] })
-     * for (const node of postOrder) {
-     *   console.log(node) // 1, 2, 0
-     * }
+     * Array.from(Graph.indices(Graph.dfsPostOrder(graph, { start: [0] }))) // => [1, 2, 0]
      * ```
      *
      * @category iterators
@@ -4189,11 +4842,18 @@ export declare const dfsPostOrder: {
      *
      * Nodes are emitted after their reachable descendants have been processed. If
      * no start nodes are supplied, the iterator is empty. The `direction` option
-     * chooses whether to follow outgoing or incoming edges.
+     * chooses whether to follow outgoing or incoming edges. The `radius` option
+     * limits traversal by edge distance from the start nodes.
+     *
+     * **Gotchas**
+     *
+     * With a finite `radius`, iteration first performs a bounded breadth-first
+     * traversal to determine shortest-distance membership before emitting nodes in
+     * postorder.
      *
      * **Example** (Traversing in postorder)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4205,10 +4865,7 @@ export declare const dfsPostOrder: {
      * })
      *
      * // Postorder: children before parents
-     * const postOrder = Graph.dfsPostOrder(graph, { start: [0] })
-     * for (const node of postOrder) {
-     *   console.log(node) // 1, 2, 0
-     * }
+     * Array.from(Graph.indices(Graph.dfsPostOrder(graph, { start: [0] }))) // => [1, 2, 0]
      * ```
      *
      * @category iterators
@@ -4226,7 +4883,7 @@ export declare const dfsPostOrder: {
  *
  * **Example** (Iterating all nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4236,8 +4893,7 @@ export declare const dfsPostOrder: {
  *   Graph.addEdge(mutable, a, b, 1)
  * })
  *
- * const indices = Array.from(Graph.indices(Graph.nodes(graph)))
- * console.log(indices) // [0, 1, 2]
+ * Array.from(Graph.indices(Graph.nodes(graph))) // => [0, 1, 2]
  * ```
  *
  * @category iterators
@@ -4254,7 +4910,7 @@ export declare const nodes: <N, E, T extends Kind = "directed">(graph: Graph<N,
  *
  * **Example** (Iterating all edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4265,8 +4921,7 @@ export declare const nodes: <N, E, T extends Kind = "directed">(graph: Graph<N,
  *   Graph.addEdge(mutable, b, c, 2)
  * })
  *
- * const indices = Array.from(Graph.indices(Graph.edges(graph)))
- * console.log(indices) // [0, 1]
+ * Array.from(Graph.indices(Graph.edges(graph))) // => [0, 1]
  * ```
  *
  * @category iterators
@@ -4307,7 +4962,7 @@ export interface ExternalsConfig {
  *
  * **Example** (Iterating external nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4321,16 +4976,10 @@ export interface ExternalsConfig {
  * })
  *
  * // Nodes with no outgoing edges (sinks + isolated)
- * const sinks = Array.from(
- *   Graph.indices(Graph.externals(graph, { direction: "outgoing" }))
- * )
- * console.log(sinks) // [2, 3]
+ * Array.from(Graph.indices(Graph.externals(graph, { direction: "outgoing" }))) // => [2, 3]
  *
  * // Nodes with no incoming edges (sources + isolated)
- * const sources = Array.from(
- *   Graph.indices(Graph.externals(graph, { direction: "incoming" }))
- * )
- * console.log(sources) // [0, 3]
+ * Array.from(Graph.indices(Graph.externals(graph, { direction: "incoming" }))) // => [0, 3]
  * ```
  *
  * @category iterators
@@ -4348,7 +4997,7 @@ export declare const externals: {
      *
      * **Example** (Iterating external nodes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4362,16 +5011,10 @@ export declare const externals: {
      * })
      *
      * // Nodes with no outgoing edges (sinks + isolated)
-     * const sinks = Array.from(
-     *   Graph.indices(Graph.externals(graph, { direction: "outgoing" }))
-     * )
-     * console.log(sinks) // [2, 3]
+     * Array.from(Graph.indices(Graph.externals(graph, { direction: "outgoing" }))) // => [2, 3]
      *
      * // Nodes with no incoming edges (sources + isolated)
-     * const sources = Array.from(
-     *   Graph.indices(Graph.externals(graph, { direction: "incoming" }))
-     * )
-     * console.log(sources) // [0, 3]
+     * Array.from(Graph.indices(Graph.externals(graph, { direction: "incoming" }))) // => [0, 3]
      * ```
      *
      * @category iterators
@@ -4389,7 +5032,7 @@ export declare const externals: {
      *
      * **Example** (Iterating external nodes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Graph } from "effect"
      *
      * const graph = Graph.directed<string, number>((mutable) => {
@@ -4403,16 +5046,10 @@ export declare const externals: {
      * })
      *
      * // Nodes with no outgoing edges (sinks + isolated)
-     * const sinks = Array.from(
-     *   Graph.indices(Graph.externals(graph, { direction: "outgoing" }))
-     * )
-     * console.log(sinks) // [2, 3]
+     * Array.from(Graph.indices(Graph.externals(graph, { direction: "outgoing" }))) // => [2, 3]
      *
      * // Nodes with no incoming edges (sources + isolated)
-     * const sources = Array.from(
-     *   Graph.indices(Graph.externals(graph, { direction: "incoming" }))
-     * )
-     * console.log(sources) // [0, 3]
+     * Array.from(Graph.indices(Graph.externals(graph, { direction: "incoming" }))) // => [0, 3]
      * ```
      *
      * @category iterators