effect-start 0.22.0 → 0.23.0

package/dist/System.js

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import * as ChildProcess from "./ChildProcess.js";
+import * as PlatformError from "./PlatformError.js";
+export const cwd = Effect.sync(() => process.cwd());
+export const which = (name) => Effect.flatMap(Effect.try({
+    try: () => Bun.which(name),
+    catch: (err) => new PlatformError.SystemError({
+        reason: "Unknown",
+        module: "System",
+        method: "which",
+        description: err instanceof Error ? err.message : `Failed to look up "${name}"`,
+        cause: err,
+    }),
+}), (path) => path === null
+    ? Effect.fail(new PlatformError.SystemError({
+        reason: "NotFound",
+        module: "System",
+        method: "which",
+        description: `Executable not found: "${name}"`,
+    }))
+    : Effect.succeed(path));
+export const spawn = (command, args, options) => ChildProcess.spawn(ChildProcess.make(command, args, options));

package/dist/TuplePathPattern.js

@@ -1,63 +1,68 @@
 export function format(tuple) {
-    return "/" + tuple
-        .map((el) => {
-        if (typeof el === "string")
-            return el;
-        if (Array.isArray(el[0]))
-            return "[[" + el[0][0] + "]]";
-        const [name, suffix, prefix] = el;
-        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "");
-    })
-        .join("/");
+    return ("/" +
+        tuple
+            .map((el) => {
+            if (typeof el === "string")
+                return el;
+            if (Array.isArray(el[0]))
+                return "[[" + el[0][0] + "]]";
+            const [name, suffix, prefix] = el;
+            return (prefix ?? "") + "[" + name + "]" + (suffix ?? "");
+        })
+            .join("/"));
 }
 export function toColon(tuple) {
-    return "/" + tuple
-        .map((el) => {
-        if (typeof el === "string")
-            return el;
-        if (Array.isArray(el[0]))
-            return "*";
-        const [name, suffix, prefix] = el;
-        return (prefix ?? "") + ":" + name + (suffix ?? "");
-    })
-        .join("/");
+    return ("/" +
+        tuple
+            .map((el) => {
+            if (typeof el === "string")
+                return el;
+            if (Array.isArray(el[0]))
+                return "*";
+            const [name, suffix, prefix] = el;
+            return (prefix ?? "") + ":" + name + (suffix ?? "");
+        })
+            .join("/"));
 }
 export const toHono = toColon;
 export function toExpress(tuple) {
-    return "/" + tuple
-        .map((el) => {
-        if (typeof el === "string")
-            return el;
-        if (Array.isArray(el[0]))
-            return "*" + el[0][0];
-        const [name, suffix, prefix] = el;
-        return (prefix ?? "") + ":" + name + (suffix ?? "");
-    })
-        .join("/");
+    return ("/" +
+        tuple
+            .map((el) => {
+            if (typeof el === "string")
+                return el;
+            if (Array.isArray(el[0]))
+                return "*" + el[0][0];
+            const [name, suffix, prefix] = el;
+            return (prefix ?? "") + ":" + name + (suffix ?? "");
+        })
+            .join("/"));
 }
 export const toEffect = toColon;
 export function toURLPattern(tuple) {
-    return "/" + tuple
-        .map((el) => {
-        if (typeof el === "string")
-            return el;
-        if (Array.isArray(el[0]))
-            return ":" + el[0][0] + "+";
-        const [name, suffix, prefix] = el;
-        return (prefix ?? "") + ":" + name + (suffix ?? "");
-    })
-        .join("/");
+    return ("/" +
+        tuple
+            .map((el) => {
+            if (typeof el === "string")
+                return el;
+            if (Array.isArray(el[0]))
+                return ":" + el[0][0] + "+";
+            const [name, suffix, prefix] = el;
+            return (prefix ?? "") + ":" + name + (suffix ?? "");
+        })
+            .join("/"));
 }
 export function toRemix(tuple) {
-    return "/" + tuple
-        .map((el) => {
-        if (typeof el === "string")
-            return el;
-        if (Array.isArray(el[0]))
-            return "$";
-        const [name, suffix, prefix] = el;
-        return (prefix ?? "") + "$" + name + (suffix ?? "");
-    })
-        .join("/");
+    return ("/" +
+        tuple
+            .map((el) => {
+            if (typeof el === "string")
+                return el;
+            if (Array.isArray(el[0]))
+                return "$";
+            const [name, suffix, prefix] = el;
+            return (prefix ?? "") + "$" + name + (suffix ?? "");
+        })
+            .join("/"));
 }
 export const toBun = toColon;

package/dist/Unique.js

@@ -54,12 +54,12 @@ function uuid4bytes() {
 export function toTimestamp(bytes) {
     if (bytes.length < 6)
         return 0;
-    return (bytes[0] * 0x10000000000
-        + bytes[1] * 0x100000000
-        + bytes[2] * 0x1000000
-        + bytes[3] * 0x10000
-        + bytes[4] * 0x100
-        + bytes[5]);
+    return (bytes[0] * 0x10000000000 +
+        bytes[1] * 0x100000000 +
+        bytes[2] * 0x1000000 +
+        bytes[3] * 0x10000 +
+        bytes[4] * 0x100 +
+        bytes[5]);
 }
 export function uuid7Bytes(time = Date.now()) {
     const buf = new Uint8Array(16);
@@ -124,7 +124,7 @@ function formatUlid(bytes) {
 }
 function encodeUlidTime(time) {
     let value = BigInt(time);
-    const result = new Array(10);
+    const result = Array.from({ length: 10 });
     for (let i = 9; i >= 0; i--) {
         result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)];
         value >>= 5n;

package/dist/Values.d.ts

@@ -12,7 +12,7 @@ export declare function isPlainObject(value: unknown): value is Record<string, u
  * class instances or objects with methods.
  */
 type HasMethod<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? true : never;
+    [K in keyof T]: T[K] extends (...args: Array<any>) => any ? true : never;
 }[keyof T];
 export type IsPlainObject<T> = T extends object ? T extends Function ? false : HasMethod<T> extends never ? true : false : false;
 export type Simplify<T> = {
@@ -22,5 +22,6 @@ export type Simplify<T> = {
 } extends infer U ? {
     [K in keyof U]: U[K];
 } : never;
+export declare const firstValue: <T>(record: Record<string, T>) => T | undefined;
 export declare const concatBytes: (a: Uint8Array, b: Uint8Array) => Uint8Array;
 export {};

package/dist/Values.js

@@ -3,25 +3,31 @@ export function isPlainObject(value) {
         return false;
     }
     // Check for built-in types and web APIs
-    if (ArrayBuffer.isView(value)
-        || value instanceof ArrayBuffer
-        || value instanceof Blob
-        || value instanceof FormData
-        || value instanceof URLSearchParams
-        || value instanceof ReadableStream
-        || value instanceof Date
-        || value instanceof Map
-        || value instanceof Set
-        || value instanceof RegExp
-        || value instanceof Error
-        || value instanceof Promise
-        || Array.isArray(value)) {
+    if (ArrayBuffer.isView(value) ||
+        value instanceof ArrayBuffer ||
+        value instanceof Blob ||
+        value instanceof FormData ||
+        value instanceof URLSearchParams ||
+        value instanceof ReadableStream ||
+        value instanceof Date ||
+        value instanceof Map ||
+        value instanceof Set ||
+        value instanceof RegExp ||
+        value instanceof Error ||
+        value instanceof Promise ||
+        Array.isArray(value)) {
         return false;
     }
     // Check if it's a plain object (Object.prototype or null prototype)
     const proto = Object.getPrototypeOf(value);
     return proto === null || proto === Object.prototype;
 }
+export const firstValue = (record) => {
+    for (const key in record) {
+        return record[key];
+    }
+    return undefined;
+};
 export const concatBytes = (a, b) => {
     const result = new Uint8Array(a.byteLength + b.byteLength);
     result.set(a);

package/dist/bun/BunBlobStoreDisk.d.ts

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

package/dist/bun/BunBlobStoreDisk.js

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

package/dist/bun/BunBlobStoreS3.d.ts

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

package/dist/bun/BunBlobStoreS3.js

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

package/dist/bun/BunBlobWatcherDisk.d.ts

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

package/dist/bun/BunBlobWatcherDisk.js

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

package/dist/bun/BunBlobWatcherQueue.d.ts

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

package/dist/bun/BunBlobWatcherQueue.js

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

package/dist/bun/BunBundle.d.ts

@@ -1,12 +1,11 @@
 import type { BuildConfig } from "bun";
-import { Context, Effect, Layer } from "effect";
-import type { BundleContext } from "../bundler/Bundle.ts";
+import { type Context, Effect, Layer } from "effect";
 import * as Bundle from "../bundler/Bundle.ts";
 export type BuildOptions = Omit<BuildConfig, "outdir">;
-export declare const buildClient: (config: BuildOptions | string) => Effect.Effect<BundleContext, Bundle.BundleError, never>;
-export declare const buildServer: (config: BuildOptions | string) => Effect.Effect<BundleContext, Bundle.BundleError, never>;
+export declare const buildClient: (config: BuildOptions | string) => Effect.Effect<Bundle.BundleContext, Bundle.BundleError, never>;
+export declare const buildServer: (config: BuildOptions | string) => Effect.Effect<Bundle.BundleContext, Bundle.BundleError, never>;
 /**
  * Given a config, build a bundle and returns every time when effect is executed.
  */
-export declare function build(config: BuildOptions): Effect.Effect<BundleContext, Bundle.BundleError>;
-export declare function layer<T>(tag: Context.Tag<T, BundleContext>, config: BuildOptions): Layer.Layer<T, Bundle.BundleError, never>;
+export declare function build(config: BuildOptions): Effect.Effect<Bundle.BundleContext, Bundle.BundleError>;
+export declare function layer<T>(tag: Context.Tag<T, Bundle.BundleContext>, config: BuildOptions): Layer.Layer<T, Bundle.BundleError, never>;

package/dist/bun/BunBundle.js

@@ -1,4 +1,4 @@
-import { Array, Effect, Iterable, Layer, pipe, Record, } from "effect";
+import { Array, Effect, Iterable, Layer, pipe, Record } from "effect";
 import * as NPath from "node:path";
 import * as Bundle from "../bundler/Bundle.js";
 export const buildClient = (config) => {
@@ -58,9 +58,7 @@ export function build(config) {
             return manifest.entrypoints[path] ?? null;
         };
         const getArtifact = (path) => {
-            return artifactsMap[resolve(path)]
-                ?? artifactsMap[path]
-                ?? null;
+            return artifactsMap[resolve(path)] ?? artifactsMap[path] ?? null;
         };
         return {
             ...manifest,
@@ -81,9 +79,9 @@ function getBaseDir(paths) {
     if (paths.length === 1)
         return NPath.dirname(paths[0]);
     const segmentsList = paths.map((path) => NPath.dirname(path).split("/").filter(Boolean));
-    return segmentsList[0]
+    return (segmentsList[0]
         .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
-        .reduce((path, seg) => `${path}/${seg}`, "") ?? "";
+        .reduce((path, seg) => `${path}/${seg}`, "") ?? "");
 }
 /**
  * Maps entrypoints to their respective build artifacts.
@@ -93,8 +91,7 @@ function joinBuildEntrypoints(options, output) {
     const commonPathPrefix = getBaseDir(options.entrypoints) + "/";
     return pipe(Iterable.zip(options.entrypoints, pipe(output.outputs, 
     // Filter out source maps to properly map artifacts to entrypoints.
-    Iterable.filter((v) => v.kind !== "sourcemap"
-        && !(v.loader === "html" && v.path.endsWith(".js"))))), Iterable.map(([entrypoint, artifact]) => {
+    Iterable.filter((v) => v.kind !== "sourcemap" && !(v.loader === "html" && v.path.endsWith(".js"))))), Iterable.map(([entrypoint, artifact]) => {
         return {
             shortPath: entrypoint.replace(commonPathPrefix, ""),
             fullPath: entrypoint,
@@ -109,10 +106,7 @@ function joinBuildEntrypoints(options, output) {
 function generateManifestfromBunBundle(options, output, imports) {
     const entrypointArtifacts = joinBuildEntrypoints(options, output);
     return {
-        entrypoints: pipe(entrypointArtifacts, Iterable.map((v) => [
-            v.shortPath,
-            v.artifact.path.replace(/^\.\//, ""),
-        ]), Record.fromEntries),
+        entrypoints: pipe(entrypointArtifacts, Iterable.map((v) => [v.shortPath, v.artifact.path.replace(/^\.\//, "")]), Record.fromEntries),
         artifacts: pipe(output.outputs, Iterable.map((v) => {
             // strip './' prefix
             const shortPath = v.path.replace(/^\.\//, "");
@@ -131,9 +125,7 @@ function buildBun(config) {
         const buildOutput = yield* Effect.tryPromise({
             try: () => Bun.build(config),
             catch: (err) => {
-                const cause = err instanceof AggregateError
-                    ? err.errors?.[0] ?? err
-                    : err;
+                const cause = err instanceof AggregateError ? (err.errors?.[0] ?? err) : err;
                 return new Bundle.BundleError({
                     message: "Failed to Bun.build: " + cause,
                     cause: cause,

package/dist/bun/BunChildProcessSpawner.d.ts

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