effect-start 0.23.1 → 0.26.0

package/dist/bun/BunHttpServer_web.d.ts

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

package/dist/bun/BunHttpServer_web.js

@@ -1,252 +0,0 @@
-import * as Cookies from "@effect/platform/Cookies";
-import * as Headers from "@effect/platform/Headers";
-import * as HttpApp from "@effect/platform/HttpApp";
-import * as HttpIncomingMessage from "@effect/platform/HttpIncomingMessage";
-import * as HttpServerError from "@effect/platform/HttpServerError";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as Socket from "@effect/platform/Socket";
-import * as UrlParams from "@effect/platform/UrlParams";
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import * as FiberSet from "effect/FiberSet";
-import * as Inspectable from "effect/Inspectable";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-export class ServerRequestImpl extends Inspectable.Class {
-    [HttpServerRequest.TypeId];
-    [HttpIncomingMessage.TypeId];
-    source;
-    resolve;
-    url;
-    bunServer;
-    headersOverride;
-    remoteAddressOverride;
-    constructor(source, resolve, url, bunServer, headersOverride, remoteAddressOverride) {
-        super();
-        this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId;
-        this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;
-        this.source = source;
-        this.resolve = resolve;
-        this.url = url;
-        this.bunServer = bunServer;
-        this.headersOverride = headersOverride;
-        this.remoteAddressOverride = remoteAddressOverride;
-    }
-    toJSON() {
-        return HttpIncomingMessage.inspect(this, {
-            _id: "@effect/platform/HttpServerRequest",
-            method: this.method,
-            url: this.originalUrl,
-        });
-    }
-    modify(options) {
-        return new ServerRequestImpl(this.source, this.resolve, options.url ?? this.url, this.bunServer, options.headers ?? this.headersOverride, options.remoteAddress ?? this.remoteAddressOverride);
-    }
-    get method() {
-        return this.source.method.toUpperCase();
-    }
-    get originalUrl() {
-        return this.source.url;
-    }
-    get remoteAddress() {
-        return this.remoteAddressOverride
-            ? Option.some(this.remoteAddressOverride)
-            : Option.fromNullable(this.bunServer.requestIP(this.source)?.address);
-    }
-    get headers() {
-        this.headersOverride ??= Headers.fromInput(this.source.headers);
-        return this.headersOverride;
-    }
-    cachedCookies;
-    get cookies() {
-        if (this.cachedCookies) {
-            return this.cachedCookies;
-        }
-        return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "");
-    }
-    get stream() {
-        return this.source.body
-            ? Stream.fromReadableStream(() => this.source.body, (cause) => new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                cause,
-            }))
-            : Stream.fail(new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                description: "can not create stream from empty body",
-            }));
-    }
-    textEffect;
-    get text() {
-        if (this.textEffect) {
-            return this.textEffect;
-        }
-        this.textEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
-            try: () => this.source.text(),
-            catch: (cause) => new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                cause,
-            }),
-        })));
-        return this.textEffect;
-    }
-    get json() {
-        return Effect.tryMap(this.text, {
-            try: (_) => JSON.parse(_),
-            catch: (cause) => new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                cause,
-            }),
-        });
-    }
-    get urlParamsBody() {
-        return Effect.flatMap(this.text, (_) => Effect.try({
-            try: () => UrlParams.fromInput(new URLSearchParams(_)),
-            catch: (cause) => new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                cause,
-            }),
-        }));
-    }
-    multipartEffect;
-    get multipart() {
-        if (this.multipartEffect) {
-            return this.multipartEffect;
-        }
-        this.multipartEffect = Effect.runSync(Effect.cached(Effect.die("Multipart not implemented")));
-        return this.multipartEffect;
-    }
-    get multipartStream() {
-        return Stream.die("Multipart stream not implemented");
-    }
-    arrayBufferEffect;
-    get arrayBuffer() {
-        if (this.arrayBufferEffect) {
-            return this.arrayBufferEffect;
-        }
-        this.arrayBufferEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
-            try: () => this.source.arrayBuffer(),
-            catch: (cause) => new HttpServerError.RequestError({
-                request: this,
-                reason: "Decode",
-                cause,
-            }),
-        })));
-        return this.arrayBufferEffect;
-    }
-    get upgrade() {
-        return Effect.flatMap(Effect.all([
-            Deferred.make(),
-            Deferred.make(),
-            Effect.makeSemaphore(1),
-        ]), ([deferred, closeDeferred, semaphore]) => Effect.async((resume) => {
-            const success = this.bunServer.upgrade(this.source, {
-                data: {
-                    deferred,
-                    closeDeferred,
-                    buffer: [],
-                    run: wsDefaultRun,
-                },
-            });
-            if (!success) {
-                resume(Effect.fail(new HttpServerError.RequestError({
-                    request: this,
-                    reason: "Decode",
-                    description: "Not an upgradeable ServerRequest",
-                })));
-                return;
-            }
-            resume(Effect.map(Deferred.await(deferred), (ws) => {
-                const write = (chunk) => Effect.sync(() => {
-                    if (typeof chunk === "string") {
-                        ws.sendText(chunk);
-                    }
-                    else if (Socket.isCloseEvent(chunk)) {
-                        ws.close(chunk.code, chunk.reason);
-                    }
-                    else {
-                        ws.sendBinary(chunk);
-                    }
-                    return true;
-                });
-                const writer = Effect.succeed(write);
-                const runRaw = Effect.fnUntraced(function* (handler, opts) {
-                    const set = yield* FiberSet.make();
-                    const run = yield* FiberSet.runtime(set)();
-                    function runRawInner(data) {
-                        const result = handler(data);
-                        if (Effect.isEffect(result)) {
-                            run(result);
-                        }
-                    }
-                    ws.data.run = runRawInner;
-                    ws.data.buffer.forEach(runRawInner);
-                    ws.data.buffer.length = 0;
-                    if (opts?.onOpen)
-                        yield* opts.onOpen;
-                    return yield* FiberSet.join(set);
-                }, Effect.scoped, Effect.onExit((exit) => {
-                    ws.close(exit._tag === "Success" ? 1000 : 1011);
-                    return Effect.void;
-                }), Effect.raceFirst(Deferred.await(closeDeferred)), semaphore.withPermits(1));
-                const encoder = new TextEncoder();
-                const run = (handler, opts) => runRaw((data) => typeof data === "string"
-                    ? handler(encoder.encode(data))
-                    : handler(data), opts);
-                return Socket.Socket.of({
-                    [Socket.TypeId]: Socket.TypeId,
-                    run,
-                    runRaw,
-                    writer,
-                });
-            }));
-        }));
-    }
-}
-function wsDefaultRun(_) {
-    this.buffer.push(_);
-}
-export function makeResponse(request, response, runtime) {
-    const fields = {
-        headers: new globalThis.Headers(response.headers),
-        status: response.status,
-    };
-    if (!Cookies.isEmpty(response.cookies)) {
-        for (const header of Cookies.toSetCookieHeaders(response.cookies)) {
-            fields.headers.append("set-cookie", header);
-        }
-    }
-    if (response.statusText !== undefined) {
-        fields.statusText = response.statusText;
-    }
-    if (request.method === "HEAD") {
-        return new Response(undefined, fields);
-    }
-    const ejectedResponse = HttpApp.unsafeEjectStreamScope(response);
-    const body = ejectedResponse.body;
-    switch (body._tag) {
-        case "Empty": {
-            return new Response(undefined, fields);
-        }
-        case "Uint8Array":
-        case "Raw": {
-            if (body.body instanceof Response) {
-                for (const [key, value] of fields.headers.entries()) {
-                    body.body.headers.set(key, value);
-                }
-                return body.body;
-            }
-            return new Response(body.body, fields);
-        }
-        case "FormData": {
-            return new Response(body.formData, fields);
-        }
-        case "Stream": {
-            return new Response(Stream.toReadableStreamRuntime(body.stream, runtime), fields);
-        }
-    }
-}

package/dist/bun/BunImportTrackerPlugin.d.ts

@@ -1,13 +0,0 @@
-import { type BunPlugin, type Import } from "bun";
-export type ImportMap = ReadonlyMap<string, Array<Import>>;
-/**
- * Tracks all imported modules.
- * State can be accessed via 'virtual:import-tracker' module within a bundle
- * or through `state` property returned by this function.
- */
-export declare const make: (opts?: {
-    includeNodeModules?: false;
-    baseDir?: string;
-}) => BunPlugin & {
-    state: ImportMap;
-};

package/dist/bun/BunImportTrackerPlugin.js

@@ -1,69 +0,0 @@
-import * as NPath from "node:path";
-/**
- * Tracks all imported modules.
- * State can be accessed via 'virtual:import-tracker' module within a bundle
- * or through `state` property returned by this function.
- */
-export const make = (opts = {}) => {
-    const foundImports = new Map();
-    const baseDir = opts.baseDir ?? process.cwd();
-    return {
-        name: "import tracker",
-        setup(build) {
-            const transpiler = new Bun.Transpiler({
-                loader: "tsx",
-            });
-            // Each module that goes through this onLoad callback
-            // will record its imports in `trackedImports`
-            build.onLoad({
-                filter: /\.(ts|js)x?$/,
-            }, async (args) => {
-                if (!opts.includeNodeModules && args.path.includes("/node_modules/")) {
-                    return undefined;
-                }
-                const contents = await Bun.file(args.path).arrayBuffer();
-                try {
-                    const fileImport = transpiler.scanImports(contents);
-                    const resolvedImports = fileImport.map((imp) => {
-                        const absoluteImportPath = NPath.resolve(NPath.dirname(args.path), 
-                        // 'file' is a default namespace, trim it
-                        imp.path.replace(/^file:/, ""));
-                        return {
-                            ...imp,
-                            // keep all module identifiers with namespace intact
-                            path: /(\w+):/.test(imp.path)
-                                ? imp.path
-                                : NPath.relative(baseDir, absoluteImportPath),
-                        };
-                    });
-                    foundImports.set(NPath.relative(baseDir, args.path), resolvedImports);
-                }
-                catch (e) { }
-                return undefined;
-            });
-            build.onResolve({
-                filter: /^virtual:import-tracker$/,
-            }, () => {
-                return {
-                    namespace: "effect-start",
-                    path: "virtual:import-tracker",
-                };
-            });
-            build.onLoad({
-                filter: /^virtual:import-tracker$/,
-                namespace: "effect-start",
-            }, async (args) => {
-                // Wait for all files to be loaded, ensuring
-                // that every file goes through the above `onLoad()` function
-                // and their imports tracked
-                await args.defer();
-                // Emit JSON containing the stats of each import
-                return {
-                    contents: JSON.stringify(Object.fromEntries(foundImports.entries())),
-                    loader: "json",
-                };
-            });
-        },
-        state: foundImports,
-    };
-};

package/dist/bun/BunPlatformHttpServer.d.ts

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

@@ -1,53 +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 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,48 +0,0 @@
-import type * as Bun from "bun";
-import * as Option from "effect/Option";
-import * as Route from "../Route.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>;
-export declare class BunRouteError extends BunRouteError_base<{
-    reason: "ProxyError" | "UnsupportedPattern";
-    pattern: string;
-    message: string;
-}> {
-}
-export type BunDescriptors = {
-    bunPrefix: string;
-    bunLoad: () => Promise<Bun.HTMLBundle>;
-};
-export declare function descriptors(route: Route.Route.Route<any, any, any, any, any>): BunDescriptors | undefined;
-type HTMLBundleModule = Bun.HTMLBundle | {
-    default: Bun.HTMLBundle;
-};
-export declare function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModule>): <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, 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>;
-/**
- * Validates that a route pattern can be implemented with Bun.serve routes.
- *
- * Supported patterns (native or via multiple routes):
- * - /exact        - Exact match
- * - /users/:id    - Full-segment named param
- * - /path/*       - Directory wildcard
- * - /[[404]]      - Catch-all / Rest
- *
- * Unsupported patterns (cannot be implemented in Bun):
- * - /pk_[id]   - Prefix before param
- * - /[id]_sfx  - Suffix after param
- * - /[id].json - Suffix with dot
- * - /[id]~test - Suffix with tilde
- * - /hello-*   - Inline prefix wildcard
- */
-export declare function validateBunPattern(pattern: string): Option.Option<BunRouteError>;
-export declare const isHtmlBundle: (handle: any) => boolean;
-export {};

package/dist/bun/BunRoute.js

@@ -1,121 +0,0 @@
-import * as Array from "effect/Array";
-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 Route from "../Route.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") {
-}
-export function descriptors(route) {
-    const descriptor = Route.descriptor(route);
-    if (typeof descriptor.bunPrefix === "string" && typeof descriptor.bunLoad === "function") {
-        return descriptor;
-    }
-    return undefined;
-}
-export function htmlBundle(load) {
-    const bunPrefix = `/.BunRoute-${Unique.token(10)}`;
-    const bunLoad = () => Promise.resolve(load()).then((mod) => ("default" in mod ? mod.default : mod));
-    const descriptors = { bunPrefix, bunLoad, format: "html" };
-    return function (self) {
-        const handler = (context, next) => Effect.gen(function* () {
-            const originalRequest = context.request;
-            if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
-                const url = new URL(originalRequest.url);
-                return yield* Effect.fail(new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: url.pathname,
-                    message: "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
-                }));
-            }
-            const bunServer = yield* BunServer.BunServer;
-            const url = new URL(originalRequest.url);
-            const internalPath = `${bunPrefix}${url.pathname}`;
-            const internalUrl = new URL(internalPath, bunServer.server.url);
-            const headers = new Headers(originalRequest.headers);
-            headers.set(INTERNAL_FETCH_HEADER, "true");
-            const proxyRequest = new Request(internalUrl, {
-                method: originalRequest.method,
-                headers,
-            });
-            const response = yield* Effect.tryPromise({
-                try: () => fetch(proxyRequest),
-                catch: (error) => new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: internalPath,
-                    message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-                }),
-            });
-            let html = yield* Effect.tryPromise({
-                try: () => response.text(),
-                catch: (error) => new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: internalPath,
-                    message: String(error),
-                }),
-            });
-            const childEntity = yield* Entity.resolve(next(context));
-            const children = childEntity?.body ?? childEntity;
-            let childrenHtml = "";
-            if (children != null) {
-                if (children instanceof Response) {
-                    childrenHtml = yield* Effect.promise(() => children.text());
-                }
-                else if (Hyper.isGenericJsxObject(children)) {
-                    childrenHtml = HyperHtml.renderToString(children);
-                }
-                else {
-                    childrenHtml = String(children);
-                }
-            }
-            html = html.replace(/%children%/g, childrenHtml);
-            return Entity.make(html, {
-                status: response.status,
-                headers: {
-                    "content-type": response.headers.get("content-type"),
-                },
-            });
-        });
-        const route = Route.make(handler, descriptors);
-        return Route.set([...Route.items(self), route], Route.descriptor(self));
-    };
-}
-/**
- * Validates that a route pattern can be implemented with Bun.serve routes.
- *
- * Supported patterns (native or via multiple routes):
- * - /exact        - Exact match
- * - /users/:id    - Full-segment named param
- * - /path/*       - Directory wildcard
- * - /[[404]]      - Catch-all / Rest
- *
- * Unsupported patterns (cannot be implemented in Bun):
- * - /pk_[id]   - Prefix before param
- * - /[id]_sfx  - Suffix after param
- * - /[id].json - Suffix with dot
- * - /[id]~test - Suffix with tilde
- * - /hello-*   - Inline prefix wildcard
- */
-export function validateBunPattern(pattern) {
-    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}" contains invalid segment.`,
-        }));
-    }
-    return Option.none();
-}
-export const isHtmlBundle = (handle) => {
-    return (typeof handle === "object" &&
-        handle !== null &&
-        (handle.toString() === "[object HTMLBundle]" || typeof handle.index === "string"));
-};

package/dist/bun/BunRuntime.d.ts

@@ -1,2 +0,0 @@
-import * as PlatformRuntime from "../PlatformRuntime.ts";
-export declare const runMain: PlatformRuntime.RunMain;

package/dist/bun/BunRuntime.js

@@ -1,31 +0,0 @@
-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);
-        }
-        teardown(exit, (code) => {
-            if (receivedSignal || code !== 0) {
-                process.exit(code);
-            }
-        });
-    });
-    function onSigint() {
-        receivedSignal = true;
-        process.removeListener("SIGINT", onSigint);
-        process.removeListener("SIGTERM", onSigint);
-        fiber.unsafeInterruptAsFork(fiber.id());
-    }
-    process.on("SIGINT", onSigint);
-    process.on("SIGTERM", onSigint);
-    if (prevFiber) {
-        prevFiber.unsafeInterruptAsFork(prevFiber.id());
-    }
-});