effect-start 0.26.0 → 0.28.0

package/src/sql/postgres/index.ts

@@ -0,0 +1,254 @@
+import postgres from "postgres"
+import type * as Postgres from "postgres"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberRef from "effect/FiberRef"
+import * as GlobalValue from "effect/GlobalValue"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as SqlClient from "../SqlClient.ts"
+
+type PgConfig = string | Postgres.Options<Record<string, Postgres.PostgresType>>
+
+const toPgTemplateValues = (values: Array<unknown>): Array<Postgres.ParameterOrFragment<never>> =>
+  values as unknown as Array<Postgres.ParameterOrFragment<never>>
+
+const toPgUnsafeValues = (
+  values?: Array<unknown>,
+): Array<Postgres.ParameterOrJSON<never>> | undefined =>
+  values === undefined ? undefined : (values as unknown as Array<Postgres.ParameterOrJSON<never>>)
+
+const getErrorCode = (error: unknown): string => {
+  if (error !== null && typeof error === "object" && "code" in error) {
+    const code = (error as { readonly code: unknown }).code
+    if (typeof code === "string") {
+      return code
+    }
+  }
+  return "UNKNOWN"
+}
+
+const wrapError = (error: unknown): SqlClient.SqlError =>
+  new SqlClient.SqlError({
+    code: getErrorCode(error),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  })
+
+interface TxState {
+  readonly conn: Postgres.ReservedSql
+  readonly depth: number
+}
+
+const currentTransaction = GlobalValue.globalValue(
+  Symbol.for("effect-start/sql/postgres/currentTransaction"),
+  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+)
+
+const runTemplate = <T extends object = SqlClient.SqlRow>(
+  pg: Postgres.Sql,
+  strings: TemplateStringsArray,
+  values: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => {
+        const args = toPgTemplateValues(values)
+        if (Option.isSome(txOpt)) {
+          return Promise.resolve(
+            txOpt.value.conn<ReadonlyArray<T>>(strings, ...args) as unknown as ReadonlyArray<T>,
+          )
+        }
+        return Promise.resolve(
+          pg<ReadonlyArray<T>>(strings, ...args) as unknown as ReadonlyArray<T>,
+        )
+      },
+      catch: wrapError,
+    }),
+  )
+
+const runUnsafe = <T extends object = SqlClient.SqlRow>(
+  pg: Postgres.Sql,
+  query: string,
+  values?: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => {
+        const args = toPgUnsafeValues(values)
+        if (Option.isSome(txOpt)) {
+          return Promise.resolve(
+            txOpt.value.conn.unsafe<Array<T>>(query, args) as unknown as ReadonlyArray<T>,
+          )
+        }
+        return Promise.resolve(pg.unsafe<Array<T>>(query, args) as unknown as ReadonlyArray<T>)
+      },
+      catch: wrapError,
+    }),
+  )
+
+const makeWithTransaction =
+  (pg: Postgres.Sql) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, SqlClient.SqlError | E, R> =>
+    Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+        if (Option.isSome(txOpt)) {
+          const { conn, depth } = txOpt.value
+          const name = `sp_${depth}`
+          return Effect.gen(function* () {
+            yield* Effect.tryPromise({
+              try: () => Promise.resolve(conn.unsafe(`SAVEPOINT ${name}`)),
+              catch: wrapError,
+            })
+            const exit = yield* Effect.exit(
+              restore(
+                Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 })),
+              ),
+            )
+            if (Exit.isSuccess(exit)) {
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(conn.unsafe(`RELEASE SAVEPOINT ${name}`)),
+                catch: wrapError,
+              })
+              return exit.value
+            }
+            yield* Effect.tryPromise({
+              try: () => Promise.resolve(conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)),
+              catch: wrapError,
+            }).pipe(Effect.orDie)
+            return yield* exit
+          })
+        }
+
+        return Effect.acquireUseRelease(
+          Effect.tryPromise({ try: () => pg.reserve(), catch: wrapError }),
+          (reserved) =>
+            Effect.gen(function* () {
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(reserved.unsafe("BEGIN")),
+                catch: wrapError,
+              })
+              const exit = yield* Effect.exit(
+                restore(
+                  Effect.locally(
+                    self,
+                    currentTransaction,
+                    Option.some({ conn: reserved, depth: 1 }),
+                  ),
+                ),
+              )
+              if (Exit.isSuccess(exit)) {
+                yield* Effect.tryPromise({
+                  try: () => Promise.resolve(reserved.unsafe("COMMIT")),
+                  catch: wrapError,
+                })
+                return exit.value
+              }
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(reserved.unsafe("ROLLBACK")),
+                catch: wrapError,
+              }).pipe(Effect.orDie)
+              return yield* exit
+            }),
+          (reserved) => Effect.sync(() => reserved.release()),
+        )
+      }),
+    )
+
+const dialect = SqlClient.postgresDialect
+const spanAttributes: ReadonlyArray<readonly [string, unknown]> = [["db.system.name", "postgresql"]]
+
+const makeTaggedTemplate = (pg: Postgres.Sql) => {
+  const unsafeFn: SqlClient.UnsafeQuery = <T extends object = SqlClient.SqlRow>(
+    query: string,
+    values?: Array<unknown>,
+  ) => runUnsafe<T>(pg, query, values)
+
+  const query = <T extends object = SqlClient.SqlRow>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> => {
+    if (SqlClient.hasFragments(values)) {
+      const compiled = SqlClient.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+    return runTemplate<T>(pg, strings, values)
+  }
+
+  return { query, unsafeFn }
+}
+
+const makeReservedConnection = (reserved: Postgres.ReservedSql): SqlClient.Connection => {
+  const query = <T extends object = SqlClient.SqlRow>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+    Effect.tryPromise({
+      try: () =>
+        Promise.resolve(
+          reserved<ReadonlyArray<T>>(
+            strings,
+            ...toPgTemplateValues(values),
+          ) as unknown as ReadonlyArray<T>,
+        ),
+      catch: wrapError,
+    })
+
+  const unsafe: SqlClient.UnsafeQuery = <T extends object = SqlClient.SqlRow>(
+    queryText: string,
+    values?: Array<unknown>,
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+    Effect.tryPromise({
+      try: () =>
+        Promise.resolve(
+          reserved.unsafe<Array<T>>(
+            queryText,
+            toPgUnsafeValues(values),
+          ) as unknown as ReadonlyArray<T>,
+        ),
+      catch: wrapError,
+    })
+
+  return SqlClient.connection(query, unsafe, { spanAttributes, dialect })
+}
+
+export const layer = (config: PgConfig): Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError> =>
+  Layer.scoped(
+    SqlClient.SqlClient,
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.try({
+          try: () => {
+            const pg =
+              typeof config === "string"
+                ? postgres(config)
+                : postgres(config as Postgres.Options<Record<string, Postgres.PostgresType>>)
+            const tagged = makeTaggedTemplate(pg)
+            const use: SqlClient.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(pg)), catch: wrapError })
+
+            return {
+              client: SqlClient.make({
+                query: tagged.query,
+                unsafe: tagged.unsafeFn,
+                withTransaction: makeWithTransaction(pg),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  Effect.tryPromise({ try: () => pg.reserve(), catch: wrapError }),
+                  (reserved: Postgres.ReservedSql) => Effect.sync(() => reserved.release()),
+                ).pipe(
+                  Effect.map((reserved): SqlClient.Connection => makeReservedConnection(reserved)),
+                ),
+                use,
+              }),
+              close: use((driver) => (driver as Postgres.Sql).end({ timeout: 0 })),
+            }
+          },
+          catch: wrapError,
+        }),
+        (handle) => handle.close.pipe(Effect.orDie),
+      ),
+      (handle) => handle.client,
+    ),
+  )

package/src/testing/TestLogger.ts

@@ -24,13 +24,13 @@ export function layer(): Layer.Layer<TestLogger> {
       const messages = yield* Ref.make<Array<string>>([])
       const mutableRef = (messages as any).ref as MutableRef.MutableRef<Array<string>>
 
-      const customLogger = Logger.make(({ message, logLevel, cause }) => {
-        const causeStr = !Cause.isEmpty(cause)
-          ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
+      const customLogger = Logger.make((options) => {
+        const causeStr = !Cause.isEmpty(options.cause)
+          ? ` ${Cause.pretty(options.cause, { renderErrorCause: true })}`
           : ""
         MutableRef.update(mutableRef, (msgs) => [
           ...msgs,
-          `[${logLevel._tag}] ${String(message)}${causeStr}`,
+          `[${options.logLevel._tag}] ${String(options.message)}${causeStr}`,
         ])
       })
 

package/src/{console → tower}/Simulation.ts

@@ -7,10 +7,6 @@ import * as MetricBoundaries from "effect/MetricBoundaries"
 import * as Random from "effect/Random"
 import * as Schedule from "effect/Schedule"
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 const pick = <T>(arr: ReadonlyArray<T>): Effect.Effect<T> =>
   Random.nextIntBetween(0, arr.length).pipe(Effect.map((i) => arr[i]))
 
@@ -22,10 +18,6 @@ const maybe = (pct: number, op: Effect.Effect<void, any>) =>
     if ((yield* Random.nextIntBetween(0, 100)) < pct) yield* op
   })
 
-// ---------------------------------------------------------------------------
-// Metrics
-// ---------------------------------------------------------------------------
-
 const httpRequestsTotal = Metric.counter("http.requests.total")
 const httpRequestDuration = Metric.histogram(
   "http.request.duration_ms",
@@ -49,10 +41,6 @@ const serializationDuration = Metric.histogram(
   MetricBoundaries.linear({ start: 0, width: 5, count: 15 }),
 )
 
-// ---------------------------------------------------------------------------
-// Simulated operations
-// ---------------------------------------------------------------------------
-
 const routes = [
   { method: "GET", path: "/api/users", handler: "UserController.list" },
   { method: "GET", path: "/api/users/:id", handler: "UserController.get" },
@@ -119,10 +107,6 @@ const errorMessages = [
   "DNS resolution failed for analytics.internal.svc",
 ]
 
-// ---------------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------------
-
 class DatabaseError extends Data.TaggedError("DatabaseError")<{
   readonly query: string
   readonly reason: string
@@ -171,10 +155,6 @@ class CircuitBreakerError extends Data.TaggedError("CircuitBreakerError")<{
   readonly failureCount: number
 }> {}
 
-// ---------------------------------------------------------------------------
-// Leaf-level spans
-// ---------------------------------------------------------------------------
-
 const simulateDnsResolve = Effect.gen(function* () {
   const hosts = [
     "db-primary.internal",
@@ -415,10 +395,6 @@ const simulateAccessLog = Effect.gen(function* () {
   yield* Effect.sleep(yield* randomMs(0, 1))
 }).pipe(Effect.withSpan("middleware.access_log"))
 
-// ---------------------------------------------------------------------------
-// Composite sub-operations with deep nesting
-// ---------------------------------------------------------------------------
-
 const simulateCircuitBreaker = (inner: Effect.Effect<void, any>, service: string) =>
   Effect.gen(function* () {
     const failures = yield* Random.nextIntBetween(0, 10)
@@ -619,10 +595,6 @@ const simulateAnalyticsPipeline = Effect.gen(function* () {
   }).pipe(Effect.withSpan("analytics.transform"))
 }).pipe(Effect.withSpan("analytics.pipeline"))
 
-// ---------------------------------------------------------------------------
-// Background tasks (also deeper now)
-// ---------------------------------------------------------------------------
-
 const simulateBackgroundTask = Effect.gen(function* () {
   const tasks = [
     "process-webhook",
@@ -685,10 +657,6 @@ const simulateBackgroundTask = Effect.gen(function* () {
   yield* Effect.logInfo(`completed background task: ${task}`)
 }).pipe(Effect.withSpan("task.background"))
 
-// ---------------------------------------------------------------------------
-// Simulate a single HTTP request (deep middleware + handler pipeline)
-// ---------------------------------------------------------------------------
-
 const simulateRequest = Effect.gen(function* () {
   const route = yield* pick(routes)
   const statusCodes = [200, 200, 200, 200, 200, 201, 204, 301, 400, 401, 404, 500]
@@ -769,10 +737,6 @@ const simulateRequest = Effect.gen(function* () {
   return result
 })
 
-// ---------------------------------------------------------------------------
-// Simulation loops
-// ---------------------------------------------------------------------------
-
 const requestLoop = Effect.gen(function* () {
   yield* Effect.logInfo("simulation: request loop started")
   yield* Effect.schedule(
@@ -800,15 +764,13 @@ const backgroundLoop = Effect.gen(function* () {
   )
 })
 
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export const layer = Layer.scopedDiscard(
-  Effect.gen(function* () {
-    yield* Effect.logInfo("simulation layer starting")
-    yield* Effect.forkScoped(requestLoop)
-    yield* Effect.forkScoped(backgroundLoop)
-    yield* Effect.logInfo("simulation layer ready")
-  }),
-)
+export function layer() {
+  return Layer.scopedDiscard(
+    Effect.gen(function* () {
+      yield* Effect.logInfo("simulation layer starting")
+      yield* Effect.forkScoped(requestLoop)
+      yield* Effect.forkScoped(backgroundLoop)
+      yield* Effect.logInfo("simulation layer ready")
+    }),
+  )
+}

package/src/tower/Tower.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Route from "../Route.ts"
+import * as RouteTree from "../RouteTree.ts"
+import * as sqlBun from "effect-start/sql/bun"
+import type * as SqlClient from "../sql/SqlClient.ts"
+import * as TowerErrors from "./TowerErrors.ts"
+import * as TowerLogger from "./TowerLogger.ts"
+import * as TowerMetrics from "./TowerMetrics.ts"
+import * as TowerProcess from "./TowerProcess.ts"
+import * as TowerStore from "./TowerStore.ts"
+import * as TowerTracer from "./TowerTracer.ts"
+import consoleRoutes from "./routes/tree.ts"
+
+export function layer(
+  options?: TowerStore.TowerStoreOptions & {
+    readonly sqlLayer?: Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError>
+  },
+): Layer.Layer<TowerStore.TowerStore> {
+  const sqlLayer =
+    options?.sqlLayer ?? sqlBun.layer({ adapter: "sqlite", filename: ":memory:" } as any)
+  const store = TowerStore.layer(options).pipe(Layer.provide(sqlLayer), Layer.orDie)
+  const features = Layer.mergeAll(
+    TowerTracer.layer,
+    TowerLogger.layer,
+    TowerMetrics.layer,
+    TowerErrors.layer,
+    TowerProcess.layer,
+  ).pipe(Layer.provide(store))
+  return Layer.merge(store, features)
+}
+
+export function layerRoutes(options?: { prefix?: string }) {
+  const prefix = options?.prefix ?? "/tower"
+
+  return Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Route.Routes
+      TowerStore.store.prefix = prefix
+      const tree = Route.tree({
+        [prefix as "/"]: consoleRoutes,
+      })
+      return RouteTree.merge(existing, tree)
+    }),
+  )
+}

package/src/{console/ConsoleErrors.ts → tower/TowerErrors.ts}

@@ -11,9 +11,7 @@ import * as PubSub from "effect/PubSub"
 import type * as Context from "effect/Context"
 import type * as Fiber from "effect/Fiber"
 import * as Supervisor from "effect/Supervisor"
-import * as ConsoleStore from "./ConsoleStore.ts"
-
-let errorId = 0
+import * as TowerStore from "./TowerStore.ts"
 
 function safeSerialize(value: unknown, depth = 0): unknown {
   if (depth > 4) return "<deep>"
@@ -124,8 +122,8 @@ function extractSpanName(error: unknown): string | undefined {
   return undefined
 }
 
-function extractDetails(cause: Cause.Cause<unknown>): Array<ConsoleStore.ConsoleErrorDetail> {
-  const details: Array<ConsoleStore.ConsoleErrorDetail> = []
+function extractDetails(cause: Cause.Cause<unknown>): Array<TowerStore.TowerErrorDetail> {
+  const details: Array<TowerStore.TowerErrorDetail> = []
 
   const failures = Chunk.toArray(Cause.failures(cause))
   for (const error of failures) {
@@ -152,7 +150,7 @@ function extractDetails(cause: Cause.Cause<unknown>): Array<ConsoleStore.Console
   return details
 }
 
-function make(store: ConsoleStore.ConsoleStoreShape): Supervisor.Supervisor<void> {
+function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
   return new (class extends Supervisor.AbstractSupervisor<void> {
     value = Effect.void
 
@@ -163,14 +161,18 @@ function make(store: ConsoleStore.ConsoleStoreShape): Supervisor.Supervisor<void
       fiber: Fiber.RuntimeFiber<A, E>,
     ) {
       const childId = FiberId.threadName(fiber.id())
-      if (Option.isSome(parent)) {
-        const parentId = FiberId.threadName(parent.value.id())
-        if (childId !== parentId) {
-          store.fiberParents.set(childId, parentId)
-        }
-      }
+      const parentId = Option.isSome(parent) ? FiberId.threadName(parent.value.id()) : undefined
 
       const span = fiber.currentSpan
+      const traceId = span
+        ? (() => {
+            try {
+              return BigInt(span.traceId)
+            } catch {
+              return undefined
+            }
+          })()
+        : undefined
       const annotations: Record<string, unknown> = {}
       const spanAnnotations = fiber.getFiberRef(FiberRef.currentTracerSpanAnnotations)
       HashMap.forEach(spanAnnotations, (value, key) => {
@@ -181,33 +183,42 @@ function make(store: ConsoleStore.ConsoleStoreShape): Supervisor.Supervisor<void
         annotations[key] = value
       })
 
-      store.fiberContexts.set(childId, {
-        spanName: span?._tag === "Span" ? span.name : undefined,
-        traceId: span ? span.traceId : undefined,
-        annotations,
-      })
+      TowerStore.runWrite(
+        TowerStore.upsertFiber(
+          store.sql,
+          childId,
+          parentId !== childId ? parentId : undefined,
+          span?._tag === "Span" ? span.name : undefined,
+          traceId,
+          annotations,
+        ),
+      )
     }
 
     onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>) {
       if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
-        const error: ConsoleStore.ConsoleError = {
-          id: String(++errorId),
-          date: new Date(),
+        const error: TowerStore.TowerError = {
+          id: TowerStore.nextErrorId(),
           fiberId: FiberId.threadName(fiber.id()),
           interrupted: Cause.isInterrupted(exit.cause),
           prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
           details: extractDetails(exit.cause),
         }
-        store.errors.push(error)
+        TowerStore.runWrite(
+          Effect.zipRight(
+            TowerStore.insertError(store.sql, error),
+            TowerStore.evict(store.sql, "Error", store.errorCapacity),
+          ),
+        )
         Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))
       }
     }
   })()
 }
 
-export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.unwrapEffect(
+export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.unwrapEffect(
   Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
+    const store = yield* TowerStore.TowerStore
     return Supervisor.addSupervisor(make(store))
   }),
 )

package/src/tower/TowerLogger.ts

@@ -0,0 +1,52 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import * as HashMap from "effect/HashMap"
+import * as List from "effect/List"
+import * as Logger from "effect/Logger"
+import * as PubSub from "effect/PubSub"
+import * as TowerStore from "./TowerStore.ts"
+
+const towerLogger = Logger.make((options) => {
+  const store = TowerStore.store
+  if (!store.sql) return
+
+  try {
+    const levelMap: Record<string, TowerStore.TowerLog["level"]> = {
+      Debug: "DEBUG",
+      Info: "INFO",
+      Warning: "WARNING",
+      Error: "ERROR",
+      Fatal: "FATAL",
+    }
+    const level = levelMap[options.logLevel._tag] ?? "INFO"
+    const causeStr = !Cause.isEmpty(options.cause)
+      ? Cause.pretty(options.cause, { renderErrorCause: true })
+      : undefined
+    const spanNames: Array<string> = []
+    List.forEach(options.spans, (s) => spanNames.push(s.label))
+    const ann: Record<string, unknown> = {}
+    HashMap.forEach(options.annotations, (v, k) => {
+      ann[k] = v
+    })
+
+    const log: TowerStore.TowerLog = {
+      id: TowerStore.nextLogId(),
+      level,
+      message: String(options.message),
+      fiberId: FiberId.threadName(options.fiberId),
+      cause: causeStr,
+      spans: spanNames,
+      annotations: ann,
+    }
+    TowerStore.runWrite(
+      Effect.zipRight(
+        TowerStore.insertLog(store.sql, log),
+        TowerStore.evict(store.sql, "Log", store.logCapacity),
+      ),
+    )
+    Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))
+  } catch (_) {}
+})
+
+export const layer = Logger.add(towerLogger)

package/src/{console/ConsoleMetrics.ts → tower/TowerMetrics.ts}

@@ -4,22 +4,22 @@ import * as Metric from "effect/Metric"
 import * as MetricKeyType from "effect/MetricKeyType"
 import * as PubSub from "effect/PubSub"
 import * as Schedule from "effect/Schedule"
-import * as ConsoleStore from "./ConsoleStore.ts"
+import * as TowerStore from "./TowerStore.ts"
 
-export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.scopedDiscard(
+export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.scopedDiscard(
   Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
+    const store = yield* TowerStore.TowerStore
 
     yield* Effect.forkScoped(
       Effect.schedule(
         Effect.sync(() => {
           const pairs = Metric.unsafeSnapshot()
-          const snapshots: Array<ConsoleStore.ConsoleMetricSnapshot> = []
+          const snapshots: Array<TowerStore.TowerMetricSnapshot> = []
 
           for (const pair of pairs) {
             const key = pair.metricKey
             const state = pair.metricState as any
-            let type: ConsoleStore.ConsoleMetricSnapshot["type"] = "counter"
+            let type: TowerStore.TowerMetricSnapshot["type"] = "counter"
             let value: unknown = 0
 
             if (MetricKeyType.CounterKeyTypeTypeId in key.keyType) {

package/src/{console/ConsoleProcess.ts → tower/TowerProcess.ts}

@@ -3,9 +3,9 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as PubSub from "effect/PubSub"
 import * as Schedule from "effect/Schedule"
-import * as ConsoleStore from "./ConsoleStore.ts"
+import * as TowerStore from "./TowerStore.ts"
 
-function snapshot(): ConsoleStore.ProcessStats {
+function snapshot(): TowerStore.ProcessStats {
   const mem = process.memoryUsage()
   const cpu = process.cpuUsage()
   const res = process.resourceUsage()
@@ -41,9 +41,9 @@ function snapshot(): ConsoleStore.ProcessStats {
   }
 }
 
-export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.scopedDiscard(
+export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.scopedDiscard(
   Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
+    const store = yield* TowerStore.TowerStore
 
     yield* Effect.forkScoped(
       Effect.schedule(