@effect-uai/core 0.13.0 → 0.15.0

package/dist/messenger/MessengerAdapter.mjs

@@ -0,0 +1,102 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { CurrentConversation, text } from "./Messenger.mjs";
+import { Array, Clock, Data, Duration, Effect, Option, Schedule, Stream } from "effect";
+//#region src/messenger/MessengerAdapter.ts
+/**
+* What an adapter author needs and a recipe author never sees: text
+* splitting at a platform ceiling, and post-then-edit progressive delivery
+* for platforms without a native streaming API.
+*/
+var MessengerAdapter_exports = /* @__PURE__ */ __exportAll({
+	splitForLimit: () => splitForLimit,
+	streamViaEdits: () => streamViaEdits
+});
+const boundaries = [
+	"\n\n",
+	"\n",
+	" "
+];
+/** Best split at or before `limit`; a hard cut only for an unbroken run. */
+const cutAt = (body, limit) => body.length <= limit ? [body, ""] : Array.findFirst(boundaries, (sep) => Option.map(Option.liftPredicate(body.lastIndexOf(sep, limit - sep.length), (at) => at > 0), (at) => [body.slice(0, at), body.slice(at + sep.length)])).pipe(Option.getOrElse(() => [body.slice(0, limit), body.slice(limit)]));
+/**
+* Chunk `body` into pieces no longer than `limit`, breaking on paragraph,
+* line, then word boundaries. Always yields at least one chunk, so callers
+* have something to send even for empty input.
+*/
+const splitForLimit = (body, limit) => {
+	const [head, rest] = cutAt(body, limit);
+	return rest.length === 0 ? [head] : [head, ...splitForLimit(rest, limit)];
+};
+const isRateLimited = (e) => e._tag === "MessengerRateLimited";
+const honourRetryAfter = (times) => Schedule.recurs(times).pipe(Schedule.setInputType(), Schedule.modifyDelay(({ input }) => Effect.succeed(input._tag === "MessengerRateLimited" ? input.retryAfter : Duration.zero)));
+const Progress = Data.taggedEnum();
+const appended = (s, delta) => ({
+	...s,
+	pending: s.pending + delta
+});
+/**
+* Progressive delivery as post-then-edit, for adapters with no native
+* streaming API. Coalesces deltas by time and growth, never resends
+* unchanged text, waits out `MessengerRateLimited`, rolls over to a fresh
+* message past `limits.maxText`, and always flushes the tail.
+*
+* The first chunk goes out as soon as any text arrives, so the message shows
+* up immediately and fills in from there. A stream that produced no text
+* posts nothing and yields `None`.
+*/
+const streamViaEdits = (verbs, options) => (deltas, streamOptions = {}) => Effect.gen(function* () {
+	const every = Duration.toMillis(options?.every ?? "1 second");
+	const minChars = options?.minChars ?? 40;
+	const schedule = honourRetryAfter(options?.rateLimitRetries ?? 3);
+	const conversation = yield* CurrentConversation;
+	const patiently = (effect) => Effect.retry(effect, {
+		schedule,
+		while: isRateLimited
+	});
+	const deliver = (s, body, now) => Progress.$match(s, {
+		Draft: ({ pending, envelope }) => patiently(verbs.post(text(body, envelope))).pipe(Effect.map((id) => Progress.Sent({
+			id,
+			sent: body,
+			pending,
+			lastFlush: now
+		}))),
+		Sent: (sent) => body === sent.sent ? Effect.succeed(sent) : patiently(verbs.edit({
+			conversation,
+			id: sent.id
+		}, text(body))).pipe(Effect.as(Progress.Sent({
+			...sent,
+			sent: body,
+			lastFlush: now
+		})))
+	});
+	const rollover = (s, now) => {
+		const [head, rest] = cutAt(s.pending, verbs.limits.maxText);
+		return rest.length === 0 ? Effect.succeed(s) : deliver(s, head, now).pipe(Effect.flatMap(() => rollover(Progress.Draft({
+			pending: rest,
+			envelope: {}
+		}), now)));
+	};
+	const due = (s, now) => Progress.$match(s, {
+		Draft: ({ pending }) => pending.trim().length > 0,
+		Sent: ({ sent, pending, lastFlush }) => now - lastFlush >= every && pending.length - sent.length >= minChars
+	});
+	const step = (before, delta) => Effect.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		const s = yield* rollover(appended(before, delta), now);
+		if (!due(s, now)) return s;
+		return yield* deliver(s, s.pending, now);
+	});
+	const folded = yield* Stream.runFoldEffect(deltas, () => Progress.Draft({
+		pending: "",
+		envelope: streamOptions
+	}), step);
+	const now = yield* Clock.currentTimeMillis;
+	const s = yield* rollover(folded, now);
+	if (s._tag === "Draft" && s.pending.trim().length === 0) return Option.none();
+	const final = yield* deliver(s, s.pending, now);
+	return Option.some(final.id);
+});
+//#endregion
+export { splitForLimit, streamViaEdits, MessengerAdapter_exports as t };
+
+//# sourceMappingURL=MessengerAdapter.mjs.map

package/dist/messenger/MessengerAdapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerAdapter.mjs","names":["Arr"],"sources":["../../src/messenger/MessengerAdapter.ts"],"sourcesContent":["/**\n * What an adapter author needs and a recipe author never sees: text\n * splitting at a platform ceiling, and post-then-edit progressive delivery\n * for platforms without a native streaming API.\n */\nimport { Array as Arr, Clock, Data, Duration, Effect, Option, Schedule, Stream } from \"effect\"\nimport {\n  CurrentConversation,\n  type MessageId,\n  type MessengerService,\n  type StreamOptions,\n  text,\n} from \"./Messenger.js\"\nimport type * as MessengerError from \"./MessengerError.js\"\n\n// ---------------------------------------------------------------------------\n// Text splitting\n// ---------------------------------------------------------------------------\n\n// Paragraph break first, then line break, then space.\nconst boundaries = [\"\\n\\n\", \"\\n\", \" \"] as const\n\n/** Best split at or before `limit`; a hard cut only for an unbroken run. */\nconst cutAt = (body: string, limit: number): readonly [head: string, rest: string] =>\n  body.length <= limit\n    ? [body, \"\"]\n    : Arr.findFirst(boundaries, (sep) =>\n        Option.map(\n          Option.liftPredicate(body.lastIndexOf(sep, limit - sep.length), (at) => at > 0),\n          (at) => [body.slice(0, at), body.slice(at + sep.length)] as const,\n        ),\n      ).pipe(Option.getOrElse(() => [body.slice(0, limit), body.slice(limit)] as const))\n\n/**\n * Chunk `body` into pieces no longer than `limit`, breaking on paragraph,\n * line, then word boundaries. Always yields at least one chunk, so callers\n * have something to send even for empty input.\n */\nexport const splitForLimit = (body: string, limit: number): Arr.NonEmptyReadonlyArray<string> => {\n  const [head, rest] = cutAt(body, limit)\n  return rest.length === 0 ? [head] : [head, ...splitForLimit(rest, limit)]\n}\n\n// ---------------------------------------------------------------------------\n// streamViaEdits\n// ---------------------------------------------------------------------------\n\n/** The slice of a messenger that {@link streamViaEdits} drives. */\nexport type EditableVerbs = Pick<MessengerService, \"post\" | \"edit\" | \"limits\">\n\nexport type StreamViaEditsOptions = {\n  /** Minimum wall time between edits. Default 1 second. */\n  readonly every?: Duration.Input\n  /** Minimum growth since the last edit before spending another. Default 40. */\n  readonly minChars?: number\n  /** How often to honour a `MessengerRateLimited` before giving up. Default 3. */\n  readonly rateLimitRetries?: number\n}\n\nconst isRateLimited = (e: MessengerError.MessengerError): boolean =>\n  e._tag === \"MessengerRateLimited\"\n\n// A retry schedule's input is the error, so the delay is the platform's own\n// `retry_after` rather than a guess. Bounded by `recurs`, so an unlucky call\n// eventually surfaces the rate limit instead of stalling behind it.\nconst honourRetryAfter = (\n  times: number,\n): Schedule.Schedule<number, MessengerError.MessengerError> =>\n  Schedule.recurs(times).pipe(\n    Schedule.setInputType<MessengerError.MessengerError>(),\n    Schedule.modifyDelay(({ input }) =>\n      Effect.succeed(input._tag === \"MessengerRateLimited\" ? input.retryAfter : Duration.zero),\n    ),\n  )\n\n/**\n * The message being filled: not on the platform yet, or posted and edited\n * since. Only the first draft carries the reply; rollover drafts do not.\n */\ntype Progress = Data.TaggedEnum<{\n  Draft: { readonly pending: string; readonly envelope: StreamOptions }\n  Sent: {\n    readonly id: MessageId\n    /** Text the message shows now. Never resent unchanged. */\n    readonly sent: string\n    /** Text it should show, deltas included. */\n    readonly pending: string\n    readonly lastFlush: number\n  }\n}>\n\nconst Progress = Data.taggedEnum<Progress>()\n\ntype Sent = Data.TaggedEnum.Value<Progress, \"Sent\">\n\nconst appended = (s: Progress, delta: string): Progress => ({\n  ...s,\n  pending: s.pending + delta,\n})\n\n/**\n * Progressive delivery as post-then-edit, for adapters with no native\n * streaming API. Coalesces deltas by time and growth, never resends\n * unchanged text, waits out `MessengerRateLimited`, rolls over to a fresh\n * message past `limits.maxText`, and always flushes the tail.\n *\n * The first chunk goes out as soon as any text arrives, so the message shows\n * up immediately and fills in from there. A stream that produced no text\n * posts nothing and yields `None`.\n */\nexport const streamViaEdits =\n  (verbs: EditableVerbs, options?: StreamViaEditsOptions): MessengerService[\"stream\"] =>\n  (deltas, streamOptions = {}) =>\n    Effect.gen(function* () {\n      const every = Duration.toMillis(options?.every ?? \"1 second\")\n      const minChars = options?.minChars ?? 40\n      const schedule = honourRetryAfter(options?.rateLimitRetries ?? 3)\n      const conversation = yield* CurrentConversation\n\n      const patiently = <A, R2>(\n        effect: Effect.Effect<A, MessengerError.MessengerError, R2>,\n      ): Effect.Effect<A, MessengerError.MessengerError, R2> =>\n        Effect.retry(effect, { schedule, while: isRateLimited })\n\n      // Post a draft, edit a sent message, and skip an edit that would resend\n      // what the message already shows.\n      const deliver = (\n        s: Progress,\n        body: string,\n        now: number,\n      ): Effect.Effect<Sent, MessengerError.MessengerError, CurrentConversation> =>\n        Progress.$match(s, {\n          Draft: ({ pending, envelope }) =>\n            patiently(verbs.post(text(body, envelope))).pipe(\n              Effect.map((id) => Progress.Sent({ id, sent: body, pending, lastFlush: now })),\n            ),\n          Sent: (sent) =>\n            body === sent.sent\n              ? Effect.succeed(sent)\n              : patiently(verbs.edit({ conversation, id: sent.id }, text(body))).pipe(\n                  Effect.as(Progress.Sent({ ...sent, sent: body, lastFlush: now })),\n                ),\n        })\n\n      // Anything past the ceiling becomes the next message: finish the current\n      // one at a clean boundary, then start a draft on the remainder.\n      const rollover = (\n        s: Progress,\n        now: number,\n      ): Effect.Effect<Progress, MessengerError.MessengerError, CurrentConversation> => {\n        const [head, rest] = cutAt(s.pending, verbs.limits.maxText)\n        return rest.length === 0\n          ? Effect.succeed(s)\n          : deliver(s, head, now).pipe(\n              Effect.flatMap(() => rollover(Progress.Draft({ pending: rest, envelope: {} }), now)),\n            )\n      }\n\n      // A draft lands on its first real text; a sent message waits for both\n      // gates. Blank is not text: a model that opens a tool-calling turn with\n      // a newline would otherwise post it, and platforms reject a message\n      // that is only whitespace.\n      const due = (s: Progress, now: number): boolean =>\n        Progress.$match(s, {\n          Draft: ({ pending }) => pending.trim().length > 0,\n          Sent: ({ sent, pending, lastFlush }) =>\n            now - lastFlush >= every && pending.length - sent.length >= minChars,\n        })\n\n      const step = (before: Progress, delta: string) =>\n        Effect.gen(function* () {\n          const now = yield* Clock.currentTimeMillis\n          const s = yield* rollover(appended(before, delta), now)\n          if (!due(s, now)) return s\n          return yield* deliver(s, s.pending, now)\n        })\n\n      const folded = yield* Stream.runFoldEffect(\n        deltas,\n        () => Progress.Draft({ pending: \"\", envelope: streamOptions }),\n        step,\n      )\n      const now = yield* Clock.currentTimeMillis\n      const s = yield* rollover(folded, now)\n      // The tail always lands; a draft that never held text is nothing to send.\n      if (s._tag === \"Draft\" && s.pending.trim().length === 0) return Option.none()\n      const final = yield* deliver(s, s.pending, now)\n      return Option.some(final.id)\n    })\n"],"mappings":"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"}

package/dist/messenger/MessengerAdapter.test.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/messenger/MessengerAdapter.test.mjs

@@ -0,0 +1,138 @@
+import { ChannelId, MessageId, inConversation } from "./Messenger.mjs";
+import { splitForLimit } from "./MessengerAdapter.mjs";
+import { MessengerRateLimited } from "./MessengerError.mjs";
+import { o as describe } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
+import { t as it } from "../dist-nohcnkD6.mjs";
+import { make } from "../testing/MockMessenger.mjs";
+import { Array, Duration, Effect, Option, Result, Stream } from "effect";
+import { TestClock } from "effect/testing";
+//#region src/messenger/MessengerAdapter.test.ts
+const here = { channel: ChannelId("c1") };
+const bodyOf = (msg) => msg.body._tag === "Text" ? msg.body.text : "";
+const posts = (calls) => Array.filterMap(calls, (c) => c._tag === "Post" ? Result.succeed(bodyOf(c.message)) : Result.failVoid);
+const edits = (calls) => Array.filterMap(calls, (c) => c._tag === "Edit" ? Result.succeed(bodyOf(c.next)) : Result.failVoid);
+/** Run `deltas` through the mock's `stream` and hand back the call log. */
+const streamed = (deltas, script = {}, streamOptions) => Effect.gen(function* () {
+	const { service, recorder } = make(script);
+	const id = yield* service.stream(Stream.fromIterable(deltas), streamOptions);
+	const { calls } = yield* recorder;
+	return {
+		id,
+		calls
+	};
+}).pipe(inConversation(here));
+const options = (o) => ({ streamOptions: o });
+describe("splitForLimit", () => {
+	it("prefers a paragraph break, then a line, then a word", () => {
+		globalExpect(splitForLimit("aaa\n\nbbb ccc", 8)).toEqual(["aaa", "bbb ccc"]);
+		globalExpect(splitForLimit("aaa\nbbbb ccc", 8)).toEqual(["aaa", "bbbb ccc"]);
+		globalExpect(splitForLimit("aaaa bbbb ccc", 9)).toEqual(["aaaa", "bbbb ccc"]);
+	});
+	it("hard-cuts a run with no boundary inside the limit", () => {
+		globalExpect(splitForLimit("aaaaaaaaaa", 4)).toEqual([
+			"aaaa",
+			"aaaa",
+			"aa"
+		]);
+	});
+});
+describe("streamViaEdits", () => {
+	it.effect("coalesces deltas arriving inside the `every` window", () => Effect.gen(function* () {
+		const { calls } = yield* streamed([
+			"Hel",
+			"lo ",
+			"the",
+			"re!"
+		]);
+		globalExpect(posts(calls)).toEqual(["Hel"]);
+		globalExpect(edits(calls)).toEqual(["Hello there!"]);
+	}));
+	it.effect("waits for `minChars` of growth before spending an edit", () => Effect.gen(function* () {
+		const { calls } = yield* streamed([
+			"aaaa",
+			"bbbb",
+			"cccc",
+			"dddd",
+			"eeee",
+			"ffff"
+		], options({
+			every: 0,
+			minChars: 10
+		}));
+		globalExpect(posts(calls)).toEqual(["aaaa"]);
+		globalExpect(edits(calls).map((t) => t.length)).toEqual([16, 24]);
+	}));
+	it.effect("skips the final flush when the message already shows the text", () => Effect.gen(function* () {
+		const { calls } = yield* streamed([
+			"aaaaa",
+			"bbbbb",
+			"ccccc"
+		], options({
+			every: 0,
+			minChars: 10
+		}));
+		globalExpect(edits(calls)).toEqual(["aaaaabbbbbccccc"]);
+	}));
+	it.effect("rolls over to a new message past maxText", () => Effect.gen(function* () {
+		const { id, calls } = yield* streamed(["aaaa bbbb cccc dddd"], { limits: {
+			maxText: 10,
+			maxCaption: 10
+		} });
+		globalExpect(posts(calls)).toEqual(["aaaa bbbb", "cccc dddd"]);
+		globalExpect(edits(calls)).toEqual([]);
+		globalExpect(id).toEqual(Option.some(MessageId("m2")));
+	}));
+	it.effect("quotes the question on the first message only, never on a rollover", () => Effect.gen(function* () {
+		const { calls } = yield* streamed(["aaaa bbbb cccc dddd"], { limits: {
+			maxText: 10,
+			maxCaption: 10
+		} }, { replyTo: MessageId("q1") });
+		const replies = Array.filterMap(calls, (c) => c._tag === "Post" ? Result.succeed(c.message.replyTo) : Result.failVoid);
+		globalExpect(replies).toEqual([MessageId("q1"), void 0]);
+	}));
+	it.effect("posts nothing for a stream with no text", () => Effect.gen(function* () {
+		const { id, calls } = yield* streamed(["", ""]);
+		globalExpect(calls).toEqual([]);
+		globalExpect(id).toEqual(Option.none());
+	}));
+	it.effect("treats whitespace-only deltas as no text at all", () => Effect.gen(function* () {
+		const { id, calls } = yield* streamed([
+			"\n",
+			"  ",
+			"\n\n"
+		]);
+		globalExpect(calls).toEqual([]);
+		globalExpect(id).toEqual(Option.none());
+	}));
+	it.live("waits out a rate limit and re-sends the same edit", () => Effect.gen(function* () {
+		const limited = new MessengerRateLimited({
+			provider: "mock",
+			retryAfter: Duration.millis(10)
+		});
+		const { calls } = yield* streamed(["abc", "defghij"], {
+			...options({
+				every: 0,
+				minChars: 1
+			}),
+			failures: [void 0, limited]
+		});
+		globalExpect(posts(calls)).toEqual(["abc"]);
+		globalExpect(edits(calls)).toEqual(["abcdefghij", "abcdefghij"]);
+	}));
+	it.effect("gives up once the rate-limit budget is spent", () => Effect.gen(function* () {
+		const limited = new MessengerRateLimited({
+			provider: "mock",
+			retryAfter: Duration.zero
+		});
+		const failed = yield* Effect.flip(streamed(["abc"], {
+			...options({ rateLimitRetries: 1 }),
+			failures: [limited, limited]
+		}));
+		globalExpect(failed._tag).toBe("MessengerRateLimited");
+	}).pipe(TestClock.withLive));
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=MessengerAdapter.test.mjs.map

package/dist/messenger/MessengerAdapter.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerAdapter.test.mjs","names":["Arr","MockMessenger.make"],"sources":["../../src/messenger/MessengerAdapter.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport { Array as Arr, Duration, Effect, Option, Result, Stream } from \"effect\"\nimport { TestClock } from \"effect/testing\"\nimport { expect } from \"vitest\"\nimport * as MockMessenger from \"../testing/MockMessenger.js\"\nimport {\n  ChannelId,\n  type ConversationRef,\n  MessageId,\n  type Outbound,\n  type StreamOptions,\n  inConversation,\n} from \"./Messenger.js\"\nimport { type StreamViaEditsOptions, splitForLimit } from \"./MessengerAdapter.js\"\nimport { MessengerRateLimited } from \"./MessengerError.js\"\n\nconst here: ConversationRef = { channel: ChannelId(\"c1\") }\n\nconst bodyOf = (msg: Outbound): string => (msg.body._tag === \"Text\" ? msg.body.text : \"\")\n\nconst posts = (calls: ReadonlyArray<MockMessenger.Call>) =>\n  Arr.filterMap(calls, (c) =>\n    c._tag === \"Post\" ? Result.succeed(bodyOf(c.message)) : Result.failVoid,\n  )\n\nconst edits = (calls: ReadonlyArray<MockMessenger.Call>) =>\n  Arr.filterMap(calls, (c) =>\n    c._tag === \"Edit\" ? Result.succeed(bodyOf(c.next)) : Result.failVoid,\n  )\n\n/** Run `deltas` through the mock's `stream` and hand back the call log. */\nconst streamed = (\n  deltas: ReadonlyArray<string>,\n  script: MockMessenger.MockMessengerScript = {},\n  streamOptions?: StreamOptions,\n) =>\n  Effect.gen(function* () {\n    const { service, recorder } = MockMessenger.make(script)\n    const id = yield* service.stream(Stream.fromIterable(deltas), streamOptions)\n    const { calls } = yield* recorder\n    return { id, calls }\n  }).pipe(inConversation(here))\n\nconst options = (o: StreamViaEditsOptions): MockMessenger.MockMessengerScript => ({\n  streamOptions: o,\n})\n\n// ---------------------------------------------------------------------------\n// splitForLimit\n// ---------------------------------------------------------------------------\n\ndescribe(\"splitForLimit\", () => {\n  it(\"prefers a paragraph break, then a line, then a word\", () => {\n    expect(splitForLimit(\"aaa\\n\\nbbb ccc\", 8)).toEqual([\"aaa\", \"bbb ccc\"])\n    expect(splitForLimit(\"aaa\\nbbbb ccc\", 8)).toEqual([\"aaa\", \"bbbb ccc\"])\n    expect(splitForLimit(\"aaaa bbbb ccc\", 9)).toEqual([\"aaaa\", \"bbbb ccc\"])\n  })\n\n  it(\"hard-cuts a run with no boundary inside the limit\", () => {\n    expect(splitForLimit(\"aaaaaaaaaa\", 4)).toEqual([\"aaaa\", \"aaaa\", \"aa\"])\n  })\n})\n\n// ---------------------------------------------------------------------------\n// streamViaEdits\n// ---------------------------------------------------------------------------\n\ndescribe(\"streamViaEdits\", () => {\n  // TestClock keeps wall time frozen, so the `every` gate never opens and\n  // every delta after the first coalesces into the final flush.\n  it.effect(\"coalesces deltas arriving inside the `every` window\", () =>\n    Effect.gen(function* () {\n      const { calls } = yield* streamed([\"Hel\", \"lo \", \"the\", \"re!\"])\n\n      expect(posts(calls)).toEqual([\"Hel\"])\n      expect(edits(calls)).toEqual([\"Hello there!\"])\n    }),\n  )\n\n  it.effect(\"waits for `minChars` of growth before spending an edit\", () =>\n    Effect.gen(function* () {\n      const { calls } = yield* streamed(\n        [\"aaaa\", \"bbbb\", \"cccc\", \"dddd\", \"eeee\", \"ffff\"],\n        options({ every: 0, minChars: 10 }),\n      )\n\n      // Edits land at 16 chars (12 of growth) and again on the final flush.\n      expect(posts(calls)).toEqual([\"aaaa\"])\n      expect(edits(calls).map((t) => t.length)).toEqual([16, 24])\n    }),\n  )\n\n  it.effect(\"skips the final flush when the message already shows the text\", () =>\n    Effect.gen(function* () {\n      const { calls } = yield* streamed(\n        [\"aaaaa\", \"bbbbb\", \"ccccc\"],\n        options({ every: 0, minChars: 10 }),\n      )\n\n      // The third delta opens the growth gate, so the tail is already sent.\n      expect(edits(calls)).toEqual([\"aaaaabbbbbccccc\"])\n    }),\n  )\n\n  it.effect(\"rolls over to a new message past maxText\", () =>\n    Effect.gen(function* () {\n      const { id, calls } = yield* streamed([\"aaaa bbbb cccc dddd\"], {\n        limits: { maxText: 10, maxCaption: 10 },\n      })\n\n      // Cut on the word boundary, not mid-word, and the id is the last message.\n      expect(posts(calls)).toEqual([\"aaaa bbbb\", \"cccc dddd\"])\n      expect(edits(calls)).toEqual([])\n      expect(id).toEqual(Option.some(MessageId(\"m2\")))\n    }),\n  )\n\n  it.effect(\"quotes the question on the first message only, never on a rollover\", () =>\n    Effect.gen(function* () {\n      const { calls } = yield* streamed(\n        [\"aaaa bbbb cccc dddd\"],\n        { limits: { maxText: 10, maxCaption: 10 } },\n        { replyTo: MessageId(\"q1\") },\n      )\n\n      const replies = Arr.filterMap(calls, (c) =>\n        c._tag === \"Post\" ? Result.succeed(c.message.replyTo) : Result.failVoid,\n      )\n      expect(replies).toEqual([MessageId(\"q1\"), undefined])\n    }),\n  )\n\n  it.effect(\"posts nothing for a stream with no text\", () =>\n    Effect.gen(function* () {\n      const { id, calls } = yield* streamed([\"\", \"\"])\n\n      expect(calls).toEqual([])\n      expect(id).toEqual(Option.none())\n    }),\n  )\n\n  // A model opening a tool-calling turn with a newline, which every platform\n  // rejects as an empty message.\n  it.effect(\"treats whitespace-only deltas as no text at all\", () =>\n    Effect.gen(function* () {\n      const { id, calls } = yield* streamed([\"\\n\", \"  \", \"\\n\\n\"])\n\n      expect(calls).toEqual([])\n      expect(id).toEqual(Option.none())\n    }),\n  )\n\n  it.live(\"waits out a rate limit and re-sends the same edit\", () =>\n    Effect.gen(function* () {\n      const limited = new MessengerRateLimited({\n        provider: \"mock\",\n        retryAfter: Duration.millis(10),\n      })\n      const { calls } = yield* streamed([\"abc\", \"defghij\"], {\n        ...options({ every: 0, minChars: 1 }),\n        failures: [undefined, limited],\n      })\n\n      expect(posts(calls)).toEqual([\"abc\"])\n      expect(edits(calls)).toEqual([\"abcdefghij\", \"abcdefghij\"])\n    }),\n  )\n\n  it.effect(\"gives up once the rate-limit budget is spent\", () =>\n    Effect.gen(function* () {\n      const limited = new MessengerRateLimited({ provider: \"mock\", retryAfter: Duration.zero })\n      const failed = yield* Effect.flip(\n        streamed([\"abc\"], { ...options({ rateLimitRetries: 1 }), failures: [limited, limited] }),\n      )\n\n      expect(failed._tag).toBe(\"MessengerRateLimited\")\n    }).pipe(TestClock.withLive),\n  )\n})\n"],"mappings":"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"}

package/dist/messenger/MessengerError.d.mts

@@ -0,0 +1,2 @@
+import { a as MessengerRateLimited, c as MessengerUnsupported, i as MessengerOperation, l as describe, n as MessengerError, o as MessengerRequestFailed, s as MessengerTransportClosed, t as MessengerConnectFailed } from "../MessengerError-CeK6VAcu.mjs";
+export { MessengerConnectFailed, MessengerError, MessengerOperation, MessengerRateLimited, MessengerRequestFailed, MessengerTransportClosed, MessengerUnsupported, describe };

package/dist/messenger/MessengerError.mjs

@@ -0,0 +1,39 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { Data, Match } from "effect";
+//#region src/messenger/MessengerError.ts
+var MessengerError_exports = /* @__PURE__ */ __exportAll({
+	MessengerConnectFailed: () => MessengerConnectFailed,
+	MessengerRateLimited: () => MessengerRateLimited,
+	MessengerRequestFailed: () => MessengerRequestFailed,
+	MessengerTransportClosed: () => MessengerTransportClosed,
+	MessengerUnsupported: () => MessengerUnsupported,
+	describe: () => describe
+});
+/** Transport never came up: bad token, rejected handshake. Raised at layer build. */
+var MessengerConnectFailed = class extends Data.TaggedError("MessengerConnectFailed") {};
+/**
+* Inbound transport ended for good (reconnect budget spent, fatal close).
+* Routine reconnects stay inside the adapter and never surface here.
+*/
+var MessengerTransportClosed = class extends Data.TaggedError("MessengerTransportClosed") {};
+/** An outbound verb was rejected: permission, unknown chat, text too long, no-op edit. */
+var MessengerRequestFailed = class extends Data.TaggedError("MessengerRequestFailed") {};
+/**
+* Slow down, for this long. Typed rather than retried blindly so callers -
+* `streamViaEdits` above all - decide whether waiting is still worth it.
+*/
+var MessengerRateLimited = class extends Data.TaggedError("MessengerRateLimited") {};
+/** The platform cannot express this at all: off-set reaction emoji, edits on WhatsApp. */
+var MessengerUnsupported = class extends Data.TaggedError("MessengerUnsupported") {};
+/** Human-readable description for logs. Prose, not a contract; branch on `_tag`. */
+const describe = Match.type().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}`
+}));
+//#endregion
+export { MessengerConnectFailed, MessengerRateLimited, MessengerRequestFailed, MessengerTransportClosed, MessengerUnsupported, describe, MessengerError_exports as t };
+
+//# sourceMappingURL=MessengerError.mjs.map

package/dist/messenger/MessengerError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerError.mjs","names":[],"sources":["../../src/messenger/MessengerError.ts"],"sourcesContent":["import { Data, type Duration, Match } from \"effect\"\n\n// `reason` is required wherever one exists: the platform always says\n// something, and an adapter raising `Unsupported` knows why it did.\n\n/** Transport never came up: bad token, rejected handshake. Raised at layer build. */\nexport class MessengerConnectFailed extends Data.TaggedError(\"MessengerConnectFailed\")<{\n  provider: string\n  reason: string\n  raw: unknown\n}> {}\n\n/**\n * Inbound transport ended for good (reconnect budget spent, fatal close).\n * Routine reconnects stay inside the adapter and never surface here.\n */\nexport class MessengerTransportClosed extends Data.TaggedError(\"MessengerTransportClosed\")<{\n  provider: string\n  reason: string\n  raw?: unknown\n}> {}\n\n/** Which verb was rejected. */\nexport type MessengerOperation = \"post\" | \"edit\" | \"react\" | \"typing\"\n\n/** An outbound verb was rejected: permission, unknown chat, text too long, no-op edit. */\nexport class MessengerRequestFailed extends Data.TaggedError(\"MessengerRequestFailed\")<{\n  provider: string\n  operation: MessengerOperation\n  reason: string\n  raw: unknown\n}> {}\n\n/**\n * Slow down, for this long. Typed rather than retried blindly so callers -\n * `streamViaEdits` above all - decide whether waiting is still worth it.\n */\nexport class MessengerRateLimited extends Data.TaggedError(\"MessengerRateLimited\")<{\n  provider: string\n  retryAfter: Duration.Duration\n  raw?: unknown\n}> {}\n\n/** The platform cannot express this at all: off-set reaction emoji, edits on WhatsApp. */\nexport class MessengerUnsupported extends Data.TaggedError(\"MessengerUnsupported\")<{\n  provider: string\n  capability: string\n  reason: string\n}> {}\n\nexport type MessengerError =\n  | MessengerConnectFailed\n  | MessengerTransportClosed\n  | MessengerRequestFailed\n  | MessengerRateLimited\n  | MessengerUnsupported\n\n/** Human-readable description for logs. Prose, not a contract; branch on `_tag`. */\nexport const describe: (e: MessengerError) => string = Match.type<MessengerError>().pipe(\n  Match.discriminatorsExhaustive(\"_tag\")({\n    MessengerConnectFailed: (e) => `the messenger could not connect: ${e.reason}`,\n    MessengerTransportClosed: (e) => `the messenger connection closed: ${e.reason}`,\n    MessengerRequestFailed: (e) => `the ${e.operation} was rejected: ${e.reason}`,\n    MessengerRateLimited: () => \"the messenger is rate limited\",\n    MessengerUnsupported: (e) => `this messenger does not support ${e.capability}: ${e.reason}`,\n  }),\n)\n"],"mappings":";;;;;;;;;;;;AAMA,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,CAAC,CAInF,CAAC;;;;;AAMJ,IAAa,2BAAb,cAA8C,KAAK,YAAY,0BAA0B,CAAC,CAIvF,CAAC;;AAMJ,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,CAAC,CAKnF,CAAC;;;;;AAMJ,IAAa,uBAAb,cAA0C,KAAK,YAAY,sBAAsB,CAAC,CAI/E,CAAC;;AAGJ,IAAa,uBAAb,cAA0C,KAAK,YAAY,sBAAsB,CAAC,CAI/E,CAAC;;AAUJ,MAAa,WAA0C,MAAM,KAAqB,CAAC,CAAC,KAClF,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,yBAAyB,MAAM,oCAAoC,EAAE;CACrE,2BAA2B,MAAM,oCAAoC,EAAE;CACvE,yBAAyB,MAAM,OAAO,EAAE,UAAU,iBAAiB,EAAE;CACrE,4BAA4B;CAC5B,uBAAuB,MAAM,mCAAmC,EAAE,WAAW,IAAI,EAAE;AACrF,CAAC,CACH"}

package/dist/music-generator/MusicGenerator.d.mts

@@ -1,6 +1,7 @@
+import { c as Watermark } from "../Media-BbX7BAaO.mjs";
 import { t as AiError } from "../AiError-eLV9t1lU.mjs";
-import { n as AudioChunk } from "../Audio-60lKKHxS.mjs";
-import { CommonGenerateMusicRequest, CommonStreamGenerateMusicRequest, GenerateResult, MusicResult, MusicSection, MusicSessionControl, MusicSessionInput, MusicStreamEvent, Watermark, WeightedPrompt } from "../domain/Music.mjs";
+import { n as AudioChunk } from "../Audio-_nGR4V0X.mjs";
+import { CommonGenerateMusicRequest, CommonStreamGenerateMusicRequest, GenerateResult, MusicResult, MusicSection, MusicSessionControl, MusicSessionInput, MusicStreamEvent, WeightedPrompt } from "../domain/Music.mjs";
 import { Context, Effect, Stream } from "effect";
 declare namespace MusicGenerator_d_exports {
   export { CommonGenerateMusicRequest, CommonStreamGenerateMusicRequest, GenerateResult, MusicGenerator, MusicGeneratorService, MusicInteractiveSession, MusicResult, MusicSection, MusicSessionControl, MusicSessionInput, MusicStreamEvent, Watermark, WeightedPrompt, generate, streamGeneration, streamGenerationFrom };

package/dist/music-generator/MusicGenerator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"MusicGenerator.d.mts","names":[],"sources":["../../src/music-generator/MusicGenerator.ts"],"mappings":";;;;;;;KAwBY;;;;;;;;;;WAUD,WACP,SAAS,+BACN,OAAO,OAAO,gBAAgB;;;;;;;WAO1B,mBACP,SAAS,qCACN,OAAO,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;WAuBtB,uBAAuB,GAAG,GACjC,OAAO,OAAO,OAAO,mBAAmB,GAAG,IAC3C,SAAS,qCACN,OAAO,OAAO,kBAAkB,UAAkB,GAAG;;;cAG/C,uBAAuB;;;;;;;;;;;;cAcvB,gCAAgC;;cAKhC,WAAQ,SACV,+BACR,OAAO,OAAO,gBAAgB,SAAiB;;cAIrC,mBAAgB,SAClB,qCACR,OAAO,OAAO,YAAY,SAAiB;;;;;;;;;;;;;;;;;;;;;;;;;cA2BjC;GAET,SAAS,oCACP,GAAG,GACL,OAAO,OAAO,OAAO,mBAAmB,GAAG,OACxC,OAAO,OACV,kBACA,UAAkB,GAClB,IAAI,iBAAiB;GAEtB,GAAG,GACF,OAAO,OAAO,OAAO,mBAAmB,GAAG,IAC3C,SAAS,mCACR,OAAO,OACR,kBACA,UAAkB,GAClB,IAAI,iBAAiB"}
+{"version":3,"file":"MusicGenerator.d.mts","names":[],"sources":["../../src/music-generator/MusicGenerator.ts"],"mappings":";;;;;;;;KAwBY;;;;;;;;;;WAUD,WACP,SAAS,+BACN,OAAO,OAAO,gBAAgB;;;;;;;WAO1B,mBACP,SAAS,qCACN,OAAO,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;WAuBtB,uBAAuB,GAAG,GACjC,OAAO,OAAO,OAAO,mBAAmB,GAAG,IAC3C,SAAS,qCACN,OAAO,OAAO,kBAAkB,UAAkB,GAAG;;;cAG/C,uBAAuB;;;;;;;;;;;;cAcvB,gCAAgC;;cAKhC,WAAQ,SACV,+BACR,OAAO,OAAO,gBAAgB,SAAiB;;cAIrC,mBAAgB,SAClB,qCACR,OAAO,OAAO,YAAY,SAAiB;;;;;;;;;;;;;;;;;;;;;;;;;cA2BjC;GAET,SAAS,oCACP,GAAG,GACL,OAAO,OAAO,OAAO,mBAAmB,GAAG,OACxC,OAAO,OACV,kBACA,UAAkB,GAClB,IAAI,iBAAiB;GAEtB,GAAG,GACF,OAAO,OAAO,OAAO,mBAAmB,GAAG,IAC3C,SAAS,mCACR,OAAO,OACR,kBACA,UAAkB,GAClB,IAAI,iBAAiB"}

package/dist/observability/Metrics.d.mts

@@ -1,4 +1,4 @@
-import { x as Usage } from "../Items-SfUabNuB.mjs";
+import { S as Usage } from "../Items-C7MyrYPX.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
 import { Duration, Effect, Option, Stream } from "effect";
 declare namespace Metrics_d_exports {

package/dist/speech-synthesizer/SpeechSynthesizer.d.mts

@@ -1,5 +1,5 @@
 import { t as AiError } from "../AiError-eLV9t1lU.mjs";
-import { n as AudioChunk, r as AudioFormat, t as AudioBlob } from "../Audio-60lKKHxS.mjs";
+import { n as AudioChunk, r as AudioFormat, t as AudioBlob } from "../Audio-_nGR4V0X.mjs";
 import { Context, Effect, Stream } from "effect";
 declare namespace SpeechSynthesizer_d_exports {
   export { CommonStreamSynthesizeRequest, CommonSynthesizeDialogueRequest, CommonSynthesizeRequest, CustomPronunciation, DialogueTurn, MultiSpeakerTts, SpeechSynthesizer, SpeechSynthesizerService, TtsIncrementalText, streamSynthesis, streamSynthesisFrom, streamSynthesizeDialogue, synthesize, synthesizeDialogue };

package/dist/streaming/Multipart.d.mts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { HttpClientRequest } from "effect/unstable/http";
+declare namespace Multipart_d_exports {
+  export { bodyMultipart };
+}
+/**
+ * Multipart body for an `HttpClientRequest`, encoded to bytes.
+ *
+ * Use this over `HttpClientRequest.bodyFormData`: the Undici client
+ * passes the `FormData` object straight to `dispatcher.request`, which
+ * cannot serialise it, so the request is never sent and the effect
+ * hangs with no error. Encoding here produces the same bytes every
+ * other client derives internally, so it works on all of them.
+ *
+ * The failure is whatever `Response.arrayBuffer` rejects with; map it
+ * to your provider's transport error at the call site.
+ */
+declare const bodyMultipart: (form: FormData) => Effect.Effect<(request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest, unknown>;
+//#endregion
+export { bodyMultipart, Multipart_d_exports as t };
+//# sourceMappingURL=Multipart.d.mts.map

package/dist/streaming/Multipart.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multipart.d.mts","names":[],"sources":["../../src/streaming/Multipart.ts"],"mappings":";;;;;;;;;;;;;;;;;cAea,gBAAa,MAClB,aACL,OAAO,QACP,SAAS,kBAAkB,sBAAsB,kBAAkB"}

package/dist/streaming/Multipart.mjs

@@ -0,0 +1,26 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { Effect } from "effect";
+import { HttpClientRequest } from "effect/unstable/http";
+//#region src/streaming/Multipart.ts
+var Multipart_exports = /* @__PURE__ */ __exportAll({ bodyMultipart: () => bodyMultipart });
+/**
+* Multipart body for an `HttpClientRequest`, encoded to bytes.
+*
+* Use this over `HttpClientRequest.bodyFormData`: the Undici client
+* passes the `FormData` object straight to `dispatcher.request`, which
+* cannot serialise it, so the request is never sent and the effect
+* hangs with no error. Encoding here produces the same bytes every
+* other client derives internally, so it works on all of them.
+*
+* The failure is whatever `Response.arrayBuffer` rejects with; map it
+* to your provider's transport error at the call site.
+*/
+const bodyMultipart = (form) => Effect.gen(function* () {
+	const encoded = new Response(form);
+	const buffer = yield* Effect.tryPromise(() => encoded.arrayBuffer());
+	return HttpClientRequest.bodyUint8Array(new Uint8Array(buffer), encoded.headers.get("content-type") ?? "multipart/form-data");
+});
+//#endregion
+export { bodyMultipart, Multipart_exports as t };
+
+//# sourceMappingURL=Multipart.mjs.map

package/dist/streaming/Multipart.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multipart.mjs","names":[],"sources":["../../src/streaming/Multipart.ts"],"sourcesContent":["import { Effect } from \"effect\"\nimport { HttpClientRequest } from \"effect/unstable/http\"\n\n/**\n * Multipart body for an `HttpClientRequest`, encoded to bytes.\n *\n * Use this over `HttpClientRequest.bodyFormData`: the Undici client\n * passes the `FormData` object straight to `dispatcher.request`, which\n * cannot serialise it, so the request is never sent and the effect\n * hangs with no error. Encoding here produces the same bytes every\n * other client derives internally, so it works on all of them.\n *\n * The failure is whatever `Response.arrayBuffer` rejects with; map it\n * to your provider's transport error at the call site.\n */\nexport const bodyMultipart = (\n  form: FormData,\n): Effect.Effect<\n  (request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest,\n  unknown\n> =>\n  Effect.gen(function* () {\n    const encoded = new Response(form)\n    const buffer = yield* Effect.tryPromise(() => encoded.arrayBuffer())\n    return HttpClientRequest.bodyUint8Array(\n      new Uint8Array(buffer),\n      encoded.headers.get(\"content-type\") ?? \"multipart/form-data\",\n    )\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAa,iBACX,SAKA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,IAAI,SAAS,IAAI;CACjC,MAAM,SAAS,OAAO,OAAO,iBAAiB,QAAQ,YAAY,CAAC;CACnE,OAAO,kBAAkB,eACvB,IAAI,WAAW,MAAM,GACrB,QAAQ,QAAQ,IAAI,cAAc,KAAK,qBACzC;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"}