@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-VANKHF46.js

@@ -0,0 +1,96 @@
+import {
+  algorithms,
+  compressTransform,
+  make
+} from "./chunk-3GR5VZ2M.js";
+import {
+  layer
+} from "./chunk-M32LDTW7.js";
+import {
+  pipeThroughDuplex
+} from "./chunk-XH4U3JSV.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/NodeHttpPlatform.js
+var NodeHttpPlatform_exports = {};
+__export(NodeHttpPlatform_exports, {
+  layer: () => layer3,
+  make: () => make3
+});
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as EtagImpl from "effect/unstable/http/Etag";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+import * as ServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as Mime from "effect/unstable/http/Mime";
+import * as Fs from "node:fs";
+import { Readable } from "node:stream";
+var compressedBody = (response, body) => ServerResponse.removeHeader(ServerResponse.setBody(response, body), "content-length");
+var compression = /* @__PURE__ */ make({
+  algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    switch (body._tag) {
+      case "Stream": {
+        return Effect.succeed(compressedBody(response, HttpBody.stream(pipeThroughDuplex(body.stream, {
+          evaluate: () => compressTransform(algorithm, options)
+        }), response.headers["content-type"] ?? body.contentType)));
+      }
+      case "Raw": {
+        const readable = body.body instanceof Readable ? body.body : Readable.fromWeb(new Response(body.body).body);
+        const transform = compressTransform(algorithm, options);
+        readable.on("error", (cause) => transform.destroy(cause));
+        transform.on("error", (cause) => readable.destroy(cause));
+        transform.on("close", () => readable.destroy());
+        return Effect.succeed(compressedBody(response, HttpBody.raw(readable.pipe(transform), {
+          contentType: response.headers["content-type"] ?? body.contentType
+        })));
+      }
+      default: {
+        return Effect.succeed(response);
+      }
+    }
+  }
+});
+var make3 = /* @__PURE__ */ Platform.make({
+  platform: "node",
+  compression,
+  fileResponse(path, status, statusText, headers, start, end, contentLength) {
+    const stream2 = contentLength === BigInt(0) ? Readable.from([]) : Fs.createReadStream(path, {
+      start,
+      end: end === void 0 ? void 0 : end - 1
+    });
+    return ServerResponse.raw(stream2, {
+      headers: {
+        ...headers,
+        "content-type": headers["content-type"] ?? Option.getOrElse(Mime.getType(path), () => "application/octet-stream"),
+        "content-length": contentLength.toString()
+      },
+      status,
+      statusText
+    });
+  },
+  fileWebResponse(file, status, statusText, headers, _options) {
+    return ServerResponse.raw(Readable.fromWeb(file.stream()), {
+      headers: Headers.merge(headers, Headers.fromRecordUnsafe({
+        "content-type": headers["content-type"] ?? Option.getOrElse(Mime.getType(file.name), () => "application/octet-stream"),
+        "content-length": file.size.toString()
+      })),
+      status,
+      statusText
+    });
+  }
+});
+var layer3 = /* @__PURE__ */ pipe(/* @__PURE__ */ Layer.effect(Platform.HttpPlatform)(make3), /* @__PURE__ */ Layer.provide(layer), /* @__PURE__ */ Layer.provide(EtagImpl.layer));
+
+export {
+  make3 as make,
+  layer3 as layer,
+  NodeHttpPlatform_exports
+};

package/dist/vendor/chunk-VZBDV3TV.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-UFH5UUZK.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/NodeCrypto.js
+var NodeCrypto_exports = {};
+__export(NodeCrypto_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeCrypto_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-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/node/NodeChildProcessSpawner.d.ts

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

package/dist/vendor/cjs/node/NodeChildProcessSpawner.js

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

package/dist/vendor/cjs/node/NodeClusterHttp.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Node.js HTTP and WebSocket layers for Effect 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.
+ * `layerHttpServer` provides the Node HTTP server used by cluster runners, and
+ * this module re-exports the Kubernetes HTTP client layer used by runner health
+ * checks.
+ *
+ * @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 type { NodeServices } from "./NodeServices.ts";
+export { 
+/**
+ * Provides the Kubernetes HTTP client layer used by Kubernetes runner health checks.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerK8sHttpClient } from "./NodeClusterSocket.ts";
+/**
+ * Builds the Node cluster HTTP/WebSocket sharding layer, configuring runner
+ * transport, RPC serialization, message storage, runner health checks, 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 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 | ("byo" extends Storage ? never : MessageStorage.MessageStorage), ServeError | Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+/**
+ * Provides the HTTP server and Node HTTP services used by cluster runners,
+ * listening on `ShardingConfig.runnerListenAddress` or `runnerAddress`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerHttpServer: Layer.Layer<HttpPlatform | Etag.Generator | NodeServices | HttpServer, ServeError, ShardingConfig.ShardingConfig>;
+//# sourceMappingURL=NodeClusterHttp.d.ts.map

package/dist/vendor/cjs/node/NodeClusterHttp.js

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

package/dist/vendor/cjs/node/NodeClusterSocket.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Node.js 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
+ * Kubernetes-aware Undici dispatcher and HTTP client layers for runner health
+ * checks.
+ *
+ * @since 4.0.0
+ */
+import { layerClientProtocol, layerSocketServer } from "../node-shared/NodeClusterSocket.js";
+import type { ConfigError } 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";
+import * as NodeHttpClient from "./NodeHttpClient.ts";
+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 Node cluster runners through the shared
+ * socket server implementation.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerSocketServer };
+/**
+ * Builds the Node cluster socket sharding layer, configuring RPC
+ * serialization, message storage, runner health checks, 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), 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 | ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+/**
+ * Provides an Undici dispatcher for Kubernetes API calls, using the service
+ * account CA certificate when it is available and falling back to the default
+ * dispatcher otherwise.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerDispatcherK8s: Layer.Layer<NodeHttpClient.Dispatcher>;
+/**
+ * Provides a `K8sHttpClient` backed by the Undici HTTP client and the
+ * Kubernetes-aware dispatcher.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient>;
+//# sourceMappingURL=NodeClusterSocket.d.ts.map

package/dist/vendor/cjs/node/NodeClusterSocket.js

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

package/dist/vendor/cjs/node/NodeCrypto.d.ts

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

package/dist/vendor/cjs/node/NodeCrypto.js

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

package/dist/vendor/cjs/node/NodeFileSystem.d.ts

@@ -0,0 +1,10 @@
+import type { FileSystem } from "effect/FileSystem";
+import type * as Layer from "effect/Layer";
+/**
+ * Provides the `FileSystem` service backed by Node filesystem APIs.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem>;
+//# sourceMappingURL=NodeFileSystem.d.ts.map

package/dist/vendor/cjs/node/NodeFileSystem.js

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