@smthrs/platform-bun 0.0.0-stage → 1.0.0-rc.3

package/dist/vendor/chunk-WIYD3THC.js

@@ -0,0 +1,31 @@
+import {
+  fromReadableStream
+} from "./chunk-NBYGGMAE.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunMultipart.js
+var BunMultipart_exports = {};
+__export(BunMultipart_exports, {
+  persisted: () => persisted,
+  stream: () => stream
+});
+import * as Stream from "effect/Stream";
+import * as Multipart from "effect/unstable/http/Multipart";
+var stream = (source) => fromReadableStream({
+  evaluate: () => source.body ?? new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array());
+      controller.close();
+    }
+  }),
+  onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+}).pipe(Stream.pipeThroughChannel(Multipart.makeChannel(Object.fromEntries(source.headers))));
+var persisted = (source) => Multipart.toPersisted(stream(source));
+
+export {
+  stream,
+  persisted,
+  BunMultipart_exports
+};

package/dist/vendor/chunk-XDKNKFBW.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  make
+} from "./chunk-TXKLEBBL.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer2,
+  make: () => make2
+});
+var make2 = make;
+var layer2 = layer;
+
+export {
+  make2 as make,
+  layer2 as layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-XH4U3JSV.js

@@ -0,0 +1,249 @@
+import {
+  pullIntoWritable
+} from "./chunk-OXNGN5H7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeStream.js
+var NodeStream_exports = {};
+__export(NodeStream_exports, {
+  fromDuplex: () => fromDuplex,
+  fromReadable: () => fromReadable,
+  fromReadableChannel: () => fromReadableChannel,
+  pipeThroughDuplex: () => pipeThroughDuplex,
+  pipeThroughSimple: () => pipeThroughSimple,
+  toArrayBuffer: () => toArrayBuffer,
+  toReadable: () => toReadable,
+  toReadableNever: () => toReadableNever,
+  toString: () => toString,
+  toUint8Array: () => toUint8Array
+});
+import * as Arr from "effect/Array";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as MutableRef from "effect/MutableRef";
+import * as Pull from "effect/Pull";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { Readable } from "node:stream";
+var fromReadable = (options) => Stream.fromChannel(fromReadableChannel(options));
+var fromReadableChannel = (options) => Channel.fromTransform((_, scope) => readableToPullUnsafe({
+  scope,
+  readable: options.evaluate(),
+  onError: options.onError ?? defaultOnError,
+  chunkSize: options.chunkSize,
+  closeOnDone: options.closeOnDone
+}));
+var fromDuplex = (options) => Channel.fromTransform((upstream, scope) => {
+  const duplex = options.evaluate();
+  const exit = MutableRef.make(void 0);
+  const latch = Latch.makeUnsafe(false);
+  return pullIntoWritable({
+    pull: upstream,
+    writable: duplex,
+    onError: options.onError ?? defaultOnError,
+    endOnDone: options.endOnDone,
+    encoding: options.encoding
+  }).pipe(Effect.catchCause((cause) => {
+    if (Pull.isDoneCause(cause)) return Effect.void;
+    exit.current = Exit.failCause(cause);
+    latch.openUnsafe();
+    return Effect.void;
+  }), Effect.forkIn(scope), Effect.flatMap(() => readableToPullUnsafe({
+    scope,
+    exit,
+    latch,
+    readable: duplex,
+    onError: options.onError ?? defaultOnError,
+    chunkSize: options.chunkSize
+  })));
+});
+var pipeThroughDuplex = /* @__PURE__ */ dual(2, (self, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(options)));
+var pipeThroughSimple = /* @__PURE__ */ dual(2, (self, duplex) => pipeThroughDuplex(self, {
+  evaluate: duplex
+}));
+var toReadable = (stream) => Effect.map(Effect.context(), (context2) => new StreamAdapter(context2, stream));
+var toReadableNever = (stream) => new StreamAdapter(Context.empty(), stream);
+var toString = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  const encoding = options?.encoding ?? "utf8";
+  return Effect.callback((resume) => {
+    const stream = readable();
+    stream.setEncoding(encoding);
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    let string = "";
+    let bytes = 0;
+    stream.once("end", () => {
+      resume(Effect.succeed(string));
+    });
+    stream.on("data", (chunk) => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toArrayBuffer = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  return Effect.callback((resume) => {
+    const stream = readable();
+    const buffers = [];
+    let bytes = 0;
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    stream.once("end", () => {
+      const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers);
+      if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) {
+        return resume(Effect.succeed(buffer.buffer));
+      }
+      resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)));
+    });
+    stream.on("data", (chunk) => {
+      buffers.push(chunk);
+      bytes += chunk.length;
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toUint8Array = (readable, options) => Effect.map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer));
+var readableToPullUnsafe = (options) => {
+  const readable = options.readable;
+  const closeOnDone = options.closeOnDone ?? true;
+  const exit = options.exit ?? MutableRef.make(void 0);
+  const latch = options.latch ?? Latch.makeUnsafe(false);
+  function onReadable() {
+    latch.openUnsafe();
+  }
+  function onError(error) {
+    exit.current = Exit.fail(options.onError(error));
+    latch.openUnsafe();
+  }
+  function onEnd() {
+    exit.current = Exit.fail(Cause.Done());
+    latch.openUnsafe();
+  }
+  readable.on("readable", onReadable);
+  readable.once("error", onError);
+  readable.once("end", onEnd);
+  const pull = Effect.suspend(function loop() {
+    let item = options.readable.read(options.chunkSize);
+    if (item === null) {
+      if (exit.current) {
+        return exit.current;
+      }
+      if (readable.readableEnded) {
+        return Effect.fail(Cause.Done());
+      }
+      latch.closeUnsafe();
+      return Effect.flatMap(latch.await, loop);
+    }
+    const chunk = Arr.of(item);
+    while (true) {
+      item = options.readable.read(options.chunkSize);
+      if (item === null) break;
+      chunk.push(item);
+    }
+    return Effect.succeed(chunk);
+  });
+  return Effect.as(Scope.addFinalizer(options.scope, Effect.sync(() => {
+    readable.off("readable", onReadable);
+    readable.off("error", onError);
+    readable.off("end", onEnd);
+    if (closeOnDone && "closed" in options.readable && !options.readable.closed) {
+      options.readable.destroy();
+    }
+  })), pull);
+};
+var StreamAdapter = class extends Readable {
+  readLatch;
+  fiber = void 0;
+  constructor(context2, stream) {
+    super({});
+    this.readLatch = Latch.makeUnsafe(false);
+    this.fiber = Stream.runForEachArray(stream, (chunk) => this.readLatch.whenOpen(Effect.sync(() => {
+      this.readLatch.closeUnsafe();
+      for (let i = 0; i < chunk.length; i++) {
+        const item = chunk[i];
+        if (typeof item === "string") {
+          this.push(item, "utf8");
+        } else {
+          this.push(item);
+        }
+      }
+    }))).pipe(this.readLatch.whenOpen, Effect.provideContext(context2), Effect.runFork);
+    this.fiber.addObserver((exit) => {
+      this.fiber = void 0;
+      if (Exit.isSuccess(exit)) {
+        this.push(null);
+      } else {
+        this.destroy(Cause.squash(exit.cause));
+      }
+    });
+  }
+  _read(_size) {
+    this.readLatch.openUnsafe();
+  }
+  _destroy(error, callback2) {
+    if (!this.fiber) {
+      return callback2(error);
+    }
+    Effect.runFork(Fiber.interrupt(this.fiber)).addObserver((exit) => {
+      callback2(exit._tag === "Failure" ? Cause.squash(exit.cause) : error);
+    });
+  }
+};
+var defaultOnError = (error) => new Cause.UnknownError(error);
+var toMaxBytes = (maxBytes) => maxBytes === void 0 || maxBytes === Infinity ? void 0 : Number(ByteSize.fromInputUnsafe(maxBytes));
+
+export {
+  fromReadable,
+  fromReadableChannel,
+  fromDuplex,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toReadable,
+  toReadableNever,
+  toString,
+  toArrayBuffer,
+  toUint8Array,
+  NodeStream_exports
+};

package/dist/vendor/chunk-XWPHMSXO.js

@@ -0,0 +1,28 @@
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "./chunk-DWSHTSVX.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunSocketServer.js
+var BunSocketServer_exports = {};
+__export(BunSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+
+export {
+  BunSocketServer_exports
+};

package/dist/vendor/chunk-Y35ZAO5U.js

@@ -0,0 +1,53 @@
+import {
+  layer
+} from "./chunk-DWSHTSVX.js";
+import {
+  makeNet
+} from "./chunk-JJ24ARBQ.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layerClientProtocol: () => layerClientProtocol,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { Socket } from "effect/unstable/socket/Socket";
+var layerClientProtocol = /* @__PURE__ */ Layer.effect(Runners.RpcClientProtocol)(/* @__PURE__ */ Effect.gen(function* () {
+  const serialization = yield* RpcSerialization.RpcSerialization;
+  return {
+    codecFor: serialization.codecFor,
+    make: Effect.fnUntraced(function* (address) {
+      const socket = yield* makeNet({
+        openTimeout: 1e3,
+        timeout: 5500,
+        host: address.host,
+        port: address.port
+      });
+      return yield* RpcClient.makeProtocolSocket().pipe(Effect.provideService(Socket, socket), Effect.provideService(RpcSerialization.RpcSerialization, serialization));
+    }, Effect.orDie)
+  };
+}));
+var layerSocketServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("layerSocketServer: ShardingConfig.runnerListenAddress is None");
+  }
+  return layer(listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layerClientProtocol,
+  layerSocketServer,
+  NodeClusterSocket_exports
+};

package/dist/vendor/cjs/bun/BunChildProcessSpawner.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bun implementation of `ChildProcessSpawner`.
+ *
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeChildProcessSpawner.js";
+//# sourceMappingURL=BunChildProcessSpawner.d.ts.map

package/dist/vendor/cjs/bun/BunChildProcessSpawner.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunChildProcessSpawner.js")

package/dist/vendor/cjs/bun/BunClusterHttp.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Bun HTTP and WebSocket layers for Effect Cluster runners.
+ *
+ * `layerHttpServer` provides the Bun HTTP server used by cluster runners. The
+ * main `layer` builds a sharding layer for HTTP or WebSocket transport,
+ * choosing serialization, runner health checks, runner storage, message
+ * storage, and optional client-only mode from the supplied options.
+ *
+ * @since 4.0.0
+ */
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import type { Sharding } from "effect/unstable/cluster/Sharding";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import type * as Etag from "effect/unstable/http/Etag";
+import type { HttpPlatform } from "effect/unstable/http/HttpPlatform";
+import type { HttpServer } from "effect/unstable/http/HttpServer";
+import type { ServeError } from "effect/unstable/http/HttpServerError";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import { layerK8sHttpClient } from "./BunClusterSocket.ts";
+import type { BunServices } from "./BunServices.ts";
+export { 
+/**
+ * Layer that provides a Kubernetes HTTP client for runner health checks.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerK8sHttpClient };
+/**
+ * Layer that provides a Bun HTTP server for cluster runners.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerHttpServer: Layer.Layer<HttpPlatform | Etag.Generator | BunServices | HttpServer, ServeError, ShardingConfig.ShardingConfig>;
+/**
+ * Creates Bun cluster layers for HTTP or WebSocket transport, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * **When to use**
+ *
+ * Use to install the complete Bun HTTP or WebSocket cluster layer, including
+ * client-only cluster access when a process should connect without serving
+ * runner RPCs.
+ *
+ * **Details**
+ *
+ * `serialization` defaults to SchemaBinary, `runnerHealth` defaults to ping
+ * checks, SQL-backed storage is used by default, and `shardingConfig` is
+ * overlaid on environment-loaded sharding configuration. `local` storage uses
+ * no-op message storage plus in-memory runner storage, while `byo` leaves both
+ * message and runner storage for the caller to provide.
+ *
+ * **Gotchas**
+ *
+ * `clientOnly` does not start the HTTP server or receive shard assignments.
+ * Non-client-only mode listens with `runnerListenAddress` when present, falling
+ * back to `runnerAddress`. HTTP and WebSocket runner RPCs use the default
+ * `HttpRunner` route.
+ *
+ * @see {@link layerHttpServer} for the server layer used by non-client-only transports
+ * @see {@link layerK8sHttpClient} for Kubernetes runner health support
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: <const ClientOnly extends boolean = false, const Storage extends "local" | "sql" | "byo" = never>(options: {
+    readonly transport: "http" | "websocket";
+    readonly serialization?: "binary" | "ndjson" | undefined;
+    readonly serializationMaxBufferSize?: number | "unbounded" | undefined;
+    readonly clientOnly?: ClientOnly | undefined;
+    readonly storage?: Storage | undefined;
+    readonly runnerHealth?: "ping" | "k8s" | undefined;
+    readonly runnerHealthK8s?: {
+        readonly namespace?: string | undefined;
+        readonly labelSelector?: string | undefined;
+    } | undefined;
+    readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined;
+}) => ClientOnly extends true ? Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient> : Layer.Layer<Sharding | Runners.Runners | MessageStorage.MessageStorage, ServeError | Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+//# sourceMappingURL=BunClusterHttp.d.ts.map

package/dist/vendor/cjs/bun/BunClusterHttp.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunClusterHttp.js")

package/dist/vendor/cjs/bun/BunClusterSocket.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Bun socket layers for Effect Cluster runners.
+ *
+ * The main `layer` builds a sharding layer for socket transport, choosing
+ * serialization, runner health checks, runner storage, message storage, and
+ * optional client-only mode from the supplied options. This module also
+ * re-exports the shared socket client and server protocol layers and provides
+ * `layerK8sHttpClient` for Kubernetes runner health checks.
+ *
+ * @since 4.0.0
+ */
+import { layerClientProtocol, layerSocketServer } from "../node-shared/NodeClusterSocket.js";
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import * as K8sHttpClient from "effect/unstable/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import type { Sharding } from "effect/unstable/cluster/Sharding";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import type * as SocketServer from "effect/unstable/socket/SocketServer";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+export { 
+/**
+ * Provides the cluster `RpcClientProtocol` using the shared socket client
+ * implementation.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerClientProtocol, 
+/**
+ * Provides the socket server used by Bun cluster runners through the shared
+ * socket server implementation.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerSocketServer };
+/**
+ * Creates Bun socket cluster layers, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: <const ClientOnly extends boolean = false, const Storage extends "local" | "sql" | "byo" = never>(options?: {
+    readonly serialization?: "binary" | "ndjson" | undefined;
+    readonly serializationMaxBufferSize?: number | "unbounded" | undefined;
+    readonly clientOnly?: ClientOnly | undefined;
+    readonly storage?: Storage | undefined;
+    readonly runnerHealth?: "ping" | "k8s" | undefined;
+    readonly runnerHealthK8s?: {
+        readonly namespace?: string | undefined;
+        readonly labelSelector?: string | undefined;
+    } | undefined;
+    readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined;
+}) => ClientOnly extends true ? Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient> : Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), SocketServer.SocketServerError | Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+/**
+ * Layer that provides `K8sHttpClient`, using the Kubernetes service-account CA certificate when it is available.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient>;
+//# sourceMappingURL=BunClusterSocket.d.ts.map

package/dist/vendor/cjs/bun/BunClusterSocket.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunClusterSocket.js")

package/dist/vendor/cjs/bun/BunCrypto.d.ts

@@ -0,0 +1,10 @@
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+/**
+ * Layer that provides the Bun Crypto service implementation.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<Crypto.Crypto>;
+//# sourceMappingURL=BunCrypto.d.ts.map

package/dist/vendor/cjs/bun/BunCrypto.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunCrypto.js")

package/dist/vendor/cjs/bun/BunFileSystem.d.ts

@@ -0,0 +1,10 @@
+import type { FileSystem } from "effect/FileSystem";
+import type * as Layer from "effect/Layer";
+/**
+ * Layer that provides the `FileSystem` service for Bun using the shared Node file-system implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem, never, never>;
+//# sourceMappingURL=BunFileSystem.d.ts.map

package/dist/vendor/cjs/bun/BunFileSystem.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunFileSystem.js")

package/dist/vendor/cjs/bun/BunHttpClient.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export * from "effect/unstable/http/FetchHttpClient";
+//# sourceMappingURL=BunHttpClient.d.ts.map

package/dist/vendor/cjs/bun/BunHttpClient.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunHttpClient.js")

package/dist/vendor/cjs/bun/BunHttpPlatform.d.ts

@@ -0,0 +1,10 @@
+import * as Layer from "effect/Layer";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+/**
+ * Layer that provides the Bun `HttpPlatform`, including file responses backed by `Bun.file`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Platform.HttpPlatform, never, never>;
+//# sourceMappingURL=BunHttpPlatform.d.ts.map

package/dist/vendor/cjs/bun/BunHttpPlatform.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunHttpPlatform.js")