effect-start 0.18.0 → 0.20.0

package/dist/bun/BunHttpServer.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import * as HttpApp from "@effect/platform/HttpApp";
 import * as HttpServer from "@effect/platform/HttpServer";
 import * as HttpServerError from "@effect/platform/HttpServerError";
@@ -14,19 +13,19 @@ 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 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 (typeof process !== "undefined"
-            && !process.stdout.isTTY
-            && process.env.CLAUDECODE) {
+        if (PlataformRuntime.isAgentHarness()) {
+            // use random port
             return Effect.succeed(0);
         }
         return Effect.succeed(3000);
@@ -41,7 +40,7 @@ export const make = (options) => Effect.gen(function* () {
     // 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;
+    currentRoutes[`/.BunEmptyHtml-${Unique.token(10)}`] = EmptyHTML;
     const websocket = {
         open(ws) {
             Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws));

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>;
@@ -15,14 +15,14 @@ export type BunDescriptors = {
     bunPrefix: string;
     bunLoad: () => Promise<Bun.HTMLBundle>;
 };
-export declare function descriptors(route: Route.Route.Route): BunDescriptors | undefined;
+export declare function descriptors(route: Route.Route.Route<any, any, any, any, any>): BunDescriptors | undefined;
 export declare function htmlBundle(load: () => Promise<Bun.HTMLBundle | {
     default: Bun.HTMLBundle;
 }>): <D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<BunDescriptors & {
     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 Random from "../Random.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") {
 }
@@ -21,7 +21,7 @@ export function descriptors(route) {
     return undefined;
 }
 export function htmlBundle(load) {
-    const bunPrefix = `/.BunRoute-${Random.token(6)}`;
+    const bunPrefix = `/.BunRoute-${Unique.token(10)}`;
     const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod);
     const descriptors = { bunPrefix, bunLoad, format: "html" };
     return function (self) {
@@ -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;