effect-start 0.17.0 → 0.17.2

package/dist/StartApp.js

@@ -0,0 +1,21 @@
+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 PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
+export class StartApp extends Context.Tag("effect-start/StartApp")() {
+}
+export function layer(options) {
+    return Layer.effect(StartApp, Effect.gen(function* () {
+        const env = options?.env ?? process.env.NODE_ENV ?? "development";
+        const middleware = yield* Ref.make(Function.identity);
+        const events = yield* PubSub.unbounded();
+        return StartApp.of({
+            env,
+            middleware,
+            addMiddleware: (f) => Ref.update(middleware, (prev) => (app) => f(prev(app))),
+            events,
+        });
+    }));
+}

package/dist/StreamExtra.d.ts

@@ -0,0 +1,28 @@
+import * as Runtime from "effect/Runtime";
+import type * as Stream from "effect/Stream";
+export declare const isStream: (u: unknown) => u is Stream.Stream<unknown, unknown, unknown>;
+export type IsStream<T> = T extends Stream.Stream<infer _A, infer _E, infer _R> ? true : false;
+export type Chunk<T> = T extends Stream.Stream<infer A, infer _E, infer _R> ? A : never;
+export type StreamError<T> = T extends Stream.Stream<infer _A, infer E, infer _R> ? E : never;
+export type Context<T> = T extends Stream.Stream<infer _A, infer _E, infer R> ? R : never;
+/**
+ * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
+ * fix an issue in Bun when native stream controller stops working when request
+ * is terminated by the client:
+ *
+ *  TypeError: Value of "this" must be of type ReadableStreamDefaultController
+ *
+ * See related issues:
+ * https://github.com/Effect-TS/effect/issues/4538
+ * https://github.com/oven-sh/bun/issues/17837
+ */
+export declare const toReadableStreamRuntimePatched: (<A, XR>(runtime: Runtime.Runtime<XR>, options?: {
+    readonly strategy?: QueuingStrategy<A> | undefined;
+}) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>, options?: {
+    readonly strategy?: QueuingStrategy<A> | undefined;
+}) => ReadableStream<A>);
+export declare const toReadableStreamRuntimePatched2: (<A, XR>(runtime: Runtime.Runtime<XR>, options?: {
+    readonly strategy?: QueuingStrategy<A> | undefined;
+}) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>, options?: {
+    readonly strategy?: QueuingStrategy<A> | undefined;
+}) => ReadableStream<A>);

package/dist/StreamExtra.js

@@ -0,0 +1,100 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Runtime from "effect/Runtime";
+import { runForEachChunk, StreamTypeId, } from "effect/Stream";
+export const isStream = (u) => Predicate.hasProperty(u, StreamTypeId);
+/**
+ * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
+ * fix an issue in Bun when native stream controller stops working when request
+ * is terminated by the client:
+ *
+ *  TypeError: Value of "this" must be of type ReadableStreamDefaultController
+ *
+ * See related issues:
+ * https://github.com/Effect-TS/effect/issues/4538
+ * https://github.com/oven-sh/bun/issues/17837
+ */
+export const toReadableStreamRuntimePatched = dual((args) => Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
+    const runFork = Runtime.runFork(runtime);
+    let currentResolve = undefined;
+    let fiber = undefined;
+    const latch = Effect.unsafeMakeLatch(false);
+    return new ReadableStream({
+        start(controller) {
+            fiber = runFork(runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
+                latch.unsafeClose();
+                try {
+                    for (const item of chunk) {
+                        controller.enqueue(item);
+                    }
+                }
+                catch (e) {
+                    if (e.message
+                        === `Value of "this" must be of type ReadableStreamDefaultController`) {
+                        // Do nothing when this happens in Bun.
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                currentResolve();
+                currentResolve = undefined;
+            }))));
+            // --- CHANGES HERE ---
+            // In original code, we had fiber.addObserver here that called
+            // error() or close() on controller. This patched version removes it.
+        },
+        pull() {
+            return new Promise((resolve) => {
+                currentResolve = resolve;
+                Effect.runSync(latch.open);
+            });
+        },
+        cancel() {
+            if (!fiber)
+                return;
+            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
+        },
+    }, options?.strategy);
+});
+export const toReadableStreamRuntimePatched2 = dual((args) => Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
+    const runSync = Runtime.runSync(runtime);
+    const runFork = Runtime.runFork(runtime);
+    let currentResolve = undefined;
+    let fiber = undefined;
+    const latch = Effect.unsafeMakeLatch(false);
+    return new ReadableStream({
+        start(controller) {
+            fiber = runFork(runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
+                latch.unsafeClose();
+                for (const item of chunk) {
+                    controller.enqueue(item);
+                }
+                currentResolve();
+                currentResolve = undefined;
+            }))));
+            fiber.addObserver((exit) => {
+                if (exit._tag === "Failure") {
+                    controller.error(Cause.squash(exit.cause));
+                }
+                else {
+                    controller.close();
+                }
+            });
+        },
+        pull() {
+            return new Promise((resolve) => {
+                currentResolve = resolve;
+                Effect.runSync(latch.open);
+            });
+        },
+        cancel() {
+            if (!fiber)
+                return;
+            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
+        },
+    }, options?.strategy);
+});

package/dist/TuplePathPattern.d.ts

@@ -0,0 +1,9 @@
+export type PathTuple = ReadonlyArray<string | [string, string?, string?] | [[string]]>;
+export declare function format(tuple: PathTuple): `/${string}`;
+export declare function toColon(tuple: PathTuple): string;
+export declare const toHono: typeof toColon;
+export declare function toExpress(tuple: PathTuple): string;
+export declare const toEffect: typeof toColon;
+export declare function toURLPattern(tuple: PathTuple): string;
+export declare function toRemix(tuple: PathTuple): string;
+export declare const toBun: typeof toColon;

package/dist/TuplePathPattern.js

@@ -0,0 +1,63 @@
+export function format(tuple) {
+    return "/" + tuple
+        .map((el) => {
+        if (typeof el === "string")
+            return el;
+        if (Array.isArray(el[0]))
+            return "[[" + el[0][0] + "]]";
+        const [name, suffix, prefix] = el;
+        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "");
+    })
+        .join("/");
+}
+export function toColon(tuple) {
+    return "/" + tuple
+        .map((el) => {
+        if (typeof el === "string")
+            return el;
+        if (Array.isArray(el[0]))
+            return "*";
+        const [name, suffix, prefix] = el;
+        return (prefix ?? "") + ":" + name + (suffix ?? "");
+    })
+        .join("/");
+}
+export const toHono = toColon;
+export function toExpress(tuple) {
+    return "/" + tuple
+        .map((el) => {
+        if (typeof el === "string")
+            return el;
+        if (Array.isArray(el[0]))
+            return "*" + el[0][0];
+        const [name, suffix, prefix] = el;
+        return (prefix ?? "") + ":" + name + (suffix ?? "");
+    })
+        .join("/");
+}
+export const toEffect = toColon;
+export function toURLPattern(tuple) {
+    return "/" + tuple
+        .map((el) => {
+        if (typeof el === "string")
+            return el;
+        if (Array.isArray(el[0]))
+            return ":" + el[0][0] + "+";
+        const [name, suffix, prefix] = el;
+        return (prefix ?? "") + ":" + name + (suffix ?? "");
+    })
+        .join("/");
+}
+export function toRemix(tuple) {
+    return "/" + tuple
+        .map((el) => {
+        if (typeof el === "string")
+            return el;
+        if (Array.isArray(el[0]))
+            return "$";
+        const [name, suffix, prefix] = el;
+        return (prefix ?? "") + "$" + name + (suffix ?? "");
+    })
+        .join("/");
+}
+export const toBun = toColon;

package/dist/Values.d.ts

@@ -0,0 +1,26 @@
+type JsonPrimitives = string | number | boolean | null;
+export type JsonObject = {
+    [key: string]: Json | undefined;
+};
+export type Json = JsonPrimitives | Json[] | JsonObject;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type helper that returns `true` if type T has any method properties,
+ * otherwise returns `never`.
+ *
+ * Used internally by IsPlainObject to distinguish plain objects from
+ * class instances or objects with methods.
+ */
+type HasMethod<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? true : never;
+}[keyof T];
+export type IsPlainObject<T> = T extends object ? T extends Function ? false : HasMethod<T> extends never ? true : false : false;
+export type Simplify<T> = {
+    -readonly [K in keyof T]: IsPlainObject<T[K]> extends true ? {
+        -readonly [P in keyof T[K]]: T[K][P];
+    } : T[K];
+} extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+export declare const concatBytes: (a: Uint8Array, b: Uint8Array) => Uint8Array;
+export {};

package/dist/Values.js

@@ -0,0 +1,30 @@
+export function isPlainObject(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    // Check for built-in types and web APIs
+    if (ArrayBuffer.isView(value)
+        || value instanceof ArrayBuffer
+        || value instanceof Blob
+        || value instanceof FormData
+        || value instanceof URLSearchParams
+        || value instanceof ReadableStream
+        || value instanceof Date
+        || value instanceof Map
+        || value instanceof Set
+        || value instanceof RegExp
+        || value instanceof Error
+        || value instanceof Promise
+        || Array.isArray(value)) {
+        return false;
+    }
+    // Check if it's a plain object (Object.prototype or null prototype)
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+export const concatBytes = (a, b) => {
+    const result = new Uint8Array(a.byteLength + b.byteLength);
+    result.set(a);
+    result.set(b, a.byteLength);
+    return result;
+};

package/dist/bun/BunBundle.d.ts

@@ -0,0 +1,12 @@
+import type { BuildConfig } from "bun";
+import { Context, Effect, Layer } from "effect";
+import type { BundleContext } from "../bundler/Bundle.ts";
+import * as Bundle from "../bundler/Bundle.ts";
+export type BuildOptions = Omit<BuildConfig, "outdir">;
+export declare const buildClient: (config: BuildOptions | string) => Effect.Effect<BundleContext, Bundle.BundleError, never>;
+export declare const buildServer: (config: BuildOptions | string) => Effect.Effect<BundleContext, Bundle.BundleError, never>;
+/**
+ * Given a config, build a bundle and returns every time when effect is executed.
+ */
+export declare function build(config: BuildOptions): Effect.Effect<BundleContext, Bundle.BundleError>;
+export declare function layer<T>(tag: Context.Tag<T, BundleContext>, config: BuildOptions): Layer.Layer<T, Bundle.BundleError, never>;

package/dist/bun/BunBundle.js

@@ -0,0 +1,145 @@
+import { Array, Effect, Iterable, Layer, pipe, Record, } from "effect";
+import * as NPath from "node:path";
+import * as Bundle from "../bundler/Bundle.js";
+export const buildClient = (config) => {
+    if (typeof config === "string") {
+        config = {
+            entrypoints: [config],
+        };
+    }
+    const baseConfig = {
+        sourcemap: "linked",
+        naming: {
+            entry: "[name]-[hash].[ext]",
+            chunk: "[name]-[hash].[ext]",
+            asset: "[name]-[hash].[ext]",
+        },
+        packages: "bundle",
+        publicPath: "/_bundle/",
+    };
+    const resolvedConfig = {
+        ...baseConfig,
+        target: "browser",
+        ...config,
+    };
+    return build(resolvedConfig);
+};
+export const buildServer = (config) => {
+    if (typeof config === "string") {
+        config = {
+            entrypoints: [config],
+        };
+    }
+    const baseConfig = {
+        sourcemap: "linked",
+        naming: {
+            entry: "[dir]/[name]-[hash].[ext]",
+            chunk: "[name]-[hash].[ext]",
+            asset: "[name]-[hash].[ext]",
+        },
+        packages: "bundle",
+    };
+    const resolvedConfig = {
+        ...baseConfig,
+        target: "bun",
+        ...config,
+    };
+    return build(resolvedConfig);
+};
+/**
+ * Given a config, build a bundle and returns every time when effect is executed.
+ */
+export function build(config) {
+    return Effect.gen(function* () {
+        const output = yield* buildBun(config);
+        const manifest = generateManifestfromBunBundle(config, output);
+        const artifactsMap = Record.fromIterableBy(output.outputs, (v) => v.path.replace(/^\.\//, ""));
+        const resolve = (path) => {
+            return manifest.entrypoints[path] ?? null;
+        };
+        const getArtifact = (path) => {
+            return artifactsMap[resolve(path)]
+                ?? artifactsMap[path]
+                ?? null;
+        };
+        return {
+            ...manifest,
+            resolve,
+            getArtifact,
+        };
+    });
+}
+export function layer(tag, config) {
+    return Layer.effect(tag, build(config));
+}
+/**
+ * Finds common path prefix across provided paths.
+ */
+function getBaseDir(paths) {
+    if (paths.length === 0)
+        return "";
+    if (paths.length === 1)
+        return NPath.dirname(paths[0]);
+    const segmentsList = paths.map((path) => NPath.dirname(path).split("/").filter(Boolean));
+    return segmentsList[0]
+        .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
+        .reduce((path, seg) => `${path}/${seg}`, "") ?? "";
+}
+/**
+ * Maps entrypoints to their respective build artifacts.
+ * Entrypoint key is trimmed to remove common path prefix.
+ */
+function joinBuildEntrypoints(options, output) {
+    const commonPathPrefix = getBaseDir(options.entrypoints) + "/";
+    return pipe(Iterable.zip(options.entrypoints, pipe(output.outputs, 
+    // Filter out source maps to properly map artifacts to entrypoints.
+    Iterable.filter((v) => v.kind !== "sourcemap"
+        && !(v.loader === "html" && v.path.endsWith(".js"))))), Iterable.map(([entrypoint, artifact]) => {
+        return {
+            shortPath: entrypoint.replace(commonPathPrefix, ""),
+            fullPath: entrypoint,
+            artifact,
+        };
+    }));
+}
+/**
+ * Generate manifest from a build.
+ * Useful for SSR and providing source->artifact path mapping.
+ */
+function generateManifestfromBunBundle(options, output, imports) {
+    const entrypointArtifacts = joinBuildEntrypoints(options, output);
+    return {
+        entrypoints: pipe(entrypointArtifacts, Iterable.map((v) => [
+            v.shortPath,
+            v.artifact.path.replace(/^\.\//, ""),
+        ]), Record.fromEntries),
+        artifacts: pipe(output.outputs, Iterable.map((v) => {
+            // strip './' prefix
+            const shortPath = v.path.replace(/^\.\//, "");
+            return {
+                path: shortPath,
+                type: v.type,
+                size: v.size,
+                hash: v.hash ?? undefined,
+                imports: imports?.get(v.path),
+            };
+        }), Array.fromIterable),
+    };
+}
+function buildBun(config) {
+    return Object.assign(Effect.gen(function* () {
+        const buildOutput = yield* Effect.tryPromise({
+            try: () => Bun.build(config),
+            catch: (err) => {
+                const cause = err instanceof AggregateError
+                    ? err.errors?.[0] ?? err
+                    : err;
+                return new Bundle.BundleError({
+                    message: "Failed to Bun.build: " + cause,
+                    cause: cause,
+                });
+            },
+        });
+        return buildOutput;
+    }));
+}

package/dist/bun/BunHttpServer.d.ts

@@ -0,0 +1,44 @@
+import * as HttpServer from "@effect/platform/HttpServer";
+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 RouteTree from "../RouteTree.ts";
+import { WebSocketContext } from "./BunHttpServer_web.ts";
+import * as BunRoute from "./BunRoute.ts";
+type FetchHandler = (request: Request, server: Bun.Server<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 ServeOptions {
+    readonly port?: number;
+    readonly hostname?: string;
+    readonly reusePort?: boolean;
+    readonly ipv6Only?: boolean;
+    readonly idleTimeout?: number;
+    readonly development?: boolean;
+}
+export type BunHttpServer = {
+    readonly server: Bun.Server<WebSocketContext>;
+    readonly addRoutes: (routes: BunRoute.BunRoutes) => void;
+    readonly pushHandler: (fetch: FetchHandler) => void;
+    readonly popHandler: () => void;
+};
+export declare const BunHttpServer: Context.Tag<BunHttpServer, BunHttpServer>;
+export declare const make: (options: ServeOptions) => Effect.Effect<BunHttpServer, never, Scope.Scope>;
+/**
+ * Provides HttpServer using BunHttpServer under the hood.
+ */
+export declare const layer: (options?: ServeOptions) => Layer.Layer<HttpServer.HttpServer | BunHttpServer>;
+/**
+ * Registers routes provided via {@link Route.layer}
+ */
+export declare function layerAuto(): Layer.Layer<never, never, BunHttpServer>;
+/**
+ * Register routes in Bun.serve.
+ */
+export declare function layerRoutes(tree: RouteTree.RouteTree): Layer.Layer<never, never, BunHttpServer>;
+export {};

package/dist/bun/BunHttpServer.js

@@ -0,0 +1,187 @@
+// @ts-nocheck
+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 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 FiberSet from "effect/FiberSet";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as PathPattern from "../PathPattern.js";
+import * as Random from "../Random.js";
+import * as Route from "../Route.js";
+import * as RouteHttp from "../RouteHttp.js";
+import * as RouteTree from "../RouteTree.js";
+import EmptyHTML from "./_empty.html";
+import { makeResponse, ServerRequestImpl, } from "./BunHttpServer_web.js";
+import * as BunRoute from "./BunRoute.js";
+export const BunHttpServer = Context.GenericTag("effect-start/BunServer");
+export const make = (options) => Effect.gen(function* () {
+    const port = yield* Config.number("PORT").pipe(Effect.catchTag("ConfigError", () => {
+        if (typeof process !== "undefined"
+            && !process.stdout.isTTY
+            && process.env.CLAUDECODE) {
+            return Effect.succeed(0);
+        }
+        return 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 });
+        },
+    ];
+    let currentRoutes = {};
+    // Bun HMR doesn't work on successive calls to `server.reload` if there are no routes
+    // on server start. We workaround that by passing a dummy HTMLBundle [2025-11-26]
+    // see: https://github.com/oven-sh/bun/issues/23564
+    currentRoutes[`/.BunEmptyHtml-${Random.token(6)}`] = EmptyHTML;
+    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,
+    });
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+        server.stop();
+    }));
+    const reload = () => {
+        server.reload({
+            fetch: handlerStack[handlerStack.length - 1],
+            routes: currentRoutes,
+            websocket,
+        });
+    };
+    return BunHttpServer.of({
+        server,
+        pushHandler(fetch) {
+            handlerStack.push(fetch);
+            reload();
+        },
+        popHandler() {
+            handlerStack.pop();
+            reload();
+        },
+        addRoutes(routes) {
+            currentRoutes = {
+                ...currentRoutes,
+                ...routes,
+            };
+            reload();
+        },
+    });
+});
+/**
+ * Provides HttpServer using BunHttpServer under the hood.
+ */
+export const layer = (options) => Layer.provideMerge(Layer.scoped(HttpServer.HttpServer, makeBunServer), Layer.scoped(BunHttpServer, make(options ?? {})));
+/**
+ * Registers routes provided via {@link Route.layer}
+ */
+export function layerAuto() {
+    return Layer.unwrapEffect(Effect.gen(function* () {
+        const bunServer = yield* BunHttpServer;
+        const routes = yield* Effect.serviceOption(Route.Routes);
+        if (Option.isSome(routes)) {
+            return layerRoutes(routes.value);
+        }
+        else {
+            return Layer.empty;
+        }
+    }));
+}
+/**
+ * Register routes in Bun.serve.
+ */
+export function layerRoutes(tree) {
+    return Layer.effectDiscard(Effect.gen(function* () {
+        const bunServer = yield* BunHttpServer;
+        const runtime = yield* Effect.runtime();
+        const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime);
+        const bunRoutes = {};
+        const pathGroups = new Map();
+        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;
+            }
+        }
+        bunServer.addRoutes(bunRoutes);
+    }));
+}
+const makeBunServer = Effect.gen(function* () {
+    const bunServer = yield* BunHttpServer;
+    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(makeResponse(request, response, runtime));
+                }), middleware);
+                function handler(request, server) {
+                    return new Promise((resolve, _reject) => {
+                        const fiber = runFork(Effect.provideService(app, HttpServerRequest.HttpServerRequest, new 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);
+};