effect-start 0.23.0 → 0.25.0

package/dist/Unique.d.ts

@@ -1,50 +0,0 @@
-export declare const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export declare const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-export declare const ALPHABET_BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-export declare const ALPHABET_HEX = "0123456789abcdef";
-/**
- * Generate a random string for ids, session tokens, and API keys.
- * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
- *
- * Minimal recommended length:
- * - public ids: 16 chars (~80 bits)
- * - API keys: 32 chars (~160 bits)
- * - session tokens: 32-40 chars (~160-200 bits)
- */
-export declare function token(length?: number): string;
-export declare function bytes(length: number): Uint8Array;
-export declare const UUID_NIL = "00000000-0000-0000-0000-000000000000";
-export declare function uuid4(): string;
-export declare function uuid7(time?: number): string;
-/**
- * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
- *
- * @example
- * const bytes = Unique.uuid7Bytes()
- * const timestamp = Unique.toTimestamp(bytes)
- *
- * @example
- * const bytes = Unique.ulidBytes()
- * const timestamp = Unique.toTimestamp(bytes)
- */
-export declare function toTimestamp(bytes: Uint8Array): number;
-export declare function uuid7Bytes(time?: number): Uint8Array;
-/**
- * Convert UUID bytes to canonical (RFC9562) representation.
- *
- * @example
- * Unique.formatUuid(new Uint8Array(16))
- */
-export declare function formatUuid(bytes: Uint8Array): string;
-export declare function ulid(time?: number): string;
-export declare function ulidBytes(time?: number): Uint8Array;
-/**
- * Generate a nanoid-style random string.
- *
- * FUN_FACT: Original nanoid implementation uses base64url alphabet
- * with non-standard custom order where charater form common words found
- * in source code (like use, random, strict) to make gzip/brotli more efficient.
- * It's qt lil opt from the times where web developers
- * were competing to have the smallest possible bundle size.
- */
-export declare function nanoid(size?: number, alphabet?: string): string;

package/dist/Values.d.ts

@@ -1,27 +0,0 @@
-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: Array<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 firstValue: <T>(record: Record<string, T>) => T | undefined;
-export declare const concatBytes: (a: Uint8Array, b: Uint8Array) => Uint8Array;
-export {};

package/dist/bun/BunBlobStoreDisk.d.ts

@@ -1,6 +0,0 @@
-import * as Layer from "effect/Layer";
-import { BlobStore as BlobStoreTag } from "../BlobStore.ts";
-export interface DiskConfig {
-    readonly directory?: string;
-}
-export declare const layer: (config?: DiskConfig) => Layer.Layer<BlobStoreTag>;

package/dist/bun/BunBlobStoreDisk.js

@@ -1,116 +0,0 @@
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import * as NFS from "node:fs";
-import * as NPath from "node:path";
-import { BlobStore as BlobStoreTag } from "../BlobStore.js";
-import * as PlatformError from "../PlatformError.js";
-import { handleErrnoException } from "../node/NodeFileSystem.js";
-const handleBadArgument = (method) => (cause) => new PlatformError.BadArgument({
-    module: "BlobStore",
-    method,
-    cause,
-});
-const handleErrno = (method) => handleErrnoException("BlobStore", method);
-const tryPromise = (method, path, promise) => Effect.tryPromise({
-    try: promise,
-    catch: (err) => {
-        if (err instanceof Error && "code" in err) {
-            return handleErrno(method)(err, [path]);
-        }
-        return handleBadArgument(method)(err);
-    },
-});
-const validatePath = (directory, key) => {
-    const resolved = NPath.resolve(directory, key);
-    const root = NPath.resolve(directory);
-    if (resolved !== root && !resolved.startsWith(root + NPath.sep)) {
-        return Effect.fail(new PlatformError.BadArgument({
-            module: "BlobStore",
-            method: "ref",
-            description: `Path traversal: key "${key}" escapes directory "${directory}"`,
-        }));
-    }
-    return Effect.succeed(resolved);
-};
-const makeRef = (directory, path, key, begin, end) => {
-    const getFile = () => {
-        const f = Bun.file(path);
-        return begin !== undefined || end !== undefined ? f.slice(begin, end) : f;
-    };
-    return {
-        key,
-        bytes: tryPromise("bytes", path, () => getFile().bytes()),
-        text: tryPromise("text", path, () => getFile().text()),
-        json: tryPromise("json", path, () => getFile().json()),
-        stat: Effect.flatMap(tryPromise("stat", path, () => Bun.file(path).stat()), (s) => Effect.succeed({
-            size: s.size,
-            lastModified: Option.fromNullable(s.mtime),
-            etag: Option.none(),
-            type: Option.fromNullable(Bun.file(path).type || null),
-        })),
-        exists: tryPromise("exists", path, () => Bun.file(path).exists()),
-        delete: tryPromise("delete", path, () => NFS.promises.unlink(path)),
-        stream: Stream.fromReadableStream(() => getFile().stream(), (err) => {
-            if (err instanceof Error && "code" in err) {
-                return handleErrno("stream")(err, [path]);
-            }
-            return handleBadArgument("stream")(err);
-        }),
-        write: (data) => tryPromise("write", path, () => Bun.write(path, data, { createPath: true }).then(() => undefined)),
-        slice: (b, e) => makeRef(directory, path, key, b, e),
-    };
-};
-const listEntries = (directory, options) => {
-    const baseDir = options?.prefix
-        ? NPath.join(directory, options.prefix)
-        : directory;
-    return Stream.fromEffect(Effect.tryPromise({
-        try: async () => {
-            try {
-                const entries = await NFS.promises.readdir(baseDir, {
-                    recursive: true,
-                    withFileTypes: true,
-                });
-                return entries
-                    .filter((e) => e.isFile())
-                    .map((e) => {
-                    const rel = NPath.join(e.parentPath, e.name);
-                    const key = NPath.relative(directory, rel);
-                    return {
-                        key,
-                        size: Option.none(),
-                        lastModified: Option.none(),
-                        etag: Option.none(),
-                    };
-                });
-            }
-            catch (err) {
-                if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-                    return [];
-                }
-                throw err;
-            }
-        },
-        catch: (err) => {
-            if (err instanceof Error && "code" in err) {
-                return handleErrno("list")(err, [baseDir]);
-            }
-            return handleBadArgument("list")(err);
-        },
-    })).pipe(Stream.flatMap((entries) => Stream.fromChunk(Chunk.fromIterable(entries))));
-};
-export const layer = (config) => {
-    const directory = config?.directory ?? "/";
-    return Layer.succeed(BlobStoreTag, {
-        ref: (key) => Effect.map(validatePath(directory, key), (path) => makeRef(directory, path, key)),
-        list: (options) => listEntries(directory, options),
-        presign: (_key, _options) => Effect.fail(new PlatformError.BadArgument({
-            module: "BlobStore",
-            method: "presign",
-            description: "Presigned URLs are not supported for disk storage",
-        })),
-    });
-};

package/dist/bun/BunBlobStoreS3.d.ts

@@ -1,11 +0,0 @@
-import * as Layer from "effect/Layer";
-import { BlobStore as BlobStoreTag } from "../BlobStore.ts";
-export interface S3Config {
-    readonly bucket?: string;
-    readonly endpoint?: string;
-    readonly region?: string;
-    readonly accessKeyId?: string;
-    readonly secretAccessKey?: string;
-    readonly sessionToken?: string;
-}
-export declare const layer: (config?: S3Config) => Layer.Layer<BlobStoreTag>;

package/dist/bun/BunBlobStoreS3.js

@@ -1,89 +0,0 @@
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import { BlobStore as BlobStoreTag } from "../BlobStore.js";
-import * as PlatformError from "../PlatformError.js";
-const handleError = (method) => (err) => {
-    if (err instanceof Error) {
-        const msg = err.message.toLowerCase();
-        let reason = "Unknown";
-        if (msg.includes("nosuchkey") || msg.includes("not found") || msg.includes("404")) {
-            reason = "NotFound";
-        }
-        else if (msg.includes("forbidden") || msg.includes("403") || msg.includes("access denied")) {
-            reason = "PermissionDenied";
-        }
-        return new PlatformError.SystemError({
-            reason,
-            module: "BlobStore",
-            method,
-            description: err.message,
-            cause: err,
-        });
-    }
-    return new PlatformError.BadArgument({
-        module: "BlobStore",
-        method,
-        cause: err,
-    });
-};
-const tryPromise = (method, promise) => Effect.tryPromise({
-    try: promise,
-    catch: handleError(method),
-});
-const makeRef = (client, key, begin, end) => {
-    const getFile = () => {
-        const f = client.file(key);
-        return begin !== undefined || end !== undefined ? f.slice(begin, end) : f;
-    };
-    return {
-        key,
-        bytes: tryPromise("bytes", () => getFile().bytes()),
-        text: tryPromise("text", () => getFile().text()),
-        json: tryPromise("json", () => getFile().json()),
-        stat: tryPromise("stat", () => client.file(key).stat()).pipe(Effect.map((s) => ({
-            size: s.size,
-            lastModified: Option.some(s.lastModified),
-            etag: Option.some(s.etag),
-            type: Option.fromNullable(s.type || null),
-        }))),
-        exists: tryPromise("exists", () => client.file(key).exists()),
-        delete: tryPromise("delete", () => client.file(key).delete()),
-        stream: Stream.fromReadableStream(() => getFile().stream(), handleError("stream")),
-        write: (data) => tryPromise("write", () => client.file(key).write(data).then(() => undefined)),
-        slice: (b, e) => makeRef(client, key, b, e),
-    };
-};
-const listEntries = (client, options) => Stream.paginateChunkEffect(undefined, (cursor) => tryPromise("list", () => client.list({
-    prefix: options?.prefix,
-    ...(cursor ? { startAfter: cursor } : {}),
-})).pipe(Effect.map((response) => {
-    const entries = (response.contents ?? []).map((item) => ({
-        key: item.key,
-        size: Option.fromNullable(item.size),
-        lastModified: Option.fromNullable(item.lastModified ? new Date(item.lastModified) : undefined),
-        etag: Option.fromNullable(item.eTag),
-    }));
-    const chunk = Chunk.fromIterable(entries);
-    const last = entries[entries.length - 1];
-    const next = response.isTruncated && last
-        ? Option.some(last.key)
-        : Option.none();
-    return [chunk, next];
-})));
-export const layer = (config) => {
-    const client = new Bun.S3Client(config);
-    return Layer.succeed(BlobStoreTag, {
-        ref: (key) => Effect.succeed(makeRef(client, key)),
-        list: (options) => listEntries(client, options),
-        presign: (key, options) => Effect.try({
-            try: () => client.presign(key, {
-                expiresIn: options?.expiresIn,
-                method: options?.method,
-            }),
-            catch: handleError("presign"),
-        }),
-    });
-};

package/dist/bun/BunBlobWatcherDisk.d.ts

@@ -1,6 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as BlobStore from "../BlobStore.ts";
-export interface DiskWatcherConfig {
-    readonly directory: string;
-}
-export declare const layer: (config: DiskWatcherConfig) => Layer.Layer<BlobStore.BlobWatcher>;

package/dist/bun/BunBlobWatcherDisk.js

@@ -1,60 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Stream from "effect/Stream";
-import * as NFS from "node:fs";
-import * as NPath from "node:path";
-import * as BlobStore from "../BlobStore.js";
-import * as PlatformError from "../PlatformError.js";
-const watchDir = (directory, options) => {
-    const watchPath = options?.prefix
-        ? NPath.join(directory, options.prefix)
-        : directory;
-    return Stream.asyncScoped((emit) => Effect.acquireRelease(Effect.sync(() => {
-        const watcher = NFS.watch(watchPath, { recursive: true }, (event, filename) => {
-            if (!filename)
-                return;
-            const key = options?.prefix
-                ? NPath.join(options.prefix, filename)
-                : filename;
-            switch (event) {
-                case "rename": {
-                    const fullPath = NPath.join(directory, key);
-                    emit.fromEffect(Effect.tryPromise({
-                        try: () => Bun.file(fullPath).exists(),
-                        catch: () => new PlatformError.SystemError({
-                            reason: "Unknown",
-                            module: "BlobWatcher",
-                            method: "watch",
-                            pathOrDescriptor: fullPath,
-                        }),
-                    }).pipe(Effect.map((exists) => exists
-                        ? new BlobStore.WatchEventCreated({ key })
-                        : new BlobStore.WatchEventDeleted({ key }))));
-                    return;
-                }
-                case "change": {
-                    emit.single(new BlobStore.WatchEventUpdated({ key }));
-                    return;
-                }
-            }
-        });
-        watcher.on("error", (error) => {
-            emit.fail(new PlatformError.SystemError({
-                module: "BlobWatcher",
-                reason: "Unknown",
-                method: "watch",
-                pathOrDescriptor: watchPath,
-                cause: error,
-            }));
-        });
-        return watcher;
-    }), (watcher) => Effect.sync(() => watcher.close())));
-};
-export const layer = (config) => Layer.succeed(BlobStore.BlobWatcher, {
-    watch: (options) => watchDir(config.directory, options),
-    notify: (_event) => Effect.fail(new PlatformError.BadArgument({
-        module: "BlobWatcher",
-        method: "notify",
-        description: "Disk watcher receives events from the OS, not from notify()",
-    })),
-});

package/dist/bun/BunBlobWatcherQueue.d.ts

@@ -1,6 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as BlobStore from "../BlobStore.ts";
-export interface QueueWatcherConfig {
-    readonly capacity?: number;
-}
-export declare const layer: (config?: QueueWatcherConfig) => Layer.Layer<BlobStore.BlobWatcher, never, never>;

package/dist/bun/BunBlobWatcherQueue.js

@@ -1,17 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Queue from "effect/Queue";
-import * as Stream from "effect/Stream";
-import * as BlobStore from "../BlobStore.js";
-export const layer = (config) => Layer.scoped(BlobStore.BlobWatcher, Effect.gen(function* () {
-    const queue = yield* Queue.bounded(config?.capacity ?? 1024);
-    return {
-        watch: (options) => {
-            const stream = Stream.fromQueue(queue);
-            if (!options?.prefix)
-                return stream;
-            return stream.pipe(Stream.filter((event) => event.key.startsWith(options.prefix)));
-        },
-        notify: (event) => Queue.offer(queue, event),
-    };
-}));

package/dist/bun/BunBundle.d.ts

@@ -1,11 +0,0 @@
-import type { BuildConfig } from "bun";
-import { type Context, Effect, Layer } from "effect";
-import * as Bundle from "../bundler/Bundle.ts";
-export type BuildOptions = Omit<BuildConfig, "outdir">;
-export declare const buildClient: (config: BuildOptions | string) => Effect.Effect<Bundle.BundleContext, Bundle.BundleError, never>;
-export declare const buildServer: (config: BuildOptions | string) => Effect.Effect<Bundle.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<Bundle.BundleContext, Bundle.BundleError>;
-export declare function layer<T>(tag: Context.Tag<T, Bundle.BundleContext>, config: BuildOptions): Layer.Layer<T, Bundle.BundleError, never>;

package/dist/bun/BunChildProcessSpawner.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as ChildProcess from "../ChildProcess.ts";
-export declare const layer: Layer.Layer<ChildProcess.ChildProcessSpawner>;

package/dist/bun/BunHttpServer.d.ts

@@ -1,44 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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 PlataformRuntime from "../PlatformRuntime.js";
-import * as Route from "../Route.js";
-import * as RouteHttp from "../RouteHttp.js";
-import * as RouteTree from "../RouteTree.js";
-import * as Unique from "../Unique.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 (PlataformRuntime.isAgentHarness()) {
-            // use random port
-            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-${Unique.token(10)}`] = 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);
-};