@das-org/dascode 0.0.31

package/dist/BunHttpServer-YBQwrNiq.mjs

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+
+import { Ai as onExit, Do as provideMerge, Ea as withFiber, Eo as provide, Fo as addFinalizerExit, Gr as flatMap, Ii as promise, Ki as runForkWith, Ku as Class, No as Scope, Oo as succeed$2, Po as addFinalizer, Sa as void_$1, Sd as flow, To as mergeAll, Vi as raceFirst, Vr as fiber, Xi as scope, Xo as doneUnsafe, Yi as runSync, Yr as fnUntraced, Zi as scoped, aa as suspend, br as cached, cs as fail$1, eu as getUnsafe, fu as fromNullishOr, gs as void_, ha as try_, hs as succeed$1, is as makeUnsafe$1, ma as tryPromise, na as succeed, nu as makeUnsafe, oa as sync, pa as timeoutOrElse, qo as _await, tl as seconds, ui as isEffect, vl as isReadonlyArrayNonEmpty, vo as effect, ws as done, xr as callback, yi as map, zo as forkUnsafe, zr as fail } from "./Schema-DuQUv9rO.mjs";
+import { D as fromChannel, It as fromTransform, J as pipeThroughChannel, Sn as runIn, Ut as makeUnsafe$2, dt as toReadableStreamWith, mt as unwrap, x as fail$2 } from "./Path-BB53LP8h.mjs";
+import { Cn as parseHeader, Ft as TypeId$1, I as TypeId, It as inspect, K as toPersisted, O as scopeTransferToStream, P as HttpServerRequest, Q as defaultCloseCodeIsError, Sn as isEmpty, St as raw, T as layerWeak, Tn as toSetCookieHeaders, V as MultipartError, W as makeChannel, X as SocketError, Y as SocketCloseError, a as make$3, c as HttpPlatform, ct as HttpServerError, dn as fromInput$1, et as isCloseEvent, gn as fromInput, i as layerTestClient, it as make$4, k as toHandled, l as make$2, lt as RequestParseError, n as layer$3, ot as runtime, r as HttpServer, rt as join, st as ClientAbort, t as RequestInit, tt as make$5, w as layer$2 } from "./FetchHttpClient-BmjpVs1I.mjs";
+import { y as unwrap$1 } from "./Config-DcF-IZjO.mjs";
+import { layer as layer$5, t as layer$4 } from "./BunServices-RIDbItx-.mjs";
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunHttpPlatform.js
+/**
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = /*#__PURE__*/ make$2({
+	fileResponse(path, status, statusText, headers, start, end, _contentLength) {
+		let file = Bun.file(path);
+		if (start > 0 || end !== void 0) file = file.slice(start, end);
+		return raw(file, {
+			headers,
+			status,
+			statusText
+		});
+	},
+	fileWebResponse(file, status, statusText, headers, _options) {
+		return raw(file, {
+			headers,
+			status,
+			statusText
+		});
+	}
+});
+/**
+* Layer that provides the Bun `HttpPlatform`, including file responses backed by `Bun.file`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = /*#__PURE__*/ effect(HttpPlatform)(make$1).pipe(/*#__PURE__*/ provide(layer$4), /*#__PURE__*/ provide(layer$2));
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunStream.js
+/**
+* Bun stream interoperability for Effect streams.
+*
+* This module is the Bun entry point for adapting runtime streams into Effect's
+* streaming model. It re-exports the shared Node stream adapters for Bun's
+* Node-compatible stream APIs and adds {@link fromReadableStream}, a Web
+* `ReadableStream` adapter that uses Bun's `readMany` reader method to pull
+* batches of values into an Effect `Stream`.
+*
+* @since 4.0.0
+*/
+/**
+* Creates a stream from a `ReadableStream` using Bun's optimized `.readMany`
+* API.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromReadableStream = (options) => fromChannel(fromTransform(fnUntraced(function* (_, scope) {
+	const reader = options.evaluate().getReader();
+	yield* addFinalizer(scope, options.releaseLockOnEnd ? sync(() => reader.releaseLock()) : promise(() => reader.cancel()));
+	function readMany() {
+		const result = reader.readMany();
+		if ("then" in result) return callback((resume) => {
+			result.then((_) => resume(handleResult(_)), (e) => resume(fail(options.onError(e))));
+		});
+		return handleResult(result);
+	}
+	function handleResult(result) {
+		if (result.done) return done();
+		else if (!isReadonlyArrayNonEmpty(result.value)) return readMany();
+		return succeed(result.value);
+	}
+	return suspend(readMany);
+})));
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunMultipart.js
+/**
+* Parses a Bun `Request` body as multipart data and returns a stream of multipart parts.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const stream = (source) => fromReadableStream({
+	evaluate: () => source.body ?? emptyReadbleStream$1,
+	onError: (cause) => MultipartError.fromReason("InternalError", cause)
+}).pipe(pipeThroughChannel(makeChannel(Object.fromEntries(source.headers))));
+const emptyReadbleStream$1 = /*#__PURE__*/ new ReadableStream({ start(controller) {
+	controller.enqueue(/* @__PURE__ */ new Uint8Array());
+	controller.close();
+} });
+/**
+* Parses and persists multipart data from a Bun `Request`, requiring file-system, path, and scope services.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const persisted = (source) => toPersisted(stream(source));
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunHttpServer.js
+/**
+* Creates a scoped Bun `HttpServer` from `Bun.serve` options, stopping the server on scope finalization with optional graceful shutdown settings.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (options) {
+	const scope$1 = yield* scope;
+	const handlerStack = [function(_request, _server) {
+		return new Response("not found", { status: 404 });
+	}];
+	const server = Bun.serve({
+		...options,
+		fetch: handlerStack[0],
+		websocket: {
+			perMessageDeflate: {
+				compress: "dedicated",
+				decompress: "shared"
+			},
+			open(ws) {
+				doneUnsafe(ws.data.deferred, succeed$1(ws));
+			},
+			message(ws, message) {
+				ws.data.run(message);
+			},
+			close(ws, code, closeReason) {
+				code = typeof code === "number" ? code : 1001;
+				doneUnsafe(ws.data.closeDeferred, defaultCloseCodeIsError(code) ? fail$1(new SocketError({ reason: new SocketCloseError({
+					code,
+					closeReason
+				}) })) : void_);
+			}
+		}
+	});
+	const shutdown = yield* promise(() => server.stop()).pipe(cached);
+	const preemptiveShutdown = options.disablePreemptiveShutdown ? void_$1 : timeoutOrElse(shutdown, {
+		duration: options.gracefulShutdownTimeout ?? seconds(20),
+		orElse: () => void_$1
+	});
+	yield* addFinalizer(scope$1, shutdown);
+	return make$3({
+		address: {
+			_tag: "TcpAddress",
+			port: server.port,
+			hostname: server.hostname
+		},
+		serve: fnUntraced(function* (httpApp, middleware) {
+			const parent = yield* fiber;
+			const services = parent.context;
+			const serveScope = getUnsafe(services, Scope);
+			const scope = forkUnsafe(serveScope, "parallel");
+			const httpEffect = toHandled(httpApp, (request, response) => sync(() => {
+				request.resolve(makeResponse(request, response, services, scope));
+			}), middleware);
+			function handler(request, server) {
+				return new Promise((resolve, _reject) => {
+					const map = new Map(services.mapUnsafe);
+					map.set(HttpServerRequest.key, new BunServerRequest(request, resolve, removeHost(request.url), server));
+					const fiber = runIn(runForkWith(makeUnsafe(map))(httpEffect), scope);
+					request.signal.addEventListener("abort", () => {
+						fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+					}, { once: true });
+				});
+			}
+			yield* addFinalizerExit(serveScope, () => {
+				handlerStack.pop();
+				server.reload({ fetch: handlerStack[handlerStack.length - 1] });
+				return preemptiveShutdown;
+			});
+			handlerStack.push(handler);
+			server.reload({ fetch: handler });
+		})
+	});
+});
+const makeResponse = (request, response, context, scope) => {
+	const fields = {
+		headers: new globalThis.Headers(response.headers),
+		status: response.status
+	};
+	if (!isEmpty(response.cookies)) for (const header of toSetCookieHeaders(response.cookies)) fields.headers.append("set-cookie", header);
+	if (response.statusText !== void 0) fields.statusText = response.statusText;
+	if (request.method === "HEAD") return new Response(void 0, fields);
+	response = scopeTransferToStream(response);
+	const body = response.body;
+	switch (body._tag) {
+		case "Empty": return new Response(void 0, 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(toReadableStreamWith(unwrap(withFiber((fiber) => {
+			runIn(fiber, scope);
+			return succeed(body.stream);
+		})), context), fields);
+	}
+};
+/**
+* Layer that provides only `HttpServer` by constructing a scoped Bun server from the supplied serve options.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerServer = /*#__PURE__*/ flow(make, /*#__PURE__*/ effect(HttpServer));
+/**
+* Layer that provides Bun HTTP support services: `HttpPlatform`, weak ETag generation, and `BunServices`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerHttpServices = /*#__PURE__*/ mergeAll(layer$1, layerWeak, layer$5);
+/**
+* Layer that provides a Bun `HttpServer` together with the Bun HTTP platform, ETag generator, and Bun services.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = (options) => mergeAll(layerServer(options), layerHttpServices);
+/**
+* Layer that starts a Bun HTTP server on an ephemeral port for tests.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerTest = /*#__PURE__*/ layerTestClient.pipe(/*#__PURE__*/ provide(/*#__PURE__*/ layer$3.pipe(/*#__PURE__*/ provide(/*#__PURE__*/ succeed$2(RequestInit)({ keepalive: false })))), /*#__PURE__*/ provideMerge(/*#__PURE__*/ layer({ port: 0 })));
+/**
+* Creates the Bun HTTP server and support-services layer from configurable serve options.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerConfig = (options) => mergeAll(effect(HttpServer)(flatMap(unwrap$1(options), make)), layerHttpServices);
+function wsDefaultRun(_) {
+	this.buffer.push(_);
+}
+var BunServerRequest = class BunServerRequest extends Class {
+	[TypeId];
+	[TypeId$1];
+	source;
+	resolve;
+	url;
+	bunServer;
+	headersOverride;
+	remoteAddressOverride;
+	constructor(source, resolve, url, bunServer, headersOverride, remoteAddressOverride) {
+		super();
+		this[TypeId] = TypeId;
+		this[TypeId$1] = TypeId$1;
+		this.source = source;
+		this.resolve = resolve;
+		this.url = url;
+		this.bunServer = bunServer;
+		this.headersOverride = headersOverride;
+		this.remoteAddressOverride = remoteAddressOverride;
+	}
+	toJSON() {
+		return inspect(this, {
+			_id: "HttpServerRequest",
+			method: this.method,
+			url: this.originalUrl
+		});
+	}
+	modify(options) {
+		return new BunServerRequest(this.source, this.resolve, options.url ?? this.url, this.bunServer, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+	}
+	get method() {
+		return this.source.method.toUpperCase();
+	}
+	get originalUrl() {
+		return this.source.url;
+	}
+	get remoteAddress() {
+		return this.remoteAddressOverride ?? fromNullishOr(this.bunServer.requestIP(this.source)?.address);
+	}
+	get headers() {
+		this.headersOverride ??= fromInput(this.source.headers);
+		return this.headersOverride;
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = parseHeader(this.headers.cookie ?? "");
+	}
+	get stream() {
+		return this.source.body ? fromReadableStream({
+			evaluate: () => this.source.body ?? emptyReadbleStream,
+			onError: (cause) => new HttpServerError({ reason: new RequestParseError({
+				request: this,
+				cause
+			}) })
+		}) : fail$2(new HttpServerError({ reason: new RequestParseError({
+			request: this,
+			description: "can not create stream from empty body"
+		}) }));
+	}
+	textEffect;
+	get text() {
+		if (this.textEffect) return this.textEffect;
+		this.textEffect = runSync(cached(tryPromise({
+			try: () => this.source.text(),
+			catch: (cause) => new HttpServerError({ reason: new RequestParseError({
+				request: this,
+				cause
+			}) })
+		})));
+		return this.textEffect;
+	}
+	get json() {
+		return flatMap(this.text, (_) => try_({
+			try: () => JSON.parse(_),
+			catch: (cause) => new HttpServerError({ reason: new RequestParseError({
+				request: this,
+				cause
+			}) })
+		}));
+	}
+	get urlParamsBody() {
+		return flatMap(this.text, (_) => try_({
+			try: () => fromInput$1(new URLSearchParams(_)),
+			catch: (cause) => new HttpServerError({ reason: new RequestParseError({
+				request: this,
+				cause
+			}) })
+		}));
+	}
+	multipartEffect;
+	get multipart() {
+		if (this.multipartEffect) return this.multipartEffect;
+		this.multipartEffect = runSync(cached(persisted(this.source)));
+		return this.multipartEffect;
+	}
+	get multipartStream() {
+		return stream(this.source);
+	}
+	arrayBufferEffect;
+	get arrayBuffer() {
+		if (this.arrayBufferEffect) return this.arrayBufferEffect;
+		this.arrayBufferEffect = runSync(cached(tryPromise({
+			try: () => this.source.arrayBuffer(),
+			catch: (cause) => new HttpServerError({ reason: new RequestParseError({
+				request: this,
+				cause
+			}) })
+		})));
+		this.textEffect = map(this.arrayBufferEffect, (_) => new TextDecoder().decode(_));
+		return this.arrayBufferEffect;
+	}
+	get upgrade() {
+		return callback((resume) => {
+			const deferred = makeUnsafe$1();
+			const closeDeferred = makeUnsafe$1();
+			const semaphore = makeUnsafe$2(1);
+			if (!this.bunServer.upgrade(this.source, { data: {
+				deferred,
+				closeDeferred,
+				buffer: [],
+				run: wsDefaultRun
+			} })) {
+				resume(fail(new HttpServerError({ reason: new RequestParseError({
+					request: this,
+					description: "Not an upgradeable ServerRequest"
+				}) })));
+				return;
+			}
+			resume(map(_await(deferred), (ws) => {
+				const write = (chunk) => sync(() => {
+					if (typeof chunk === "string") ws.sendText(chunk);
+					else if (isCloseEvent(chunk)) ws.close(chunk.code, chunk.reason);
+					else ws.sendBinary(chunk);
+					return true;
+				});
+				const writer = succeed(write);
+				return make$5({
+					runRaw: fnUntraced(function* (handler, opts) {
+						const set = yield* make$4();
+						const run = yield* runtime(set)();
+						function runRaw(data) {
+							const result = handler(data);
+							if (isEffect(result)) run(result);
+						}
+						ws.data.run = runRaw;
+						ws.data.buffer.forEach(runRaw);
+						ws.data.buffer.length = 0;
+						if (opts?.onOpen) yield* opts.onOpen;
+						return yield* join(set);
+					}, scoped, onExit((exit) => sync(() => ws.close(exit._tag === "Success" ? 1e3 : 1011))), raceFirst(_await(closeDeferred)), semaphore.withPermits(1)),
+					writer
+				});
+			}));
+		});
+	}
+};
+const emptyReadbleStream = /*#__PURE__*/ new ReadableStream({ start(controller) {
+	controller.enqueue(/* @__PURE__ */ new Uint8Array());
+	controller.close();
+} });
+const removeHost = (url) => {
+	if (url[0] === "/") return url;
+	const index = url.indexOf("/", url.indexOf("//") + 2);
+	return index === -1 ? "/" : url.slice(index);
+};
+//#endregion
+export { layer, layerConfig, layerHttpServices, layerServer, layerTest, make };
+
+//# sourceMappingURL=BunHttpServer-YBQwrNiq.mjs.map

package/dist/BunPtyAdapter--Swo7U5P.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { E as Number$1, F as TaggedErrorClass, Fr as die, Jr as fn, _ as Literal, ha as try_, v as Literals, vo as effect } from "./Schema-DuQUv9rO.mjs";
+import { c as HostProcessPlatform, n as PtySpawnError, t as PtyAdapter } from "./PtyAdapter-mAqTlv3d.mjs";
+//#region src/terminal/BunPtyAdapter.ts
+var BunPtyUnsupportedPlatformError = class extends TaggedErrorClass()("BunPtyUnsupportedPlatformError", { platform: Literal("win32") }) {
+	get message() {
+		return `Bun PTY terminal support is unavailable on ${this.platform}. Please use Node.js (e.g. by running \`npx @das-org/dascode\`) instead.`;
+	}
+};
+var BunPtyOperationUnavailableError = class extends TaggedErrorClass()("BunPtyOperationUnavailableError", {
+	operation: Literals(["write", "resize"]),
+	pid: Number$1
+}) {
+	get message() {
+		return `Bun PTY ${this.operation} is unavailable for process ${this.pid}.`;
+	}
+};
+var BunPtyProcess = class {
+	dataListeners = /* @__PURE__ */ new Set();
+	exitListeners = /* @__PURE__ */ new Set();
+	decoder = new TextDecoder();
+	process;
+	didExit = false;
+	constructor(process) {
+		this.process = process;
+		this.process.exited.then((exitCode) => {
+			this.emitExit({
+				exitCode: Number.isInteger(exitCode) ? exitCode : 0,
+				signal: typeof this.process.signalCode === "number" ? this.process.signalCode : null
+			});
+		}).catch(() => {
+			this.emitExit({
+				exitCode: 1,
+				signal: null
+			});
+		});
+	}
+	get pid() {
+		return this.process.pid;
+	}
+	write(data) {
+		if (!this.process.terminal) throw new BunPtyOperationUnavailableError({
+			operation: "write",
+			pid: this.pid
+		});
+		this.process.terminal.write(data);
+	}
+	resize(cols, rows) {
+		if (!this.process.terminal?.resize) throw new BunPtyOperationUnavailableError({
+			operation: "resize",
+			pid: this.pid
+		});
+		this.process.terminal.resize(cols, rows);
+	}
+	kill(signal) {
+		if (!signal) {
+			this.process.kill();
+			return;
+		}
+		this.process.kill(signal);
+	}
+	onData(callback) {
+		this.dataListeners.add(callback);
+		return () => {
+			this.dataListeners.delete(callback);
+		};
+	}
+	onExit(callback) {
+		this.exitListeners.add(callback);
+		return () => {
+			this.exitListeners.delete(callback);
+		};
+	}
+	emitData(data) {
+		if (this.didExit) return;
+		const text = this.decoder.decode(data, { stream: true });
+		if (text.length === 0) return;
+		for (const listener of this.dataListeners) listener(text);
+	}
+	emitExit(event) {
+		if (this.didExit) return;
+		this.didExit = true;
+		const remainder = this.decoder.decode();
+		if (remainder.length > 0) for (const listener of this.dataListeners) listener(remainder);
+		for (const listener of this.exitListeners) listener(event);
+	}
+};
+const make = fn("BunPtyAdapter.make")(function* () {
+	const platform = yield* HostProcessPlatform;
+	if (platform === "win32") return yield* die(new BunPtyUnsupportedPlatformError({ platform }));
+	return PtyAdapter.of({ spawn: (input) => try_({
+		try: () => {
+			let processHandle = null;
+			const command = [input.shell, ...input.args ?? []];
+			processHandle = new BunPtyProcess(Bun.spawn(command, {
+				cwd: input.cwd,
+				env: input.env,
+				terminal: {
+					cols: input.cols,
+					rows: input.rows,
+					data: (_terminal, data) => {
+						processHandle?.emitData(data);
+					}
+				}
+			}));
+			return processHandle;
+		},
+		catch: (cause) => new PtySpawnError({
+			adapter: "bun",
+			shell: input.shell,
+			cause
+		})
+	}) });
+});
+const layer = effect(PtyAdapter, make());
+//#endregion
+export { BunPtyOperationUnavailableError, BunPtyUnsupportedPlatformError, layer, make };
+
+//# sourceMappingURL=BunPtyAdapter--Swo7U5P.mjs.map

package/dist/BunServices-RIDbItx-.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+import { Do as provideMerge, To as mergeAll } from "./Schema-DuQUv9rO.mjs";
+import { a as layer$9, c as layer$8, f as layer$11, l as layer$6, t as layer$10, u as layer$7 } from "./NodeTerminal-C6yhrF1E.mjs";
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunFileSystem.js
+/**
+* Bun layer for Effect's `FileSystem` service.
+*
+* This module exposes one `layer` that provides `FileSystem` in Bun by using
+* the shared Node file-system implementation. Once the layer is provided,
+* programs use the standard `effect/FileSystem` service operations.
+*
+* @since 4.0.0
+*/
+/**
+* Layer that provides the `FileSystem` service for Bun using the shared Node file-system implementation.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$5 = layer$6;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunCrypto.js
+/**
+* The `BunCrypto` module provides Bun's `Crypto` service layer for Effect
+* programs. Provide {@link layer} at the edge of a Bun app, CLI, script, or
+* test to satisfy `effect/Crypto` with cryptographically secure random bytes,
+* UUID generation, random values, and SHA digest operations.
+*
+* This adapter reuses the shared Node-compatible implementation, so randomness
+* and digest behavior follow Bun's `node:crypto` compatibility layer. SHA-1 is
+* present for interoperability with existing protocols, not for new
+* security-sensitive designs.
+*
+* @since 1.0.0
+*/
+/**
+* Layer that provides the Bun Crypto service implementation.
+*
+* @category layers
+* @since 1.0.0
+*/
+const layer$4 = layer$7;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunPath.js
+/**
+* Bun-backed layers for Effect's {@link Path} service.
+*
+* This module provides the `Path` service for Bun programs by reusing the
+* shared Node-compatible path implementation. Provide one of these layers when
+* Bun code should receive path operations from the Effect environment instead
+* of importing runtime path helpers directly.
+*
+* @since 4.0.0
+*/
+/**
+* Layer that provides the default `Path` service for Bun using the shared Node path implementation.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$3 = layer$8;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunStdio.js
+/**
+* Process stdio for Bun applications.
+*
+* This module provides the Bun layer for Effect's `Stdio` service by using the
+* shared Node stdio implementation. Arguments come from `process.argv`, input
+* is read from `process.stdin`, and output and error output write to
+* `process.stdout` and `process.stderr`.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the `Stdio` service backed by the current process arguments,
+* stdin, stdout, and stderr streams.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$2 = layer$9;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunTerminal.js
+/**
+* Bun-backed implementation of Effect's `Terminal` service.
+*
+* This module reuses the shared Node terminal implementation for Bun. `make`
+* creates a scoped process-backed `Terminal` service, and `layer` provides the
+* default terminal service with the standard quit behavior for key input.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the default process-backed `Terminal` service, ending key input on
+* the default quit keys.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = layer$10;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-bun@4.0.0-_eb85553ea6f9cc2fe0b2661a1d300123/node_modules/@effect/platform-bun/dist/BunServices.js
+/**
+* Provides the default Bun implementations for child process spawning,
+* filesystem, path, stdio, and terminal services.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ layer$11.pipe(/*#__PURE__*/ provideMerge(/*#__PURE__*/ mergeAll(layer$5, layer$4, layer$3, layer$2, layer$1)));
+//#endregion
+export { layer, layer$5 as t };
+
+//# sourceMappingURL=BunServices-RIDbItx-.mjs.map