@livestore/utils 0.4.0-dev.9 → 0.5.0-dev.0

package/src/{effect → browser}/WebLock.ts

@@ -1,5 +1,4 @@
-import type { Exit } from 'effect'
-import { Deferred, Effect, Runtime } from 'effect'
+import { Deferred, Effect, type Exit } from 'effect'
 
 // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
 export const withLock =
@@ -14,27 +13,27 @@ export const withLock =
   }) =>
   <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A, E | E2, Ctx> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime<Ctx>()
+      const services = yield* Effect.context<Ctx>()
 
       const exit = yield* Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
         try: (signal) => {
-          if (signal.aborted) return 'aborted' as never
+          if (signal.aborted === true) return 'aborted' as never
 
           // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
           const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
-          return navigator.locks.request(lockName, requestOptions, async (lock) => {
+          return navigator.locks.request(lockName, requestOptions, async (lock: Lock | null) => {
             if (lock === null) {
-              if (onTaken) {
-                const exit = await Runtime.runPromiseExit(runtime)(onTaken)
-                if (exit._tag === 'Failure') {
-                  return exit
+              if (onTaken !== undefined) {
+                const onTakenExit = await Effect.runPromiseExitWith(services)(onTaken)
+                if (onTakenExit._tag === 'Failure') {
+                  return onTakenExit
                 }
               }
               return
             }
 
             // TODO also propagate Effect interruption to the execution
-            return Runtime.runPromiseExit(runtime)(eff)
+            return Effect.runPromiseExitWith(services)(eff)
           }) as unknown as Promise<Exit.Exit<A, E>>
         },
         catch: (err) => err as any as E,
@@ -48,11 +47,11 @@ export const withLock =
     })
 
 export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<void>((cb, signal) => {
-    if (signal.aborted) return
+  Effect.callback<void>((cb, signal) => {
+    if (signal.aborted === true) return
 
     navigator.locks
-      .request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, (_lock) => {
+      .request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, (_lock: Lock | null) => {
         // immediately continuing calling Effect since we have the lock
         cb(Effect.void)
 
@@ -71,8 +70,8 @@ export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName:
   })
 
 export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb, signal) => {
-    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock) => {
+  Effect.callback<boolean>((cb, signal) => {
+    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock: Lock | null) => {
       cb(Effect.succeed(lock !== null))
 
       // the code below is still running
@@ -95,8 +94,8 @@ export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName:
   })
 
 export const stealDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb, signal) => {
-    navigator.locks.request(lockName, { mode: 'exclusive', steal: true }, (lock) => {
+  Effect.callback<boolean>((cb, signal) => {
+    navigator.locks.request(lockName, { mode: 'exclusive', steal: true }, (lock: Lock | null) => {
       cb(Effect.succeed(lock !== null))
 
       // the code below is still running
@@ -116,24 +115,24 @@ export const stealDeferredLock = (deferred: Deferred.Deferred<void>, lockName: s
   })
 
 export const waitForLock = (lockName: string) =>
-  Effect.async<void>((cb, signal) => {
-    if (signal.aborted) return
+  Effect.callback<void>((cb, signal) => {
+    if (signal.aborted === true) return
 
-    navigator.locks.request(lockName, { mode: 'shared', signal, ifAvailable: false }, (_lock) => {
-      cb(Effect.succeed(void 0))
+    navigator.locks.request(lockName, { mode: 'shared', signal, ifAvailable: false }, (_lock: Lock | null) => {
+      cb(Effect.void)
     })
   })
 
 /** Attempts to get the lock if available and waits for it to be stolen */
 export const getLockAndWaitForSteal = (lockName: string) =>
-  Effect.async<void>((cb, signal) => {
-    if (signal.aborted) return
+  Effect.callback<void>((cb, signal) => {
+    if (signal.aborted === true) return
 
     navigator.locks
-      .request(lockName, { mode: 'exclusive', ifAvailable: true }, async (lock) => {
+      .request(lockName, { mode: 'exclusive', ifAvailable: true }, async (lock: Lock | null) => {
         if (lock === null) {
           // Lock wasn't available, resolve immediately
-          cb(Effect.succeed(void 0))
+          cb(Effect.void)
           return
         }
 
@@ -148,10 +147,10 @@ export const getLockAndWaitForSteal = (lockName: string) =>
             resolve()
           })
 
-          return Promise.race([holdLock, signal.aborted ? Promise.resolve() : holdLock]).catch(() => {})
+          return Promise.race([holdLock, signal.aborted === true ? Promise.resolve() : holdLock]).catch(() => {})
         }).catch(() => {})
 
-        cb(Effect.succeed(void 0))
+        cb(Effect.void)
       })
       .catch((error) => {
         if (
@@ -161,7 +160,7 @@ export const getLockAndWaitForSteal = (lockName: string) =>
         ) {
           // Given signal interruption is handled via Effect, we can ignore this case
           // or the case when the lock is stolen
-          cb(Effect.succeed(void 0))
+          cb(Effect.void)
         } else {
           console.error('[@livestore/utils:WebLock] getLockAndWaitForSteal. error', error)
           throw error

package/src/{browser.ts → browser/detect.ts}

@@ -1,7 +1,7 @@
 export type DetectedBrowser = 'Something' | 'Opera' | 'Chrome' | 'Safari' | 'Firefox' | 'Edge' | 'Browser'
 
 export const detectBrowserName: () => DetectedBrowser = () => {
-  if (!navigator.userAgent) {
+  if (navigator.userAgent == null) {
     return 'Something'
   }
 
@@ -13,19 +13,19 @@ export const detectBrowserName: () => DetectedBrowser = () => {
 
   // TODO: also parse out version
 
-  if (isOpera) {
+  if (isOpera === true) {
     return 'Opera'
   }
-  if (isChrome) {
+  if (isChrome === true) {
     return 'Chrome'
   }
-  if (isSafari) {
+  if (isSafari === true) {
     return 'Safari'
   }
-  if (isFirefox) {
+  if (isFirefox === true) {
     return 'Firefox'
   }
-  if (isEdge) {
+  if (isEdge === true) {
     return 'Edge'
   }
   return 'Browser'

package/src/browser/mod.ts

@@ -0,0 +1,8 @@
+import '../global.ts'
+
+export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export * as WebSocket from '../effect/WebSocket.ts'
+export * as Opfs from './Opfs/mod.ts'
+export * as WebChannelBrowser from './WebChannelBrowser.ts'
+export * as WebError from './WebError.ts'
+export * as WebLock from './WebLock.ts'

package/src/cuid/cuid.browser.ts

@@ -82,7 +82,7 @@ export const slug = () => {
 
 export const isCuid = (stringToCheck: string) => {
   if (typeof stringToCheck !== 'string') return false
-  if (stringToCheck.startsWith('c')) return true
+  if (stringToCheck.startsWith('c') === true) return true
   return false
 }
 

package/src/cuid/cuid.node.ts

@@ -90,7 +90,7 @@ export const slug = () => {
 
 export const isCuid = (stringToCheck: string) => {
   if (typeof stringToCheck !== 'string') return false
-  if (stringToCheck.startsWith('c')) return true
+  if (stringToCheck.startsWith('c') === true) return true
   return false
 }
 

package/src/effect/Debug.ts

@@ -0,0 +1,477 @@
+import { Cause, Context, Effect, type Exit, type Fiber, Graph, Option, Scope, Tracer } from 'effect'
+
+/**
+ * How to use:
+ * 1. Call `Debug.attachSlowDebugInstrumentation` in the root/main file of your program to ensure it is loaded as soon as possible.
+ * 2. Call `Debug.logDebug` to log the current state of the effect system.
+ */
+
+interface SpanEvent {
+  readonly name: string
+  readonly startTime: bigint
+  readonly attributes?: Record<string, unknown>
+}
+
+interface GraphNodeInfo {
+  readonly span: Tracer.AnySpan
+  readonly exitTag: 'Success' | 'Failure' | 'Interrupted' | undefined
+  readonly events: Array<SpanEvent>
+}
+
+export type MutableSpanGraph = Graph.MutableGraph<GraphNodeInfo, void>
+export type MutableSpanGraphInfo = {
+  readonly graph: MutableSpanGraph
+  readonly nodeIdBySpanId: Map<string, number>
+}
+
+const graphByTraceId = new Map<string, MutableSpanGraphInfo>()
+
+const ensureSpan = (traceId: string, spanId: string): [MutableSpanGraph, number] => {
+  let info = graphByTraceId.get(traceId)
+  if (info === undefined) {
+    info = {
+      graph: Graph.beginMutation(Graph.directed<GraphNodeInfo, void>()),
+      nodeIdBySpanId: new Map<string, number>(),
+    }
+    graphByTraceId.set(traceId, info)
+  }
+  let nodeId = info.nodeIdBySpanId.get(spanId)
+  if (nodeId === undefined) {
+    nodeId = Graph.addNode(info.graph, {
+      span: { _tag: 'ExternalSpan', spanId, traceId, sampled: false, annotations: Context.empty() },
+      events: [],
+      exitTag: undefined,
+    })
+    info.nodeIdBySpanId.set(spanId, nodeId)
+  }
+  return [info.graph, nodeId]
+}
+
+const sortSpan = (
+  prev: Tracer.AnySpan,
+  next: Tracer.AnySpan,
+): [info: Tracer.AnySpan, isUpgrade: boolean, timingUpdated: boolean] => {
+  if (prev._tag === 'ExternalSpan' && next._tag === 'Span') return [next, true, true]
+  if (prev._tag === 'Span' && next._tag === 'Span' && next.status._tag === 'Ended') return [next, false, true]
+  return [prev, false, false]
+}
+
+const addNode = (span: Tracer.AnySpan) => {
+  const [mutableGraph, nodeId] = ensureSpan(span.traceId, span.spanId)
+  Graph.updateNode(mutableGraph, nodeId, (previousInfo) => {
+    const [latestInfo, upgraded] = sortSpan(previousInfo.span, span)
+    if (upgraded === true && latestInfo._tag === 'Span' && Option.isSome(latestInfo.parent) === true) {
+      const parentNodeId = addNode(latestInfo.parent.value)
+      Graph.addEdge(mutableGraph, parentNodeId, nodeId, undefined)
+    }
+    return { ...previousInfo, span: latestInfo }
+  })
+  return nodeId
+}
+
+const addEvent = (traceId: string, spanId: string, event: SpanEvent) => {
+  const [mutableGraph, nodeId] = ensureSpan(traceId, spanId)
+  Graph.updateNode(mutableGraph, nodeId, (previousInfo) => {
+    return { ...previousInfo, events: [...previousInfo.events, event] }
+  })
+  return nodeId
+}
+const addNodeExit = (traceId: string, spanId: string, exit: Exit.Exit<any, any>) => {
+  const [mutableGraph, nodeId] = ensureSpan(traceId, spanId)
+  Graph.updateNode(mutableGraph, nodeId, (previousInfo) => {
+    const isInterruptedOnly = exit._tag === 'Failure' && Cause.hasInterruptsOnly(exit.cause)
+    return {
+      ...previousInfo,
+      exitTag: isInterruptedOnly === true ? ('Interrupted' as const) : exit._tag,
+    }
+  })
+  return nodeId
+}
+
+const createPropertyInterceptor = <T extends object, K extends keyof T>(
+  obj: T,
+  property: K,
+  interceptor: (value: T[K]) => void,
+): void => {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, property)
+
+  const previousSetter = descriptor?.set
+
+  let currentValue: T[K]
+  const previousGetter = descriptor?.get
+
+  if (previousGetter == null) {
+    currentValue = obj[property]
+  }
+
+  Object.defineProperty(obj, property, {
+    get(): T[K] {
+      if (previousGetter !== undefined) {
+        return previousGetter.call(obj)
+      }
+      return currentValue
+    },
+    set(value: T[K]) {
+      if (previousSetter !== undefined) {
+        previousSetter.call(obj, value)
+      } else {
+        currentValue = value
+      }
+      interceptor(value)
+    },
+    enumerable: descriptor?.enumerable ?? true,
+    configurable: descriptor?.configurable ?? true,
+  })
+}
+
+type EffectDevtoolsHookEvent =
+  | {
+      _tag: 'FiberAllocated'
+      fiber: Fiber.Fiber<any, any>
+    }
+  | {
+      _tag: 'ScopeAllocated'
+      scope: Scope.Scope
+    }
+
+type GlobalWithFiberCurrent = {
+  ['~effect/Fiber/currentFiber']: Fiber.Fiber<any, any> | undefined
+  'effect/DevtoolsHook'?: {
+    onEvent: (event: EffectDevtoolsHookEvent) => void
+  }
+}
+
+type MutableTracer = {
+  span: Tracer.Tracer['span']
+  context?: Tracer.Tracer['context']
+}
+
+type EvaluatablePrimitive<X> = Tracer.EffectPrimitive<X> & {
+  readonly ['~effect/Effect/evaluate']: (fiber: Fiber.Fiber<any, any>) => X
+}
+
+const patchedTracer = new WeakSet<Tracer.Tracer>()
+const ensureTracerPatched = (tracer: Tracer.Tracer) => {
+  if (patchedTracer.has(tracer) === true) {
+    return
+  }
+  patchedTracer.add(tracer)
+
+  // Effect v4 exposes the tracer context as readonly and caches it on fibers, so keep mutation localized here.
+  const mutableTracer = tracer as MutableTracer
+
+  const oldSpanConstructor: Tracer.Tracer['span'] = tracer.span
+  mutableTracer.span = function (this: Tracer.Tracer, options: Parameters<Tracer.Tracer['span']>[0]): Tracer.Span {
+    const span = oldSpanConstructor.call(this, options)
+    addNode(span)
+
+    const oldSpanEnd = span.end
+    span.end = function (this: Tracer.Span, endTime, exit) {
+      oldSpanEnd.call(this, endTime, exit)
+      addNodeExit(this.traceId, this.spanId, exit)
+    }
+
+    const oldSpanEvent = span.event
+    span.event = function (this: Tracer.Span, name, startTime, attributes) {
+      oldSpanEvent.call(this, name, startTime, attributes)
+      addEvent(this.traceId, this.spanId, { name, startTime, attributes: attributes ?? {} })
+    }
+
+    return span
+  }
+
+  const oldContext = tracer.context
+  mutableTracer.context = function <X>(
+    this: Tracer.Tracer,
+    primitive: Tracer.EffectPrimitive<X>,
+    fiber: Fiber.Fiber<any, any>,
+  ) {
+    ensureFiberPatched(fiber)
+    if (oldContext !== undefined) {
+      return oldContext(primitive, fiber)
+    }
+    return (primitive as EvaluatablePrimitive<X>)['~effect/Effect/evaluate'](fiber)
+  }
+}
+
+interface ScopeImpl extends Scope.Scope {
+  readonly state:
+    | {
+        readonly _tag: 'Open'
+        readonly finalizers: Map<{}, (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown>>
+      }
+    | {
+        readonly _tag: 'Closed'
+        readonly exit: Exit.Exit<unknown, unknown>
+      }
+}
+
+const knownScopes = new Map<
+  ScopeImpl,
+  { id: number; allocationFiber: Fiber.Fiber<any, any> | undefined; allocationSpan: Tracer.AnySpan | undefined }
+>()
+let lastScopeId = 0
+const ensureScopePatched = (scope: ScopeImpl, allocationFiber: Fiber.Fiber<any, any> | undefined) => {
+  if (scope.state._tag === 'Closed') return
+  if (knownScopes.has(scope) === true) return
+  const id = lastScopeId++
+  if (patchScopeClose === true) {
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- patching Scope.close; ScopeImpl is an internal interface not exported by Effect
+    const oldClose = (scope as any).close
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- patching Scope.close; ScopeImpl is an internal interface not exported by Effect
+    ;(scope as any).close = function (...args: any[]) {
+      return oldClose.apply(this, args).pipe(
+        Effect.withSpan(`scope.${id}.closeRunFinalizers`),
+        Effect.ensuring(
+          Effect.sync(() => {
+            knownScopes.delete(scope)
+          }),
+        ),
+      )
+    }
+  } else {
+    cleanupScopes()
+  }
+  const allocationSpan = allocationFiber?.currentSpan
+  knownScopes.set(scope, { id, allocationFiber, allocationSpan })
+}
+const cleanupScopes = () => {
+  for (const [scope] of knownScopes) {
+    if (scope.state._tag === 'Closed') knownScopes.delete(scope)
+  }
+}
+
+const knownFibers = new Set<Fiber.Fiber<any, any>>()
+const ensureFiberPatched = (fiber: Fiber.Fiber<any, any>) => {
+  // patch tracer
+  ensureTracerPatched(fiber.getRef(Tracer.Tracer))
+  // patch scope
+  const currentScope = Context.getOrElse(fiber.context, Scope.Scope, () => undefined)
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- casting Scope to ScopeImpl; internal Effect type not publicly exported
+  if (currentScope !== undefined) ensureScopePatched(currentScope as any as ScopeImpl, undefined)
+  // patch fiber
+  if (knownFibers.has(fiber) === true) return
+  knownFibers.add(fiber)
+  fiber.addObserver((exit) => {
+    knownFibers.delete(fiber)
+    onFiberCompleted?.(fiber, exit)
+  })
+}
+
+let patchScopeClose = false
+let onFiberResumed: undefined | ((fiber: Fiber.Fiber<any, any>) => void)
+let onFiberSuspended: undefined | ((fiber: Fiber.Fiber<any, any>) => void)
+let onFiberCompleted: undefined | ((fiber: Fiber.Fiber<any, any>, exit: Exit.Exit<any, any>) => void)
+export const attachSlowDebugInstrumentation = (options: {
+  /** If set to true, the scope prototype will be patched to attach a span to visualize pending scope closing */
+  readonly patchScopeClose?: boolean
+  /** An optional callback that will be called when any fiber resumes performing a run loop */
+  readonly onFiberResumed?: (fiber: Fiber.Fiber<any, any>) => void
+  /** An optional callback that will be called when any fiber stops performing a run loop */
+  readonly onFiberSuspended?: (fiber: Fiber.Fiber<any, any>) => void
+  /** An optional callback that will be called when any fiber completes with a exit */
+  readonly onFiberCompleted?: (fiber: Fiber.Fiber<any, any>, exit: Exit.Exit<any, any>) => void
+}): void => {
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- accessing Effect's global fiber tracking via well-known symbol keys
+  const _globalThis = globalThis as any as GlobalWithFiberCurrent
+  if (_globalThis['effect/DevtoolsHook'] !== undefined) {
+    return console.error(
+      'attachDebugInstrumentation has already been called! To show the tree, call attachDebugInstrumentation() in the root/main file of your program to ensure it is loaded as soon as possible.',
+    )
+  }
+  patchScopeClose = options.patchScopeClose ?? false
+  onFiberResumed = options.onFiberResumed
+  onFiberSuspended = options.onFiberSuspended
+  onFiberCompleted = options.onFiberCompleted
+  let lastFiber: undefined | Fiber.Fiber<any, any>
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- accessing Effect's global fiber tracking via well-known symbol keys
+  createPropertyInterceptor(globalThis as any as GlobalWithFiberCurrent, '~effect/Fiber/currentFiber', (value) => {
+    if (value !== undefined && knownFibers.has(value) === true) onFiberResumed?.(value)
+    if (value !== undefined) ensureFiberPatched(value)
+    if (value == null && lastFiber !== undefined && knownFibers.has(lastFiber) === true) onFiberSuspended?.(lastFiber)
+    lastFiber = value
+  })
+  _globalThis['effect/DevtoolsHook'] = {
+    onEvent: (event) => {
+      console.log('onEvent', event)
+      switch (event._tag) {
+        case 'ScopeAllocated':
+          // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- casting Scope to ScopeImpl; internal Effect type not publicly exported
+          ensureScopePatched(event.scope as any as ScopeImpl, _globalThis['~effect/Fiber/currentFiber'])
+          break
+        case 'FiberAllocated':
+          ensureFiberPatched(event.fiber)
+          break
+      }
+    },
+  }
+}
+
+const formatDuration = (startTime: bigint, endTime: bigint | undefined): string => {
+  if (endTime === undefined) return '[running]'
+  const durationMs = Number(endTime - startTime) / 1000000 // Convert nanoseconds to milliseconds
+  if (durationMs < 1000) return `${durationMs.toFixed(0)}ms`
+  if (durationMs < 60000) return `${(durationMs / 1000).toFixed(2)}s`
+  return `${(durationMs / 60000).toFixed(2)}m`
+}
+
+const getSpanName = (span: Tracer.AnySpan): string => {
+  if (span._tag === 'ExternalSpan') return `[external] ${span.spanId}`
+  return span.name
+}
+
+const getSpanStatus = (info: GraphNodeInfo): string => {
+  if (info.span._tag === 'ExternalSpan') return '?'
+  if (info.exitTag === 'Success') return '✓'
+  if (info.exitTag === 'Failure') return '✗'
+  if (info.exitTag === 'Interrupted') return '!'
+  return '⋮'
+}
+
+const getSpanDuration = (span: Tracer.AnySpan): string => {
+  if (span._tag === 'ExternalSpan') return ''
+  const endTime = span.status._tag === 'Ended' ? span.status.endTime : undefined
+  return formatDuration(span.status.startTime, endTime)
+}
+
+const filterGraphKeepAncestors = <N, E>(
+  graph: Graph.Graph<N, E, 'directed'>,
+  predicate: (nodeData: N, nodeId: number) => boolean,
+): Graph.Graph<N, E, 'directed'> => {
+  // Find all root nodes (nodes with no incoming edges)
+  const rootNodes = Array.from(Graph.indices(Graph.externals(graph, { direction: 'incoming' })))
+  const shouldInclude = new Set<number>()
+
+  // Use postorder DFS to evaluate children before parents
+  for (const nodeId of Graph.indices(Graph.dfsPostOrder(graph, { start: rootNodes, direction: 'outgoing' }))) {
+    const node = Graph.getNode(graph, nodeId)
+    if (Option.isNone(node) === true) continue
+
+    const matchesPredicate = predicate(node.value, nodeId)
+    if (matchesPredicate === true) {
+      shouldInclude.add(nodeId)
+    } else {
+      const children = Graph.neighborsDirected(graph, nodeId, 'outgoing')
+      const hasMatchingChildren = children.some((childId) => shouldInclude.has(childId))
+      if (hasMatchingChildren === true) shouldInclude.add(nodeId)
+    }
+  }
+
+  // Create a filtered copy of the graph
+  return Graph.mutate(graph, (mutable) => {
+    const nodeIds = Array.from(Graph.indices(Graph.nodes(mutable)))
+    for (const nodeId of nodeIds) {
+      if (shouldInclude.has(nodeId) === true) continue
+      Graph.removeNode(mutable, nodeId)
+    }
+  })
+}
+
+const renderSpanNode = (graph: Graph.Graph<GraphNodeInfo, void, 'directed'>, nodeId: number): string[] => {
+  const node = Graph.getNode(graph, nodeId)
+  if (Option.isNone(node) === true) return []
+  const info = node.value
+  const status = getSpanStatus(info)
+  const name = getSpanName(info.span)
+  const duration = getSpanDuration(info.span)
+  const durationStr = duration !== undefined ? ` ${duration}` : ''
+
+  const fiberIds = Array.from(knownFibers)
+    .filter(
+      (fiber) => fiber.currentSpan?.spanId === info.span.spanId && fiber.currentSpan?.traceId === info.span.traceId,
+    )
+    .map((fiber) => `#${fiber.id}`)
+    .join(', ')
+  const runningOnFibers = fiberIds.length > 0 ? ` [fibers ${fiberIds}]` : ''
+
+  return [` ${status} ${name}${durationStr}${runningOnFibers}`]
+}
+
+const renderTree = <N, E>(
+  graph: Graph.Graph<N, E, 'directed'>,
+  nodeIds: Array<number>,
+  renderNode: (graph: Graph.Graph<N, E, 'directed'>, nodeId: number) => string[],
+): string[] => {
+  let lines: string[] = []
+  for (let childIndex = 0; childIndex < nodeIds.length; childIndex++) {
+    const isLastChild = childIndex === nodeIds.length - 1
+    const childLines = renderNode(graph, nodeIds[childIndex]!).concat(
+      renderTree(graph, Graph.neighborsDirected(graph, nodeIds[childIndex]!, 'outgoing'), renderNode),
+    )
+    lines = [
+      ...lines,
+      ...childLines.map((l, lineIndex) => {
+        if (lineIndex === 0) {
+          return (isLastChild === true ? ' └─' : ' ├─') + l
+        }
+        return (isLastChild === true ? '  ' : ' │') + l
+      }),
+    ]
+  }
+
+  return lines
+}
+
+export interface LogDebugOptions {
+  readonly regex?: RegExp
+  readonly title?: string
+}
+
+export const logDebug = (options: LogDebugOptions = {}) => {
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- accessing Effect's global fiber tracking via well-known symbol keys
+  const _globalThis = globalThis as any as GlobalWithFiberCurrent
+  if (_globalThis['effect/DevtoolsHook'] == null) {
+    return console.error(
+      'attachDebugInstrumentation has not been called! To show the tree, call attachDebugInstrumentation() in the root/main file of your program to ensure it is loaded as soon as possible.',
+    )
+  }
+
+  let lines: Array<string> = [`----------------${options.title ?? ''}----------------`]
+
+  // fibers
+  lines = [...lines, 'Active Fibers:']
+  for (const fiber of knownFibers) {
+    lines = [...lines, `- #${fiber.id}`]
+  }
+  if (knownFibers.size === 0) {
+    lines = [...lines, '- No active effect fibers']
+  }
+  lines = [...lines, '']
+
+  // spans
+  for (const [traceId, info] of graphByTraceId) {
+    const graph = Graph.endMutation(info.graph)
+    const filteredGraph =
+      options.regex !== undefined
+        ? filterGraphKeepAncestors(graph, (nodeData, _nodeId) => {
+            const name = getSpanName(nodeData.span)
+            return options.regex!.test(name)
+          })
+        : graph
+    const filteredRootNodes = Array.from(Graph.indices(Graph.externals(filteredGraph, { direction: 'incoming' })))
+
+    lines = [...lines, `Spans Trace ${traceId}:`, ...renderTree(filteredGraph, filteredRootNodes, renderSpanNode)]
+  }
+  lines = [...lines, '? external span - ✓ success - ✗ failure - ! interrupted', '']
+
+  // scopes
+  lines = [...lines, 'Open Scopes:']
+  for (const [scope, info] of knownScopes) {
+    const fiberIds = Array.from(knownFibers)
+      .filter((fiber) => Context.getOrElse(fiber.context, Scope.Scope, () => undefined) === scope)
+      .map((fiber) => `#${fiber.id}`)
+      .join(', ')
+    const usedByFibers = fiberIds.length > 0 ? ` [used by: ${fiberIds}]` : ''
+    const allocationFiber =
+      info.allocationFiber !== undefined ? ` [allocated in fiber #${info.allocationFiber.id}]` : ''
+    const allocationSpan =
+      info.allocationSpan !== undefined ? ` [allocated in span: ${getSpanName(info.allocationSpan)}]` : ''
+    lines = [...lines, `- #${info.id}${usedByFibers}${allocationFiber}${allocationSpan}`]
+  }
+  if (knownScopes.size === 0) {
+    lines = [...lines, '- No active scopes']
+  }
+  lines = [...lines, '']
+
+  console.log(lines.join('\n'))
+}