@effect-uai/core 0.3.0 → 0.4.0

package/dist/testing/MockSpeechSynthesizer.mjs

@@ -0,0 +1,95 @@
+import { InvalidRequest } from "../domain/AiError.mjs";
+import { SpeechSynthesizer, TtsIncrementalText } from "../speech-synthesizer/SpeechSynthesizer.mjs";
+import { Effect, Layer, Ref, Stream } from "effect";
+//#region src/testing/MockSpeechSynthesizer.ts
+const makeService = (script, record) => Effect.gen(function* () {
+	const bCursor = yield* Ref.make(0);
+	const ssCursor = yield* Ref.make(0);
+	const ssfCursor = yield* Ref.make(0);
+	return {
+		synthesize: (request) => Effect.gen(function* () {
+			yield* record.synthesize(request);
+			const i = yield* Ref.getAndUpdate(bCursor, (n) => n + 1);
+			const scripted = script.blobs ?? [];
+			if (i >= scripted.length) return yield* Effect.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`
+			}));
+			return scripted[i];
+		}),
+		streamSynthesis: (request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.streamSynthesis(request);
+			const i = yield* Ref.getAndUpdate(ssCursor, (n) => n + 1);
+			const scripted = script.streamSynthesisChunks ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesis lists scripted, but call ${i + 1} was made`
+			}));
+			return Stream.fromIterable(scripted[i]);
+		})),
+		streamSynthesisFrom: (textIn, request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.streamSynthesisFrom(request);
+			const i = yield* Ref.getAndUpdate(ssfCursor, (n) => n + 1);
+			const scripted = script.streamSynthesisFromChunks ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesisFrom lists scripted, but call ${i + 1} was made`
+			}));
+			return Stream.drain(textIn).pipe(Stream.concat(Stream.fromIterable(scripted[i])));
+		}))
+	};
+});
+/**
+* Layer providing the `SpeechSynthesizer` service AND the
+* `TtsIncrementalText` capability marker. Use for the common case
+* where code under test exercises `streamSynthesisFrom`.
+*/
+const layer = (script) => {
+	const bCalls = Ref.makeUnsafe([]);
+	const ssCalls = Ref.makeUnsafe([]);
+	const ssfCalls = Ref.makeUnsafe([]);
+	const synthesizerLayer = Layer.effect(SpeechSynthesizer, makeService(script, {
+		synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+		streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+		streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req])
+	}));
+	return {
+		layer: Layer.merge(synthesizerLayer, Layer.succeed(TtsIncrementalText, void 0)),
+		recorder: Effect.gen(function* () {
+			return {
+				synthesizeCalls: yield* Ref.get(bCalls),
+				streamSynthesisCalls: yield* Ref.get(ssCalls),
+				streamSynthesisFromCalls: yield* Ref.get(ssfCalls)
+			};
+		})
+	};
+};
+/**
+* Variant that omits the `TtsIncrementalText` marker — simulates a
+* provider without incremental-text-in support (e.g. OpenAI, AWS
+* Polly non-Generative). Calls to `streamSynthesisFrom` in code under
+* test should be a compile-time error.
+*/
+const layerWithoutIncremental = (script) => {
+	const bCalls = Ref.makeUnsafe([]);
+	const ssCalls = Ref.makeUnsafe([]);
+	const ssfCalls = Ref.makeUnsafe([]);
+	return {
+		layer: Layer.effect(SpeechSynthesizer, makeService(script, {
+			synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+			streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+			streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				synthesizeCalls: yield* Ref.get(bCalls),
+				streamSynthesisCalls: yield* Ref.get(ssCalls),
+				streamSynthesisFromCalls: yield* Ref.get(ssfCalls)
+			};
+		})
+	};
+};
+//#endregion
+export { layer, layerWithoutIncremental };
+
+//# sourceMappingURL=MockSpeechSynthesizer.mjs.map

package/dist/testing/MockSpeechSynthesizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockSpeechSynthesizer.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockSpeechSynthesizer.ts"],"sourcesContent":["import { Effect, Layer, Ref, Stream } from \"effect\"\nimport type { AudioBlob, AudioChunk } from \"../domain/Audio.js\"\nimport * as AiError from \"../domain/AiError.js\"\nimport {\n  SpeechSynthesizer,\n  TtsIncrementalText,\n  type CommonStreamSynthesizeRequest,\n  type CommonSynthesizeRequest,\n  type SpeechSynthesizerService,\n} from \"../speech-synthesizer/SpeechSynthesizer.js\"\n\nexport type MockSynthesizerRecorder = {\n  readonly synthesizeCalls: ReadonlyArray<CommonSynthesizeRequest>\n  readonly streamSynthesisCalls: ReadonlyArray<CommonSynthesizeRequest>\n  readonly streamSynthesisFromCalls: ReadonlyArray<CommonStreamSynthesizeRequest>\n}\n\nexport type MockSynthesizerScript = {\n  /** One blob per `synthesize` call, consumed in order. */\n  readonly blobs?: ReadonlyArray<AudioBlob>\n  /** One chunk-list per `streamSynthesis` call, consumed in order. */\n  readonly streamSynthesisChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>\n  /** One chunk-list per `streamSynthesisFrom` call, consumed in order. */\n  readonly streamSynthesisFromChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>\n}\n\nconst makeService = (\n  script: MockSynthesizerScript,\n  record: {\n    readonly synthesize: (req: CommonSynthesizeRequest) => Effect.Effect<void>\n    readonly streamSynthesis: (req: CommonSynthesizeRequest) => Effect.Effect<void>\n    readonly streamSynthesisFrom: (req: CommonStreamSynthesizeRequest) => Effect.Effect<void>\n  },\n) =>\n  Effect.gen(function* () {\n    const bCursor = yield* Ref.make(0)\n    const ssCursor = yield* Ref.make(0)\n    const ssfCursor = yield* Ref.make(0)\n    const service: SpeechSynthesizerService = {\n      synthesize: (request) =>\n        Effect.gen(function* () {\n          yield* record.synthesize(request)\n          const i = yield* Ref.getAndUpdate(bCursor, (n) => n + 1)\n          const scripted = script.blobs ?? []\n          if (i >= scripted.length) {\n            return yield* Effect.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          return scripted[i]!\n        }),\n      streamSynthesis: (request) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.streamSynthesis(request)\n            const i = yield* Ref.getAndUpdate(ssCursor, (n) => n + 1)\n            const scripted = script.streamSynthesisChunks ?? []\n            if (i >= scripted.length) {\n              return Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesis lists scripted, but call ${i + 1} was made`,\n                }),\n              )\n            }\n            return Stream.fromIterable(scripted[i]!)\n          }),\n        ),\n      streamSynthesisFrom: <E, R>(\n        textIn: Stream.Stream<string, E, R>,\n        request: CommonStreamSynthesizeRequest,\n      ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.streamSynthesisFrom(request)\n            const i = yield* Ref.getAndUpdate(ssfCursor, (n) => n + 1)\n            const scripted = script.streamSynthesisFromChunks ?? []\n            if (i >= scripted.length) {\n              const exhausted: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesisFrom lists scripted, but call ${i + 1} was made`,\n                }),\n              )\n              return exhausted\n            }\n            // Drain the input text fully before emitting scripted audio chunks,\n            // so consumers can assert on what text was pushed.\n            return Stream.drain(textIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))\n          }),\n        ),\n    }\n    return service\n  })\n\n/**\n * Layer providing the `SpeechSynthesizer` service AND the\n * `TtsIncrementalText` capability marker. Use for the common case\n * where code under test exercises `streamSynthesisFrom`.\n */\nexport const layer = (\n  script: MockSynthesizerScript,\n): {\n  readonly layer: Layer.Layer<SpeechSynthesizer | TtsIncrementalText>\n  readonly recorder: Effect.Effect<MockSynthesizerRecorder>\n} => {\n  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])\n  const synthesizerLayer = Layer.effect(\n    SpeechSynthesizer,\n    makeService(script, {\n      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),\n      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),\n      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),\n    }),\n  )\n  const live = Layer.merge(synthesizerLayer, Layer.succeed(TtsIncrementalText, undefined))\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const synthesizeCalls = yield* Ref.get(bCalls)\n      const streamSynthesisCalls = yield* Ref.get(ssCalls)\n      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)\n      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }\n    }),\n  }\n}\n\n/**\n * Variant that omits the `TtsIncrementalText` marker — simulates a\n * provider without incremental-text-in support (e.g. OpenAI, AWS\n * Polly non-Generative). Calls to `streamSynthesisFrom` in code under\n * test should be a compile-time error.\n */\nexport const layerWithoutIncremental = (\n  script: MockSynthesizerScript,\n): {\n  readonly layer: Layer.Layer<SpeechSynthesizer>\n  readonly recorder: Effect.Effect<MockSynthesizerRecorder>\n} => {\n  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])\n  const live = Layer.effect(\n    SpeechSynthesizer,\n    makeService(script, {\n      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),\n      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),\n      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),\n    }),\n  )\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const synthesizeCalls = yield* Ref.get(bCalls)\n      const streamSynthesisCalls = yield* Ref.get(ssCalls)\n      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)\n      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }\n    }),\n  }\n}\n"],"mappings":"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"}

package/dist/testing/MockTranscriber.d.mts

@@ -0,0 +1,37 @@
+import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
+import { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber } from "../transcriber/Transcriber.mjs";
+import { Effect, Layer } from "effect";
+
+//#region src/testing/MockTranscriber.d.ts
+/**
+ * Recorder of every call made to the mock.
+ */
+type MockTranscriberRecorder = {
+  readonly transcribeCalls: ReadonlyArray<CommonTranscribeRequest>;
+  readonly streamCalls: ReadonlyArray<CommonStreamTranscribeRequest>;
+};
+type MockTranscriberScript = {
+  /** One result per `transcribe` call, consumed in order. */readonly transcripts?: ReadonlyArray<TranscriptResult>; /** One event-list per `streamTranscriptionFrom` call, consumed in order. */
+  readonly streams?: ReadonlyArray<ReadonlyArray<TranscriptEvent>>;
+};
+/**
+ * Returns a Layer that provides both the `Transcriber` service and the
+ * `SttStreaming` capability marker. Use when the code under test calls
+ * `streamTranscriptionFrom`.
+ */
+declare const layer: (script: MockTranscriberScript) => {
+  readonly layer: Layer.Layer<Transcriber | SttStreaming>;
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>;
+};
+/**
+ * Variant that omits the `SttStreaming` marker — use to test that
+ * consumers calling `streamTranscriptionFrom` fail to compile against
+ * a non-streaming provider.
+ */
+declare const layerSyncOnly: (script: MockTranscriberScript) => {
+  readonly layer: Layer.Layer<Transcriber>;
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>;
+};
+//#endregion
+export { MockTranscriberRecorder, MockTranscriberScript, layer, layerSyncOnly };
+//# sourceMappingURL=MockTranscriber.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MockTranscriber.d.mts","names":[],"sources":["../../src/testing/MockTranscriber.ts"],"mappings":";;;;;;;AAcA;KAAY,uBAAA;EAAA,SACD,eAAA,EAAiB,aAAA,CAAc,uBAAA;EAAA,SAC/B,WAAA,EAAa,aAAA,CAAc,6BAAA;AAAA;AAAA,KAG1B,qBAAA;EAHY,oEAKb,WAAA,GAAc,aAAA,CAAc,gBAAA,GALF;EAAA,SAO1B,OAAA,GAAU,aAAA,CAAc,aAAA,CAAc,eAAA;AAAA;;;;;;cA6DpC,KAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,WAAA,GAAc,YAAA;EAAA,SACjC,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA;;;;;;cA2BtB,aAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,WAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA"}

package/dist/testing/MockTranscriber.mjs

@@ -0,0 +1,77 @@
+import { InvalidRequest } from "../domain/AiError.mjs";
+import { SttStreaming, Transcriber } from "../transcriber/Transcriber.mjs";
+import { Effect, Layer, Ref, Stream } from "effect";
+//#region src/testing/MockTranscriber.ts
+const makeService = (script, record) => Effect.gen(function* () {
+	const tCursor = yield* Ref.make(0);
+	const sCursor = yield* Ref.make(0);
+	return {
+		transcribe: (request) => Effect.gen(function* () {
+			yield* record.transcribe(request);
+			const i = yield* Ref.getAndUpdate(tCursor, (n) => n + 1);
+			const scripted = script.transcripts ?? [];
+			if (i >= scripted.length) return yield* Effect.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`
+			}));
+			return scripted[i];
+		}),
+		streamTranscriptionFrom: (audioIn, request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.stream(request);
+			const i = yield* Ref.getAndUpdate(sCursor, (n) => n + 1);
+			const scripted = script.streams ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockTranscriber exhausted: ${scripted.length} streams scripted, but call ${i + 1} was made`
+			}));
+			return Stream.drain(audioIn).pipe(Stream.concat(Stream.fromIterable(scripted[i])));
+		}))
+	};
+});
+/**
+* Returns a Layer that provides both the `Transcriber` service and the
+* `SttStreaming` capability marker. Use when the code under test calls
+* `streamTranscriptionFrom`.
+*/
+const layer = (script) => {
+	const tCalls = Ref.makeUnsafe([]);
+	const sCalls = Ref.makeUnsafe([]);
+	const transcriberLayer = Layer.effect(Transcriber, makeService(script, {
+		transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+		stream: (req) => Ref.update(sCalls, (xs) => [...xs, req])
+	}));
+	return {
+		layer: Layer.merge(transcriberLayer, Layer.succeed(SttStreaming, void 0)),
+		recorder: Effect.gen(function* () {
+			return {
+				transcribeCalls: yield* Ref.get(tCalls),
+				streamCalls: yield* Ref.get(sCalls)
+			};
+		})
+	};
+};
+/**
+* Variant that omits the `SttStreaming` marker — use to test that
+* consumers calling `streamTranscriptionFrom` fail to compile against
+* a non-streaming provider.
+*/
+const layerSyncOnly = (script) => {
+	const tCalls = Ref.makeUnsafe([]);
+	const sCalls = Ref.makeUnsafe([]);
+	return {
+		layer: Layer.effect(Transcriber, makeService(script, {
+			transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+			stream: (req) => Ref.update(sCalls, (xs) => [...xs, req])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				transcribeCalls: yield* Ref.get(tCalls),
+				streamCalls: yield* Ref.get(sCalls)
+			};
+		})
+	};
+};
+//#endregion
+export { layer, layerSyncOnly };
+
+//# sourceMappingURL=MockTranscriber.mjs.map

package/dist/testing/MockTranscriber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockTranscriber.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockTranscriber.ts"],"sourcesContent":["import { Effect, Layer, Ref, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\nimport {\n  SttStreaming,\n  Transcriber,\n  type CommonStreamTranscribeRequest,\n  type CommonTranscribeRequest,\n  type TranscriberService,\n} from \"../transcriber/Transcriber.js\"\n\n/**\n * Recorder of every call made to the mock.\n */\nexport type MockTranscriberRecorder = {\n  readonly transcribeCalls: ReadonlyArray<CommonTranscribeRequest>\n  readonly streamCalls: ReadonlyArray<CommonStreamTranscribeRequest>\n}\n\nexport type MockTranscriberScript = {\n  /** One result per `transcribe` call, consumed in order. */\n  readonly transcripts?: ReadonlyArray<TranscriptResult>\n  /** One event-list per `streamTranscriptionFrom` call, consumed in order. */\n  readonly streams?: ReadonlyArray<ReadonlyArray<TranscriptEvent>>\n}\n\nconst makeService = (\n  script: MockTranscriberScript,\n  record: {\n    readonly transcribe: (req: CommonTranscribeRequest) => Effect.Effect<void>\n    readonly stream: (req: CommonStreamTranscribeRequest) => Effect.Effect<void>\n  },\n) =>\n  Effect.gen(function* () {\n    const tCursor = yield* Ref.make(0)\n    const sCursor = yield* Ref.make(0)\n    const service: TranscriberService = {\n      transcribe: (request) =>\n        Effect.gen(function* () {\n          yield* record.transcribe(request)\n          const i = yield* Ref.getAndUpdate(tCursor, (n) => n + 1)\n          const scripted = script.transcripts ?? []\n          if (i >= scripted.length) {\n            return yield* Effect.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          return scripted[i]!\n        }),\n      streamTranscriptionFrom: <E, R>(\n        audioIn: Stream.Stream<Uint8Array, E, R>,\n        request: CommonStreamTranscribeRequest,\n      ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R> =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.stream(request)\n            const i = yield* Ref.getAndUpdate(sCursor, (n) => n + 1)\n            const scripted = script.streams ?? []\n            if (i >= scripted.length) {\n              const exhausted: Stream.Stream<TranscriptEvent, AiError.AiError | E, R> = Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockTranscriber exhausted: ${scripted.length} streams scripted, but call ${i + 1} was made`,\n                }),\n              )\n              return exhausted\n            }\n            // Drain the input audio fully before emitting the scripted events,\n            // so consumers can assert on what bytes were pushed.\n            return Stream.drain(audioIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))\n          }),\n        ),\n    }\n    return service\n  })\n\n/**\n * Returns a Layer that provides both the `Transcriber` service and the\n * `SttStreaming` capability marker. Use when the code under test calls\n * `streamTranscriptionFrom`.\n */\nexport const layer = (\n  script: MockTranscriberScript,\n): {\n  readonly layer: Layer.Layer<Transcriber | SttStreaming>\n  readonly recorder: Effect.Effect<MockTranscriberRecorder>\n} => {\n  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])\n  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])\n  const transcriberLayer = Layer.effect(\n    Transcriber,\n    makeService(script, {\n      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),\n      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),\n    }),\n  )\n  const live = Layer.merge(transcriberLayer, Layer.succeed(SttStreaming, undefined))\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const transcribeCalls = yield* Ref.get(tCalls)\n      const streamCalls = yield* Ref.get(sCalls)\n      return { transcribeCalls, streamCalls }\n    }),\n  }\n}\n\n/**\n * Variant that omits the `SttStreaming` marker — use to test that\n * consumers calling `streamTranscriptionFrom` fail to compile against\n * a non-streaming provider.\n */\nexport const layerSyncOnly = (\n  script: MockTranscriberScript,\n): {\n  readonly layer: Layer.Layer<Transcriber>\n  readonly recorder: Effect.Effect<MockTranscriberRecorder>\n} => {\n  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])\n  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])\n  const live = Layer.effect(\n    Transcriber,\n    makeService(script, {\n      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),\n      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),\n    }),\n  )\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const transcribeCalls = yield* Ref.get(tCalls)\n      const streamCalls = yield* Ref.get(sCalls)\n      return { transcribeCalls, streamCalls }\n    }),\n  }\n}\n"],"mappings":";;;;AA0BA,MAAM,eACJ,QACA,WAKA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,IAAI,KAAK,EAAE;CAClC,MAAM,UAAU,OAAO,IAAI,KAAK,EAAE;AAyClC,QAAO;EAvCL,aAAa,YACX,OAAO,IAAI,aAAa;AACtB,UAAO,OAAO,WAAW,QAAQ;GACjC,MAAM,IAAI,OAAO,IAAI,aAAa,UAAU,MAAM,IAAI,EAAE;GACxD,MAAM,WAAW,OAAO,eAAe,EAAE;AACzC,OAAI,KAAK,SAAS,OAChB,QAAO,OAAO,OAAO,KACnB,IAAIA,eAAuB;IACzB,UAAU;IACV,KAAK,8BAA8B,SAAS,OAAO,kCAAkC,IAAI,EAAE;IAC5F,CAAC,CACH;AAEH,UAAO,SAAS;IAChB;EACJ,0BACE,SACA,YAEA,OAAO,OACL,OAAO,IAAI,aAAa;AACtB,UAAO,OAAO,OAAO,QAAQ;GAC7B,MAAM,IAAI,OAAO,IAAI,aAAa,UAAU,MAAM,IAAI,EAAE;GACxD,MAAM,WAAW,OAAO,WAAW,EAAE;AACrC,OAAI,KAAK,SAAS,OAOhB,QAN0E,OAAO,KAC/E,IAAIA,eAAuB;IACzB,UAAU;IACV,KAAK,8BAA8B,SAAS,OAAO,8BAA8B,IAAI,EAAE;IACxF,CAAC,CAEY;AAIlB,UAAO,OAAO,MAAM,QAAQ,CAAC,KAAK,OAAO,OAAO,OAAO,aAAa,SAAS,GAAI,CAAC,CAAC;IACnF,CACH;EAES;EACd;;;;;;AAOJ,MAAa,SACX,WAIG;CACH,MAAM,SAAS,IAAI,WAAmD,EAAE,CAAC;CACzE,MAAM,SAAS,IAAI,WAAyD,EAAE,CAAC;CAC/E,MAAM,mBAAmB,MAAM,OAC7B,aACA,YAAY,QAAQ;EAClB,aAAa,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;EAC7D,SAAS,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;EAC1D,CAAC,CACH;AAED,QAAO;EACL,OAFW,MAAM,MAAM,kBAAkB,MAAM,QAAQ,cAAc,KAAA,EAAU,CAEpE;EACX,UAAU,OAAO,IAAI,aAAa;AAGhC,UAAO;IAAE,iBAAA,OAFsB,IAAI,IAAI,OAAO;IAEpB,aAAA,OADC,IAAI,IAAI,OAAO;IACH;IACvC;EACH;;;;;;;AAQH,MAAa,iBACX,WAIG;CACH,MAAM,SAAS,IAAI,WAAmD,EAAE,CAAC;CACzE,MAAM,SAAS,IAAI,WAAyD,EAAE,CAAC;AAQ/E,QAAO;EACL,OARW,MAAM,OACjB,aACA,YAAY,QAAQ;GAClB,aAAa,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;GAC7D,SAAS,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;GAC1D,CAAC,CAGS;EACX,UAAU,OAAO,IAAI,aAAa;AAGhC,UAAO;IAAE,iBAAA,OAFsB,IAAI,IAAI,OAAO;IAEpB,aAAA,OADC,IAAI,IAAI,OAAO;IACH;IACvC;EACH"}

package/dist/tool/HistoryCheck.d.mts

@@ -1,4 +1,4 @@
-import { d as Item, o as FunctionCall } from "../Items-CB8Bo3FI.mjs";
+import { d as Item, o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
 import { ToolResult } from "./Outcome.mjs";
 
 //#region src/tool/HistoryCheck.d.ts

package/dist/tool/Outcome.d.mts

@@ -1,4 +1,4 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "../Items-CB8Bo3FI.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "../Items-Hg5AsYxl.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 

package/dist/tool/Resolvers.d.mts

@@ -1,4 +1,4 @@
-import { o as FunctionCall } from "../Items-CB8Bo3FI.mjs";
+import { o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
 import { ToolResult } from "./Outcome.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";
 import { Effect, Queue, Scope, Stream } from "effect";

package/dist/tool/Tool.d.mts

@@ -1,2 +1,2 @@
-import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as isStreamingTool, h as toDescriptors, i as StreamingTool, m as streaming, n as AnyPlainTool, o as ToolDescriptor, p as make, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-DjVufH7i.mjs";
+import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as isStreamingTool, h as toDescriptors, i as StreamingTool, m as streaming, n as AnyPlainTool, o as ToolDescriptor, p as make, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-B8B5qVEy.mjs";
 export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, isStreamingTool, make, streaming, toDescriptors };

package/dist/tool/Toolkit.d.mts

@@ -1,5 +1,5 @@
-import { o as FunctionCall } from "../Items-CB8Bo3FI.mjs";
-import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-DjVufH7i.mjs";
+import { o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
+import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-B8B5qVEy.mjs";
 import { Event } from "../loop/Loop.mjs";
 import { ToolResult } from "./Outcome.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";

package/dist/transcriber/Transcriber.d.mts

@@ -0,0 +1,101 @@
+import { t as AiError } from "../AiError-csR8Bhxx.mjs";
+import { a as AudioSource, r as AudioFormat } from "../Audio-BfCTGnH3.mjs";
+import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
+import { Context, Effect, Stream } from "effect";
+
+//#region src/transcriber/Transcriber.d.ts
+declare namespace Transcriber_d_exports {
+  export { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber, TranscriberService, streamTranscriptionFrom, transcribe };
+}
+/**
+ * Cross-provider sync transcription request. Provider-specific
+ * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google
+ * `adaptation`, …) live on each provider's typed request which extends
+ * this and narrows `model`.
+ */
+type CommonTranscribeRequest = {
+  readonly audio: AudioSource; /** Model identifier. Each provider narrows to its typed literal union. */
+  readonly model: string; /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */
+  readonly language?: string;
+  /**
+   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;
+   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS
+   * `vocabularyName`. Providers ignore what they don't support.
+   */
+  readonly prompt?: string | {
+    readonly terms: ReadonlyArray<string>;
+  };
+  readonly diarization?: boolean;
+  readonly wordTimestamps?: boolean;
+};
+/**
+ * Streaming-transcription request. `inputFormat` declares what the
+ * bytes in the input stream will look like — providers reject
+ * mismatches at stream startup with `AiError.InvalidRequest`.
+ */
+type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, "audio"> & {
+  readonly inputFormat: AudioFormat;
+  readonly interimResults?: boolean;
+  readonly vadEvents?: boolean;
+};
+type TranscriberService = {
+  /**
+   * One-shot transcription. Universal — AWS Transcribe (which has no
+   * native sync endpoint) emulates this by draining a streaming session
+   * internally.
+   */
+  readonly transcribe: (request: CommonTranscribeRequest) => Effect.Effect<TranscriptResult, AiError>;
+  /**
+   * Live transcription as a Stream transformer. Consumes audio bytes
+   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The
+   * underlying WS / gRPC connection is acquired on first pull and
+   * released when the output stream is finalized (success, failure, or
+   * interruption) via `Stream.scoped` — no explicit Scope handling at
+   * the call site.
+   *
+   * Gated by the `SttStreaming` capability marker on the top-level
+   * helper — providers without streaming-STT support don't ship the
+   * marker, so calls fail at `Effect.provide` with a type error.
+   */
+  readonly streamTranscriptionFrom: <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) => Stream.Stream<TranscriptEvent, AiError | E, R>;
+};
+declare const Transcriber_base: Context.ServiceClass<Transcriber, "@betalyra/effect-uai/Transcriber", TranscriberService>;
+declare class Transcriber extends Transcriber_base {}
+declare const SttStreaming_base: Context.ServiceClass<SttStreaming, "@betalyra/effect-uai/capability/SttStreaming", void>;
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamTranscriptionFrom` is wired up at the wire level. Azure does
+ * not ship it (streaming-STT is SDK-internal). Calling
+ * `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+ * at `Effect.provide` with a type error, not at runtime.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(SttStreaming, undefined)`.
+ */
+declare class SttStreaming extends SttStreaming_base {}
+/** One-shot transcription. */
+declare const transcribe: (request: CommonTranscribeRequest) => Effect.Effect<TranscriptResult, AiError, Transcriber>;
+/**
+ * Live transcription. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `SttStreaming` in R — providers without
+ * streaming support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * // Pipeable — composes with other Stream operators
+ * mic.frames.pipe(
+ *   Transcriber.streamTranscriptionFrom(req),
+ *   Stream.filter((e) => e._tag === "final"),
+ * )
+ *
+ * // Direct
+ * Transcriber.streamTranscriptionFrom(mic.frames, req)
+ * ```
+ */
+declare const streamTranscriptionFrom: {
+  (request: CommonStreamTranscribeRequest): <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>) => Stream.Stream<TranscriptEvent, AiError | E, R | Transcriber | SttStreaming>;
+  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest): Stream.Stream<TranscriptEvent, AiError | E, R | Transcriber | SttStreaming>;
+};
+//#endregion
+export { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber, TranscriberService, streamTranscriptionFrom, Transcriber_d_exports as t, transcribe };
+//# sourceMappingURL=Transcriber.d.mts.map

package/dist/transcriber/Transcriber.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.d.mts","names":[],"sources":["../../src/transcriber/Transcriber.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,uBAAA;EAAA,SACD,KAAA,EAAO,WAAA;WAEP,KAAA;WAEA,QAAA;EALC;;;;;EAAA,SAWD,MAAA;IAAA,SAA6B,KAAA,EAAO,aAAA;EAAA;EAAA,SACpC,WAAA;EAAA,SACA,cAAA;AAAA;;;;;AAQX;KAAY,6BAAA,GAAgC,IAAA,CAAK,uBAAA;EAAA,SACtC,WAAA,EAAa,WAAA;EAAA,SACb,cAAA;EAAA,SACA,SAAA;AAAA;AAAA,KAGC,kBAAA;EALuB;;;;;EAAA,SAWxB,UAAA,GACP,OAAA,EAAS,uBAAA,KACN,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB,OAAA;EAX5B;;;AAGX;;;;;;;;;EAHW,SAwBA,uBAAA,SACP,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,KACN,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA;AAAA;AAAA,cAC1D,gBAAA;cAEY,WAAA,SAAoB,gBAAA;AAAA,cAE7B,iBAAA;;;;;;;;;;;cAYS,YAAA,SAAqB,iBAAA;;cAKrB,UAAA,GACX,OAAA,EAAS,uBAAA,KACR,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB,OAAA,EAAiB,WAAA;;;;;;;;;;;;;;;;;;cAoBvC,uBAAA;EAAA,CAET,OAAA,EAAS,6BAAA,UAET,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,WAAA,GAAc,YAAA;EAAA,OAEzE,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,GACR,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,WAAA,GAAc,YAAA;AAAA"}

package/dist/transcriber/Transcriber.mjs

@@ -0,0 +1,49 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Context, Effect, Function, Stream } from "effect";
+//#region src/transcriber/Transcriber.ts
+var Transcriber_exports = /* @__PURE__ */ __exportAll({
+	SttStreaming: () => SttStreaming,
+	Transcriber: () => Transcriber,
+	streamTranscriptionFrom: () => streamTranscriptionFrom,
+	transcribe: () => transcribe
+});
+var Transcriber = class extends Context.Service()("@betalyra/effect-uai/Transcriber") {};
+/**
+* Capability marker — provided by provider layers whose
+* `streamTranscriptionFrom` is wired up at the wire level. Azure does
+* not ship it (streaming-STT is SDK-internal). Calling
+* `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+* at `Effect.provide` with a type error, not at runtime.
+*
+* Phantom — the value is `void`; providers register with
+* `Layer.succeed(SttStreaming, undefined)`.
+*/
+var SttStreaming = class extends Context.Service()("@betalyra/effect-uai/capability/SttStreaming") {};
+/** One-shot transcription. */
+const transcribe = (request) => Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request));
+/**
+* Live transcription. Dual-arity: pipeable (data-last) and direct
+* (data-first). Requires `SttStreaming` in R — providers without
+* streaming support are a type error at provide time.
+*
+* @example
+* ```ts
+* // Pipeable — composes with other Stream operators
+* mic.frames.pipe(
+*   Transcriber.streamTranscriptionFrom(req),
+*   Stream.filter((e) => e._tag === "final"),
+* )
+*
+* // Direct
+* Transcriber.streamTranscriptionFrom(mic.frames, req)
+* ```
+*/
+const streamTranscriptionFrom = Function.dual(2, (audioIn, request) => Stream.unwrap(Effect.gen(function* () {
+	const t = yield* Transcriber.asEffect();
+	yield* SttStreaming.asEffect();
+	return t.streamTranscriptionFrom(audioIn, request);
+})));
+//#endregion
+export { SttStreaming, Transcriber, streamTranscriptionFrom, Transcriber_exports as t, transcribe };
+
+//# sourceMappingURL=Transcriber.mjs.map

package/dist/transcriber/Transcriber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.mjs","names":[],"sources":["../../src/transcriber/Transcriber.ts"],"sourcesContent":["import { Context, Effect, Function, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { AudioFormat, AudioSource } from \"../domain/Audio.js\"\nimport type { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\n\n/**\n * Cross-provider sync transcription request. Provider-specific\n * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google\n * `adaptation`, …) live on each provider's typed request which extends\n * this and narrows `model`.\n */\nexport type CommonTranscribeRequest = {\n  readonly audio: AudioSource\n  /** Model identifier. Each provider narrows to its typed literal union. */\n  readonly model: string\n  /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */\n  readonly language?: string\n  /**\n   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;\n   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS\n   * `vocabularyName`. Providers ignore what they don't support.\n   */\n  readonly prompt?: string | { readonly terms: ReadonlyArray<string> }\n  readonly diarization?: boolean\n  readonly wordTimestamps?: boolean\n}\n\n/**\n * Streaming-transcription request. `inputFormat` declares what the\n * bytes in the input stream will look like — providers reject\n * mismatches at stream startup with `AiError.InvalidRequest`.\n */\nexport type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, \"audio\"> & {\n  readonly inputFormat: AudioFormat\n  readonly interimResults?: boolean\n  readonly vadEvents?: boolean\n}\n\nexport type TranscriberService = {\n  /**\n   * One-shot transcription. Universal — AWS Transcribe (which has no\n   * native sync endpoint) emulates this by draining a streaming session\n   * internally.\n   */\n  readonly transcribe: (\n    request: CommonTranscribeRequest,\n  ) => Effect.Effect<TranscriptResult, AiError.AiError>\n  /**\n   * Live transcription as a Stream transformer. Consumes audio bytes\n   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The\n   * underlying WS / gRPC connection is acquired on first pull and\n   * released when the output stream is finalized (success, failure, or\n   * interruption) via `Stream.scoped` — no explicit Scope handling at\n   * the call site.\n   *\n   * Gated by the `SttStreaming` capability marker on the top-level\n   * helper — providers without streaming-STT support don't ship the\n   * marker, so calls fail at `Effect.provide` with a type error.\n   */\n  readonly streamTranscriptionFrom: <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>\n}\n\nexport class Transcriber extends Context.Service<Transcriber, TranscriberService>()(\n  \"@betalyra/effect-uai/Transcriber\",\n) {}\n\n/**\n * Capability marker — provided by provider layers whose\n * `streamTranscriptionFrom` is wired up at the wire level. Azure does\n * not ship it (streaming-STT is SDK-internal). Calling\n * `streamTranscriptionFrom` while only Azure's Layer is in scope fails\n * at `Effect.provide` with a type error, not at runtime.\n *\n * Phantom — the value is `void`; providers register with\n * `Layer.succeed(SttStreaming, undefined)`.\n */\nexport class SttStreaming extends Context.Service<SttStreaming, void>()(\n  \"@betalyra/effect-uai/capability/SttStreaming\",\n) {}\n\n/** One-shot transcription. */\nexport const transcribe = (\n  request: CommonTranscribeRequest,\n): Effect.Effect<TranscriptResult, AiError.AiError, Transcriber> =>\n  Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request))\n\n/**\n * Live transcription. Dual-arity: pipeable (data-last) and direct\n * (data-first). Requires `SttStreaming` in R — providers without\n * streaming support are a type error at provide time.\n *\n * @example\n * ```ts\n * // Pipeable — composes with other Stream operators\n * mic.frames.pipe(\n *   Transcriber.streamTranscriptionFrom(req),\n *   Stream.filter((e) => e._tag === \"final\"),\n * )\n *\n * // Direct\n * Transcriber.streamTranscriptionFrom(mic.frames, req)\n * ```\n */\nexport const streamTranscriptionFrom: {\n  (\n    request: CommonStreamTranscribeRequest,\n  ): <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>\n  <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>\n} = Function.dual(\n  2,\n  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const t = yield* Transcriber.asEffect()\n        yield* SttStreaming.asEffect()\n        return t.streamTranscriptionFrom(audioIn, request)\n      }),\n    ),\n)\n"],"mappings":";;;;;;;;;AAiEA,IAAa,cAAb,cAAiC,QAAQ,SAA0C,CACjF,mCACD,CAAC;;;;;;;;;;;AAYF,IAAa,eAAb,cAAkC,QAAQ,SAA6B,CACrE,+CACD,CAAC;;AAGF,MAAa,cACX,YAEA,OAAO,QAAQ,YAAY,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC;;;;;;;;;;;;;;;;;;AAmBtE,MAAa,0BAUT,SAAS,KACX,IACO,SAA0C,YAC/C,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,YAAY,UAAU;AACvC,QAAO,aAAa,UAAU;AAC9B,QAAO,EAAE,wBAAwB,SAAS,QAAQ;EAClD,CACH,CACJ"}

package/dist/transcriber/Transcriber.test.d.mts

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

package/dist/transcriber/Transcriber.test.mjs

@@ -0,0 +1,130 @@
+import { streamTranscriptionFrom, transcribe } from "./Transcriber.mjs";
+import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { layer, layerSyncOnly } from "../testing/MockTranscriber.mjs";
+import { Effect, Stream } from "effect";
+//#region src/transcriber/Transcriber.test.ts
+describe("Transcriber.transcribe", () => {
+	it("returns the scripted TranscriptResult", async () => {
+		const mock = layer({ transcripts: [{
+			text: "hello world",
+			durationSeconds: 1.23
+		}] });
+		const program = transcribe({
+			audio: {
+				_tag: "bytes",
+				bytes: new Uint8Array([0]),
+				mimeType: "audio/wav"
+			},
+			model: "mock-stt"
+		});
+		const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(result.text).toBe("hello world");
+		globalExpect(result.durationSeconds).toBe(1.23);
+	});
+	it("records each transcribe call", async () => {
+		const mock = layer({ transcripts: [{ text: "a" }, { text: "b" }] });
+		const program = Effect.gen(function* () {
+			yield* transcribe({
+				audio: {
+					_tag: "bytes",
+					bytes: new Uint8Array([1]),
+					mimeType: "audio/wav"
+				},
+				model: "m1"
+			});
+			yield* transcribe({
+				audio: {
+					_tag: "bytes",
+					bytes: new Uint8Array([2]),
+					mimeType: "audio/wav"
+				},
+				model: "m2"
+			});
+			return yield* mock.recorder;
+		});
+		globalExpect((await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))).transcribeCalls.map((c) => c.model)).toEqual(["m1", "m2"]);
+	});
+});
+describe("Transcriber capability marker (compile-time)", () => {
+	const sttReq = {
+		model: "mock-stt",
+		inputFormat: {
+			container: "raw",
+			encoding: "pcm_s16le",
+			sampleRate: 16e3
+		}
+	};
+	it("requires `SttStreaming` on the R channel of streamTranscriptionFrom", () => {
+		(0, import_dist.expectTypeOf)(Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq))).toEqualTypeOf();
+	});
+	it("does NOT require `SttStreaming` for sync `transcribe`", () => {
+		(0, import_dist.expectTypeOf)(transcribe({
+			audio: {
+				_tag: "bytes",
+				bytes: new Uint8Array([0]),
+				mimeType: "audio/wav"
+			},
+			model: "m"
+		})).toEqualTypeOf();
+	});
+	it("a sync-only layer leaves `SttStreaming` unsatisfied in R", () => {
+		const syncOnly = layerSyncOnly({});
+		const events = Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))).toEqualTypeOf();
+	});
+	it("a full layer (with marker) clears R to never", () => {
+		const fullMock = layer({ streams: [[]] });
+		const events = Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))).toEqualTypeOf();
+	});
+});
+describe("Transcriber.streamTranscriptionFrom", () => {
+	const sttReq = {
+		model: "mock-stt",
+		inputFormat: {
+			container: "raw",
+			encoding: "pcm_s16le",
+			sampleRate: 16e3
+		}
+	};
+	it("emits scripted events after draining the input audio stream", async () => {
+		const mock = layer({ streams: [[{
+			_tag: "partial",
+			text: "hello"
+		}, {
+			_tag: "final",
+			text: "hello world"
+		}]] });
+		const events = Stream.fromIterable([new Uint8Array([
+			0,
+			1,
+			2
+		]), new Uint8Array([
+			3,
+			4,
+			5
+		])]).pipe(streamTranscriptionFrom(sttReq));
+		globalExpect(await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))).toEqual([{
+			_tag: "partial",
+			text: "hello"
+		}, {
+			_tag: "final",
+			text: "hello world"
+		}]);
+	});
+	it("works data-first (direct call) as well as pipeable (data-last)", async () => {
+		const mock = layer({ streams: [[{
+			_tag: "final",
+			text: "x"
+		}]] });
+		const events = streamTranscriptionFrom(Stream.fromIterable([new Uint8Array([0])]), sttReq);
+		globalExpect(await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))).toEqual([{
+			_tag: "final",
+			text: "x"
+		}]);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Transcriber.test.mjs.map

package/dist/transcriber/Transcriber.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.test.mjs","names":["MockTranscriber.layer","Transcriber.transcribe","Transcriber.streamTranscriptionFrom","MockTranscriber.layerSyncOnly"],"sources":["../../src/transcriber/Transcriber.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 { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\nimport * as MockTranscriber from \"../testing/MockTranscriber.js\"\nimport * as Transcriber from \"./Transcriber.js\"\n\ndescribe(\"Transcriber.transcribe\", () => {\n  it(\"returns the scripted TranscriptResult\", async () => {\n    const mock = MockTranscriber.layer({\n      transcripts: [{ text: \"hello world\", durationSeconds: 1.23 }],\n    })\n    const program = Transcriber.transcribe({\n      audio: { _tag: \"bytes\", bytes: new Uint8Array([0]), mimeType: \"audio/wav\" },\n      model: \"mock-stt\",\n    })\n    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(result.text).toBe(\"hello world\")\n    expect(result.durationSeconds).toBe(1.23)\n  })\n\n  it(\"records each transcribe call\", async () => {\n    const mock = MockTranscriber.layer({\n      transcripts: [{ text: \"a\" }, { text: \"b\" }],\n    })\n    const program = Effect.gen(function* () {\n      yield* Transcriber.transcribe({\n        audio: { _tag: \"bytes\", bytes: new Uint8Array([1]), mimeType: \"audio/wav\" },\n        model: \"m1\",\n      })\n      yield* Transcriber.transcribe({\n        audio: { _tag: \"bytes\", bytes: new Uint8Array([2]), mimeType: \"audio/wav\" },\n        model: \"m2\",\n      })\n      return yield* mock.recorder\n    })\n    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(rec.transcribeCalls.map((c) => c.model)).toEqual([\"m1\", \"m2\"])\n  })\n})\n\ndescribe(\"Transcriber capability marker (compile-time)\", () => {\n  const sttReq: Transcriber.CommonStreamTranscribeRequest = {\n    model: \"mock-stt\",\n    inputFormat: { container: \"raw\", encoding: \"pcm_s16le\", sampleRate: 16000 },\n  }\n\n  it(\"requires `SttStreaming` on the R channel of streamTranscriptionFrom\", () => {\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    expectTypeOf(events).toEqualTypeOf<\n      Stream.Stream<\n        TranscriptEvent,\n        AiError.AiError,\n        Transcriber.Transcriber | Transcriber.SttStreaming\n      >\n    >()\n  })\n\n  it(\"does NOT require `SttStreaming` for sync `transcribe`\", () => {\n    const eff = Transcriber.transcribe({\n      audio: { _tag: \"bytes\", bytes: new Uint8Array([0]), mimeType: \"audio/wav\" },\n      model: \"m\",\n    })\n    expectTypeOf(eff).toEqualTypeOf<\n      Effect.Effect<TranscriptResult, AiError.AiError, Transcriber.Transcriber>\n    >()\n  })\n\n  it(\"a sync-only layer leaves `SttStreaming` unsatisfied in R\", () => {\n    const syncOnly = MockTranscriber.layerSyncOnly({})\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const program = Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))\n    // `Transcriber` is provided by syncOnly.layer; `SttStreaming` is not.\n    expectTypeOf(program).toEqualTypeOf<\n      Effect.Effect<void, AiError.AiError, Transcriber.SttStreaming>\n    >()\n  })\n\n  it(\"a full layer (with marker) clears R to never\", () => {\n    const fullMock = MockTranscriber.layer({ streams: [[]] })\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const program = Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))\n    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()\n  })\n})\n\ndescribe(\"Transcriber.streamTranscriptionFrom\", () => {\n  const sttReq: Transcriber.CommonStreamTranscribeRequest = {\n    model: \"mock-stt\",\n    inputFormat: { container: \"raw\", encoding: \"pcm_s16le\", sampleRate: 16000 },\n  }\n\n  it(\"emits scripted events after draining the input audio stream\", async () => {\n    const mock = MockTranscriber.layer({\n      streams: [\n        [\n          { _tag: \"partial\", text: \"hello\" },\n          { _tag: \"final\", text: \"hello world\" },\n        ],\n      ],\n    })\n    const audio = Stream.fromIterable([new Uint8Array([0, 1, 2]), new Uint8Array([3, 4, 5])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const collected = await Effect.runPromise(\n      Stream.runCollect(events).pipe(Effect.provide(mock.layer)),\n    )\n    expect(collected).toEqual([\n      { _tag: \"partial\", text: \"hello\" },\n      { _tag: \"final\", text: \"hello world\" },\n    ])\n  })\n\n  it(\"works data-first (direct call) as well as pipeable (data-last)\", async () => {\n    const mock = MockTranscriber.layer({\n      streams: [[{ _tag: \"final\", text: \"x\" }]],\n    })\n    const audio = Stream.fromIterable([new Uint8Array([0])])\n    const events = Transcriber.streamTranscriptionFrom(audio, sttReq)\n    const out = await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))\n    expect(out).toEqual([{ _tag: \"final\", text: \"x\" }])\n  })\n})\n"],"mappings":"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"}