effect-start 0.22.1 → 0.23.0

package/dist/bun/BunChildProcessSpawner.js

@@ -0,0 +1,103 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as ChildProcess from "../ChildProcess.js";
+import * as PlatformError from "../PlatformError.js";
+const toCmd = (command) => [
+    command.command,
+    ...command.args,
+];
+export const layer = Layer.succeed(ChildProcess.ChildProcessSpawner, {
+    spawn: (command) => Effect.gen(function* () {
+        const cmd = toCmd(command);
+        const proc = yield* Effect.try({
+            try: () => Bun.spawn(cmd, {
+                cwd: command.cwd,
+                env: command.env,
+                stdin: command.stdin ?? "ignore",
+                stdout: command.stdout ?? "pipe",
+                stderr: command.stderr ?? "pipe",
+                detached: command.detached,
+            }),
+            catch: (err) => new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "spawn",
+                description: err instanceof Error ? err.message : "Failed to spawn process",
+                cause: err,
+            }),
+        });
+        yield* Effect.addFinalizer(() => Effect.sync(() => {
+            if (!proc.killed) {
+                proc.kill();
+            }
+        }));
+        const handle = {
+            pid: proc.pid,
+            exitCode: Effect.tryPromise({
+                try: () => proc.exited,
+                catch: (err) => new PlatformError.SystemError({
+                    reason: "Unknown",
+                    module: "ChildProcess",
+                    method: "exitCode",
+                    description: "Process exited unexpectedly",
+                    cause: err,
+                }),
+            }),
+            isRunning: Effect.try({
+                try: () => !proc.killed && proc.exitCode === null,
+                catch: (err) => new PlatformError.SystemError({
+                    reason: "BadResource",
+                    module: "ChildProcess",
+                    method: "isRunning",
+                    description: err instanceof Error ? err.message : "Failed to check process status",
+                    cause: err,
+                }),
+            }),
+            kill: (options) => Effect.try({
+                try: () => {
+                    proc.kill(options?.killSignal);
+                },
+                catch: (err) => new PlatformError.SystemError({
+                    reason: "BadResource",
+                    module: "ChildProcess",
+                    method: "kill",
+                    description: err instanceof Error ? err.message : "Failed to kill process",
+                    cause: err,
+                }),
+            }),
+            stdin: Sink.forEach((chunk) => Effect.try({
+                try: () => {
+                    const sink = proc.stdin;
+                    sink.write(chunk);
+                },
+                catch: (err) => new PlatformError.SystemError({
+                    reason: "Unknown",
+                    module: "ChildProcess",
+                    method: "fromWritable(stdin)",
+                    description: "Failed to write to stdin",
+                    cause: err,
+                }),
+            })).pipe(Sink.ensuring(Effect.promise(async () => {
+                const sink = proc.stdin;
+                await sink.end();
+            }))),
+            stdout: Stream.fromReadableStream(() => proc.stdout, (err) => new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "fromReadable(stdout)",
+                description: "Failed to read stdout stream",
+                cause: err,
+            })),
+            stderr: Stream.fromReadableStream(() => proc.stderr, (err) => new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "fromReadable(stderr)",
+                description: "Failed to read stderr stream",
+                cause: err,
+            })),
+        };
+        return handle;
+    }),
+});

package/dist/bun/BunImportTrackerPlugin.d.ts

@@ -1,5 +1,5 @@
 import { type BunPlugin, type Import } from "bun";
-export type ImportMap = ReadonlyMap<string, Import[]>;
+export type ImportMap = ReadonlyMap<string, Array<Import>>;
 /**
  * Tracks all imported modules.
  * State can be accessed via 'virtual:import-tracker' module within a bundle

package/dist/bun/BunImportTrackerPlugin.js

@@ -18,14 +18,13 @@ export const make = (opts = {}) => {
             build.onLoad({
                 filter: /\.(ts|js)x?$/,
             }, async (args) => {
-                if (!opts.includeNodeModules
-                    && args.path.includes("/node_modules/")) {
+                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 resolvedImports = fileImport.map((imp) => {
                         const absoluteImportPath = NPath.resolve(NPath.dirname(args.path), 
                         // 'file' is a default namespace, trim it
                         imp.path.replace(/^file:/, ""));
@@ -39,8 +38,7 @@ export const make = (opts = {}) => {
                     });
                     foundImports.set(NPath.relative(baseDir, args.path), resolvedImports);
                 }
-                catch (e) {
-                }
+                catch (e) { }
                 return undefined;
             });
             build.onResolve({

package/dist/bun/BunRoute.d.ts

@@ -16,9 +16,10 @@ export type BunDescriptors = {
     bunLoad: () => Promise<Bun.HTMLBundle>;
 };
 export declare function descriptors(route: Route.Route.Route<any, any, any, any, any>): BunDescriptors | undefined;
-export declare function htmlBundle(load: () => Promise<Bun.HTMLBundle | {
+type HTMLBundleModule = 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 & {
+};
+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;

package/dist/bun/BunRoute.js

@@ -14,15 +14,14 @@ 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") {
+    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 = () => load().then(mod => "default" in mod ? mod.default : mod);
+    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* () {
@@ -116,8 +115,7 @@ export function validateBunPattern(pattern) {
     return Option.none();
 }
 export const isHtmlBundle = (handle) => {
-    return (typeof handle === "object"
-        && handle !== null
-        && (handle.toString() === "[object HTMLBundle]"
-            || typeof handle.index === "string"));
+    return (typeof handle === "object" &&
+        handle !== null &&
+        (handle.toString() === "[object HTMLBundle]" || typeof handle.index === "string"));
 };

package/dist/bun/BunRuntime.js

@@ -2,7 +2,7 @@ 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, }) => {
+export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
     const prevFiber = MutableRef.get(mainFiber);
     MutableRef.set(mainFiber, fiber);
     let receivedSignal = false;

package/dist/bun/BunServer.d.ts

@@ -1,10 +1,17 @@
-import * as Bun from "bun";
+import * as Socket from "../Socket.ts";
+import type * as Bun from "bun";
 import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
 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>;
+export interface WebSocketContext {
+    readonly deferred: Deferred.Deferred<Bun.ServerWebSocket<WebSocketContext>>;
+    readonly closeDeferred: Deferred.Deferred<void, Socket.SocketError>;
+    readonly buffer: Array<Uint8Array | string>;
+    run: (_: Uint8Array | string) => void;
+}
+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
@@ -19,7 +26,7 @@ interface BunServeOptions {
     readonly development?: boolean;
 }
 export type BunServer = {
-    readonly server: Bun.Server<BunServerRequest.WebSocketContext>;
+    readonly server: Bun.Server<WebSocketContext>;
     readonly pushHandler: (fetch: FetchHandler) => void;
     readonly popHandler: () => void;
 };

package/dist/bun/BunServer.js

@@ -1,5 +1,4 @@
-import * as Socket from "@effect/platform/Socket";
-import * as Bun from "bun";
+import * as Socket from "../Socket.js";
 import * as Config from "effect/Config";
 import * as Context from "effect/Context";
 import * as Deferred from "effect/Deferred";
@@ -8,6 +7,8 @@ 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 NOs from "node:os";
+import * as NPath from "node:path";
 import * as PathPattern from "../PathPattern.js";
 import * as PlataformRuntime from "../PlatformRuntime.js";
 import * as Route from "../Route.js";
@@ -22,7 +23,8 @@ export const make = (options) => Effect.gen(function* () {
             ? Effect.succeed(0) // random port
             : Effect.succeed(3000);
     }));
-    const hostname = yield* Config.string("HOSTNAME").pipe(Effect.catchTag("ConfigError", () => Effect.succeed(undefined)));
+    const hostFlag = process.argv.includes("--host");
+    const hostname = yield* Config.string("HOSTNAME").pipe(Effect.catchTag("ConfigError", () => Effect.succeed(hostFlag ? "0.0.0.0" : undefined)));
     const handlerStack = [
         function (_request, _server) {
             return new Response("not found", { status: 404 });
@@ -46,9 +48,7 @@ export const make = (options) => Effect.gen(function* () {
         },
     });
     const runtime = yield* Effect.runtime().pipe(Effect.andThen(Runtime.provideService(BunServer, service)));
-    let currentRoutes = routes
-        ? yield* walkBunRoutes(runtime, routes)
-        : {};
+    let currentRoutes = routes ? yield* walkBunRoutes(runtime, routes) : {};
     const websocket = {
         open(ws) {
             Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws));
@@ -66,7 +66,7 @@ export const make = (options) => Effect.gen(function* () {
                 : Exit.void);
         },
     };
-    const server = Bun.serve({
+    const server = Bun?.serve({
         port,
         hostname,
         ...options,
@@ -103,9 +103,11 @@ export const make = (options) => Effect.gen(function* () {
  * 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));
+export const withLogAddress = (layer) => Layer.effectDiscard(BunServer.pipe(Effect.andThen((server) => {
+    const { hostname, port } = server.server;
+    const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost";
+    return Effect.log(`Listening on http://${addr}:${port}`);
+}))).pipe(Layer.provideMerge(layer));
 function walkBunRoutes(runtime, tree) {
     return Effect.gen(function* () {
         const bunRoutes = {};
@@ -115,7 +117,12 @@ function walkBunRoutes(runtime, tree) {
             const bunDescriptors = BunRoute.descriptors(route);
             if (bunDescriptors) {
                 const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad);
-                bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle;
+                if (htmlBundle.files) {
+                    registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes);
+                }
+                else {
+                    bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle;
+                }
             }
             const path = Route.descriptor(route).path;
             const group = pathGroups.get(path) ?? [];
@@ -131,3 +138,20 @@ function walkBunRoutes(runtime, tree) {
         return bunRoutes;
     });
 }
+function registerPrebuiltBundle(prefix, bundle, bunRoutes) {
+    const mainDir = NPath.dirname(Bun.main);
+    const indexPath = NPath.resolve(mainDir, bundle.index);
+    bunRoutes[`${prefix}/*`] = () => new Response(Bun.file(indexPath), { headers: { "content-type": "text/html;charset=utf-8" } });
+    for (const file of bundle.files ?? []) {
+        if (file.loader === "html")
+            continue;
+        const absPath = NPath.resolve(mainDir, file.path);
+        const basename = NPath.basename(file.path);
+        bunRoutes[`/${basename}`] = () => new Response(Bun.file(absPath), { headers: file.headers ?? {} });
+    }
+}
+function getLocalIp() {
+    return Object.values(NOs.networkInterfaces())
+        .flatMap((addresses) => addresses ?? [])
+        .find((addr) => addr.family === "IPv4" && !addr.internal)?.address;
+}

package/dist/bun/BunSql.d.ts

@@ -0,0 +1,4 @@
+import * as Layer from "effect/Layer";
+import * as Sql from "../Sql.ts";
+export declare const layer: (config: Sql.SqlClientConfig) => Layer.Layer<Sql.SqlClient, Sql.SqlError>;
+export declare const layerMemory: Layer.Layer<Sql.SqlClient, Sql.SqlError>;

package/dist/bun/BunSql.js

@@ -0,0 +1,81 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FiberRef from "effect/FiberRef";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Sql from "../Sql.js";
+const wrapError = (error) => new Sql.SqlError({
+    code: error?.code ?? "UNKNOWN",
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+});
+const wrapQuery = (promise) => Effect.tryPromise({ try: () => promise, catch: wrapError });
+const makeValues = (obj, ...columns) => {
+    const items = Array.isArray(obj) ? obj : [obj];
+    const cols = columns.length > 0 ? columns : Object.keys(items[0]);
+    return { value: items, columns: cols };
+};
+const currentTransaction = GlobalValue.globalValue(Symbol.for("effect-start/BunSql/currentTransaction"), () => FiberRef.unsafeMake(Option.none()));
+const runQuery = (bunSql, strings, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    if (Option.isSome(txOpt)) {
+        return wrapQuery(txOpt.value.conn(strings, ...values));
+    }
+    return wrapQuery(bunSql(strings, ...values));
+});
+const runUnsafe = (bunSql, query, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    if (Option.isSome(txOpt)) {
+        return wrapQuery(txOpt.value.conn.unsafe(query, values));
+    }
+    return wrapQuery(bunSql.unsafe(query, values));
+});
+const makeWithTransaction = (bunSql) => (self) => Effect.uninterruptibleMask((restore) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    if (Option.isSome(txOpt)) {
+        const { conn, depth } = txOpt.value;
+        const name = `sp_${depth}`;
+        return Effect.gen(function* () {
+            yield* wrapQuery(conn.unsafe(`SAVEPOINT ${name}`));
+            const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 }))));
+            if (Exit.isSuccess(exit)) {
+                yield* wrapQuery(conn.unsafe(`RELEASE SAVEPOINT ${name}`));
+                return exit.value;
+            }
+            yield* wrapQuery(conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)).pipe(Effect.orDie);
+            return yield* exit;
+        });
+    }
+    const runTx = (conn) => Effect.gen(function* () {
+        yield* wrapQuery(conn.unsafe("BEGIN"));
+        const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: 1 }))));
+        if (Exit.isSuccess(exit)) {
+            yield* wrapQuery(conn.unsafe("COMMIT"));
+            return exit.value;
+        }
+        yield* wrapQuery(conn.unsafe("ROLLBACK")).pipe(Effect.orDie);
+        return yield* exit;
+    });
+    return Effect.matchEffect(Effect.tryPromise({ try: () => bunSql.reserve(), catch: wrapError }), {
+        onFailure: () => runTx(bunSql),
+        onSuccess: (reserved) => Effect.ensuring(runTx(reserved), Effect.sync(() => reserved.release())),
+    });
+}));
+export const layer = (config) => Layer.scoped(Sql.SqlClient, Effect.acquireRelease(Effect.try({
+    try: () => {
+        const bunSql = new Bun.SQL(config);
+        return Object.assign((strings, ...values) => runQuery(bunSql, strings, values), {
+            unsafe: (query, values) => runUnsafe(bunSql, query, values),
+            values: makeValues,
+            withTransaction: makeWithTransaction(bunSql),
+            reserve: Effect.acquireRelease(Effect.tryPromise({ try: () => bunSql.reserve(), catch: wrapError }), (reserved) => Effect.sync(() => reserved.release())).pipe(Effect.map((reserved) => Object.assign((strings, ...values) => wrapQuery(reserved(strings, ...values)), {
+                unsafe: (query, values) => wrapQuery(reserved.unsafe(query, values)),
+                values: makeValues,
+            }))),
+            close: (options) => wrapQuery(bunSql.close(options)),
+        });
+    },
+    catch: wrapError,
+}), (client) => client.close().pipe(Effect.orDie)));
+export const layerMemory = layer({
+    adapter: "sqlite",
+    filename: ":memory:",
+});

package/dist/bun/_BunEnhancedResolve.d.ts

@@ -26,9 +26,9 @@ interface ResolveContext {
     yield?: (request: ResolveRequest) => void;
 }
 interface ResolveOptions {
-    extensions?: string[];
-    mainFields?: (string | string[])[];
-    conditionNames?: string[];
+    extensions?: Array<string>;
+    mainFields?: Array<string | string[]>;
+    conditionNames?: Array<string>;
     fileSystem?: unknown;
     useSyncFileSystemCalls?: boolean;
     modules?: string | string[];

package/dist/bun/_BunEnhancedResolve.js

@@ -13,7 +13,7 @@ export class CachedInputFileSystem {
 export const ResolverFactory = {
     createResolver(options) {
         const extensions = options.extensions ?? [];
-        const mainFields = (options.mainFields ?? []).flatMap((f) => Array.isArray(f) ? f : [f]);
+        const mainFields = (options.mainFields ?? []).flatMap((f) => (Array.isArray(f) ? f : [f]));
         const conditionNames = options.conditionNames ?? [];
         return {
             resolve(_context, basePath, id, _resolveContext, callback) {
@@ -70,9 +70,7 @@ function resolveSync(id, base, options) {
 }
 function resolvePackagePath(id, base) {
     const parts = id.split("/");
-    const packageName = id.startsWith("@")
-        ? parts.slice(0, 2).join("/")
-        : parts[0];
+    const packageName = id.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
     let dir = base;
     while (dir !== path.dirname(dir)) {
         const candidate = path.join(dir, "node_modules", packageName);

package/dist/bun/index.d.ts

@@ -1,3 +1,4 @@
+export * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts";
 export * as BunBundle from "./BunBundle.ts";
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts";
 export * as BunRoute from "./BunRoute.ts";

package/dist/bun/index.js

@@ -1,3 +1,4 @@
+export * as BunChildProcessSpawner from "./BunChildProcessSpawner.js";
 export * as BunBundle from "./BunBundle.js";
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.js";
 export * as BunRoute from "./BunRoute.js";

package/dist/bundler/Bundle.d.ts

@@ -1,4 +1,5 @@
-import { Context, Effect, PubSub } from "effect";
+import type { PubSub } from "effect";
+import { Context, Effect } from "effect";
 import * as Schema from "effect/Schema";
 export declare const BundleEntrypointMetaKey: unique symbol;
 export type BundleOutputMetaValue = {};

package/dist/bundler/Bundle.js

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, pipe, } from "effect";
+import { Context, Data, Effect, pipe } from "effect";
 import * as Schema from "effect/Schema";
 export const BundleEntrypointMetaKey = Symbol.for("effect-start/BundleEntrypointMetaKey");
 /**

package/dist/bundler/BundleFiles.d.ts

@@ -1,13 +1,13 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "../FileSystem.ts";
 import * as Effect from "effect/Effect";
-import { type BundleContext, BundleError } from "./Bundle.ts";
+import * as Bundle from "./Bundle.ts";
 /**
  * Exports a bundle to a file system under specified directory.
  */
-export declare const toFiles: (context: BundleContext, outDir: string) => Effect.Effect<undefined, import("@effect/platform/Error").PlatformError | BundleError, FileSystem.FileSystem>;
+export declare const toFiles: (context: Bundle.BundleContext, outDir: string) => Effect.Effect<undefined, import("../PlatformError.ts").PlatformError | Bundle.BundleError, FileSystem.FileSystem>;
 /**
- * Loads a bundle from a directory and returns a BundleContext.
+ * Loads a bundle from a directory and returns a Bundle.BundleContext.
  * Expects the directory to contain a manifest.json file and all the artifacts
  * referenced in the manifest.
  */
-export declare const fromFiles: (directory: string) => Effect.Effect<BundleContext, BundleError, FileSystem.FileSystem>;
+export declare const fromFiles: (directory: string) => Effect.Effect<Bundle.BundleContext, Bundle.BundleError, FileSystem.FileSystem>;

package/dist/bundler/BundleFiles.js

@@ -1,11 +1,11 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "../FileSystem.js";
 import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Iterable from "effect/Iterable";
 import * as Record from "effect/Record";
 import * as S from "effect/Schema";
-import { BundleError, BundleManifestSchema, } from "./Bundle.js";
+import * as Bundle from "./Bundle.js";
 /**
  * Exports a bundle to a file system under specified directory.
  */
@@ -27,7 +27,9 @@ export const toFiles = (context, outDir) => {
             ...bundleArtifacts,
             ...extraArtifacts,
         };
-        const existingOutDirFiles = yield* fs.readDirectory(normalizedOutDir).pipe(Effect.catchAll(() => Effect.succeed(null)));
+        const existingOutDirFiles = yield* fs
+            .readDirectory(normalizedOutDir)
+            .pipe(Effect.catchAll(() => Effect.succeed(null)));
         // check if the output directory is empty. if it contains previous build,
         // remove it. Otherwise fail.
         if (existingOutDirFiles && existingOutDirFiles.length > 0) {
@@ -38,7 +40,7 @@ export const toFiles = (context, outDir) => {
                 });
             }
             else {
-                return yield* Effect.fail(new BundleError({
+                return yield* Effect.fail(new Bundle.BundleError({
                     message: "Output directory is not empty",
                 }));
             }
@@ -49,7 +51,7 @@ export const toFiles = (context, outDir) => {
         // write all artifacts to files
         yield* Effect.all(Function.pipe(allArtifacts, Record.toEntries, Array.map(([p, b]) => Function.pipe(Effect.tryPromise({
             try: () => b.arrayBuffer(),
-            catch: (e) => new BundleError({
+            catch: (e) => new Bundle.BundleError({
                 message: "Failed to read an artifact as a buffer",
                 cause: e,
             }),
@@ -57,7 +59,7 @@ export const toFiles = (context, outDir) => {
     });
 };
 /**
- * Loads a bundle from a directory and returns a BundleContext.
+ * Loads a bundle from a directory and returns a Bundle.BundleContext.
  * Expects the directory to contain a manifest.json file and all the artifacts
  * referenced in the manifest.
  */
@@ -65,12 +67,12 @@ export const fromFiles = (directory) => {
     return Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
         const normalizedDir = directory.replace(/\/$/, "");
-        const manifest = yield* Function.pipe(fs.readFileString(`${normalizedDir}/manifest.json`), Effect.andThen((v) => JSON.parse(v)), Effect.andThen(S.decodeUnknownSync(BundleManifestSchema)), Effect.catchAll((e) => Effect.fail(new BundleError({
+        const manifest = yield* Function.pipe(fs.readFileString(`${normalizedDir}/manifest.json`), Effect.andThen((v) => JSON.parse(v)), Effect.andThen(S.decodeUnknownSync(Bundle.BundleManifestSchema)), Effect.catchAll((e) => Effect.fail(new Bundle.BundleError({
             message: `Failed to read manifest.json from ${normalizedDir}`,
             cause: e,
         }))));
         const artifactPaths = Array.map(manifest.artifacts, (a) => a.path);
-        const artifactBlobs = yield* Function.pipe(artifactPaths, Iterable.map((path) => fs.readFile(`${normalizedDir}/${path}`)), Effect.all, Effect.catchAll((e) => new BundleError({
+        const artifactBlobs = yield* Function.pipe(artifactPaths, Iterable.map((path) => fs.readFile(`${normalizedDir}/${path}`)), Effect.all, Effect.catchAll((e) => new Bundle.BundleError({
             message: `Failed to read an artifact from ${normalizedDir}`,
             cause: e,
         })), Effect.andThen(Iterable.map((v, i) => new Blob([v.slice(0)], {

package/dist/bundler/BundleRoute.d.ts

@@ -0,0 +1,27 @@
+import type * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as PathPattern from "../PathPattern.ts";
+import * as Route from "../Route.ts";
+import * as Bundle from "./Bundle.ts";
+/**
+ * Creates a GET route that serves bundle artifacts.
+ * Mount at a path with a wildcard param (any name works).
+ *
+ * ```ts
+ * RouteTree.make({
+ *   "/_bundle/:path+": BundleRoute.make(Bundle.ClientBundle),
+ * })
+ * ```
+ */
+export declare const make: <Tag extends Context.Tag<any, Bundle.BundleContext>>(tag: Tag) => import("../RouteMount.ts").RouteMount.Builder<{}, [Route.Route.Route<{
+    method: "GET";
+    format: "*";
+}, {}, Uint8Array<ArrayBuffer>, never, any>]>;
+export declare const client: () => import("../RouteMount.ts").RouteMount.Builder<{}, [Route.Route.Route<{
+    method: "GET";
+    format: "*";
+}, {}, Uint8Array<ArrayBuffer>, never, any>]>;
+export declare const layer: (options?: {
+    bundle?: Context.Tag<any, Bundle.BundleContext>;
+    path?: PathPattern.PathPattern;
+}) => Layer.Layer<Route.Routes, never, never>;

package/dist/bundler/BundleRoute.js

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Entity from "../Entity.js";
+import * as PathPattern from "../PathPattern.js";
+import * as Route from "../Route.js";
+import * as RouteTree from "../RouteTree.js";
+import * as Values from "../Values.js";
+import * as Bundle from "./Bundle.js";
+/**
+ * Creates a GET route that serves bundle artifacts.
+ * Mount at a path with a wildcard param (any name works).
+ *
+ * ```ts
+ * RouteTree.make({
+ *   "/_bundle/:path+": BundleRoute.make(Bundle.ClientBundle),
+ * })
+ * ```
+ */
+export const make = (tag) => Route.get(Route.render(function* (ctx) {
+    const bundle = yield* tag;
+    const url = new URL(ctx.request.url);
+    const mountPath = ctx.path ?? "/";
+    const params = PathPattern.match(mountPath, url.pathname);
+    const artifactPath = params ? Values.firstValue(params) : undefined;
+    if (!artifactPath) {
+        return Entity.make(new Uint8Array(0), { status: 404 });
+    }
+    const blob = bundle.getArtifact(artifactPath);
+    if (!blob) {
+        return Entity.make(new Uint8Array(0), { status: 404 });
+    }
+    const bytes = new Uint8Array(yield* Effect.promise(() => blob.arrayBuffer()));
+    return Entity.make(bytes, {
+        headers: {
+            "content-type": blob.type || "application/octet-stream",
+            "cache-control": "public, max-age=31536000, immutable",
+        },
+    });
+}));
+export const client = () => make(Bundle.ClientBundle);
+export const layer = (options) => Layer.effect(Route.Routes, Effect.gen(function* () {
+    const existing = yield* Effect.serviceOption(Route.Routes).pipe(Effect.andThen(Option.getOrUndefined));
+    const path = options?.path ?? "/_bundle/:path+";
+    const bundleTree = Route.tree({
+        [path]: make(options?.bundle ?? Bundle.ClientBundle),
+    });
+    if (!existing)
+        return bundleTree;
+    return RouteTree.merge(existing, bundleTree);
+}));