effect 4.0.0-beta.77 → 4.0.0-beta.79

package/src/internal/schema/representation.ts

@@ -276,8 +276,8 @@ export const fromASTBlacklist: Set<string> = new Set([
   "~structural",
   "~sentinels",
   "meta",
+  "arbitrary",
   "toArbitrary",
-  "toArbitraryConstraint",
   "toEquivalence",
   "toFormatter",
   "toCodec",

package/src/testing/FastCheck.ts

@@ -1,11 +1,10 @@
 /**
- * This module provides a re-export of the fast-check library for property-based testing.
- * Fast-check is a property-based testing framework that generates random test cases
- * to validate that properties hold true for a wide range of inputs.
+ * Re-exports `fast-check` for property-based testing.
  *
- * Property-based testing is a testing methodology where you specify properties that
- * should hold true for your functions, and the framework generates many random test
- * cases to try to find counterexamples.
+ * Property-based tests describe a rule that should hold for many inputs, and
+ * `fast-check` generates random examples to look for counterexamples. This
+ * module exposes the library from `effect/testing` so tests can use it alongside
+ * the other Effect testing helpers.
  *
  * @since 3.10.0
  */

package/src/testing/TestClock.ts

@@ -1,27 +1,12 @@
 /**
- * The `TestClock` module provides a controllable implementation of the Effect
- * `Clock` service for tests. Instead of waiting for real time to pass, effects
- * that use `Effect.sleep`, timeouts, schedules, retries, and other time-based
- * operators can be driven deterministically by advancing the test clock.
- *
- * **Common use cases**
- *
- * - Testing sleeps, delays, timeouts, debouncing, retries, and schedules without
- *   slowing the test suite down
- * - Advancing time with {@link adjust} or jumping to an exact timestamp with
- *   {@link setTime}
- * - Running a specific effect against the live clock with {@link withLive}
- *   while the rest of the test remains under test-clock control
- *
- * **Testing gotchas**
- *
- * - Effects that sleep semantically block until the clock is advanced far
- *   enough, so tests usually fork the time-dependent effect before calling
- *   {@link adjust} or {@link setTime}
- * - Scheduled sleeps are resumed in clock-time order as the test clock moves
- *   forward
- * - If a test uses time but never advances the `TestClock`, the module starts a
- *   delayed warning to help identify a hanging test
+ * Controllable `Clock` service for tests.
+ *
+ * Instead of waiting for real time to pass, effects that use `Effect.sleep`,
+ * timeouts, schedules, retries, and other time-based operators can be driven by
+ * advancing the test clock. This makes time-based tests deterministic and fast.
+ * The module also includes helpers for moving test time, temporarily using the
+ * live clock, and warning when a test appears to be waiting on time without
+ * advancing it.
  *
  * @since 2.0.0
  */

package/src/testing/TestConsole.ts

@@ -1,40 +1,11 @@
 /**
- * The `TestConsole` module provides a test implementation of the Effect
- * `Console` service. When {@link layer} is provided, calls made through the
- * Effect console APIs are captured in memory instead of being written to the
- * host console, so tests can assert on logged values deterministically.
- *
- * This module is intentionally small: it gives tests a console layer, helpers
- * for reading captured `Console.log` and `Console.error` arguments, and a way
- * to access the provided test console service directly.
- *
- * **Mental model**
- *
- * - {@link layer} replaces the current `Console` service with a fresh
- *   in-memory test console for the effect it is provided to
- * - Code under test must call Effect's `Console` APIs; direct calls to
- *   `globalThis.console` are outside the service and are not captured
- * - {@link logLines} returns the values passed to `Console.log` in call order
- * - {@link errorLines} returns the values passed to `Console.error` in call
- *   order
- * - {@link testConsoleWith} gives direct access to the current `TestConsole`
- *   service when a test needs to inspect or call it manually
- *
- * **Common tasks**
- *
- * - Capture console output by providing {@link layer}
- * - Assert on logged values with {@link logLines}
- * - Assert on error output with {@link errorLines}
- * - Construct a standalone test console service with {@link make}
- * - Access the provided service with {@link testConsoleWith}
- *
- * **Gotchas**
- *
- * - Captured log and error values are the original arguments, not formatted
- *   strings
- * - `logLines` and `errorLines` expose `Console.log` and `Console.error`
- *   output; other console methods are implemented for compatibility but do not
- *   have dedicated accessor effects in this module
+ * Provides a test implementation of the Effect `Console` service.
+ *
+ * When the test layer is provided, calls made through the Effect console APIs
+ * are captured in memory instead of being written to the host console. Tests can
+ * then assert on logged values deterministically. This module includes the
+ * console layer, helpers for reading captured `Console.log` and `Console.error`
+ * arguments, and access to the provided test console service.
  *
  * @since 4.0.0
  */

package/src/testing/TestSchema.ts

@@ -1,68 +1,11 @@
 /**
- * Testing utilities for asserting Schema decoding, encoding, make, and
- * arbitrary-generation behavior. Used in unit tests to verify that schemas
- * accept, reject, and round-trip values correctly.
+ * Provides helpers for testing Schema behavior.
  *
- * ## Mental model
- *
- * - **Asserts** – entry point: wraps a schema and exposes helpers grouped by
- *   operation (decoding, encoding, make, arbitrary, round-trip).
- * - **Decoding** – returned by `asserts.decoding()`; has `succeed` / `fail`
- *   helpers that run the schema's decoder and compare the result.
- * - **Encoding** – returned by `asserts.encoding()`; mirrors {@link Decoding}
- *   but exercises the encoder direction.
- * - Every assertion is async (`Promise<void>`) because parsing may involve
- *   effectful schemas.
- * - `succeed` with one argument asserts identity (output equals input);
- *   with two arguments asserts a specific expected output.
- * - `fail` always takes the input and the expected error message string.
- *
- * ## Common tasks
- *
- * - Assert decoding succeeds / fails → `new Asserts(schema).decoding().succeed(…)` / `.fail(…)`
- * - Assert encoding succeeds / fails → `new Asserts(schema).encoding().succeed(…)` / `.fail(…)`
- * - Assert make succeeds / fails → `new Asserts(schema).make().succeed(…)` / `.fail(…)`
- * - Verify round-trip (encode then decode) → `new Asserts(schema).verifyLosslessTransformation()`
- * - Verify arbitrary generation → `new Asserts(schema).arbitrary().verifyGeneration()`
- * - Compare AST of struct fields → `Asserts.ast.fields.equals(a, b)`
- * - Provide a service dependency for decoding → `asserts.decoding().provide(key, impl)`
- *
- * ## Gotchas
- *
- * - `succeed` uses `assert.deepStrictEqual`, so reference equality is not
- *   required but structural equality is.
- * - `fail` compares against the stringified `Issue`, not the `Issue` object
- *   itself. Pass the exact multiline string the issue produces.
- * - `verifyLosslessTransformation` and `arbitrary().verifyGeneration` run
- *   property-based tests via FastCheck; default run count is 20 for
- *   `verifyGeneration`.
- *
- * ## Quickstart
- *
- * **Example** (Basic decoding and encoding assertions)
- *
- * ```ts
- * import { Schema } from "effect"
- * import { TestSchema } from "effect/testing"
- *
- * const schema = Schema.NumberFromString
- * const asserts = new TestSchema.Asserts(schema)
- *
- * // decoding
- * const decoding = asserts.decoding()
- * await decoding.succeed("1", 1)
- * await decoding.fail(null, "Expected string, got null")
- *
- * // encoding
- * const encoding = asserts.encoding()
- * await encoding.succeed(1, "1")
- * ```
- *
- * ## See also
- *
- * - {@link Asserts}
- * - {@link Decoding}
- * - {@link Encoding}
+ * These utilities assert how schemas construct values, decode input, encode
+ * output, generate arbitrary values, and round-trip between encoded and decoded
+ * forms. The `Asserts` class groups the common checks for one schema, while
+ * `Decoding` and `Encoding` can be used directly when a test only needs one
+ * direction.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/AiError.ts

@@ -1,82 +1,13 @@
 /**
- * The `AiError` module provides comprehensive, provider-agnostic error handling
- * for AI operations.
- *
- * This module uses the `reason` pattern where `AiError` is a top-level
- * wrapper error containing `module`, `method`, and a `reason` field that holds
- * the semantic error. This design enables ergonomic error handling while
- * preserving rich context about failures.
- *
- * ## Semantic Error Categories
- *
- * - **RateLimitError** - Request throttled (429s, provider-specific limits)
- * - **QuotaExhaustedError** - Account/billing limits reached
- * - **AuthenticationError** - Invalid/expired credentials
- * - **ContentPolicyError** - Input/output violated content policy
- * - **InvalidRequestError** - Malformed request parameters
- * - **InvalidUserInputError** - Prompt contains unsupported content
- * - **InternalProviderError** - Provider-side failures (5xx)
- * - **NetworkError** - Transport-level failures
- * - **InvalidOutputError** - LLM output parsing/validation failures
- * - **StructuredOutputError** - LLM generated text that doesn't conform to structured output schema
- * - **UnsupportedSchemaError** - Codec transformer rejected a schema with unsupported constructs
- * - **UnknownError** - Catch-all for unknown errors
- *
- * ## Tool Call Errors
- *
- * - **ToolNotFoundError** - Model requested non-existent tool
- * - **ToolParameterValidationError** - Tool call params failed validation
- * - **InvalidToolResultError** - Tool handler returned invalid result
- * - **ToolResultEncodingError** - Tool result encoding failed
- * - **ToolConfigurationError** - Provider tool misconfigured
- *
- * ## Retryability
- *
- * Each reason type has an `isRetryable` getter indicating whether the error is
- * transient. Some errors also provide a `retryAfter` duration hint.
- *
- * **Example** (Handling AI errors by reason)
- *
- * ```ts
- * import { Effect, Match } from "effect"
- * import type { AiError } from "effect/unstable/ai"
- *
- * // Handle errors using Match on the reason
- * const handleAiError = Match.type<AiError.AiError>().pipe(
- *   Match.when(
- *     { reason: { _tag: "RateLimitError" } },
- *     (err) => Effect.logWarning(`Rate limited, retry after ${err.retryAfter}`)
- *   ),
- *   Match.when(
- *     { reason: { _tag: "AuthenticationError" } },
- *     (err) => Effect.logError(`Auth failed: ${err.reason.kind}`)
- *   ),
- *   Match.when(
- *     { reason: { isRetryable: true } },
- *     (err) => Effect.logWarning(`Transient error, retrying: ${err.message}`)
- *   ),
- *   Match.orElse((err) => Effect.logError(`Permanent error: ${err.message}`))
- * )
- * ```
- *
- * **Example** (Creating an AI error with a reason)
- *
- * ```ts
- * import { Duration, Effect } from "effect"
- * import { AiError } from "effect/unstable/ai"
- *
- * // Create an AiError with a reason
- * const error = AiError.make({
- *   module: "OpenAI",
- *   method: "completion",
- *   reason: new AiError.RateLimitError({
- *     retryAfter: Duration.seconds(60)
- *   })
- * })
- *
- * console.log(error.isRetryable) // true
- * console.log(error.message) // "OpenAI.completion: Rate limit exceeded. Retry after 1 minute"
- * ```
+ * Defines shared errors for AI operations.
+ *
+ * `AiError` records where a failure happened and stores the detailed reason in a
+ * `reason` field. Those reasons cover transport problems, provider responses,
+ * rate limits, authentication, content policy failures, invalid requests,
+ * invalid output, unsupported schemas, tool failures, invalid user input, and
+ * unknown failures. This module also includes metadata schemas, guards,
+ * constructors, and helpers for converting HTTP response information into AI
+ * error reasons.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/AnthropicStructuredOutput.ts

@@ -1,38 +1,13 @@
 /**
- * Adapt Effect Schema codecs to the JSON Schema subset accepted by Anthropic
+ * Adapts Effect Schema codecs to the JSON Schema subset accepted by Anthropic
  * structured output.
  *
- * The main entry point is {@link toCodecAnthropic}. It returns the JSON Schema
- * to send to Anthropic and a codec that preserves the original decoded value
- * type while changing the encoded representation when Anthropic cannot express
- * that shape directly.
- *
- * **Mental model**
- *
- * Anthropic structured output accepts a narrower schema vocabulary than Effect
- * Schema. This module walks the encoded schema AST before JSON Schema
- * generation, rewrites unsupported shapes into provider-safe encodings, and
- * leaves the returned codec responsible for translating model output back into
- * the original application shape.
- *
- * **Common tasks**
- *
- * - Convert a `Schema.Codec` for Anthropic structured output with
- *   {@link toCodecAnthropic}
- * - Decode model output with the returned codec so transformed tuples, records,
- *   and optional properties become the original values again
- * - Preserve provider-compatible descriptions and formats while dropping or
- *   rewriting annotations Anthropic cannot represent
- *
- * **Gotchas**
- *
- * - The emitted JSON Schema may use an encoded shape: tuples become objects
- *   with numeric string keys, records become arrays of `[key, value]` pairs, and
- *   optional properties become required properties that accept `null`.
- * - Unsupported schema kinds throw during conversion rather than producing a
- *   lossy schema.
- * - `oneOf` unions are emitted as `anyOf` unions because Anthropic's structured
- *   output subset does not support the full JSON Schema vocabulary.
+ * The main entry point returns the JSON Schema to send to Anthropic and a codec
+ * for decoding the model response back into the original application type. When
+ * Anthropic cannot express the original schema shape directly, the conversion
+ * rewrites supported cases such as tuples, records, optional properties, and
+ * `oneOf` unions. Schema kinds that cannot be represented throw during
+ * conversion instead of producing a lossy schema.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/Chat.ts

@@ -8,52 +8,6 @@
  * sessions, seed sessions from prompts, restore exported history, or connect a
  * chat to persistence.
  *
- * **Mental model**
- *
- * A {@link Service} is a mutable conversation handle. It stores history, while
- * the language model implementation is still supplied through the Effect
- * environment when `generateText`, `streamText`, or `generateObject` runs.
- * Local sessions created with {@link empty} and {@link fromPrompt} live only in
- * memory; persisted sessions add a backing store and save after generation.
- *
- * **Common tasks**
- *
- * - Start an empty session with {@link empty}.
- * - Seed system prompts or prior messages with {@link fromPrompt}.
- * - Restore saved history with {@link fromExport} or {@link fromJson}.
- * - Persist sessions by providing {@link Persistence} with {@link makePersisted}
- *   or {@link layerPersisted}.
- *
- * **Example** (Starting a chat session)
- *
- * ```ts
- * import { Effect } from "effect"
- * import { Chat } from "effect/unstable/ai"
- *
- * const program = Effect.gen(function*() {
- *   const chat = yield* Chat.fromPrompt([{
- *     role: "system",
- *     content: "Answer in one sentence."
- *   }])
- *
- *   const response = yield* chat.generateText({
- *     prompt: "What does Effect provide for TypeScript applications?"
- *   })
- *
- *   const saved = yield* chat.exportJson
- *
- *   return { text: response.text, saved }
- * })
- * ```
- *
- * **Gotchas**
- *
- * Generation requires a language model service in the environment. `streamText`
- * records the parts emitted by the stream when the stream finalizes, so consume
- * the stream to completion when the full assistant response should become part
- * of history. Direct writes to `history` are possible, but bypass the helpers
- * that encode, decode, export, and persist the conversation.
- *
  * @since 4.0.0
  */
 import * as Channel from "../../Channel.ts"

package/src/unstable/ai/EmbeddingModel.ts

@@ -1,49 +1,12 @@
 /**
- * The `EmbeddingModel` module defines the provider-neutral service for turning
- * text into embedding vectors. It exposes single-input `embed` and ordered
- * batch `embedMany` operations, and keeps provider failures represented as
- * `AiError` values.
- *
- * **Mental model**
- *
- * Providers supply one batch embedding function through `make`. The module
- * derives single-input `embed` calls from a request resolver, so concurrent
- * single-input requests can be batched into one provider call. Provider
- * vectors are wrapped as `EmbedResponse` values, while `EmbedManyResponse`
- * preserves input order and carries token usage when the provider reports it.
- *
- * **Common tasks**
- *
- * - Build an `EmbeddingModel` service from a provider implementation.
- * - Use `embed` for one query or document, and `embedMany` when the caller
- *   already has a batch.
- * - Read `Dimensions` when downstream code needs the configured vector size.
- *
- * **Example** (Building a small embedding model)
- *
- * ```ts
- * import { Effect } from "effect"
- * import { EmbeddingModel } from "effect/unstable/ai"
- *
- * const program = Effect.gen(function*() {
- *   const model = yield* EmbeddingModel.make({
- *     embedMany: ({ inputs }) =>
- *       Effect.succeed({
- *         results: inputs.map((input) => [input.length]),
- *         usage: { inputTokens: inputs.join(" ").length }
- *       })
- *   })
- *
- *   const response = yield* model.embed("hello")
- *   return response.vector
- * })
- * ```
- *
- * **Gotchas**
- *
- * - `embedMany([])` returns an empty response without invoking the provider.
- * - Provider batch responses must contain exactly one vector for each input,
- *   in the same order as the input array.
+ * Defines the provider-neutral service for text embeddings.
+ *
+ * An `EmbeddingModel` turns text into numeric vectors. It supports single-input
+ * embedding and ordered batch embedding, and represents provider failures as
+ * `AiError` values. This module also includes the embedding dimensions service,
+ * request and response models, usage metadata, provider contracts, and a
+ * constructor that adapts a provider batch implementation into the service.
+ * Single `embed` calls can be batched together internally.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/IdGenerator.ts

@@ -1,49 +1,11 @@
 /**
- * The `IdGenerator` module provides a pluggable system for generating unique identifiers
- * for tool calls and other items in the Effect AI SDKs.
+ * Provides identifier generation for AI features.
  *
- * This module offers a flexible and configurable approach to ID generation, supporting
- * custom alphabets, prefixes, separators, and sizes.
- *
- * **Example** (Generating IDs with the default service)
- *
- * ```ts
- * import { Effect } from "effect"
- * import { IdGenerator } from "effect/unstable/ai"
- *
- * // Using the default ID generator
- * const program = Effect.gen(function*() {
- *   const idGen = yield* IdGenerator.IdGenerator
- *   const toolCallId = yield* idGen.generateId()
- *   console.log(toolCallId) // "id_A7xK9mP2qR5tY8uV"
- *   return toolCallId
- * }).pipe(Effect.provideService(
- *   IdGenerator.IdGenerator,
- *   IdGenerator.defaultIdGenerator
- * ))
- * ```
- *
- * **Example** (Providing a custom ID generator)
- *
- * ```ts
- * import { Effect } from "effect"
- * import { IdGenerator } from "effect/unstable/ai"
- *
- * // Creating a custom ID generator for AI tool calls
- * const customLayer = IdGenerator.layer({
- *   alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
- *   prefix: "tool_call",
- *   separator: "-",
- *   size: 12
- * })
- *
- * const program = Effect.gen(function*() {
- *   const idGen = yield* IdGenerator.IdGenerator
- *   const id = yield* idGen.generateId()
- *   console.log(id) // "tool_call-A7XK9MP2QR5T"
- *   return id
- * }).pipe(Effect.provide(customLayer))
- * ```
+ * The `IdGenerator` service exposes one operation, `generateId`, which returns
+ * a string inside `Effect`. AI modules use it for values such as tool call ids
+ * and generated response item ids. This module includes the service tag,
+ * service interface, default generator, configurable custom generator, and layer
+ * for providing the service.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/LanguageModel.ts

@@ -1,52 +1,13 @@
 /**
- * The `LanguageModel` module provides AI text generation capabilities with tool
- * calling support.
- *
- * This module offers a comprehensive interface for interacting with large
- * language models, supporting both streaming and non-streaming text generation,
- * structured output generation, and tool calling functionality. It provides a
- * unified API that can be implemented by different AI providers while
- * maintaining type safety and effect management.
- *
- * **Example** (Generating text)
- *
- * ```ts
- * import { Effect } from "effect"
- * import { LanguageModel } from "effect/unstable/ai"
- *
- * // Basic text generation
- * const program = Effect.gen(function*() {
- *   const response = yield* LanguageModel.generateText({
- *     prompt: "Explain quantum computing"
- *   })
- *
- *   console.log(response.text)
- *
- *   return response
- * })
- * ```
- *
- * **Example** (Generating structured output)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { LanguageModel } from "effect/unstable/ai"
- *
- * // Structured output generation
- * const ContactSchema = Schema.Struct({
- *   name: Schema.String,
- *   email: Schema.String
- * })
- *
- * const extractContact = Effect.gen(function*() {
- *   const response = yield* LanguageModel.generateObject({
- *     prompt: "Extract contact: John Doe, john@example.com",
- *     schema: ContactSchema
- *   })
- *
- *   return response.value
- * })
- * ```
+ * Defines the shared service for language model providers.
+ *
+ * The `LanguageModel` service lets application code ask for generated text,
+ * streamed text, or structured output without depending on a specific provider.
+ * Requests can include tools, and the service can resolve tool calls while the
+ * model is generating a response. This module contains the service contract,
+ * request and response types, structured-output support, and the constructor
+ * used by provider packages to adapt their own generate and stream functions to
+ * the shared interface.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/McpSchema.ts

@@ -1,31 +1,12 @@
 /**
- * The `McpSchema` module defines Effect Schema and RPC models for the Model
- * Context Protocol (MCP). It provides the shared protocol vocabulary used by
- * MCP clients and servers, including JSON-RPC request identifiers, metadata,
- * capabilities, errors, resources, prompts, tools, logging, sampling,
- * completions, roots, and elicitation.
- *
- * **Common tasks**
- *
- * - Describe MCP payloads with schemas such as {@link Resource}, {@link Tool},
- *   {@link Prompt}, and {@link ContentBlock}
- * - Build typed protocol handlers with request RPCs such as {@link Initialize},
- *   {@link ListResources}, {@link ReadResource}, {@link ListTools}, and
- *   {@link CallTool}
- * - Work with protocol notifications such as
- *   {@link ProgressNotification}, {@link ResourceUpdatedNotification}, and
- *   {@link LoggingMessageNotification}
- * - Use {@link ClientRpcs} and server RPC groups to derive encoded request,
- *   notification, success, and failure message types
- *
- * **Gotchas**
- *
- * - MCP distinguishes absent fields from present fields whose value is
- *   `undefined`; use {@link optional} and {@link optionalWithDefault} for
- *   protocol fields so encoding omits undefined values consistently.
- * - Capability objects are extensible. Known fields are modeled here, but
- *   `experimental` and `extensions` allow implementations to advertise
- *   additional protocol features.
+ * Defines schemas for Model Context Protocol messages.
+ *
+ * MCP clients and servers use these schemas to describe the JSON-RPC requests,
+ * notifications, results, and errors that can cross the protocol boundary. This
+ * module focuses on message shapes: it defines the shared protocol data model,
+ * groups related messages for the RPC layer, and provides helpers for optional
+ * fields and parameter metadata. Transport and server behavior live in other
+ * modules.
  *
  * @since 4.0.0
  */

package/src/unstable/ai/McpServer.ts

@@ -1,26 +1,12 @@
 /**
- * The `McpServer` module provides Effect services and layers for building
- * Model Context Protocol servers. It keeps track of registered tools,
- * resources, resource templates, prompts, completions, and server
- * notifications, then exposes them through the MCP request handlers.
+ * Builds Model Context Protocol (MCP) servers with Effect.
  *
- * **Common tasks**
- *
- * - Start a server over stdio with {@link layerStdio}
- * - Register HTTP routes for an existing `HttpRouter` with {@link layerHttp}
- * - Expose Effect AI toolkits as MCP tools with {@link registerToolkit}
- * - Register resources, resource templates, and prompts with {@link resource}
- *   and {@link prompt}
- * - Ask the connected MCP client for structured input with {@link elicit}
- *
- * **Gotchas**
- *
- * - Registration helpers require an `McpServer` service, usually provided by
- *   one of this module's layers.
- * - HTTP clients must complete MCP initialization before other requests; the
- *   server tracks initialized sessions with the `Mcp-Session-Id` header.
- * - Resource template parameters are decoded with the schemas embedded in the
- *   template literal.
+ * The `McpServer` service stores the tools, resources, resource templates,
+ * prompts, completions, initialized clients, and outgoing notifications exposed
+ * by a server. This module also includes the server runner, custom protocol,
+ * stdio, and HTTP layers, registration helpers, and APIs that let handlers ask
+ * the connected client for structured input or read its advertised
+ * capabilities.
  *
  * @since 4.0.0
  */