@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/vendor/chunk-W4OASVX6.js

@@ -0,0 +1,92 @@
+import {
+  fromReadable,
+  toArrayBuffer
+} from "./chunk-Z7QPP4YH.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/NodeHttpIncomingMessage.js
+var NodeHttpIncomingMessage_exports = {};
+__export(NodeHttpIncomingMessage_exports, {
+  NodeHttpIncomingMessage: () => NodeHttpIncomingMessage
+});
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Headers from "effect/unstable/http/Headers";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+var NodeHttpIncomingMessage = class extends Inspectable.Class {
+  /**
+   * Marks this value as an HTTP incoming message for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [IncomingMessage.TypeId];
+  source;
+  onError;
+  remoteAddressOverride;
+  constructor(source, onError, remoteAddressOverride) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this.source = source;
+    this.onError = onError;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? Option.fromNullishOr(this.source.socket?.remoteAddress);
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = Effect.map(this.arrayBuffer, (_) => Buffer.from(_).toString("utf8"));
+    return this.textEffect;
+  }
+  get textUnsafe() {
+    return Effect.runSync(this.text);
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: this.onError
+    }));
+  }
+  get jsonUnsafe() {
+    return Effect.runSync(this.json);
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: this.onError
+    }));
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source,
+      onError: this.onError
+    });
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = Effect.withFiber((fiber) => toArrayBuffer(() => this.source, {
+      onError: this.onError,
+      maxBytes: fiber.getRef(IncomingMessage.MaxBodySize)
+    })).pipe(Effect.cached, Effect.runSync);
+    this.textEffect = Effect.map(this.arrayBufferEffect, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferEffect;
+  }
+};
+
+export {
+  NodeHttpIncomingMessage,
+  NodeHttpIncomingMessage_exports
+};

package/dist/vendor/chunk-WAII54GA.js

@@ -0,0 +1,18 @@
+import {
+  flattenCommand,
+  layer
+} from "./chunk-DZ2VOUDP.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/NodeChildProcessSpawner.js
+var NodeChildProcessSpawner_exports = {};
+__export(NodeChildProcessSpawner_exports, {
+  flattenCommand: () => flattenCommand,
+  layer: () => layer
+});
+
+export {
+  NodeChildProcessSpawner_exports
+};

package/dist/vendor/chunk-WECQDT36.js

@@ -0,0 +1,426 @@
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-W4OASVX6.js";
+import {
+  fromReadable,
+  toReadable
+} from "./chunk-Z7QPP4YH.js";
+import {
+  fromWritable
+} from "./chunk-37CUR3PO.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/NodeHttpClient.js
+var NodeHttpClient_exports = {};
+__export(NodeHttpClient_exports, {
+  Dispatcher: () => Dispatcher,
+  Fetch: () => Fetch,
+  HttpAgent: () => HttpAgent,
+  RequestInit: () => RequestInit,
+  UndiciOptions: () => UndiciOptions,
+  dispatcherLayerGlobal: () => dispatcherLayerGlobal,
+  layerAgent: () => layerAgent,
+  layerAgentOptions: () => layerAgentOptions,
+  layerDispatcher: () => layerDispatcher,
+  layerFetch: () => layer,
+  layerNodeHttp: () => layerNodeHttp,
+  layerNodeHttpNoAgent: () => layerNodeHttpNoAgent,
+  layerUndici: () => layerUndici,
+  layerUndiciNoDispatcher: () => layerUndiciNoDispatcher,
+  makeAgent: () => makeAgent,
+  makeDispatcher: () => makeDispatcher,
+  makeNodeHttp: () => makeNodeHttp,
+  makeUndici: () => makeUndici
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { flow } from "effect/Function";
+import * as Inspectable from "effect/Inspectable";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Stream from "effect/Stream";
+import * as Cookies from "effect/unstable/http/Cookies";
+import * as Headers from "effect/unstable/http/Headers";
+import * as Client from "effect/unstable/http/HttpClient";
+import * as Error from "effect/unstable/http/HttpClientError";
+import * as Response from "effect/unstable/http/HttpClientResponse";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import * as Http from "node:http";
+import * as Https from "node:https";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import {
+  Fetch,
+  layer,
+  RequestInit
+} from "effect/unstable/http/FetchHttpClient";
+var Dispatcher = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/Dispatcher")) {
+};
+var loadUndici = /* @__PURE__ */ Effect.promise(() => import("./node/Undici.js"));
+var makeDispatcher = /* @__PURE__ */ Effect.acquireRelease(/* @__PURE__ */ Effect.map(loadUndici, (_) => new _.Agent()), (dispatcher) => Effect.promise(() => dispatcher.destroy()));
+var layerDispatcher = /* @__PURE__ */ Layer.effect(Dispatcher)(makeDispatcher);
+var dispatcherLayerGlobal = /* @__PURE__ */ Layer.effect(Dispatcher)(/* @__PURE__ */ Effect.map(loadUndici, (_) => _.getGlobalDispatcher()));
+var UndiciOptions = /* @__PURE__ */ Context.Reference("@effect/platform-node/NodeHttpClient/UndiciOptions", {
+  defaultValue: () => ({})
+});
+var makeUndici = /* @__PURE__ */ Effect.gen(function* () {
+  const dispatcher = yield* Dispatcher;
+  return Client.make((request3, url, signal, fiber) => convertBody(request3.body).pipe(Effect.flatMap((body) => Effect.tryPromise({
+    try: () => dispatcher.request({
+      ...fiber.getRef(UndiciOptions),
+      signal,
+      method: request3.method,
+      headers: request3.headers,
+      origin: url.origin,
+      path: url.pathname + url.search,
+      body,
+      // leave timeouts to Effect.timeout etc
+      headersTimeout: 60 * 60 * 1e3,
+      bodyTimeout: 0
+    }),
+    catch: (cause) => new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })
+  })), Effect.map((response) => new UndiciResponse(request3, response, url.href.split("#")[0]))));
+});
+function convertBody(body) {
+  switch (body._tag) {
+    case "Empty": {
+      return Effect.succeed(null);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      return Effect.succeed(body.body);
+    }
+    case "FormData": {
+      return Effect.succeed(body.formData);
+    }
+    case "Stream": {
+      return toReadable(body.stream);
+    }
+  }
+}
+function noopErrorHandler(_) {
+}
+var UndiciResponse = class extends Inspectable.Class {
+  [IncomingMessage.TypeId];
+  [Response.TypeId];
+  request;
+  source;
+  url;
+  constructor(request3, source, url) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.source = source;
+    this.url = url;
+    source.body.on("error", noopErrorHandler);
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  get statusText() {
+    return void 0;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get remoteAddress() {
+    return Option.none();
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source.body,
+      onError: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    });
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  textBody;
+  get text() {
+    if (this.textBody) {
+      return this.textBody;
+    }
+    this.textBody = Effect.map(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+    return this.textBody;
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  formDataBody;
+  get formData() {
+    return this.formDataBody ??= Effect.flatMap(this.arrayBuffer, (body) => Effect.tryPromise({
+      try: () => new globalThis.Response(body, {
+        headers: this.headers
+      }).formData(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    })).pipe(Effect.cached, Effect.runSync);
+  }
+  arrayBufferBody;
+  get arrayBuffer() {
+    if (this.arrayBufferBody) {
+      return this.arrayBufferBody;
+    }
+    this.arrayBufferBody = Effect.tryPromise({
+      try: () => this.source.body.arrayBuffer(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(Effect.cached, Effect.runSync);
+    this.textBody = Effect.map(this.arrayBufferBody, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferBody;
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerUndiciNoDispatcher = /* @__PURE__ */ Client.layerMergedContext(makeUndici);
+var layerUndici = /* @__PURE__ */ Layer.provide(layerUndiciNoDispatcher, layerDispatcher);
+var HttpAgent = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/HttpAgent")) {
+};
+var makeAgent = (options) => Effect.zipWith(Effect.acquireRelease(Effect.sync(() => new Http.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), Effect.acquireRelease(Effect.sync(() => new Https.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), (http, https) => ({
+  http,
+  https
+}));
+var layerAgentOptions = /* @__PURE__ */ flow(makeAgent, /* @__PURE__ */ Layer.effect(HttpAgent));
+var layerAgent = /* @__PURE__ */ layerAgentOptions();
+var makeNodeHttp = /* @__PURE__ */ Effect.gen(function* () {
+  const agent = yield* HttpAgent;
+  return Client.make((request3, url, signal) => {
+    const nodeRequest = url.protocol === "https:" ? Https.request(url, {
+      agent: agent.https,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    }) : Http.request(url, {
+      agent: agent.http,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    });
+    return Effect.raceFirst(waitForResponse(nodeRequest, request3), sendBody(nodeRequest, request3, request3.body).pipe(Effect.andThen(Effect.never))).pipe(Effect.onError(() => Effect.sync(() => nodeRequest.destroy())), Effect.map((_) => new NodeHttpResponse(request3, _, url.href.split("#")[0])));
+  });
+});
+var sendBody = (nodeRequest, request3, body) => Effect.suspend(() => {
+  switch (body._tag) {
+    case "Empty": {
+      nodeRequest.end();
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      nodeRequest.end(body.body);
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "FormData": {
+      const response = new globalThis.Response(body.formData);
+      response.headers.forEach((value, key) => {
+        nodeRequest.setHeader(key, value);
+      });
+      return Effect.tryPromise({
+        try: () => pipeline(Readable.fromWeb(response.body), nodeRequest),
+        catch: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      });
+    }
+    case "Stream": {
+      return Stream.run(Stream.mapError(body.stream, (cause) => new Error.HttpClientError({
+        reason: new Error.EncodeError({
+          request: request3,
+          cause
+        })
+      })), fromWritable({
+        evaluate: () => nodeRequest,
+        onError: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      }));
+    }
+  }
+});
+var waitForResponse = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.on("error", onError2);
+  function onResponse(response) {
+    nodeRequest.off("error", onError2);
+    resume(Effect.succeed(response));
+  }
+  nodeRequest.on("upgrade", onResponse);
+  nodeRequest.on("response", onResponse);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("upgrade", onResponse);
+    nodeRequest.off("response", onResponse);
+  });
+});
+var waitForFinish = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.once("error", onError2);
+  function onFinish() {
+    nodeRequest.off("error", onError2);
+    resume(Effect.void);
+  }
+  nodeRequest.once("finish", onFinish);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("finish", onFinish);
+  });
+});
+var NodeHttpResponse = class extends NodeHttpIncomingMessage {
+  [Response.TypeId];
+  request;
+  url;
+  constructor(request3, source, url) {
+    super(source, (cause) => new Error.HttpClientError({
+      reason: new Error.DecodeError({
+        request: request3,
+        response: this,
+        cause
+      })
+    }));
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.url = url;
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get formData() {
+    return Effect.tryPromise({
+      try: () => {
+        const init = {
+          headers: new globalThis.Headers(this.source.headers)
+        };
+        if (this.source.statusCode) {
+          init.status = this.source.statusCode;
+        }
+        if (this.source.statusMessage) {
+          init.statusText = this.source.statusMessage;
+        }
+        return new globalThis.Response(Readable.toWeb(this.source), init).formData();
+      },
+      catch: this.onError
+    });
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerNodeHttpNoAgent = /* @__PURE__ */ Client.layerMergedContext(makeNodeHttp);
+var layerNodeHttp = /* @__PURE__ */ Layer.provide(layerNodeHttpNoAgent, layerAgent);
+
+export {
+  Dispatcher,
+  makeDispatcher,
+  layerDispatcher,
+  dispatcherLayerGlobal,
+  UndiciOptions,
+  makeUndici,
+  layerUndiciNoDispatcher,
+  layerUndici,
+  HttpAgent,
+  makeAgent,
+  layerAgentOptions,
+  layerAgent,
+  makeNodeHttp,
+  layerNodeHttpNoAgent,
+  layerNodeHttp,
+  NodeHttpClient_exports,
+  Fetch,
+  layer,
+  RequestInit
+};

package/dist/vendor/chunk-WHKMOC7Z.js

@@ -0,0 +1,28 @@
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "./chunk-Z7QNPJEB.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/NodeSocketServer.js
+var NodeSocketServer_exports = {};
+__export(NodeSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+
+export {
+  NodeSocketServer_exports
+};

package/dist/vendor/chunk-WVFOZ2UL.js

@@ -0,0 +1,40 @@
+// ../../../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/internal/utils.js
+import * as PlatformError from "effect/PlatformError";
+var handleErrnoException = (module, method) => (err, [path]) => {
+  let reason = "Unknown";
+  switch (err.code) {
+    case "ENOENT":
+      reason = "NotFound";
+      break;
+    case "EACCES":
+      reason = "PermissionDenied";
+      break;
+    case "EEXIST":
+      reason = "AlreadyExists";
+      break;
+    case "EISDIR":
+      reason = "BadResource";
+      break;
+    case "ENOTDIR":
+      reason = "BadResource";
+      break;
+    case "EBUSY":
+      reason = "Busy";
+      break;
+    case "ELOOP":
+      reason = "BadResource";
+      break;
+  }
+  return PlatformError.systemError({
+    _tag: reason,
+    module,
+    method,
+    pathOrDescriptor: path,
+    syscall: err.syscall,
+    cause: err
+  });
+};
+
+export {
+  handleErrnoException
+};

package/dist/vendor/chunk-X73E2UPI.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-D64L6YND.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/NodeStdio.js
+var NodeStdio_exports = {};
+__export(NodeStdio_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeStdio_exports
+};

package/dist/vendor/chunk-XCYARUII.js

@@ -0,0 +1,63 @@
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-6UPBD47P.js";
+import {
+  layer
+} from "./chunk-6C5H7S6B.js";
+import {
+  layer as layer2
+} from "./chunk-UXBGYQR3.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/BunClusterSocket.js
+var BunClusterSocket_exports = {};
+__export(BunClusterSocket_exports, {
+  layer: () => layer8,
+  layerClientProtocol: () => layerClientProtocol,
+  layerK8sHttpClient: () => layerK8sHttpClient,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as K8sHttpClient from "effect/unstable/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as RunnerHealth from "effect/unstable/cluster/RunnerHealth";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as SocketRunner from "effect/unstable/cluster/SocketRunner";
+import * as SqlMessageStorage from "effect/unstable/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/unstable/cluster/SqlRunnerStorage";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+var layer8 = (options) => {
+  const layer9 = options?.clientOnly ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol) : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol]);
+  const runnerHealth = options?.clientOnly ? Layer.empty : options?.runnerHealth === "k8s" ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(Layer.provide([layer2, layerK8sHttpClient])) : RunnerHealth.layerPing.pipe(Layer.provide(Runners.layerRpc), Layer.provide(layerClientProtocol));
+  return layer9.pipe(Layer.provide(runnerHealth), Layer.provideMerge(options?.storage === "local" ? MessageStorage.layerNoop : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlMessageStorage.layer).pipe(Layer.provide(layer))), Layer.provide(options?.storage === "local" ? RunnerStorage.layerMemory : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlRunnerStorage.layer)), Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)), Layer.provide(options?.serialization === "ndjson" ? RpcSerialization.layerNdjsonWith({
+    maxBufferSize: options?.serializationMaxBufferSize
+  }) : RpcSerialization.layerSchemaBinary({
+    maxFrameSize: options?.serializationMaxBufferSize
+  })));
+};
+var layerK8sHttpClient = /* @__PURE__ */ K8sHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.unwrap(/* @__PURE__ */ Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const caCertOption = yield* fs.readFile("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(Effect.option);
+  if (caCertOption._tag === "None") {
+    return FetchHttpClient.layer;
+  }
+  return Layer.fresh(FetchHttpClient.layer).pipe(Layer.provide(Layer.succeed(FetchHttpClient.RequestInit, {
+    tls: {
+      ca: caCertOption.value
+    }
+  })));
+}))), /* @__PURE__ */ Layer.provide(layer2));
+
+export {
+  layer8 as layer,
+  layerK8sHttpClient,
+  BunClusterSocket_exports
+};