effect-start 0.17.0 → 0.17.2

package/dist/bun/BunHttpServer_web.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;

package/dist/bun/BunHttpServer_web.js

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

@@ -0,0 +1,13 @@
+import { type BunPlugin, type Import } from "bun";
+export type ImportMap = ReadonlyMap<string, 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

@@ -0,0 +1,71 @@
+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/BunRoute.d.ts

@@ -0,0 +1,49 @@
+import type * as Bun from "bun";
+import * as Option from "effect/Option";
+import * as Route from "../Route.ts";
+import * as BunHttpServer from "./BunHttpServer.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): 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>]>;
+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
+ * - /*            - Catch-all
+ * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
+ * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ *
+ * 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

@@ -0,0 +1,131 @@
+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 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";
+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-${Random.token(6)}`;
+    const bunLoad = () => 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* BunHttpServer.BunHttpServer;
+            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
+ * - /*            - Catch-all
+ * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
+ * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ *
+ * 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 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)) {
+        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.`,
+        }));
+    }
+    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

@@ -0,0 +1 @@
+export declare const runMain: import("@effect/platform/Runtime").RunMain;

package/dist/bun/BunRuntime.js

@@ -0,0 +1,26 @@
+import { makeRunMain } from "@effect/platform/Runtime";
+import { constVoid } from "effect/Function";
+export const runMain = makeRunMain(({ fiber, teardown, }) => {
+    const keepAlive = setInterval(constVoid, 2 ** 31 - 1);
+    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);
+            }
+        });
+    });
+    function onSigint() {
+        receivedSignal = true;
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onSigint);
+        fiber.unsafeInterruptAsFork(fiber.id());
+    }
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigint);
+});

package/dist/bun/BunVirtualFilesPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { BunPlugin } from "bun";
+type VirtualFiles = Record<string, string>;
+export declare function make(files: VirtualFiles): BunPlugin;
+export {};

package/dist/bun/BunVirtualFilesPlugin.js

@@ -0,0 +1,40 @@
+function loaderFromPath(path) {
+    return path.slice(path.lastIndexOf(".") + 1);
+}
+export function make(files) {
+    return {
+        name: "virtual-fs",
+        setup(build) {
+            build.onResolve({
+                // change the filter so it only works for file namespace
+                filter: /.*/,
+            }, (args) => {
+                const resolved = resolvePath(args.path, args.resolveDir);
+                const resolvedFile = files[resolved];
+                if (resolvedFile) {
+                    return {
+                        path: resolved,
+                        namespace: "virtual-fs",
+                    };
+                }
+                return;
+            });
+            build.onLoad({
+                filter: /.*/,
+                namespace: "virtual-fs",
+            }, (args) => {
+                const contents = files[args.path];
+                if (!contents) {
+                    return undefined;
+                }
+                return {
+                    contents,
+                    loader: loaderFromPath(args.path),
+                };
+            });
+        },
+    };
+}
+function resolvePath(path, base = process.cwd()) {
+    return Bun.resolveSync(path, base);
+}