effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Graph.js

@@ -184,7 +184,7 @@ export const isGraph = u => hasProperty(u, TypeId);
  *
  * **Example** (Constructing by kind)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const makeGraph = Graph.make("directed")
@@ -192,7 +192,7 @@ export const isGraph = u => hasProperty(u, TypeId);
  *   Graph.addNode(mutable, "A")
  * })
  *
- * console.log(graph.type) // "directed"
+ * graph.type // => "directed"
  * ```
  *
  * @see {@link directed} for constructing a directed graph directly
@@ -223,7 +223,7 @@ export const make = type => mutate => {
  *
  * **Example** (Creating a directed graph)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Directed graph with initial nodes and edges
@@ -234,6 +234,7 @@ export const make = type => mutate => {
  *   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
@@ -245,7 +246,7 @@ export const directed = /*#__PURE__*/make("directed");
  *
  * **Example** (Creating an undirected graph)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Undirected graph with initial nodes and edges
@@ -256,6 +257,7 @@ export const directed = /*#__PURE__*/make("directed");
  *   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
@@ -270,12 +272,13 @@ export const undirected = /*#__PURE__*/make("undirected");
  *
  * **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
@@ -307,13 +310,13 @@ export const beginMutation = graph => {
  *
  * **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
@@ -350,7 +353,7 @@ const mutateScoped = (mutable, f) => {
  *
  * **Example** (Applying scoped mutations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>()
@@ -360,8 +363,8 @@ const mutateScoped = (mutable, f) => {
  *   Graph.addEdge(mutable, nodeA, nodeB, 1)
  * })
  *
- * console.log(Graph.nodeCount(newGraph)) // 2
- * console.log(Graph.edgeCount(newGraph)) // 1
+ * Graph.nodeCount(newGraph) // => 2
+ * Graph.edgeCount(newGraph) // => 1
  * ```
  *
  * @category mutations
@@ -470,7 +473,7 @@ const assertSameKind = (self, that) => {
  *
  * **Example** (Combining graphs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const left = Graph.directed<{ id: string }, string>((mutable) => {
@@ -489,8 +492,8 @@ const assertSameKind = (self, that) => {
  *   nodeIdentity: (node) => node.id
  * })
  *
- * console.log(Graph.nodeCount(result)) // 3
- * console.log(Graph.edgeCount(result)) // 2
+ * Graph.nodeCount(result) // => 3
+ * Graph.edgeCount(result) // => 2
  * ```
  *
  * @category set operations
@@ -540,7 +543,7 @@ export const compose = /*#__PURE__*/dual(args => isGraph(args[0]) && isGraph(arg
  *
  * **Example** (Finding shared structure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const left = Graph.directed<string, string>((mutable) => {
@@ -557,8 +560,8 @@ export const compose = /*#__PURE__*/dual(args => isGraph(args[0]) && isGraph(arg
  *
  * const result = Graph.intersection(left, right)
  *
- * console.log(Graph.nodeCount(result)) // 2
- * console.log(Graph.edgeCount(result)) // 1
+ * Graph.nodeCount(result) // => 2
+ * Graph.edgeCount(result) // => 1
  * ```
  *
  * @category set operations
@@ -617,7 +620,7 @@ export const intersection = /*#__PURE__*/dual(args => isGraph(args[0]) && isGrap
  *
  * **Example** (Removing shared edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const left = Graph.directed<string, string>((mutable) => {
@@ -636,8 +639,8 @@ export const intersection = /*#__PURE__*/dual(args => isGraph(args[0]) && isGrap
  *
  * const result = Graph.difference(left, right)
  *
- * console.log(Graph.nodeCount(result)) // 3
- * console.log(Graph.edgeCount(result)) // 1
+ * Graph.nodeCount(result) // => 3
+ * Graph.edgeCount(result) // => 1
  * ```
  *
  * @category set operations
@@ -686,7 +689,7 @@ export const difference = /*#__PURE__*/dual(args => isGraph(args[0]) && isGraph(
  *
  * **Example** (Finding differing edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const left = Graph.directed<string, string>((mutable) => {
@@ -707,8 +710,8 @@ export const difference = /*#__PURE__*/dual(args => isGraph(args[0]) && isGraph(
  *
  * const result = Graph.symmetricDifference(left, right)
  *
- * console.log(Graph.nodeCount(result)) // 4
- * console.log(Graph.edgeCount(result)) // 2
+ * Graph.nodeCount(result) // => 4
+ * Graph.edgeCount(result) // => 2
  * ```
  *
  * @category set operations
@@ -756,7 +759,7 @@ export const symmetricDifference = /*#__PURE__*/dual(args => isGraph(args[0]) &&
  *
  * **Example** (Finding missing relationships)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -767,7 +770,7 @@ export const symmetricDifference = /*#__PURE__*/dual(args => isGraph(args[0]) &&
  *
  * const result = Graph.complement(graph, (source, target) => `${source}-${target}`)
  *
- * console.log(Graph.edgeCount(result)) // 1
+ * Graph.edgeCount(result) // => 1
  * ```
  *
  * @category set operations
@@ -811,7 +814,7 @@ export const complement = /*#__PURE__*/dual(2, (self, createEdge) => {
  *
  * **Example** (Getting a local neighborhood)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -824,7 +827,7 @@ export const complement = /*#__PURE__*/dual(2, (self, createEdge) => {
  *
  * const result = Graph.neighborhood(graph, 1, { radius: 1 })
  *
- * console.log(Graph.nodeCount(result)) // 2
+ * Graph.nodeCount(result) // => 2
  * ```
  *
  * @category set operations
@@ -916,14 +919,12 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **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
  * })
  * ```
  *
@@ -952,19 +953,14 @@ export const addNode = (mutable, data) => {
  *
  * **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
@@ -979,20 +975,15 @@ export const getNode = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
  *
  * **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
@@ -1004,11 +995,11 @@ export const hasNode = /*#__PURE__*/dual(2, (graph, nodeIndex) => graphImpl(grap
  *
  * **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")
@@ -1016,7 +1007,7 @@ export const hasNode = /*#__PURE__*/dual(2, (graph, nodeIndex) => graphImpl(grap
  *   Graph.addNode(mutable, "Node C")
  * })
  *
- * console.log(Graph.nodeCount(graphWithNodes)) // 3
+ * Graph.nodeCount(graphWithNodes) // => 3
  * ```
  *
  * @category getters
@@ -1028,8 +1019,8 @@ export const nodeCount = graph => graphImpl(graph).nodes.size;
  *
  * **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")
@@ -1037,11 +1028,8 @@ export const nodeCount = graph => graphImpl(graph).nodes.size;
  *   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
@@ -1061,7 +1049,7 @@ export const findNode = /*#__PURE__*/dual(2, (graph, predicate) => {
  *
  * **Example** (Finding matching nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1070,11 +1058,8 @@ export const findNode = /*#__PURE__*/dual(2, (graph, predicate) => {
  *   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
@@ -1095,8 +1080,8 @@ export const findNodes = /*#__PURE__*/dual(2, (graph, predicate) => {
  *
  * **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")
@@ -1106,11 +1091,8 @@ export const findNodes = /*#__PURE__*/dual(2, (graph, predicate) => {
  *   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
@@ -1130,7 +1112,7 @@ export const findEdge = /*#__PURE__*/dual(2, (graph, predicate) => {
  *
  * **Example** (Finding matching edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1142,11 +1124,8 @@ export const findEdge = /*#__PURE__*/dual(2, (graph, predicate) => {
  *   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
@@ -1167,8 +1146,8 @@ export const findEdges = /*#__PURE__*/dual(2, (graph, predicate) => {
  *
  * **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")
@@ -1176,8 +1155,7 @@ export const findEdges = /*#__PURE__*/dual(2, (graph, predicate) => {
  *   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
@@ -1198,8 +1176,8 @@ export const updateNode = (mutable, index, f) => {
  *
  * **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")
@@ -1208,8 +1186,7 @@ export const updateNode = (mutable, index, f) => {
  *   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
@@ -1238,8 +1215,8 @@ export const updateEdge = (mutable, edgeIndex, f) => {
  *
  * **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")
@@ -1248,8 +1225,7 @@ export const updateEdge = (mutable, edgeIndex, f) => {
  *   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
@@ -1269,8 +1245,8 @@ export const mapNodes = (mutable, f) => {
  *
  * **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")
@@ -1281,8 +1257,7 @@ export const mapNodes = (mutable, f) => {
  *   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
@@ -1324,8 +1299,8 @@ const rebuildAdjacency = mutable => {
  *
  * **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")
@@ -1336,8 +1311,7 @@ const rebuildAdjacency = mutable => {
  *   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
@@ -1367,7 +1341,7 @@ export const reverse = mutable => {
  *
  * **Example** (Filtering and mapping nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1385,7 +1359,7 @@ export const reverse = mutable => {
  *   )
  * })
  *
- * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * Graph.nodeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1417,7 +1391,7 @@ export const filterMapNodes = (mutable, f) => {
  *
  * **Example** (Filtering and mapping edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph, Option } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1435,7 +1409,7 @@ export const filterMapNodes = (mutable, f) => {
  *   )
  * })
  *
- * console.log(Graph.edgeCount(graph)) // 2 (edges with weight 5 removed)
+ * Graph.edgeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1470,7 +1444,7 @@ export const filterMapEdges = (mutable, f) => {
  *
  * **Example** (Filtering nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1483,7 +1457,7 @@ export const filterMapEdges = (mutable, f) => {
  *   Graph.filterNodes(mutable, (data) => data === "active")
  * })
  *
- * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * Graph.nodeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1510,7 +1484,7 @@ export const filterNodes = (mutable, predicate) => {
  *
  * **Example** (Filtering edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -1526,7 +1500,7 @@ export const filterNodes = (mutable, predicate) => {
  *   Graph.filterEdges(mutable, (data) => data >= 10)
  * })
  *
- * console.log(Graph.edgeCount(graph)) // 2 (edge with weight 5 removed)
+ * Graph.edgeCount(graph) // => 2
  * ```
  *
  * @category transforming
@@ -1588,14 +1562,13 @@ const invalidateCycleFlagOnAddition = mutable => {
  *
  * **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
  * })
  * ```
  *
@@ -1657,7 +1630,7 @@ export const addEdge = (mutable, source, target, data) => {
  *
  * **Example** (Removing a node)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1668,6 +1641,7 @@ export const addEdge = (mutable, source, target, data) => {
  *   // Remove nodeA and all edges connected to it
  *   Graph.removeNode(mutable, nodeA)
  * })
+ * Array.of(Graph.nodeCount(result), Graph.edgeCount(result)) // => [1, 0]
  * ```
  *
  * @category mutations
@@ -1713,7 +1687,7 @@ export const removeNode = (mutable, nodeIndex) => {
  *
  * **Example** (Removing an edge)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const result = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1724,6 +1698,7 @@ export const removeNode = (mutable, nodeIndex) => {
  *   // Remove the edge
  *   Graph.removeEdge(mutable, edge)
  * })
+ * Array.of(Graph.nodeCount(result), Graph.edgeCount(result)) // => [2, 0]
  * ```
  *
  * @category mutations
@@ -1794,8 +1769,8 @@ const removeEdgeInternal = (mutable, edgeIndex) => {
  *
  * **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")
@@ -1803,14 +1778,7 @@ const removeEdgeInternal = (mutable, edgeIndex) => {
  *   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
@@ -1822,7 +1790,7 @@ export const getEdge = /*#__PURE__*/dual(2, (graph, edgeIndex) => Option.fromUnd
  *
  * **Example** (Checking edge existence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1832,15 +1800,8 @@ export const getEdge = /*#__PURE__*/dual(2, (graph, edgeIndex) => Option.fromUnd
  *   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
@@ -1869,11 +1830,11 @@ export const hasEdge = /*#__PURE__*/dual(3, (graph, source, target) => {
  *
  * **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")
@@ -1884,7 +1845,7 @@ export const hasEdge = /*#__PURE__*/dual(3, (graph, source, target) => {
  *   Graph.addEdge(mutable, nodeC, nodeA, 3)
  * })
  *
- * console.log(Graph.edgeCount(graphWithEdges)) // 3
+ * Graph.edgeCount(graphWithEdges) // => 3
  * ```
  *
  * @category getters
@@ -1917,7 +1878,7 @@ const getDirectedNeighbors = (graph, nodeIndex, direction) => {
  *
  * **Example** (Getting outgoing neighbors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -1928,15 +1889,8 @@ const getDirectedNeighbors = (graph, nodeIndex, direction) => {
  *   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
@@ -1964,7 +1918,7 @@ export const neighbors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
  * @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 const successors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
@@ -1990,7 +1944,7 @@ export const successors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
  * @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 const predecessors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
@@ -2015,7 +1969,7 @@ export const predecessors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
  *
  * **Example** (Traversing directed neighbors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -2032,12 +1986,13 @@ export const predecessors = /*#__PURE__*/dual(2, (graph, nodeIndex) => {
  *
  * // 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 const neighborsDirected = /*#__PURE__*/dual(3, (graph, nodeIndex, direction) => {
@@ -2054,7 +2009,7 @@ const escapeGraphVizString = value => value.replace(/\\/g, "\\\\").replace(/"/g,
  *
  * **Example** (Exporting GraphViz DOT)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
@@ -2066,16 +2021,7 @@ const escapeGraphVizString = value => value.replace(/\\/g, "\\\\").replace(/"/g,
  *   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
@@ -2153,7 +2099,7 @@ const formatMermaidNode = (nodeId, label, shape) => {
  *
  * **Example** (Exporting a directed Mermaid diagram)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Basic directed graph export
@@ -2165,19 +2111,12 @@ const formatMermaidNode = (nodeId, label, shape) => {
  *   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
@@ -2194,18 +2133,12 @@ const formatMermaidNode = (nodeId, label, shape) => {
  *   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
@@ -2244,20 +2177,12 @@ const formatMermaidNode = (nodeId, label, shape) => {
  *     }
  *   }
  * })
- * 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
@@ -2306,15 +2231,7 @@ const formatMermaidNode = (nodeId, label, shape) => {
  *   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
@@ -2372,7 +2289,7 @@ export const toMermaid = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, opt
  *
  * **Example** (Checking cycles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Acyclic directed graph (DAG)
@@ -2383,7 +2300,7 @@ export const toMermaid = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, opt
  *   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) => {
@@ -2392,7 +2309,7 @@ export const toMermaid = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, opt
  *   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
@@ -2513,7 +2430,7 @@ export const isAcyclic = graph => {
  *
  * **Example** (Checking bipartite graphs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * // Bipartite graph (alternating coloring possible)
@@ -2526,7 +2443,7 @@ export const isAcyclic = 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) => {
@@ -2537,7 +2454,7 @@ export const isAcyclic = 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
@@ -2626,7 +2543,7 @@ const getTraversableNeighbor = (graph, current, edge) => graph.type === "undirec
  *
  * **Example** (Finding connected components)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.undirected<string, string>((mutable) => {
@@ -2638,8 +2555,7 @@ const getTraversableNeighbor = (graph, current, edge) => graph.type === "undirec
  *   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
@@ -2683,7 +2599,7 @@ export const connectedComponents = graph => {
  *
  * **Example** (Finding strongly connected components)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, string>((mutable) => {
@@ -2695,8 +2611,7 @@ export const connectedComponents = graph => {
  *   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
@@ -2827,8 +2742,8 @@ const minHeapPop = heap => {
  *
  * **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")
@@ -2845,10 +2760,7 @@ const minHeapPop = heap => {
  *   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
@@ -2980,7 +2892,7 @@ export const dijkstra = /*#__PURE__*/dual(2, (graph, config) => {
  *
  * **Example** (Finding all-pairs shortest paths)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -2993,8 +2905,8 @@ export const dijkstra = /*#__PURE__*/dual(2, (graph, config) => {
  * })
  *
  * 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
@@ -3122,8 +3034,8 @@ export const floydWarshall = /*#__PURE__*/dual(2, (graph, cost) => {
  *
  * **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 })
@@ -3146,10 +3058,7 @@ export const floydWarshall = /*#__PURE__*/dual(2, (graph, cost) => {
  *   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
@@ -3304,8 +3213,8 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
  *
  * **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")
@@ -3322,10 +3231,7 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
  *   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
@@ -3453,7 +3359,7 @@ export const bellmanFord = /*#__PURE__*/dual(2, (graph, config) => {
  *
  * **Example** (Working with node walkers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3472,8 +3378,8 @@ export const bellmanFord = /*#__PURE__*/dual(2, (graph, config) => {
  * }
  *
  * // 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
@@ -3493,7 +3399,7 @@ export class Walker {
    *
    * **Example** (Visiting walker elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Graph } from "effect"
    *
    * const graph = Graph.directed<string, number>((mutable) => {
@@ -3505,14 +3411,10 @@ export class Walker {
    * 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
@@ -3528,7 +3430,7 @@ export class Walker {
    *
    * **Example** (Visiting walker elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Graph } from "effect"
    *
    * const graph = Graph.directed<string, number>((mutable) => {
@@ -3540,14 +3442,10 @@ export class Walker {
    * 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
@@ -3563,7 +3461,7 @@ export class Walker {
  *
  * **Example** (Iterating walker indices)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3573,8 +3471,7 @@ export class Walker {
  * })
  *
  * 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
@@ -3586,7 +3483,7 @@ export const indices = walker => walker.visit((index, _) => index);
  *
  * **Example** (Iterating walker values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3596,8 +3493,7 @@ export const indices = walker => walker.visit((index, _) => index);
  * })
  *
  * 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
@@ -3609,7 +3505,7 @@ export const values = walker => walker.visit((_, data) => data);
  *
  * **Example** (Iterating walker entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3619,8 +3515,7 @@ export const values = walker => walker.visit((_, data) => data);
  * })
  *
  * 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
@@ -3640,7 +3535,7 @@ export const entries = walker => walker.visit((index, data) => [index, data]);
  *
  * **Example** (Traversing depth-first)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3652,14 +3547,10 @@ export const entries = walker => walker.visit((index, data) => [index, data]);
  * })
  *
  * // 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,7 +3652,7 @@ export const dfs = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  *
  * **Example** (Traversing breadth-first)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3773,14 +3664,10 @@ export const dfs = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  * })
  *
  * // 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
@@ -3844,7 +3731,7 @@ export const bfs = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  *
  * **Example** (Sorting topologically)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -3856,13 +3743,10 @@ export const bfs = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  * })
  *
  * // 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) => {
@@ -3872,9 +3756,7 @@ export const bfs = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  *   Graph.addEdge(mutable, b, a, 2) // Creates cycle
  * })
  *
- * if (!Graph.isAcyclic(cyclicGraph)) {
- *   console.log("cyclic graph") // cyclic graph
- * }
+ * Graph.isAcyclic(cyclicGraph) // => false
  * ```
  *
  * @category iterators
@@ -3992,7 +3874,7 @@ export const topo = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  *
  * **Example** (Traversing in postorder)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4004,10 +3886,7 @@ export const topo = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, config =
  * })
  *
  * // 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
@@ -4095,7 +3974,7 @@ export const dfsPostOrder = /*#__PURE__*/dual(args => isGraph(args[0]), (graph,
  *
  * **Example** (Iterating all nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4105,8 +3984,7 @@ export const dfsPostOrder = /*#__PURE__*/dual(args => isGraph(args[0]), (graph,
  *   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
@@ -4144,7 +4022,7 @@ export const nodes = graph => new Walker(f => ({
  *
  * **Example** (Iterating all edges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4155,8 +4033,7 @@ export const nodes = graph => new Walker(f => ({
  *   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
@@ -4195,7 +4072,7 @@ export const edges = graph => new Walker(f => ({
  *
  * **Example** (Iterating external nodes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Graph } from "effect"
  *
  * const graph = Graph.directed<string, number>((mutable) => {
@@ -4209,16 +4086,10 @@ export const edges = graph => new Walker(f => ({
  * })
  *
  * // 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