effect-start 0.26.0 → 0.28.0

package/src/Docker.ts

@@ -0,0 +1,190 @@
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+
+import type * as ChildProcess from "./ChildProcess.ts"
+import * as System from "./System.ts"
+
+export class DockerError extends Data.TaggedError("DockerError")<{
+  message: string
+  cause?: unknown
+}> {}
+
+export interface ExecResult {
+  readonly exitCode: number
+  readonly stdout: string
+}
+
+export interface Container {
+  readonly id: string
+  readonly name?: string
+  readonly ports?: ReadonlyArray<readonly [host: number, container: number]>
+  readonly exec: (
+    command: ReadonlyArray<string>,
+    options?: { readonly detach?: boolean },
+  ) => Effect.Effect<ExecResult, DockerError, ChildProcess.ChildProcessSpawner>
+}
+
+export interface ContainerOptions {
+  readonly image: string
+  readonly name?: string
+  readonly detach?: boolean
+  readonly rm?: boolean
+  readonly env?: Record<string, string>
+  readonly ports?: ReadonlyArray<readonly [host: number, container: number]>
+  readonly args?: ReadonlyArray<string>
+}
+
+export interface DockerService {
+  readonly exec: (
+    container: string,
+    command: ReadonlyArray<string>,
+    options?: { readonly detach?: boolean },
+  ) => Effect.Effect<ExecResult, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly run: (
+    options: ContainerOptions,
+  ) => Effect.Effect<Container, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly start: (
+    container: string,
+  ) => Effect.Effect<void, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly containers: Effect.Effect<ReadonlyArray<Container>>
+}
+
+export class Docker extends Context.Tag("effect-start/Docker")<Docker, DockerService>() {}
+
+export class DockerContainer extends Context.Tag("effect-start/DockerContainer")<
+  DockerContainer,
+  Container
+>() {}
+
+const dockerExec = (...args: ReadonlyArray<string>) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const handle = yield* System.spawn(["docker", ...args], {
+        stdout: "ignore",
+        stderr: "inherit",
+      })
+      return yield* handle.exitCode
+    }),
+  )
+
+const dockerExecStdout = (...args: ReadonlyArray<string>) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const handle = yield* System.spawn(["docker", ...args], {
+        stdout: "pipe",
+        stderr: "inherit",
+      })
+      const [stdout, exitCode] = yield* Effect.all(
+        [handle.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString), handle.exitCode],
+        { concurrency: 2 },
+      )
+      return { stdout, exitCode }
+    }),
+  )
+
+const removeContainer = (container: string) => dockerExec("rm", "-f", container).pipe(Effect.ignore)
+
+export const layer = Layer.scoped(
+  Docker,
+  Effect.gen(function* () {
+    const tracked = yield* Ref.make<ReadonlyArray<Container>>([])
+
+    yield* Effect.addFinalizer(() =>
+      Ref.get(tracked).pipe(
+        Effect.flatMap((containers) =>
+          Effect.forEach(containers, (c) => removeContainer(c.id), { discard: true }),
+        ),
+      ),
+    )
+
+    const track = (container: Container) => Ref.update(tracked, (cs) => [container, ...cs])
+
+    const execFn = (
+      container: string,
+      command: ReadonlyArray<string>,
+      options?: { readonly detach?: boolean },
+    ) =>
+      Effect.gen(function* () {
+        const args: Array<string> = ["exec"]
+        if (options?.detach) args.push("-d")
+        args.push(container, ...command)
+
+        const result = yield* dockerExecStdout(...args).pipe(
+          Effect.mapError((cause) => new DockerError({ message: `docker exec failed`, cause })),
+        )
+
+        return { exitCode: result.exitCode, stdout: result.stdout.trim() } satisfies ExecResult
+      })
+
+    return {
+      exec: execFn,
+
+      run: (options) =>
+        Effect.gen(function* () {
+          const args: Array<string> = ["run"]
+
+          if (options.detach) args.push("-d")
+          if (options.rm) args.push("--rm")
+          if (options.name) args.push("--name", options.name)
+
+          if (options.env) {
+            for (const [k, v] of Object.entries(options.env)) {
+              args.push("-e", `${k}=${v}`)
+            }
+          }
+
+          if (options.ports) {
+            for (const [host, container] of options.ports) {
+              args.push("-p", `${host}:${container}`)
+            }
+          }
+
+          args.push(options.image)
+
+          if (options.args) args.push(...options.args)
+
+          const result = yield* dockerExecStdout(...args).pipe(
+            Effect.mapError((cause) => new DockerError({ message: `docker run failed`, cause })),
+          )
+
+          const id = result.stdout.trim()
+          const container: Container = {
+            id,
+            name: options.name,
+            ports: options.ports,
+            exec: (command, execOptions) => execFn(id, command, execOptions),
+          }
+
+          if (!options.rm) {
+            yield* track(container)
+          }
+
+          return container
+        }),
+
+      start: (container) =>
+        Effect.gen(function* () {
+          const code = yield* dockerExec("start", container).pipe(
+            Effect.mapError((cause) => new DockerError({ message: `docker start failed`, cause })),
+          )
+          if (code !== 0) {
+            yield* Effect.fail(
+              new DockerError({ message: `docker start exited with code ${code}` }),
+            )
+          }
+        }),
+
+      containers: Ref.get(tracked),
+    } satisfies DockerService
+  }),
+)
+
+export const layerContainer = (options: ContainerOptions) =>
+  Layer.effect(
+    DockerContainer,
+    Effect.flatMap(Docker, (docker) => docker.run(options)),
+  )

package/src/Effectify.ts

@@ -269,16 +269,13 @@ export const effectify: {
   (...args: Array<any>) =>
     Effect.async<any, any>((resume) => {
       try {
-        fn(
-          ...args,
-          (err: any, result: any) => {
-            if (err) {
-              resume(Effect.fail(onError ? onError(err, args) : err))
-            } else {
-              resume(Effect.succeed(result))
-            }
-          },
-        )
+        fn(...args, (err: any, result: any) => {
+          if (err) {
+            resume(Effect.fail(onError ? onError(err, args) : err))
+          } else {
+            resume(Effect.succeed(result))
+          }
+        })
       } catch (err) {
         resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
       }

package/src/Entity.ts

@@ -1,6 +1,6 @@
+import * as Effectable from "effect/Effectable"
 import * as Effect from "effect/Effect"
 import * as ParseResult from "effect/ParseResult"
-import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
@@ -24,7 +24,7 @@ export type Headers = {
   [header: string]: string | null | undefined
 }
 
-export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
+export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T, E>, E> {
   readonly [TypeId]: TypeId
   readonly body: T
   readonly headers: Headers
@@ -57,7 +57,7 @@ export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
     : Stream.Stream<Uint8Array, ParseResult.ParseError | E>
 }
 
-export interface Proto extends Pipeable.Pipeable {
+export interface Proto extends Effect.Effect<Entity, never> {
   readonly [TypeId]: TypeId
 }
 
@@ -218,11 +218,11 @@ function getStream(self: Entity<unknown, unknown>): Stream.Stream<unknown, unkno
   return Stream.fromEffect(getBytes(self))
 }
 
-const Proto: Proto = Object.defineProperties(Object.create(null), {
+const Proto: Proto = Object.defineProperties(Object.create(Effectable.CommitPrototype), {
   [TypeId]: { value: TypeId },
-  pipe: {
+  commit: {
     value: function (this: Entity) {
-      return Pipeable.pipeArguments(this, arguments)
+      return resolve(this)
     },
   },
   text: {

package/src/FileRouterCodegen.ts

@@ -166,14 +166,14 @@ export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string |
   }
 
   const routeEntries = entries
-    .map(({ path, loaders }) => {
-      const loadersCode = loaders.join(",\n    ")
-      return `  "${path}": [\n    ${loadersCode},\n  ]`
+    .map((v) => {
+      const loadersCode = v.loaders.join(",\n    ")
+      return `  "${v.path}": [\n    ${loadersCode},\n  ]`
     })
     .join(",\n")
 
   return `/**
- * Auto-generated by effect-start.
+ * Auto-generated by effect-start on startup and changes. Do not edit manually.
  */
 
 export default {

package/src/FileSystem.ts

@@ -342,16 +342,9 @@ export const make = (
   })
 }
 
-const fileStream = (
-  file: File,
-  {
-    bufferSize = 16,
-    bytesToRead: bytesToRead_,
-    chunkSize: chunkSize_ = Size(64 * 1024),
-  }: StreamOptions = {},
-) => {
-  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
-  const chunkSize = Size(chunkSize_)
+const fileStream = (file: File, options: StreamOptions = {}) => {
+  const bytesToRead = options.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
+  const chunkSize = Size(options.chunkSize ?? 64 * 1024)
 
   function loop(
     totalBytesRead: bigint,
@@ -385,6 +378,6 @@ const fileStream = (
   }
 
   return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
-    capacity: bufferSize,
+    capacity: options.bufferSize ?? 16,
   })
 }

package/src/GlobalLayer.ts

@@ -0,0 +1,85 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import type * as Fiber from "effect/Fiber"
+import * as GlobalValue from "effect/GlobalValue"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+
+import * as ChildProcess from "./ChildProcess.ts"
+
+interface CacheEntry {
+  readonly context: Context.Context<any>
+  readonly fiber: Fiber.RuntimeFiber<void>
+}
+
+const cache = GlobalValue.globalValue(Symbol.for("effect-start/GlobalLayer/cache"), () =>
+  MutableRef.make(HashMap.empty<string, CacheEntry>()),
+)
+
+export const globalLayer =
+  (key: string) =>
+  <A, E>(
+    layer: Layer.Layer<A, E> | Layer.Layer<A, E, ChildProcess.ChildProcessSpawner>,
+  ): Layer.Layer<A, E> => {
+    const existing = HashMap.get(MutableRef.get(cache), key)
+    if (existing._tag === "Some") {
+      return Layer.succeedContext(existing.value.context) as Layer.Layer<A, E>
+    }
+
+    return Layer.scopedContext(
+      Effect.gen(function* () {
+        const cached = HashMap.get(MutableRef.get(cache), key)
+        if (cached._tag === "Some") {
+          return cached.value.context as Context.Context<A>
+        }
+
+        const spawner = yield* Effect.serviceOption(ChildProcess.ChildProcessSpawner)
+        const deferred = yield* Deferred.make<Context.Context<A>, E>()
+
+        const parentRuntime = yield* Effect.runtime<never>()
+
+        const defaultRuntime = Runtime.make({
+          // Empty service context — no custom services leak into the forked fiber
+          context: Context.empty(),
+
+          // Bit flags for runtime behavior (interruption, cooperative yielding, etc.)
+          runtimeFlags: parentRuntime.runtimeFlags,
+
+          // Per-fiber state like logger config, tracer settings, span annotations.
+          // Default services are wired through FiberRefs, not the service context.
+          fiberRefs: parentRuntime.fiberRefs,
+        })
+
+        const fiber = Runtime.runFork(defaultRuntime)(
+          Effect.scoped(
+            Effect.gen(function* () {
+              const scope = yield* Effect.scope
+              const memoMap = yield* Layer.makeMemoMap
+              const ctx = yield* (layer as Layer.Layer<A, E>).pipe(
+                Layer.buildWithMemoMap(memoMap, scope),
+                Option.isSome(spawner)
+                  ? Effect.provideService(ChildProcess.ChildProcessSpawner, spawner.value)
+                  : (a) => a,
+              )
+              yield* Deferred.succeed(deferred, ctx)
+              yield* Effect.never
+            }),
+          ),
+        ) as Fiber.RuntimeFiber<void>
+
+        const ctx = yield* Deferred.await(deferred)
+
+        MutableRef.update(cache, HashMap.set(key, { context: ctx, fiber } as CacheEntry))
+
+        fiber.addObserver(() => {
+          MutableRef.update(cache, HashMap.remove(key))
+        })
+
+        return ctx
+      }),
+    )
+  }

package/src/PlatformRuntime.ts

@@ -6,8 +6,15 @@ import type * as FiberId from "effect/FiberId"
 import * as FiberRef from "effect/FiberRef"
 import * as FiberRefs from "effect/FiberRefs"
 import * as Function from "effect/Function"
+import * as GlobalValue from "effect/GlobalValue"
 import * as HashSet from "effect/HashSet"
 import * as Logger from "effect/Logger"
+import * as MutableRef from "effect/MutableRef"
+
+export const mainFiber = GlobalValue.globalValue(
+  Symbol.for("effect-start/PlatformRuntime/mainFiber"),
+  () => MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
+)
 
 export interface Teardown {
   <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void
@@ -95,6 +102,6 @@ export function isAgentHarness() {
   return (
     typeof process !== "undefined" &&
     !process.stdout.isTTY &&
-    (process.env.CLAUDECODE || process.env.CURSOR_AGENT)
+    (process.env.CLAUDECODE || process.env.CURSOR_AGENT || process.env.CODEX_THREAD_ID)
   )
 }

package/src/RouteHook.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import type * as Utils from "effect/Utils"
-import * as Entity from "./Entity.ts"
+import type * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
 
 export type FilterResult<BOut, E, R> = { context: BOut } | Effect.Effect<{ context: BOut }, E, R>
@@ -34,7 +34,7 @@ export function filter<
 
           const mergedContext = filterResult ? { ...context, ...filterResult.context } : context
 
-          return yield* Entity.resolve(next(mergedContext as Partial<BOut>))
+          return yield* next(mergedContext as Partial<BOut>)
         }),
     )
 

package/src/RouteSse.ts

@@ -13,7 +13,7 @@ const HEARTBEAT = ": <3\n\n"
 
 export interface SseEvent {
   data?: string | undefined
-  event?: string
+  type?: string
   retry?: number
 }
 
@@ -35,8 +35,8 @@ function formatSseEvent(event: SseEventInput): string {
 
   const e = event as SseEvent
   let result = ""
-  if (e.event) {
-    result += `event: ${e.event}\n`
+  if (e.type) {
+    result += `event: ${e.type}\n`
   }
   if (typeof e.data === "string") {
     for (const line of e.data.split("\n")) {

package/src/SqlIntrospect.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import * as Sql from "./sql/Sql.ts"
+import * as SqlClient from "./sql/SqlClient.ts"
 
 export interface Column {
   readonly tableSchema: string
@@ -336,9 +336,9 @@ const normalizeBooleans = (columns: ReadonlyArray<Column>): ReadonlyArray<Column
 export const introspect = (
   dialect: Dialect,
   options?: IntrospectOptions,
-): Effect.Effect<DatabaseSchema, Sql.SqlError, Sql.SqlClient> =>
+): Effect.Effect<DatabaseSchema, SqlClient.SqlError, SqlClient.SqlClient> =>
   Effect.gen(function* () {
-    const sql = yield* Sql.SqlClient
+    const sql = yield* SqlClient.SqlClient
     const q = dialectQueries[dialect]
     const columns = normalizeBooleans(yield* sql.unsafe<Column>(q.columns))
     const foreignKeys =
@@ -481,11 +481,13 @@ export interface TableReader {
   readonly sortableColumns: ReadonlyArray<string>
   readonly findAll: (
     options?: FindAllOptions,
-  ) => Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError, Sql.SqlClient>
-  readonly findById: (id: unknown) => Effect.Effect<unknown | null, Sql.SqlError, Sql.SqlClient>
+  ) => Effect.Effect<ReadonlyArray<unknown>, SqlClient.SqlError, SqlClient.SqlClient>
+  readonly findById: (
+    id: unknown,
+  ) => Effect.Effect<unknown | null, SqlClient.SqlError, SqlClient.SqlClient>
   readonly count: (options?: {
     readonly filters?: ReadonlyArray<Filter>
-  }) => Effect.Effect<number, Sql.SqlError, Sql.SqlClient>
+  }) => Effect.Effect<number, SqlClient.SqlError, SqlClient.SqlClient>
 }
 
 export interface DatabaseReader {
@@ -496,9 +498,9 @@ export interface DatabaseReader {
 const escapeIdentifier = (id: string): string => `"${id.replace(/"/g, '""')}"`
 
 const concatSql = (
-  sql: Sql.SqlQuery,
+  sql: SqlClient.Connection,
   fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }>,
-): Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError> => {
+): Effect.Effect<ReadonlyArray<unknown>, SqlClient.SqlError> => {
   const strings: Array<string> = []
   const values: Array<unknown> = []
   for (let i = 0; i < fragments.length; i++) {
@@ -559,7 +561,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
     sortableColumns: Array.from(sortableSet),
     findAll: (options) =>
       Effect.gen(function* () {
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
           literal(`SELECT ${selectCols} FROM ${qualifiedName}`),
         ]
@@ -581,7 +583,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
     findById: (id) =>
       Effect.gen(function* () {
         if (!primaryKey) return null
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const pkCol = escapeIdentifier(primaryKey.columnName)
         const rows = yield* concatSql(sql, [
           literal(`SELECT ${selectCols} FROM ${qualifiedName} WHERE ${pkCol} = `),
@@ -591,7 +593,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
       }),
     count: (options) =>
       Effect.gen(function* () {
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
           literal(`SELECT COUNT(*) as count FROM ${qualifiedName}`),
         ]

package/src/Start.ts

@@ -2,13 +2,20 @@ import type * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as SynchronizedRef from "effect/SynchronizedRef"
 import type * as ChildProcess from "./ChildProcess.ts"
+import * as MutableRef from "effect/MutableRef"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
+import * as PlatformRuntime from "./PlatformRuntime.ts"
 import * as StartApp from "./StartApp.ts"
 
 export function layer<
@@ -45,7 +52,7 @@ export function layer<
  * @category constructors
  */
 export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-  ...layers: Layers
+  ...layers: Layers & OrderedPack<NoInfer<Layers>, NoInfer<Layers>>
 ): Layer.Layer<
   { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number],
   { [K in keyof Layers]: Layer.Layer.Error<Layers[K]> }[number],
@@ -64,6 +71,105 @@ export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<La
   return result as AnyLayer
 }
 
+type Unsatisfied<Unmet, Success> = Unmet extends Success ? Unmet : never
+
+type OrderedPack<
+  Layers extends readonly Layer.Layer.Any[],
+  All extends readonly Layer.Layer.Any[],
+> = Layers extends readonly [
+  infer Head extends Layer.Layer.Any,
+  ...infer Tail extends Layer.Layer.Any[],
+]
+  ? [
+      [
+        Unsatisfied<
+          Exclude<
+            Layer.Layer.Context<Head>,
+            { [K in keyof Tail]: Layer.Layer.Success<Tail[K]> }[number]
+          >,
+          { [K in keyof All]: Layer.Layer.Success<All[K]> }[number]
+        >,
+      ] extends [never]
+        ? Head
+        : never,
+      ...OrderedPack<Tail, All>,
+    ]
+  : []
+
+/**
+ * Like `pack`, but accepts layers in any order.
+ *
+ * ```ts
+ * // These all produce the same result:
+ * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
+ * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+type BuildSuccess<Layers extends readonly Layer.Layer.Any[]> = {
+  [K in keyof Layers]: Layer.Layer.Success<Layers[K]>
+}[number]
+
+type BuildError<Layers extends readonly Layer.Layer.Any[]> = {
+  [K in keyof Layers]: Layer.Layer.Error<Layers[K]>
+}[number]
+
+type BuildContext<Layers extends readonly Layer.Layer.Any[]> = Exclude<
+  { [K in keyof Layers]: Layer.Layer.Context<Layers[K]> }[number],
+  { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
+>
+
+export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+  ...layers: Layers
+): Layer.Layer<BuildSuccess<Layers>, BuildError<Layers>, BuildContext<Layers>> {
+  type AnyLayer = Layer.Layer<any, any, any>
+  const layerArray = layers as unknown as ReadonlyArray<AnyLayer>
+
+  return Layer.scopedContext(
+    Effect.gen(function* () {
+      const scope = yield* Effect.scope
+      const memoMap = yield* Layer.makeMemoMap
+      const memoMapRef = (memoMap as any).ref as SynchronizedRef.SynchronizedRef<Map<AnyLayer, any>>
+      let ctx = yield* Effect.context<any>()
+      const pending = new Set<AnyLayer>(layerArray)
+
+      for (let pass = 0; pass < layerArray.length && pending.size > 0; pass++) {
+        for (const layer of pending) {
+          const childScope = yield* Scope.fork(scope, ExecutionStrategy.sequential)
+          const exit = yield* layer.pipe(
+            Layer.buildWithMemoMap(memoMap, childScope),
+            Effect.provide(ctx),
+            Effect.exit,
+          )
+          if (Exit.isSuccess(exit)) {
+            ctx = Context.merge(ctx, exit.value)
+            pending.delete(layer)
+          } else {
+            yield* Scope.close(childScope, exit)
+            yield* SynchronizedRef.update(memoMapRef, (map) => {
+              map.delete(layer)
+              return map
+            })
+          }
+        }
+      }
+
+      for (const layer of pending) {
+        const childScope = yield* Scope.fork(scope, ExecutionStrategy.sequential)
+        const built = yield* layer.pipe(
+          Layer.buildWithMemoMap(memoMap, childScope),
+          Effect.provide(ctx),
+        )
+        ctx = Context.merge(ctx, built)
+      }
+
+      return ctx
+    }),
+  )
+}
+
 export type PlatformServices =
   | BunServer.BunServer
   | FileSystem.FileSystem
@@ -105,3 +211,8 @@ export function serve<ROut, E, RIn extends PlatformServices>(
 
   return Function.pipe(composed, Layer.launch, BunRuntime.runMain)
 }
+
+export const mainFiberId: Effect.Effect<FiberId.FiberId> = Effect.sync(() => {
+  const fiber = MutableRef.get(PlatformRuntime.mainFiber)
+  return fiber ? fiber.id() : FiberId.none
+})