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

package/dist/vendor/chunk-XDPP24MG.js

@@ -0,0 +1,129 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeRedis.js
+var NodeRedis_exports = {};
+__export(NodeRedis_exports, {
+  NodeRedis: () => NodeRedis,
+  layer: () => layer,
+  layerConfig: () => layerConfig
+});
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fn from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Redis from "effect/persistence/Redis";
+import { createClient, SocketTimeoutError } from "redis";
+var NodeRedis = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeRedis")) {
+};
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  let ready = false;
+  const socket = options?.socket;
+  const client = yield* Effect.acquireRelease(Effect.sync(() => createClient({
+    ...options,
+    socket: socket?.reconnectStrategy === void 0 ? {
+      ...socket,
+      reconnectStrategy: (retries, cause) => {
+        if (!ready) return cause;
+        if (cause instanceof SocketTimeoutError) return false;
+        const jitter = Math.floor(Math.random() * 200);
+        const delay = Math.min(2 ** retries * 50, 2e3);
+        return delay + jitter;
+      }
+    } : socket
+  })), (client2) => Effect.ignoreCause(Effect.promise(() => client2.close())));
+  client.once("ready", () => {
+    ready = true;
+  });
+  const runSync = Effect.runSyncWith(yield* Effect.context());
+  client.on("error", (cause) => {
+    runSync(Effect.logWarning("NodeRedis client error", cause));
+  });
+  yield* Effect.tryPromise({
+    try: () => client.connect(),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const use = (f) => Effect.tryPromise({
+    try: () => f(client),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const redis = yield* Redis.make({
+    send: (command, ...args) => Effect.tryPromise({
+      try: () => client.sendCommand([command, ...args]),
+      catch: (cause) => new Redis.RedisError({
+        cause
+      })
+    }),
+    subscribe: (channel, onMessage) => Effect.gen(function* () {
+      const terminal = yield* Deferred.make();
+      yield* Effect.acquireRelease(Effect.tryPromise({
+        try: async () => {
+          let subscriberReady = false;
+          const subscriber = client.duplicate(socket?.reconnectStrategy === void 0 ? {
+            socket: {
+              ...socket,
+              reconnectStrategy: (retries, cause) => {
+                if (!subscriberReady) return cause;
+                if (cause instanceof SocketTimeoutError) return false;
+                const jitter = Math.floor(Math.random() * 200);
+                const delay = Math.min(2 ** retries * 50, 2e3);
+                return delay + jitter;
+              }
+            }
+          } : {});
+          subscriber.once("ready", () => {
+            subscriberReady = true;
+          });
+          subscriber.on("error", (cause) => {
+            runSync(Effect.logWarning("NodeRedis subscriber error", cause));
+            if (!subscriber.isOpen) {
+              runSync(Deferred.fail(terminal, new Redis.RedisError({
+                cause
+              })));
+            }
+          });
+          try {
+            await subscriber.connect();
+            await subscriber.subscribe(channel, (message, channel2) => {
+              onMessage({
+                channel: channel2,
+                message
+              });
+            });
+            return subscriber;
+          } catch (cause) {
+            if (subscriber.isOpen) subscriber.destroy();
+            throw cause;
+          }
+        },
+        catch: (cause) => new Redis.RedisError({
+          cause
+        })
+      }), (subscriber) => Effect.sync(() => {
+        if (subscriber.isOpen) subscriber.destroy();
+      }));
+      return Deferred.await(terminal);
+    })
+  });
+  const nodeRedis = Fn.identity({
+    client,
+    use
+  });
+  return Context.make(NodeRedis, nodeRedis).pipe(Context.add(Redis.Redis, redis));
+});
+var layer = (options) => Layer.effectContext(make4(options));
+var layerConfig = (options) => Layer.effectContext(Config.unwrap(options).pipe(Effect.flatMap(make4)));
+
+export {
+  NodeRedis,
+  layer,
+  layerConfig,
+  NodeRedis_exports
+};

package/dist/vendor/chunk-XF3WZCMZ.js

@@ -0,0 +1,26 @@
+import {
+  layer,
+  layerPosix,
+  layerWin32
+} from "./chunk-JTST2Z7N.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodePath.js
+var NodePath_exports = {};
+__export(NodePath_exports, {
+  layer: () => layer2,
+  layerPosix: () => layerPosix2,
+  layerWin32: () => layerWin322
+});
+var layer2 = layer;
+var layerPosix2 = layerPosix;
+var layerWin322 = layerWin32;
+
+export {
+  layer2 as layer,
+  layerPosix2 as layerPosix,
+  layerWin322 as layerWin32,
+  NodePath_exports
+};

package/dist/vendor/chunk-YJGNV6EV.js

@@ -0,0 +1,85 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeWorker.js
+var NodeWorker_exports = {};
+__export(NodeWorker_exports, {
+  layer: () => layer,
+  layerPlatform: () => layerPlatform
+});
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Worker from "effect/workers/Worker";
+import { WorkerError, WorkerReceiveError } from "effect/workers/WorkerError";
+var layerPlatform = /* @__PURE__ */ Layer.succeed(Worker.WorkerPlatform)(/* @__PURE__ */ Worker.makePlatform()({
+  setup({
+    scope,
+    worker
+  }) {
+    const exitDeferred = Deferred.makeUnsafe();
+    const thing = "postMessage" in worker ? {
+      postMessage(msg, t) {
+        worker.postMessage(msg, t);
+      },
+      kill: () => worker.terminate(),
+      worker
+    } : {
+      postMessage(msg, _) {
+        worker.send(msg);
+      },
+      kill: () => worker.kill("SIGKILL"),
+      worker
+    };
+    worker.on("exit", () => {
+      Deferred.doneUnsafe(exitDeferred, Exit.void);
+    });
+    return Effect.as(Scope.addFinalizer(scope, Effect.suspend(() => {
+      thing.postMessage([1]);
+      return Deferred.await(exitDeferred);
+    }).pipe(Effect.timeout(5e3), Effect.catchCause(() => Effect.promise(() => Promise.resolve(thing.kill()))))), thing);
+  },
+  listen({
+    deferred,
+    emit,
+    port
+  }) {
+    port.worker.on("message", (message) => {
+      emit(message);
+    });
+    port.worker.on("messageerror", (cause) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "An messageerror event was emitted",
+          cause
+        })
+      }));
+    });
+    port.worker.on("error", (cause) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "An error event was emitted",
+          cause
+        })
+      }));
+    });
+    port.worker.on("exit", (code) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "The worker has exited with code: " + code
+        })
+      }));
+    });
+    return Effect.void;
+  }
+}));
+var layer = (spawn) => Layer.merge(Worker.layerSpawner(spawn), layerPlatform);
+
+export {
+  layerPlatform,
+  layer,
+  NodeWorker_exports
+};

package/dist/vendor/chunk-ZJEHEPDQ.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-4O4Z52A2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_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/cjs/bun/BunAddressResolver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bun implementation of Effect's `AddressResolver` service.
+ *
+ * IPv6 literals with a named zone such as `fe80::1%eth0` get their scope ID
+ * from `os.networkInterfaces()`, listed each time a named zone is resolved.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeAddressResolver.js";
+//# sourceMappingURL=BunAddressResolver.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Bun implementation of `ChildProcessSpawner`.
+ *
+ * @stability unstable
+ * @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,76 @@
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import type { Sharding } from "effect/cluster/Sharding";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import type * as Config from "effect/Config";
+import type * as Etag from "effect/http/Etag";
+import type { HttpPlatform } from "effect/http/HttpPlatform";
+import type { HttpServer } from "effect/http/HttpServer";
+import type { ServeError } from "effect/http/HttpServerError";
+import * as Layer from "effect/Layer";
+import type { SqlClient } from "effect/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.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerK8sHttpClient };
+/**
+ * Layer that provides a Bun HTTP server for cluster runners.
+ *
+ * @stability unstable
+ * @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
+ *
+ * @stability unstable
+ * @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,70 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import { layerClientProtocol, layerSocketServer } from "../node-shared/NodeClusterSocket.js";
+import * as K8sHttpClient from "effect/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import type { Sharding } from "effect/cluster/Sharding";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import type * as SocketServer from "effect/socket/SocketServer";
+import type { SqlClient } from "effect/sql/SqlClient";
+export { 
+/**
+ * Provides the cluster `RpcClientProtocol` using the shared socket client
+ * implementation.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerClientProtocol, 
+/**
+ * Provides the socket server used by Bun cluster runners through the shared
+ * socket server implementation.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerSocketServer };
+/**
+ * Creates Bun socket cluster layers, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,11 @@
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+/**
+ * Layer that provides the Bun Crypto service implementation.
+ *
+ * @stability unstable
+ * @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")