effect-start 0.19.0 → 0.20.0

package/dist/PlatformError.js

@@ -0,0 +1,43 @@
+import * as Data from "effect/Data";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { TypeId as TypeId_ } from "@effect/platform/Error";
+export const TypeId = TypeId_;
+export const isPlatformError = (u) => Predicate.hasProperty(u, TypeId);
+export const TypeIdError = (typeId, tag) => {
+    class Base extends Data.Error {
+        _tag = tag;
+    }
+    ;
+    Base.prototype[typeId] = typeId;
+    Base.prototype.name = tag;
+    return Base;
+};
+export const Module = Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
+export class BadArgument extends Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect),
+}) {
+    [TypeId] = TypeId;
+    get message() {
+        return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+    }
+}
+export const SystemErrorReason = Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
+export class SystemError extends Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
+    reason: SystemErrorReason,
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    syscall: Schema.optional(Schema.String),
+    pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
+    cause: Schema.optional(Schema.Defect),
+}) {
+    [TypeId] = TypeId;
+    get message() {
+        return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+    }
+}
+export const PlatformError = Schema.Union(BadArgument, SystemError);

package/dist/PlatformRuntime.d.ts

@@ -1,3 +1,26 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import type * as Fiber from "effect/Fiber";
+export interface Teardown {
+    <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void;
+}
+export declare const defaultTeardown: Teardown;
+export interface RunMain {
+    (options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly disablePrettyLogger?: boolean | undefined;
+        readonly teardown?: Teardown | undefined;
+    }): <E, A>(effect: Effect.Effect<A, E>) => void;
+    <E, A>(effect: Effect.Effect<A, E>, options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly disablePrettyLogger?: boolean | undefined;
+        readonly teardown?: Teardown | undefined;
+    }): void;
+}
+export declare const makeRunMain: (f: <E, A>(options: {
+    readonly fiber: Fiber.RuntimeFiber<A, E>;
+    readonly teardown: Teardown;
+}) => void) => RunMain;
 /**
  * Are we running within an agent harness, like Claude Code?
  */

package/dist/PlatformRuntime.js

@@ -1,3 +1,45 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FiberRef from "effect/FiberRef";
+import * as FiberRefs from "effect/FiberRefs";
+import * as Function from "effect/Function";
+import * as HashSet from "effect/HashSet";
+import * as Logger from "effect/Logger";
+export const defaultTeardown = (exit, onExit) => {
+    onExit(Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause) ? 1 : 0);
+};
+const addPrettyLogger = (refs, fiberId) => {
+    const loggers = FiberRefs.getOrDefault(refs, FiberRef.currentLoggers);
+    if (!HashSet.has(loggers, Logger.defaultLogger)) {
+        return refs;
+    }
+    return FiberRefs.updateAs(refs, {
+        fiberId,
+        fiberRef: FiberRef.currentLoggers,
+        value: loggers.pipe(HashSet.remove(Logger.defaultLogger), HashSet.add(Logger.prettyLoggerDefault)),
+    });
+};
+export const makeRunMain = (f) => Function.dual((args) => Effect.isEffect(args[0]), (effect, options) => {
+    const fiber = options?.disableErrorReporting === true
+        ? Effect.runFork(effect, {
+            updateRefs: options?.disablePrettyLogger === true
+                ? undefined
+                : addPrettyLogger,
+        })
+        : Effect.runFork(Effect.tapErrorCause(effect, (cause) => {
+            if (Cause.isInterruptedOnly(cause)) {
+                return Effect.void;
+            }
+            return Effect.logError(cause);
+        }), {
+            updateRefs: options?.disablePrettyLogger === true
+                ? undefined
+                : addPrettyLogger,
+        });
+    const teardown = options?.teardown ?? defaultTeardown;
+    return f({ fiber, teardown });
+});
 /**
  * Are we running within an agent harness, like Claude Code?
  */

package/dist/RouteBody.d.ts

@@ -8,7 +8,7 @@ export type Format = "text" | "html" | "json" | "bytes" | "*";
 type UnwrapStream<T> = T extends Stream.Stream<infer V, any, any> ? V : T;
 type YieldError<T> = T extends Utils.YieldWrap<Effect.Effect<any, infer E, any>> ? E : never;
 type YieldContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never;
-export type GeneratorHandler<B, A, Y> = (context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>) => Generator<Y, A | Entity.Entity<A>, unknown>;
+export type GeneratorHandler<B, A, Y> = (context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>) => Generator<Y, A | Entity.Entity<A>, never>;
 export type HandlerInput<B, A, E, R> = A | Entity.Entity<A> | Effect.Effect<A | Entity.Entity<A>, E, R> | ((context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>) => Effect.Effect<A | Entity.Entity<A>, E, R> | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, A | Entity.Entity<A>, unknown>);
 export declare function handle<B, A, Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>>(handler: GeneratorHandler<B, A, Y>): Route.Route.Handler<B, A, YieldError<Y>, YieldContext<Y>>;
 export declare function handle<B, A, E, R>(handler: HandlerInput<B, A, E, R>): Route.Route.Handler<B, A, E, R>;

package/dist/Start.d.ts

@@ -1,5 +1,6 @@
+import * as FileSystem from "@effect/platform/FileSystem";
 import * as Layer from "effect/Layer";
-import * as BunHttpServer from "./bun/BunHttpServer.ts";
+import * as BunServer from "./bun/BunServer.ts";
 export declare function layer<Layers extends [
     Layer.Layer<never, any, any>,
     ...Array<Layer.Layer<never, any, any>>
@@ -10,6 +11,36 @@ export declare function layer<Layers extends [
 }[number], {
     [k in keyof Layers]: Layer.Layer.Context<Layers[k]>;
 }[number]>;
-export declare function serve<ROut, E>(load: () => Promise<{
-    default: Layer.Layer<ROut, E, BunHttpServer.BunHttpServer>;
+/**
+ * Bundles layers together, wiring their dependencies automatically.
+ *
+ * Equivalent to chaining `Layer.provide` calls, but more concise.
+ *
+ * **Ordering: dependents first, dependencies last.**
+ *
+ * @example
+ * ```ts
+ * // UserRepo needs Database, Database needs Logger
+ * const AppLayer = Start.pack(
+ *   UserRepoLive,   // needs Database, Logger
+ *   DatabaseLive,   // needs Logger
+ *   LoggerLive,     // no deps
+ * )
+ * // Result: Layer<UserRepo | Database | Logger, never, never>
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(...layers: Layers): Layer.Layer<{
+    [K in keyof Layers]: Layer.Layer.Success<Layers[K]>;
+}[number], {
+    [K in keyof Layers]: Layer.Layer.Error<Layers[K]>;
+}[number], Exclude<{
+    [K in keyof Layers]: Layer.Layer.Context<Layers[K]>;
+}[number], {
+    [K in keyof Layers]: Layer.Layer.Success<Layers[K]>;
+}[number]>>;
+export declare function serve<ROut, E, RIn extends BunServer.BunServer | FileSystem.FileSystem>(load: () => Promise<{
+    default: Layer.Layer<ROut, E, RIn>;
 }>): void;

package/dist/Start.js

@@ -1,16 +1,41 @@
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as BunHttpServer from "./bun/BunHttpServer.js";
 import * as BunRuntime from "./bun/BunRuntime.js";
-import * as StartApp from "./StartApp.js";
+import * as BunServer from "./bun/BunServer.js";
+import * as NodeFileSystem from "./node/NodeFileSystem.js";
 export function layer(...layers) {
     return Layer.mergeAll(...layers);
 }
+/**
+ * Bundles layers together, wiring their dependencies automatically.
+ *
+ * Equivalent to chaining `Layer.provide` calls, but more concise.
+ *
+ * **Ordering: dependents first, dependencies last.**
+ *
+ * @example
+ * ```ts
+ * // UserRepo needs Database, Database needs Logger
+ * const AppLayer = Start.pack(
+ *   UserRepoLive,   // needs Database, Logger
+ *   DatabaseLive,   // needs Logger
+ *   LoggerLive,     // no deps
+ * )
+ * // Result: Layer<UserRepo | Database | Logger, never, never>
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function pack(...layers) {
+    const layerArray = layers;
+    const result = layerArray.reduce((acc, layer) => Layer.provideMerge(acc, layer), Layer.succeedContext(Context.empty()));
+    return result;
+}
 export function serve(load) {
     const appLayer = Function.pipe(Effect.tryPromise(load), Effect.map(v => v.default), Effect.orDie, Layer.unwrapEffect);
-    return Function.pipe(BunHttpServer.layerAuto(), Layer.provide(appLayer), Layer.provide([
-        BunHttpServer.layer(),
-        StartApp.layer(),
-    ]), Layer.launch, BunRuntime.runMain);
+    const composed = Function.pipe(BunServer.layer(), BunServer.withLogAddress, Layer.provide(appLayer), Layer.provide(NodeFileSystem.layer), Layer.provide(BunServer.layer()));
+    return Function.pipe(composed, Layer.launch, BunRuntime.runMain);
 }

package/dist/bun/BunPlatformHttpServer.d.ts

@@ -0,0 +1,10 @@
+import * as HttpServer from "@effect/platform/HttpServer";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import * as BunServer from "./BunServer.ts";
+/**
+ * From times when we used @effect/platform
+ * Not used any more internally. Kept for the future,
+ * in case someone will need it for whatever reason. [2026]
+ */
+export declare const make: Effect.Effect<HttpServer.HttpServer, never, Scope.Scope | BunServer.BunServer>;

package/dist/bun/BunPlatformHttpServer.js

@@ -0,0 +1,53 @@
+import * as HttpApp from "@effect/platform/HttpApp";
+import * as HttpServer from "@effect/platform/HttpServer";
+import * as HttpServerError from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import * as BunServer from "./BunServer.js";
+import * as BunServerRequest from "./BunServerRequest.js";
+/**
+ * From times when we used @effect/platform
+ * Not used any more internally. Kept for the future,
+ * in case someone will need it for whatever reason. [2026]
+ */
+export const make = Effect.gen(function* () {
+    const bunServer = yield* BunServer.BunServer;
+    return HttpServer.make({
+        address: {
+            _tag: "TcpAddress",
+            port: bunServer.server.port,
+            hostname: bunServer.server.hostname,
+        },
+        serve(httpApp, middleware) {
+            return Effect.gen(function* () {
+                const runFork = yield* FiberSet.makeRuntime();
+                const runtime = yield* Effect.runtime();
+                const app = HttpApp.toHandled(httpApp, (request, response) => Effect.sync(() => {
+                    ;
+                    request.resolve(BunServerRequest.makeResponse(request, response, runtime));
+                }), middleware);
+                function handler(request, server) {
+                    return new Promise((resolve, _reject) => {
+                        const fiber = runFork(Effect.provideService(app, HttpServerRequest.HttpServerRequest, new BunServerRequest.ServerRequestImpl(request, resolve, removeHost(request.url), server)));
+                        request.signal.addEventListener("abort", () => {
+                            runFork(fiber.interruptAsFork(HttpServerError.clientAbortFiberId));
+                        }, { once: true });
+                    });
+                }
+                yield* Effect.acquireRelease(Effect.sync(() => {
+                    bunServer.pushHandler(handler);
+                }), () => Effect.sync(() => {
+                    bunServer.popHandler();
+                }));
+            });
+        },
+    });
+});
+const removeHost = (url) => {
+    if (url[0] === "/") {
+        return url;
+    }
+    const index = url.indexOf("/", url.indexOf("//") + 2);
+    return index === -1 ? "/" : url.slice(index);
+};

package/dist/bun/BunRoute.d.ts

@@ -1,7 +1,7 @@
 import type * as Bun from "bun";
 import * as Option from "effect/Option";
 import * as Route from "../Route.ts";
-import * as BunHttpServer from "./BunHttpServer.ts";
+import * as BunServer from "./BunServer.ts";
 declare const BunRouteError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
     readonly _tag: "BunRouteError";
 } & Readonly<A>;
@@ -22,7 +22,7 @@ export declare function htmlBundle(load: () => Promise<Bun.HTMLBundle | {
     format: "html";
 }, {
     request: Request;
-}, string, BunRouteError, BunHttpServer.BunHttpServer>]>;
+}, string, BunRouteError, BunServer.BunServer>]>;
 type BunServerFetchHandler = (request: Request, server: Bun.Server<unknown>) => Response | Promise<Response>;
 type BunServerRouteHandler = Bun.HTMLBundle | BunServerFetchHandler | Partial<Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>>;
 export type BunRoutes = Record<string, BunServerRouteHandler>;
@@ -33,9 +33,7 @@ export type BunRoutes = Record<string, BunServerRouteHandler>;
  * - /exact        - Exact match
  * - /users/:id    - Full-segment named param
  * - /path/*       - Directory wildcard
- * - /*            - Catch-all
- * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
- * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ * - /[[404]]      - Catch-all / Rest
  *
  * Unsupported patterns (cannot be implemented in Bun):
  * - /pk_[id]   - Prefix before param

package/dist/bun/BunRoute.js

@@ -3,12 +3,12 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Entity from "../Entity.js";
+import * as FilePathPattern from "../FilePathPattern.js";
 import * as Hyper from "../hyper/Hyper.js";
 import * as HyperHtml from "../hyper/HyperHtml.js";
-import * as Unique from "../Unique.js";
 import * as Route from "../Route.js";
-import * as RouterPattern from "../RouterPattern.js";
-import * as BunHttpServer from "./BunHttpServer.js";
+import * as Unique from "../Unique.js";
+import * as BunServer from "./BunServer.js";
 const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch";
 export class BunRouteError extends Data.TaggedError("BunRouteError") {
 }
@@ -35,7 +35,7 @@ export function htmlBundle(load) {
                     message: "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
                 }));
             }
-            const bunServer = yield* BunHttpServer.BunHttpServer;
+            const bunServer = yield* BunServer.BunServer;
             const url = new URL(originalRequest.url);
             const internalPath = `${bunPrefix}${url.pathname}`;
             const internalUrl = new URL(internalPath, bunServer.server.url);
@@ -94,9 +94,7 @@ export function htmlBundle(load) {
  * - /exact        - Exact match
  * - /users/:id    - Full-segment named param
  * - /path/*       - Directory wildcard
- * - /*            - Catch-all
- * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
- * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ * - /[[404]]      - Catch-all / Rest
  *
  * Unsupported patterns (cannot be implemented in Bun):
  * - /pk_[id]   - Prefix before param
@@ -106,19 +104,13 @@ export function htmlBundle(load) {
  * - /hello-*   - Inline prefix wildcard
  */
 export function validateBunPattern(pattern) {
-    const segments = RouterPattern.parse(pattern);
-    const unsupported = Array.findFirst(segments, (seg) => {
-        if (seg._tag === "ParamSegment") {
-            return seg.prefix !== undefined || seg.suffix !== undefined;
-        }
-        return false;
-    });
-    if (Option.isSome(unsupported)) {
+    const segs = FilePathPattern.segments(pattern);
+    const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment");
+    if (Option.isSome(invalid)) {
         return Option.some(new BunRouteError({
             reason: "UnsupportedPattern",
             pattern,
-            message: `Pattern "${pattern}" uses prefixed/suffixed params (prefix_[param] or [param]_suffix) `
-                + `which cannot be implemented in Bun.serve.`,
+            message: `Pattern "${pattern}" contains invalid segment.`,
         }));
     }
     return Option.none();

package/dist/bun/BunRuntime.d.ts

@@ -1 +1,2 @@
-export declare const runMain: import("@effect/platform/Runtime").RunMain;
+import * as PlatformRuntime from "../PlatformRuntime.ts";
+export declare const runMain: PlatformRuntime.RunMain;

package/dist/bun/BunRuntime.js

@@ -1,14 +1,16 @@
-import { makeRunMain } from "@effect/platform/Runtime";
-import { constVoid } from "effect/Function";
-export const runMain = makeRunMain(({ fiber, teardown, }) => {
-    const keepAlive = setInterval(constVoid, 2 ** 31 - 1);
+import * as GlobalValue from "effect/GlobalValue";
+import * as MutableRef from "effect/MutableRef";
+import * as PlatformRuntime from "../PlatformRuntime.js";
+const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () => MutableRef.make(undefined));
+export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown, }) => {
+    const prevFiber = MutableRef.get(mainFiber);
+    MutableRef.set(mainFiber, fiber);
     let receivedSignal = false;
     fiber.addObserver((exit) => {
         if (!receivedSignal) {
             process.removeListener("SIGINT", onSigint);
             process.removeListener("SIGTERM", onSigint);
         }
-        clearInterval(keepAlive);
         teardown(exit, (code) => {
             if (receivedSignal || code !== 0) {
                 process.exit(code);
@@ -23,4 +25,7 @@ export const runMain = makeRunMain(({ fiber, teardown, }) => {
     }
     process.on("SIGINT", onSigint);
     process.on("SIGTERM", onSigint);
+    if (prevFiber) {
+        prevFiber.unsafeInterruptAsFork(prevFiber.id());
+    }
 });

package/dist/bun/BunServer.d.ts

@@ -0,0 +1,33 @@
+import * as Bun from "bun";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as BunServerRequest from "./BunServerRequest.ts";
+type FetchHandler = (request: Request, server: Bun.Server<BunServerRequest.WebSocketContext>) => Response | Promise<Response>;
+/**
+ * Basically `Omit<Bun.Serve.Options, "fetch" | "error" | "websocket">`
+ * TypeScript 5.9 cannot verify discriminated union types used in
+ * {@link Bun.serve} so we need to define them explicitly.
+ */
+interface BunServeOptions {
+    readonly port?: number;
+    readonly hostname?: string;
+    readonly reusePort?: boolean;
+    readonly ipv6Only?: boolean;
+    readonly idleTimeout?: number;
+    readonly development?: boolean;
+}
+export type BunServer = {
+    readonly server: Bun.Server<BunServerRequest.WebSocketContext>;
+    readonly pushHandler: (fetch: FetchHandler) => void;
+    readonly popHandler: () => void;
+};
+export declare const BunServer: Context.Tag<BunServer, BunServer>;
+export declare const make: (options: BunServeOptions) => Effect.Effect<BunServer, never, Scope.Scope>;
+/**
+ * Provides HttpServer using BunServer under the hood.
+ */
+export declare const layer: (options?: BunServeOptions) => Layer.Layer<BunServer>;
+export declare const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<BunServer, A>>;
+export {};

package/dist/bun/BunServer.js

@@ -0,0 +1,133 @@
+import * as Socket from "@effect/platform/Socket";
+import * as Bun from "bun";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Runtime from "effect/Runtime";
+import * as PathPattern from "../PathPattern.js";
+import * as PlataformRuntime from "../PlatformRuntime.js";
+import * as Route from "../Route.js";
+import * as RouteHttp from "../RouteHttp.js";
+import * as RouteTree from "../RouteTree.js";
+import * as BunRoute from "./BunRoute.js";
+export const BunServer = Context.GenericTag("effect-start/BunServer");
+export const make = (options) => Effect.gen(function* () {
+    const routes = yield* Effect.serviceOption(Route.Routes).pipe(Effect.andThen(Option.getOrUndefined));
+    const port = yield* Config.number("PORT").pipe(Effect.catchTag("ConfigError", () => {
+        return PlataformRuntime.isAgentHarness()
+            ? Effect.succeed(0) // random port
+            : Effect.succeed(3000);
+    }));
+    const hostname = yield* Config.string("HOSTNAME").pipe(Effect.catchTag("ConfigError", () => Effect.succeed(undefined)));
+    const handlerStack = [
+        function (_request, _server) {
+            return new Response("not found", { status: 404 });
+        },
+    ];
+    const service = BunServer.of({
+        // During the construction we need to create a service imlpementation
+        // first so we can provide it in the runtime that will be used in web
+        // handlers. After we create the runtime, we set it below so it's always
+        // available at runtime.
+        // An alternative approach would be to use Bun.Server.reload but I prefer
+        // to avoid it since it's badly documented and has bunch of bugs.
+        server: undefined,
+        pushHandler(fetch) {
+            handlerStack.push(fetch);
+            reload();
+        },
+        popHandler() {
+            handlerStack.pop();
+            reload();
+        },
+    });
+    const runtime = yield* Effect.runtime().pipe(Effect.andThen(Runtime.provideService(BunServer, service)));
+    let currentRoutes = routes
+        ? yield* walkBunRoutes(runtime, routes)
+        : {};
+    const websocket = {
+        open(ws) {
+            Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws));
+        },
+        message(ws, message) {
+            ws.data.run(message);
+        },
+        close(ws, code, closeReason) {
+            Deferred.unsafeDone(ws.data.closeDeferred, Socket.defaultCloseCodeIsError(code)
+                ? Exit.fail(new Socket.SocketCloseError({
+                    reason: "Close",
+                    code,
+                    closeReason,
+                }))
+                : Exit.void);
+        },
+    };
+    const server = Bun.serve({
+        port,
+        hostname,
+        ...options,
+        routes: currentRoutes,
+        fetch: handlerStack[0],
+        websocket,
+    });
+    // @ts-expect-error
+    service.server = server;
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+        server.stop();
+    }));
+    const reload = () => {
+        server.reload({
+            fetch: handlerStack[handlerStack.length - 1],
+            routes: currentRoutes,
+            websocket,
+        });
+    };
+    const bunServer = BunServer.of({
+        server,
+        pushHandler(fetch) {
+            handlerStack.push(fetch);
+            reload();
+        },
+        popHandler() {
+            handlerStack.pop();
+            reload();
+        },
+    });
+    return bunServer;
+});
+/**
+ * Provides HttpServer using BunServer under the hood.
+ */
+export const layer = (options) => Layer.scoped(BunServer, make(options ?? {}));
+export const withLogAddress = (layer) => Layer
+    .effectDiscard(BunServer.pipe(Effect.andThen(server => Effect.log(`Listening on ${server.server.hostname}:${server.server.port}`))))
+    .pipe(Layer.provideMerge(layer));
+function walkBunRoutes(runtime, tree) {
+    return Effect.gen(function* () {
+        const bunRoutes = {};
+        const pathGroups = new Map();
+        const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime);
+        for (const route of RouteTree.walk(tree)) {
+            const bunDescriptors = BunRoute.descriptors(route);
+            if (bunDescriptors) {
+                const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad);
+                bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle;
+            }
+            const path = Route.descriptor(route).path;
+            const group = pathGroups.get(path) ?? [];
+            group.push(route);
+            pathGroups.set(path, group);
+        }
+        for (const [path, routes] of pathGroups) {
+            const handler = toWebHandler(routes);
+            for (const bunPath of PathPattern.toBun(path)) {
+                bunRoutes[bunPath] = handler;
+            }
+        }
+        return bunRoutes;
+    });
+}

package/dist/bun/BunServerRequest.d.ts

@@ -0,0 +1,60 @@
+import type * as FileSystem from "@effect/platform/FileSystem";
+import * as Headers from "@effect/platform/Headers";
+import * as HttpIncomingMessage from "@effect/platform/HttpIncomingMessage";
+import type { HttpMethod } from "@effect/platform/HttpMethod";
+import * as HttpServerError from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import type * as Multipart from "@effect/platform/Multipart";
+import type * as Path from "@effect/platform/Path";
+import * as Socket from "@effect/platform/Socket";
+import * as UrlParams from "@effect/platform/UrlParams";
+import type { Server as BunServerInstance, ServerWebSocket } from "bun";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Runtime from "effect/Runtime";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+export interface WebSocketContext {
+    readonly deferred: Deferred.Deferred<ServerWebSocket<WebSocketContext>>;
+    readonly closeDeferred: Deferred.Deferred<void, Socket.SocketError>;
+    readonly buffer: Array<Uint8Array | string>;
+    run: (_: Uint8Array | string) => void;
+}
+export declare class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest.HttpServerRequest {
+    readonly [HttpServerRequest.TypeId]: HttpServerRequest.TypeId;
+    readonly [HttpIncomingMessage.TypeId]: HttpIncomingMessage.TypeId;
+    readonly source: Request;
+    resolve: (response: Response) => void;
+    readonly url: string;
+    private bunServer;
+    headersOverride?: Headers.Headers;
+    private remoteAddressOverride?;
+    constructor(source: Request, resolve: (response: Response) => void, url: string, bunServer: BunServerInstance<WebSocketContext>, headersOverride?: Headers.Headers, remoteAddressOverride?: string);
+    toJSON(): unknown;
+    modify(options: {
+        readonly url?: string | undefined;
+        readonly headers?: Headers.Headers | undefined;
+        readonly remoteAddress?: string | undefined;
+    }): ServerRequestImpl;
+    get method(): HttpMethod;
+    get originalUrl(): string;
+    get remoteAddress(): Option.Option<string>;
+    get headers(): Headers.Headers;
+    private cachedCookies;
+    get cookies(): Record<string, string>;
+    get stream(): Stream.Stream<Uint8Array, HttpServerError.RequestError>;
+    private textEffect;
+    get text(): Effect.Effect<string, HttpServerError.RequestError>;
+    get json(): Effect.Effect<unknown, HttpServerError.RequestError>;
+    get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError.RequestError>;
+    private multipartEffect;
+    get multipart(): Effect.Effect<Multipart.Persisted, Multipart.MultipartError, Scope.Scope | FileSystem.FileSystem | Path.Path>;
+    get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError>;
+    private arrayBufferEffect;
+    get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError.RequestError>;
+    get upgrade(): Effect.Effect<Socket.Socket, HttpServerError.RequestError>;
+}
+export declare function makeResponse(request: HttpServerRequest.HttpServerRequest, response: HttpServerResponse.HttpServerResponse, runtime: Runtime.Runtime<never>): Response;