effect 4.0.0-beta.67 → 4.0.0-beta.68

package/dist/unstable/cluster/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ClusterCron","ClusterError","ClusterMetrics","ClusterSchema","ClusterWorkflowEngine","DeliverAt","Entity","EntityAddress","EntityId","EntityProxy","EntityProxyServer","EntityResource","EntityType","Envelope","HttpRunner","K8sHttpClient","MachineId","Message","MessageStorage","Reply","Runner","RunnerAddress","RunnerHealth","Runners","RunnerServer","RunnerStorage","ShardId","Sharding","ShardingConfig","ShardingRegistrationEvent","SingleRunner","Singleton","SingletonAddress","Snowflake","SocketRunner","SqlMessageStorage","SqlRunnerStorage","TestRunner"],"sources":["../../../src/unstable/cluster/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;AAGA,OAAO,KAAKA,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;AAGA,OAAO,KAAKC,qBAAqB,MAAM,4BAA4B;AAEnE;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;AAGA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,KAAK,MAAM,YAAY;AAEnC;;;AAGA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,yBAAyB,MAAM,gCAAgC;AAE3E;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,gBAAgB,MAAM,uBAAuB;AAEzD;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;AAGA,OAAO,KAAKC,gBAAgB,MAAM,uBAAuB;AAEzD;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["ClusterCron","ClusterError","ClusterMetrics","ClusterSchema","ClusterWorkflowEngine","DeliverAt","Entity","EntityAddress","EntityId","EntityProxy","EntityProxyServer","EntityResource","EntityType","Envelope","HttpRunner","K8sHttpClient","MachineId","Message","MessageStorage","Reply","Runner","RunnerAddress","RunnerHealth","Runners","RunnerServer","RunnerStorage","ShardId","Sharding","ShardingConfig","ShardingRegistrationEvent","SingleRunner","Singleton","SingletonAddress","Snowflake","SocketRunner","SqlMessageStorage","SqlRunnerStorage","TestRunner"],"sources":["../../../src/unstable/cluster/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,KAAKA,WAAW,MAAM,kBAAkB;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,KAAKC,qBAAqB,MAAM,4BAA4B;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;;;;;;;;;;AAYA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;;;;;;;;;;;;;;;;AAkBA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,KAAKC,KAAK,MAAM,YAAY;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,KAAKC,aAAa,MAAM,oBAAoB;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,QAAQ,MAAM,eAAe;AAEzC;;;;;;;;;;;;;;;;;;AAkBA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;AAiBA,OAAO,KAAKC,yBAAyB,MAAM,gCAAgC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;AAcA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;AAiBA,OAAO,KAAKC,gBAAgB,MAAM,uBAAuB;AAEzD;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,KAAKC,gBAAgB,MAAM,uBAAuB;AAEzD;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,KAAKC,UAAU,MAAM,iBAAiB","ignoreList":[]}

package/dist/unstable/devtools/index.d.ts

@@ -2,18 +2,76 @@
  * @since 4.0.0
  */
 /**
+ * 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
  */
 export * as DevTools from "./DevTools.ts";
 /**
+ * Provides the low-level client used by the unstable devtools integration to
+ * exchange telemetry with an Effect devtools server over the current `Socket`.
+ *
+ * The client speaks the devtools NDJSON protocol, publishes span starts, span
+ * events, span completions, and metric snapshots, and exposes layers for
+ * installing a tracer that mirrors the current tracer while forwarding data to
+ * devtools. Most applications should use the higher-level devtools layers
+ * instead of constructing this service directly. When using this module
+ * directly, provide a live `Socket`, keep the layer scoped so the background
+ * ping and stream fibers are finalized, and prefer `layerTracer` when the goal
+ * is to observe an application's Effect traces.
+ *
  * @since 4.0.0
  */
 export * as DevToolsClient from "./DevToolsClient.ts";
 /**
+ * Schemas and TypeScript types for the Effect devtools protocol.
+ *
+ * This module defines the wire format used by devtools clients and servers to
+ * exchange telemetry, including spans, span events, metric snapshots, fiber
+ * dumps, heartbeat messages, and request/response payloads. Use these schemas
+ * when encoding or decoding messages at the devtools boundary, validating
+ * custom transports, or building integrations that need to inspect the same
+ * protocol data as the built-in devtools implementation.
+ *
+ * The exported values describe serialized protocol payloads rather than the
+ * full in-memory runtime data structures. Some fields intentionally normalize
+ * runtime values for transport, for example ended span exits are encoded with
+ * successful values erased via `Exit.asVoid`, timestamps are represented as
+ * `bigint`s, and arbitrary attributes are accepted as unknown schema values.
+ * The module lives under `unstable`, so consumers should treat the protocol
+ * shape as experimental.
+ *
  * @since 4.0.0
  */
 export * as DevToolsSchema from "./DevToolsSchema.ts";
 /**
+ * Server-side helpers for exposing the Effect devtools protocol over a socket.
+ *
+ * This module is used by runtime integrations that want to accept devtools
+ * clients, decode newline-delimited JSON protocol messages, and hand each
+ * connected client to application-specific handling logic. It is most useful
+ * for building a devtools endpoint that can inspect running fibers, spans, and
+ * other telemetry described by `DevToolsSchema`.
+ *
+ * The server automatically responds to protocol `Ping` requests with `Pong`
+ * responses. All other requests are delivered through the connected `Client`
+ * queue, while responses should be written with `Client.send`. The queue is
+ * shut down when the socket processing fiber terminates, so handlers should
+ * treat it as connection-scoped state rather than a long-lived global channel.
+ *
  * @since 4.0.0
  */
 export * as DevToolsServer from "./DevToolsServer.ts";

package/dist/unstable/devtools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/devtools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;GAEG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;GAEG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;GAEG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/devtools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA"}

package/dist/unstable/devtools/index.js

@@ -3,18 +3,76 @@
  */
 // @barrel: Auto-generated exports. Do not edit manually.
 /**
+ * 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
  */
 export * as DevTools from "./DevTools.js";
 /**
+ * Provides the low-level client used by the unstable devtools integration to
+ * exchange telemetry with an Effect devtools server over the current `Socket`.
+ *
+ * The client speaks the devtools NDJSON protocol, publishes span starts, span
+ * events, span completions, and metric snapshots, and exposes layers for
+ * installing a tracer that mirrors the current tracer while forwarding data to
+ * devtools. Most applications should use the higher-level devtools layers
+ * instead of constructing this service directly. When using this module
+ * directly, provide a live `Socket`, keep the layer scoped so the background
+ * ping and stream fibers are finalized, and prefer `layerTracer` when the goal
+ * is to observe an application's Effect traces.
+ *
  * @since 4.0.0
  */
 export * as DevToolsClient from "./DevToolsClient.js";
 /**
+ * Schemas and TypeScript types for the Effect devtools protocol.
+ *
+ * This module defines the wire format used by devtools clients and servers to
+ * exchange telemetry, including spans, span events, metric snapshots, fiber
+ * dumps, heartbeat messages, and request/response payloads. Use these schemas
+ * when encoding or decoding messages at the devtools boundary, validating
+ * custom transports, or building integrations that need to inspect the same
+ * protocol data as the built-in devtools implementation.
+ *
+ * The exported values describe serialized protocol payloads rather than the
+ * full in-memory runtime data structures. Some fields intentionally normalize
+ * runtime values for transport, for example ended span exits are encoded with
+ * successful values erased via `Exit.asVoid`, timestamps are represented as
+ * `bigint`s, and arbitrary attributes are accepted as unknown schema values.
+ * The module lives under `unstable`, so consumers should treat the protocol
+ * shape as experimental.
+ *
  * @since 4.0.0
  */
 export * as DevToolsSchema from "./DevToolsSchema.js";
 /**
+ * Server-side helpers for exposing the Effect devtools protocol over a socket.
+ *
+ * This module is used by runtime integrations that want to accept devtools
+ * clients, decode newline-delimited JSON protocol messages, and hand each
+ * connected client to application-specific handling logic. It is most useful
+ * for building a devtools endpoint that can inspect running fibers, spans, and
+ * other telemetry described by `DevToolsSchema`.
+ *
+ * The server automatically responds to protocol `Ping` requests with `Pong`
+ * responses. All other requests are delivered through the connected `Client`
+ * queue, while responses should be written with `Client.send`. The queue is
+ * shut down when the socket processing fiber terminates, so handlers should
+ * treat it as connection-scoped state rather than a long-lived global channel.
+ *
  * @since 4.0.0
  */
 export * as DevToolsServer from "./DevToolsServer.js";

package/dist/unstable/devtools/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["DevTools","DevToolsClient","DevToolsSchema","DevToolsServer"],"sources":["../../../src/unstable/devtools/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;AAGA,OAAO,KAAKA,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["DevTools","DevToolsClient","DevToolsSchema","DevToolsServer"],"sources":["../../../src/unstable/devtools/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;;;;;;;;;;;;;;;;AAkBA,OAAO,KAAKA,QAAQ,MAAM,eAAe;AAEzC;;;;;;;;;;;;;;;AAeA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,KAAKC,cAAc,MAAM,qBAAqB;AAErD;;;;;;;;;;;;;;;;;AAiBA,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}

package/dist/unstable/encoding/Sse.d.ts

@@ -31,7 +31,7 @@ import * as Transformation from "../../SchemaTransformation.ts";
  * SSE `retry` directives are emitted as `Retry` failures so callers can
  * reconnect with the requested delay.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decode: <IE, Done>() => Channel.Channel<NonEmptyReadonlyArray<Event>, IE | Retry, Done, NonEmptyReadonlyArray<string>, IE, Done>;
@@ -41,7 +41,7 @@ export declare const decode: <IE, Done>() => Channel.Channel<NonEmptyReadonlyArr
  * The schema receives the untagged event shape containing `id`, `event`, and
  * string `data`.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decodeSchema: <Type extends {
@@ -56,7 +56,7 @@ export declare const decodeSchema: <Type extends {
  * The output preserves the SSE `event` name and optional `id` while replacing
  * `data` with the decoded value.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decodeDataSchema: <Type, DecodingServices, IE, Done>(schema: Schema.Decoder<Type, DecodingServices>) => Channel.Channel<NonEmptyReadonlyArray<{
@@ -70,7 +70,7 @@ export declare const decodeDataSchema: <Type, DecodingServices, IE, Done>(schema
  * Call `feed` with text chunks to parse `Event` and `Retry` values through the
  * callback, and call `reset` to clear any buffered event state.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare function makeParser(onParse: (event: AnyEvent) => void): Parser;
@@ -79,7 +79,7 @@ export declare function makeParser(onParse: (event: AnyEvent) => void): Parser;
  *
  * `feed` accepts additional text chunks and `reset` clears buffered parser state.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export interface Parser {
@@ -92,7 +92,7 @@ export interface Parser {
  * If the upstream channel fails with `Retry`, the retry directive is written and
  * the encoder completes.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encode: <IE, Done>() => Channel.Channel<NonEmptyReadonlyArray<string>, IE, void, NonEmptyReadonlyArray<Event>, IE | Retry, Done>;
@@ -102,7 +102,7 @@ export declare const encode: <IE, Done>() => Channel.Channel<NonEmptyReadonlyArr
  * Values are schema-encoded to the untagged SSE event shape, transformed to
  * `Event`, and then written as Server-Sent Events text.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encodeSchema: <S extends Schema.Encoder<{
@@ -114,7 +114,7 @@ export declare const encodeSchema: <S extends Schema.Encoder<{
  * Encoder capable of rendering an `Event` or `Retry` value as Server-Sent
  * Events text.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export interface Encoder {
@@ -125,7 +125,7 @@ export interface Encoder {
  *
  * It contains the event name, optional event ID, and string data payload.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface Event {
@@ -139,7 +139,7 @@ export interface Event {
  *
  * The shape contains `id`, `event`, and string `data` fields.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export declare const EventEncoded: Schema.Struct<{
@@ -153,7 +153,7 @@ export declare const EventEncoded: Schema.Struct<{
  * The schema adds `_tag: "Event"` to the event name, optional event ID, and
  * string data payload.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export declare const Event: Schema.Struct<{
@@ -166,7 +166,7 @@ export declare const Event: Schema.Struct<{
  * Schema transformation between the untagged SSE event shape and the tagged
  * `Event` model.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export declare const transformEvent: Transformation.Transformation<{
@@ -184,7 +184,7 @@ export declare const transformEvent: Transformation.Transformation<{
  *
  * It contains the event name, optional event ID, and string data payload.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface EventEncoded {
@@ -202,7 +202,7 @@ declare const Retry_base: new <A extends Record<string, any> = {}>(args: import(
  * Decoders surface this value as a failure to request reconnection after
  * `duration`; encoders serialize an upstream `Retry` failure as a `retry:` line.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export declare class Retry extends Retry_base<{
@@ -232,7 +232,7 @@ export declare class Retry extends Retry_base<{
  * Union of SSE values that can be rendered by an `Encoder`: regular events and
  * retry directives.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type AnyEvent = Event | Retry;
@@ -242,7 +242,7 @@ export type AnyEvent = Event | Retry;
  * It renders `Event` values as `id`, `event`, and `data` lines and renders
  * `Retry` values as `retry:` directives.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encoder: Encoder;

package/dist/unstable/encoding/Sse.js

@@ -17,7 +17,7 @@ import * as Transformation from "../../SchemaTransformation.js";
  * SSE `retry` directives are emitted as `Retry` failures so callers can
  * reconnect with the requested delay.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export const decode = () => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {
@@ -53,7 +53,7 @@ export const decode = () => Channel.fromTransform((upstream, _scope) => Effect.s
  * The schema receives the untagged event shape containing `id`, `event`, and
  * string `data`.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export const decodeSchema = schema => Channel.pipeTo(decode(), ChannelSchema.decode(EventEncoded.pipe(Schema.decodeTo(schema)))());
@@ -64,7 +64,7 @@ export const decodeSchema = schema => Channel.pipeTo(decode(), ChannelSchema.dec
  * The output preserves the SSE `event` name and optional `id` while replacing
  * `data` with the decoded value.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export const decodeDataSchema = schema => {
@@ -80,7 +80,7 @@ export const decodeDataSchema = schema => {
  * Call `feed` with text chunks to parse `Event` and `Retry` values through the
  * callback, and call `reset` to clear any buffered event state.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export function makeParser(onParse) {
@@ -225,7 +225,7 @@ function hasBom(buffer) {
  * If the upstream channel fails with `Retry`, the retry directive is written and
  * the encoder completes.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export const encode = () => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {
@@ -242,7 +242,7 @@ export const encode = () => Channel.fromTransform((upstream, _scope) => Effect.s
  * Values are schema-encoded to the untagged SSE event shape, transformed to
  * `Event`, and then written as Server-Sent Events text.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export const encodeSchema = schema => ChannelSchema.encode(Event.pipe(Schema.decodeTo(schema, transformEvent)))().pipe(Channel.pipeTo(encode()));
@@ -251,7 +251,7 @@ export const encodeSchema = schema => ChannelSchema.encode(Event.pipe(Schema.dec
  *
  * The shape contains `id`, `event`, and string `data` fields.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export const EventEncoded = /*#__PURE__*/Schema.Struct({
@@ -265,7 +265,7 @@ export const EventEncoded = /*#__PURE__*/Schema.Struct({
  * The schema adds `_tag: "Event"` to the event name, optional event ID, and
  * string data payload.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export const Event = /*#__PURE__*/Schema.Struct({
@@ -278,7 +278,7 @@ export const Event = /*#__PURE__*/Schema.Struct({
  * Schema transformation between the untagged SSE event shape and the tagged
  * `Event` model.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export const transformEvent = /*#__PURE__*/Transformation.transform({
@@ -297,7 +297,7 @@ const RetryTypeId = "~effect/encoding/Sse/Retry";
  * Decoders surface this value as a failure to request reconnection after
  * `duration`; encoders serialize an upstream `Retry` failure as a `retry:` line.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export class Retry extends /*#__PURE__*/Data.TaggedClass("Retry") {
@@ -330,7 +330,7 @@ export class Retry extends /*#__PURE__*/Data.TaggedClass("Retry") {
  * It renders `Event` values as `id`, `event`, and `data` lines and renders
  * `Retry` values as `retry:` directives.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export const encoder = {

package/dist/unstable/encoding/index.d.ts

@@ -2,14 +2,63 @@
  * @since 4.0.0
  */
 /**
+ * Utilities for encoding Effect channel payloads and schema values as
+ * MessagePack bytes.
+ *
+ * This module is useful when a protocol or storage layer expects compact binary
+ * frames instead of JSON text, such as RPC transports, socket streams, caches,
+ * or database columns that carry typed Effect data. Use the raw channel helpers
+ * when both sides already agree on the MessagePack value shape, and use the
+ * schema-aware helpers when values should be validated, transformed, or decoded
+ * into domain types at the boundary.
+ *
+ * MessagePack preserves binary data and common JavaScript collection shapes, but
+ * it is still a data format rather than an Effect schema. Schema encoders run
+ * before packing and schema decoders run after unpacking, so unsupported runtime
+ * values, lossy schema encodings, or mismatched schemas surface as either
+ * `MsgPackError` or `SchemaError` depending on where the failure occurs.
+ *
  * @since 4.0.0
  */
 export * as Msgpack from "./Msgpack.ts";
 /**
+ * Utilities for encoding Effect channel payloads and schema values as
+ * newline-delimited JSON.
+ *
+ * NDJSON represents a stream as one complete JSON value per line, making this
+ * module useful for log pipelines, long-lived HTTP responses, socket protocols,
+ * and file formats where records should be processed incrementally instead of
+ * buffering a whole JSON array. Use the byte helpers at transport boundaries
+ * that speak UTF-8, the string helpers when text framing is already handled,
+ * and the schema-aware helpers when each record should be validated or
+ * transformed at the boundary.
+ *
+ * Encoders append a trailing newline after each emitted chunk, and decoders
+ * tolerate records split across input chunks. Empty lines are only skipped when
+ * `ignoreEmptyLines` is enabled; otherwise they are passed to `JSON.parse` and
+ * fail like any other invalid JSON record.
+ *
  * @since 4.0.0
  */
 export * as Ndjson from "./Ndjson.ts";
 /**
+ * Utilities for parsing and rendering Server-Sent Events text streams.
+ *
+ * This module is useful at HTTP streaming boundaries that speak the EventSource
+ * wire format, such as live updates, notifications, progress feeds, and other
+ * unidirectional server-to-client event streams. It provides low-level parser
+ * and encoder primitives, channel combinators for streaming chunks through
+ * Effect pipelines, and schema-aware helpers for validating or transforming the
+ * `id`, `event`, and string `data` fields at the edge of an application.
+ *
+ * SSE is line-oriented text rather than a framed binary protocol. Incoming
+ * chunks may split fields across arbitrary boundaries, events are dispatched by
+ * a blank line, repeated `data:` lines are joined with newlines, and `retry:`
+ * directives are control messages rather than regular events. The decoder
+ * handles UTF-8 byte order marks, CRLF and LF line endings, default `message`
+ * events, and retry directives so callers can reconnect with the requested
+ * delay while preserving the last event ID when available.
+ *
  * @since 4.0.0
  */
 export * as Sse from "./Sse.ts";

package/dist/unstable/encoding/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/encoding/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;GAEG;AACH,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/encoding/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA"}

package/dist/unstable/encoding/index.js

@@ -3,14 +3,63 @@
  */
 // @barrel: Auto-generated exports. Do not edit manually.
 /**
+ * Utilities for encoding Effect channel payloads and schema values as
+ * MessagePack bytes.
+ *
+ * This module is useful when a protocol or storage layer expects compact binary
+ * frames instead of JSON text, such as RPC transports, socket streams, caches,
+ * or database columns that carry typed Effect data. Use the raw channel helpers
+ * when both sides already agree on the MessagePack value shape, and use the
+ * schema-aware helpers when values should be validated, transformed, or decoded
+ * into domain types at the boundary.
+ *
+ * MessagePack preserves binary data and common JavaScript collection shapes, but
+ * it is still a data format rather than an Effect schema. Schema encoders run
+ * before packing and schema decoders run after unpacking, so unsupported runtime
+ * values, lossy schema encodings, or mismatched schemas surface as either
+ * `MsgPackError` or `SchemaError` depending on where the failure occurs.
+ *
  * @since 4.0.0
  */
 export * as Msgpack from "./Msgpack.js";
 /**
+ * Utilities for encoding Effect channel payloads and schema values as
+ * newline-delimited JSON.
+ *
+ * NDJSON represents a stream as one complete JSON value per line, making this
+ * module useful for log pipelines, long-lived HTTP responses, socket protocols,
+ * and file formats where records should be processed incrementally instead of
+ * buffering a whole JSON array. Use the byte helpers at transport boundaries
+ * that speak UTF-8, the string helpers when text framing is already handled,
+ * and the schema-aware helpers when each record should be validated or
+ * transformed at the boundary.
+ *
+ * Encoders append a trailing newline after each emitted chunk, and decoders
+ * tolerate records split across input chunks. Empty lines are only skipped when
+ * `ignoreEmptyLines` is enabled; otherwise they are passed to `JSON.parse` and
+ * fail like any other invalid JSON record.
+ *
  * @since 4.0.0
  */
 export * as Ndjson from "./Ndjson.js";
 /**
+ * Utilities for parsing and rendering Server-Sent Events text streams.
+ *
+ * This module is useful at HTTP streaming boundaries that speak the EventSource
+ * wire format, such as live updates, notifications, progress feeds, and other
+ * unidirectional server-to-client event streams. It provides low-level parser
+ * and encoder primitives, channel combinators for streaming chunks through
+ * Effect pipelines, and schema-aware helpers for validating or transforming the
+ * `id`, `event`, and string `data` fields at the edge of an application.
+ *
+ * SSE is line-oriented text rather than a framed binary protocol. Incoming
+ * chunks may split fields across arbitrary boundaries, events are dispatched by
+ * a blank line, repeated `data:` lines are joined with newlines, and `retry:`
+ * directives are control messages rather than regular events. The decoder
+ * handles UTF-8 byte order marks, CRLF and LF line endings, default `message`
+ * events, and retry directives so callers can reconnect with the requested
+ * delay while preserving the last event ID when available.
+ *
  * @since 4.0.0
  */
 export * as Sse from "./Sse.js";

package/dist/unstable/encoding/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["Msgpack","Ndjson","Sse"],"sources":["../../../src/unstable/encoding/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;AAGA,OAAO,KAAKA,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,GAAG,MAAM,UAAU","ignoreList":[]}
+{"version":3,"file":"index.js","names":["Msgpack","Ndjson","Sse"],"sources":["../../../src/unstable/encoding/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,KAAKA,OAAO,MAAM,cAAc;AAEvC;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,KAAKC,GAAG,MAAM,UAAU","ignoreList":[]}

package/dist/unstable/eventlog/Event.d.ts

@@ -3,14 +3,14 @@ import * as Msgpack from "../encoding/Msgpack.ts";
 /**
  * Unique type identifier used to mark event log event definitions.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export type TypeId = "~effect/eventlog/Event";
 /**
  * Runtime type identifier used to mark event log event definitions.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export declare const TypeId: TypeId;

package/dist/unstable/eventlog/Event.js

@@ -24,7 +24,7 @@ import * as Msgpack from "../encoding/Msgpack.js";
 /**
  * Runtime type identifier used to mark event log event definitions.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export const TypeId = "~effect/eventlog/Event";

package/dist/unstable/eventlog/EventGroup.d.ts

@@ -23,14 +23,14 @@ import * as Event from "./Event.ts";
 /**
  * Unique type identifier used to mark event log event groups.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export type TypeId = "~effect/eventlog/EventGroup";
 /**
  * Runtime type identifier used to mark event log event groups.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export declare const TypeId: TypeId;

package/dist/unstable/eventlog/EventGroup.js

@@ -23,7 +23,7 @@ import * as Event from "./Event.js";
 /**
  * Runtime type identifier used to mark event log event groups.
  *
- * @category type ids
+ * @category type IDs
  * @since 4.0.0
  */
 export const TypeId = "~effect/eventlog/EventGroup";