@effect-uai/core 0.4.0 → 0.5.1

package/dist/testing/MockProvider.d.mts

@@ -1,5 +1,5 @@
-import { d as Item } from "../Items-Hg5AsYxl.mjs";
-import { r as Turn } from "../Turn-7geUcKsf.mjs";
+import { d as Item } from "../Items-BH8xUkoR.mjs";
+import { r as Turn } from "../Turn-0CwCAyVe.mjs";
 import { LanguageModel, LanguageModelService } from "../language-model/LanguageModel.mjs";
 import { Duration, Effect, Layer } from "effect";
 
@@ -12,37 +12,42 @@ type MockOptions = {
    */
   readonly deltaInterval?: Duration.Input;
 };
+type Call = {
+  readonly history: ReadonlyArray<Item>;
+  readonly turn: Turn;
+};
 /**
  * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,
  * one per call to `streamTurn`. Each scripted turn is split into synthetic
- * deltas (text → tool_call_start → tool_call_args_delta → ... → turn_complete)
+ * deltas (text → ToolCallStart → ToolCallArgsDelta → ... → TurnComplete)
  * so streaming consumers can see realistic delta shapes.
  */
 type MockRecorder = {
-  readonly calls: ReadonlyArray<{
-    readonly history: ReadonlyArray<Item>;
-    readonly turn: Turn;
-  }>;
+  readonly calls: ReadonlyArray<Call>;
 };
-declare const layer: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => Layer.Layer<LanguageModel>;
 /**
- * Synchronous constructor that returns the `LanguageModelService` value
- * directly, plus a recorder. Use this when you want to swap models
- * mid-stream via `Effect.provideService` instead of providing one model
- * for the whole program via `Layer`.
+ * Layer that registers a `MockProvider` against the `LanguageModel` tag.
+ * Calls beyond the scripted turn count fail with `InvalidRequest`.
  */
-declare const make: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => {
-  readonly service: LanguageModelService;
-  readonly recorder: Effect.Effect<MockRecorder>;
-};
+declare const layer: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => Layer.Layer<LanguageModel>;
 /**
- * Same as `layer`, but also exposes a recorder that captures every call
+ * Like `layer`, but also exposes a recorder that captures every call
  * (history + returned turn).
  */
 declare const layerWithRecorder: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => {
   readonly layer: Layer.Layer<LanguageModel>;
   readonly recorder: Effect.Effect<MockRecorder>;
 };
+/**
+ * Build the `LanguageModelService` value directly (no Layer), plus a
+ * recorder. Use this when you want to swap models mid-program via
+ * `Effect.provideService` instead of providing one model for the whole
+ * program via `Layer`.
+ */
+declare const make: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => {
+  readonly service: LanguageModelService;
+  readonly recorder: Effect.Effect<MockRecorder>;
+};
 //#endregion
-export { MockOptions, MockRecorder, layer, layerWithRecorder, make };
+export { Call, MockOptions, MockRecorder, layer, layerWithRecorder, make };
 //# sourceMappingURL=MockProvider.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MockProvider.d.mts","names":[],"sources":["../../src/testing/MockProvider.ts"],"mappings":";;;;;;KAMY,WAAA;;AAAZ;;;;WAMW,aAAA,GAAgB,QAAA,CAAS,KAAA;AAAA;;;;AASpC;;;KAAY,YAAA;EAAA,SACD,KAAA,EAAO,aAAA;IAAA,SACL,OAAA,EAAS,aAAA,CAAc,IAAA;IAAA,SACvB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAqEN,KAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA,KACT,KAAA,CAAM,KAAA,CAAM,aAAA;;;;;;;cAQF,IAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;;;;;cAiCtB,iBAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,aAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA"}
+{"version":3,"file":"MockProvider.d.mts","names":[],"sources":["../../src/testing/MockProvider.ts"],"mappings":";;;;;;KAMY,WAAA;;AAAZ;;;;WAMW,aAAA,GAAgB,QAAA,CAAS,KAAA;AAAA;AAAA,KAGxB,IAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,IAAA;EAAA,SACvB,IAAA,EAAM,IAAA;AAAA;;;;;;;KASL,YAAA;EAAA,SACD,KAAA,EAAO,aAAA,CAAc,IAAA;AAAA;;;;;cAqGnB,KAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA,KACT,KAAA,CAAM,KAAA,CAAM,aAAA;AAzGf;;;;AAAA,cAqHa,iBAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,aAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;;AApBnC;;;;;cAwCa,IAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA"}

package/dist/testing/MockProvider.mjs

@@ -1,92 +1,76 @@
 import { InvalidRequest } from "../domain/AiError.mjs";
+import { isOutputText } from "../domain/Items.mjs";
+import { TurnEvent } from "../domain/Turn.mjs";
 import { LanguageModel } from "../language-model/LanguageModel.mjs";
-import { Effect, Layer, Ref, Schedule, Stream } from "effect";
+import { Array, Effect, Layer, Match, Option, Ref, Schedule, Stream } from "effect";
 //#region src/testing/MockProvider.ts
-const turnToDeltas = (turn) => {
-	const deltas = [];
-	for (const item of turn.items) if (item.type === "message" && item.role === "assistant") {
-		for (const block of item.content) if (block.type === "output_text") deltas.push({
-			type: "text_delta",
-			text: block.text
-		});
-	} else if (item.type === "function_call") {
-		deltas.push({
-			type: "tool_call_start",
-			call_id: item.call_id,
-			name: item.name
-		});
-		deltas.push({
-			type: "tool_call_args_delta",
-			call_id: item.call_id,
-			delta: item.arguments
-		});
-	} else if (item.type === "reasoning" && item.summary !== void 0) deltas.push({
-		type: "reasoning_delta",
-		text: item.summary,
+const itemToDeltas = Match.type().pipe(Match.discriminators("type")({
+	message: (m) => m.role === "assistant" ? m.content.filter(isOutputText).map((b) => TurnEvent.TextDelta({ text: b.text })) : [],
+	function_call: (fc) => [TurnEvent.ToolCallStart({
+		call_id: fc.call_id,
+		name: fc.name
+	}), TurnEvent.ToolCallArgsDelta({
+		call_id: fc.call_id,
+		delta: fc.arguments
+	})],
+	function_call_output: () => [],
+	reasoning: (r) => r.summary !== void 0 ? [TurnEvent.ReasoningDelta({
+		text: r.summary,
 		kind: "summary"
-	});
-	deltas.push({
-		type: "turn_complete",
-		turn
-	});
-	return deltas;
-};
+	})] : []
+}), Match.exhaustive);
+const turnToDeltas = (turn) => [...turn.items.flatMap(itemToDeltas), TurnEvent.TurnComplete({ turn })];
 const pacedDeltas = (turn, options) => {
 	const base = Stream.fromIterable(turnToDeltas(turn));
 	return options?.deltaInterval === void 0 ? base : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)));
 };
-const makeService = (scriptedTurns, options, recordCall) => Effect.gen(function* () {
-	const cursor = yield* Ref.make(0);
-	return LanguageModel.of({ streamTurn: (request) => Stream.unwrap(Effect.gen(function* () {
-		const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1);
-		if (i >= scriptedTurns.length) return Stream.fail(new InvalidRequest({
-			provider: "mock",
-			raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`
-		}));
-		const turn = scriptedTurns[i];
-		if (recordCall !== void 0) yield* recordCall(request.history, turn);
-		return pacedDeltas(turn, options);
-	})) });
+const exhausted = (n, attempt) => new InvalidRequest({
+	provider: "mock",
+	raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`
 });
-const layer = (scriptedTurns, options) => Layer.effect(LanguageModel, makeService(scriptedTurns, options));
-/**
-* Synchronous constructor that returns the `LanguageModelService` value
-* directly, plus a recorder. Use this when you want to swap models
-* mid-stream via `Effect.provideService` instead of providing one model
-* for the whole program via `Layer`.
-*/
-const make = (scriptedTurns, options) => {
-	const cursor = Ref.makeUnsafe(0);
-	const callsRef = Ref.makeUnsafe([]);
+const noRecord = (_) => Effect.void;
+const buildService = (scriptedTurns, options, cursor, record) => ({ streamTurn: (request) => Stream.unwrap(Ref.getAndUpdate(cursor, (n) => n + 1).pipe(Effect.flatMap((i) => Option.match(Array.get(scriptedTurns, i), {
+	onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),
+	onSome: (turn) => record({
+		history: request.history,
+		turn
+	}).pipe(Effect.as(pacedDeltas(turn, options)))
+})))) });
+const makeRecorderUnsafe = () => {
+	const ref = Ref.makeUnsafe([]);
 	return {
-		service: { streamTurn: (request) => Stream.unwrap(Effect.gen(function* () {
-			const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1);
-			if (i >= scriptedTurns.length) return Stream.fail(new InvalidRequest({
-				provider: "mock",
-				raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`
-			}));
-			const turn = scriptedTurns[i];
-			yield* Ref.update(callsRef, (xs) => [...xs, {
-				history: request.history,
-				turn
-			}]);
-			return pacedDeltas(turn, options);
-		})) },
-		recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls })))
+		record: (call) => Ref.update(ref, Array.append(call)),
+		recorder: Ref.get(ref).pipe(Effect.map((calls) => ({ calls })))
 	};
 };
 /**
-* Same as `layer`, but also exposes a recorder that captures every call
+* Layer that registers a `MockProvider` against the `LanguageModel` tag.
+* Calls beyond the scripted turn count fail with `InvalidRequest`.
+*/
+const layer = (scriptedTurns, options) => Layer.effect(LanguageModel, Ref.make(0).pipe(Effect.map((cursor) => buildService(scriptedTurns, options, cursor, noRecord))));
+/**
+* Like `layer`, but also exposes a recorder that captures every call
 * (history + returned turn).
 */
 const layerWithRecorder = (scriptedTurns, options) => {
-	const callsRef = Ref.makeUnsafe([]);
+	const { record, recorder } = makeRecorderUnsafe();
+	return {
+		layer: Layer.effect(LanguageModel, Ref.make(0).pipe(Effect.map((cursor) => buildService(scriptedTurns, options, cursor, record)))),
+		recorder
+	};
+};
+/**
+* Build the `LanguageModelService` value directly (no Layer), plus a
+* recorder. Use this when you want to swap models mid-program via
+* `Effect.provideService` instead of providing one model for the whole
+* program via `Layer`.
+*/
+const make = (scriptedTurns, options) => {
+	const cursor = Ref.makeUnsafe(0);
+	const { record, recorder } = makeRecorderUnsafe();
 	return {
-		layer: Layer.effect(LanguageModel, makeService(scriptedTurns, options, (history, turn) => Ref.update(callsRef, (xs) => [...xs, {
-			history,
-			turn
-		}]))),
-		recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls })))
+		service: buildService(scriptedTurns, options, cursor, record),
+		recorder
 	};
 };
 //#endregion

package/dist/testing/MockProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MockProvider.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockProvider.ts"],"sourcesContent":["import { Duration, Effect, Layer, Ref, Schedule, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Item } from \"../domain/Items.js\"\nimport { LanguageModel, type LanguageModelService } from \"../language-model/LanguageModel.js\"\nimport type { Turn, TurnEvent } from \"../domain/Turn.js\"\n\nexport type MockOptions = {\n  /**\n   * If set, deltas of each scripted turn are spaced by this duration via\n   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic\n   * timing in tests.\n   */\n  readonly deltaInterval?: Duration.Input\n}\n\n/**\n * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,\n * one per call to `streamTurn`. Each scripted turn is split into synthetic\n * deltas (text → tool_call_start → tool_call_args_delta → ... → turn_complete)\n * so streaming consumers can see realistic delta shapes.\n */\nexport type MockRecorder = {\n  readonly calls: ReadonlyArray<{\n    readonly history: ReadonlyArray<Item>\n    readonly turn: Turn\n  }>\n}\n\nconst turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => {\n  const deltas: TurnEvent[] = []\n  for (const item of turn.items) {\n    if (item.type === \"message\" && item.role === \"assistant\") {\n      for (const block of item.content) {\n        if (block.type === \"output_text\") {\n          deltas.push({ type: \"text_delta\", text: block.text })\n        }\n      }\n    } else if (item.type === \"function_call\") {\n      deltas.push({\n        type: \"tool_call_start\",\n        call_id: item.call_id,\n        name: item.name,\n      })\n      deltas.push({\n        type: \"tool_call_args_delta\",\n        call_id: item.call_id,\n        delta: item.arguments,\n      })\n    } else if (item.type === \"reasoning\" && item.summary !== undefined) {\n      deltas.push({ type: \"reasoning_delta\", text: item.summary, kind: \"summary\" })\n    }\n  }\n  deltas.push({ type: \"turn_complete\", turn })\n  return deltas\n}\n\nconst pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {\n  const base = Stream.fromIterable(turnToDeltas(turn))\n  return options?.deltaInterval === undefined\n    ? base\n    : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))\n}\n\nconst makeService = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n  recordCall?: (history: ReadonlyArray<Item>, turn: Turn) => Effect.Effect<void>,\n) =>\n  Effect.gen(function* () {\n    const cursor = yield* Ref.make(0)\n    return LanguageModel.of({\n      streamTurn: (request) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)\n            if (i >= scriptedTurns.length) {\n              return Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,\n                }),\n              )\n            }\n            const turn = scriptedTurns[i]!\n            if (recordCall !== undefined) {\n              yield* recordCall(request.history, turn)\n            }\n            return pacedDeltas(turn, options)\n          }),\n        ),\n    })\n  })\n\nexport const layer = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): Layer.Layer<LanguageModel> => Layer.effect(LanguageModel, makeService(scriptedTurns, options))\n\n/**\n * Synchronous constructor that returns the `LanguageModelService` value\n * directly, plus a recorder. Use this when you want to swap models\n * mid-stream via `Effect.provideService` instead of providing one model\n * for the whole program via `Layer`.\n */\nexport const make = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly service: LanguageModelService\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const cursor = Ref.makeUnsafe(0)\n  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])\n  const service: LanguageModelService = {\n    streamTurn: (request) =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)\n          if (i >= scriptedTurns.length) {\n            return Stream.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          const turn = scriptedTurns[i]!\n          yield* Ref.update(callsRef, (xs) => [...xs, { history: request.history, turn }])\n          return pacedDeltas(turn, options)\n        }),\n      ),\n  }\n  return {\n    service,\n    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),\n  }\n}\n\n/**\n * Same as `layer`, but also exposes a recorder that captures every call\n * (history + returned turn).\n */\nexport const layerWithRecorder = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly layer: Layer.Layer<LanguageModel>\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])\n  const live = Layer.effect(\n    LanguageModel,\n    makeService(scriptedTurns, options, (history, turn) =>\n      Ref.update(callsRef, (xs) => [...xs, { history, turn }]),\n    ),\n  )\n  return {\n    layer: live,\n    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"MockProvider.mjs","names":["AiError.InvalidRequest","Arr"],"sources":["../../src/testing/MockProvider.ts"],"sourcesContent":["import { Array as Arr, Duration, Effect, Layer, Match, Option, Ref, Schedule, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport { type Item, isOutputText } from \"../domain/Items.js\"\nimport { LanguageModel, type LanguageModelService } from \"../language-model/LanguageModel.js\"\nimport { type Turn, TurnEvent } from \"../domain/Turn.js\"\n\nexport type MockOptions = {\n  /**\n   * If set, deltas of each scripted turn are spaced by this duration via\n   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic\n   * timing in tests.\n   */\n  readonly deltaInterval?: Duration.Input\n}\n\nexport type Call = {\n  readonly history: ReadonlyArray<Item>\n  readonly turn: Turn\n}\n\n/**\n * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,\n * one per call to `streamTurn`. Each scripted turn is split into synthetic\n * deltas (text → ToolCallStart → ToolCallArgsDelta → ... → TurnComplete)\n * so streaming consumers can see realistic delta shapes.\n */\nexport type MockRecorder = {\n  readonly calls: ReadonlyArray<Call>\n}\n\n// ---------------------------------------------------------------------------\n// Pure projection: Turn → ReadonlyArray<TurnEvent>\n// ---------------------------------------------------------------------------\n\nconst itemToDeltas: (item: Item) => ReadonlyArray<TurnEvent> = Match.type<Item>().pipe(\n  Match.discriminators(\"type\")({\n    message: (m): ReadonlyArray<TurnEvent> =>\n      m.role === \"assistant\"\n        ? m.content.filter(isOutputText).map((b) => TurnEvent.TextDelta({ text: b.text }))\n        : [],\n    function_call: (fc) => [\n      TurnEvent.ToolCallStart({ call_id: fc.call_id, name: fc.name }),\n      TurnEvent.ToolCallArgsDelta({ call_id: fc.call_id, delta: fc.arguments }),\n    ],\n    function_call_output: () => [],\n    reasoning: (r) =>\n      r.summary !== undefined\n        ? [TurnEvent.ReasoningDelta({ text: r.summary, kind: \"summary\" as const })]\n        : [],\n  }),\n  Match.exhaustive,\n)\n\nconst turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => [\n  ...turn.items.flatMap(itemToDeltas),\n  TurnEvent.TurnComplete({ turn }),\n]\n\nconst pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {\n  const base = Stream.fromIterable(turnToDeltas(turn))\n  return options?.deltaInterval === undefined\n    ? base\n    : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))\n}\n\n// ---------------------------------------------------------------------------\n// Canonical service factory. One implementation; sync/Layer/recorder\n// variants below are just different ways to wire the cursor + record hook.\n// ---------------------------------------------------------------------------\n\nconst exhausted = (n: number, attempt: number): AiError.AiError =>\n  new AiError.InvalidRequest({\n    provider: \"mock\",\n    raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`,\n  })\n\nconst noRecord = (_: Call): Effect.Effect<void> => Effect.void\n\nconst buildService = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options: MockOptions | undefined,\n  cursor: Ref.Ref<number>,\n  record: (call: Call) => Effect.Effect<void>,\n): LanguageModelService => ({\n  streamTurn: (request) =>\n    Stream.unwrap(\n      Ref.getAndUpdate(cursor, (n) => n + 1).pipe(\n        Effect.flatMap(\n          (i): Effect.Effect<Stream.Stream<TurnEvent, AiError.AiError>> =>\n            Option.match(Arr.get(scriptedTurns, i), {\n              onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),\n              onSome: (turn) =>\n                record({ history: request.history, turn }).pipe(\n                  Effect.as(pacedDeltas(turn, options)),\n                ),\n            }),\n        ),\n      ),\n    ),\n})\n\n// ---------------------------------------------------------------------------\n// Recorder handle. Unsafe Ref is local: it backs both the `record` write\n// hook (called inside the service) and the `recorder` read effect (called\n// by the test). Both close over the same cell.\n// ---------------------------------------------------------------------------\n\ntype RecorderHandle = {\n  readonly record: (call: Call) => Effect.Effect<void>\n  readonly recorder: Effect.Effect<MockRecorder>\n}\n\nconst makeRecorderUnsafe = (): RecorderHandle => {\n  const ref = Ref.makeUnsafe<ReadonlyArray<Call>>([])\n  return {\n    record: (call) => Ref.update(ref, Arr.append(call)),\n    recorder: Ref.get(ref).pipe(Effect.map((calls): MockRecorder => ({ calls }))),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Layer that registers a `MockProvider` against the `LanguageModel` tag.\n * Calls beyond the scripted turn count fail with `InvalidRequest`.\n */\nexport const layer = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): Layer.Layer<LanguageModel> =>\n  Layer.effect(\n    LanguageModel,\n    Ref.make(0).pipe(\n      Effect.map((cursor) => buildService(scriptedTurns, options, cursor, noRecord)),\n    ),\n  )\n\n/**\n * Like `layer`, but also exposes a recorder that captures every call\n * (history + returned turn).\n */\nexport const layerWithRecorder = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly layer: Layer.Layer<LanguageModel>\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    layer: Layer.effect(\n      LanguageModel,\n      Ref.make(0).pipe(\n        Effect.map((cursor) => buildService(scriptedTurns, options, cursor, record)),\n      ),\n    ),\n    recorder,\n  }\n}\n\n/**\n * Build the `LanguageModelService` value directly (no Layer), plus a\n * recorder. Use this when you want to swap models mid-program via\n * `Effect.provideService` instead of providing one model for the whole\n * program via `Layer`.\n */\nexport const make = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly service: LanguageModelService\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const cursor = Ref.makeUnsafe(0)\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    service: buildService(scriptedTurns, options, cursor, record),\n    recorder,\n  }\n}\n"],"mappings":";;;;;;AAkCA,MAAM,eAAyD,MAAM,MAAY,CAAC,KAChF,MAAM,eAAe,OAAO,CAAC;CAC3B,UAAU,MACR,EAAE,SAAS,cACP,EAAE,QAAQ,OAAO,aAAa,CAAC,KAAK,MAAM,UAAU,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAChF,EAAE;CACR,gBAAgB,OAAO,CACrB,UAAU,cAAc;EAAE,SAAS,GAAG;EAAS,MAAM,GAAG;EAAM,CAAC,EAC/D,UAAU,kBAAkB;EAAE,SAAS,GAAG;EAAS,OAAO,GAAG;EAAW,CAAC,CAC1E;CACD,4BAA4B,EAAE;CAC9B,YAAY,MACV,EAAE,YAAY,KAAA,IACV,CAAC,UAAU,eAAe;EAAE,MAAM,EAAE;EAAS,MAAM;EAAoB,CAAC,CAAC,GACzE,EAAE;CACT,CAAC,EACF,MAAM,WACP;AAED,MAAM,gBAAgB,SAAyC,CAC7D,GAAG,KAAK,MAAM,QAAQ,aAAa,EACnC,UAAU,aAAa,EAAE,MAAM,CAAC,CACjC;AAED,MAAM,eAAe,MAAY,YAAoD;CACnF,MAAM,OAAO,OAAO,aAAa,aAAa,KAAK,CAAC;AACpD,QAAO,SAAS,kBAAkB,KAAA,IAC9B,OACA,KAAK,KAAK,OAAO,SAAS,SAAS,OAAO,QAAQ,cAAc,CAAC,CAAC;;AAQxE,MAAM,aAAa,GAAW,YAC5B,IAAIA,eAAuB;CACzB,UAAU;CACV,KAAK,2BAA2B,EAAE,4BAA4B,QAAQ;CACvE,CAAC;AAEJ,MAAM,YAAY,MAAiC,OAAO;AAE1D,MAAM,gBACJ,eACA,SACA,QACA,YAC0B,EAC1B,aAAa,YACX,OAAO,OACL,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE,CAAC,KACrC,OAAO,SACJ,MACC,OAAO,MAAMC,MAAI,IAAI,eAAe,EAAE,EAAE;CACtC,cAAc,OAAO,QAAQ,OAAO,KAAK,UAAU,cAAc,QAAQ,IAAI,EAAE,CAAC,CAAC;CACjF,SAAS,SACP,OAAO;EAAE,SAAS,QAAQ;EAAS;EAAM,CAAC,CAAC,KACzC,OAAO,GAAG,YAAY,MAAM,QAAQ,CAAC,CACtC;CACJ,CAAC,CACL,CACF,CACF,EACJ;AAaD,MAAM,2BAA2C;CAC/C,MAAM,MAAM,IAAI,WAAgC,EAAE,CAAC;AACnD,QAAO;EACL,SAAS,SAAS,IAAI,OAAO,KAAKA,MAAI,OAAO,KAAK,CAAC;EACnD,UAAU,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,WAAyB,EAAE,OAAO,EAAE,CAAC;EAC9E;;;;;;AAWH,MAAa,SACX,eACA,YAEA,MAAM,OACJ,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,SAAS,CAAC,CAC/E,CACF;;;;;AAMH,MAAa,qBACX,eACA,YAIG;CACH,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,OAAO,MAAM,OACX,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,OAAO,CAAC,CAC7E,CACF;EACD;EACD;;;;;;;;AASH,MAAa,QACX,eACA,YAIG;CACH,MAAM,SAAS,IAAI,WAAW,EAAE;CAChC,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,SAAS,aAAa,eAAe,SAAS,QAAQ,OAAO;EAC7D;EACD"}

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

@@ -1 +1 @@
-{"version":3,"file":"MockSpeechSynthesizer.d.mts","names":[],"sources":["../../src/testing/MockSpeechSynthesizer.ts"],"mappings":";;;;;KAWY,uBAAA;EAAA,SACD,eAAA,EAAiB,aAAA,CAAc,uBAAA;EAAA,SAC/B,oBAAA,EAAsB,aAAA,CAAc,uBAAA;EAAA,SACpC,wBAAA,EAA0B,aAAA,CAAc,6BAAA;AAAA;AAAA,KAGvC,qBAAA;EALgB,kEAOjB,KAAA,GAAQ,aAAA,CAAc,SAAA,GANA;EAAA,SAQtB,qBAAA,GAAwB,aAAA,CAAc,aAAA,CAAc,UAAA,IAP1B;EAAA,SAS1B,yBAAA,GAA4B,aAAA,CAAc,aAAA,CAAc,UAAA;AAAA;;;;;;cAgFtD,KAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,iBAAA,GAAoB,kBAAA;EAAA,SACvC,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA;;;AA1FnC;;;;cAyHa,uBAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,iBAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA"}
+{"version":3,"file":"MockSpeechSynthesizer.d.mts","names":[],"sources":["../../src/testing/MockSpeechSynthesizer.ts"],"mappings":";;;;;KAWY,uBAAA;EAAA,SACD,eAAA,EAAiB,aAAA,CAAc,uBAAA;EAAA,SAC/B,oBAAA,EAAsB,aAAA,CAAc,uBAAA;EAAA,SACpC,wBAAA,EAA0B,aAAA,CAAc,6BAAA;AAAA;AAAA,KAGvC,qBAAA;EALgB,kEAOjB,KAAA,GAAQ,aAAA,CAAc,SAAA,GANA;EAAA,SAQtB,qBAAA,GAAwB,aAAA,CAAc,aAAA,CAAc,UAAA,IAP1B;EAAA,SAS1B,yBAAA,GAA4B,aAAA,CAAc,aAAA,CAAc,UAAA;AAAA;;;;;;cA8EtD,KAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,iBAAA,GAAoB,kBAAA;EAAA,SACvC,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA;;;AAxFnC;;;;cAuHa,uBAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,iBAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA"}

package/dist/testing/MockSpeechSynthesizer.mjs

@@ -11,10 +11,10 @@ const makeService = (script, record) => 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({
+			if (i >= scripted.length) return yield* 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* () {

package/dist/testing/MockSpeechSynthesizer.mjs.map

@@ -1 +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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"}
+{"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* new AiError.InvalidRequest({\n              provider: \"mock\",\n              raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`,\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.map

@@ -1 +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"}
+{"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;;;;;;cA2DpC,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

@@ -10,10 +10,10 @@ const makeService = (script, record) => 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({
+			if (i >= scripted.length) return yield* 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* () {

package/dist/testing/MockTranscriber.mjs.map

@@ -1 +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"}
+{"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* new AiError.InvalidRequest({\n              provider: \"mock\",\n              raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`,\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;AAuClC,QAAO;EArCL,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,IAAIA,eAAuB;IACvC,UAAU;IACV,KAAK,8BAA8B,SAAS,OAAO,kCAAkC,IAAI,EAAE;IAC5F,CAAC;AAEJ,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-Hg5AsYxl.mjs";
+import { d as Item, o as FunctionCall } from "../Items-BH8xUkoR.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-Hg5AsYxl.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "../Items-BH8xUkoR.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 

package/dist/tool/Resolvers.d.mts

@@ -1,7 +1,8 @@
-import { o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
+import { o as FunctionCall } from "../Items-BH8xUkoR.mjs";
 import { ToolResult } from "./Outcome.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";
-import { Effect, Queue, Scope, Stream } from "effect";
+import { Data, Effect, Queue, Scope, Stream } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
 
 //#region src/tool/Resolvers.d.ts
 declare namespace Resolvers_d_exports {
@@ -11,12 +12,68 @@ type ToolCallPlan = {
   readonly approved: ReadonlyArray<FunctionCall>;
   readonly rejected: ReadonlyArray<ToolResult>;
 };
-type ToolCallDecision = {
-  readonly _tag: "Approved";
-  readonly call: FunctionCall;
-} | {
-  readonly _tag: "Rejected";
-  readonly result: ToolResult;
+type ToolCallDecision = Data.TaggedEnum<{
+  Approved: {
+    readonly call: FunctionCall;
+  };
+  Rejected: {
+    readonly result: ToolResult;
+  };
+}>;
+declare const ToolCallDecision: {
+  readonly Approved: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Approved";
+    readonly call: FunctionCall;
+  }, "_tag">;
+  readonly Rejected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Rejected";
+    readonly result: ToolResult;
+  }, "_tag">;
+  readonly $is: <Tag extends "Approved" | "Rejected">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Approved";
+    readonly call: FunctionCall;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Rejected";
+    readonly result: ToolResult;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Approved: (args: {
+        readonly _tag: "Approved";
+        readonly call: FunctionCall;
+      }) => any;
+      readonly Rejected: (args: {
+        readonly _tag: "Rejected";
+        readonly result: ToolResult;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Approved";
+      readonly call: FunctionCall;
+    } | {
+      readonly _tag: "Rejected";
+      readonly result: ToolResult;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["Approved" | "Rejected"]>>;
+    <Cases extends {
+      readonly Approved: (args: {
+        readonly _tag: "Approved";
+        readonly call: FunctionCall;
+      }) => any;
+      readonly Rejected: (args: {
+        readonly _tag: "Rejected";
+        readonly result: ToolResult;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Approved";
+      readonly call: FunctionCall;
+    } | {
+      readonly _tag: "Rejected";
+      readonly result: ToolResult;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Approved" | "Rejected"]>>;
+  };
 };
 declare const approve: (call: FunctionCall) => ToolCallDecision;
 declare const reject: (result: ToolResult) => ToolCallDecision;

package/dist/tool/Resolvers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;;;KAYY,YAAA;EAAA,SACD,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,IAAA,EAAM,YAAA;AAAA;EAAA,SACjC,IAAA;EAAA,SAA2B,MAAA,EAAQ,UAAA;AAAA;AAAA,cAErC,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAKhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAK/B,sBAAA,GAA0B,SAAA,EAAW,aAAA,CAAc,gBAAA,MAAoB,YAAA;AAAA,cASvE,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,KAW3C,OAAA;EAAA,SACD,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;cAQE,gBAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAEnE,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,SAAA,EAAW,MAAA,CAAO,MAAA,CAAO,gBAAA;EAAA,SACzB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAC3E,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}
+{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;;;;KAYY,YAAA;EAAA,SACD,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA,GAAmB,IAAA,CAAK,UAAA;EAClC,QAAA;IAAA,SAAqB,IAAA,EAAM,YAAA;EAAA;EAC3B,QAAA;IAAA,SAAqB,MAAA,EAAQ,UAAA;EAAA;AAAA;AAAA,cAGlB,gBAAA;EAAA;;mBAJgB,YAAA;EAAA;EAAA;;qBACE,UAAA;EAAA;EAAA;;mBADF,YAAA;EAAA;IAAA;;;qBACE,UAAA;EAAA;IAAA;;;;;;uBADF,YAAA;MAAA;MAAA;;yBACE,UAAA;MAAA;IAAA;;qBADF,YAAA;IAAA;MAAA;uBACE,UAAA;IAAA;;;;uBADF,YAAA;MAAA;MAAA;;yBACE,UAAA;MAAA;IAAA;;qBADF,YAAA;IAAA;MAAA;uBACE,UAAA;IAAA;;;cAKlB,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAEhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAG/B,sBAAA,GAA0B,SAAA,EAAW,aAAA,CAAc,gBAAA,MAAoB,YAAA;AAAA,cASvE,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,KAW3C,OAAA;EAAA,SACD,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;cAQE,gBAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAEnE,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,SAAA,EAAW,MAAA,CAAO,MAAA,CAAO,gBAAA;EAAA,SACzB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAC3E,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}

package/dist/tool/Resolvers.mjs

@@ -1,6 +1,7 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { cancelled, denied } from "./Outcome.mjs";
-import { Deferred, Effect, Queue, Stream } from "effect";
+import { ToolEvent } from "./ToolEvent.mjs";
+import { Data, Deferred, Effect, Queue, Stream } from "effect";
 //#region src/tool/Resolvers.ts
 /**
 * Approval helpers for the two transport flavors.
@@ -10,6 +11,7 @@ import { Deferred, Effect, Queue, Stream } from "effect";
 * the recipe boundary via `Toolkit.executeAll`.
 */
 var Resolvers_exports = /* @__PURE__ */ __exportAll({
+	ToolCallDecision: () => ToolCallDecision,
 	approvalRequested: () => approvalRequested,
 	approve: () => approve,
 	fromApprovalMap: () => fromApprovalMap,
@@ -17,14 +19,9 @@ var Resolvers_exports = /* @__PURE__ */ __exportAll({
 	reject: () => reject,
 	splitToolCallDecisions: () => splitToolCallDecisions
 });
-const approve = (call) => ({
-	_tag: "Approved",
-	call
-});
-const reject = (result) => ({
-	_tag: "Rejected",
-	result
-});
+const ToolCallDecision = Data.taggedEnum();
+const approve = (call) => ToolCallDecision.Approved({ call });
+const reject = (result) => ToolCallDecision.Rejected({ result });
 const splitToolCallDecisions = (decisions) => decisions.reduce((acc, decision) => decision._tag === "Approved" ? {
 	...acc,
 	approved: [...acc.approved, decision.call]
@@ -35,8 +32,7 @@ const splitToolCallDecisions = (decisions) => decisions.reduce((acc, decision) =
 	approved: [],
 	rejected: []
 });
-const approvalRequested = (call) => ({
-	_tag: "ApprovalRequested",
+const approvalRequested = (call) => ToolEvent.ApprovalRequested({
 	call_id: call.call_id,
 	tool: call.name,
 	arguments: call.arguments
@@ -72,6 +68,6 @@ const fromApprovalMap = (predicate, approvals) => (calls) => splitToolCallDecisi
 	return v.decision === "approve" ? approve(call) : reject(denied(call, v.reason));
 }));
 //#endregion
-export { approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions, Resolvers_exports as t };
+export { ToolCallDecision, approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions, Resolvers_exports as t };
 
 //# sourceMappingURL=Resolvers.mjs.map

package/dist/tool/Resolvers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.ts"],"sourcesContent":["/**\n * Approval helpers for the two transport flavors.\n *\n * These helpers only decide which calls are approved and which synthetic\n * results must be returned to the model. Tool execution stays explicit at\n * the recipe boundary via `Toolkit.executeAll`.\n */\nimport { Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./Outcome.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\n\nexport type ToolCallPlan = {\n  readonly approved: ReadonlyArray<FunctionCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ToolCallDecision =\n  | { readonly _tag: \"Approved\"; readonly call: FunctionCall }\n  | { readonly _tag: \"Rejected\"; readonly result: ToolResult }\n\nexport const approve = (call: FunctionCall): ToolCallDecision => ({\n  _tag: \"Approved\",\n  call,\n})\n\nexport const reject = (result: ToolResult): ToolCallDecision => ({\n  _tag: \"Rejected\",\n  result,\n})\n\nexport const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision>): ToolCallPlan =>\n  decisions.reduce<ToolCallPlan>(\n    (acc, decision) =>\n      decision._tag === \"Approved\"\n        ? { ...acc, approved: [...acc.approved, decision.call] }\n        : { ...acc, rejected: [...acc.rejected, decision.result] },\n    { approved: [], rejected: [] },\n  )\n\nexport const approvalRequested = (call: FunctionCall): ToolEvent => ({\n  _tag: \"ApprovalRequested\",\n  call_id: call.call_id,\n  tool: call.name,\n  arguments: call.arguments,\n})\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport type Verdict = {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ToolCallDecision` when their matching verdict arrives.\n */\nexport const fromVerdictQueue =\n  (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<FunctionCall>\n      readonly decisions: Stream.Stream<ToolCallDecision>\n      readonly announce: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n      const approved = calls.filter((call) => !predicate(call))\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap(\n          (call) => {\n            const d = deferreds.get(call.call_id)!\n            return Stream.fromEffect(\n              Deferred.await(d).pipe(\n                Effect.map((v) =>\n                  v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason)),\n                ),\n              ),\n            )\n          },\n          { concurrency: \"unbounded\" },\n        ),\n      )\n\n      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, announce }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromApprovalMap =\n  (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>\n  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>\n    splitToolCallDecisions(\n      calls.map((call) => {\n        if (!predicate(call)) return approve(call)\n        const v = approvals.get(call.call_id)\n        if (v === undefined) return reject(cancelled(call))\n        return v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason))\n      }),\n    )\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqBA,MAAa,WAAW,UAA0C;CAChE,MAAM;CACN;CACD;AAED,MAAa,UAAU,YAA0C;CAC/D,MAAM;CACN;CACD;AAED,MAAa,0BAA0B,cACrC,UAAU,QACP,KAAK,aACJ,SAAS,SAAS,aACd;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,KAAK;CAAE,GACtD;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,OAAO;CAAE,EAC9D;CAAE,UAAU,EAAE;CAAE,UAAU,EAAE;CAAE,CAC/B;AAEH,MAAa,qBAAqB,UAAmC;CACnE,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX,WAAW,KAAK;CACjB;;;;;;AAiBD,MAAa,oBACV,WAA4C,cAE3C,UAUA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CACrC,MAAM,WAAW,MAAM,QAAQ,SAAS,CAAC,UAAU,KAAK,CAAC;CAEzD,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;AAoBD,QAAO;EAAE;EAAU,WAlBD,OAAO,aAAa,MAAM,CAAC,KAC3C,OAAO,SACJ,SAAS;GACR,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,UAAO,OAAO,WACZ,SAAS,MAAM,EAAE,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CAC1E,CACF,CACF;KAEH,EAAE,aAAa,aAAa,CAC7B,CAKyB;EAAE,UAFb,OAAO,aAAwB,MAAM,IAAI,kBAAkB,CAEtC;EAAE;EACxC;AAWN,MAAa,mBACV,WAA4C,eAC5C,UACC,uBACE,MAAM,KAAK,SAAS;AAClB,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,QAAQ,KAAK;CAC1C,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,UAAU,KAAK,CAAC;AACnD,QAAO,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC;EAChF,CACH"}
+{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.ts"],"sourcesContent":["/**\n * Approval helpers for the two transport flavors.\n *\n * These helpers only decide which calls are approved and which synthetic\n * results must be returned to the model. Tool execution stays explicit at\n * the recipe boundary via `Toolkit.executeAll`.\n */\nimport { Data, Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./Outcome.js\"\nimport { ToolEvent } from \"./ToolEvent.js\"\n\nexport type ToolCallPlan = {\n  readonly approved: ReadonlyArray<FunctionCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ToolCallDecision = Data.TaggedEnum<{\n  Approved: { readonly call: FunctionCall }\n  Rejected: { readonly result: ToolResult }\n}>\n\nexport const ToolCallDecision = Data.taggedEnum<ToolCallDecision>()\n\nexport const approve = (call: FunctionCall): ToolCallDecision => ToolCallDecision.Approved({ call })\n\nexport const reject = (result: ToolResult): ToolCallDecision =>\n  ToolCallDecision.Rejected({ result })\n\nexport const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision>): ToolCallPlan =>\n  decisions.reduce<ToolCallPlan>(\n    (acc, decision) =>\n      decision._tag === \"Approved\"\n        ? { ...acc, approved: [...acc.approved, decision.call] }\n        : { ...acc, rejected: [...acc.rejected, decision.result] },\n    { approved: [], rejected: [] },\n  )\n\nexport const approvalRequested = (call: FunctionCall): ToolEvent =>\n  ToolEvent.ApprovalRequested({\n    call_id: call.call_id,\n    tool: call.name,\n    arguments: call.arguments,\n  })\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport type Verdict = {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ToolCallDecision` when their matching verdict arrives.\n */\nexport const fromVerdictQueue =\n  (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<FunctionCall>\n      readonly decisions: Stream.Stream<ToolCallDecision>\n      readonly announce: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n      const approved = calls.filter((call) => !predicate(call))\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap(\n          (call) => {\n            const d = deferreds.get(call.call_id)!\n            return Stream.fromEffect(\n              Deferred.await(d).pipe(\n                Effect.map((v) =>\n                  v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason)),\n                ),\n              ),\n            )\n          },\n          { concurrency: \"unbounded\" },\n        ),\n      )\n\n      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, announce }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromApprovalMap =\n  (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>\n  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>\n    splitToolCallDecisions(\n      calls.map((call) => {\n        if (!predicate(call)) return approve(call)\n        const v = approvals.get(call.call_id)\n        if (v === undefined) return reject(cancelled(call))\n        return v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason))\n      }),\n    )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,mBAAmB,KAAK,YAA8B;AAEnE,MAAa,WAAW,SAAyC,iBAAiB,SAAS,EAAE,MAAM,CAAC;AAEpG,MAAa,UAAU,WACrB,iBAAiB,SAAS,EAAE,QAAQ,CAAC;AAEvC,MAAa,0BAA0B,cACrC,UAAU,QACP,KAAK,aACJ,SAAS,SAAS,aACd;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,KAAK;CAAE,GACtD;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,OAAO;CAAE,EAC9D;CAAE,UAAU,EAAE;CAAE,UAAU,EAAE;CAAE,CAC/B;AAEH,MAAa,qBAAqB,SAChC,UAAU,kBAAkB;CAC1B,SAAS,KAAK;CACd,MAAM,KAAK;CACX,WAAW,KAAK;CACjB,CAAC;;;;;;AAiBJ,MAAa,oBACV,WAA4C,cAE3C,UAUA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CACrC,MAAM,WAAW,MAAM,QAAQ,SAAS,CAAC,UAAU,KAAK,CAAC;CAEzD,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;AAoBD,QAAO;EAAE;EAAU,WAlBD,OAAO,aAAa,MAAM,CAAC,KAC3C,OAAO,SACJ,SAAS;GACR,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,UAAO,OAAO,WACZ,SAAS,MAAM,EAAE,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CAC1E,CACF,CACF;KAEH,EAAE,aAAa,aAAa,CAC7B,CAKyB;EAAE,UAFb,OAAO,aAAwB,MAAM,IAAI,kBAAkB,CAEtC;EAAE;EACxC;AAWN,MAAa,mBACV,WAA4C,eAC5C,UACC,uBACE,MAAM,KAAK,SAAS;AAClB,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,QAAQ,KAAK;CAC1C,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,UAAU,KAAK,CAAC;AACnD,QAAO,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC;EAChF,CACH"}