effect 4.0.1 → 4.0.2

package/src/rpc/RpcClient.ts

@@ -13,8 +13,9 @@
  */
 import type { NonEmptyReadonlyArray } from "../Array.ts"
 import * as Cause from "../Cause.ts"
+import * as Clock from "../Clock.ts"
 import * as Context from "../Context.ts"
-import type * as Duration from "../Duration.ts"
+import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import * as Fiber from "../Fiber.ts"
@@ -42,6 +43,7 @@ import type { Span } from "../Tracer.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import * as Worker from "../workers/Worker.ts"
 import type { WorkerError } from "../workers/WorkerError.ts"
+import * as RpcTracing from "./internal/tracing.ts"
 import * as Rpc from "./Rpc.ts"
 import { RpcClientDefect, RpcClientError } from "./RpcClientError.ts"
 import type * as RpcGroup from "./RpcGroup.ts"
@@ -267,7 +269,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     readonly flatten?: Flatten | undefined
   }
 ) {
-  const spanPrefix = options?.spanPrefix ?? "RpcClient"
+  const spanPrefix = options.spanPrefix
   const supportsAck = options?.supportsAck ?? true
   const disableTracing = options?.disableTracing ?? false
   const generateRequestId = options?.generateRequestId ?? (() => requestIdCounter++ as RequestId)
@@ -335,8 +337,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             opts?.discard ?? false
           )
         return disableTracing ? onRequest(undefined) : Effect.useSpan(
-          `${spanPrefix}.${rpc._tag}`,
-          { attributes: options.spanAttributes },
+          RpcTracing.spanName(spanPrefix, rpc._tag),
+          { kind: "client", attributes: RpcTracing.spanAttributes(rpc._tag, options.spanAttributes) },
           onRequest
         )
       }
@@ -447,9 +449,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       return yield* Effect.interrupt
     }
 
-    const span = disableTracing ? undefined : yield* Effect.makeSpanScoped(`${spanPrefix}.${rpc._tag}`, {
-      attributes: options.spanAttributes
-    })
+    const span = disableTracing ? undefined : yield* Effect.makeSpanScoped(
+      RpcTracing.spanName(spanPrefix, rpc._tag),
+      { kind: "client", attributes: RpcTracing.spanAttributes(rpc._tag, options.spanAttributes) }
+    )
     const fiber = Fiber.getCurrent()!
     const id = generateRequestId()
 
@@ -1046,16 +1049,24 @@ export const layerProtocolHttp = (options: {
  * `RpcSerialization`, connection hooks, ping timeouts, and the configured retry
  * policy.
  *
+ * **Details**
+ *
+ * `pingInterval` defaults to 5 seconds. `pingTimeout` defaults to the interval
+ * and measures time since the last decoded server frame, not the last pong.
+ * The timeout is checked on each ping tick; any decoded frame counts as liveness.
+ *
  * @stability unstable
  * @category protocols
  * @since 4.0.0
  */
 export const makeProtocolSocket = (options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
   readonly retryTransientErrors?: boolean | undefined
   readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * A missed pong fails in-flight calls and is not reported through this hook.
+   * A ping timeout fails in-flight calls and is not reported through this hook.
    * The returned `Effect<void>` cannot fail with a typed error or require
    * services; defects are logged and ignored so retries can continue.
    */
@@ -1078,7 +1089,7 @@ export const makeProtocolSocket = (options?: {
     // `parser` is replaced on every connect, and a stateful serialization
     // encodes against the connection it is writing to, so the ping is encoded
     // when it is sent rather than once up front.
-    const pinger = yield* makePinger(Effect.suspend(() => writer.write(parser.encode(constPing)!)))
+    const pinger = yield* makePinger(Effect.suspend(() => writer.write(parser.encode(constPing)!)), options)
     let currentError: RpcClientError | undefined
 
     const broadcast = (response: FromServerEncoded) =>
@@ -1095,15 +1106,13 @@ export const makeProtocolSocket = (options?: {
       try {
         const responses = parser.decode(data) as Array<FromServerEncoded>
         if (responses.length === 0) return Effect.void
+        pinger.onFrame()
         let i = 0
         return Effect.whileLoop({
           while: () => i < responses.length,
           body: () => {
             const response = responses[i++]
-            if (response._tag === "Pong") {
-              pinger.onPong()
-              return Effect.void
-            }
+            if (response._tag === "Pong") return Effect.void
             if (Object.hasOwn(response, "requestId")) {
               const requestId = (response as FromServerEncoded & { readonly requestId: string | number }).requestId
               const clientId = requestClientMap.get(requestId)
@@ -1218,43 +1227,58 @@ const defaultRetryPolicy = Schedule.min([
   Schedule.spaced(5000)
 ])
 
-const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>) {
-  let recievedPong = true
+const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>, options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
+}) {
+  const clock = yield* Clock.Clock
+  const interval = options?.pingInterval ?? "5 seconds"
+  const timeoutMillis = Duration.toMillis(options?.pingTimeout ?? interval)
+  let lastSeen = clock.currentTimeMillisUnsafe()
   const latch = Latch.makeUnsafe()
+  const onFrame = () => {
+    lastSeen = clock.currentTimeMillisUnsafe()
+  }
   const reset = () => {
-    recievedPong = true
+    onFrame()
     latch.closeUnsafe()
   }
-  const onPong = () => {
-    recievedPong = true
-  }
   yield* Effect.suspend((): Effect.Effect<void, E, R> => {
-    if (!recievedPong) return latch.open
-    recievedPong = false
+    if (clock.currentTimeMillisUnsafe() - lastSeen > timeoutMillis) return latch.open
     return writePing
   }).pipe(
-    Effect.delay("5 seconds"),
+    Effect.delay(interval),
     Effect.ignore,
     Effect.forever,
     Effect.interruptible,
     Effect.forkScoped
   )
-  return { timeout: latch.await, reset, onPong } as const
+  return { timeout: latch.await, reset, onFrame } as const
 })
 
 /**
  * Provides a client `Protocol` backed by the current `Socket` and
  * `RpcSerialization` services.
  *
+ * **Details**
+ *
+ * `pingInterval` defaults to 5 seconds. `pingTimeout` defaults to the interval
+ * and measures time since the last decoded server frame, not the last pong.
+ * The timeout is checked on each ping tick; any decoded frame counts as liveness.
+ * `retryPolicy` configures retries after socket errors.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
  */
 export const layerProtocolSocket = (options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
   readonly retryTransientErrors?: boolean | undefined
+  readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * A missed pong fails in-flight calls and is not reported through this hook.
+   * A ping timeout fails in-flight calls and is not reported through this hook.
    * The returned `Effect<void>` cannot fail with a typed error or require
    * services; defects are logged and ignored so retries can continue.
    */

package/src/rpc/RpcServer.ts

@@ -44,6 +44,7 @@ import type * as Types from "../Types.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import type { WorkerError } from "../workers/WorkerError.ts"
 import * as WorkerRunner from "../workers/WorkerRunner.ts"
+import * as RpcTracing from "./internal/tracing.ts"
 import * as Rpc from "./Rpc.ts"
 import type * as RpcGroup from "./RpcGroup.ts"
 import type {
@@ -117,7 +118,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const enableTracing = options.disableTracing !== true
   const enableSpanPropagation = options.disableSpanPropagation !== true
   const supportsAck = options.disableClientAcks !== true
-  const spanPrefix = options.spanPrefix ?? "RpcServer"
+  const spanPrefix = options.spanPrefix
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
   const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
@@ -331,9 +332,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
         requestFiber.context,
         Tracer.ParentSpan
       )
-      effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
+      effect = Effect.withSpan(effect, RpcTracing.spanName(spanPrefix, request.tag), {
         captureStackTrace: false,
-        attributes: options.spanAttributes,
+        kind: "server",
+        attributes: RpcTracing.spanAttributes(request.tag, options.spanAttributes),
         parent: enableSpanPropagation && request.spanId
           ? Tracer.externalSpan({
             traceId: request.traceId!,
@@ -359,11 +361,14 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     )
     const fiber = trackFiber(
       runFork(
-        effect,
+        // Register before the handler runs to catch synchronous cancellation.
+        Effect.withFiber((fiber) => {
+          client.fibers.set(request.id, fiber)
+          return effect
+        }),
         isUninterruptible ? { uninterruptible: true } : undefined
       )
     )
-    client.fibers.set(request.id, fiber)
     fiber.addObserver(function onExit(exit: Exit.Exit<any, any>): void {
       if (deferred) {
         const fiber = trackFiber(runFork(Effect.onExit(Deferred.await(deferred), (exit) =>
@@ -564,6 +569,10 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsTransferables
   } = yield* Protocol
   const encodeDefectUnsafe = Schema.encodeSync(codecFor(Schema.Defect()))
+  // Unknown tags have no RPC schema, so use a defect-only exit schema.
+  const encodeUnknownRequestExit: Schemas["encodeExit"] = Schema.encodeUnknownEffect(
+    codecFor(Schema.Exit(Schema.Never, Schema.Never, Schema.Defect()))
+  ) as any
   const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
@@ -629,7 +638,6 @@ export const make: <Rpcs extends Rpc.Any>(
       u: NonEmptyReadonlyArray<unknown>
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
-    readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
     readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
@@ -648,7 +656,6 @@ export const make: <Rpcs extends Rpc.Any>(
           )
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any))) as any,
-        encodeDefect: Schema.encodeUnknownEffect(codecFor(rpc.defectSchema)) as any,
         context: entry.context
       }
       schemasCache.set(rpc, schemas)
@@ -694,7 +701,7 @@ export const make: <Rpcs extends Rpc.Any>(
       client.schemas.delete(requestId)
       const defect = Cause.squash(Cause.map(cause, (e) => SchemaIssue.defaultFormatter(e.issue)))
       return Effect.andThen(
-        sendRequestDefect(client, requestId, schemas.encodeDefect, defect),
+        sendRequestDefect(client, requestId, schemas.encodeExit, defect),
         server.write(client.id, { _tag: "Interrupt", requestId, interruptors: [] })
       )
     })
@@ -703,22 +710,14 @@ export const make: <Rpcs extends Rpc.Any>(
   const sendRequestDefect = (
     client: Client,
     requestId: RequestId,
-    encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>,
+    encodeExit: Schemas["encodeExit"],
     defect: unknown
   ) =>
     Effect.catchCause(
-      Effect.flatMap(encodeDefect(defect), (encodedDefect) =>
-        send(client.id, {
-          _tag: "Exit",
-          requestId,
-          exit: {
-            _tag: "Failure",
-            cause: [{
-              _tag: "Die",
-              defect: encodedDefect
-            }]
-          }
-        })),
+      Effect.flatMap(
+        encodeExit(Exit.die(defect)),
+        (exit) => send(client.id, responseEnvelope(requestId, "Exit", exit))
+      ),
       (cause) => sendDefect(client, Cause.squash(cause))
     )
 
@@ -784,7 +783,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const rpc = group.requests.get(tag)
         if (!rpc) {
-          return sendRequestDefect(client, requestId, (defect) => Effect.succeed(defect), `Unknown request tag: ${tag}`)
+          return sendRequestDefect(client, requestId, encodeUnknownRequestExit, `Unknown request tag: ${tag}`)
         }
         const schemas = getSchemas(rpc as any)
         const decoded = schemas.decode(request.payload)
@@ -798,7 +797,7 @@ export const make: <Rpcs extends Rpc.Any>(
           Effect.provideContext(decoded, schemas.context),
           {
             onFailure: (error) =>
-              sendRequestDefect(client, requestId, schemas.encodeDefect, SchemaIssue.defaultFormatter(error.issue)),
+              sendRequestDefect(client, requestId, schemas.encodeExit, SchemaIssue.defaultFormatter(error.issue)),
             onSuccess: (payload) => writeDecodedRequest(client, requestId, schemas, request, payload)
           }
         )
@@ -1181,7 +1180,10 @@ export const makeProtocolWithHttpEffect: (
       })
     }
 
-    const initialChunk = yield* Queue.takeAll(queue) as any as Effect.Effect<NonEmptyReadonlyArray<Uint8Array>>
+    const initialChunk = yield* Pull.catchDone(
+      Queue.takeAll(queue as Queue.Dequeue<Uint8Array, Cause.Done>),
+      () => Effect.succeed([])
+    )
     if (queue.state._tag === "Done") {
       return HttpServerResponse.uint8Array(mergeUint8Arrays(initialChunk), {
         contentType: serialization.contentType

package/src/rpc/internal/tracing.ts

@@ -0,0 +1,22 @@
+/**
+ * Names the span after the RPC method, or `${spanPrefix}.${tag}` when a prefix
+ * is configured.
+ *
+ * @internal
+ */
+export const spanName = (spanPrefix: string | undefined, tag: string): string =>
+  spanPrefix === undefined ? tag : `${spanPrefix}.${tag}`
+
+/**
+ * Default RPC span attributes, overridden by user `spanAttributes`.
+ *
+ * @internal
+ */
+export const spanAttributes = (
+  tag: string,
+  attributes: Record<string, unknown> | undefined
+): Record<string, unknown> => ({
+  "rpc.system.name": "effect_rpc",
+  "rpc.method": tag,
+  ...attributes
+})

package/src/schema/SchemaCompiler/runtime.ts

@@ -65,12 +65,15 @@ const makeObjectBase = (
   const runFallback: SchemaIssueParser = (input, options) =>
     (fallback ??= ast.getParser(compile, compileField))(input, options)
   const resume = (
-    state: ObjectParserState,
+    snapshot: ObjectParserState,
     index: number,
     pending: Effect.Effect<unknown, SchemaIssue.Issue, any>
   ): Effect.Effect<unknown, SchemaIssue.Issue, any> => {
     const property = properties![index]
     return Effect.flatMap(Effect.exit(pending), (exit) => {
+      // Each execution gets its own output; `issues` is still undefined here
+      // because `errors: "all"` is routed to the fallback before suspending.
+      const state: ObjectParserState = { ...snapshot, out: { ...snapshot.out } }
       const terminal = SchemaAST.stepProperty(state, property, exit)
       if (terminal) return terminal
       const done = () => InternalParser.succeed(state.out)

package/src/sql/SqlClient.ts

@@ -394,7 +394,7 @@ export const makeWithTransaction = <I, S>(options: {
     Effect.uninterruptibleMask((restore) =>
       Effect.useSpan(
         "sql.transaction",
-        { kind: "client" },
+        { kind: "internal" },
         (span) =>
           Effect.withFiber<A, E | SqlError, R>((fiber) => {
             for (const [key, value] of options.spanAttributes) {
@@ -427,18 +427,18 @@ export const makeWithTransaction = <I, S>(options: {
                         let effect: Effect.Effect<void>
                         if (Exit.isSuccess(exit)) {
                           if (id === 0) {
-                            span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.commit", clock.currentTimeNanosUnsafe())
                             const onCommitFailure = options.onCommitFailure
                             effect = Effect.orDie(options.commit(conn))
                             if (onCommitFailure) {
                               effect = Effect.onError(effect, () => Effect.orDie(onCommitFailure(conn)))
                             }
                           } else {
-                            span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.savepoint", clock.currentTimeNanosUnsafe())
                             effect = Effect.void
                           }
                         } else {
-                          span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
+                          span.event("effect.sql.transaction.rollback", clock.currentTimeNanosUnsafe())
                           effect = Effect.orDie(
                             id > 0
                               ? options.rollbackSavepoint(conn, id)

package/src/sql/Statement.ts

@@ -114,7 +114,7 @@ export const CurrentTransformer = Context.Reference<Transformer | undefined>("ef
 })
 
 /**
- * Parents driver spans under `sql.execute` for every client in the current scope,
+ * Parents driver spans under the statement span for every client in the current scope,
  * including acquisition and stream pulls. Defaults to `false`; ignored when tracing is disabled.
  *
  * @stability unstable
@@ -1285,10 +1285,62 @@ export const defaultTransforms = (
   } as const
 }
 
+/**
+ * Returns the OpenTelemetry database span target for a client with the given
+ * span attributes: `db.namespace`, then `server.address[:server.port]`, or
+ * `undefined` when neither is set.
+ *
+ * @stability unstable
+ * @category tracing
+ * @since 4.0.1
+ */
+export const spanTarget = (spanAttributes: ReadonlyArray<readonly [string, unknown]>): string | undefined => {
+  const namespace = spanAttribute(spanAttributes, "db.namespace")
+  if (isNonEmptyString(namespace)) {
+    return namespace
+  }
+  const address = spanAttribute(spanAttributes, "server.address")
+  if (isNonEmptyString(address)) {
+    const port = spanAttribute(spanAttributes, "server.port")
+    return port === undefined ? address : `${address}:${port}`
+  }
+  return undefined
+}
+
+/**
+ * Returns the span name for statements run by a client with the given span
+ * attributes, following the OpenTelemetry database span conventions: the
+ * {@link spanTarget}, then `db.system.name`, falling back to `sql.execute`.
+ *
+ * @stability unstable
+ * @category tracing
+ * @since 4.0.1
+ */
+export const spanName = (spanAttributes: ReadonlyArray<readonly [string, unknown]>): string => {
+  const target = spanTarget(spanAttributes)
+  if (target !== undefined) {
+    return target
+  }
+  const system = spanAttribute(spanAttributes, "db.system.name")
+  return isNonEmptyString(system) ? system : "sql.execute"
+}
+
 // internal
 
-const ATTR_DB_OPERATION_NAME = "db.operation.name"
 const ATTR_DB_QUERY_TEXT = "db.query.text"
+const ATTR_SQL_METHOD = "effect.sql.method"
+
+// the last value wins, matching the order the attributes are applied to spans
+const spanAttribute = (spanAttributes: ReadonlyArray<readonly [string, unknown]>, key: string): unknown => {
+  for (let i = spanAttributes.length - 1; i >= 0; i--) {
+    if (spanAttributes[i][0] === key) {
+      return spanAttributes[i][1]
+    }
+  }
+  return undefined
+}
+
+const isNonEmptyString = (u: unknown): u is string => typeof u === "string" && u.length > 0
 
 interface StatementImpl<A> extends Statement<A> {
   readonly segments: ReadonlyArray<Segment>
@@ -1354,7 +1406,7 @@ const StatementProto: Omit<
     withoutTransform = false
   ): Effect.Effect<XA, E | SqlError> {
     return Effect.useSpan(
-      "sql.execute",
+      spanName(this.spanAttributes),
       { kind: "client" },
       (span) =>
         this.withConnectionSpan(
@@ -1381,7 +1433,7 @@ const StatementProto: Omit<
       for (const [key, value] of this.spanAttributes) {
         span.attribute(key, value)
       }
-      span.attribute(ATTR_DB_OPERATION_NAME, operation)
+      span.attribute(ATTR_SQL_METHOD, operation)
       span.attribute(ATTR_DB_QUERY_TEXT, sql)
       const execute = this.borrower === undefined
         ? Effect.scoped(Effect.flatMap(this.acquirer, (_) => f(_, sql, params)))
@@ -1411,14 +1463,14 @@ const StatementProto: Omit<
   get stream(): Stream.Stream<any, SqlError> {
     const self = this as StatementImpl<any>
     return Stream.unwrap(Effect.flatMap(
-      Effect.makeSpanScoped("sql.execute", { kind: "client" }),
+      Effect.makeSpanScoped(spanName(self.spanAttributes), { kind: "client" }),
       (span) =>
         withStatement(self, span, (statement, fiber) => {
           const [sql, params] = statement.compile()
           for (const [key, value] of self.spanAttributes) {
             span.attribute(key, value)
           }
-          span.attribute(ATTR_DB_OPERATION_NAME, "executeStream")
+          span.attribute(ATTR_SQL_METHOD, "executeStream")
           span.attribute(ATTR_DB_QUERY_TEXT, sql)
           const acquire = Effect.map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows))
           return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
@@ -1456,7 +1508,7 @@ const StatementProto: Omit<
   ...Effectable.Prototype<StatementImpl<any>>({
     label: "Statement",
     evaluate(fiber) {
-      const span = internalEffect.makeSpanUnsafe(fiber, "sql.execute", { kind: "client" })
+      const span = internalEffect.makeSpanUnsafe(fiber, spanName(this.spanAttributes), { kind: "client" })
       const clock = fiber.getRef(Clock)
       const timingEnabled = fiber.getRef(TracerTimingEnabled)
       return Effect.onExit(

package/src/testing/TestClock.ts

@@ -8,6 +8,7 @@
  * live clock, and warning when a test appears to be waiting on time without
  * advancing it.
  *
+ * @stability stable
  * @since 2.0.0
  */
 import * as Arr from "../Array.ts"
@@ -88,6 +89,7 @@ import * as Semaphore from "../Semaphore.ts"
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category models
  * @since 2.0.0
  */
@@ -133,6 +135,7 @@ export interface TestClock extends Clock.Clock {
  * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
+ * @stability stable
  * @since 2.0.0
  */
 export declare namespace TestClock {
@@ -238,6 +241,7 @@ const millisToNanos = (millis: number): bigint => {
  * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
+ * @stability stable
  * @category constructors
  * @since 4.0.0
  */
@@ -430,6 +434,7 @@ export const make = Effect.fnUntraced(function*(
  * await Effect.runPromise(Effect.provide(program, customTestClockLayer)) // => 3_600_000
  * ```
  *
+ * @stability stable
  * @category layers
  * @since 4.0.0
  */
@@ -463,6 +468,7 @@ export const layer: (options?: TestClock.Options) => Layer.Layer<TestClock> = fl
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -501,6 +507,7 @@ export const testClockWith = <A, E, R>(
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -538,6 +545,7 @@ export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 2.0.0
  */
@@ -574,6 +582,7 @@ export const setTime = (timestamp: number): Effect.Effect<void> =>
  * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
+ * @stability stable
  * @category testing
  * @since 4.0.0
  */

package/src/testing/TestConsole.ts

@@ -7,6 +7,7 @@
  * console layer, helpers for reading captured `Console.log` and `Console.error`
  * arguments, and access to the provided test console service.
  *
+ * @stability unstable
  * @since 4.0.0
  */
 import * as Array from "../Array.ts"
@@ -53,6 +54,7 @@ import * as Layer from "../Layer.ts"
  * @see {@link logLines} for reading captured `Console.log` calls
  * @see {@link errorLines} for reading captured `Console.error` calls
  *
+ * @stability unstable
  * @category models
  * @since 4.0.0
  */
@@ -87,6 +89,7 @@ export interface TestConsole extends Console.Console {
  *
  * Use when referring to types nested under the `TestConsole` namespace.
  *
+ * @stability unstable
  * @since 4.0.0
  */
 export declare namespace TestConsole {
@@ -173,6 +176,7 @@ export declare namespace TestConsole {
  *
  * @see {@link layer} for providing a `TestConsole` as a `Layer`
  *
+ * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
@@ -250,6 +254,7 @@ export const make = Effect.gen(function*() {
  * @see {@link logLines} for reading captured `Console.log` calls directly
  * @see {@link errorLines} for reading captured `Console.error` calls directly
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
@@ -288,6 +293,7 @@ export const testConsoleWith = <A, E, R>(f: (console: TestConsole) => Effect.Eff
  * @see {@link make} for constructing the service value directly
  * @see {@link testConsoleWith} for accessing the provided test console service
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */
@@ -324,6 +330,7 @@ export const layer: Layer.Layer<TestConsole> = Layer.effect(Console.Console)(mak
  * @see {@link errorLines} for reading captured `Console.error` output
  * @see {@link layer} for capturing console calls during a test
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
@@ -362,6 +369,7 @@ export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = tes
  * @see {@link logLines} for reading captured `Console.log` output
  * @see {@link layer} for capturing console calls during a test
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */

package/src/testing/index.ts

@@ -1,15 +1,18 @@
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
 /**
+ * @stability stable
  * @since 2.0.0
  */
 export * as TestClock from "./TestClock.ts"
 
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as TestConsole from "./TestConsole.ts"