@effect-uai/core 0.14.0 → 0.16.0

package/dist/streaming/WebSocketSession.test.mjs

@@ -0,0 +1,51 @@
+import { describe } from "../domain/AiError.mjs";
+import { toAiError } from "./WebSocketSession.mjs";
+import { o as describe$1 } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
+import { t as it } from "../dist-nohcnkD6.mjs";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/streaming/WebSocketSession.test.ts
+const KEY = "AIzaSyEXAMPLEKEY";
+const URL = `wss://generativelanguage.googleapis.com/ws/BidiGenerateContent?key=${KEY}`;
+/**
+* What Bun hands the `error` listener when the upgrade is rejected: the whole
+* socket URL, in prose, on a prototype getter. Node and Deno say less, but the
+* adapter cannot know which runtime it is on.
+*/
+var BunErrorEvent = class {
+	get message() {
+		return `WebSocket connection to '${URL}' failed: Connection ended`;
+	}
+};
+/** Deno names the status but not the URL, also on a prototype getter. */
+var DenoErrorEvent = class {
+	detail;
+	constructor(detail) {
+		this.detail = detail;
+	}
+	get message() {
+		return `NetworkError: failed to connect to WebSocket: ${this.detail}`;
+	}
+};
+const openFailure = (cause) => new Socket.SocketError({ reason: new Socket.SocketOpenError({
+	kind: "Unknown",
+	cause
+}) });
+describe$1("WebSocketSession errors", () => {
+	it("keeps the key out of the error a rejected upgrade produces", () => {
+		const error = toAiError("google")(openFailure(new BunErrorEvent()));
+		globalExpect(JSON.stringify(error)).not.toContain(KEY);
+		globalExpect(describe(error)).not.toContain(KEY);
+		globalExpect(JSON.stringify(error)).toContain("generativelanguage.googleapis.com");
+	});
+	it("reads the rejected status out of the prose, wherever the runtime put it", () => {
+		const forbidden = toAiError("google")(openFailure(new DenoErrorEvent("Invalid status code: 403")));
+		const ended = toAiError("google")(openFailure(new BunErrorEvent()));
+		globalExpect(forbidden._tag).toBe("AuthFailed");
+		globalExpect(ended._tag).toBe("Unavailable");
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=WebSocketSession.test.mjs.map

package/dist/streaming/WebSocketSession.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketSession.test.mjs","names":["describe","AiError.describe"],"sources":["../../src/streaming/WebSocketSession.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport { expect } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport { toAiError } from \"./WebSocketSession.js\"\n\nconst KEY = \"AIzaSyEXAMPLEKEY\"\nconst URL = `wss://generativelanguage.googleapis.com/ws/BidiGenerateContent?key=${KEY}`\n\n/**\n * What Bun hands the `error` listener when the upgrade is rejected: the whole\n * socket URL, in prose, on a prototype getter. Node and Deno say less, but the\n * adapter cannot know which runtime it is on.\n */\nclass BunErrorEvent {\n  get message(): string {\n    return `WebSocket connection to '${URL}' failed: Connection ended`\n  }\n}\n\n/** Deno names the status but not the URL, also on a prototype getter. */\nclass DenoErrorEvent {\n  constructor(private readonly detail: string) {}\n  get message(): string {\n    return `NetworkError: failed to connect to WebSocket: ${this.detail}`\n  }\n}\n\nconst openFailure = (cause: unknown) =>\n  new Socket.SocketError({ reason: new Socket.SocketOpenError({ kind: \"Unknown\", cause }) })\n\ndescribe(\"WebSocketSession errors\", () => {\n  it(\"keeps the key out of the error a rejected upgrade produces\", () => {\n    const error = toAiError(\"google\")(openFailure(new BunErrorEvent()))\n\n    expect(JSON.stringify(error)).not.toContain(KEY)\n    expect(AiError.describe(error)).not.toContain(KEY)\n    // The host is still there: an error that says nothing is its own problem.\n    expect(JSON.stringify(error)).toContain(\"generativelanguage.googleapis.com\")\n  })\n\n  it(\"reads the rejected status out of the prose, wherever the runtime put it\", () => {\n    // Deno's wording. The status is the only hint a rejected upgrade gives.\n    const forbidden = toAiError(\"google\")(\n      openFailure(new DenoErrorEvent(\"Invalid status code: 403\")),\n    )\n    const ended = toAiError(\"google\")(openFailure(new BunErrorEvent()))\n\n    expect(forbidden._tag).toBe(\"AuthFailed\")\n    expect(ended._tag).toBe(\"Unavailable\")\n  })\n})\n"],"mappings":";;;;;;;AAMA,MAAM,MAAM;AACZ,MAAM,MAAM,sEAAsE;;;;;;AAOlF,IAAM,gBAAN,MAAoB;CAClB,IAAI,UAAkB;EACpB,OAAO,4BAA4B,IAAI;CACzC;AACF;;AAGA,IAAM,iBAAN,MAAqB;CACU;CAA7B,YAAY,QAAiC;EAAhB,KAAA,SAAA;CAAiB;CAC9C,IAAI,UAAkB;EACpB,OAAO,iDAAiD,KAAK;CAC/D;AACF;AAEA,MAAM,eAAe,UACnB,IAAI,OAAO,YAAY,EAAE,QAAQ,IAAI,OAAO,gBAAgB;CAAE,MAAM;CAAW;AAAM,CAAC,EAAE,CAAC;AAE3FA,WAAS,iCAAiC;CACxC,GAAG,oEAAoE;EACrE,MAAM,QAAQ,UAAU,QAAQ,CAAC,CAAC,YAAY,IAAI,cAAc,CAAC,CAAC;EAElE,aAAO,KAAK,UAAU,KAAK,CAAC,CAAC,CAAC,IAAI,UAAU,GAAG;EAC/C,aAAOC,SAAiB,KAAK,CAAC,CAAC,CAAC,IAAI,UAAU,GAAG;EAEjD,aAAO,KAAK,UAAU,KAAK,CAAC,CAAC,CAAC,UAAU,mCAAmC;CAC7E,CAAC;CAED,GAAG,iFAAiF;EAElF,MAAM,YAAY,UAAU,QAAQ,CAAC,CACnC,YAAY,IAAI,eAAe,0BAA0B,CAAC,CAC5D;EACA,MAAM,QAAQ,UAAU,QAAQ,CAAC,CAAC,YAAY,IAAI,cAAc,CAAC,CAAC;EAElE,aAAO,UAAU,IAAI,CAAC,CAAC,KAAK,YAAY;EACxC,aAAO,MAAM,IAAI,CAAC,CAAC,KAAK,aAAa;CACvC,CAAC;AACH,CAAC"}

package/dist/testing/FakeWebSocket.d.mts

@@ -0,0 +1,25 @@
+import { Effect, Layer, Scope } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/testing/FakeWebSocket.d.ts
+type FakeWebSocketServer = {
+  /** Every frame the client has sent, JSON-parsed, oldest first. */
+  readonly sent: Effect.Effect<ReadonlyArray<unknown>>;
+  /** Deliver one frame to the client. */
+  readonly push: (frame: unknown) => Effect.Effect<void>;
+  /** Close the socket. 1000, 1001 and 1005 are the clean codes. */
+  readonly close: (code?: number) => Effect.Effect<void>;
+  /** Hand this to an adapter that takes a socket constructor directly. */
+  readonly connect: Socket.WebSocketConstructor["Service"];
+  /** Provide this in place of the real constructor. */
+  readonly layer: Layer.Layer<Socket.WebSocketConstructor>;
+};
+type FakeWebSocketOptions = {
+  /** Pushed once the client subscribes, for a protocol whose server speaks first. */
+  readonly greeting?: ReadonlyArray<unknown>;
+  /** How the server answers each client frame. */
+  readonly reply?: (frame: unknown) => Effect.Effect<ReadonlyArray<unknown>>;
+};
+declare const make: (options?: FakeWebSocketOptions) => Effect.Effect<FakeWebSocketServer, never, Scope.Scope>;
+//#endregion
+export { FakeWebSocketOptions, FakeWebSocketServer, make };
+//# sourceMappingURL=FakeWebSocket.d.mts.map

package/dist/testing/FakeWebSocket.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeWebSocket.d.mts","names":[],"sources":["../../src/testing/FakeWebSocket.ts"],"mappings":";;;KAeY;;WAED,MAAM,OAAO,OAAO;;WAEpB,OAAO,mBAAmB,OAAO;;WAEjC,QAAQ,kBAAkB,OAAO;;WAEjC,SAAS,OAAO;;WAEhB,OAAO,MAAM,MAAM,OAAO;;KAGzB;;WAED,WAAW;;WAEX,SAAS,mBAAmB,OAAO,OAAO;;cAWxC,OAAI,UACL,yBACT,OAAO,OAAO,4BAA4B,MAAM"}

package/dist/testing/FakeWebSocket.mjs

@@ -0,0 +1,79 @@
+import { Effect, Layer, Queue, Ref, Stream } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/testing/FakeWebSocket.ts
+/**
+* An in-memory WebSocket for testing socket adapters without a server.
+*
+* Provide `layer` in place of the real `Socket.WebSocketConstructor` and the
+* adapter runs end to end: its own connect, handshake, decode and teardown.
+* The test plays the other end with `reply`, `push`, `close` and `sent`.
+*
+* Client frames land on a queue, so the scripted server is a forked fiber and
+* `reply` is a real Effect. What stays imperative is the listener table the
+* shim registers, since `Socket.makeWebSocket` drives it with plain callbacks.
+* The shim is a plain object, so nothing here touches a platform global.
+*/
+const OPEN = 1;
+const CLOSED = 3;
+/** Run after the current call unwinds, so the client is never re-entered. */
+const soon = (run) => void Promise.resolve().then(run);
+const make = (options) => Effect.gen(function* () {
+	const inbound = yield* Queue.unbounded();
+	const sent = yield* Ref.make([]);
+	const wiring = {
+		listeners: {},
+		readyState: OPEN,
+		greeted: false
+	};
+	const emit = (type, event) => (wiring.listeners[type] ?? []).forEach((listener) => listener(event));
+	const deliverSync = (frames) => frames.forEach((f) => emit("message", { data: JSON.stringify(f) }));
+	const deliver = (frames) => Effect.sync(() => deliverSync(frames));
+	const shutdown = (code) => {
+		if (wiring.readyState === CLOSED) return;
+		wiring.readyState = CLOSED;
+		emit("close", {
+			code,
+			reason: ""
+		});
+	};
+	yield* Stream.fromQueue(inbound).pipe(Stream.runForEach((frame) => Effect.gen(function* () {
+		yield* Ref.update(sent, (frames) => [...frames, frame]);
+		const answer = yield* options?.reply?.(frame) ?? Effect.succeed([]);
+		yield* deliver(answer);
+	})), Effect.forkScoped);
+	const socket = {
+		get readyState() {
+			return wiring.readyState;
+		},
+		addEventListener: (type, fn) => {
+			wiring.listeners = {
+				...wiring.listeners,
+				[type]: [...wiring.listeners[type] ?? [], fn]
+			};
+			if (type === "message" && !wiring.greeted) {
+				wiring.greeted = true;
+				soon(() => deliverSync(options?.greeting ?? []));
+			}
+		},
+		removeEventListener: (type, fn) => {
+			wiring.listeners = {
+				...wiring.listeners,
+				[type]: (wiring.listeners[type] ?? []).filter((l) => l !== fn)
+			};
+		},
+		send: (data) => void Queue.offerUnsafe(inbound, JSON.parse(data)),
+		close: (code = 1e3) => shutdown(code)
+	};
+	const connect = () => socket;
+	return {
+		sent: Ref.get(sent),
+		push: (frame) => deliver([frame]),
+		close: (code = 1e3) => Effect.sync(() => shutdown(code)),
+		connect,
+		layer: Layer.succeed(Socket.WebSocketConstructor, connect)
+	};
+});
+//#endregion
+export { make };
+
+//# sourceMappingURL=FakeWebSocket.mjs.map

package/dist/testing/FakeWebSocket.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeWebSocket.mjs","names":[],"sources":["../../src/testing/FakeWebSocket.ts"],"sourcesContent":["/**\n * An in-memory WebSocket for testing socket adapters without a server.\n *\n * Provide `layer` in place of the real `Socket.WebSocketConstructor` and the\n * adapter runs end to end: its own connect, handshake, decode and teardown.\n * The test plays the other end with `reply`, `push`, `close` and `sent`.\n *\n * Client frames land on a queue, so the scripted server is a forked fiber and\n * `reply` is a real Effect. What stays imperative is the listener table the\n * shim registers, since `Socket.makeWebSocket` drives it with plain callbacks.\n * The shim is a plain object, so nothing here touches a platform global.\n */\nimport { Effect, Layer, Queue, Ref, type Scope, Stream } from \"effect\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\n\nexport type FakeWebSocketServer = {\n  /** Every frame the client has sent, JSON-parsed, oldest first. */\n  readonly sent: Effect.Effect<ReadonlyArray<unknown>>\n  /** Deliver one frame to the client. */\n  readonly push: (frame: unknown) => Effect.Effect<void>\n  /** Close the socket. 1000, 1001 and 1005 are the clean codes. */\n  readonly close: (code?: number) => Effect.Effect<void>\n  /** Hand this to an adapter that takes a socket constructor directly. */\n  readonly connect: Socket.WebSocketConstructor[\"Service\"]\n  /** Provide this in place of the real constructor. */\n  readonly layer: Layer.Layer<Socket.WebSocketConstructor>\n}\n\nexport type FakeWebSocketOptions = {\n  /** Pushed once the client subscribes, for a protocol whose server speaks first. */\n  readonly greeting?: ReadonlyArray<unknown>\n  /** How the server answers each client frame. */\n  readonly reply?: (frame: unknown) => Effect.Effect<ReadonlyArray<unknown>>\n}\n\ntype Listener = (event: any) => void\n\nconst OPEN = 1\nconst CLOSED = 3\n\n/** Run after the current call unwinds, so the client is never re-entered. */\nconst soon = (run: () => void): void => void Promise.resolve().then(run)\n\nexport const make = (\n  options?: FakeWebSocketOptions,\n): Effect.Effect<FakeWebSocketServer, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const inbound = yield* Queue.unbounded<unknown>()\n    const sent = yield* Ref.make<ReadonlyArray<unknown>>([])\n\n    const wiring = {\n      listeners: {} as Record<string, ReadonlyArray<Listener>>,\n      readyState: OPEN,\n      greeted: false,\n    }\n\n    const emit = (type: string, event: unknown): void =>\n      (wiring.listeners[type] ?? []).forEach((listener) => listener(event))\n\n    const deliverSync = (frames: ReadonlyArray<unknown>): void =>\n      frames.forEach((f) => emit(\"message\", { data: JSON.stringify(f) }))\n\n    const deliver = (frames: ReadonlyArray<unknown>): Effect.Effect<void> =>\n      Effect.sync(() => deliverSync(frames))\n\n    const shutdown = (code: number): void => {\n      if (wiring.readyState === CLOSED) return\n      wiring.readyState = CLOSED\n      emit(\"close\", { code, reason: \"\" })\n    }\n\n    // The scripted server. Answers land on their own turn, like a real one.\n    yield* Stream.fromQueue(inbound).pipe(\n      Stream.runForEach((frame) =>\n        Effect.gen(function* () {\n          yield* Ref.update(sent, (frames) => [...frames, frame])\n          const answer = yield* options?.reply?.(frame) ?? Effect.succeed([])\n          yield* deliver(answer)\n        }),\n      ),\n      Effect.forkScoped,\n    )\n\n    const socket = {\n      get readyState() {\n        return wiring.readyState\n      },\n      addEventListener: (type: string, fn: Listener): void => {\n        wiring.listeners = {\n          ...wiring.listeners,\n          [type]: [...(wiring.listeners[type] ?? []), fn],\n        }\n        // The greeting waits for a subscriber before it lands.\n        if (type === \"message\" && !wiring.greeted) {\n          wiring.greeted = true\n          soon(() => deliverSync(options?.greeting ?? []))\n        }\n      },\n      removeEventListener: (type: string, fn: Listener): void => {\n        wiring.listeners = {\n          ...wiring.listeners,\n          [type]: (wiring.listeners[type] ?? []).filter((l) => l !== fn),\n        }\n      },\n      // Safe from a synchronous callback, and no runtime needed.\n      send: (data: string): void => void Queue.offerUnsafe(inbound, JSON.parse(data)),\n      close: (code = 1000): void => shutdown(code),\n    }\n\n    const connect: Socket.WebSocketConstructor[\"Service\"] = () =>\n      socket as unknown as globalThis.WebSocket\n\n    return {\n      sent: Ref.get(sent),\n      push: (frame) => deliver([frame]),\n      close: (code = 1000) => Effect.sync(() => shutdown(code)),\n      connect,\n      layer: Layer.succeed(Socket.WebSocketConstructor, connect),\n    }\n  })\n"],"mappings":";;;;;;;;;;;;;;;AAqCA,MAAM,OAAO;AACb,MAAM,SAAS;;AAGf,MAAM,QAAQ,QAA0B,KAAK,QAAQ,QAAQ,CAAC,CAAC,KAAK,GAAG;AAEvE,MAAa,QACX,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,MAAM,UAAmB;CAChD,MAAM,OAAO,OAAO,IAAI,KAA6B,CAAC,CAAC;CAEvD,MAAM,SAAS;EACb,WAAW,CAAC;EACZ,YAAY;EACZ,SAAS;CACX;CAEA,MAAM,QAAQ,MAAc,WACzB,OAAO,UAAU,SAAS,CAAC,EAAA,CAAG,SAAS,aAAa,SAAS,KAAK,CAAC;CAEtE,MAAM,eAAe,WACnB,OAAO,SAAS,MAAM,KAAK,WAAW,EAAE,MAAM,KAAK,UAAU,CAAC,EAAE,CAAC,CAAC;CAEpE,MAAM,WAAW,WACf,OAAO,WAAW,YAAY,MAAM,CAAC;CAEvC,MAAM,YAAY,SAAuB;EACvC,IAAI,OAAO,eAAe,QAAQ;EAClC,OAAO,aAAa;EACpB,KAAK,SAAS;GAAE;GAAM,QAAQ;EAAG,CAAC;CACpC;CAGA,OAAO,OAAO,UAAU,OAAO,CAAC,CAAC,KAC/B,OAAO,YAAY,UACjB,OAAO,IAAI,aAAa;EACtB,OAAO,IAAI,OAAO,OAAO,WAAW,CAAC,GAAG,QAAQ,KAAK,CAAC;EACtD,MAAM,SAAS,OAAO,SAAS,QAAQ,KAAK,KAAK,OAAO,QAAQ,CAAC,CAAC;EAClE,OAAO,QAAQ,MAAM;CACvB,CAAC,CACH,GACA,OAAO,UACT;CAEA,MAAM,SAAS;EACb,IAAI,aAAa;GACf,OAAO,OAAO;EAChB;EACA,mBAAmB,MAAc,OAAuB;GACtD,OAAO,YAAY;IACjB,GAAG,OAAO;KACT,OAAO,CAAC,GAAI,OAAO,UAAU,SAAS,CAAC,GAAI,EAAE;GAChD;GAEA,IAAI,SAAS,aAAa,CAAC,OAAO,SAAS;IACzC,OAAO,UAAU;IACjB,WAAW,YAAY,SAAS,YAAY,CAAC,CAAC,CAAC;GACjD;EACF;EACA,sBAAsB,MAAc,OAAuB;GACzD,OAAO,YAAY;IACjB,GAAG,OAAO;KACT,QAAQ,OAAO,UAAU,SAAS,CAAC,EAAA,CAAG,QAAQ,MAAM,MAAM,EAAE;GAC/D;EACF;EAEA,OAAO,SAAuB,KAAK,MAAM,YAAY,SAAS,KAAK,MAAM,IAAI,CAAC;EAC9E,QAAQ,OAAO,QAAe,SAAS,IAAI;CAC7C;CAEA,MAAM,gBACJ;CAEF,OAAO;EACL,MAAM,IAAI,IAAI,IAAI;EAClB,OAAO,UAAU,QAAQ,CAAC,KAAK,CAAC;EAChC,QAAQ,OAAO,QAAS,OAAO,WAAW,SAAS,IAAI,CAAC;EACxD;EACA,OAAO,MAAM,QAAQ,OAAO,sBAAsB,OAAO;CAC3D;AACF,CAAC"}

package/dist/testing/MockMessenger.d.mts

@@ -0,0 +1,192 @@
+import { n as MessengerError } from "../MessengerError-CeK6VAcu.mjs";
+import { ConversationRef, InboundEvent, MessageRef, Messenger, MessengerLimits, MessengerService, Outbound } from "../messenger/Messenger.mjs";
+import { StreamViaEditsOptions } from "../messenger/MessengerAdapter.mjs";
+import { Data, Effect, Layer, Stream } from "effect";
+//#region src/testing/MockMessenger.d.ts
+/**
+ * One entry per outbound call. `Post` is logged once even when the text was
+ * long enough to split, so a caller that rolled over on its own is
+ * distinguishable from one that leaned on `post` to do it.
+ */
+type Call = Data.TaggedEnum<{
+  Post: {
+    readonly conversation: ConversationRef;
+    readonly message: Outbound;
+  };
+  Edit: {
+    readonly message: MessageRef;
+    readonly next: Outbound;
+  };
+  React: {
+    readonly message: MessageRef;
+    readonly emoji: string;
+  };
+  TypingStart: {
+    readonly conversation: ConversationRef;
+  };
+  TypingStop: {
+    readonly conversation: ConversationRef;
+  };
+}>;
+declare const Call: {
+  readonly $is: <Tag extends "Edit" | "Post" | "React" | "TypingStart" | "TypingStop">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Edit";
+    readonly message: MessageRef;
+    readonly next: Outbound;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Post";
+    readonly conversation: ConversationRef;
+    readonly message: Outbound;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "React";
+    readonly message: MessageRef;
+    readonly emoji: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TypingStart";
+    readonly conversation: ConversationRef;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TypingStop";
+    readonly conversation: ConversationRef;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Edit" | "Post" | "React" | "TypingStart" | "TypingStop"]: (args: Extract<{
+      readonly _tag: "Edit";
+      readonly message: MessageRef;
+      readonly next: Outbound;
+    } | {
+      readonly _tag: "Post";
+      readonly conversation: ConversationRef;
+      readonly message: Outbound;
+    } | {
+      readonly _tag: "React";
+      readonly message: MessageRef;
+      readonly emoji: string;
+    } | {
+      readonly _tag: "TypingStart";
+      readonly conversation: ConversationRef;
+    } | {
+      readonly _tag: "TypingStop";
+      readonly conversation: ConversationRef;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Edit";
+      readonly message: MessageRef;
+      readonly next: Outbound;
+    } | {
+      readonly _tag: "Post";
+      readonly conversation: ConversationRef;
+      readonly message: Outbound;
+    } | {
+      readonly _tag: "React";
+      readonly message: MessageRef;
+      readonly emoji: string;
+    } | {
+      readonly _tag: "TypingStart";
+      readonly conversation: ConversationRef;
+    } | {
+      readonly _tag: "TypingStop";
+      readonly conversation: ConversationRef;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Edit" | "Post" | "React" | "TypingStart" | "TypingStop"]>>;
+    <Cases extends { readonly [Tag in "Edit" | "Post" | "React" | "TypingStart" | "TypingStop"]: (args: Extract<{
+      readonly _tag: "Edit";
+      readonly message: MessageRef;
+      readonly next: Outbound;
+    } | {
+      readonly _tag: "Post";
+      readonly conversation: ConversationRef;
+      readonly message: Outbound;
+    } | {
+      readonly _tag: "React";
+      readonly message: MessageRef;
+      readonly emoji: string;
+    } | {
+      readonly _tag: "TypingStart";
+      readonly conversation: ConversationRef;
+    } | {
+      readonly _tag: "TypingStop";
+      readonly conversation: ConversationRef;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Edit";
+      readonly message: MessageRef;
+      readonly next: Outbound;
+    } | {
+      readonly _tag: "Post";
+      readonly conversation: ConversationRef;
+      readonly message: Outbound;
+    } | {
+      readonly _tag: "React";
+      readonly message: MessageRef;
+      readonly emoji: string;
+    } | {
+      readonly _tag: "TypingStart";
+      readonly conversation: ConversationRef;
+    } | {
+      readonly _tag: "TypingStop";
+      readonly conversation: ConversationRef;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Edit" | "Post" | "React" | "TypingStart" | "TypingStop"]>>;
+  };
+  readonly Edit: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Edit";
+    readonly message: MessageRef;
+    readonly next: Outbound;
+  }, "_tag">;
+  readonly Post: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Post";
+    readonly conversation: ConversationRef;
+    readonly message: Outbound;
+  }, "_tag">;
+  readonly React: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "React";
+    readonly message: MessageRef;
+    readonly emoji: string;
+  }, "_tag">;
+  readonly TypingStart: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TypingStart";
+    readonly conversation: ConversationRef;
+  }, "_tag">;
+  readonly TypingStop: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TypingStop";
+    readonly conversation: ConversationRef;
+  }, "_tag">;
+};
+type MockMessengerRecorder = {
+  readonly calls: ReadonlyArray<Call>;
+};
+type MockMessengerScript = {
+  /** Inbound events to replay. Empty by default. */
+  readonly events?: Stream.Stream<InboundEvent, MessengerError>;
+  readonly limits?: MessengerLimits;
+  /**
+   * Failures handed back one per `post` / `edit` call, in order; `undefined`
+   * entries succeed, and everything past the end succeeds.
+   */
+  readonly failures?: ReadonlyArray<MessengerError | undefined>;
+  /** Passed through to `streamViaEdits`, which backs `stream`. */
+  readonly streamOptions?: StreamViaEditsOptions;
+};
+/** Layer registering the mock against the `Messenger` tag, plus its recorder. */
+declare const layer: (script?: MockMessengerScript) => {
+  layer: Layer.Layer<Messenger, never, never>;
+  recorder: Effect.Effect<MockMessengerRecorder, never, never>;
+};
+/** Bare service value + recorder. Use with `Effect.provideService`. */
+declare const make: (script?: MockMessengerScript) => {
+  service: MessengerService;
+  recorder: Effect.Effect<MockMessengerRecorder, never, never>;
+};
+//#endregion
+export { Call, MockMessengerRecorder, MockMessengerScript, layer, make };
+//# sourceMappingURL=MockMessenger.d.mts.map

package/dist/testing/MockMessenger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockMessenger.d.mts","names":[],"sources":["../../src/testing/MockMessenger.ts"],"mappings":";;;;;;;;;;KA4BY,OAAO,KAAK;EACtB;aAAiB,cAAc;aAA0B,SAAS;;EAClE;aAAiB,SAAS;aAAqB,MAAM;;EACrD;aAAkB,SAAS;aAAqB;;EAChD;aAAwB,cAAc;;EACtC;aAAuB,cAAc;;;cAG1B;;;aANe,SAAA;aAA2B,MAAA;;;;;aADtB,cAAA;aAAmC,SAAA;;;;;aAEvC,SAAA;aAA4B;;;;;aACjB,cAAA;;;;;aACD,cAAA;;;;;;;eAHX,SAAA;eAA2B,MAAA;;;eADtB,cAAA;eAAmC,SAAA;;;eAEvC,SAAA;eAA4B;;;eACjB,cAAA;;;eACD,cAAA;;;;;;;;;;;;;;;;;;;;;;;;eAHX,SAAA;eAA2B,MAAA;;;eADtB,cAAA;eAAmC,SAAA;;;eAEvC,SAAA;eAA4B;;;eACjB,cAAA;;;eACD,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;aAHX,SAAA;aAA2B,MAAA;;;;aADtB,cAAA;aAAmC,SAAA;;;;aAEvC,SAAA;aAA4B;;;;aACjB,cAAA;;;;aACD,cAAA;;;KAK3B;WACD,OAAO,cAAc;;KAOpB;;WAED,SAAS,OAAO,OAAO,cAAc;WACrC,SAAS;;;;;WAKT,WAAW,cAAc;;WAEzB,gBAAgB;;;cAoFd,QAAK,SAAY;;;;;cAMjB,OAAI,SAAY"}

package/dist/testing/MockMessenger.mjs

@@ -0,0 +1,76 @@
+import { CurrentConversation, MessageId, Messenger } from "../messenger/Messenger.mjs";
+import { splitForLimit, streamViaEdits } from "../messenger/MessengerAdapter.mjs";
+import { Array, Data, Effect, Layer, Option, Ref, Stream } from "effect";
+//#region src/testing/MockMessenger.ts
+const Call = Data.taggedEnum();
+const defaultLimits = {
+	maxText: 4096,
+	maxCaption: 1024
+};
+const bodyText = (msg) => msg.body._tag === "Text" ? Option.some(msg.body.text) : Option.none();
+const buildService = (script, record, cursor, minted) => {
+	const limits = script.limits ?? defaultLimits;
+	const nextFailure = Ref.getAndUpdate(cursor, (n) => n + 1).pipe(Effect.flatMap((i) => Option.match(Option.fromNullishOr((script.failures ?? [])[i]), {
+		onNone: () => Effect.void,
+		onSome: Effect.fail
+	})));
+	const mint = Ref.updateAndGet(minted, (n) => n + 1).pipe(Effect.map((n) => MessageId(`m${n}`)));
+	const post = (msg) => Effect.gen(function* () {
+		const conversation = yield* CurrentConversation;
+		yield* record(Call.Post({
+			conversation,
+			message: msg
+		}));
+		yield* nextFailure;
+		const chunks = Option.match(bodyText(msg), {
+			onNone: () => 1,
+			onSome: (t) => splitForLimit(t, limits.maxText).length
+		});
+		return yield* Effect.map(Effect.forEach(Array.range(1, chunks), () => mint), Array.lastNonEmpty);
+	});
+	const edit = (msg, next) => record(Call.Edit({
+		message: msg,
+		next
+	})).pipe(Effect.andThen(nextFailure));
+	return {
+		events: script.events ?? Stream.empty,
+		post,
+		edit,
+		react: (msg, emoji) => record(Call.React({
+			message: msg,
+			emoji
+		})),
+		typing: Effect.gen(function* () {
+			const conversation = yield* CurrentConversation;
+			yield* record(Call.TypingStart({ conversation }));
+			yield* Effect.addFinalizer(() => record(Call.TypingStop({ conversation })));
+		}),
+		stream: streamViaEdits({
+			post,
+			edit,
+			limits
+		}, script.streamOptions),
+		limits
+	};
+};
+const makeUnsafe = (script) => {
+	const calls = Ref.makeUnsafe([]);
+	return {
+		service: buildService(script, (call) => Ref.update(calls, Array.append(call)), Ref.makeUnsafe(0), Ref.makeUnsafe(0)),
+		recorder: Ref.get(calls).pipe(Effect.map((c) => ({ calls: c })))
+	};
+};
+/** Layer registering the mock against the `Messenger` tag, plus its recorder. */
+const layer = (script = {}) => {
+	const { service, recorder } = makeUnsafe(script);
+	return {
+		layer: Layer.succeed(Messenger, service),
+		recorder
+	};
+};
+/** Bare service value + recorder. Use with `Effect.provideService`. */
+const make = (script = {}) => makeUnsafe(script);
+//#endregion
+export { Call, layer, make };
+
+//# sourceMappingURL=MockMessenger.mjs.map

package/dist/testing/MockMessenger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockMessenger.mjs","names":["Arr"],"sources":["../../src/testing/MockMessenger.ts"],"sourcesContent":["import { Array as Arr, Data, Effect, Layer, Option, Ref, Stream } from \"effect\"\nimport {\n  type ConversationRef,\n  CurrentConversation,\n  type InboundEvent,\n  MessageId,\n  type MessageRef,\n  Messenger,\n  type MessengerLimits,\n  type MessengerService,\n  type Outbound,\n} from \"../messenger/Messenger.js\"\nimport {\n  type StreamViaEditsOptions,\n  splitForLimit,\n  streamViaEdits,\n} from \"../messenger/MessengerAdapter.js\"\nimport * as MessengerError from \"../messenger/MessengerError.js\"\n\n// ---------------------------------------------------------------------------\n// Call log\n// ---------------------------------------------------------------------------\n\n/**\n * One entry per outbound call. `Post` is logged once even when the text was\n * long enough to split, so a caller that rolled over on its own is\n * distinguishable from one that leaned on `post` to do it.\n */\nexport type Call = Data.TaggedEnum<{\n  Post: { readonly conversation: ConversationRef; readonly message: Outbound }\n  Edit: { readonly message: MessageRef; readonly next: Outbound }\n  React: { readonly message: MessageRef; readonly emoji: string }\n  TypingStart: { readonly conversation: ConversationRef }\n  TypingStop: { readonly conversation: ConversationRef }\n}>\n\nexport const Call = Data.taggedEnum<Call>()\n\nexport type MockMessengerRecorder = {\n  readonly calls: ReadonlyArray<Call>\n}\n\n// ---------------------------------------------------------------------------\n// Script\n// ---------------------------------------------------------------------------\n\nexport type MockMessengerScript = {\n  /** Inbound events to replay. Empty by default. */\n  readonly events?: Stream.Stream<InboundEvent, MessengerError.MessengerError>\n  readonly limits?: MessengerLimits\n  /**\n   * Failures handed back one per `post` / `edit` call, in order; `undefined`\n   * entries succeed, and everything past the end succeeds.\n   */\n  readonly failures?: ReadonlyArray<MessengerError.MessengerError | undefined>\n  /** Passed through to `streamViaEdits`, which backs `stream`. */\n  readonly streamOptions?: StreamViaEditsOptions\n}\n\nconst defaultLimits: MessengerLimits = { maxText: 4096, maxCaption: 1024 }\n\nconst bodyText = (msg: Outbound): Option.Option<string> =>\n  msg.body._tag === \"Text\" ? Option.some(msg.body.text) : Option.none()\n\n// ---------------------------------------------------------------------------\n// Service builder\n// ---------------------------------------------------------------------------\n\nconst buildService = (\n  script: MockMessengerScript,\n  record: (call: Call) => Effect.Effect<void>,\n  cursor: Ref.Ref<number>,\n  minted: Ref.Ref<number>,\n): MessengerService => {\n  const limits = script.limits ?? defaultLimits\n\n  const nextFailure = Ref.getAndUpdate(cursor, (n) => n + 1).pipe(\n    Effect.flatMap((i) =>\n      Option.match(Option.fromNullishOr((script.failures ?? [])[i]), {\n        onNone: () => Effect.void,\n        onSome: Effect.fail<MessengerError.MessengerError>,\n      }),\n    ),\n  )\n\n  const mint = Ref.updateAndGet(minted, (n) => n + 1).pipe(Effect.map((n) => MessageId(`m${n}`)))\n\n  const post: MessengerService[\"post\"] = (msg) =>\n    Effect.gen(function* () {\n      const conversation = yield* CurrentConversation\n      yield* record(Call.Post({ conversation, message: msg }))\n      yield* nextFailure\n      // One id per chunk, mirroring an adapter that splits at the ceiling.\n      const chunks = Option.match(bodyText(msg), {\n        onNone: () => 1,\n        onSome: (t) => splitForLimit(t, limits.maxText).length,\n      })\n      return yield* Effect.map(\n        Effect.forEach(Arr.range(1, chunks), () => mint),\n        Arr.lastNonEmpty,\n      )\n    })\n\n  const edit: MessengerService[\"edit\"] = (msg, next) =>\n    record(Call.Edit({ message: msg, next })).pipe(Effect.andThen(nextFailure))\n\n  return {\n    events: script.events ?? Stream.empty,\n    post,\n    edit,\n    react: (msg, emoji) => record(Call.React({ message: msg, emoji })),\n    typing: Effect.gen(function* () {\n      const conversation = yield* CurrentConversation\n      yield* record(Call.TypingStart({ conversation }))\n      yield* Effect.addFinalizer(() => record(Call.TypingStop({ conversation })))\n    }),\n    stream: streamViaEdits({ post, edit, limits }, script.streamOptions),\n    limits,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\nconst makeUnsafe = (script: MockMessengerScript) => {\n  const calls = Ref.makeUnsafe<ReadonlyArray<Call>>([])\n  const service = buildService(\n    script,\n    (call) => Ref.update(calls, Arr.append(call)),\n    Ref.makeUnsafe(0),\n    Ref.makeUnsafe(0),\n  )\n  return {\n    service,\n    recorder: Ref.get(calls).pipe(Effect.map((c): MockMessengerRecorder => ({ calls: c }))),\n  }\n}\n\n/** Layer registering the mock against the `Messenger` tag, plus its recorder. */\nexport const layer = (script: MockMessengerScript = {}) => {\n  const { service, recorder } = makeUnsafe(script)\n  return { layer: Layer.succeed(Messenger, service), recorder }\n}\n\n/** Bare service value + recorder. Use with `Effect.provideService`. */\nexport const make = (script: MockMessengerScript = {}) => makeUnsafe(script)\n"],"mappings":";;;;AAoCA,MAAa,OAAO,KAAK,WAAiB;AAuB1C,MAAM,gBAAiC;CAAE,SAAS;CAAM,YAAY;AAAK;AAEzE,MAAM,YAAY,QAChB,IAAI,KAAK,SAAS,SAAS,OAAO,KAAK,IAAI,KAAK,IAAI,IAAI,OAAO,KAAK;AAMtE,MAAM,gBACJ,QACA,QACA,QACA,WACqB;CACrB,MAAM,SAAS,OAAO,UAAU;CAEhC,MAAM,cAAc,IAAI,aAAa,SAAS,MAAM,IAAI,CAAC,CAAC,CAAC,KACzD,OAAO,SAAS,MACd,OAAO,MAAM,OAAO,eAAe,OAAO,YAAY,CAAC,EAAA,CAAG,EAAE,GAAG;EAC7D,cAAc,OAAO;EACrB,QAAQ,OAAO;CACjB,CAAC,CACH,CACF;CAEA,MAAM,OAAO,IAAI,aAAa,SAAS,MAAM,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,MAAM,UAAU,IAAI,GAAG,CAAC,CAAC;CAE9F,MAAM,QAAkC,QACtC,OAAO,IAAI,aAAa;EACtB,MAAM,eAAe,OAAO;EAC5B,OAAO,OAAO,KAAK,KAAK;GAAE;GAAc,SAAS;EAAI,CAAC,CAAC;EACvD,OAAO;EAEP,MAAM,SAAS,OAAO,MAAM,SAAS,GAAG,GAAG;GACzC,cAAc;GACd,SAAS,MAAM,cAAc,GAAG,OAAO,OAAO,CAAC,CAAC;EAClD,CAAC;EACD,OAAO,OAAO,OAAO,IACnB,OAAO,QAAQA,MAAI,MAAM,GAAG,MAAM,SAAS,IAAI,GAC/CA,MAAI,YACN;CACF,CAAC;CAEH,MAAM,QAAkC,KAAK,SAC3C,OAAO,KAAK,KAAK;EAAE,SAAS;EAAK;CAAK,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,WAAW,CAAC;CAE5E,OAAO;EACL,QAAQ,OAAO,UAAU,OAAO;EAChC;EACA;EACA,QAAQ,KAAK,UAAU,OAAO,KAAK,MAAM;GAAE,SAAS;GAAK;EAAM,CAAC,CAAC;EACjE,QAAQ,OAAO,IAAI,aAAa;GAC9B,MAAM,eAAe,OAAO;GAC5B,OAAO,OAAO,KAAK,YAAY,EAAE,aAAa,CAAC,CAAC;GAChD,OAAO,OAAO,mBAAmB,OAAO,KAAK,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC;EAC5E,CAAC;EACD,QAAQ,eAAe;GAAE;GAAM;GAAM;EAAO,GAAG,OAAO,aAAa;EACnE;CACF;AACF;AAMA,MAAM,cAAc,WAAgC;CAClD,MAAM,QAAQ,IAAI,WAAgC,CAAC,CAAC;CAOpD,OAAO;EACL,SAPc,aACd,SACC,SAAS,IAAI,OAAO,OAAOA,MAAI,OAAO,IAAI,CAAC,GAC5C,IAAI,WAAW,CAAC,GAChB,IAAI,WAAW,CAAC,CAGV;EACN,UAAU,IAAI,IAAI,KAAK,CAAC,CAAC,KAAK,OAAO,KAAK,OAA8B,EAAE,OAAO,EAAE,EAAE,CAAC;CACxF;AACF;;AAGA,MAAa,SAAS,SAA8B,CAAC,MAAM;CACzD,MAAM,EAAE,SAAS,aAAa,WAAW,MAAM;CAC/C,OAAO;EAAE,OAAO,MAAM,QAAQ,WAAW,OAAO;EAAG;CAAS;AAC9D;;AAGA,MAAa,QAAQ,SAA8B,CAAC,MAAM,WAAW,MAAM"}

package/dist/testing/MockRealtimeSession.d.mts

@@ -0,0 +1,30 @@
+import { CommonSessionRequest, RealtimeEvent, RealtimeInput } from "../domain/Realtime.mjs";
+import { RealtimeSession, RealtimeVideoInput } from "../realtime/RealtimeSession.mjs";
+import { Effect, Layer } from "effect";
+//#region src/testing/MockRealtimeSession.d.ts
+type MockRealtimeSessionRecorder = {
+  readonly openCalls: ReadonlyArray<CommonSessionRequest>;
+  readonly sent: ReadonlyArray<RealtimeInput>;
+};
+type MockRealtimeSessionScript = {
+  /** Emitted as soon as the session opens. */
+  readonly initial?: ReadonlyArray<RealtimeEvent>;
+  /** The server's answer to each input. */
+  readonly onInput?: (input: RealtimeInput) => ReadonlyArray<RealtimeEvent>;
+};
+/** Scripted session that also ships the `RealtimeVideoInput` marker. */
+declare const layer: (script: MockRealtimeSessionScript) => {
+  readonly layer: Layer.Layer<RealtimeSession | RealtimeVideoInput>;
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>;
+};
+/**
+ * The same without the marker, to test that a caller sending video against an
+ * audio-only provider fails to compile.
+ */
+declare const layerAudioOnly: (script: MockRealtimeSessionScript) => {
+  readonly layer: Layer.Layer<RealtimeSession>;
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>;
+};
+//#endregion
+export { MockRealtimeSessionRecorder, MockRealtimeSessionScript, layer, layerAudioOnly };
+//# sourceMappingURL=MockRealtimeSession.d.mts.map

package/dist/testing/MockRealtimeSession.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockRealtimeSession.d.mts","names":[],"sources":["../../src/testing/MockRealtimeSession.ts"],"mappings":";;;;KASY;WACD,WAAW,cAAc;WACzB,MAAM,cAAc;;KAGnB;;WAED,UAAU,cAAc;;WAExB,WAAW,OAAO,kBAAkB,cAAc;;;cAgDhD,QAAK,QACR;WAEC,OAAO,MAAM,MAAM,kBAAkB;WACrC,UAAU,OAAO,OAAO;;;;;;cAatB,iBAAc,QACjB;WAEC,OAAO,MAAM,MAAM;WACnB,UAAU,OAAO,OAAO"}

package/dist/testing/MockRealtimeSession.mjs

@@ -0,0 +1,52 @@
+import { RealtimeSession, RealtimeVideoInput } from "../realtime/RealtimeSession.mjs";
+import { Effect, Layer, Queue, Ref, Stream } from "effect";
+//#region src/testing/MockRealtimeSession.ts
+const makeService = (script, record) => ({ open: (request) => Effect.gen(function* () {
+	yield* record.open(request);
+	const queue = yield* Queue.unbounded();
+	yield* Effect.addFinalizer(() => Queue.end(queue));
+	yield* Queue.offerAll(queue, script.initial ?? []);
+	return {
+		send: (input) => Effect.andThen(record.send(input), Queue.offerAll(queue, script.onInput?.(input) ?? [])).pipe(Effect.asVoid),
+		events: Stream.fromQueue(queue)
+	};
+}) });
+const build = (script) => {
+	const openCalls = Ref.makeUnsafe([]);
+	const sent = Ref.makeUnsafe([]);
+	return {
+		sessionLayer: Layer.succeed(RealtimeSession, makeService(script, {
+			open: (request) => Ref.update(openCalls, (xs) => [...xs, request]),
+			send: (input) => Ref.update(sent, (xs) => [...xs, input])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				openCalls: yield* Ref.get(openCalls),
+				sent: yield* Ref.get(sent)
+			};
+		})
+	};
+};
+/** Scripted session that also ships the `RealtimeVideoInput` marker. */
+const layer = (script) => {
+	const { sessionLayer, recorder } = build(script);
+	return {
+		layer: Layer.merge(sessionLayer, Layer.succeed(RealtimeVideoInput, void 0)),
+		recorder
+	};
+};
+/**
+* The same without the marker, to test that a caller sending video against an
+* audio-only provider fails to compile.
+*/
+const layerAudioOnly = (script) => {
+	const { sessionLayer, recorder } = build(script);
+	return {
+		layer: sessionLayer,
+		recorder
+	};
+};
+//#endregion
+export { layer, layerAudioOnly };
+
+//# sourceMappingURL=MockRealtimeSession.mjs.map

package/dist/testing/MockRealtimeSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockRealtimeSession.mjs","names":[],"sources":["../../src/testing/MockRealtimeSession.ts"],"sourcesContent":["import { Cause, Effect, Layer, Queue, Ref, Stream } from \"effect\"\nimport type { CommonSessionRequest, RealtimeEvent, RealtimeInput } from \"../domain/Realtime.js\"\nimport {\n  RealtimeSession,\n  RealtimeVideoInput,\n  type RealtimeSessionHandle,\n  type RealtimeSessionService,\n} from \"../realtime/RealtimeSession.js\"\n\nexport type MockRealtimeSessionRecorder = {\n  readonly openCalls: ReadonlyArray<CommonSessionRequest>\n  readonly sent: ReadonlyArray<RealtimeInput>\n}\n\nexport type MockRealtimeSessionScript = {\n  /** Emitted as soon as the session opens. */\n  readonly initial?: ReadonlyArray<RealtimeEvent>\n  /** The server's answer to each input. */\n  readonly onInput?: (input: RealtimeInput) => ReadonlyArray<RealtimeEvent>\n}\n\ntype Recorders = {\n  readonly open: (request: CommonSessionRequest) => Effect.Effect<void>\n  readonly send: (input: RealtimeInput) => Effect.Effect<void>\n}\n\nconst makeService = (\n  script: MockRealtimeSessionScript,\n  record: Recorders,\n): RealtimeSessionService => ({\n  open: (request) =>\n    Effect.gen(function* () {\n      yield* record.open(request)\n      const queue = yield* Queue.unbounded<RealtimeEvent, Cause.Done>()\n      // Closing the scope ends `events`, leaving anything already queued to drain.\n      yield* Effect.addFinalizer(() => Queue.end(queue))\n      yield* Queue.offerAll(queue, script.initial ?? [])\n      const handle: RealtimeSessionHandle = {\n        send: (input) =>\n          Effect.andThen(\n            record.send(input),\n            Queue.offerAll(queue, script.onInput?.(input) ?? []),\n          ).pipe(Effect.asVoid),\n        events: Stream.fromQueue(queue),\n      }\n      return handle\n    }),\n})\n\nconst build = (script: MockRealtimeSessionScript) => {\n  const openCalls = Ref.makeUnsafe<ReadonlyArray<CommonSessionRequest>>([])\n  const sent = Ref.makeUnsafe<ReadonlyArray<RealtimeInput>>([])\n  const sessionLayer = Layer.succeed(\n    RealtimeSession,\n    makeService(script, {\n      open: (request) => Ref.update(openCalls, (xs) => [...xs, request]),\n      send: (input) => Ref.update(sent, (xs) => [...xs, input]),\n    }),\n  )\n  const recorder: Effect.Effect<MockRealtimeSessionRecorder> = Effect.gen(function* () {\n    return { openCalls: yield* Ref.get(openCalls), sent: yield* Ref.get(sent) }\n  })\n  return { sessionLayer, recorder }\n}\n\n/** Scripted session that also ships the `RealtimeVideoInput` marker. */\nexport const layer = (\n  script: MockRealtimeSessionScript,\n): {\n  readonly layer: Layer.Layer<RealtimeSession | RealtimeVideoInput>\n  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>\n} => {\n  const { sessionLayer, recorder } = build(script)\n  return {\n    layer: Layer.merge(sessionLayer, Layer.succeed(RealtimeVideoInput, undefined)),\n    recorder,\n  }\n}\n\n/**\n * The same without the marker, to test that a caller sending video against an\n * audio-only provider fails to compile.\n */\nexport const layerAudioOnly = (\n  script: MockRealtimeSessionScript,\n): {\n  readonly layer: Layer.Layer<RealtimeSession>\n  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>\n} => {\n  const { sessionLayer, recorder } = build(script)\n  return { layer: sessionLayer, recorder }\n}\n"],"mappings":";;;AA0BA,MAAM,eACJ,QACA,YAC4B,EAC5B,OAAO,YACL,OAAO,IAAI,aAAa;CACtB,OAAO,OAAO,KAAK,OAAO;CAC1B,MAAM,QAAQ,OAAO,MAAM,UAAqC;CAEhE,OAAO,OAAO,mBAAmB,MAAM,IAAI,KAAK,CAAC;CACjD,OAAO,MAAM,SAAS,OAAO,OAAO,WAAW,CAAC,CAAC;CASjD,OAAO;EAPL,OAAO,UACL,OAAO,QACL,OAAO,KAAK,KAAK,GACjB,MAAM,SAAS,OAAO,OAAO,UAAU,KAAK,KAAK,CAAC,CAAC,CACrD,CAAC,CAAC,KAAK,OAAO,MAAM;EACtB,QAAQ,OAAO,UAAU,KAAK;CAEpB;AACd,CAAC,EACL;AAEA,MAAM,SAAS,WAAsC;CACnD,MAAM,YAAY,IAAI,WAAgD,CAAC,CAAC;CACxE,MAAM,OAAO,IAAI,WAAyC,CAAC,CAAC;CAW5D,OAAO;EAAE,cAVY,MAAM,QACzB,iBACA,YAAY,QAAQ;GAClB,OAAO,YAAY,IAAI,OAAO,YAAY,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC;GACjE,OAAO,UAAU,IAAI,OAAO,OAAO,OAAO,CAAC,GAAG,IAAI,KAAK,CAAC;EAC1D,CAAC,CAKiB;EAAG,UAHsC,OAAO,IAAI,aAAa;GACnF,OAAO;IAAE,WAAW,OAAO,IAAI,IAAI,SAAS;IAAG,MAAM,OAAO,IAAI,IAAI,IAAI;GAAE;EAC5E,CAC8B;CAAE;AAClC;;AAGA,MAAa,SACX,WAIG;CACH,MAAM,EAAE,cAAc,aAAa,MAAM,MAAM;CAC/C,OAAO;EACL,OAAO,MAAM,MAAM,cAAc,MAAM,QAAQ,oBAAoB,KAAA,CAAS,CAAC;EAC7E;CACF;AACF;;;;;AAMA,MAAa,kBACX,WAIG;CACH,MAAM,EAAE,cAAc,aAAa,MAAM,MAAM;CAC/C,OAAO;EAAE,OAAO;EAAc;CAAS;AACzC"}

package/dist/tool/Toolkit.d.mts

@@ -1,2 +1,2 @@
-import { S as wrap, _ as fromArray, a as ToolMap, b as namespace, c as ToolkitR, d as appendToolResults, f as collectResults, g as descriptors, h as describeFailures, i as NoDuplicateNames, m as continueWithResults, n as ExecuteOptions, o as Toolkit, p as compose, r as Middleware, s as ToolkitE, t as DuplicateToolName, u as UniqueTools, v as make, x as run, y as makeNamespaced } from "../Toolkit-DAjJ9Tvl.mjs";
+import { S as wrap, _ as fromArray, a as ToolMap, b as namespace, c as ToolkitR, d as appendToolResults, f as collectResults, g as descriptors, h as describeFailures, i as NoDuplicateNames, m as continueWithResults, n as ExecuteOptions, o as Toolkit, p as compose, r as Middleware, s as ToolkitE, t as DuplicateToolName, u as UniqueTools, v as make, x as run, y as makeNamespaced } from "../Toolkit-tlL0F2YR.mjs";
 export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };

package/dist/transcriber/Transcriber.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { a as AudioSource, r as AudioFormat } from "../Audio-_nGR4V0X.mjs";
 import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
 import { Context, Effect, Stream } from "effect";

package/dist/web-read/WebRead.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { Context, Duration, Effect } from "effect";
 declare namespace WebRead_d_exports {
   export { CommonReadRequest, ReadFormat, ReadResponse, WebRead, WebReadService, read };

package/dist/web-read/WebReadTool.d.mts

@@ -1,5 +1,5 @@
 import { l as Tool } from "../Tool-BF78QWtn.mjs";
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { ReadFormat, ReadResponse, WebRead } from "./WebRead.mjs";
 import { Schema } from "effect";
 declare namespace WebReadTool_d_exports {

package/dist/web-search/WebSearch.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { Context, DateTime, Effect, Schema } from "effect";
 declare namespace WebSearch_d_exports {
   export { CommonSearchRequest, SearchRecency, SearchResponse, SearchResult, WebSearch, WebSearchService, search };

package/dist/web-search/WebSearchTool.d.mts

@@ -1,5 +1,5 @@
 import { l as Tool } from "../Tool-BF78QWtn.mjs";
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { SearchResult, WebSearch } from "./WebSearch.mjs";
 import { Schema } from "effect";
 declare namespace WebSearchTool_d_exports {