effect-start 0.28.0 → 0.29.0

package/src/lint/plugin.js

@@ -9,19 +9,19 @@ export default {
     version: "0.1.0",
   },
   rules: {
-    "prefer-namespace-import": {
+    "namespace-import": {
       meta: {
         type: "suggestion",
         docs: {
           description:
-            "Enforce namespace imports for modules with capitalized base names or specific forced modules",
+            "Enforce namespace imports with matching aliases for capitalized modules and specific forced modules",
         },
-        fixable: "code",
-        hasSuggestions: true,
         schema: [],
         messages: {
           preferNamespace:
-            'Use namespace import for module "{{source}}": import {{typePrefix}}* as {{baseName}} from "{{source}}"',
+            'Use namespace import for module "{{source}}": import * as {{baseName}} from "{{source}}"',
+          mismatch:
+            'Namespace import alias "{{alias}}" does not match module basename "{{baseName}}"',
         },
       },
       create(context) {
@@ -36,58 +36,33 @@ export default {
             const forced = forceNamespace.has(source)
             if (!forced && !isCapitalized(baseName)) return
 
-            // Already a namespace import (with or without type-only)
-            if (
-              node.specifiers.length === 1 &&
-              node.specifiers[0].type === "ImportNamespaceSpecifier"
-            ) {
+            const isNamespace =
+              node.specifiers.length === 1 && node.specifiers[0].type === "ImportNamespaceSpecifier"
+
+            if (isNamespace) {
+              if (!isLocalImport(source)) return
+              const alias = node.specifiers[0].local.name
+              if (alias === baseName) return
+
+              context.report({
+                node,
+                messageId: "mismatch",
+                data: { alias, baseName },
+              })
               return
             }
 
-            // Skip if there are no specifiers (side-effect import)
             if (node.specifiers.length === 0) return
 
-            // Skip if it's only a default import (not applicable for forced modules)
             if (!forced) {
               const hasNamedImports = node.specifiers.some((s) => s.type === "ImportSpecifier")
               if (!hasNamedImports) return
             }
 
-            const typePrefix = node.importKind === "type" ? "type " : ""
-
-            const sourceCode = context.sourceCode || context.getSourceCode()
-
             context.report({
               node,
               messageId: "preferNamespace",
-              data: { source, baseName, typePrefix },
-              fix(fixer) {
-                const fixes = [
-                  fixer.replaceText(node, `import ${typePrefix}* as ${baseName} from "${source}"`),
-                ]
-
-                for (const specifier of node.specifiers) {
-                  if (specifier.type !== "ImportSpecifier") continue
-                  const localName = specifier.local.name
-                  const importedName = specifier.imported.name
-
-                  for (const variable of sourceCode.getDeclaredVariables(specifier)) {
-                    for (const ref of variable.references) {
-                      if (ref.identifier.range[0] === specifier.local.range[0]) continue
-                      fixes.push(
-                        fixer.replaceTextRange(
-                          ref.identifier.range,
-                          localName !== importedName
-                            ? `${baseName}.${importedName}`
-                            : `${baseName}.${localName}`,
-                        ),
-                      )
-                    }
-                  }
-                }
-
-                return fixes
-              },
+              data: { source, baseName },
             })
           },
         }
@@ -339,75 +314,85 @@ export default {
       },
     },
 
-    "namespace-import-mismatch": {
+    "test-effects": {
       meta: {
         type: "suggestion",
         docs: {
           description:
-            "Warn when a namespace import alias doesn't match the basename of the module path",
+            "Disallow await Effect.runPromise(...) in test callbacks. Use Effect.gen(...).pipe(Effect.runPromise) as the return value instead.",
         },
-        fixable: "code",
         schema: [],
         messages: {
-          mismatch:
-            'Namespace import alias "{{alias}}" does not match module basename "{{baseName}}"',
+          noAwaitRunPromise:
+            "Avoid Effect.runPromise in async test callbacks. Use () => Effect.gen(function*() { ... }).pipe(Effect.runPromise) instead.",
+          scopedWrapping: "Use .pipe(Effect.scoped) instead of Effect.scoped(...) wrapping.",
         },
       },
       create(context) {
-        const importNames = new Set()
-
-        return {
-          ImportDeclaration(node) {
-            for (const spec of node.specifiers) {
-              importNames.add(spec.local.name)
-            }
+        const filename = context.filename || context.getFilename()
+        if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
+          return {}
+        }
 
-            const source = node.source.value
-            if (typeof source !== "string") return
+        function isTestCallback(node) {
+          const sourceCode = context.sourceCode || context.getSourceCode()
+          const ancestors = sourceCode.getAncestors(node)
+          const parent = ancestors[ancestors.length - 1]
+          if (!parent || parent.type !== "CallExpression") return false
+          const callee = parent.callee
+          return (
+            callee.type === "MemberExpression" &&
+            callee.object.type === "Identifier" &&
+            callee.object.name === "test" &&
+            callee.property.type === "Identifier" &&
+            (callee.property.name === "it" || callee.property.name === "test")
+          )
+        }
 
+        function findEnclosingAsyncTestCallback(node) {
+          const sourceCode = context.sourceCode || context.getSourceCode()
+          const ancestors = sourceCode.getAncestors(node)
+          for (let i = ancestors.length - 1; i >= 0; i--) {
+            const ancestor = ancestors[i]
             if (
-              node.specifiers.length !== 1 ||
-              node.specifiers[0].type !== "ImportNamespaceSpecifier"
+              (ancestor.type === "ArrowFunctionExpression" ||
+                ancestor.type === "FunctionExpression") &&
+              ancestor.async
             ) {
-              return
+              return isTestCallback(ancestor) ? ancestor : undefined
             }
+          }
+        }
 
-            if (!isLocalImport(source)) return
-
-            const baseName = getBaseName(source)
-            if (!baseName) return
-            if (!isCapitalized(baseName)) return
-
-            const alias = node.specifiers[0].local.name
-            if (alias === baseName) return
-
-            const hasCollision = importNames.has(baseName) && alias !== baseName
-            const sourceCode = context.sourceCode || context.getSourceCode()
-
-            context.report({
-              node,
-              messageId: "mismatch",
-              data: { alias, baseName },
-              fix: hasCollision
-                ? undefined
-                : (fixer) => {
-                    const fixes = [
-                      fixer.replaceText(
-                        node,
-                        `import ${node.importKind === "type" ? "type " : ""}* as ${baseName} from "${source}"`,
-                      ),
-                    ]
-
-                    for (const variable of sourceCode.getDeclaredVariables(node.specifiers[0])) {
-                      for (const ref of variable.references) {
-                        if (ref.identifier.range[0] === node.specifiers[0].local.range[0]) continue
-                        fixes.push(fixer.replaceTextRange(ref.identifier.range, baseName))
-                      }
-                    }
-
-                    return fixes
-                  },
-            })
+        return {
+          CallExpression(node) {
+            if (
+              node.callee.type === "MemberExpression" &&
+              node.callee.object.type === "Identifier" &&
+              node.callee.object.name === "Effect" &&
+              node.callee.property.type === "Identifier" &&
+              node.callee.property.name === "scoped" &&
+              node.arguments.length === 1
+            ) {
+              context.report({
+                node,
+                messageId: "scopedWrapping",
+              })
+            }
+          },
+          MemberExpression(node) {
+            if (
+              node.object.type === "Identifier" &&
+              node.object.name === "Effect" &&
+              node.property.type === "Identifier" &&
+              node.property.name === "runPromise" &&
+              findEnclosingAsyncTestCallback(node)
+            ) {
+              context.report({
+                node,
+                messageId: "noAwaitRunPromise",
+              })
+            }
           },
         }
       },
@@ -610,6 +595,9 @@ function getBaseName(source) {
   // Strip file extension (.ts, .tsx, .js, .jsx, .mjs, .cjs)
   last = last.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "")
 
+  // Strip leading underscores (private module convention)
+  last = last.replace(/^_+/, "")
+
   return last
 }
 
@@ -618,6 +606,7 @@ function isLocalImport(source) {
 }
 
 function isCapitalized(name) {
+  if (name.length > 0 && name[0] === "_") return isCapitalized(name.slice(1))
   return name.length > 0 && name[0] >= "A" && name[0] <= "Z"
 }
 

package/src/node/NodeFileSystem.ts

@@ -12,11 +12,12 @@ import * as NCrypto from "node:crypto"
 import * as NFS from "node:fs"
 import * as NOS from "node:os"
 import * as NPath from "node:path"
-import * as PlatformError from "../PlatformError.ts"
-import * as Effectify from "../Effectify.ts"
+import * as System from "../System.ts"
+import * as Effectify from "../_Effectify.ts"
 
 const handleBadArgument = (method: string) => (cause: unknown) =>
-  new PlatformError.BadArgument({
+  new System.SystemError({
+    reason: "BadArgument",
     module: "FileSystem",
     method,
     cause,
@@ -324,7 +325,7 @@ const makeFile = (() => {
       )
     }
 
-    private writeAllChunk(buffer: Uint8Array): Effect.Effect<void, PlatformError.PlatformError> {
+    private writeAllChunk(buffer: Uint8Array): Effect.Effect<void, System.SystemError> {
       return Effect.flatMap(
         Effect.suspend(() =>
           nodeWriteAll(
@@ -338,7 +339,7 @@ const makeFile = (() => {
         (bytesWritten) => {
           if (bytesWritten === 0) {
             return Effect.fail(
-              new PlatformError.SystemError({
+              new System.SystemError({
                 module: "FileSystem",
                 method: "writeAll",
                 reason: "WriteZero",
@@ -398,7 +399,7 @@ const readDirectory = (path: string, options?: FileSystem.ReadDirectoryOptions)
   })
 
 const readFile = (path: string) =>
-  Effect.async<Uint8Array, PlatformError.PlatformError>((resume, signal) => {
+  Effect.async<Uint8Array, System.SystemError>((resume, signal) => {
     try {
       NFS.readFile(path, { signal }, (err, data) => {
         if (err) {
@@ -508,7 +509,7 @@ const utimes = (() => {
 })()
 
 const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
-  Stream.asyncScoped<FileSystem.WatchEvent, PlatformError.PlatformError>((emit) =>
+  Stream.asyncScoped<FileSystem.WatchEvent, System.SystemError>((emit) =>
     Effect.acquireRelease(
       Effect.sync(() => {
         const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
@@ -534,7 +535,7 @@ const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
         })
         watcher.on("error", (error) => {
           emit.fail(
-            new PlatformError.SystemError({
+            new System.SystemError({
               module: "FileSystem",
               reason: "Unknown",
               method: "watch",
@@ -568,7 +569,7 @@ const watch = (
   )
 
 const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFileOptions) =>
-  Effect.async<void, PlatformError.PlatformError>((resume, signal) => {
+  Effect.async<void, System.SystemError>((resume, signal) => {
     try {
       NFS.writeFile(
         path,
@@ -624,14 +625,14 @@ const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend)
 
 export const layer = Layer.effect(FileSystem.FileSystem, make)
 
-export { PlatformError as Error }
+export { System as Error }
 
-export function handleErrnoException(module: PlatformError.SystemError["module"], method: string) {
+export function handleErrnoException(module: System.SystemError["module"], method: string) {
   return function (
     err: NodeJS.ErrnoException,
     [path]: [path: NFS.PathLike | number, ...args: Array<any>],
-  ): PlatformError.PlatformError {
-    let reason: PlatformError.SystemErrorReason = "Unknown"
+  ): System.SystemError {
+    let reason: System.SystemErrorReason = "Unknown"
 
     switch (err.code) {
       case "ENOENT":
@@ -663,7 +664,7 @@ export function handleErrnoException(module: PlatformError.SystemError["module"]
         break
     }
 
-    return new PlatformError.SystemError({
+    return new System.SystemError({
       reason,
       module,
       method,

package/src/sql/SqlCache.ts

@@ -9,10 +9,23 @@ type SqlCacheInstance = Cache.Cache<string, ReadonlyArray<any>>
 
 export class SqlCache extends Context.Tag("effect-start/SqlCache")<SqlCache, SqlCacheInstance>() {}
 
+export function layer(cache: SqlCacheInstance): Layer.Layer<SqlCache>
 export function layer(options: {
   readonly capacity: number
   readonly timeToLive: Duration.DurationInput
-}): Layer.Layer<SqlCache> {
+}): Layer.Layer<SqlCache>
+export function layer(
+  cacheOrOptions:
+    | SqlCacheInstance
+    | { readonly capacity: number; readonly timeToLive: Duration.DurationInput },
+): Layer.Layer<SqlCache> {
+  if (Cache.CacheTypeId in cacheOrOptions) {
+    return Layer.succeed(SqlCache, cacheOrOptions as SqlCacheInstance)
+  }
+  const options = cacheOrOptions as {
+    readonly capacity: number
+    readonly timeToLive: Duration.DurationInput
+  }
   return Layer.effect(
     SqlCache,
     Cache.make<string, ReadonlyArray<any>>({

package/src/sql/SqlClient.ts

@@ -6,7 +6,7 @@ import * as Exit from "effect/Exit"
 import * as FiberRef from "effect/FiberRef"
 import * as GlobalValue from "effect/GlobalValue"
 import type * as Scope from "effect/Scope"
-import * as Values from "../Values.ts"
+import * as Values from "../_Values.ts"
 
 export class SqlError extends Data.TaggedError("SqlError")<{
   readonly code: string

package/src/{SqlIntrospect.ts → sql/SqlIntrospect.ts}

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import * as SqlClient from "./sql/SqlClient.ts"
+import * as SqlClient from "./SqlClient.ts"
 
 export interface Column {
   readonly tableSchema: string

package/src/sql/bun/index.ts

@@ -5,7 +5,7 @@ import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as SqlClient from "../SqlClient.ts"
-import * as Values from "../../Values.ts"
+import * as Values from "../../_Values.ts"
 
 const errorCode = (error: unknown): string => {
   const e = error as any

package/src/sql/index.ts

@@ -1,2 +1,3 @@
 export * as SqlCache from "./SqlCache.ts"
 export * as SqlClient from "./SqlClient.ts"
+export * as SqlIntrospect from "./SqlIntrospect.ts"

package/src/sql/libsql/index.ts

@@ -7,7 +7,7 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Libsql from "@libsql/client"
 import * as SqlClient from "../SqlClient.ts"
-import * as Values from "../../Values.ts"
+import * as Values from "../../_Values.ts"
 
 type ConfigOrValue<T> = T | Config.Config<T>
 

package/src/sql/mssql/index.ts

@@ -6,7 +6,7 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Mssql from "mssql"
 import * as SqlClient from "../SqlClient.ts"
-import * as Values from "../../Values.ts"
+import * as Values from "../../_Values.ts"
 
 const wrapError = (error: unknown): SqlClient.SqlError =>
   new SqlClient.SqlError({

package/src/studio/Studio.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 "../sql/bun/index.ts"
+import type * as SqlClient from "../sql/SqlClient.ts"
+import * as StudioErrors from "./StudioErrors.ts"
+import * as StudioLogger from "./StudioLogger.ts"
+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"
+
+export function layer(
+  options?: StudioStore.StudioStoreOptions & {
+    readonly sqlLayer?: Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError>
+  },
+): Layer.Layer<StudioStore.StudioStore> {
+  const sqlLayer =
+    options?.sqlLayer ?? sqlBun.layer({ adapter: "sqlite" as const, filename: ":memory:" })
+  const store = StudioStore.layer(options).pipe(Layer.provide(sqlLayer), Layer.orDie)
+  const features = Layer.mergeAll(
+    StudioTracer.layer,
+    StudioLogger.layer,
+    StudioMetrics.layer,
+    StudioErrors.layer,
+    StudioProcess.layer,
+  ).pipe(Layer.provide(store))
+  return Layer.merge(store, features)
+}
+
+export function layerRoutes(options?: { prefix?: string }) {
+  const prefix = options?.prefix ?? "/studio"
+
+  return Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Route.Routes
+      StudioStore.store.prefix = prefix
+      const tree = Route.tree({
+        [prefix as "/"]: consoleRoutes,
+      })
+      return RouteTree.merge(existing, tree)
+    }),
+  )
+}

package/src/{tower/TowerErrors.ts → studio/StudioErrors.ts}

@@ -11,7 +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 TowerStore from "./TowerStore.ts"
+import * as StudioStore from "./StudioStore.ts"
 
 function safeSerialize(value: unknown, depth = 0): unknown {
   if (depth > 4) return "<deep>"
@@ -122,8 +122,8 @@ function extractSpanName(error: unknown): string | undefined {
   return undefined
 }
 
-function extractDetails(cause: Cause.Cause<unknown>): Array<TowerStore.TowerErrorDetail> {
-  const details: Array<TowerStore.TowerErrorDetail> = []
+function extractDetails(cause: Cause.Cause<unknown>): Array<StudioStore.StudioErrorDetail> {
+  const details: Array<StudioStore.StudioErrorDetail> = []
 
   const failures = Chunk.toArray(Cause.failures(cause))
   for (const error of failures) {
@@ -150,7 +150,7 @@ function extractDetails(cause: Cause.Cause<unknown>): Array<TowerStore.TowerErro
   return details
 }
 
-function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
+function make(store: StudioStore.StudioStoreShape): Supervisor.Supervisor<void> {
   return new (class extends Supervisor.AbstractSupervisor<void> {
     value = Effect.void
 
@@ -183,8 +183,8 @@ function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
         annotations[key] = value
       })
 
-      TowerStore.runWrite(
-        TowerStore.upsertFiber(
+      StudioStore.runWrite(
+        StudioStore.upsertFiber(
           store.sql,
           childId,
           parentId !== childId ? parentId : undefined,
@@ -197,17 +197,17 @@ function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
 
     onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>) {
       if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
-        const error: TowerStore.TowerError = {
-          id: TowerStore.nextErrorId(),
+        const error: StudioStore.StudioError = {
+          id: StudioStore.nextErrorId(),
           fiberId: FiberId.threadName(fiber.id()),
           interrupted: Cause.isInterrupted(exit.cause),
           prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
           details: extractDetails(exit.cause),
         }
-        TowerStore.runWrite(
+        StudioStore.runWrite(
           Effect.zipRight(
-            TowerStore.insertError(store.sql, error),
-            TowerStore.evict(store.sql, "Error", store.errorCapacity),
+            StudioStore.insertError(store.sql, error),
+            StudioStore.evict(store.sql, "Error", store.errorCapacity),
           ),
         )
         Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))
@@ -216,9 +216,9 @@ function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
   })()
 }
 
-export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.unwrapEffect(
+export const layer: Layer.Layer<never, never, StudioStore.StudioStore> = Layer.unwrapEffect(
   Effect.gen(function* () {
-    const store = yield* TowerStore.TowerStore
+    const store = yield* StudioStore.StudioStore
     return Supervisor.addSupervisor(make(store))
   }),
 )

package/src/{tower/TowerLogger.ts → studio/StudioLogger.ts}

@@ -5,14 +5,14 @@ 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"
+import * as StudioStore from "./StudioStore.ts"
 
-const towerLogger = Logger.make((options) => {
-  const store = TowerStore.store
+const studioLogger = Logger.make((options) => {
+  const store = StudioStore.store
   if (!store.sql) return
 
   try {
-    const levelMap: Record<string, TowerStore.TowerLog["level"]> = {
+    const levelMap: Record<string, StudioStore.StudioLog["level"]> = {
       Debug: "DEBUG",
       Info: "INFO",
       Warning: "WARNING",
@@ -30,8 +30,8 @@ const towerLogger = Logger.make((options) => {
       ann[k] = v
     })
 
-    const log: TowerStore.TowerLog = {
-      id: TowerStore.nextLogId(),
+    const log: StudioStore.StudioLog = {
+      id: StudioStore.nextLogId(),
       level,
       message: String(options.message),
       fiberId: FiberId.threadName(options.fiberId),
@@ -39,14 +39,14 @@ const towerLogger = Logger.make((options) => {
       spans: spanNames,
       annotations: ann,
     }
-    TowerStore.runWrite(
+    StudioStore.runWrite(
       Effect.zipRight(
-        TowerStore.insertLog(store.sql, log),
-        TowerStore.evict(store.sql, "Log", store.logCapacity),
+        StudioStore.insertLog(store.sql, log),
+        StudioStore.evict(store.sql, "Log", store.logCapacity),
       ),
     )
     Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))
   } catch (_) {}
 })
 
-export const layer = Logger.add(towerLogger)
+export const layer = Logger.add(studioLogger)

package/src/{tower/TowerMetrics.ts → studio/StudioMetrics.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 TowerStore from "./TowerStore.ts"
+import * as StudioStore from "./StudioStore.ts"
 
-export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.scopedDiscard(
+export const layer: Layer.Layer<never, never, StudioStore.StudioStore> = Layer.scopedDiscard(
   Effect.gen(function* () {
-    const store = yield* TowerStore.TowerStore
+    const store = yield* StudioStore.StudioStore
 
     yield* Effect.forkScoped(
       Effect.schedule(
         Effect.sync(() => {
           const pairs = Metric.unsafeSnapshot()
-          const snapshots: Array<TowerStore.TowerMetricSnapshot> = []
+          const snapshots: Array<StudioStore.StudioMetricSnapshot> = []
 
           for (const pair of pairs) {
             const key = pair.metricKey
             const state = pair.metricState as any
-            let type: TowerStore.TowerMetricSnapshot["type"] = "counter"
+            let type: StudioStore.StudioMetricSnapshot["type"] = "counter"
             let value: unknown = 0
 
             if (MetricKeyType.CounterKeyTypeTypeId in key.keyType) {

package/src/{tower/TowerProcess.ts → studio/StudioProcess.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 TowerStore from "./TowerStore.ts"
+import * as StudioStore from "./StudioStore.ts"
 
-function snapshot(): TowerStore.ProcessStats {
+function snapshot(): StudioStore.ProcessStats {
   const mem = process.memoryUsage()
   const cpu = process.cpuUsage()
   const res = process.resourceUsage()
@@ -41,9 +41,9 @@ function snapshot(): TowerStore.ProcessStats {
   }
 }
 
-export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.scopedDiscard(
+export const layer: Layer.Layer<never, never, StudioStore.StudioStore> = Layer.scopedDiscard(
   Effect.gen(function* () {
-    const store = yield* TowerStore.TowerStore
+    const store = yield* StudioStore.StudioStore
 
     yield* Effect.forkScoped(
       Effect.schedule(