effect-start 0.26.0 → 0.27.0

package/src/sql/libsql/index.ts

@@ -5,7 +5,8 @@ import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Libsql from "@libsql/client"
-import * as Sql from "../Sql.ts"
+import * as Sql from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
 export interface LibsqlConfig {
   readonly url: string
@@ -13,6 +14,7 @@ export interface LibsqlConfig {
   readonly syncUrl?: string
   readonly syncInterval?: number
   readonly encryptionKey?: string
+  readonly spanAttributes?: Record<string, unknown>
 }
 
 const wrapError = (error: unknown): Sql.SqlError =>
@@ -25,12 +27,28 @@ const wrapError = (error: unknown): Sql.SqlError =>
 const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
   Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
 
-const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
+const dialect = Sql.sqliteDialect
+const makeSpanAttributes = (config: LibsqlConfig): ReadonlyArray<readonly [string, unknown]> => {
+  const parsed = (() => {
+    try {
+      return new URL(config.url)
+    } catch {
+      return undefined
+    }
+  })()
+  const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+  const parsedPort = parsed?.port ? Number(parsed.port) : undefined
+
+  return Object.entries(
+    Values.compact({
+      ...(config.spanAttributes ?? {}),
+      "db.system.name": "sqlite",
+      "db.namespace": dbFromPath,
+      "server.address": parsed?.hostname,
+      "server.port": parsedPort,
+    }),
+  )
 }
-
 const resultSetToRows = <T>(result: Libsql.ResultSet): ReadonlyArray<T> => {
   const { columns, rows } = result
   return rows.map((row) => {
@@ -40,13 +58,14 @@ const resultSetToRows = <T>(result: Libsql.ResultSet): ReadonlyArray<T> => {
   })
 }
 
-const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
-  let sql = strings[0]
-  for (let i = 0; i < values.length; i++) sql += "?" + strings[i + 1]
-  return { sql, args: values }
-}
+const executeQuery = <T>(
+  client: Libsql.Client,
+  sql: string,
+  args: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
 
-interface TxState {
+interface TransactionConnection {
   readonly depth: number
 }
 
@@ -58,34 +77,39 @@ const loadLibsql = () => import("@libsql/client") as Promise<LibsqlModule>
 
 const currentTransaction = GlobalValue.globalValue(
   Symbol.for("effect-start/sql/libsql/currentTransaction"),
-  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
-const executeQuery = <T>(
-  client: Libsql.Client,
-  sql: string,
-  args: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
-
-const runQuery = <T>(
-  client: Libsql.Client,
-  strings: TemplateStringsArray,
-  values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
-  const { sql, args } = buildQuery(strings, values)
-  return executeQuery(client, sql, args)
+const exec = (client: Libsql.Client, sql: string) => wrap(() => client.execute(sql))
+
+const makeTaggedTemplate = (client: Libsql.Client) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    executeQuery<T>(client, query, values ?? [])
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+    if (Sql.hasFragments(values)) {
+      const compiled = Sql.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+
+    let sqlText = strings[0]
+    for (let i = 0; i < values.length; i++) sqlText += "?" + strings[i + 1]
+    return executeQuery<T>(client, sqlText, values)
+  }
 }
 
-const runUnsafe = <T>(
+const makeQuery = (
   client: Libsql.Client,
-  query: string,
-  values?: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  executeQuery(client, query, values ?? [])
-
-const exec = (client: Libsql.Client, sql: string) =>
-  wrap(() => client.execute(sql))
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): Sql.Connection => {
+  const query = makeTaggedTemplate(client)
+  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+    executeQuery<T>(client, query, values ?? [])
+  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (client: Libsql.Client) =>
@@ -98,9 +122,7 @@ const makeWithTransaction =
           return Effect.gen(function* () {
             yield* exec(client, `SAVEPOINT ${name}`)
             const exit = yield* Effect.exit(
-              restore(
-                Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 })),
-              ),
+              restore(Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 }))),
             )
             if (Exit.isSuccess(exit)) {
               yield* exec(client, `RELEASE SAVEPOINT ${name}`)
@@ -129,45 +151,37 @@ const makeWithTransaction =
 export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
   Layer.scoped(
     Sql.SqlClient,
-    Effect.acquireRelease(
-      wrap(() => loadLibsql()).pipe(
-        Effect.map((libsql) => {
-          const client = libsql.createClient(config)
-          const use: Sql.SqlClient["use"] = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
-          return Object.assign(
-            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-              runQuery<T>(client, strings, values),
-            {
-              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                runUnsafe<T>(client, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(client),
-              reserve: Effect.acquireRelease(
-                wrap(() => loadLibsql()).pipe(
-                  Effect.map((m) => m.createClient(config)),
-                ),
-                (reserved: Libsql.Client) => Effect.sync(() => reserved.close()),
-              ).pipe(
-                Effect.map(
-                  (reserved): Sql.SqlQuery =>
-                    Object.assign(
-                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-                        runQuery<T>(reserved, strings, values),
-                      {
-                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                          runUnsafe<T>(reserved, query, values),
-                        values: makeValues,
-                      },
-                    ),
-                ),
-              ),
-              close: () => Effect.sync(() => client.close()),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        }),
+    Effect.map(
+      Effect.acquireRelease(
+        wrap(() => loadLibsql()).pipe(
+          Effect.map((libsql) => {
+            const client = libsql.createClient(config)
+            const spanAttributes = makeSpanAttributes(config)
+            const query = makeTaggedTemplate(client)
+            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => executeQuery<T>(client, query, values ?? [])
+            const use: Sql.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
+
+            return {
+              client: Sql.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(client),
+                spanAttributes,
+                dialect,
+                // libsql has no connection pool — reuse the existing client
+                reserve: Effect.succeed(makeQuery(client, spanAttributes)),
+                use,
+              }),
+              close: Effect.sync(() => client.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
       ),
-      (client) => client.close().pipe(Effect.orDie),
+      (handle) => handle.client,
     ),
   )

package/src/sql/libsql/libsql.d.ts

@@ -21,7 +21,10 @@ declare module "@libsql/client" {
 
   export interface Client {
     execute(stmt: InStatement | string): Promise<ResultSet>
-    batch(stmts: ReadonlyArray<InStatement | string>, mode?: TransactionMode): Promise<ReadonlyArray<ResultSet>>
+    batch(
+      stmts: ReadonlyArray<InStatement | string>,
+      mode?: TransactionMode,
+    ): Promise<ReadonlyArray<ResultSet>>
     transaction(mode?: TransactionMode): Promise<Transaction>
     close(): void
   }

package/src/sql/mssql/index.ts

@@ -5,26 +5,8 @@ import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Mssql from "mssql"
-import * as Sql from "../Sql.ts"
-
-export interface MssqlConfig {
-  readonly server: string
-  readonly database?: string
-  readonly user?: string
-  readonly password?: string
-  readonly port?: number
-  readonly pool?: {
-    readonly max?: number
-    readonly min?: number
-    readonly idleTimeoutMillis?: number
-  }
-  readonly options?: {
-    readonly encrypt?: boolean
-    readonly trustServerCertificate?: boolean
-    readonly requestTimeout?: number
-    readonly connectionTimeout?: number
-  }
-}
+import * as Sql from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
 const wrapError = (error: unknown): Sql.SqlError =>
   new Sql.SqlError({
@@ -35,17 +17,33 @@ const wrapError = (error: unknown): Sql.SqlError =>
     cause: error,
   })
 
-const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
-}
+const dialect = Sql.mssqlDialect
+const makeSpanAttributes = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): Record<string, unknown> =>
+  {
+    const parsed = (() => {
+      if (typeof config.url !== "string") return undefined
+      try {
+        return new URL(config.url)
+      } catch {
+        return undefined
+      }
+    })()
+    const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+    const parsedPort = parsed?.port ? Number(parsed.port) : undefined
 
-const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
-  let text = strings[0]
-  for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
-  return { text, values }
-}
+    return Values.compact({
+      ...(config.spanAttributes ?? {}),
+      "db.system.name": "microsoft.sql_server",
+      "db.namespace": config.database ?? dbFromPath,
+      "server.address": config.server ?? parsed?.hostname,
+      "server.port": config.port ?? parsedPort,
+    })
+  }
 
 const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
   for (let i = 0; i < values.length; i++) {
@@ -53,7 +51,7 @@ const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
   }
 }
 
-interface TxState {
+interface TransactionConnection {
   readonly transaction: Mssql.Transaction
   readonly depth: number
 }
@@ -66,45 +64,71 @@ const loadMssql = () => import("mssql") as Promise<MssqlModule>
 
 const currentTransaction = GlobalValue.globalValue(
   Symbol.for("effect-start/sql/mssql/currentTransaction"),
-  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
+const makeRequest = (
+  pool: Mssql.ConnectionPool,
+  txOpt: Option.Option<TransactionConnection>,
+  values: Array<unknown>,
+): Mssql.Request => {
+  const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
+  addInputs(request, values)
+  return request
+}
+
 const executeQuery = <T>(
   pool: Mssql.ConnectionPool,
   text: string,
   values: Array<unknown>,
 ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query<T>(text),
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values).query<T>(text),
       catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
-
-const runQuery = <T>(
-  pool: Mssql.ConnectionPool,
-  strings: TemplateStringsArray,
-  values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
-  const { text, values: params } = buildQuery(strings, values)
-  return executeQuery(pool, text, params)
-}
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
 
 const runUnsafe = <T>(
   pool: Mssql.ConnectionPool,
   query: string,
   values?: Array<unknown>,
 ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    if (values) addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query<T>(query),
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values ?? []).query<T>(query),
       catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
+
+const makeTaggedTemplate = (pool: Mssql.ConnectionPool) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+    if (Sql.hasFragments(values)) {
+      const compiled = Sql.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+
+    let text = strings[0]
+    for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
+    return executeQuery<T>(pool, text, values)
+  }
+}
+
+const makeQuery = (
+  pool: Mssql.ConnectionPool,
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): Sql.Connection => {
+  const query = makeTaggedTemplate(pool)
+  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (pool: Mssql.ConnectionPool) =>
@@ -161,63 +185,72 @@ const makeWithTransaction =
       }),
     )
 
-export const layer = (config: MssqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+export const layer = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
   Layer.scoped(
     Sql.SqlClient,
-    Effect.acquireRelease(
-      Effect.tryPromise({
-        try: async () => {
-          const mssql = await loadMssql()
-          const pool = await new mssql.ConnectionPool(config as Mssql.config).connect()
-          return { mssql, pool }
-        },
-        catch: wrapError,
-      }).pipe(
-        Effect.map(({ mssql, pool }) => {
-          const use: Sql.SqlClient["use"] = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
-          return Object.assign(
-            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-              runQuery<T>(pool, strings, values),
-            {
-              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                runUnsafe<T>(pool, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(pool),
-              reserve: Effect.acquireRelease(
-                Effect.tryPromise({
-                  try: () =>
-                    new mssql.ConnectionPool({
-                      ...config,
-                      pool: { max: 1, min: 1 },
-                    } as Mssql.config).connect(),
-                  catch: wrapError,
-                }),
-                (reserved: Mssql.ConnectionPool) =>
-                  Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
-                    Effect.asVoid,
-                    Effect.orDie,
-                  ),
-              ).pipe(
-                Effect.map(
-                  (reserved): Sql.SqlQuery =>
-                    Object.assign(
-                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-                        runQuery<T>(reserved, strings, values),
-                      {
-                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                          runUnsafe<T>(reserved, query, values),
-                        values: makeValues,
-                      },
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.tryPromise({
+          try: async () => {
+            const mssql = await loadMssql()
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const pool = await new mssql.ConnectionPool(driverConfig as unknown as Mssql.config).connect()
+            return { mssql, pool }
+          },
+          catch: wrapError,
+        }).pipe(
+          Effect.map((options) => {
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const spanAttributes = Object.entries(makeSpanAttributes(config))
+            const query = makeTaggedTemplate(options.pool)
+            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => runUnsafe<T>(options.pool, query, values)
+            const use: Sql.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(options.pool)), catch: wrapError })
+
+            return {
+              client: Sql.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(options.pool),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  Effect.tryPromise({
+                    try: () =>
+                      new options.mssql.ConnectionPool({
+                        ...driverConfig,
+                        pool: { max: 1, min: 1 },
+                      } as unknown as Mssql.config).connect(),
+                    catch: wrapError,
+                  }),
+                  (reserved: Mssql.ConnectionPool) =>
+                    Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
+                      Effect.asVoid,
+                      Effect.orDie,
                     ),
+                ).pipe(
+                  Effect.map((reserved): Sql.Connection => makeQuery(reserved, spanAttributes)),
                 ),
-              ),
-              close: () => use((pool) => pool.close()),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        }),
+                use,
+              }),
+              close: use((pool) => pool.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
       ),
-      (client) => client.close().pipe(Effect.orDie),
+      (handle) => handle.client,
     ),
   )

package/src/sql/mssql/mssql.d.ts

@@ -1,3 +1,4 @@
+// types from @types/mssql@9.1.9
 declare module "mssql" {
   export interface config {
     readonly server: string

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/x/tailwind/compile.ts

@@ -20,24 +20,16 @@ export interface CompileOptions {
   customJsResolver?: Resolver
 }
 
-function createCompileOptions({
-  base,
-  from,
-  polyfills,
-  onDependency,
-
-  customCssResolver,
-  customJsResolver,
-}: CompileOptions) {
+function createCompileOptions(options: CompileOptions) {
   return {
-    base,
-    polyfills,
-    from,
+    base: options.base,
+    polyfills: options.polyfills,
+    from: options.from,
     async loadModule(id: string, base: string) {
-      return loadModule(id, base, onDependency, customJsResolver)
+      return loadModule(id, base, options.onDependency, options.customJsResolver)
     },
     async loadStylesheet(id: string, sheetBase: string) {
-      let sheet = await loadStylesheet(id, sheetBase, onDependency, customCssResolver)
+      let sheet = await loadStylesheet(id, sheetBase, options.onDependency, options.customCssResolver)
 
       return sheet
     },

package/src/console/Console.ts

@@ -1,42 +0,0 @@
-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 ConsoleErrors from "./ConsoleErrors.ts"
-import * as ConsoleLogger from "./ConsoleLogger.ts"
-import * as ConsoleMetrics from "./ConsoleMetrics.ts"
-import * as ConsoleProcess from "./ConsoleProcess.ts"
-import * as ConsoleStore from "./ConsoleStore.ts"
-import * as ConsoleTracer from "./ConsoleTracer.ts"
-import consoleRoutes from "./routes/tree.ts"
-
-export { ConsoleStore } from "./ConsoleStore.ts"
-
-export function layer(
-  options?: ConsoleStore.ConsoleStoreOptions,
-): Layer.Layer<ConsoleStore.ConsoleStore> {
-  const store = ConsoleStore.layer(options)
-  return Layer.mergeAll(
-    ConsoleTracer.layer,
-    ConsoleLogger.layer,
-    ConsoleMetrics.layer,
-    ConsoleErrors.layer,
-    ConsoleProcess.layer,
-  ).pipe(Layer.provideMerge(store))
-}
-
-export function routeLayer(
-  prefix: string,
-): Layer.Layer<Route.Routes, never, Route.Routes | ConsoleStore.ConsoleStore> {
-  return Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Route.Routes
-      ConsoleStore.store.prefix = prefix
-      const tree = Route.tree({
-        [prefix as "/"]: consoleRoutes,
-      })
-      return RouteTree.merge(existing, tree)
-    }),
-  )
-}