@effect-uai/core 0.14.0 → 0.16.0

package/src/messenger/MessengerError.ts

@@ -0,0 +1,67 @@
+import { Data, type Duration, Match } from "effect"
+
+// `reason` is required wherever one exists: the platform always says
+// something, and an adapter raising `Unsupported` knows why it did.
+
+/** Transport never came up: bad token, rejected handshake. Raised at layer build. */
+export class MessengerConnectFailed extends Data.TaggedError("MessengerConnectFailed")<{
+  provider: string
+  reason: string
+  raw: unknown
+}> {}
+
+/**
+ * Inbound transport ended for good (reconnect budget spent, fatal close).
+ * Routine reconnects stay inside the adapter and never surface here.
+ */
+export class MessengerTransportClosed extends Data.TaggedError("MessengerTransportClosed")<{
+  provider: string
+  reason: string
+  raw?: unknown
+}> {}
+
+/** Which verb was rejected. */
+export type MessengerOperation = "post" | "edit" | "react" | "typing"
+
+/** An outbound verb was rejected: permission, unknown chat, text too long, no-op edit. */
+export class MessengerRequestFailed extends Data.TaggedError("MessengerRequestFailed")<{
+  provider: string
+  operation: MessengerOperation
+  reason: string
+  raw: unknown
+}> {}
+
+/**
+ * Slow down, for this long. Typed rather than retried blindly so callers -
+ * `streamViaEdits` above all - decide whether waiting is still worth it.
+ */
+export class MessengerRateLimited extends Data.TaggedError("MessengerRateLimited")<{
+  provider: string
+  retryAfter: Duration.Duration
+  raw?: unknown
+}> {}
+
+/** The platform cannot express this at all: off-set reaction emoji, edits on WhatsApp. */
+export class MessengerUnsupported extends Data.TaggedError("MessengerUnsupported")<{
+  provider: string
+  capability: string
+  reason: string
+}> {}
+
+export type MessengerError =
+  | MessengerConnectFailed
+  | MessengerTransportClosed
+  | MessengerRequestFailed
+  | MessengerRateLimited
+  | MessengerUnsupported
+
+/** Human-readable description for logs. Prose, not a contract; branch on `_tag`. */
+export const describe: (e: MessengerError) => string = Match.type<MessengerError>().pipe(
+  Match.discriminatorsExhaustive("_tag")({
+    MessengerConnectFailed: (e) => `the messenger could not connect: ${e.reason}`,
+    MessengerTransportClosed: (e) => `the messenger connection closed: ${e.reason}`,
+    MessengerRequestFailed: (e) => `the ${e.operation} was rejected: ${e.reason}`,
+    MessengerRateLimited: () => "the messenger is rate limited",
+    MessengerUnsupported: (e) => `this messenger does not support ${e.capability}: ${e.reason}`,
+  }),
+)

package/src/realtime/RealtimeSession.test.ts

@@ -0,0 +1,100 @@
+import { describe, it } from "@effect/vitest"
+import { Effect, Stream } from "effect"
+import { expect, expectTypeOf } from "vitest"
+import type * as AiError from "../domain/AiError.js"
+import { imageBase64 } from "../domain/Image.js"
+import { type CommonSessionRequest, RealtimeEvent, RealtimeInput } from "../domain/Realtime.js"
+import * as MockRealtimeSession from "../testing/MockRealtimeSession.js"
+import { RealtimeVideoInput, open, sendVideoFrame, toolCalls } from "./RealtimeSession.js"
+
+const pcm = { container: "raw", encoding: "pcm_s16le", sampleRate: 24000, channels: 1 } as const
+
+const request: CommonSessionRequest = {
+  model: "gpt-realtime-2.1",
+  inputFormat: pcm,
+  outputFormat: pcm,
+}
+
+const call = {
+  type: "function_call",
+  call_id: "call_1",
+  name: "get_time",
+  arguments: "{}",
+} as const
+
+describe("RealtimeSession against a scripted session", () => {
+  it.effect("answers each input and ends `events` when the scope closes", () =>
+    Effect.gen(function* () {
+      const mock = MockRealtimeSession.layer({
+        initial: [RealtimeEvent.ResponseStarted({ responseId: "r1" })],
+        onInput: (input) =>
+          RealtimeInput.$is("Audio")(input)
+            ? [RealtimeEvent.AudioDelta({ responseId: "r1", bytes: new Uint8Array([7]) })]
+            : [RealtimeEvent.ResponseDone({ responseId: "r1", reason: "interrupted" })],
+      })
+
+      const handle = yield* Effect.scoped(
+        Effect.gen(function* () {
+          const handle = yield* open(request)
+          yield* handle.send(RealtimeInput.Audio({ bytes: new Uint8Array([1, 2]) }))
+          yield* handle.send(RealtimeInput.Interrupt())
+          return handle
+        }),
+      ).pipe(Effect.provide(mock.layer))
+
+      // The scope is closed, so the stream drains what is queued and ends
+      // rather than hanging.
+      const events = yield* Stream.runCollect(handle.events)
+      expect(events).toEqual([
+        RealtimeEvent.ResponseStarted({ responseId: "r1" }),
+        RealtimeEvent.AudioDelta({ responseId: "r1", bytes: new Uint8Array([7]) }),
+        RealtimeEvent.ResponseDone({ responseId: "r1", reason: "interrupted" }),
+      ])
+
+      const recorder = yield* mock.recorder
+      expect(recorder.openCalls.map((r) => r.model)).toEqual(["gpt-realtime-2.1"])
+      expect(recorder.sent.map((i) => i._tag)).toEqual(["Audio", "Interrupt"])
+    }),
+  )
+
+  it.effect("narrows `toolCalls` to the calls the model made", () =>
+    Effect.gen(function* () {
+      const mock = MockRealtimeSession.layer({
+        initial: [
+          RealtimeEvent.ResponseStarted({ responseId: "r1" }),
+          RealtimeEvent.ToolCall({ responseId: "r1", call }),
+          RealtimeEvent.OutputTranscriptDelta({ responseId: "r1", text: "one moment" }),
+        ],
+      })
+
+      const handle = yield* Effect.scoped(open(request)).pipe(Effect.provide(mock.layer))
+      const calls = yield* Stream.runCollect(toolCalls(handle.events))
+
+      expect(calls.map((e) => e.call.call_id)).toEqual(["call_1"])
+    }),
+  )
+})
+
+describe("RealtimeVideoInput marker", () => {
+  const frame = imageBase64("aW1n", "image/jpeg")
+
+  it("leaves the marker unsatisfied against an audio-only Layer", () => {
+    const mock = MockRealtimeSession.layerAudioOnly({})
+    const program = Effect.scoped(
+      Effect.flatMap(open(request), (handle) => sendVideoFrame(handle, frame)),
+    ).pipe(Effect.provide(mock.layer))
+
+    // `RealtimeSession` is provided, `RealtimeVideoInput` is not, so running
+    // this would be a type error.
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, RealtimeVideoInput>>()
+  })
+
+  it("clears R to never against a Layer that ships the marker", () => {
+    const mock = MockRealtimeSession.layer({})
+    const program = Effect.scoped(
+      Effect.flatMap(open(request), (handle) => sendVideoFrame(handle, frame)),
+    ).pipe(Effect.provide(mock.layer))
+
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()
+  })
+})

package/src/realtime/RealtimeSession.ts

@@ -0,0 +1,77 @@
+/**
+ * A duplex speech-to-speech session. The server drives turn-taking, so this is
+ * its own primitive rather than a variant of `Loop`.
+ *
+ * The session is deliberately low level: tool execution, playback, barge-in
+ * bookkeeping and reconnection are the caller's, built from `send` and
+ * `events`. There is no agent wrapper, no hidden queue and no automatic
+ * reconnect here.
+ */
+import { Context, Effect, type Scope, Stream } from "effect"
+import type * as AiError from "../domain/AiError.js"
+import type { ImageSource } from "../domain/Image.js"
+import { type CommonSessionRequest, RealtimeInput, RealtimeEvent } from "../domain/Realtime.js"
+
+/**
+ * The live connection. `events` ends when the socket closes cleanly; a close
+ * during a response ends it with `AiError.IncompleteTurn` instead, and never
+ * synthesizes a `ResponseDone`. `send` after close fails `Unavailable`.
+ */
+export type RealtimeSessionHandle = {
+  readonly send: (input: RealtimeInput) => Effect.Effect<void, AiError.AiError>
+  readonly events: Stream.Stream<RealtimeEvent, AiError.AiError>
+}
+
+export type RealtimeSessionService = {
+  /**
+   * Connect and complete the provider handshake before succeeding. Closing the
+   * `Scope` closes the socket.
+   */
+  readonly open: (
+    request: CommonSessionRequest,
+  ) => Effect.Effect<RealtimeSessionHandle, AiError.AiError, Scope.Scope>
+}
+
+export class RealtimeSession extends Context.Service<RealtimeSession, RealtimeSessionService>()(
+  "@betalyra/effect-uai/RealtimeSession",
+) {}
+
+/**
+ * Capability marker for sessions that accept video frames. Phantom: providers
+ * register with `Layer.succeed(RealtimeVideoInput, undefined)`. Only Gemini
+ * ships it, so `sendVideoFrame` against an OpenAI-only Layer is a type error.
+ */
+export class RealtimeVideoInput extends Context.Service<RealtimeVideoInput, void>()(
+  "@betalyra/effect-uai/capability/RealtimeVideoInput",
+) {}
+
+/** Open a session for the lifetime of the surrounding `Scope`. */
+export const open = (
+  request: CommonSessionRequest,
+): Effect.Effect<RealtimeSessionHandle, AiError.AiError, RealtimeSession | Scope.Scope> =>
+  Effect.flatMap(RealtimeSession, (s) => s.open(request))
+
+/**
+ * Push one video frame. Requires `RealtimeVideoInput`, so a provider without
+ * video fails at `Effect.provide` rather than at runtime.
+ */
+export const sendVideoFrame = (
+  handle: RealtimeSessionHandle,
+  frame: ImageSource,
+): Effect.Effect<void, AiError.AiError, RealtimeVideoInput> =>
+  Effect.flatMap(RealtimeVideoInput, () => handle.send(RealtimeInput.VideoFrame({ frame })))
+
+const isAudioDelta = RealtimeEvent.$is("AudioDelta")
+const isToolCall = RealtimeEvent.$is("ToolCall")
+
+/** Just the audio, for wiring straight to playback. */
+export const audioDeltas = <E, R>(
+  events: Stream.Stream<RealtimeEvent, E, R>,
+): Stream.Stream<Extract<RealtimeEvent, { readonly _tag: "AudioDelta" }>, E, R> =>
+  Stream.filter(events, isAudioDelta)
+
+/** Just the tool calls. Answer each with a `ToolResult`; the adapter resumes. */
+export const toolCalls = <E, R>(
+  events: Stream.Stream<RealtimeEvent, E, R>,
+): Stream.Stream<Extract<RealtimeEvent, { readonly _tag: "ToolCall" }>, E, R> =>
+  Stream.filter(events, isToolCall)

package/src/streaming/Settle.test.ts

@@ -0,0 +1,344 @@
+import { describe, it } from "@effect/vitest"
+import { Cause, Effect, Fiber, Option, Queue, Ref, Stream } from "effect"
+import { TestClock } from "effect/testing"
+import { expect } from "vitest"
+import { drainBurst, onQuiet, settleBurst } from "./Settle.js"
+
+describe("drainBurst", () => {
+  it.effect("resets the window on every arrival, so a burst outlives one settle", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("900 millis")
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("900 millis")
+      // 1.8s elapsed, more than one settle, and the burst is still open.
+      expect(burst.pollUnsafe()).toBeUndefined()
+
+      yield* TestClock.adjust("1 second")
+      expect(yield* Fiber.join(burst)).toEqual(["a", "b"])
+    }),
+  )
+
+  it.effect("waits for the first item without a deadline", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* TestClock.adjust("1 hour")
+      expect(burst.pollUnsafe()).toBeUndefined()
+
+      yield* Queue.offer(queue, "late")
+      yield* TestClock.adjust("1 second")
+      expect(yield* Fiber.join(burst)).toEqual(["late"])
+    }),
+  )
+
+  it.effect("ends on the first quiet gap and leaves later items for the next drain", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* Queue.offer(queue, "first")
+      yield* TestClock.adjust("1 second")
+      expect(yield* Fiber.join(burst)).toEqual(["first"])
+
+      yield* Queue.offer(queue, "second")
+      expect(yield* Queue.poll(queue)).toEqual(Option.some("second"))
+    }),
+  )
+
+  it.effect("yields the batch in hand when the queue ends mid-burst", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.end(queue)
+      yield* TestClock.adjust("10 millis")
+
+      expect(yield* Fiber.join(burst)).toEqual(["a"])
+    }),
+  )
+
+  it.effect("propagates a queue failure rather than treating it as the end", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, string | Cause.Done>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.fail(queue, "boom")
+      yield* TestClock.adjust("10 millis")
+
+      const exit = yield* Effect.exit(Fiber.join(burst))
+      expect(exit._tag).toBe("Failure")
+      expect(JSON.stringify(exit)).toContain("boom")
+    }),
+  )
+
+  it.effect("does not mistake an interrupt mid-burst for the end of the queue", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("100 millis")
+      yield* Fiber.interrupt(burst)
+
+      // Returning ["a"] here would mean interruption silently looked like a
+      // settled burst.
+      const exit = yield* Effect.exit(Fiber.join(burst))
+      expect(exit._tag).toBe("Failure")
+    }),
+  )
+})
+
+describe("settleBurst", () => {
+  const collecting = <A>(stream: Stream.Stream<A, never>) =>
+    Effect.gen(function* () {
+      const seen = yield* Ref.make<ReadonlyArray<A>>([])
+      const fiber = yield* Effect.forkChild(
+        Stream.runForEach(stream, (a) => Ref.update(seen, (xs) => [...xs, a])),
+      )
+      return { seen, fiber }
+    })
+
+  it.effect("holds a growing burst back, then emits it as one batch", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const { seen } = yield* collecting(Stream.fromQueue(queue).pipe(settleBurst("1 second")))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("900 millis")
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("900 millis")
+      // Each arrival reset the window, so nothing has been emitted yet.
+      expect(yield* Ref.get(seen)).toEqual([])
+
+      yield* TestClock.adjust("1 second")
+      expect(yield* Ref.get(seen)).toEqual([["a", "b"]])
+    }),
+  )
+
+  it.effect("emits the in-flight batch when the source ends mid-burst", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const { seen } = yield* collecting(Stream.fromQueue(queue).pipe(settleBurst("1 second")))
+
+      yield* Queue.offer(queue, "only")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.end(queue)
+      yield* TestClock.adjust("10 millis")
+
+      expect(yield* Ref.get(seen)).toEqual([["only"]])
+    }),
+  )
+
+  it.effect("splits bursts on every silence, keeping order across a conversation", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const { seen } = yield* collecting(Stream.fromQueue(queue).pipe(settleBurst("1 second")))
+
+      // Three quick lines, a pause, two more, a pause, then one alone.
+      yield* Queue.offer(queue, "hey")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.offer(queue, "are you there")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.offer(queue, "?")
+      yield* TestClock.adjust("2 seconds")
+
+      yield* Queue.offer(queue, "actually")
+      yield* TestClock.adjust("100 millis")
+      yield* Queue.offer(queue, "never mind")
+      yield* TestClock.adjust("2 seconds")
+
+      yield* Queue.offer(queue, "bye")
+      yield* TestClock.adjust("2 seconds")
+
+      expect(yield* Ref.get(seen)).toEqual([
+        ["hey", "are you there", "?"],
+        ["actually", "never mind"],
+        ["bye"],
+      ])
+    }),
+  )
+
+  it.effect("fails the stream when the source fails instead of ending quietly", () =>
+    Effect.gen(function* () {
+      const source: Stream.Stream<string, string> = Stream.make("a").pipe(
+        Stream.concat(Stream.fail("boom")),
+      )
+      const exit = yield* Effect.exit(Stream.runCollect(source.pipe(settleBurst("1 second"))))
+
+      expect(exit._tag).toBe("Failure")
+      expect(JSON.stringify(exit)).toContain("boom")
+    }),
+  )
+
+  it.effect("stops pulling the source while the consumer is blocked", () =>
+    Effect.gen(function* () {
+      const pulled = yield* Ref.make(0)
+      const source = Stream.fromIterable(Array.from({ length: 50 }, (_, i) => i)).pipe(
+        Stream.rechunk(1),
+        Stream.tap(() => Ref.update(pulled, (n) => n + 1)),
+      )
+      yield* Effect.forkChild(
+        source.pipe(
+          settleBurst("1 second", { capacity: 2 }),
+          Stream.runForEach(() => Effect.never),
+        ),
+      )
+      yield* TestClock.adjust("10 seconds")
+
+      // An unbounded buffer would have drained all 50 into memory by now.
+      expect(yield* Ref.get(pulled)).toBeLessThan(50)
+    }),
+  )
+})
+
+describe("onQuiet", () => {
+  const mark = Effect.succeed(Option.some("<quiet>"))
+
+  const collecting = (stream: Stream.Stream<string, never>) =>
+    Effect.gen(function* () {
+      const seen = yield* Ref.make<ReadonlyArray<string>>([])
+      yield* Effect.forkChild(
+        Stream.runForEach(stream, (a) => Ref.update(seen, (xs) => [...xs, a])),
+      )
+      return seen
+    })
+
+  it.effect("passes elements downstream without waiting for the quiet period", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const seen = yield* collecting(Stream.fromQueue(queue).pipe(onQuiet("1 second", mark)))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("10 millis")
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("10 millis")
+
+      // Both are downstream well inside the settle window, and no mark yet.
+      expect(yield* Ref.get(seen)).toEqual(["a", "b"])
+    }),
+  )
+
+  it.effect("emits once the source goes quiet, and not again until it speaks", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const seen = yield* collecting(Stream.fromQueue(queue).pipe(onQuiet("1 second", mark)))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("2 seconds")
+      expect(yield* Ref.get(seen)).toEqual(["a", "<quiet>"])
+
+      // Still silent: the mark does not repeat while nothing arrives.
+      yield* TestClock.adjust("10 seconds")
+      expect(yield* Ref.get(seen)).toEqual(["a", "<quiet>"])
+
+      // A new element re-arms it.
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("2 seconds")
+      expect(yield* Ref.get(seen)).toEqual(["a", "<quiet>", "b", "<quiet>"])
+    }),
+  )
+
+  it.effect("marks an element that arrives in the same instant as the mark", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const seen = yield* collecting(Stream.fromQueue(queue).pipe(onQuiet("1 second", mark)))
+
+      yield* Queue.offer(queue, "a")
+      // The window expires exactly here, so "b" races the re-arm.
+      yield* TestClock.adjust("1 second")
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("2 seconds")
+
+      // Losing that race would leave "b" unmarked until something else spoke.
+      expect(yield* Ref.get(seen)).toEqual(["a", "<quiet>", "b", "<quiet>"])
+    }),
+  )
+
+  it.effect("keeps the window open while elements keep arriving", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const seen = yield* collecting(Stream.fromQueue(queue).pipe(onQuiet("1 second", mark)))
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("900 millis")
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("900 millis")
+      // 1.8s elapsed, but never 1s of silence.
+      expect(yield* Ref.get(seen)).toEqual(["a", "b"])
+
+      yield* TestClock.adjust("2 seconds")
+      expect(yield* Ref.get(seen)).toEqual(["a", "b", "<quiet>"])
+    }),
+  )
+
+  it.effect("marks each utterance in a run of speech, pauses and more speech", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const seen = yield* collecting(Stream.fromQueue(queue).pipe(onQuiet("1 second", mark)))
+
+      // Deltas of one sentence, arriving faster than the window.
+      for (const token of ["what", " about", " Paris"]) {
+        yield* Queue.offer(queue, token)
+        yield* TestClock.adjust("200 millis")
+      }
+      expect(yield* Ref.get(seen)).toEqual(["what", " about", " Paris"])
+
+      // The speaker stops: one mark, and it does not repeat.
+      yield* TestClock.adjust("3 seconds")
+      // A second sentence re-arms and marks again.
+      for (const token of ["in", " winter"]) {
+        yield* Queue.offer(queue, token)
+        yield* TestClock.adjust("200 millis")
+      }
+      yield* TestClock.adjust("3 seconds")
+
+      expect(yield* Ref.get(seen)).toEqual([
+        "what",
+        " about",
+        " Paris",
+        "<quiet>",
+        "in",
+        " winter",
+        "<quiet>",
+      ])
+    }),
+  )
+
+  it.effect("emits nothing when there is nothing to emit, and waits for the next element", () =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<string, Cause.Done>()
+      const emitted = yield* Ref.make(0)
+      // Stands in for an accumulator that is already empty.
+      const emitIfSecond = Effect.map(
+        Ref.updateAndGet(emitted, (n) => n + 1),
+        (n) => (n === 1 ? Option.none<string>() : Option.some("<quiet>")),
+      )
+      const seen = yield* collecting(
+        Stream.fromQueue(queue).pipe(onQuiet("1 second", emitIfSecond)),
+      )
+
+      yield* Queue.offer(queue, "a")
+      yield* TestClock.adjust("3 seconds")
+      // First quiet period asked, got None, and stayed silent.
+      expect(yield* Ref.get(seen)).toEqual(["a"])
+      expect(yield* Ref.get(emitted)).toBe(1)
+
+      // It is disarmed, so silence alone does not ask again.
+      yield* TestClock.adjust("10 seconds")
+      expect(yield* Ref.get(emitted)).toBe(1)
+
+      yield* Queue.offer(queue, "b")
+      yield* TestClock.adjust("3 seconds")
+      expect(yield* Ref.get(seen)).toEqual(["a", "b", "<quiet>"])
+    }),
+  )
+})