@effect-uai/core 0.2.0 → 0.4.0

package/dist/music-generator/MusicGenerator.test.mjs

@@ -0,0 +1,154 @@
+import { configInput, promptsInput } from "../domain/Music.mjs";
+import { generate, streamGeneration, streamGenerationFrom } from "./MusicGenerator.mjs";
+import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { layer, layerWithoutInteractive } from "../testing/MockMusicGenerator.mjs";
+import { Effect, Stream } from "effect";
+//#region src/music-generator/MusicGenerator.test.ts
+const result = {
+	format: {
+		container: "mp3",
+		encoding: "mp3",
+		sampleRate: 44100,
+		channels: 2
+	},
+	bytes: new Uint8Array([
+		255,
+		251,
+		144,
+		0
+	]),
+	durationSeconds: 30,
+	lyrics: "[Verse]\nhello\n",
+	watermark: { kind: "synthid" }
+};
+const chunk = (n) => ({ bytes: new Uint8Array([n]) });
+describe("MusicGenerator.generate", () => {
+	it("returns the scripted MusicResult", async () => {
+		const mock = layer({ results: [result] });
+		const program = generate({
+			model: "mock-music",
+			prompts: "upbeat indie pop"
+		});
+		const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(out.bytes).toEqual(result.bytes);
+		globalExpect(out.durationSeconds).toBe(30);
+		globalExpect(out.watermark?.kind).toBe("synthid");
+		globalExpect(out.lyrics).toContain("[Verse]");
+	});
+	it("records the request shape on the recorder", async () => {
+		const mock = layer({ results: [result, result] });
+		const program = Effect.gen(function* () {
+			yield* generate({
+				model: "m",
+				prompts: "techno"
+			});
+			yield* generate({
+				model: "m",
+				prompts: [{
+					text: "synthwave",
+					weight: 1
+				}, {
+					text: "80s movie OST",
+					weight: .4
+				}],
+				bpm: 120,
+				instrumental: true
+			});
+			return yield* mock.recorder;
+		});
+		const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(rec.generateCalls.length).toBe(2);
+		globalExpect(rec.generateCalls[1].bpm).toBe(120);
+		globalExpect(rec.generateCalls[1].instrumental).toBe(true);
+		globalExpect(Array.isArray(rec.generateCalls[1].prompts)).toBe(true);
+	});
+});
+describe("MusicGenerator.streamGeneration", () => {
+	it("emits scripted chunks", async () => {
+		const mock = layer({ streamGenerationChunks: [[
+			chunk(1),
+			chunk(2),
+			chunk(3)
+		]] });
+		const program = Stream.runCollect(streamGeneration({
+			model: "m",
+			prompts: "ambient"
+		}));
+		globalExpect((await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))).map((c) => Array.from(c.bytes))).toEqual([
+			[1],
+			[2],
+			[3]
+		]);
+	});
+});
+describe("MusicGenerator capability marker (compile-time)", () => {
+	const sgfReq = {
+		model: "m",
+		prompts: ""
+	};
+	it("requires `MusicInteractiveSession` on the R channel of streamGenerationFrom", () => {
+		(0, import_dist.expectTypeOf)(Stream.fromIterable([promptsInput([{ text: "techno" }])]).pipe(streamGenerationFrom(sgfReq))).toEqualTypeOf();
+	});
+	it("does NOT require `MusicInteractiveSession` for sync `generate`", () => {
+		(0, import_dist.expectTypeOf)(generate({
+			model: "m",
+			prompts: "ambient"
+		})).toEqualTypeOf();
+	});
+	it("does NOT require `MusicInteractiveSession` for `streamGeneration`", () => {
+		(0, import_dist.expectTypeOf)(streamGeneration({
+			model: "m",
+			prompts: "ambient"
+		})).toEqualTypeOf();
+	});
+	it("a layer without the marker leaves `MusicInteractiveSession` unsatisfied in R", () => {
+		const noMarker = layerWithoutInteractive({});
+		const audio = Stream.fromIterable([promptsInput([{ text: "techno" }])]).pipe(streamGenerationFrom(sgfReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))).toEqualTypeOf();
+	});
+	it("a full layer (with marker) clears R to never", () => {
+		const fullMock = layer({ streamGenerationFromChunks: [[]] });
+		const audio = Stream.fromIterable([promptsInput([{ text: "techno" }])]).pipe(streamGenerationFrom(sgfReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))).toEqualTypeOf();
+	});
+});
+describe("MusicGenerator.streamGenerationFrom", () => {
+	const sgfReq = {
+		model: "lyria-realtime-001",
+		prompts: ""
+	};
+	it("drains a session-input stream and emits scripted audio", async () => {
+		const mock = layer({ streamGenerationFromChunks: [[chunk(10), chunk(20)]] });
+		const audio = Stream.fromIterable([
+			promptsInput([{
+				text: "minimal techno",
+				weight: 1
+			}]),
+			configInput({ bpm: 124 }),
+			promptsInput([{
+				text: "minimal techno",
+				weight: 1
+			}, {
+				text: "1980s synthwave",
+				weight: .3
+			}])
+		]).pipe(streamGenerationFrom(sgfReq));
+		globalExpect((await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))).map((c) => Array.from(c.bytes))).toEqual([[10], [20]]);
+	});
+	it("records the request on the streamGenerationFrom call channel", async () => {
+		const mock = layer({ streamGenerationFromChunks: [[chunk(42)]] });
+		const program = Effect.gen(function* () {
+			yield* Stream.runDrain(Stream.fromIterable([promptsInput([{ text: "x" }])]).pipe(streamGenerationFrom(sgfReq)));
+			return yield* mock.recorder;
+		});
+		const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(rec.streamGenerationFromCalls.length).toBe(1);
+		globalExpect(rec.streamGenerationFromCalls[0].model).toBe("lyria-realtime-001");
+		globalExpect(rec.generateCalls.length).toBe(0);
+		globalExpect(rec.streamGenerationCalls.length).toBe(0);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=MusicGenerator.test.mjs.map

package/dist/music-generator/MusicGenerator.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MusicGenerator.test.mjs","names":["MockMusicGenerator.layer","MusicGenerator.generate","MusicGenerator.streamGeneration","MusicGenerator.streamGenerationFrom","MockMusicGenerator.layerWithoutInteractive"],"sources":["../../src/music-generator/MusicGenerator.test.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type { AudioChunk, AudioFormat } from \"../domain/Audio.js\"\nimport { configInput, promptsInput, type MusicResult } from \"../domain/Music.js\"\nimport * as MockMusicGenerator from \"../testing/MockMusicGenerator.js\"\nimport * as MusicGenerator from \"./MusicGenerator.js\"\n\nconst mp3Format: AudioFormat = {\n  container: \"mp3\",\n  encoding: \"mp3\",\n  sampleRate: 44100,\n  channels: 2,\n}\n\nconst result: MusicResult = {\n  format: mp3Format,\n  bytes: new Uint8Array([0xff, 0xfb, 0x90, 0x00]),\n  durationSeconds: 30,\n  lyrics: \"[Verse]\\nhello\\n\",\n  watermark: { kind: \"synthid\" },\n}\n\nconst chunk = (n: number): AudioChunk => ({ bytes: new Uint8Array([n]) })\n\ndescribe(\"MusicGenerator.generate\", () => {\n  it(\"returns the scripted MusicResult\", async () => {\n    const mock = MockMusicGenerator.layer({ results: [result] })\n    const program = MusicGenerator.generate({\n      model: \"mock-music\",\n      prompts: \"upbeat indie pop\",\n    })\n    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(out.bytes).toEqual(result.bytes)\n    expect(out.durationSeconds).toBe(30)\n    expect(out.watermark?.kind).toBe(\"synthid\")\n    expect(out.lyrics).toContain(\"[Verse]\")\n  })\n\n  it(\"records the request shape on the recorder\", async () => {\n    const mock = MockMusicGenerator.layer({ results: [result, result] })\n    const program = Effect.gen(function* () {\n      yield* MusicGenerator.generate({ model: \"m\", prompts: \"techno\" })\n      yield* MusicGenerator.generate({\n        model: \"m\",\n        prompts: [\n          { text: \"synthwave\", weight: 1.0 },\n          { text: \"80s movie OST\", weight: 0.4 },\n        ],\n        bpm: 120,\n        instrumental: true,\n      })\n      return yield* mock.recorder\n    })\n    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(rec.generateCalls.length).toBe(2)\n    expect(rec.generateCalls[1]!.bpm).toBe(120)\n    expect(rec.generateCalls[1]!.instrumental).toBe(true)\n    expect(Array.isArray(rec.generateCalls[1]!.prompts)).toBe(true)\n  })\n})\n\ndescribe(\"MusicGenerator.streamGeneration\", () => {\n  it(\"emits scripted chunks\", async () => {\n    const mock = MockMusicGenerator.layer({\n      streamGenerationChunks: [[chunk(1), chunk(2), chunk(3)]],\n    })\n    const program = Stream.runCollect(\n      MusicGenerator.streamGeneration({ model: \"m\", prompts: \"ambient\" }),\n    )\n    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(out.map((c) => Array.from(c.bytes))).toEqual([[1], [2], [3]])\n  })\n})\n\ndescribe(\"MusicGenerator capability marker (compile-time)\", () => {\n  const sgfReq: MusicGenerator.CommonStreamGenerateMusicRequest = {\n    model: \"m\",\n    prompts: \"\",\n  }\n\n  it(\"requires `MusicInteractiveSession` on the R channel of streamGenerationFrom\", () => {\n    const inputs = Stream.fromIterable([promptsInput([{ text: \"techno\" }])])\n    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))\n    expectTypeOf(audio).toEqualTypeOf<\n      Stream.Stream<\n        AudioChunk,\n        AiError.AiError,\n        MusicGenerator.MusicGenerator | MusicGenerator.MusicInteractiveSession\n      >\n    >()\n  })\n\n  it(\"does NOT require `MusicInteractiveSession` for sync `generate`\", () => {\n    const eff = MusicGenerator.generate({ model: \"m\", prompts: \"ambient\" })\n    expectTypeOf(eff).toEqualTypeOf<\n      Effect.Effect<MusicResult, AiError.AiError, MusicGenerator.MusicGenerator>\n    >()\n  })\n\n  it(\"does NOT require `MusicInteractiveSession` for `streamGeneration`\", () => {\n    const audio = MusicGenerator.streamGeneration({ model: \"m\", prompts: \"ambient\" })\n    expectTypeOf(audio).toEqualTypeOf<\n      Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator.MusicGenerator>\n    >()\n  })\n\n  it(\"a layer without the marker leaves `MusicInteractiveSession` unsatisfied in R\", () => {\n    const noMarker = MockMusicGenerator.layerWithoutInteractive({})\n    const inputs = Stream.fromIterable([promptsInput([{ text: \"techno\" }])])\n    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))\n    const program = Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))\n    expectTypeOf(program).toEqualTypeOf<\n      Effect.Effect<void, AiError.AiError, MusicGenerator.MusicInteractiveSession>\n    >()\n  })\n\n  it(\"a full layer (with marker) clears R to never\", () => {\n    const fullMock = MockMusicGenerator.layer({\n      streamGenerationFromChunks: [[]],\n    })\n    const inputs = Stream.fromIterable([promptsInput([{ text: \"techno\" }])])\n    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))\n    const program = Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))\n    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()\n  })\n})\n\ndescribe(\"MusicGenerator.streamGenerationFrom\", () => {\n  const sgfReq: MusicGenerator.CommonStreamGenerateMusicRequest = {\n    model: \"lyria-realtime-001\",\n    prompts: \"\",\n  }\n\n  it(\"drains a session-input stream and emits scripted audio\", async () => {\n    const mock = MockMusicGenerator.layer({\n      streamGenerationFromChunks: [[chunk(10), chunk(20)]],\n    })\n    const inputs = Stream.fromIterable([\n      promptsInput([{ text: \"minimal techno\", weight: 1.0 }]),\n      configInput({ bpm: 124 }),\n      promptsInput([\n        { text: \"minimal techno\", weight: 1.0 },\n        { text: \"1980s synthwave\", weight: 0.3 },\n      ]),\n    ])\n    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))\n    const out = await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))\n    expect(out.map((c) => Array.from(c.bytes))).toEqual([[10], [20]])\n  })\n\n  it(\"records the request on the streamGenerationFrom call channel\", async () => {\n    const mock = MockMusicGenerator.layer({\n      streamGenerationFromChunks: [[chunk(42)]],\n    })\n    const program = Effect.gen(function* () {\n      yield* Stream.runDrain(\n        Stream.fromIterable([promptsInput([{ text: \"x\" }])]).pipe(\n          MusicGenerator.streamGenerationFrom(sgfReq),\n        ),\n      )\n      return yield* mock.recorder\n    })\n    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(rec.streamGenerationFromCalls.length).toBe(1)\n    expect(rec.streamGenerationFromCalls[0]!.model).toBe(\"lyria-realtime-001\")\n    expect(rec.generateCalls.length).toBe(0)\n    expect(rec.streamGenerationCalls.length).toBe(0)\n  })\n})\n"],"mappings":"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"}

package/dist/observability/Metrics.d.mts

@@ -22,12 +22,12 @@ declare const withElapsed: <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Str
  * branch.
  */
 declare const timeToFirst: <A>(predicate: (a: A) => boolean) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<Option.Option<Duration.Duration>, E, R>;
-interface RatePoint<A> {
+type RatePoint<A> = {
   readonly value: A;
   readonly total: number;
   readonly ratePerSecond: number;
   readonly elapsed: Duration.Duration;
-}
+};
 /**
  * Annotate every event with a running total and a rolling rate per second,
  * computed from a user-supplied weight function.

package/dist/observability/Metrics.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Metrics.d.mts","names":[],"sources":["../../src/observability/Metrics.ts"],"mappings":";;;;;;;;;;;cAOa,WAAA,YACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MACzB,MAAA,CAAO,MAAA;EAAA,SAAkB,KAAA,EAAO,CAAA;EAAA,SAAY,OAAA,EAAS,QAAA,CAAS,QAAA;AAAA,GAAY,CAAA,EAAG,CAAA;AAFhF;;;;;;;;AAAA,cAwBa,WAAA,MACP,SAAA,GAAY,CAAA,EAAG,CAAA,wBACZ,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,QAAA,GAAW,CAAA,EAAG,CAAA;AAAA,UAO1E,SAAA;EAAA,SACN,KAAA,EAAO,CAAA;EAAA,SACP,KAAA;EAAA,SACA,aAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,QAAA;AAAA;;;;;;;;;;;;cAchB,QAAA,MACP,MAAA,GAAS,CAAA,EAAG,CAAA,uBACT,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,CAAA"}
+{"version":3,"file":"Metrics.d.mts","names":[],"sources":["../../src/observability/Metrics.ts"],"mappings":";;;;;;;;;;;cAOa,WAAA,YACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MACzB,MAAA,CAAO,MAAA;EAAA,SAAkB,KAAA,EAAO,CAAA;EAAA,SAAY,OAAA,EAAS,QAAA,CAAS,QAAA;AAAA,GAAY,CAAA,EAAG,CAAA;AAFhF;;;;;;;;AAAA,cAwBa,WAAA,MACP,SAAA,GAAY,CAAA,EAAG,CAAA,wBACZ,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,QAAA,GAAW,CAAA,EAAG,CAAA;AAAA,KAO/E,SAAA;EAAA,SACD,KAAA,EAAO,CAAA;EAAA,SACP,KAAA;EAAA,SACA,aAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,QAAA;AAAA;;;;;;;;;;;;cAchB,QAAA,MACP,MAAA,GAAS,CAAA,EAAG,CAAA,uBACT,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,CAAA"}

package/dist/observability/Metrics.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Clock, Duration, Effect, Option, Stream } from "effect";
 //#region src/observability/Metrics.ts
 var Metrics_exports = /* @__PURE__ */ __exportAll({

package/dist/observability/Metrics.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Metrics.mjs","names":[],"sources":["../../src/observability/Metrics.ts"],"sourcesContent":["import { Clock, Duration, Effect, Option, Stream } from \"effect\"\n\n/**\n * Annotate every event in a stream with the elapsed `Duration` since the\n * stream started consuming. The first event reports its time-from-start,\n * which is also the conventional \"time to first ____\" metric.\n */\nexport const withElapsed = <A, E, R>(\n  self: Stream.Stream<A, E, R>,\n): Stream.Stream<{ readonly value: A; readonly elapsed: Duration.Duration }, E, R> =>\n  Stream.unwrap(\n    Effect.map(Clock.currentTimeMillis, (start) =>\n      self.pipe(\n        Stream.mapEffect((value) =>\n          Effect.map(Clock.currentTimeMillis, (now) => ({\n            value,\n            elapsed: Duration.millis(now - start),\n          })),\n        ),\n      ),\n    ),\n  )\n\n/**\n * Compute the elapsed time until the first event matching the predicate.\n * Returns `Option.none()` if the stream completes without one.\n *\n * Consumes the stream. To track this *alongside* live consumption, use\n * `Stream.broadcast` to fan the source out and run `timeToFirst` on one\n * branch.\n */\nexport const timeToFirst =\n  <A>(predicate: (a: A) => boolean) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<Duration.Duration>, E, R> =>\n    withElapsed(self).pipe(\n      Stream.filter(({ value }) => predicate(value)),\n      Stream.runHead,\n      Effect.map(Option.map(({ elapsed }) => elapsed)),\n    )\n\nexport interface RatePoint<A> {\n  readonly value: A\n  readonly total: number\n  readonly ratePerSecond: number\n  readonly elapsed: Duration.Duration\n}\n\n/**\n * Annotate every event with a running total and a rolling rate per second,\n * computed from a user-supplied weight function.\n *\n * The weight is the unit you care about - bytes, tokens, error count, etc.\n * For tokens-per-second on `TurnEvent`, pass:\n *\n *   `(d) => d.type === \"text_delta\" ? countTokens(d.text) : 0`\n *\n * Use any tokenizer you like; the library does not ship one.\n */\nexport const withRate =\n  <A>(weight: (a: A) => number) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<RatePoint<A>, E, R> =>\n    Stream.unwrap(\n      Effect.map(Clock.currentTimeMillis, (start) =>\n        self.pipe(\n          Stream.mapAccumEffect(\n            () => ({ total: 0 }),\n            (acc, value) =>\n              Effect.map(Clock.currentTimeMillis, (now) => {\n                const total = acc.total + weight(value)\n                const elapsedMs = now - start\n                const ratePerSecond = elapsedMs > 0 ? (total / elapsedMs) * 1000 : 0\n                return [\n                  { total },\n                  [\n                    {\n                      value,\n                      total,\n                      ratePerSecond,\n                      elapsed: Duration.millis(elapsedMs),\n                    } satisfies RatePoint<A>,\n                  ],\n                ] as const\n              }),\n          ),\n        ),\n      ),\n    )\n"],"mappings":";;;;;;;;;;;;;AAOA,MAAa,eACX,SAEA,OAAO,OACL,OAAO,IAAI,MAAM,oBAAoB,UACnC,KAAK,KACH,OAAO,WAAW,UAChB,OAAO,IAAI,MAAM,oBAAoB,SAAS;CAC5C;CACA,SAAS,SAAS,OAAO,MAAM,MAAM;CACtC,EAAE,CACJ,CACF,CACF,CACF;;;;;;;;;AAUH,MAAa,eACP,eACG,SACL,YAAY,KAAK,CAAC,KAChB,OAAO,QAAQ,EAAE,YAAY,UAAU,MAAM,CAAC,EAC9C,OAAO,SACP,OAAO,IAAI,OAAO,KAAK,EAAE,cAAc,QAAQ,CAAC,CACjD;;;;;;;;;;;;AAoBL,MAAa,YACP,YACG,SACL,OAAO,OACL,OAAO,IAAI,MAAM,oBAAoB,UACnC,KAAK,KACH,OAAO,sBACE,EAAE,OAAO,GAAG,IAClB,KAAK,UACJ,OAAO,IAAI,MAAM,oBAAoB,QAAQ;CAC3C,MAAM,QAAQ,IAAI,QAAQ,OAAO,MAAM;CACvC,MAAM,YAAY,MAAM;CACxB,MAAM,gBAAgB,YAAY,IAAK,QAAQ,YAAa,MAAO;AACnE,QAAO,CACL,EAAE,OAAO,EACT,CACE;EACE;EACA;EACA;EACA,SAAS,SAAS,OAAO,UAAU;EACpC,CACF,CACF;EACD,CACL,CACF,CACF,CACF"}
+{"version":3,"file":"Metrics.mjs","names":[],"sources":["../../src/observability/Metrics.ts"],"sourcesContent":["import { Clock, Duration, Effect, Option, Stream } from \"effect\"\n\n/**\n * Annotate every event in a stream with the elapsed `Duration` since the\n * stream started consuming. The first event reports its time-from-start,\n * which is also the conventional \"time to first ____\" metric.\n */\nexport const withElapsed = <A, E, R>(\n  self: Stream.Stream<A, E, R>,\n): Stream.Stream<{ readonly value: A; readonly elapsed: Duration.Duration }, E, R> =>\n  Stream.unwrap(\n    Effect.map(Clock.currentTimeMillis, (start) =>\n      self.pipe(\n        Stream.mapEffect((value) =>\n          Effect.map(Clock.currentTimeMillis, (now) => ({\n            value,\n            elapsed: Duration.millis(now - start),\n          })),\n        ),\n      ),\n    ),\n  )\n\n/**\n * Compute the elapsed time until the first event matching the predicate.\n * Returns `Option.none()` if the stream completes without one.\n *\n * Consumes the stream. To track this *alongside* live consumption, use\n * `Stream.broadcast` to fan the source out and run `timeToFirst` on one\n * branch.\n */\nexport const timeToFirst =\n  <A>(predicate: (a: A) => boolean) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<Duration.Duration>, E, R> =>\n    withElapsed(self).pipe(\n      Stream.filter(({ value }) => predicate(value)),\n      Stream.runHead,\n      Effect.map(Option.map(({ elapsed }) => elapsed)),\n    )\n\nexport type RatePoint<A> = {\n  readonly value: A\n  readonly total: number\n  readonly ratePerSecond: number\n  readonly elapsed: Duration.Duration\n}\n\n/**\n * Annotate every event with a running total and a rolling rate per second,\n * computed from a user-supplied weight function.\n *\n * The weight is the unit you care about - bytes, tokens, error count, etc.\n * For tokens-per-second on `TurnEvent`, pass:\n *\n *   `(d) => d.type === \"text_delta\" ? countTokens(d.text) : 0`\n *\n * Use any tokenizer you like; the library does not ship one.\n */\nexport const withRate =\n  <A>(weight: (a: A) => number) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<RatePoint<A>, E, R> =>\n    Stream.unwrap(\n      Effect.map(Clock.currentTimeMillis, (start) =>\n        self.pipe(\n          Stream.mapAccumEffect(\n            () => ({ total: 0 }),\n            (acc, value) =>\n              Effect.map(Clock.currentTimeMillis, (now) => {\n                const total = acc.total + weight(value)\n                const elapsedMs = now - start\n                const ratePerSecond = elapsedMs > 0 ? (total / elapsedMs) * 1000 : 0\n                return [\n                  { total },\n                  [\n                    {\n                      value,\n                      total,\n                      ratePerSecond,\n                      elapsed: Duration.millis(elapsedMs),\n                    } satisfies RatePoint<A>,\n                  ],\n                ] as const\n              }),\n          ),\n        ),\n      ),\n    )\n"],"mappings":";;;;;;;;;;;;;AAOA,MAAa,eACX,SAEA,OAAO,OACL,OAAO,IAAI,MAAM,oBAAoB,UACnC,KAAK,KACH,OAAO,WAAW,UAChB,OAAO,IAAI,MAAM,oBAAoB,SAAS;CAC5C;CACA,SAAS,SAAS,OAAO,MAAM,MAAM;CACtC,EAAE,CACJ,CACF,CACF,CACF;;;;;;;;;AAUH,MAAa,eACP,eACG,SACL,YAAY,KAAK,CAAC,KAChB,OAAO,QAAQ,EAAE,YAAY,UAAU,MAAM,CAAC,EAC9C,OAAO,SACP,OAAO,IAAI,OAAO,KAAK,EAAE,cAAc,QAAQ,CAAC,CACjD;;;;;;;;;;;;AAoBL,MAAa,YACP,YACG,SACL,OAAO,OACL,OAAO,IAAI,MAAM,oBAAoB,UACnC,KAAK,KACH,OAAO,sBACE,EAAE,OAAO,GAAG,IAClB,KAAK,UACJ,OAAO,IAAI,MAAM,oBAAoB,QAAQ;CAC3C,MAAM,QAAQ,IAAI,QAAQ,OAAO,MAAM;CACvC,MAAM,YAAY,MAAM;CACxB,MAAM,gBAAgB,YAAY,IAAK,QAAQ,YAAa,MAAO;AACnE,QAAO,CACL,EAAE,OAAO,EACT,CACE;EACE;EACA;EACA;EACA,SAAS,SAAS,OAAO,UAAU;EACpC,CACF,CACF;EACD,CACL,CACF,CACF,CACF"}

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

@@ -0,0 +1,96 @@
+import { t as AiError } from "../AiError-csR8Bhxx.mjs";
+import { n as AudioChunk, r as AudioFormat, t as AudioBlob } from "../Audio-BfCTGnH3.mjs";
+import { Context, Effect, Stream } from "effect";
+
+//#region src/speech-synthesizer/SpeechSynthesizer.d.ts
+declare namespace SpeechSynthesizer_d_exports {
+  export { CommonStreamSynthesizeRequest, CommonSynthesizeRequest, SpeechSynthesizer, SpeechSynthesizerService, TtsIncrementalText, streamSynthesis, streamSynthesisFrom, synthesize };
+}
+/**
+ * Cross-provider synthesis request. Provider-specific extensions
+ * (ElevenLabs `stability` / `similarity_boost`, Cartesia `emotion`,
+ * MiniMax `vol` / `pitch`, Azure SSML style tags) live on each
+ * provider's typed request which extends this and narrows `model` and
+ * `voiceId`.
+ */
+type CommonSynthesizeRequest = {
+  readonly text: string; /** Model identifier. Each provider narrows. */
+  readonly model: string;
+  /**
+   * Voice identifier. Per-provider request types narrow this to a
+   * typed literal union of stock voices + `(string & {})` escape for
+   * custom cloned voice IDs. Providers without custom-voice support
+   * (OpenAI, Deepgram Aura, AWS Polly) narrow to the stock-only union.
+   */
+  readonly voiceId: string;
+  readonly outputFormat?: AudioFormat;
+  readonly speed?: number;
+  readonly languageCode?: string;
+};
+/**
+ * Incremental-synthesis request — text arrives as `Stream<string>`.
+ * Gated by the `TtsIncrementalText` capability marker; only providers
+ * that ship the marker can be used.
+ *
+ * Multi-context features (Cartesia `context_id`, ElevenLabs `multi-
+ * stream-input`) are NOT exposed here — one logical utterance per
+ * call. Provider extensions can expose `forkContext` for that.
+ */
+type CommonStreamSynthesizeRequest = Omit<CommonSynthesizeRequest, "text">;
+type SpeechSynthesizerService = {
+  /** One-shot. Full text in, full audio bytes out. Universally supported. */readonly synthesize: (request: CommonSynthesizeRequest) => Effect.Effect<AudioBlob, AiError>;
+  /**
+   * Full text in, audio chunks streamed out (chunked HTTP). Universally
+   * supported across providers that offer any streaming TTS at all.
+   */
+  readonly streamSynthesis: (request: CommonSynthesizeRequest) => Stream.Stream<AudioChunk, AiError>;
+  /**
+   * Incremental text in (as a Stream), audio chunks streamed out. The
+   * underlying WS connection is acquired on first pull and released
+   * when the output stream is finalized via `Stream.scoped`.
+   *
+   * Gated by the `TtsIncrementalText` capability marker on the top-
+   * level helper — providers without WS-style incremental input don't
+   * ship the marker, so calls fail at `Effect.provide` with a type
+   * error.
+   */
+  readonly streamSynthesisFrom: <E, R>(textIn: Stream.Stream<string, E, R>, request: CommonStreamSynthesizeRequest) => Stream.Stream<AudioChunk, AiError | E, R>;
+};
+declare const SpeechSynthesizer_base: Context.ServiceClass<SpeechSynthesizer, "@betalyra/effect-uai/SpeechSynthesizer", SpeechSynthesizerService>;
+declare class SpeechSynthesizer extends SpeechSynthesizer_base {}
+declare const TtsIncrementalText_base: Context.ServiceClass<TtsIncrementalText, "@betalyra/effect-uai/capability/TtsIncrementalText", void>;
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamSynthesisFrom` is wired up at the wire level. OpenAI, Azure
+ * (wire), and AWS Polly non-Generative do not ship it. Calling
+ * `streamSynthesisFrom` while only one of those Layers is in scope
+ * fails at `Effect.provide` with a type error.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(TtsIncrementalText, undefined)`.
+ */
+declare class TtsIncrementalText extends TtsIncrementalText_base {}
+/** One-shot synthesis. */
+declare const synthesize: (request: CommonSynthesizeRequest) => Effect.Effect<AudioBlob, AiError, SpeechSynthesizer>;
+/** Full text in, audio chunks out. */
+declare const streamSynthesis: (request: CommonSynthesizeRequest) => Stream.Stream<AudioChunk, AiError, SpeechSynthesizer>;
+/**
+ * Incremental synthesis. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `TtsIncrementalText` in R — providers without
+ * incremental-text-in support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * const audio = LanguageModel.streamTurn(turnReq).pipe(
+ *   Stream.filterMap(Turn.toTextDelta),
+ *   SpeechSynthesizer.streamSynthesisFrom(synthReq),
+ * )
+ * ```
+ */
+declare const streamSynthesisFrom: {
+  (request: CommonStreamSynthesizeRequest): <E, R>(textIn: Stream.Stream<string, E, R>) => Stream.Stream<AudioChunk, AiError | E, R | SpeechSynthesizer | TtsIncrementalText>;
+  <E, R>(textIn: Stream.Stream<string, E, R>, request: CommonStreamSynthesizeRequest): Stream.Stream<AudioChunk, AiError | E, R | SpeechSynthesizer | TtsIncrementalText>;
+};
+//#endregion
+export { CommonStreamSynthesizeRequest, CommonSynthesizeRequest, SpeechSynthesizer, SpeechSynthesizerService, TtsIncrementalText, streamSynthesis, streamSynthesisFrom, synthesize, SpeechSynthesizer_d_exports as t };
+//# sourceMappingURL=SpeechSynthesizer.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpeechSynthesizer.d.mts","names":[],"sources":["../../src/speech-synthesizer/SpeechSynthesizer.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,uBAAA;EAAA,SACD,IAAA;WAEA,KAAA;;;AAHX;;;;WAUW,OAAA;EAAA,SACA,YAAA,GAAe,WAAA;EAAA,SACf,KAAA;EAAA,SACA,YAAA;AAAA;;;;;AAYX;;;;;KAAY,6BAAA,GAAgC,IAAA,CAAK,uBAAA;AAAA,KAErC,wBAAA;EAAwB,oFAEzB,UAAA,GACP,OAAA,EAAS,uBAAA,KACN,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;EAAX;;;;EAAA,SAKV,eAAA,GACP,OAAA,EAAS,uBAAA,KACN,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA;EAAA;;;;;;;;;;EAAA,SAWtB,mBAAA,SACP,MAAA,EAAQ,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,GACjC,OAAA,EAAS,6BAAA,KACN,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,GAAkB,CAAA,EAAG,CAAA;AAAA;AAAA,cACrD,sBAAA;cAEY,iBAAA,SAA0B,sBAAA;AAAA,cAGS,uBAAA;;;;;;;;;;;cAYnC,kBAAA,SAA2B,uBAAA;;cAK3B,UAAA,GACX,OAAA,EAAS,uBAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,iBAAA;;cAIhC,eAAA,GACX,OAAA,EAAS,uBAAA,KACR,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,EAAiB,iBAAA;;;;;;;;;;;;;;cAgBjC,mBAAA;EAAA,CAET,OAAA,EAAS,6BAAA,UAET,MAAA,EAAQ,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAC9B,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,iBAAA,GAAoB,kBAAA;EAAA,OAE1E,MAAA,EAAQ,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,GACjC,OAAA,EAAS,6BAAA,GACR,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,iBAAA,GAAoB,kBAAA;AAAA"}

package/dist/speech-synthesizer/SpeechSynthesizer.mjs

@@ -0,0 +1,48 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Context, Effect, Function, Stream } from "effect";
+//#region src/speech-synthesizer/SpeechSynthesizer.ts
+var SpeechSynthesizer_exports = /* @__PURE__ */ __exportAll({
+	SpeechSynthesizer: () => SpeechSynthesizer,
+	TtsIncrementalText: () => TtsIncrementalText,
+	streamSynthesis: () => streamSynthesis,
+	streamSynthesisFrom: () => streamSynthesisFrom,
+	synthesize: () => synthesize
+});
+var SpeechSynthesizer = class extends Context.Service()("@betalyra/effect-uai/SpeechSynthesizer") {};
+/**
+* Capability marker — provided by provider layers whose
+* `streamSynthesisFrom` is wired up at the wire level. OpenAI, Azure
+* (wire), and AWS Polly non-Generative do not ship it. Calling
+* `streamSynthesisFrom` while only one of those Layers is in scope
+* fails at `Effect.provide` with a type error.
+*
+* Phantom — the value is `void`; providers register with
+* `Layer.succeed(TtsIncrementalText, undefined)`.
+*/
+var TtsIncrementalText = class extends Context.Service()("@betalyra/effect-uai/capability/TtsIncrementalText") {};
+/** One-shot synthesis. */
+const synthesize = (request) => Effect.flatMap(SpeechSynthesizer.asEffect(), (s) => s.synthesize(request));
+/** Full text in, audio chunks out. */
+const streamSynthesis = (request) => Stream.unwrap(Effect.map(SpeechSynthesizer.asEffect(), (s) => s.streamSynthesis(request)));
+/**
+* Incremental synthesis. Dual-arity: pipeable (data-last) and direct
+* (data-first). Requires `TtsIncrementalText` in R — providers without
+* incremental-text-in support are a type error at provide time.
+*
+* @example
+* ```ts
+* const audio = LanguageModel.streamTurn(turnReq).pipe(
+*   Stream.filterMap(Turn.toTextDelta),
+*   SpeechSynthesizer.streamSynthesisFrom(synthReq),
+* )
+* ```
+*/
+const streamSynthesisFrom = Function.dual(2, (textIn, request) => Stream.unwrap(Effect.gen(function* () {
+	const s = yield* SpeechSynthesizer.asEffect();
+	yield* TtsIncrementalText.asEffect();
+	return s.streamSynthesisFrom(textIn, request);
+})));
+//#endregion
+export { SpeechSynthesizer, TtsIncrementalText, streamSynthesis, streamSynthesisFrom, synthesize, SpeechSynthesizer_exports as t };
+
+//# sourceMappingURL=SpeechSynthesizer.mjs.map

package/dist/speech-synthesizer/SpeechSynthesizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeechSynthesizer.mjs","names":[],"sources":["../../src/speech-synthesizer/SpeechSynthesizer.ts"],"sourcesContent":["import { Context, Effect, Function, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { AudioBlob, AudioChunk, AudioFormat } from \"../domain/Audio.js\"\n\n/**\n * Cross-provider synthesis request. Provider-specific extensions\n * (ElevenLabs `stability` / `similarity_boost`, Cartesia `emotion`,\n * MiniMax `vol` / `pitch`, Azure SSML style tags) live on each\n * provider's typed request which extends this and narrows `model` and\n * `voiceId`.\n */\nexport type CommonSynthesizeRequest = {\n  readonly text: string\n  /** Model identifier. Each provider narrows. */\n  readonly model: string\n  /**\n   * Voice identifier. Per-provider request types narrow this to a\n   * typed literal union of stock voices + `(string & {})` escape for\n   * custom cloned voice IDs. Providers without custom-voice support\n   * (OpenAI, Deepgram Aura, AWS Polly) narrow to the stock-only union.\n   */\n  readonly voiceId: string\n  readonly outputFormat?: AudioFormat\n  readonly speed?: number\n  readonly languageCode?: string\n}\n\n/**\n * Incremental-synthesis request — text arrives as `Stream<string>`.\n * Gated by the `TtsIncrementalText` capability marker; only providers\n * that ship the marker can be used.\n *\n * Multi-context features (Cartesia `context_id`, ElevenLabs `multi-\n * stream-input`) are NOT exposed here — one logical utterance per\n * call. Provider extensions can expose `forkContext` for that.\n */\nexport type CommonStreamSynthesizeRequest = Omit<CommonSynthesizeRequest, \"text\">\n\nexport type SpeechSynthesizerService = {\n  /** One-shot. Full text in, full audio bytes out. Universally supported. */\n  readonly synthesize: (\n    request: CommonSynthesizeRequest,\n  ) => Effect.Effect<AudioBlob, AiError.AiError>\n  /**\n   * Full text in, audio chunks streamed out (chunked HTTP). Universally\n   * supported across providers that offer any streaming TTS at all.\n   */\n  readonly streamSynthesis: (\n    request: CommonSynthesizeRequest,\n  ) => Stream.Stream<AudioChunk, AiError.AiError>\n  /**\n   * Incremental text in (as a Stream), audio chunks streamed out. The\n   * underlying WS connection is acquired on first pull and released\n   * when the output stream is finalized via `Stream.scoped`.\n   *\n   * Gated by the `TtsIncrementalText` capability marker on the top-\n   * level helper — providers without WS-style incremental input don't\n   * ship the marker, so calls fail at `Effect.provide` with a type\n   * error.\n   */\n  readonly streamSynthesisFrom: <E, R>(\n    textIn: Stream.Stream<string, E, R>,\n    request: CommonStreamSynthesizeRequest,\n  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R>\n}\n\nexport class SpeechSynthesizer extends Context.Service<\n  SpeechSynthesizer,\n  SpeechSynthesizerService\n>()(\"@betalyra/effect-uai/SpeechSynthesizer\") {}\n\n/**\n * Capability marker — provided by provider layers whose\n * `streamSynthesisFrom` is wired up at the wire level. OpenAI, Azure\n * (wire), and AWS Polly non-Generative do not ship it. Calling\n * `streamSynthesisFrom` while only one of those Layers is in scope\n * fails at `Effect.provide` with a type error.\n *\n * Phantom — the value is `void`; providers register with\n * `Layer.succeed(TtsIncrementalText, undefined)`.\n */\nexport class TtsIncrementalText extends Context.Service<TtsIncrementalText, void>()(\n  \"@betalyra/effect-uai/capability/TtsIncrementalText\",\n) {}\n\n/** One-shot synthesis. */\nexport const synthesize = (\n  request: CommonSynthesizeRequest,\n): Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer> =>\n  Effect.flatMap(SpeechSynthesizer.asEffect(), (s) => s.synthesize(request))\n\n/** Full text in, audio chunks out. */\nexport const streamSynthesis = (\n  request: CommonSynthesizeRequest,\n): Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer> =>\n  Stream.unwrap(Effect.map(SpeechSynthesizer.asEffect(), (s) => s.streamSynthesis(request)))\n\n/**\n * Incremental synthesis. Dual-arity: pipeable (data-last) and direct\n * (data-first). Requires `TtsIncrementalText` in R — providers without\n * incremental-text-in support are a type error at provide time.\n *\n * @example\n * ```ts\n * const audio = LanguageModel.streamTurn(turnReq).pipe(\n *   Stream.filterMap(Turn.toTextDelta),\n *   SpeechSynthesizer.streamSynthesisFrom(synthReq),\n * )\n * ```\n */\nexport const streamSynthesisFrom: {\n  (\n    request: CommonStreamSynthesizeRequest,\n  ): <E, R>(\n    textIn: Stream.Stream<string, E, R>,\n  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R | SpeechSynthesizer | TtsIncrementalText>\n  <E, R>(\n    textIn: Stream.Stream<string, E, R>,\n    request: CommonStreamSynthesizeRequest,\n  ): Stream.Stream<AudioChunk, AiError.AiError | E, R | SpeechSynthesizer | TtsIncrementalText>\n} = Function.dual(\n  2,\n  <E, R>(textIn: Stream.Stream<string, E, R>, request: CommonStreamSynthesizeRequest) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const s = yield* SpeechSynthesizer.asEffect()\n        yield* TtsIncrementalText.asEffect()\n        return s.streamSynthesisFrom(textIn, request)\n      }),\n    ),\n)\n"],"mappings":";;;;;;;;;;AAkEA,IAAa,oBAAb,cAAuC,QAAQ,SAG5C,CAAC,yCAAyC,CAAC;;;;;;;;;;;AAY9C,IAAa,qBAAb,cAAwC,QAAQ,SAAmC,CACjF,qDACD,CAAC;;AAGF,MAAa,cACX,YAEA,OAAO,QAAQ,kBAAkB,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC;;AAG5E,MAAa,mBACX,YAEA,OAAO,OAAO,OAAO,IAAI,kBAAkB,UAAU,GAAG,MAAM,EAAE,gBAAgB,QAAQ,CAAC,CAAC;;;;;;;;;;;;;;AAe5F,MAAa,sBAUT,SAAS,KACX,IACO,QAAqC,YAC1C,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,kBAAkB,UAAU;AAC7C,QAAO,mBAAmB,UAAU;AACpC,QAAO,EAAE,oBAAoB,QAAQ,QAAQ;EAC7C,CACH,CACJ"}

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

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

package/dist/speech-synthesizer/SpeechSynthesizer.test.mjs

@@ -0,0 +1,112 @@
+import { streamSynthesis, streamSynthesisFrom, synthesize } from "./SpeechSynthesizer.mjs";
+import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { layer, layerWithoutIncremental } from "../testing/MockSpeechSynthesizer.mjs";
+import { Effect, Stream } from "effect";
+//#region src/speech-synthesizer/SpeechSynthesizer.test.ts
+const blob = {
+	format: {
+		container: "raw",
+		encoding: "pcm_s16le",
+		sampleRate: 24e3
+	},
+	bytes: new Uint8Array([
+		222,
+		173,
+		190,
+		239
+	]),
+	durationSeconds: .5
+};
+const chunk = (n) => ({ bytes: new Uint8Array([n]) });
+describe("SpeechSynthesizer.synthesize", () => {
+	it("returns the scripted AudioBlob", async () => {
+		const mock = layer({ blobs: [blob] });
+		const program = synthesize({
+			text: "hi",
+			model: "mock-tts",
+			voiceId: "stock-voice"
+		});
+		const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(result.bytes).toEqual(blob.bytes);
+		globalExpect(result.durationSeconds).toBe(.5);
+	});
+});
+describe("SpeechSynthesizer.streamSynthesis", () => {
+	it("emits scripted chunks for full-text-in streaming", async () => {
+		const mock = layer({ streamSynthesisChunks: [[
+			chunk(1),
+			chunk(2),
+			chunk(3)
+		]] });
+		const program = Stream.runCollect(streamSynthesis({
+			text: "hi",
+			model: "mock-tts",
+			voiceId: "stock-voice"
+		}));
+		globalExpect((await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))).map((c) => Array.from(c.bytes))).toEqual([
+			[1],
+			[2],
+			[3]
+		]);
+	});
+});
+describe("SpeechSynthesizer capability marker (compile-time)", () => {
+	const ssfReq = {
+		model: "mock-tts",
+		voiceId: "v"
+	};
+	it("requires `TtsIncrementalText` on the R channel of streamSynthesisFrom", () => {
+		(0, import_dist.expectTypeOf)(Stream.fromIterable(["a"]).pipe(streamSynthesisFrom(ssfReq))).toEqualTypeOf();
+	});
+	it("does NOT require `TtsIncrementalText` for sync `synthesize`", () => {
+		(0, import_dist.expectTypeOf)(synthesize({
+			text: "hi",
+			model: "m",
+			voiceId: "v"
+		})).toEqualTypeOf();
+	});
+	it("does NOT require `TtsIncrementalText` for full-text `streamSynthesis`", () => {
+		(0, import_dist.expectTypeOf)(streamSynthesis({
+			text: "hi",
+			model: "m",
+			voiceId: "v"
+		})).toEqualTypeOf();
+	});
+	it("a layer without the marker leaves `TtsIncrementalText` unsatisfied in R", () => {
+		const noMarker = layerWithoutIncremental({});
+		const audio = Stream.fromIterable(["a"]).pipe(streamSynthesisFrom(ssfReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))).toEqualTypeOf();
+	});
+	it("a full layer (with marker) clears R to never", () => {
+		const fullMock = layer({ streamSynthesisFromChunks: [[]] });
+		const audio = Stream.fromIterable(["a"]).pipe(streamSynthesisFrom(ssfReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))).toEqualTypeOf();
+	});
+});
+describe("SpeechSynthesizer.streamSynthesisFrom", () => {
+	const ssfReq = {
+		model: "mock-tts",
+		voiceId: "stock-voice"
+	};
+	it("pipes an LLM-style text stream into audio chunks", async () => {
+		const mock = layer({ streamSynthesisFromChunks: [[chunk(10), chunk(20)]] });
+		const audio = Stream.fromIterable(["Hello, ", "world."]).pipe(streamSynthesisFrom(ssfReq));
+		globalExpect((await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))).map((c) => Array.from(c.bytes))).toEqual([[10], [20]]);
+	});
+	it("records the request on the streamSynthesisFrom call channel", async () => {
+		const mock = layer({ streamSynthesisFromChunks: [[chunk(42)]] });
+		const program = Effect.gen(function* () {
+			yield* Stream.runDrain(Stream.fromIterable(["x"]).pipe(streamSynthesisFrom(ssfReq)));
+			return yield* mock.recorder;
+		});
+		const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(rec.streamSynthesisFromCalls.length).toBe(1);
+		globalExpect(rec.streamSynthesisFromCalls[0].voiceId).toBe("stock-voice");
+		globalExpect(rec.synthesizeCalls.length).toBe(0);
+		globalExpect(rec.streamSynthesisCalls.length).toBe(0);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=SpeechSynthesizer.test.mjs.map

package/dist/speech-synthesizer/SpeechSynthesizer.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeechSynthesizer.test.mjs","names":["MockSpeechSynthesizer.layer","SpeechSynthesizer.synthesize","SpeechSynthesizer.streamSynthesis","SpeechSynthesizer.streamSynthesisFrom","MockSpeechSynthesizer.layerWithoutIncremental"],"sources":["../../src/speech-synthesizer/SpeechSynthesizer.test.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type { AudioBlob, AudioChunk, AudioFormat } from \"../domain/Audio.js\"\nimport * as MockSpeechSynthesizer from \"../testing/MockSpeechSynthesizer.js\"\nimport * as SpeechSynthesizer from \"./SpeechSynthesizer.js\"\n\nconst pcmFormat: AudioFormat = {\n  container: \"raw\",\n  encoding: \"pcm_s16le\",\n  sampleRate: 24000,\n}\n\nconst blob: AudioBlob = {\n  format: pcmFormat,\n  bytes: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),\n  durationSeconds: 0.5,\n}\n\nconst chunk = (n: number): AudioChunk => ({ bytes: new Uint8Array([n]) })\n\ndescribe(\"SpeechSynthesizer.synthesize\", () => {\n  it(\"returns the scripted AudioBlob\", async () => {\n    const mock = MockSpeechSynthesizer.layer({ blobs: [blob] })\n    const program = SpeechSynthesizer.synthesize({\n      text: \"hi\",\n      model: \"mock-tts\",\n      voiceId: \"stock-voice\",\n    })\n    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(result.bytes).toEqual(blob.bytes)\n    expect(result.durationSeconds).toBe(0.5)\n  })\n})\n\ndescribe(\"SpeechSynthesizer.streamSynthesis\", () => {\n  it(\"emits scripted chunks for full-text-in streaming\", async () => {\n    const mock = MockSpeechSynthesizer.layer({\n      streamSynthesisChunks: [[chunk(1), chunk(2), chunk(3)]],\n    })\n    const program = Stream.runCollect(\n      SpeechSynthesizer.streamSynthesis({\n        text: \"hi\",\n        model: \"mock-tts\",\n        voiceId: \"stock-voice\",\n      }),\n    )\n    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(out.map((c) => Array.from(c.bytes))).toEqual([[1], [2], [3]])\n  })\n})\n\ndescribe(\"SpeechSynthesizer capability marker (compile-time)\", () => {\n  const ssfReq: SpeechSynthesizer.CommonStreamSynthesizeRequest = {\n    model: \"mock-tts\",\n    voiceId: \"v\",\n  }\n\n  it(\"requires `TtsIncrementalText` on the R channel of streamSynthesisFrom\", () => {\n    const tokens: Stream.Stream<string> = Stream.fromIterable([\"a\"])\n    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))\n    expectTypeOf(audio).toEqualTypeOf<\n      Stream.Stream<\n        AudioChunk,\n        AiError.AiError,\n        SpeechSynthesizer.SpeechSynthesizer | SpeechSynthesizer.TtsIncrementalText\n      >\n    >()\n  })\n\n  it(\"does NOT require `TtsIncrementalText` for sync `synthesize`\", () => {\n    const eff = SpeechSynthesizer.synthesize({ text: \"hi\", model: \"m\", voiceId: \"v\" })\n    expectTypeOf(eff).toEqualTypeOf<\n      Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer.SpeechSynthesizer>\n    >()\n  })\n\n  it(\"does NOT require `TtsIncrementalText` for full-text `streamSynthesis`\", () => {\n    const audio = SpeechSynthesizer.streamSynthesis({ text: \"hi\", model: \"m\", voiceId: \"v\" })\n    expectTypeOf(audio).toEqualTypeOf<\n      Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer.SpeechSynthesizer>\n    >()\n  })\n\n  it(\"a layer without the marker leaves `TtsIncrementalText` unsatisfied in R\", () => {\n    const noMarker = MockSpeechSynthesizer.layerWithoutIncremental({})\n    const tokens: Stream.Stream<string> = Stream.fromIterable([\"a\"])\n    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))\n    const program = Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))\n    // `SpeechSynthesizer` is provided by the layer; `TtsIncrementalText` is not,\n    // so it remains in R — calling `Effect.runPromise(program)` would be a type\n    // error because runPromise requires `R = never`.\n    expectTypeOf(program).toEqualTypeOf<\n      Effect.Effect<void, AiError.AiError, SpeechSynthesizer.TtsIncrementalText>\n    >()\n  })\n\n  it(\"a full layer (with marker) clears R to never\", () => {\n    const fullMock = MockSpeechSynthesizer.layer({\n      streamSynthesisFromChunks: [[]],\n    })\n    const tokens: Stream.Stream<string> = Stream.fromIterable([\"a\"])\n    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))\n    const program = Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))\n    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()\n  })\n})\n\ndescribe(\"SpeechSynthesizer.streamSynthesisFrom\", () => {\n  const ssfReq: SpeechSynthesizer.CommonStreamSynthesizeRequest = {\n    model: \"mock-tts\",\n    voiceId: \"stock-voice\",\n  }\n\n  it(\"pipes an LLM-style text stream into audio chunks\", async () => {\n    const mock = MockSpeechSynthesizer.layer({\n      streamSynthesisFromChunks: [[chunk(10), chunk(20)]],\n    })\n    const tokens = Stream.fromIterable([\"Hello, \", \"world.\"])\n    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))\n    const out = await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))\n    expect(out.map((c) => Array.from(c.bytes))).toEqual([[10], [20]])\n  })\n\n  it(\"records the request on the streamSynthesisFrom call channel\", async () => {\n    const mock = MockSpeechSynthesizer.layer({\n      streamSynthesisFromChunks: [[chunk(42)]],\n    })\n    const program = Effect.gen(function* () {\n      yield* Stream.runDrain(\n        Stream.fromIterable([\"x\"]).pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq)),\n      )\n      return yield* mock.recorder\n    })\n    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(rec.streamSynthesisFromCalls.length).toBe(1)\n    expect(rec.streamSynthesisFromCalls[0]!.voiceId).toBe(\"stock-voice\")\n    expect(rec.synthesizeCalls.length).toBe(0)\n    expect(rec.streamSynthesisCalls.length).toBe(0)\n  })\n})\n"],"mappings":"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"}

package/dist/streaming/JSONL.d.mts

@@ -1,10 +1,10 @@
-import { Schema, Stream } from "effect";
+import { Effect, Schema, Stream } from "effect";
 import * as _$effect_Types0 from "effect/Types";
 import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/streaming/JSONL.d.ts
 declare namespace JSONL_d_exports {
-  export { JsonParseError, fromBytes, parse, toBytes };
+  export { JsonParseError, fromBytes, parse, parseSafe, toBytes };
 }
 declare const JsonParseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "JsonParseError";
@@ -24,11 +24,18 @@ declare const fromBytes: <E, R>(self: Stream.Stream<Uint8Array, E, R>) => Stream
  * uniformly.
  */
 declare const parse: <A, I>(schema: Schema.Codec<A, I>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<A, JsonParseError | E, R>;
+/**
+ * Best-effort parse of a single JSON frame. Returns the parsed value or
+ * `undefined` on malformed input. Realtime WS adapters use this to skip
+ * non-JSON or partially-received frames silently rather than fail the
+ * entire session over one bad frame.
+ */
+declare const parseSafe: (raw: string) => Effect.Effect<unknown, never, never>;
 /**
  * Serialize a stream of values to JSONL bytes. Encodes each value via
  * `Schema.encodeUnknownSync`. Each line ends with `\n`.
  */
 declare const toBytes: <A, I>(schema: Schema.Codec<A, I>) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Uint8Array, E, R>;
 //#endregion
-export { JsonParseError, fromBytes, parse, JSONL_d_exports as t, toBytes };
+export { JsonParseError, fromBytes, parse, parseSafe, JSONL_d_exports as t, toBytes };
 //# sourceMappingURL=JSONL.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"JSONL.d.mts","names":[],"sources":["../../src/streaming/JSONL.ts"],"mappings":";;;;;;;;cAAqD,mBAAA;;;cAExC,cAAA,SAAuB,mBAAA;EAAA,SACzB,IAAA;EAAA,SACA,KAAA;AAAA;;;;AAJ0C;cAgDxC,SAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MAClC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;;;;;;cAaf,KAAA,SACJ,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,aACxB,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,CAAA,EAAG,CAAA;;;;;cAsBrE,OAAA,SACJ,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,aACxB,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA"}
+{"version":3,"file":"JSONL.d.mts","names":[],"sources":["../../src/streaming/JSONL.ts"],"mappings":";;;;;;;;cAAqD,mBAAA;;;cAExC,cAAA,SAAuB,mBAAA;EAAA,SACzB,IAAA;EAAA,SACA,KAAA;AAAA;;;;;cA4CE,SAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MAClC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;;;;;;cAaf,KAAA,SACJ,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,aACxB,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,CAAA,EAAG,CAAA;;;;;;;cAsBrE,SAAA,GAAa,GAAA,aAAW,MAAA,CAAA,MAAA;;;;;cAYxB,OAAA,SACJ,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,aACxB,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA"}

package/dist/streaming/JSONL.mjs

@@ -1,10 +1,11 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Data, Effect, Schema, Stream } from "effect";
 //#region src/streaming/JSONL.ts
 var JSONL_exports = /* @__PURE__ */ __exportAll({
 	JsonParseError: () => JsonParseError,
 	fromBytes: () => fromBytes,
 	parse: () => parse,
+	parseSafe: () => parseSafe,
 	toBytes: () => toBytes
 });
 var JsonParseError = class extends Data.TaggedError("JsonParseError") {};
@@ -36,6 +37,16 @@ const parse = (schema) => (self) => self.pipe(Stream.mapEffect((line) => Effect.
 	line,
 	cause
 })))))));
+/**
+* Best-effort parse of a single JSON frame. Returns the parsed value or
+* `undefined` on malformed input. Realtime WS adapters use this to skip
+* non-JSON or partially-received frames silently rather than fail the
+* entire session over one bad frame.
+*/
+const parseSafe = (raw) => Effect.try({
+	try: () => JSON.parse(raw),
+	catch: () => void 0
+}).pipe(Effect.orElseSucceed(() => void 0));
 const encoder = new TextEncoder();
 /**
 * Serialize a stream of values to JSONL bytes. Encodes each value via
@@ -46,6 +57,6 @@ const toBytes = (schema) => (self) => self.pipe(Stream.map((value) => {
 	return encoder.encode(JSON.stringify(encoded) + "\n");
 }));
 //#endregion
-export { JsonParseError, fromBytes, parse, JSONL_exports as t, toBytes };
+export { JsonParseError, fromBytes, parse, parseSafe, JSONL_exports as t, toBytes };
 
 //# sourceMappingURL=JSONL.mjs.map

package/dist/streaming/JSONL.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"JSONL.mjs","names":[],"sources":["../../src/streaming/JSONL.ts"],"sourcesContent":["import { Data, Effect, Schema, Stream } from \"effect\"\n\nexport class JsonParseError extends Data.TaggedError(\"JsonParseError\")<{\n  readonly line: string\n  readonly cause: unknown\n}> {}\n\n// ---------------------------------------------------------------------------\n// Generic stream helpers (kept module-local; see SSE.ts for the same shape).\n// ---------------------------------------------------------------------------\n\nconst decodeText = <E, R>(self: Stream.Stream<Uint8Array, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): TextDecoder => new TextDecoder(\"utf-8\"),\n      (decoder, chunk: Uint8Array) => [decoder, [decoder.decode(chunk, { stream: true })]] as const,\n      {\n        onHalt: (decoder: TextDecoder) => {\n          const tail = decoder.decode()\n          return tail.length > 0 ? [tail] : []\n        },\n      },\n    ),\n  )\n\nconst splitOn =\n  (separator: string) =>\n  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n    self.pipe(\n      Stream.mapAccum(\n        (): string => \"\",\n        (buffer, chunk: string) => {\n          const parts = (buffer + chunk).split(separator)\n          const tail = parts[parts.length - 1] ?? \"\"\n          return [tail, parts.slice(0, -1)] as const\n        },\n        { onHalt: (tail: string) => (tail.length > 0 ? [tail] : []) },\n      ),\n    )\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Decode a `Stream<Uint8Array>` into a `Stream<string>` of newline-delimited\n * lines. Empty lines are skipped. Buffers across chunk boundaries.\n */\nexport const fromBytes = <E, R>(\n  self: Stream.Stream<Uint8Array, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    decodeText,\n    Stream.map((s) => s.replace(/\\r/g, \"\")),\n    splitOn(\"\\n\"),\n    Stream.filter((line) => line.length > 0),\n  )\n\n/**\n * Validate each JSONL line against a Schema. JSON parse errors and Schema\n * decode errors both surface as a `JsonParseError` so callers can `catchTag`\n * uniformly.\n */\nexport const parse =\n  <A, I>(schema: Schema.Codec<A, I>) =>\n  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<A, JsonParseError | E, R> =>\n    self.pipe(\n      Stream.mapEffect((line) =>\n        Effect.try({\n          try: () => JSON.parse(line) as unknown,\n          catch: (cause) => new JsonParseError({ line, cause }),\n        }).pipe(\n          Effect.flatMap((value) =>\n            Schema.decodeUnknownEffect(schema)(value).pipe(\n              Effect.mapError((cause) => new JsonParseError({ line, cause })),\n            ),\n          ),\n        ),\n      ),\n    )\n\nconst encoder = new TextEncoder()\n\n/**\n * Serialize a stream of values to JSONL bytes. Encodes each value via\n * `Schema.encodeUnknownSync`. Each line ends with `\\n`.\n */\nexport const toBytes =\n  <A, I>(schema: Schema.Codec<A, I>) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<Uint8Array, E, R> =>\n    self.pipe(\n      Stream.map((value) => {\n        const encoded = Schema.encodeUnknownSync(schema)(value)\n        return encoder.encode(JSON.stringify(encoded) + \"\\n\")\n      }),\n    )\n"],"mappings":";;;;;;;;;AAEA,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAGnE;AAMH,MAAM,cAAoB,SACxB,KAAK,KACH,OAAO,eACc,IAAI,YAAY,QAAQ,GAC1C,SAAS,UAAsB,CAAC,SAAS,CAAC,QAAQ,OAAO,OAAO,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,EACpF,EACE,SAAS,YAAyB;CAChC,MAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAO,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE;GAEvC,CACF,CACF;AAEH,MAAM,WACH,eACM,SACL,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CACzB,MAAM,SAAS,SAAS,OAAO,MAAM,UAAU;AAE/C,QAAO,CADM,MAAM,MAAM,SAAS,MAAM,IAC1B,MAAM,MAAM,GAAG,GAAG,CAAC;GAEnC,EAAE,SAAS,SAAkB,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE,EAAG,CAC9D,CACF;;;;;AAUL,MAAa,aACX,SAEA,KAAK,KACH,YACA,OAAO,KAAK,MAAM,EAAE,QAAQ,OAAO,GAAG,CAAC,EACvC,QAAQ,KAAK,EACb,OAAO,QAAQ,SAAS,KAAK,SAAS,EAAE,CACzC;;;;;;AAOH,MAAa,SACJ,YACA,SACL,KAAK,KACH,OAAO,WAAW,SAChB,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,KAAK;CAC3B,QAAQ,UAAU,IAAI,eAAe;EAAE;EAAM;EAAO,CAAC;CACtD,CAAC,CAAC,KACD,OAAO,SAAS,UACd,OAAO,oBAAoB,OAAO,CAAC,MAAM,CAAC,KACxC,OAAO,UAAU,UAAU,IAAI,eAAe;CAAE;CAAM;CAAO,CAAC,CAAC,CAChE,CACF,CACF,CACF,CACF;AAEL,MAAM,UAAU,IAAI,aAAa;;;;;AAMjC,MAAa,WACJ,YACA,SACL,KAAK,KACH,OAAO,KAAK,UAAU;CACpB,MAAM,UAAU,OAAO,kBAAkB,OAAO,CAAC,MAAM;AACvD,QAAO,QAAQ,OAAO,KAAK,UAAU,QAAQ,GAAG,KAAK;EACrD,CACH"}
+{"version":3,"file":"JSONL.mjs","names":[],"sources":["../../src/streaming/JSONL.ts"],"sourcesContent":["import { Data, Effect, Schema, Stream } from \"effect\"\n\nexport class JsonParseError extends Data.TaggedError(\"JsonParseError\")<{\n  readonly line: string\n  readonly cause: unknown\n}> {}\n\n// ---------------------------------------------------------------------------\n// Generic stream helpers (kept module-local; see SSE.ts for the same shape).\n// ---------------------------------------------------------------------------\n\nconst decodeText = <E, R>(self: Stream.Stream<Uint8Array, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): TextDecoder => new TextDecoder(\"utf-8\"),\n      (decoder, chunk: Uint8Array) => [decoder, [decoder.decode(chunk, { stream: true })]] as const,\n      {\n        onHalt: (decoder: TextDecoder) => {\n          const tail = decoder.decode()\n          return tail.length > 0 ? [tail] : []\n        },\n      },\n    ),\n  )\n\nconst splitOn =\n  (separator: string) =>\n  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n    self.pipe(\n      Stream.mapAccum(\n        (): string => \"\",\n        (buffer, chunk: string) => {\n          const parts = (buffer + chunk).split(separator)\n          const tail = parts[parts.length - 1] ?? \"\"\n          return [tail, parts.slice(0, -1)] as const\n        },\n        { onHalt: (tail: string) => (tail.length > 0 ? [tail] : []) },\n      ),\n    )\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Decode a `Stream<Uint8Array>` into a `Stream<string>` of newline-delimited\n * lines. Empty lines are skipped. Buffers across chunk boundaries.\n */\nexport const fromBytes = <E, R>(\n  self: Stream.Stream<Uint8Array, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    decodeText,\n    Stream.map((s) => s.replace(/\\r/g, \"\")),\n    splitOn(\"\\n\"),\n    Stream.filter((line) => line.length > 0),\n  )\n\n/**\n * Validate each JSONL line against a Schema. JSON parse errors and Schema\n * decode errors both surface as a `JsonParseError` so callers can `catchTag`\n * uniformly.\n */\nexport const parse =\n  <A, I>(schema: Schema.Codec<A, I>) =>\n  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<A, JsonParseError | E, R> =>\n    self.pipe(\n      Stream.mapEffect((line) =>\n        Effect.try({\n          try: () => JSON.parse(line) as unknown,\n          catch: (cause) => new JsonParseError({ line, cause }),\n        }).pipe(\n          Effect.flatMap((value) =>\n            Schema.decodeUnknownEffect(schema)(value).pipe(\n              Effect.mapError((cause) => new JsonParseError({ line, cause })),\n            ),\n          ),\n        ),\n      ),\n    )\n\n/**\n * Best-effort parse of a single JSON frame. Returns the parsed value or\n * `undefined` on malformed input. Realtime WS adapters use this to skip\n * non-JSON or partially-received frames silently rather than fail the\n * entire session over one bad frame.\n */\nexport const parseSafe = (raw: string) =>\n  Effect.try({\n    try: () => JSON.parse(raw) as unknown,\n    catch: () => undefined,\n  }).pipe(Effect.orElseSucceed(() => undefined))\n\nconst encoder = new TextEncoder()\n\n/**\n * Serialize a stream of values to JSONL bytes. Encodes each value via\n * `Schema.encodeUnknownSync`. Each line ends with `\\n`.\n */\nexport const toBytes =\n  <A, I>(schema: Schema.Codec<A, I>) =>\n  <E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<Uint8Array, E, R> =>\n    self.pipe(\n      Stream.map((value) => {\n        const encoded = Schema.encodeUnknownSync(schema)(value)\n        return encoder.encode(JSON.stringify(encoded) + \"\\n\")\n      }),\n    )\n"],"mappings":";;;;;;;;;;AAEA,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAGnE;AAMH,MAAM,cAAoB,SACxB,KAAK,KACH,OAAO,eACc,IAAI,YAAY,QAAQ,GAC1C,SAAS,UAAsB,CAAC,SAAS,CAAC,QAAQ,OAAO,OAAO,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,EACpF,EACE,SAAS,YAAyB;CAChC,MAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAO,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE;GAEvC,CACF,CACF;AAEH,MAAM,WACH,eACM,SACL,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CACzB,MAAM,SAAS,SAAS,OAAO,MAAM,UAAU;AAE/C,QAAO,CADM,MAAM,MAAM,SAAS,MAAM,IAC1B,MAAM,MAAM,GAAG,GAAG,CAAC;GAEnC,EAAE,SAAS,SAAkB,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE,EAAG,CAC9D,CACF;;;;;AAUL,MAAa,aACX,SAEA,KAAK,KACH,YACA,OAAO,KAAK,MAAM,EAAE,QAAQ,OAAO,GAAG,CAAC,EACvC,QAAQ,KAAK,EACb,OAAO,QAAQ,SAAS,KAAK,SAAS,EAAE,CACzC;;;;;;AAOH,MAAa,SACJ,YACA,SACL,KAAK,KACH,OAAO,WAAW,SAChB,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,KAAK;CAC3B,QAAQ,UAAU,IAAI,eAAe;EAAE;EAAM;EAAO,CAAC;CACtD,CAAC,CAAC,KACD,OAAO,SAAS,UACd,OAAO,oBAAoB,OAAO,CAAC,MAAM,CAAC,KACxC,OAAO,UAAU,UAAU,IAAI,eAAe;CAAE;CAAM;CAAO,CAAC,CAAC,CAChE,CACF,CACF,CACF,CACF;;;;;;;AAQL,MAAa,aAAa,QACxB,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,IAAI;CAC1B,aAAa,KAAA;CACd,CAAC,CAAC,KAAK,OAAO,oBAAoB,KAAA,EAAU,CAAC;AAEhD,MAAM,UAAU,IAAI,aAAa;;;;;AAMjC,MAAa,WACJ,YACA,SACL,KAAK,KACH,OAAO,KAAK,UAAU;CACpB,MAAM,UAAU,OAAO,kBAAkB,OAAO,CAAC,MAAM;AACvD,QAAO,QAAQ,OAAO,KAAK,UAAU,QAAQ,GAAG,KAAK;EACrD,CACH"}