effect 4.0.0-beta.65 → 4.0.0-beta.67

package/src/unstable/cluster/SingleRunner.ts

@@ -1,4 +1,26 @@
 /**
+ * The `SingleRunner` module provides a ready-to-use layer for running the
+ * cluster sharding services in a single process. It wires together sharding,
+ * message storage, runner registration, runner health, and sharding
+ * configuration so durable entities and workflows can run without a fleet of
+ * external runners.
+ *
+ * **Common tasks**
+ *
+ * - Start a local or embedded cluster runner backed by SQL message storage
+ * - Run durable entities and workflows in development, tests, or small
+ *   single-node deployments
+ * - Choose SQL runner storage for persistence or in-memory runner storage for
+ *   short-lived scenarios
+ * - Override sharding configuration while still using the standard
+ *   environment-based defaults
+ *
+ * **Gotchas**
+ *
+ * - The layer still requires a `SqlClient` because message storage is SQL-backed
+ * - Runner health and runner coordination are no-op implementations, so this is
+ *   for single-node use rather than multi-runner cluster coordination
+ *
  * @since 4.0.0
  */
 import * as Layer from "effect/Layer"
@@ -17,8 +39,8 @@ import * as SqlRunnerStorage from "./SqlRunnerStorage.ts"
  * A sql backed single-node cluster, that can be used for running durable
  * entities and workflows.
  *
- * @since 4.0.0
  * @category Layers
+ * @since 4.0.0
  */
 export const layer = (options?: {
   readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined

package/src/unstable/cluster/Singleton.ts

@@ -1,4 +1,15 @@
 /**
+ * The `Singleton` module provides a small helper for registering effects that
+ * should run once across an Effect cluster. A singleton is coordinated through
+ * `Sharding`, which assigns ownership to one node at a time and can move that
+ * ownership when nodes leave or fail.
+ *
+ * Use singletons for cluster-wide background work such as schedulers, polling
+ * loops, maintenance jobs, or consumers that must not have one instance per
+ * process. Because ownership can change during failover, the registered effect
+ * should be interruptible, scoped, and able to resume work without assuming that
+ * the previous owner completed every in-flight action exactly once.
+ *
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
@@ -7,8 +18,11 @@ import type { Scope } from "../../Scope.ts"
 import { Sharding } from "./Sharding.ts"
 
 /**
- * @since 4.0.0
+ * Creates a layer that registers a singleton effect with `Sharding` under the
+ * specified name and optional shard group.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make = <E, R>(
   name: string,

package/src/unstable/cluster/SingletonAddress.ts

@@ -1,4 +1,18 @@
 /**
+ * The `SingletonAddress` module defines the address used by cluster sharding to
+ * identify a registered singleton. A singleton address combines the singleton
+ * name with the `ShardId` that owns it, giving the runtime a stable key for
+ * registration events, equality checks, hashing, and runner-local fiber
+ * tracking.
+ *
+ * Use this module when observing singleton registrations or working with
+ * sharding internals that need to tell which shard currently owns a singleton.
+ * The shard id is derived from the singleton name and shard group at
+ * registration time, so changing either value changes ownership and routing.
+ * Ownership can also move as shard locks are acquired or released, so an address
+ * identifies the target shard rather than guaranteeing that a particular runner
+ * is currently executing the singleton.
+ *
  * @since 4.0.0
  */
 import * as Equal from "../../Equal.ts"
@@ -11,24 +25,30 @@ const TypeId = "~effect/cluster/SingletonAddress"
 /**
  * Represents the unique address of an singleton within the cluster.
  *
- * @since 4.0.0
  * @category Address
+ * @since 4.0.0
  */
 export class SingletonAddress extends Schema.Class<SingletonAddress>(TypeId)({
   shardId: ShardId,
   name: Schema.String
 }) {
   /**
+   * Marks this value as a cluster singleton address for runtime guards.
+   *
    * @since 4.0.0
    */
   readonly [TypeId] = TypeId;
   /**
+   * Computes a structural hash from the singleton name and shard id.
+   *
    * @since 4.0.0
    */
   [Hash.symbol]() {
     return Hash.string(`${this.name}:${this.shardId.toString()}`)
   }
   /**
+   * Compares singleton addresses by name and shard id.
+   *
    * @since 4.0.0
    */
   [Equal.symbol](that: SingletonAddress): boolean {

package/src/unstable/cluster/Snowflake.ts

@@ -1,4 +1,22 @@
 /**
+ * The `Snowflake` module provides compact, sortable identifiers for cluster
+ * resources and events. A snowflake id is a branded `bigint` made from a
+ * millisecond timestamp, a machine id, and a per-machine sequence number.
+ *
+ * **Common use cases**
+ *
+ * - Creating ids without coordinating through a central database
+ * - Ordering cluster events, entity ids, or log records by generation time
+ * - Encoding ids as strings at service boundaries with {@link SnowflakeFromString}
+ * - Decoding a generated id into timestamp, machine id, and sequence parts with {@link toParts}
+ *
+ * **Gotchas**
+ *
+ * - Uniqueness depends on each concurrent generator using a distinct machine id
+ * - Generated ids are time-sortable, but they are not random or secret values
+ * - The default generator prevents local clock drift from moving ids backward
+ * - More than 4096 ids in the same millisecond advance the logical timestamp
+ *
  * @since 4.0.0
  */
 import type * as Brand from "../../Brand.ts"
@@ -13,36 +31,50 @@ import * as Transformation from "../../SchemaTransformation.ts"
 import type { MachineId } from "./MachineId.ts"
 
 /**
+ * Runtime brand identifier for cluster snowflake ids.
+ *
  * @since 4.0.0
  */
 export const TypeId = "~effect/cluster/Snowflake"
 
 /**
+ * Type-level representation of the cluster snowflake brand identifier.
+ *
  * @since 4.0.0
  */
 export type TypeId = typeof TypeId
 
 /**
- * @since 4.0.0
+ * Branded bigint identifier composed from a timestamp, machine id, and per-machine
+ * sequence number.
+ *
  * @category Models
+ * @since 4.0.0
  */
 export type Snowflake = Brand.Branded<bigint, TypeId>
 
 /**
- * @since 4.0.0
+ * Constructs a branded `Snowflake` from a bigint or bigint-compatible string.
+ *
  * @category Models
+ * @since 4.0.0
  */
 export const Snowflake = (input: string | bigint): Snowflake =>
   typeof input === "string" ? BigInt(input) as Snowflake : input as Snowflake
 
 /**
- * @since 4.0.0
+ * Namespace containing support types for snowflake parts and generators.
+ *
  * @category Models
+ * @since 4.0.0
  */
 export declare namespace Snowflake {
   /**
-   * @since 4.0.0
+   * Decoded components of a snowflake id: Unix timestamp milliseconds, machine id,
+   * and sequence number.
+   *
    * @category Models
+   * @since 4.0.0
    */
   export interface Parts {
     readonly timestamp: number
@@ -51,8 +83,11 @@ export declare namespace Snowflake {
   }
 
   /**
-   * @since 4.0.0
+   * Stateful generator for runner-local snowflake ids, exposing an unsafe
+   * synchronous `nextUnsafe` operation and an effectful machine id setter.
+   *
    * @category Models
+   * @since 4.0.0
    */
   export interface Generator {
     readonly nextUnsafe: () => Snowflake
@@ -61,34 +96,45 @@ export declare namespace Snowflake {
 }
 
 /**
- * @since 4.0.0
+ * Schema type for snowflake ids represented as branded bigints.
+ *
  * @category Schemas
+ * @since 4.0.0
  */
 export interface SnowflakeFromBigInt extends Schema.brand<Schema.BigInt, TypeId> {}
 
 /**
- * @since 4.0.0
+ * Schema for snowflake ids represented as branded bigints.
+ *
  * @category Schemas
+ * @since 4.0.0
  */
 export const SnowflakeFromBigInt: SnowflakeFromBigInt = Schema.BigInt.pipe(Schema.brand(TypeId))
 
 /**
- * @since 4.0.0
+ * Schema type for snowflake ids decoded from strings into branded bigints.
+ *
  * @category Schemas
+ * @since 4.0.0
  */
 export interface SnowflakeFromString extends Schema.decodeTo<SnowflakeFromBigInt, Schema.String> {}
 
 /**
- * @since 4.0.0
+ * Schema that decodes snowflake ids from strings into branded bigints and encodes
+ * them back to strings.
+ *
  * @category Schemas
+ * @since 4.0.0
  */
 export const SnowflakeFromString: SnowflakeFromString = Schema.String.pipe(
   Schema.decodeTo(SnowflakeFromBigInt, Transformation.bigintFromString)
 )
 
 /**
- * @since 4.0.0
+ * Custom snowflake epoch in Unix milliseconds, set to January 1, 2025 UTC.
+ *
  * @category Epoch
+ * @since 4.0.0
  */
 export const constEpochMillis: number = Date.UTC(2025, 0, 1)
 
@@ -99,8 +145,12 @@ const constBigInt1024 = BigInt(1024)
 const constBigInt4096 = BigInt(4096)
 
 /**
- * @since 4.0.0
+ * Packs a timestamp, machine id, and sequence number into a branded snowflake id,
+ * using the custom snowflake epoch and 10-bit machine id and 12-bit sequence
+ * fields.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make = (options: {
   readonly machineId: MachineId
@@ -112,33 +162,43 @@ export const make = (options: {
     | BigInt(options.sequence % 4096)) as Snowflake
 
 /**
- * @since 4.0.0
+ * Extracts the Unix timestamp in milliseconds from a snowflake id.
+ *
  * @category Parts
+ * @since 4.0.0
  */
 export const timestamp = (snowflake: Snowflake): number => Number(snowflake >> constBigInt22) + sinceUnixEpoch
 
 /**
- * @since 4.0.0
+ * Extracts the timestamp from a snowflake id as a `DateTime.Utc`.
+ *
  * @category Parts
+ * @since 4.0.0
  */
 export const dateTime = (snowflake: Snowflake): DateTime.Utc => DateTime.makeUnsafe(timestamp(snowflake))
 
 /**
- * @since 4.0.0
+ * Extracts the machine id component from a snowflake id.
+ *
  * @category Parts
+ * @since 4.0.0
  */
 export const machineId = (snowflake: Snowflake): MachineId =>
   Number((snowflake >> constBigInt12) % constBigInt1024) as MachineId
 
 /**
- * @since 4.0.0
+ * Extracts the per-machine sequence component from a snowflake id.
+ *
  * @category Parts
+ * @since 4.0.0
  */
 export const sequence = (snowflake: Snowflake): number => Number(snowflake % constBigInt4096)
 
 /**
- * @since 4.0.0
+ * Decomposes a snowflake id into its timestamp, machine id, and sequence parts.
+ *
  * @category Parts
+ * @since 4.0.0
  */
 export const toParts = (snowflake: Snowflake): Snowflake.Parts => ({
   timestamp: timestamp(snowflake),
@@ -147,8 +207,14 @@ export const toParts = (snowflake: Snowflake): Snowflake.Parts => ({
 })
 
 /**
- * @since 4.0.0
+ * Creates a stateful snowflake generator using `Clock`.
+ *
+ * The generator starts with a random machine id, never moves generated timestamps
+ * backward, resets the sequence each millisecond, and advances the timestamp when
+ * more than 4096 ids are requested in the same millisecond.
+ *
  * @category Generator
+ * @since 4.0.0
  */
 export const makeGenerator: Effect.Effect<Snowflake.Generator> = Effect.gen(function*() {
   let machineId = Math.floor(Math.random() * 1024) as MachineId
@@ -189,8 +255,10 @@ export const makeGenerator: Effect.Effect<Snowflake.Generator> = Effect.gen(func
 })
 
 /**
- * @since 4.0.0
+ * Context service for a stateful snowflake id generator.
+ *
  * @category Generator
+ * @since 4.0.0
  */
 export class Generator extends Context.Service<
   Generator,
@@ -198,7 +266,9 @@ export class Generator extends Context.Service<
 >()("effect/cluster/Snowflake/Generator") {}
 
 /**
- * @since 4.0.0
+ * Layer that provides the default snowflake `Generator` service.
+ *
  * @category Generator
+ * @since 4.0.0
  */
 export const layerGenerator: Layer.Layer<Generator> = Layer.effect(Generator)(makeGenerator)

package/src/unstable/cluster/SocketRunner.ts

@@ -1,4 +1,25 @@
 /**
+ * The `SocketRunner` module wires cluster runner RPCs to socket transports. It
+ * provides a complete runner layer that serves RPC handlers on a `SocketServer`
+ * and installs `Sharding` and `Runners` clients for talking to other runners
+ * through the socket RPC protocol.
+ *
+ * **Common tasks**
+ *
+ * - Run a cluster worker over TCP or Unix sockets with {@link layer}
+ * - Connect to other runners while exposing `Sharding` and `Runners` clients
+ * - Embed a client-only cluster participant with {@link layerClientOnly} when
+ *   the process should send messages but not receive shard assignments
+ *
+ * **Transport gotchas**
+ *
+ * - The server listen address comes from the provided `SocketServer` and is
+ *   logged when {@link layer} starts
+ * - TCP addresses are logged as `hostname:port`, while Unix socket addresses
+ *   are logged as their filesystem path
+ * - The client-only layer does not start a socket server; provide the full
+ *   layer when the process must accept runner RPCs
+ *
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
@@ -27,8 +48,11 @@ const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E,
   })).pipe(Layer.provideMerge(layer))
 
 /**
- * @since 4.0.0
+ * Layer that runs a cluster runner over the socket RPC protocol, providing
+ * `Sharding` and `Runners` clients and logging the socket listen address.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<
   Sharding.Sharding | Runners.Runners,
@@ -46,8 +70,11 @@ export const layer: Layer.Layer<
 )
 
 /**
- * @since 4.0.0
+ * Client-only socket runner layer that provides `Sharding` and `Runners` clients
+ * without starting a runner server or receiving shard assignments.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layerClientOnly: Layer.Layer<
   Sharding.Sharding | Runners.Runners,

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -1,4 +1,20 @@
 /**
+ * SQL-backed message storage for the unstable cluster runtime.
+ *
+ * This module persists encoded cluster envelopes and replies in SQL tables so
+ * shards can resume work after process restarts, redeliver unprocessed messages,
+ * deduplicate requests by primary key, and replay outstanding reply chunks until
+ * they are acknowledged. It is the storage implementation to use when a cluster
+ * needs durable request / reply state backed by `SqlClient` rather than an
+ * in-memory store.
+ *
+ * The storage layer runs its own migrations and creates messages, replies, and
+ * migration tables using the configured prefix (`cluster` by default). Choose a
+ * stable prefix before deploying, because changing it points the runtime at a
+ * different set of tables. Existing deployments should also keep the generated
+ * migration history table with the message tables so future schema changes can
+ * be applied consistently across supported SQL dialects.
+ *
  * @since 4.0.0
  */
 // eslint-disable effect/no-bigint-literals
@@ -23,8 +39,11 @@ import * as Snowflake from "./Snowflake.ts"
 const withTracerDisabled = Effect.withTracerEnabled(false)
 
 /**
- * @since 4.0.0
+ * Creates a SQL-backed `MessageStorage` implementation, running its migrations
+ * and using the optional table prefix.
+ *
  * @category Constructors
+ * @since 4.0.0
  */
 export const make: (options?: {
   readonly prefix?: string | undefined
@@ -603,8 +622,11 @@ export const make: (options?: {
 }, withTracerDisabled)
 
 /**
- * @since 4.0.0
+ * Layer that provides SQL-backed `MessageStorage` using the default table prefix
+ * and the default snowflake generator.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<
   MessageStorage.MessageStorage,
@@ -615,8 +637,10 @@ export const layer: Layer.Layer<
 )
 
 /**
- * @since 4.0.0
+ * Layer that provides SQL-backed `MessageStorage` using a custom table prefix.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layerWith = (options: {
   readonly prefix?: string | undefined

package/src/unstable/cluster/SqlRunnerStorage.ts

@@ -1,4 +1,33 @@
 /**
+ * SQL-backed storage for Effect Cluster runner metadata and shard ownership.
+ *
+ * The `SqlRunnerStorage` module builds a `RunnerStorage` implementation from a
+ * `SqlClient`, creating the runner and lock tables it needs using the configured
+ * table prefix. It is used by clustered applications that need runner
+ * registration, health tracking, shard acquisition, refresh, and release to be
+ * coordinated through an external database instead of in-memory state.
+ *
+ * **Common tasks**
+ *
+ * - Provide the default storage layer with {@link layer}
+ * - Use {@link layerWith} when multiple clusters share the same database and
+ *   need distinct table prefixes
+ * - Create a storage implementation directly with {@link make} for custom layer
+ *   composition
+ *
+ * **Gotchas**
+ *
+ * - Runner heartbeats and persisted shard locks expire according to
+ *   `ShardingConfig.shardLockExpiration`; stale rows may be reused or cleaned up
+ *   by later storage operations.
+ * - PostgreSQL and MySQL use advisory locks by default, keeping shard ownership
+ *   tied to a reserved database connection. Set
+ *   `ShardingConfig.shardLockDisableAdvisory` when persisted lock rows should be
+ *   used instead.
+ * - The selected table prefix controls the generated `runners` and `locks`
+ *   table names, so changing it points the cluster at a different storage
+ *   namespace.
+ *
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts"
@@ -18,13 +47,19 @@ import * as ShardingConfig from "./ShardingConfig.ts"
 const withTracerDisabled = Effect.withTracerEnabled(false)
 
 /**
- * @since 4.0.0
+ * Creates a SQL-backed `RunnerStorage` implementation for registered runners and
+ * shard locks, using the configured table prefix and advisory locks where
+ * supported and enabled.
+ *
  * @category Constructors
+ * @since 4.0.0
  */
 export const make = Effect.fnUntraced(function*(options: {
   readonly prefix?: string | undefined
 }) {
   const config = yield* ShardingConfig.ShardingConfig
+  const shardGroups = ShardingConfig.shardGroupConfig(config)
+  const availableShardGroups = Array.from(shardGroups.available)
   const disableAdvisoryLocks = config.shardLockDisableAdvisory
   const sql = (yield* SqlClient.SqlClient).withoutTransforms()
   const prefix = options?.prefix ?? "cluster"
@@ -391,8 +426,8 @@ export const make = Effect.fnUntraced(function*(options: {
 
   const lockNumbers = new Map<string, number>()
   const lockNumbersReverse = new Map<number, string>()
-  for (let i = 0; i < config.shardGroups.length; i++) {
-    const group = config.shardGroups[i]
+  for (let i = 0; i < availableShardGroups.length; i++) {
+    const group = availableShardGroups[i]
     const base = (i + 1) * 1000000
     for (let shard = 1; shard <= config.shardsPerGroup; shard++) {
       const shardId = ShardId.make(group, shard).toString()
@@ -407,8 +442,8 @@ export const make = Effect.fnUntraced(function*(options: {
   const lockNamesReverse = new Map<string, string>()
   {
     let index = 0
-    for (let i = 0; i < config.shardGroups.length; i++) {
-      const group = config.shardGroups[i]
+    for (let i = 0; i < availableShardGroups.length; i++) {
+      const group = availableShardGroups[i]
       for (let shard = 1; shard <= config.shardsPerGroup; shard++) {
         const shardId = ShardId.make(group, shard).toString()
         const lockName = `${prefix}.${shardId}`
@@ -643,8 +678,10 @@ export const make = Effect.fnUntraced(function*(options: {
 }, withTracerDisabled)
 
 /**
- * @since 4.0.0
+ * Layer that provides SQL-backed `RunnerStorage` using the default table prefix.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<
   RunnerStorage.RunnerStorage,
@@ -653,8 +690,10 @@ export const layer: Layer.Layer<
 > = Layer.effect(RunnerStorage.RunnerStorage)(make({}))
 
 /**
- * @since 4.0.0
+ * Layer that provides SQL-backed `RunnerStorage` using a custom table prefix.
+ *
  * @category Layers
+ * @since 4.0.0
  */
 export const layerWith = (options: {
   readonly prefix?: string | undefined

package/src/unstable/cluster/TestRunner.ts

@@ -1,4 +1,21 @@
 /**
+ * The `TestRunner` module provides a lightweight in-memory cluster layer for
+ * tests that need the cluster sharding services without starting real runners
+ * or relying on external storage.
+ *
+ * Use it when exercising sharding behavior, message storage, or code that
+ * depends on the cluster runner services in unit and integration tests. The
+ * layer wires the normal sharding service to in-memory message and runner
+ * storage, along with no-op runner and health implementations.
+ *
+ * **Testing gotchas**
+ *
+ * - State is held in memory and scoped to the layer lifetime; it is not shared
+ *   across independently constructed layers or persisted between test runs
+ * - Runner execution and health checks are no-ops, so this layer is best suited
+ *   for testing coordination and storage behavior rather than real distributed
+ *   runner processes
+ *
  * @since 4.0.0
  */
 import * as Layer from "../../Layer.ts"
@@ -15,8 +32,8 @@ import * as ShardingConfig from "./ShardingConfig.ts"
  * MessageStorage is backed by an in-memory driver, and RunnerStorage is backed
  * by an in-memory driver.
  *
- * @since 4.0.0
  * @category Layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<
   Sharding.Sharding | Runners.Runners | MessageStorage.MessageStorage | MessageStorage.MemoryDriver

package/src/unstable/cluster/internal/hash.ts

@@ -1,3 +1,15 @@
+/**
+ * Internal hashing helpers used by cluster routing to map entity identifiers to
+ * shard numbers. The hash is intentionally small and deterministic for
+ * JavaScript strings so every node that sees the same entity id and sharding
+ * configuration derives the same destination shard.
+ *
+ * **Gotchas**
+ *
+ * - Changing this implementation changes entity-to-shard assignment.
+ * - Strings are hashed as UTF-16 code units; normalize ids before routing if
+ *   callers may produce equivalent text in different Unicode forms.
+ */
 /** @internal */
 export const hashOptimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0x40000000)
 

package/src/unstable/devtools/DevTools.ts

@@ -1,4 +1,19 @@
 /**
+ * Utilities for wiring an Effect application to the Effect devtools runtime
+ * tracer.
+ *
+ * This module is the high-level entry point for installing the devtools tracer
+ * as a `Layer`. Use it when an application should stream spans, span events,
+ * span completions, and metrics snapshots to a devtools process for local
+ * inspection. The default `layer` and `layerWebSocket` helpers connect over a
+ * WebSocket to `ws://localhost:34437`, while `layerSocket` lets integrations
+ * provide their own `Socket` transport.
+ *
+ * These layers install tracing for the scoped runtime they are provided to;
+ * they do not start a devtools server, and a compatible devtools endpoint must
+ * be reachable separately. Because this API lives under `unstable`, its
+ * protocol and surface may change between releases.
+ *
  * @since 4.0.0
  */
 import * as Layer from "../../Layer.ts"
@@ -6,14 +21,19 @@ import * as Socket from "../socket/Socket.ts"
 import * as DevToolsClient from "./DevToolsClient.ts"
 
 /**
- * @since 4.0.0
+ * Layer that installs the devtools tracer using an existing `Socket`.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerSocket: Layer.Layer<never, never, Socket.Socket> = DevToolsClient.layerTracer
 
 /**
- * @since 4.0.0
+ * Layer that installs the devtools tracer over a WebSocket connection to the
+ * specified URL, defaulting to `ws://localhost:34437`.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocket = (
   url = "ws://localhost:34437"
@@ -23,8 +43,11 @@ export const layerWebSocket = (
   )
 
 /**
- * @since 4.0.0
+ * Layer that installs the devtools tracer over a WebSocket connection using the
+ * global WebSocket constructor, defaulting to `ws://localhost:34437`.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer = (url = "ws://localhost:34437"): Layer.Layer<never> =>
   layerWebSocket(url).pipe(