effect-start 0.30.1 → 0.32.0

package/src/bun/BunServer.ts

@@ -50,6 +50,7 @@ export type BunServer = {
   readonly server: Bun.Server<WebSocketContext>
   readonly pushHandler: (fetch: FetchHandler) => void
   readonly popHandler: () => void
+  readonly setRoutes: (tree: RouteTree.RouteTree) => Effect.Effect<void>
 }
 
 export const BunServer = Context.GenericTag<BunServer>("effect-start/BunServer")
@@ -77,6 +78,9 @@ export const make = (
       },
     ]
 
+    const setRoutesDeferred =
+      yield* Deferred.make<(tree: RouteTree.RouteTree) => Effect.Effect<void>>()
+
     const service = BunServer.of({
       // During the construction we need to create a service imlpementation
       // first so we can provide it in the runtime that will be used in web
@@ -93,6 +97,11 @@ export const make = (
         handlerStack.pop()
         reload()
       },
+      setRoutes(tree) {
+        return Deferred.await(setRoutesDeferred).pipe(
+          Effect.flatMap((applyRoutes) => applyRoutes(tree)),
+        )
+      },
     })
 
     const runtime = yield* Effect.runtime().pipe(
@@ -150,6 +159,18 @@ export const make = (
       })
     }
 
+    yield* Deferred.succeed(setRoutesDeferred, (tree) =>
+      walkBunRoutes(runtime, tree).pipe(
+        Effect.tap((bunRoutes) =>
+          Effect.sync(() => {
+            currentRoutes = bunRoutes
+            reload()
+          }),
+        ),
+        Effect.asVoid,
+      ),
+    )
+
     const bunServer = BunServer.of({
       server,
       pushHandler(fetch) {
@@ -160,6 +181,11 @@ export const make = (
         handlerStack.pop()
         reload()
       },
+      setRoutes(tree) {
+        return Deferred.await(setRoutesDeferred).pipe(
+          Effect.flatMap((applyRoutes) => applyRoutes(tree)),
+        )
+      },
     })
 
     return bunServer
@@ -185,6 +211,7 @@ export const layerRoutes = (
 /**
  * Resolves the Bun server in one place for Start.serve so routes are available:
  * 1) Reuse a user-provided BunServer when one already exists in context.
+ *    If Route.Routes are available, upgrade the existing server with them.
  * 2) Otherwise create the server from Route.Routes when routes are available.
  * 3) Otherwise create a fallback server with the default 404 handler.
  */
@@ -195,18 +222,17 @@ export const layerStart = (
     BunServer,
     Effect.gen(function* () {
       const app = yield* StartApp.StartApp
+      const routes = yield* Effect.serviceOption(Route.Routes)
+      const routeTree = Option.getOrNull(routes)
       const existing = yield* Effect.serviceOption(BunServer)
       if (Option.isSome(existing)) {
+        if (routeTree !== null) {
+          yield* existing.value.setRoutes(routeTree)
+        }
         yield* Deferred.succeed(app.server, existing.value)
         return existing.value
       }
-      const routes = yield* Effect.serviceOption(Route.Routes)
-      if (Option.isSome(routes)) {
-        const server = yield* make(options ?? {}, routes.value)
-        yield* Deferred.succeed(app.server, server)
-        return server
-      }
-      const server = yield* make(options ?? {})
+      const server = yield* make(options ?? {}, routeTree ?? undefined)
       yield* Deferred.succeed(app.server, server)
       return server
     }),

package/src/studio/Studio.ts

@@ -10,16 +10,17 @@ import * as StudioMetrics from "./StudioMetrics.ts"
 import * as StudioProcess from "./StudioProcess.ts"
 import * as StudioStore from "./StudioStore.ts"
 import * as StudioTracer from "./StudioTracer.ts"
-import consoleRoutes from "./routes/tree.ts"
+import routes from "./routes/tree.ts"
 
 export function layer(
   options?: StudioStore.StudioStoreOptions & {
     readonly sqlLayer?: Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError>
   },
-): Layer.Layer<StudioStore.StudioStore> {
+): Layer.Layer<StudioStore.StudioStore | SqlClient.SqlClient> {
   const sqlLayer =
     options?.sqlLayer ?? sqlBun.layer({ adapter: "sqlite" as const, filename: ":memory:" })
-  const store = StudioStore.layer(options).pipe(Layer.provide(sqlLayer), Layer.orDie)
+  const providedSqlLayer = sqlLayer.pipe(Layer.orDie)
+  const store = StudioStore.layer(options).pipe(Layer.provide(providedSqlLayer), Layer.orDie)
   const features = Layer.mergeAll(
     StudioTracer.layer,
     StudioLogger.layer,
@@ -27,7 +28,7 @@ export function layer(
     StudioErrors.layer,
     StudioProcess.layer,
   ).pipe(Layer.provide(store))
-  return Layer.merge(store, features)
+  return Layer.mergeAll(providedSqlLayer, store, features)
 }
 
 export function layerRoutes(options?: { prefix?: string }) {
@@ -39,7 +40,7 @@ export function layerRoutes(options?: { prefix?: string }) {
       const existing = yield* Route.Routes
       StudioStore.store.prefix = prefix
       const tree = Route.tree({
-        [prefix as "/"]: consoleRoutes,
+        [prefix as "/"]: routes,
       })
       return RouteTree.merge(existing, tree)
     }),

package/src/studio/StudioErrors.ts

@@ -185,7 +185,6 @@ function make(store: StudioStore.StudioStoreShape): Supervisor.Supervisor<void>
 
       StudioStore.runWrite(
         StudioStore.upsertFiber(
-          store.sql,
           childId,
           parentId !== childId ? parentId : undefined,
           span?._tag === "Span" ? span.name : undefined,
@@ -206,8 +205,8 @@ function make(store: StudioStore.StudioStoreShape): Supervisor.Supervisor<void>
         }
         StudioStore.runWrite(
           Effect.zipRight(
-            StudioStore.insertError(store.sql, error),
-            StudioStore.evict(store.sql, "Error", store.errorCapacity),
+            StudioStore.insertError(error),
+            StudioStore.evict("Error", store.errorCapacity),
           ),
         )
         Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))

package/src/studio/StudioLogger.ts

@@ -9,7 +9,6 @@ import * as StudioStore from "./StudioStore.ts"
 
 const studioLogger = Logger.make((options) => {
   const store = StudioStore.store
-  if (!store.sql) return
 
   try {
     const levelMap: Record<string, StudioStore.StudioLog["level"]> = {
@@ -41,8 +40,8 @@ const studioLogger = Logger.make((options) => {
     }
     StudioStore.runWrite(
       Effect.zipRight(
-        StudioStore.insertLog(store.sql, log),
-        StudioStore.evict(store.sql, "Log", store.logCapacity),
+        StudioStore.insertLog(log),
+        StudioStore.evict("Log", store.logCapacity),
       ),
     )
     Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))

package/src/studio/StudioStore.ts

@@ -114,6 +114,8 @@ export interface StudioMetricSnapshot {
 export type StudioEvent =
   | { readonly _tag: "SpanStart"; readonly span: StudioSpan }
   | { readonly _tag: "SpanEnd"; readonly span: StudioSpan }
+  | { readonly _tag: "TraceStart"; readonly traceId: bigint }
+  | { readonly _tag: "TraceEnd"; readonly traceId: bigint }
   | { readonly _tag: "Log"; readonly log: StudioLog }
   | { readonly _tag: "Error"; readonly error: StudioError }
   | { readonly _tag: "MetricsSnapshot"; readonly metrics: Array<StudioMetricSnapshot> }
@@ -327,179 +329,221 @@ function deserializeError(row: ErrorRow): StudioError {
   }
 }
 
-export function insertSpan(sql: SqlClient.SqlClient, span: StudioSpan) {
-  return sql`INSERT INTO Span ${sql({
-    spanId: span.spanId,
-    traceId: span.traceId,
-    fiberId: span.fiberId ?? null,
-    name: span.name,
-    kind: span.kind,
-    parentSpanId: span.parentSpanId ?? null,
-    startTime: span.startTime.toString(),
-    endTime: span.endTime?.toString() ?? null,
-    durationMs: span.durationMs ?? null,
-    status: span.status,
-    attributes: JSON.stringify(span.attributes),
-    events: JSON.stringify(serializeBigint(span.events)),
-  })}`
-}
-
-export function updateSpan(sql: SqlClient.SqlClient, span: StudioSpan) {
-  return sql`UPDATE Span SET
-    endTime = ${span.endTime?.toString() ?? null},
-    durationMs = ${span.durationMs ?? null},
-    status = ${span.status},
-    attributes = ${JSON.stringify(span.attributes)},
-    events = ${JSON.stringify(serializeBigint(span.events))}
-    WHERE spanId = ${span.spanId}`
-}
-
-export function insertLog(sql: SqlClient.SqlClient, log: StudioLog) {
-  return sql`INSERT INTO Log ${sql({
-    id: log.id,
-    level: log.level,
-    message: log.message,
-    fiberId: log.fiberId,
-    cause: log.cause ?? null,
-    spans: JSON.stringify(log.spans),
-    annotations: JSON.stringify(log.annotations),
-  })}`
-}
-
-export function insertError(sql: SqlClient.SqlClient, error: StudioError) {
-  return sql`INSERT INTO Error ${sql({
-    id: error.id,
-    fiberId: error.fiberId,
-    interrupted: error.interrupted ? 1 : 0,
-    prettyPrint: error.prettyPrint,
-    details: JSON.stringify(error.details),
-  })}`
+const withSql = <A, E>(
+  f: (sql: SqlClient.SqlClient) => Effect.Effect<A, E>,
+): Effect.Effect<A, E, SqlClient.SqlClient> => Effect.flatMap(SqlClient.SqlClient, f)
+
+export function insertSpan(span: StudioSpan) {
+  return withSql((sql) =>
+    sql`INSERT INTO Span ${sql({
+      spanId: span.spanId,
+      traceId: span.traceId,
+      fiberId: span.fiberId ?? null,
+      name: span.name,
+      kind: span.kind,
+      parentSpanId: span.parentSpanId ?? null,
+      startTime: span.startTime.toString(),
+      endTime: span.endTime?.toString() ?? null,
+      durationMs: span.durationMs ?? null,
+      status: span.status,
+      attributes: JSON.stringify(span.attributes),
+      events: JSON.stringify(serializeBigint(span.events)),
+    })}`,
+  )
+}
+
+export function updateSpan(span: StudioSpan) {
+  return withSql(
+    (sql) => sql`UPDATE Span SET
+      endTime = ${span.endTime?.toString() ?? null},
+      durationMs = ${span.durationMs ?? null},
+      status = ${span.status},
+      attributes = ${JSON.stringify(span.attributes)},
+      events = ${JSON.stringify(serializeBigint(span.events))}
+      WHERE spanId = ${span.spanId}`,
+  )
+}
+
+export function insertLog(log: StudioLog) {
+  return withSql((sql) =>
+    sql`INSERT INTO Log ${sql({
+      id: log.id,
+      level: log.level,
+      message: log.message,
+      fiberId: log.fiberId,
+      cause: log.cause ?? null,
+      spans: JSON.stringify(log.spans),
+      annotations: JSON.stringify(log.annotations),
+    })}`,
+  )
+}
+
+export function insertError(error: StudioError) {
+  return withSql((sql) =>
+    sql`INSERT INTO Error ${sql({
+      id: error.id,
+      fiberId: error.fiberId,
+      interrupted: error.interrupted ? 1 : 0,
+      prettyPrint: error.prettyPrint,
+      details: JSON.stringify(error.details),
+    })}`,
+  )
 }
 
 export function upsertFiber(
-  sql: SqlClient.SqlClient,
   id: string,
   parentId: string | undefined,
   spanName: string | undefined,
   traceId: bigint | undefined,
   annotations: Record<string, unknown>,
 ) {
-  return sql`INSERT OR REPLACE INTO Fiber ${sql({
-    id,
-    parentId: parentId ?? null,
-    spanName: spanName ?? null,
-    traceId: traceId ?? null,
-    annotations: JSON.stringify(annotations),
-  })}`
-}
-
-export function evict(sql: SqlClient.SqlClient, table: string, capacity: number) {
-  return Effect.gen(function* () {
-    const [{ cnt }] = yield* sql<{ cnt: number }>`SELECT count(*) as cnt FROM ${sql(table)}`
-    if (cnt > capacity) {
-      const excess = cnt - capacity
-      yield* sql`DELETE FROM ${sql(table)} WHERE rowid IN (SELECT rowid FROM ${sql(table)} ORDER BY rowid LIMIT ${excess})`
-    }
-  })
+  return withSql((sql) =>
+    sql`INSERT OR REPLACE INTO Fiber ${sql({
+      id,
+      parentId: parentId ?? null,
+      spanName: spanName ?? null,
+      traceId: traceId ?? null,
+      annotations: JSON.stringify(annotations),
+    })}`,
+  )
 }
 
-export function runWrite(effect: Effect.Effect<unknown, SqlClient.SqlError>) {
+export function evict(table: string, capacity: number) {
+  return withSql((sql) =>
+    Effect.gen(function* () {
+      const [{ cnt }] = yield* sql<{ cnt: number }>`SELECT count(*) as cnt FROM ${sql(table)}`
+      if (cnt > capacity) {
+        const excess = cnt - capacity
+        yield* sql`DELETE FROM ${sql(table)} WHERE rowid IN (SELECT rowid FROM ${sql(table)} ORDER BY rowid LIMIT ${excess})`
+      }
+    }),
+  )
+}
+
+export function runWrite(effect: Effect.Effect<unknown, SqlClient.SqlError, SqlClient.SqlClient>) {
+  const sql = store.sql
+  if (!sql) return
   writeQueue = writeQueue
-    .then(() => Effect.runPromise(Effect.withTracerEnabled(effect, false)).then(() => undefined))
+    .then(() =>
+      Effect.runPromise(
+        Effect.withTracerEnabled(
+          Effect.provideService(effect, SqlClient.SqlClient, sql),
+          false,
+        ),
+      ).then(() => undefined),
+    )
     .catch(() => undefined)
 }
 
 let writeQueue = Promise.resolve<void>(undefined)
 
-const noTrace = <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> =>
+const noTrace = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.withTracerEnabled(effect, false)
 
-export function allSpans(sql: SqlClient.SqlClient) {
+export function allSpans() {
   return noTrace(
-    Effect.map(sql<SpanRow>`SELECT * FROM Span ORDER BY rowid`, (rows) =>
-      rows.map(deserializeSpan),
+    withSql((sql) =>
+      Effect.map(sql<SpanRow>`SELECT * FROM Span ORDER BY rowid`, (rows) =>
+        rows.map(deserializeSpan),
+      ),
     ),
   )
 }
 
-export function allLogs(sql: SqlClient.SqlClient) {
+export function allLogs() {
   return noTrace(
-    Effect.map(sql<LogRow>`SELECT * FROM Log ORDER BY rowid`, (rows) => rows.map(deserializeLog)),
+    withSql((sql) =>
+      Effect.map(sql<LogRow>`SELECT * FROM Log ORDER BY rowid`, (rows) => rows.map(deserializeLog)),
+    ),
   )
 }
 
-export function allErrors(sql: SqlClient.SqlClient) {
+export function allErrors() {
   return noTrace(
-    Effect.map(sql<ErrorRow>`SELECT * FROM Error ORDER BY rowid`, (rows) =>
-      rows.map(deserializeError),
+    withSql((sql) =>
+      Effect.map(sql<ErrorRow>`SELECT * FROM Error ORDER BY rowid`, (rows) =>
+        rows.map(deserializeError),
+      ),
     ),
   )
 }
 
-export function spansByTraceId(sql: SqlClient.SqlClient, traceId: bigint) {
+export function spansByTraceId(traceId: bigint) {
   return noTrace(
-    Effect.map(sql<SpanRow>`SELECT * FROM Span WHERE traceId = ${traceId} ORDER BY rowid`, (rows) =>
-      rows.map(deserializeSpan),
+    withSql((sql) =>
+      Effect.map(sql<SpanRow>`SELECT * FROM Span WHERE traceId = ${traceId} ORDER BY rowid`, (rows) =>
+        rows.map(deserializeSpan),
+      ),
     ),
   )
 }
 
-export function spansByFiberId(sql: SqlClient.SqlClient, fiberId: string) {
+export function spansByFiberId(fiberId: string) {
   return noTrace(
-    Effect.map(sql<SpanRow>`SELECT * FROM Span WHERE fiberId = ${fiberId} ORDER BY rowid`, (rows) =>
-      rows.map(deserializeSpan),
+    withSql((sql) =>
+      Effect.map(sql<SpanRow>`SELECT * FROM Span WHERE fiberId = ${fiberId} ORDER BY rowid`, (rows) =>
+        rows.map(deserializeSpan),
+      ),
     ),
   )
 }
 
-export function logsByFiberId(sql: SqlClient.SqlClient, fiberId: string) {
+export function logsByFiberId(fiberId: string) {
   return noTrace(
-    Effect.map(sql<LogRow>`SELECT * FROM Log WHERE fiberId = ${fiberId} ORDER BY rowid`, (rows) =>
-      rows.map(deserializeLog),
+    withSql((sql) =>
+      Effect.map(sql<LogRow>`SELECT * FROM Log WHERE fiberId = ${fiberId} ORDER BY rowid`, (rows) =>
+        rows.map(deserializeLog),
+      ),
     ),
   )
 }
 
-export function getFiber(sql: SqlClient.SqlClient, fiberId: string) {
+export function getFiber(fiberId: string) {
   return noTrace(
-    Effect.map(sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${fiberId}`, (rows) =>
-      rows.length > 0 ? rows[0] : undefined,
+    withSql((sql) =>
+      Effect.map(sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${fiberId}`, (rows) =>
+        rows.length > 0 ? rows[0] : undefined,
+      ),
     ),
   )
 }
 
-export function getParentChain(sql: SqlClient.SqlClient, fiberId: string) {
+export function getParentChain(fiberId: string) {
   return noTrace(
-    Effect.gen(function* () {
-      const chain: Array<string> = []
-      const visited = new Set<string>()
-      let current = fiberId
-      while (true) {
-        const rows = yield* sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${current}`
-        if (rows.length === 0 || !rows[0].parentId) break
-        const parentId = rows[0].parentId
-        if (visited.has(parentId)) break
-        chain.push(parentId)
-        visited.add(parentId)
-        current = parentId
-      }
-      return chain.reverse()
-    }),
+    withSql((sql) =>
+      Effect.gen(function* () {
+        const chain: Array<string> = []
+        const visited = new Set<string>()
+        let current = fiberId
+        while (true) {
+          const rows = yield* sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${current}`
+          if (rows.length === 0 || !rows[0].parentId) break
+          const parentId = rows[0].parentId
+          if (visited.has(parentId)) break
+          chain.push(parentId)
+          visited.add(parentId)
+          current = parentId
+        }
+        return chain.reverse()
+      }),
+    ),
   )
 }
 
-export function getFiberContext(sql: SqlClient.SqlClient, fiberId: string) {
+export function getFiberContext(fiberId: string) {
   return noTrace(
-    Effect.map(
-      sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${fiberId}`,
-      (rows): FiberContext | undefined =>
-        rows.length > 0
-          ? {
-              spanName: rows[0].spanName ?? undefined,
-              traceId: rows[0].traceId != null ? BigInt(rows[0].traceId) : undefined,
-              annotations: JSON.parse(rows[0].annotations),
-            }
-          : undefined,
+    withSql((sql) =>
+      Effect.map(
+        sql<FiberRow>`SELECT * FROM Fiber WHERE id = ${fiberId}`,
+        (rows): FiberContext | undefined =>
+          rows.length > 0
+            ? {
+                spanName: rows[0].spanName ?? undefined,
+                traceId: rows[0].traceId != null ? BigInt(rows[0].traceId) : undefined,
+                annotations: JSON.parse(rows[0].annotations),
+              }
+            : undefined,
+      ),
     ),
   )
 }

package/src/studio/StudioTracer.ts

@@ -62,11 +62,14 @@ const make = (store: StudioStore.StudioStoreShape): Tracer.Tracer =>
 
       StudioStore.runWrite(
         Effect.zipRight(
-          StudioStore.insertSpan(store.sql, studioSpan),
-          StudioStore.evict(store.sql, "Span", store.spanCapacity),
+          StudioStore.insertSpan(studioSpan),
+          StudioStore.evict("Span", store.spanCapacity),
         ),
       )
       publish(store, { _tag: "SpanStart", span: studioSpan })
+      if (parentSpanId === undefined) {
+        publish(store, { _tag: "TraceStart", traceId })
+      }
 
       const attrs = new Map<string, unknown>(Object.entries(attributes))
       const spanLinks = [...links]
@@ -97,17 +100,20 @@ const make = (store: StudioStore.StudioStoreShape): Tracer.Tracer =>
           studioSpan.endTime = endTime
           studioSpan.durationMs = Number(endTime - studioSpan.startTime) / 1_000_000
           studioSpan.status = Exit.isSuccess(exit) ? "ok" : "error"
-          StudioStore.runWrite(StudioStore.updateSpan(store.sql, studioSpan))
+          StudioStore.runWrite(StudioStore.updateSpan(studioSpan))
           publish(store, { _tag: "SpanEnd", span: studioSpan })
+          if (parentSpanId === undefined) {
+            publish(store, { _tag: "TraceEnd", traceId })
+          }
         },
         attribute(key, value) {
           attrs.set(key, value)
           ;(studioSpan.attributes as Record<string, unknown>)[key] = value
-          StudioStore.runWrite(StudioStore.updateSpan(store.sql, studioSpan))
+          StudioStore.runWrite(StudioStore.updateSpan(studioSpan))
         },
         event(name, startTime, attributes) {
           studioSpan.events.push({ name, startTime, attributes })
-          StudioStore.runWrite(StudioStore.updateSpan(store.sql, studioSpan))
+          StudioStore.runWrite(StudioStore.updateSpan(studioSpan))
         },
         addLinks(newLinks) {
           spanLinks.push(...newLinks)

package/src/studio/routes/errors/route.tsx

@@ -12,7 +12,7 @@ export default Route.get(
     const url = new URL(ctx.request.url)
     const search = url.searchParams.get("errorSearch") || ""
     const tag = url.searchParams.get("errorTag") || ""
-    const allErrors = yield* StudioStore.allErrors(StudioStore.store.sql)
+    const allErrors = yield* StudioStore.allErrors()
     const tagSet = new Set<string>()
     for (const error of allErrors) {
       for (const d of error.details) {
@@ -67,6 +67,8 @@ export default Route.get(
               <Errors.ErrorLine error={e} />
             ))}
           </div>
+
+          <div data-init={`@get('${prefix}/errors')`} />
         </form>
       </Shell.Shell>
     )
@@ -75,10 +77,7 @@ export default Route.get(
     Stream.fromPubSub(StudioStore.store.events).pipe(
       Stream.filter((e) => e._tag === "Error"),
       Stream.map((e) => {
-        const html = Html.renderToString(<Errors.ErrorLine error={e.error} />).replace(
-          /\n/g,
-          "",
-        )
+        const html = Html.renderToString(<Errors.ErrorLine error={e.error} />).replace(/\n/g, "")
         return {
           event: "datastar-patch-elements",
           data: `selector #errors-list\nmode prepend\nelements ${html}`,

package/src/studio/routes/fiberDetail.tsx

@@ -12,8 +12,8 @@ export default Route.get(
     const fiberId = ctx.pathParams.id
     const fiberName = fiberId.startsWith("#") ? fiberId : `#${fiberId}`
 
-    const fiberLogs = yield* StudioStore.logsByFiberId(StudioStore.store.sql, fiberName)
-    const fiberSpans = yield* StudioStore.spansByFiberId(StudioStore.store.sql, fiberName)
+    const fiberLogs = yield* StudioStore.logsByFiberId(fiberName)
+    const fiberSpans = yield* StudioStore.spansByFiberId(fiberName)
 
     const fiberNum = parseInt(fiberName.slice(1), 10)
     const counter = StudioStore.fiberIdCounter()
@@ -30,8 +30,8 @@ export default Route.get(
       else if (fiberNum < counter) alive = "dead"
     }
 
-    const parents = yield* StudioStore.getParentChain(StudioStore.store.sql, fiberName)
-    const fiberContext = yield* StudioStore.getFiberContext(StudioStore.store.sql, fiberName)
+    const parents = yield* StudioStore.getParentChain(fiberName)
+    const fiberContext = yield* StudioStore.getFiberContext(fiberName)
 
     return (
       <Shell.Shell prefix={StudioStore.store.prefix} active="fibers">

package/src/studio/routes/fibers/route.tsx

@@ -8,8 +8,8 @@ import * as Shell from "../../ui/Shell.tsx"
 
 export default Route.get(
   Route.html(function* () {
-    const logs = yield* StudioStore.allLogs(StudioStore.store.sql)
-    const spans = yield* StudioStore.allSpans(StudioStore.store.sql)
+    const logs = yield* StudioStore.allLogs()
+    const spans = yield* StudioStore.allSpans()
     const fibers = Fibers.collectFibers(logs, spans)
     return (
       <Shell.Shell prefix={StudioStore.store.prefix} active="fibers">
@@ -28,8 +28,8 @@ export default Route.get(
       Stream.filter((e) => e._tag === "SpanStart" || e._tag === "SpanEnd" || e._tag === "Log"),
       Stream.mapEffect(() =>
         Effect.gen(function* () {
-          const logs = yield* StudioStore.allLogs(StudioStore.store.sql)
-          const spans = yield* StudioStore.allSpans(StudioStore.store.sql)
+          const logs = yield* StudioStore.allLogs()
+          const spans = yield* StudioStore.allSpans()
           const fibers = Fibers.collectFibers(logs, spans)
           const html = Html.renderToString(
             <Fibers.FiberList fibers={fibers} prefix={StudioStore.store.prefix} />,

package/src/studio/routes/logs/route.tsx

@@ -12,7 +12,7 @@ export default Route.get(
     const url = new URL(ctx.request.url)
     const level = url.searchParams.get("logLevel") || ""
     const search = url.searchParams.get("logSearch") || ""
-    let logs = yield* StudioStore.allLogs(StudioStore.store.sql)
+    let logs = yield* StudioStore.allLogs()
     if (level) logs = logs.filter((l) => l.level === level)
     if (search) {
       const lower = search.toLowerCase()
@@ -53,6 +53,8 @@ export default Route.get(
               <Logs.LogLine log={l} />
             ))}
           </div>
+
+          <div data-init={`@get('${prefix}/logs')`} />
         </form>
       </Shell.Shell>
     )

package/src/studio/routes/traceDetail.tsx

@@ -18,7 +18,7 @@ export default Route.get(
         </Shell.Shell>
       )
     }
-    const spans = yield* StudioStore.spansByTraceId(StudioStore.store.sql, traceId)
+    const spans = yield* StudioStore.spansByTraceId(traceId)
 
     return (
       <Shell.Shell prefix={StudioStore.store.prefix} active="traces">