@effect-uai/core 0.1.0

package/dist/loop/Loop.mjs

@@ -0,0 +1,172 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { IncompleteTurn } from "../domain/AiError.mjs";
+import { isTurnComplete } from "../domain/Turn.mjs";
+import { Cause, Channel, Data, Effect, Exit, Function, Option, Ref, Scope, Stream } from "effect";
+//#region src/loop/Loop.ts
+/**
+* Pull-based `loop` for state-threaded sub-streams.
+*
+* Each iteration runs a body that returns a `Stream<Event<A, S>>`. The body
+* emits values via `Loop.value(a)` and signals iteration control via
+* `Loop.next(state)` (continue with new state) or `Loop.stop` (terminate).
+* The loop unwraps `Value` events back to `A` for downstream consumers, so
+* the resulting stream is a plain `Stream<A>`.
+*
+* The next body stream is only pulled when downstream pulls the outer
+* stream - no producer fiber, no queue buffering. Cancellation, failures,
+* scoped resources, and backpressure stay aligned with normal Stream
+* semantics.
+*
+* Convention: a `Next` or `Stop` event is the terminal element of a body's
+* iteration. Values emitted in the same chunk after one are discarded
+* (their producing side effects may already have run). Prefer the
+* `Loop.nextAfter` / `Loop.stopAfter` helpers to terminate cleanly.
+*/
+var Loop_exports = /* @__PURE__ */ __exportAll({
+	loop: () => loop,
+	next: () => next,
+	nextAfter: () => nextAfter,
+	nextAfterFold: () => nextAfterFold,
+	stop: () => stop,
+	stopAfter: () => stopAfter,
+	stopEvent: () => stopEvent,
+	streamUntilComplete: () => streamUntilComplete,
+	value: () => value
+});
+const Event = Data.taggedEnum();
+/** Wrap a value so it flows through the loop to downstream consumers. */
+const value = (a) => Event.Value({ value: a });
+/** End the current iteration and continue with a new state. */
+const next = (state) => Event.Next({ state });
+/** The terminal `Stop` event. Use `stop` (the Stream) to end a loop body. */
+const stopEvent = Event.Stop();
+/**
+* A single-element stream that ends the loop. Return this from a body when
+* there's nothing else to emit; equivalent to `stopAfter(Stream.empty)` but
+* named for the common case.
+*/
+const stop = Stream.succeed(stopEvent);
+/**
+* Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
+* iteration with `next(state)`. Common shape for "stream this turn's
+* deltas, then continue with updated history."
+*/
+const nextAfter = (stream, state) => Stream.concat(Stream.map(stream, value), Stream.fromIterable([next(state)]));
+/**
+* Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
+* loop. Common shape for "stream this turn's deltas, then we're done."
+*/
+const stopAfter = (stream) => Stream.concat(Stream.map(stream, value), Stream.fromIterable([stopEvent]));
+/**
+* General `nextAfter` variant: drain `stream` to the consumer, fold elements
+* into an accumulator, and at end-of-stream emit one `next(build(finalAcc))`.
+*
+* Subsumes `nextAfter` when state is constant (`reduce: (s, _) => s`,
+* `build: (s) => s`). Used by `Toolkit.nextStateFrom` to collect tool
+* results and build next state without exposing a Ref to recipes.
+*/
+const nextAfterFold = (stream, initial, reduce, build) => Stream.unwrap(Effect.gen(function* () {
+	const ref = yield* Ref.make(initial);
+	const tapped = stream.pipe(Stream.tap((a) => Ref.update(ref, (acc) => reduce(acc, a))), Stream.map(value));
+	const continuation = Stream.fromEffect(Ref.get(ref).pipe(Effect.map((acc) => next(build(acc)))));
+	return tapped.pipe(Stream.concat(continuation));
+}));
+/**
+* Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Event<TurnEvent | A, S>>`.
+* Each delta passes through as `value(delta)` (including the terminal
+* `turn_complete`, so the consumer sees turn boundaries naturally). Once
+* the terminal arrives, `then(turn)` runs and its returned stream of loop
+* events (typically tool outputs followed by `next(state)` or `stop`) is
+* concatenated.
+*
+* Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on
+* the raw delta stream cover anything an `emit`-style callback would do.
+*
+* If the upstream ends without a `turn_complete`, the resulting stream
+* fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
+* you want to recover.
+*/
+const streamUntilComplete = (then) => (deltas) => Stream.unwrap(Effect.gen(function* () {
+	const turnRef = yield* Ref.make(Option.none());
+	const events = deltas.pipe(Stream.tap((delta) => isTurnComplete(delta) ? Ref.set(turnRef, Option.some(delta.turn)) : Effect.void), Stream.map(value));
+	const continuation = Stream.unwrap(Effect.gen(function* () {
+		const opt = yield* Ref.get(turnRef);
+		if (Option.isNone(opt)) return yield* Effect.fail(new IncompleteTurn({}));
+		return yield* then(opt.value);
+	}));
+	return Stream.concat(events, continuation);
+}));
+const isNonEmpty = (array) => array.length > 0;
+const closeBody = (current, exit) => Scope.close(current.scope, exit);
+/**
+* Walk a chunk of `Event<A, S>` until a terminal `Next` or `Stop` is found.
+* Returns the unwrapped values seen so far and (optionally) the terminal
+* event. Anything in the chunk after the terminal is discarded - its
+* producing side effects may have run, but downstream never sees it.
+*/
+const partitionChunk = (chunk) => {
+	const values = [];
+	for (let i = 0; i < chunk.length; i++) {
+		const event = chunk[i];
+		if (event._tag === "Value") values.push(event.value);
+		else return {
+			values,
+			decision: event
+		};
+	}
+	return {
+		values,
+		decision: void 0
+	};
+};
+/**
+* Drive a state-threaded loop body. Each iteration runs `body(state)` to get
+* a `Stream<Event<A, S>>`; values flow downstream, `next(s)` continues with
+* a new state, `stop` ends the loop. See the file header for the full
+* pull-based execution model.
+*
+* Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`
+* (or `pipe(initial, loop(body))`) both work.
+*/
+const loop = Function.dual(2, (initial, body) => Stream.scoped(Stream.fromPull(Effect.gen(function* () {
+	const outerScope = yield* Effect.scope;
+	let state = initial;
+	let current;
+	let done = false;
+	const closeActive = (active, exit) => {
+		if (current === active) current = void 0;
+		return closeBody(active, exit);
+	};
+	yield* Scope.addFinalizerExit(outerScope, (exit) => current === void 0 ? Effect.void : closeActive(current, exit));
+	return Effect.gen(function* () {
+		while (true) {
+			if (done) return yield* Cause.done();
+			if (current === void 0) {
+				const result = body(state);
+				const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result;
+				const bodyScope = yield* Scope.fork(outerScope);
+				current = {
+					scope: bodyScope,
+					pull: yield* Channel.toPullScoped(Stream.toChannel(stream), bodyScope).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))
+				};
+			}
+			const active = current;
+			const chunk = yield* active.pull.pipe(Effect.catchIf(Cause.isDone, () => closeActive(active, Exit.void).pipe(Effect.as(void 0))), Effect.onError((cause) => closeActive(active, Exit.failCause(cause))));
+			if (chunk === void 0) {
+				done = true;
+				return yield* Cause.done();
+			}
+			const { values, decision } = partitionChunk(chunk);
+			if (decision !== void 0) {
+				yield* closeActive(active, Exit.void);
+				if (decision._tag === "Stop") done = true;
+				else if (decision._tag === "Next") state = decision.state;
+			}
+			if (isNonEmpty(values)) return values;
+		}
+	});
+}))));
+//#endregion
+export { loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, Loop_exports as t, value };
+
+//# sourceMappingURL=Loop.mjs.map

package/dist/loop/Loop.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loop.mjs","names":[],"sources":["../../src/loop/Loop.ts"],"sourcesContent":["/**\n * Pull-based `loop` for state-threaded sub-streams.\n *\n * Each iteration runs a body that returns a `Stream<Event<A, S>>`. The body\n * emits values via `Loop.value(a)` and signals iteration control via\n * `Loop.next(state)` (continue with new state) or `Loop.stop` (terminate).\n * The loop unwraps `Value` events back to `A` for downstream consumers, so\n * the resulting stream is a plain `Stream<A>`.\n *\n * The next body stream is only pulled when downstream pulls the outer\n * stream - no producer fiber, no queue buffering. Cancellation, failures,\n * scoped resources, and backpressure stay aligned with normal Stream\n * semantics.\n *\n * Convention: a `Next` or `Stop` event is the terminal element of a body's\n * iteration. Values emitted in the same chunk after one are discarded\n * (their producing side effects may already have run). Prefer the\n * `Loop.nextAfter` / `Loop.stopAfter` helpers to terminate cleanly.\n */\nimport { Cause, Channel, Data, Effect, Exit, Function, Option, Ref, Scope, Stream } from \"effect\"\nimport { IncompleteTurn } from \"../domain/AiError.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n// ---------------------------------------------------------------------------\n// Event type - the body's emit shape\n// ---------------------------------------------------------------------------\n\n/**\n * The tagged union a body emits per pull. `Value` carries a payload that\n * flows downstream. `Next` ends the current iteration and continues with a\n * new state. `Stop` ends the loop entirely.\n */\nexport type Event<A, S> = Data.TaggedEnum<{\n  Value: { readonly value: A }\n  Next: { readonly state: S }\n  Stop: {}\n}>\n\ninterface EventDef extends Data.TaggedEnum.WithGenerics<2> {\n  readonly taggedEnum: Event<this[\"A\"], this[\"B\"]>\n}\n\nconst Event = Data.taggedEnum<EventDef>()\n\n/** Wrap a value so it flows through the loop to downstream consumers. */\nexport const value = <A>(a: A): Event<A, never> => Event.Value({ value: a })\n\n/** End the current iteration and continue with a new state. */\nexport const next = <S>(state: S): Event<never, S> => Event.Next({ state })\n\n/** The terminal `Stop` event. Use `stop` (the Stream) to end a loop body. */\nexport const stopEvent: Event<never, never> = Event.Stop()\n\n/**\n * A single-element stream that ends the loop. Return this from a body when\n * there's nothing else to emit; equivalent to `stopAfter(Stream.empty)` but\n * named for the common case.\n */\nexport const stop: Stream.Stream<Event<never, never>> = Stream.succeed(stopEvent)\n\n/**\n * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the\n * iteration with `next(state)`. Common shape for \"stream this turn's\n * deltas, then continue with updated history.\"\n */\nexport const nextAfter = <S, A, E, R>(\n  stream: Stream.Stream<A, E, R>,\n  state: S,\n): Stream.Stream<Event<A, S>, E, R> =>\n  Stream.concat(Stream.map(stream, value), Stream.fromIterable([next(state)]))\n\n/**\n * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the\n * loop. Common shape for \"stream this turn's deltas, then we're done.\"\n */\nexport const stopAfter = <A, E, R>(\n  stream: Stream.Stream<A, E, R>,\n): Stream.Stream<Event<A, never>, E, R> =>\n  Stream.concat(Stream.map(stream, value), Stream.fromIterable([stopEvent]))\n\n/**\n * General `nextAfter` variant: drain `stream` to the consumer, fold elements\n * into an accumulator, and at end-of-stream emit one `next(build(finalAcc))`.\n *\n * Subsumes `nextAfter` when state is constant (`reduce: (s, _) => s`,\n * `build: (s) => s`). Used by `Toolkit.nextStateFrom` to collect tool\n * results and build next state without exposing a Ref to recipes.\n */\nexport const nextAfterFold = <A, B, S, E, R>(\n  stream: Stream.Stream<A, E, R>,\n  initial: B,\n  reduce: (acc: B, a: A) => B,\n  build: (b: B) => S,\n): Stream.Stream<Event<A, S>, E, R> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const ref = yield* Ref.make(initial)\n      const tapped = stream.pipe(\n        Stream.tap((a) => Ref.update(ref, (acc) => reduce(acc, a))),\n        Stream.map(value),\n      )\n      const continuation = Stream.fromEffect(\n        Ref.get(ref).pipe(Effect.map((acc) => next(build(acc)))),\n      )\n      return tapped.pipe(Stream.concat(continuation))\n    }),\n  )\n\n// ---------------------------------------------------------------------------\n// streamUntilComplete - turn-aware stream operator for loop bodies\n// ---------------------------------------------------------------------------\n\n/**\n * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Event<TurnEvent | A, S>>`.\n * Each delta passes through as `value(delta)` (including the terminal\n * `turn_complete`, so the consumer sees turn boundaries naturally). Once\n * the terminal arrives, `then(turn)` runs and its returned stream of loop\n * events (typically tool outputs followed by `next(state)` or `stop`) is\n * concatenated.\n *\n * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on\n * the raw delta stream cover anything an `emit`-style callback would do.\n *\n * If the upstream ends without a `turn_complete`, the resulting stream\n * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if\n * you want to recover.\n */\nexport const streamUntilComplete =\n  <S, A, E2 = never, R2 = never>(\n    then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>,\n  ) =>\n  <E, R>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n  ): Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const turnRef = yield* Ref.make<Option.Option<Turn>>(Option.none())\n\n        const events: Stream.Stream<Event<TurnEvent, S>, E, R> = deltas.pipe(\n          Stream.tap((delta) =>\n            isTurnComplete(delta) ? Ref.set(turnRef, Option.some(delta.turn)) : Effect.void,\n          ),\n          Stream.map(value),\n        )\n\n        const continuation = Stream.unwrap(\n          Effect.gen(function* () {\n            const opt = yield* Ref.get(turnRef)\n            if (Option.isNone(opt)) return yield* Effect.fail(new IncompleteTurn({}))\n            return yield* then(opt.value)\n          }),\n        )\n\n        return Stream.concat(events, continuation)\n      }),\n    )\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst isNonEmpty = <A>(array: ReadonlyArray<A>): array is readonly [A, ...Array<A>] =>\n  array.length > 0\n\ninterface CurrentBody<S, A, E, R> {\n  readonly scope: Scope.Closeable\n  readonly pull: Effect.Effect<ReadonlyArray<Event<A, S>>, E | Cause.Done<void>, R>\n}\n\nconst closeBody = <S, A, E, R>(\n  current: CurrentBody<S, A, E, R>,\n  exit: Exit.Exit<unknown, unknown>,\n) => Scope.close(current.scope, exit)\n\n/**\n * Walk a chunk of `Event<A, S>` until a terminal `Next` or `Stop` is found.\n * Returns the unwrapped values seen so far and (optionally) the terminal\n * event. Anything in the chunk after the terminal is discarded - its\n * producing side effects may have run, but downstream never sees it.\n */\nconst partitionChunk = <A, S>(\n  chunk: ReadonlyArray<Event<A, S>>,\n): { readonly values: Array<A>; readonly decision: Event<A, S> | undefined } => {\n  const values: Array<A> = []\n  for (let i = 0; i < chunk.length; i++) {\n    const event = chunk[i]!\n    if (event._tag === \"Value\") {\n      values.push(event.value)\n    } else {\n      return { values, decision: event }\n    }\n  }\n  return { values, decision: undefined }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\ntype LoopBody<S, A, E, R> = (\n  state: S,\n) => Stream.Stream<Event<A, S>, E, R> | Effect.Effect<Stream.Stream<Event<A, S>, E, R>, E, R>\n\n/**\n * Drive a state-threaded loop body. Each iteration runs `body(state)` to get\n * a `Stream<Event<A, S>>`; values flow downstream, `next(s)` continues with\n * a new state, `stop` ends the loop. See the file header for the full\n * pull-based execution model.\n *\n * Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`\n * (or `pipe(initial, loop(body))`) both work.\n */\nexport const loop: {\n  <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>\n  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>\n} = Function.dual(\n  2,\n  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R> =>\n    Stream.scoped(\n      Stream.fromPull(\n        Effect.gen(function* () {\n          const outerScope = yield* Effect.scope\n          let state = initial\n          let current: CurrentBody<S, A, E, R> | undefined\n          let done = false\n\n          const closeActive = (\n            active: CurrentBody<S, A, E, R>,\n            exit: Exit.Exit<unknown, unknown>,\n          ) => {\n            const isActive = current === active\n            if (isActive) current = undefined\n            // Scope.close is idempotent. Multiple paths can race to close the\n            // active body during cancellation/failure, so closing twice is safe.\n            return closeBody(active, exit)\n          }\n\n          yield* Scope.addFinalizerExit(outerScope, (exit) =>\n            current === undefined ? Effect.void : closeActive(current, exit),\n          )\n\n          const pull = Effect.gen(function* () {\n            while (true) {\n              if (done) return yield* Cause.done()\n\n              if (current === undefined) {\n                const result = body(state)\n                const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result\n                const bodyScope = yield* Scope.fork(outerScope)\n                const bodyPull = yield* Channel.toPullScoped(\n                  Stream.toChannel(stream),\n                  bodyScope,\n                ).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))\n                current = { scope: bodyScope, pull: bodyPull }\n              }\n\n              const active = current\n              const chunk = yield* active.pull.pipe(\n                Effect.catchIf(Cause.isDone, () =>\n                  closeActive(active, Exit.void).pipe(\n                    Effect.as(undefined as ReadonlyArray<Event<A, S>> | undefined),\n                  ),\n                ),\n                Effect.onError((cause) => closeActive(active, Exit.failCause(cause))),\n              )\n\n              if (chunk === undefined) {\n                done = true\n                return yield* Cause.done()\n              }\n\n              const { values, decision } = partitionChunk(chunk)\n\n              if (decision !== undefined) {\n                yield* closeActive(active, Exit.void)\n                if (decision._tag === \"Stop\") {\n                  done = true\n                } else if (decision._tag === \"Next\") {\n                  state = decision.state\n                }\n              }\n\n              // Emit the values seen so far if any. Chunks from a Stream pull\n              // are non-empty, so when `decision === undefined` every event was\n              // a `Value` and `values` is non-empty here. With a decision and\n              // no preceding values, fall through to the next iteration.\n              if (isNonEmpty(values)) return values\n            }\n          })\n\n          return pull\n        }),\n      ),\n    ),\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAM,QAAQ,KAAK,YAAsB;;AAGzC,MAAa,SAAY,MAA0B,MAAM,MAAM,EAAE,OAAO,GAAG,CAAC;;AAG5E,MAAa,QAAW,UAA8B,MAAM,KAAK,EAAE,OAAO,CAAC;;AAG3E,MAAa,YAAiC,MAAM,MAAM;;;;;;AAO1D,MAAa,OAA2C,OAAO,QAAQ,UAAU;;;;;;AAOjF,MAAa,aACX,QACA,UAEA,OAAO,OAAO,OAAO,IAAI,QAAQ,MAAM,EAAE,OAAO,aAAa,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC;;;;;AAM9E,MAAa,aACX,WAEA,OAAO,OAAO,OAAO,IAAI,QAAQ,MAAM,EAAE,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC;;;;;;;;;AAU5E,MAAa,iBACX,QACA,SACA,QACA,UAEA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,MAAM,OAAO,IAAI,KAAK,QAAQ;CACpC,MAAM,SAAS,OAAO,KACpB,OAAO,KAAK,MAAM,IAAI,OAAO,MAAM,QAAQ,OAAO,KAAK,EAAE,CAAC,CAAC,EAC3D,OAAO,IAAI,MAAM,CAClB;CACD,MAAM,eAAe,OAAO,WAC1B,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,CAAC,CACzD;AACD,QAAO,OAAO,KAAK,OAAO,OAAO,aAAa,CAAC;EAC/C,CACH;;;;;;;;;;;;;;;;AAqBH,MAAa,uBAET,UAGA,WAEA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,IAAI,KAA0B,OAAO,MAAM,CAAC;CAEnE,MAAM,SAAmD,OAAO,KAC9D,OAAO,KAAK,UACV,eAAe,MAAM,GAAG,IAAI,IAAI,SAAS,OAAO,KAAK,MAAM,KAAK,CAAC,GAAG,OAAO,KAC5E,EACD,OAAO,IAAI,MAAM,CAClB;CAED,MAAM,eAAe,OAAO,OAC1B,OAAO,IAAI,aAAa;EACtB,MAAM,MAAM,OAAO,IAAI,IAAI,QAAQ;AACnC,MAAI,OAAO,OAAO,IAAI,CAAE,QAAO,OAAO,OAAO,KAAK,IAAI,eAAe,EAAE,CAAC,CAAC;AACzE,SAAO,OAAO,KAAK,IAAI,MAAM;GAC7B,CACH;AAED,QAAO,OAAO,OAAO,QAAQ,aAAa;EAC1C,CACH;AAML,MAAM,cAAiB,UACrB,MAAM,SAAS;AAOjB,MAAM,aACJ,SACA,SACG,MAAM,MAAM,QAAQ,OAAO,KAAK;;;;;;;AAQrC,MAAM,kBACJ,UAC8E;CAC9E,MAAM,SAAmB,EAAE;AAC3B,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,QAAQ,MAAM;AACpB,MAAI,MAAM,SAAS,QACjB,QAAO,KAAK,MAAM,MAAM;MAExB,QAAO;GAAE;GAAQ,UAAU;GAAO;;AAGtC,QAAO;EAAE;EAAQ,UAAU,KAAA;EAAW;;;;;;;;;;;AAoBxC,MAAa,OAGT,SAAS,KACX,IACa,SAAY,SACvB,OAAO,OACL,OAAO,SACL,OAAO,IAAI,aAAa;CACtB,MAAM,aAAa,OAAO,OAAO;CACjC,IAAI,QAAQ;CACZ,IAAI;CACJ,IAAI,OAAO;CAEX,MAAM,eACJ,QACA,SACG;AAEH,MADiB,YAAY,OACf,WAAU,KAAA;AAGxB,SAAO,UAAU,QAAQ,KAAK;;AAGhC,QAAO,MAAM,iBAAiB,aAAa,SACzC,YAAY,KAAA,IAAY,OAAO,OAAO,YAAY,SAAS,KAAK,CACjE;AAmDD,QAjDa,OAAO,IAAI,aAAa;AACnC,SAAO,MAAM;AACX,OAAI,KAAM,QAAO,OAAO,MAAM,MAAM;AAEpC,OAAI,YAAY,KAAA,GAAW;IACzB,MAAM,SAAS,KAAK,MAAM;IAC1B,MAAM,SAAS,OAAO,SAAS,OAAO,GAAG,OAAO,OAAO,OAAO,GAAG;IACjE,MAAM,YAAY,OAAO,MAAM,KAAK,WAAW;AAK/C,cAAU;KAAE,OAAO;KAAW,MAAM,OAJZ,QAAQ,aAC9B,OAAO,UAAU,OAAO,EACxB,UACD,CAAC,KAAK,OAAO,SAAS,UAAU,MAAM,MAAM,WAAW,KAAK,UAAU,MAAM,CAAC,CAAC,CAAC;KAClC;;GAGhD,MAAM,SAAS;GACf,MAAM,QAAQ,OAAO,OAAO,KAAK,KAC/B,OAAO,QAAQ,MAAM,cACnB,YAAY,QAAQ,KAAK,KAAK,CAAC,KAC7B,OAAO,GAAG,KAAA,EAAoD,CAC/D,CACF,EACD,OAAO,SAAS,UAAU,YAAY,QAAQ,KAAK,UAAU,MAAM,CAAC,CAAC,CACtE;AAED,OAAI,UAAU,KAAA,GAAW;AACvB,WAAO;AACP,WAAO,OAAO,MAAM,MAAM;;GAG5B,MAAM,EAAE,QAAQ,aAAa,eAAe,MAAM;AAElD,OAAI,aAAa,KAAA,GAAW;AAC1B,WAAO,YAAY,QAAQ,KAAK,KAAK;AACrC,QAAI,SAAS,SAAS,OACpB,QAAO;aACE,SAAS,SAAS,OAC3B,SAAQ,SAAS;;AAQrB,OAAI,WAAW,OAAO,CAAE,QAAO;;GAIxB;EACX,CACH,CACF,CACJ"}

package/dist/match/Match.d.mts

@@ -0,0 +1,16 @@
+import { Match } from "effect";
+
+//#region src/match/Match.d.ts
+declare namespace Match_d_exports {
+  export { matchType };
+}
+/**
+ * Dispatch on the `type` discriminator of a tagged union. Equivalent to
+ * `Match.discriminator("type")`, exposed as a named helper because the
+ * `type` field is the framework's convention for `Item`, `TurnEvent`,
+ * `ContentBlock`, and most provider wire types.
+ */
+declare const matchType: <R, P extends Match.Types.Tags<"type", R> & string, Ret, Fn extends (_: Extract<R, Record<"type", P>>) => Ret>(...pattern: [first: P, ...values: P[], f: Fn]) => <I, F, A, Pr>(self: Match.Matcher<I, F, R, A, Pr, Ret>) => Match.Matcher<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>, Match.Types.ApplyFilters<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>>, A | ReturnType<Fn>, Pr, Ret>;
+//#endregion
+export { matchType, Match_d_exports as t };
+//# sourceMappingURL=Match.d.mts.map

package/dist/match/Match.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Match.d.mts","names":[],"sources":["../../src/match/Match.ts"],"mappings":";;;;;;;;;;AAQA;;cAAa,SAAA,gBAAS,KAAA,CAAA,KAAA,CAAA,IAAA,SAAA,CAAA,6BAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,OAAA,GAAA,KAAA,OAAA,GAAA,KAAA,EAAA,CAAA,KAAA,MAAA,EAAA,CAAA,IAAA,CAAA,EAAA,EAAA,oBAAA,IAAA,EAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,EAAA,EAAA,GAAA,MAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,KAAA,KAAA,CAAA,KAAA,CAAA,YAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,MAAA,CAAA,GAAA,UAAA,CAAA,EAAA,GAAA,EAAA,EAAA,GAAA"}

package/dist/match/Match.mjs

@@ -0,0 +1,15 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Match } from "effect";
+//#region src/match/Match.ts
+var Match_exports = /* @__PURE__ */ __exportAll({ matchType: () => matchType });
+/**
+* Dispatch on the `type` discriminator of a tagged union. Equivalent to
+* `Match.discriminator("type")`, exposed as a named helper because the
+* `type` field is the framework's convention for `Item`, `TurnEvent`,
+* `ContentBlock`, and most provider wire types.
+*/
+const matchType = Match.discriminator("type");
+//#endregion
+export { matchType, Match_exports as t };
+
+//# sourceMappingURL=Match.mjs.map

package/dist/match/Match.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Match.mjs","names":[],"sources":["../../src/match/Match.ts"],"sourcesContent":["import { Match } from \"effect\"\n\n/**\n * Dispatch on the `type` discriminator of a tagged union. Equivalent to\n * `Match.discriminator(\"type\")`, exposed as a named helper because the\n * `type` field is the framework's convention for `Item`, `TurnEvent`,\n * `ContentBlock`, and most provider wire types.\n */\nexport const matchType = Match.discriminator(\"type\")\n"],"mappings":";;;;;;;;;;AAQA,MAAa,YAAY,MAAM,cAAc,OAAO"}

package/dist/observability/Metrics.d.mts

@@ -0,0 +1,45 @@
+import { Duration, Effect, Option, Stream } from "effect";
+
+//#region src/observability/Metrics.d.ts
+declare namespace Metrics_d_exports {
+  export { RatePoint, timeToFirst, withElapsed, withRate };
+}
+/**
+ * Annotate every event in a stream with the elapsed `Duration` since the
+ * stream started consuming. The first event reports its time-from-start,
+ * which is also the conventional "time to first ____" metric.
+ */
+declare const withElapsed: <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<{
+  readonly value: A;
+  readonly elapsed: Duration.Duration;
+}, E, R>;
+/**
+ * Compute the elapsed time until the first event matching the predicate.
+ * Returns `Option.none()` if the stream completes without one.
+ *
+ * Consumes the stream. To track this *alongside* live consumption, use
+ * `Stream.broadcast` to fan the source out and run `timeToFirst` on one
+ * branch.
+ */
+declare const timeToFirst: <A>(predicate: (a: A) => boolean) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<Option.Option<Duration.Duration>, E, R>;
+interface RatePoint<A> {
+  readonly value: A;
+  readonly total: number;
+  readonly ratePerSecond: number;
+  readonly elapsed: Duration.Duration;
+}
+/**
+ * Annotate every event with a running total and a rolling rate per second,
+ * computed from a user-supplied weight function.
+ *
+ * The weight is the unit you care about - bytes, tokens, error count, etc.
+ * For tokens-per-second on `TurnEvent`, pass:
+ *
+ *   `(d) => d.type === "text_delta" ? countTokens(d.text) : 0`
+ *
+ * Use any tokenizer you like; the library does not ship one.
+ */
+declare const withRate: <A>(weight: (a: A) => number) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<RatePoint<A>, E, R>;
+//#endregion
+export { RatePoint, Metrics_d_exports as t, timeToFirst, withElapsed, withRate };
+//# sourceMappingURL=Metrics.d.mts.map

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

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

package/dist/observability/Metrics.mjs

@@ -0,0 +1,52 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Clock, Duration, Effect, Option, Stream } from "effect";
+//#region src/observability/Metrics.ts
+var Metrics_exports = /* @__PURE__ */ __exportAll({
+	timeToFirst: () => timeToFirst,
+	withElapsed: () => withElapsed,
+	withRate: () => withRate
+});
+/**
+* Annotate every event in a stream with the elapsed `Duration` since the
+* stream started consuming. The first event reports its time-from-start,
+* which is also the conventional "time to first ____" metric.
+*/
+const withElapsed = (self) => Stream.unwrap(Effect.map(Clock.currentTimeMillis, (start) => self.pipe(Stream.mapEffect((value) => Effect.map(Clock.currentTimeMillis, (now) => ({
+	value,
+	elapsed: Duration.millis(now - start)
+}))))));
+/**
+* Compute the elapsed time until the first event matching the predicate.
+* Returns `Option.none()` if the stream completes without one.
+*
+* Consumes the stream. To track this *alongside* live consumption, use
+* `Stream.broadcast` to fan the source out and run `timeToFirst` on one
+* branch.
+*/
+const timeToFirst = (predicate) => (self) => withElapsed(self).pipe(Stream.filter(({ value }) => predicate(value)), Stream.runHead, Effect.map(Option.map(({ elapsed }) => elapsed)));
+/**
+* Annotate every event with a running total and a rolling rate per second,
+* computed from a user-supplied weight function.
+*
+* The weight is the unit you care about - bytes, tokens, error count, etc.
+* For tokens-per-second on `TurnEvent`, pass:
+*
+*   `(d) => d.type === "text_delta" ? countTokens(d.text) : 0`
+*
+* Use any tokenizer you like; the library does not ship one.
+*/
+const withRate = (weight) => (self) => Stream.unwrap(Effect.map(Clock.currentTimeMillis, (start) => self.pipe(Stream.mapAccumEffect(() => ({ total: 0 }), (acc, value) => Effect.map(Clock.currentTimeMillis, (now) => {
+	const total = acc.total + weight(value);
+	const elapsedMs = now - start;
+	const ratePerSecond = elapsedMs > 0 ? total / elapsedMs * 1e3 : 0;
+	return [{ total }, [{
+		value,
+		total,
+		ratePerSecond,
+		elapsed: Duration.millis(elapsedMs)
+	}]];
+})))));
+//#endregion
+export { Metrics_exports as t, timeToFirst, withElapsed, withRate };
+
+//# sourceMappingURL=Metrics.mjs.map

package/dist/observability/Metrics.mjs.map

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

package/dist/streaming/JSONL.d.mts

@@ -0,0 +1,34 @@
+import { Schema, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/streaming/JSONL.d.ts
+declare namespace JSONL_d_exports {
+  export { JsonParseError, fromBytes, parse, toBytes };
+}
+declare const JsonParseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "JsonParseError";
+} & Readonly<A>;
+declare class JsonParseError extends JsonParseError_base<{
+  readonly line: string;
+  readonly cause: unknown;
+}> {}
+/**
+ * Decode a `Stream<Uint8Array>` into a `Stream<string>` of newline-delimited
+ * lines. Empty lines are skipped. Buffers across chunk boundaries.
+ */
+declare const fromBytes: <E, R>(self: Stream.Stream<Uint8Array, E, R>) => Stream.Stream<string, E, R>;
+/**
+ * Validate each JSONL line against a Schema. JSON parse errors and Schema
+ * decode errors both surface as a `JsonParseError` so callers can `catchTag`
+ * uniformly.
+ */
+declare const parse: <A, I>(schema: Schema.Codec<A, I>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<A, JsonParseError | E, R>;
+/**
+ * Serialize a stream of values to JSONL bytes. Encodes each value via
+ * `Schema.encodeUnknownSync`. Each line ends with `\n`.
+ */
+declare const toBytes: <A, I>(schema: Schema.Codec<A, I>) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Uint8Array, E, R>;
+//#endregion
+export { JsonParseError, fromBytes, parse, JSONL_d_exports as t, toBytes };
+//# sourceMappingURL=JSONL.d.mts.map

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

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

package/dist/streaming/JSONL.mjs

@@ -0,0 +1,51 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Data, Effect, Schema, Stream } from "effect";
+//#region src/streaming/JSONL.ts
+var JSONL_exports = /* @__PURE__ */ __exportAll({
+	JsonParseError: () => JsonParseError,
+	fromBytes: () => fromBytes,
+	parse: () => parse,
+	toBytes: () => toBytes
+});
+var JsonParseError = class extends Data.TaggedError("JsonParseError") {};
+const decodeText = (self) => self.pipe(Stream.mapAccum(() => new TextDecoder("utf-8"), (decoder, chunk) => [decoder, [decoder.decode(chunk, { stream: true })]], { onHalt: (decoder) => {
+	const tail = decoder.decode();
+	return tail.length > 0 ? [tail] : [];
+} }));
+const splitOn = (separator) => (self) => self.pipe(Stream.mapAccum(() => "", (buffer, chunk) => {
+	const parts = (buffer + chunk).split(separator);
+	return [parts[parts.length - 1] ?? "", parts.slice(0, -1)];
+}, { onHalt: (tail) => tail.length > 0 ? [tail] : [] }));
+/**
+* Decode a `Stream<Uint8Array>` into a `Stream<string>` of newline-delimited
+* lines. Empty lines are skipped. Buffers across chunk boundaries.
+*/
+const fromBytes = (self) => self.pipe(decodeText, Stream.map((s) => s.replace(/\r/g, "")), splitOn("\n"), Stream.filter((line) => line.length > 0));
+/**
+* Validate each JSONL line against a Schema. JSON parse errors and Schema
+* decode errors both surface as a `JsonParseError` so callers can `catchTag`
+* uniformly.
+*/
+const parse = (schema) => (self) => self.pipe(Stream.mapEffect((line) => Effect.try({
+	try: () => JSON.parse(line),
+	catch: (cause) => new JsonParseError({
+		line,
+		cause
+	})
+}).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new JsonParseError({
+	line,
+	cause
+})))))));
+const encoder = new TextEncoder();
+/**
+* Serialize a stream of values to JSONL bytes. Encodes each value via
+* `Schema.encodeUnknownSync`. Each line ends with `\n`.
+*/
+const toBytes = (schema) => (self) => self.pipe(Stream.map((value) => {
+	const encoded = Schema.encodeUnknownSync(schema)(value);
+	return encoder.encode(JSON.stringify(encoded) + "\n");
+}));
+//#endregion
+export { JsonParseError, fromBytes, parse, JSONL_exports as t, toBytes };
+
+//# sourceMappingURL=JSONL.mjs.map

package/dist/streaming/JSONL.mjs.map

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

package/dist/streaming/Lines.d.mts

@@ -0,0 +1,27 @@
+import { Stream } from "effect";
+
+//#region src/streaming/Lines.d.ts
+declare namespace Lines_d_exports {
+  export { lines, linesStrict };
+}
+/**
+ * Split a string stream on `\n`, emitting one line per element. Buffers
+ * partial chunks until a newline arrives, and flushes any non-newline
+ * tail at stream end - so streams that don't terminate with `\n`
+ * (typical of LLM token streams) still get their last line. Empty lines
+ * are dropped, `\r` is stripped (handles `\r\n` endings).
+ *
+ * Intended use: feed text deltas from a model that has been prompted to
+ * emit JSONL (or any other newline-delimited format), then parse /
+ * validate each emitted line.
+ */
+declare const lines: <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<string, E, R>;
+/**
+ * Like `lines`, but only emits lines that were terminated by `\n`. Any
+ * partial trailing content is dropped at stream end. Use when you want
+ * strict "complete-line-or-nothing" semantics.
+ */
+declare const linesStrict: <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<string, E, R>;
+//#endregion
+export { lines, linesStrict, Lines_d_exports as t };
+//# sourceMappingURL=Lines.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lines.d.mts","names":[],"sources":["../../src/streaming/Lines.ts"],"mappings":";;;;;;;;;;;;;AAaA;;;;cAAa,KAAA,SAAe,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;;;;;;cAQ5E,WAAA,SAAqB,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA"}

package/dist/streaming/Lines.mjs

@@ -0,0 +1,32 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Stream } from "effect";
+//#region src/streaming/Lines.ts
+var Lines_exports = /* @__PURE__ */ __exportAll({
+	lines: () => lines,
+	linesStrict: () => linesStrict
+});
+/**
+* Split a string stream on `\n`, emitting one line per element. Buffers
+* partial chunks until a newline arrives, and flushes any non-newline
+* tail at stream end - so streams that don't terminate with `\n`
+* (typical of LLM token streams) still get their last line. Empty lines
+* are dropped, `\r` is stripped (handles `\r\n` endings).
+*
+* Intended use: feed text deltas from a model that has been prompted to
+* emit JSONL (or any other newline-delimited format), then parse /
+* validate each emitted line.
+*/
+const lines = (self) => linesStrict(Stream.concat(self, Stream.make("\n")));
+/**
+* Like `lines`, but only emits lines that were terminated by `\n`. Any
+* partial trailing content is dropped at stream end. Use when you want
+* strict "complete-line-or-nothing" semantics.
+*/
+const linesStrict = (self) => self.pipe(Stream.mapAccum(() => "", (buffer, chunk) => {
+	const parts = (buffer + chunk).split("\n");
+	return [parts.pop() ?? "", parts.map((line) => line.replace(/\r/g, ""))];
+}), Stream.filter((line) => line.trim().length > 0));
+//#endregion
+export { lines, linesStrict, Lines_exports as t };
+
+//# sourceMappingURL=Lines.mjs.map

package/dist/streaming/Lines.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lines.mjs","names":[],"sources":["../../src/streaming/Lines.ts"],"sourcesContent":["import { Stream } from \"effect\"\n\n/**\n * Split a string stream on `\\n`, emitting one line per element. Buffers\n * partial chunks until a newline arrives, and flushes any non-newline\n * tail at stream end - so streams that don't terminate with `\\n`\n * (typical of LLM token streams) still get their last line. Empty lines\n * are dropped, `\\r` is stripped (handles `\\r\\n` endings).\n *\n * Intended use: feed text deltas from a model that has been prompted to\n * emit JSONL (or any other newline-delimited format), then parse /\n * validate each emitted line.\n */\nexport const lines = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  linesStrict(Stream.concat(self, Stream.make(\"\\n\")))\n\n/**\n * Like `lines`, but only emits lines that were terminated by `\\n`. Any\n * partial trailing content is dropped at stream end. Use when you want\n * strict \"complete-line-or-nothing\" semantics.\n */\nexport const linesStrict = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): string => \"\",\n      (buffer, chunk: string) => {\n        const combined = buffer + chunk\n        const parts = combined.split(\"\\n\")\n        const tail = parts.pop() ?? \"\"\n        return [tail, parts.map((line) => line.replace(/\\r/g, \"\"))] as const\n      },\n    ),\n    Stream.filter((line) => line.trim().length > 0),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;AAaA,MAAa,SAAe,SAC1B,YAAY,OAAO,OAAO,MAAM,OAAO,KAAK,KAAK,CAAC,CAAC;;;;;;AAOrD,MAAa,eAAqB,SAChC,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CAEzB,MAAM,SADW,SAAS,OACH,MAAM,KAAK;AAElC,QAAO,CADM,MAAM,KAAK,IAAI,IACd,MAAM,KAAK,SAAS,KAAK,QAAQ,OAAO,GAAG,CAAC,CAAC;EAE9D,EACD,OAAO,QAAQ,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAChD"}

package/dist/streaming/SSE.d.mts

@@ -0,0 +1,31 @@
+import { Stream } from "effect";
+
+//#region src/streaming/SSE.d.ts
+declare namespace SSE_d_exports {
+  export { Event, fromBytes, toBytes };
+}
+/**
+ * One Server-Sent Event. Fields per the WHATWG spec:
+ * - `event`: optional event name (default "message" on the wire)
+ * - `data`: payload, with multiple `data:` lines joined by `\n`
+ * - `id`: optional last-event id
+ */
+interface Event {
+  readonly event?: string;
+  readonly data: string;
+  readonly id?: string;
+}
+/**
+ * Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a
+ * `Stream<SSE.Event>`. Handles partial UTF-8 sequences, CRLF/LF line
+ * endings, and events split across chunk boundaries.
+ */
+declare const fromBytes: <E, R>(self: Stream.Stream<Uint8Array, E, R>) => Stream.Stream<Event, E, R>;
+/**
+ * Encode a `Stream<Event>` as `Stream<Uint8Array>` ready to send on an
+ * HTTP response with `Content-Type: text/event-stream`.
+ */
+declare const toBytes: <E, R>(self: Stream.Stream<Event, E, R>) => Stream.Stream<Uint8Array, E, R>;
+//#endregion
+export { Event, fromBytes, SSE_d_exports as t, toBytes };
+//# sourceMappingURL=SSE.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SSE.d.mts","names":[],"sources":["../../src/streaming/SSE.ts"],"mappings":";;;;;;;;;;;;UAQiB,KAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;AAAA;;;;;;cA4EE,SAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MAClC,MAAA,CAAO,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,CAAA;AAF3B;;;;AAAA,cAyBa,OAAA,SAAiB,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA"}

package/dist/streaming/SSE.mjs

@@ -0,0 +1,58 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Stream } from "effect";
+//#region src/streaming/SSE.ts
+var SSE_exports = /* @__PURE__ */ __exportAll({
+	fromBytes: () => fromBytes,
+	toBytes: () => toBytes
+});
+/** Decode `Uint8Array` chunks as UTF-8, handling multi-byte boundaries. */
+const decodeText = (self) => self.pipe(Stream.mapAccum(() => new TextDecoder("utf-8"), (decoder, chunk) => [decoder, [decoder.decode(chunk, { stream: true })]], { onHalt: (decoder) => {
+	const tail = decoder.decode();
+	return tail.length > 0 ? [tail] : [];
+} }));
+/** Split a text stream on a separator, buffering across chunk boundaries. */
+const splitOn = (separator) => (self) => self.pipe(Stream.mapAccum(() => "", (buffer, chunk) => {
+	const parts = (buffer + chunk).split(separator);
+	return [parts[parts.length - 1] ?? "", parts.slice(0, -1)];
+}, { onHalt: (tail) => tail.length > 0 ? [tail] : [] }));
+const parseField = (line) => {
+	const colon = line.indexOf(":");
+	if (colon < 0) return [line, ""];
+	const value = line.slice(colon + 1);
+	return [line.slice(0, colon), value.startsWith(" ") ? value.slice(1) : value];
+};
+const parseBlock = (block) => {
+	const lines = block.split("\n").filter((l) => l.length > 0 && !l.startsWith(":"));
+	if (lines.length === 0) return null;
+	const fields = lines.map(parseField);
+	const dataLines = fields.filter(([f]) => f === "data").map(([, v]) => v);
+	const event = fields.find(([f]) => f === "event")?.[1];
+	const id = fields.find(([f]) => f === "id")?.[1];
+	const out = { data: dataLines.join("\n") };
+	if (event !== void 0) out.event = event;
+	if (id !== void 0) out.id = id;
+	return out;
+};
+/**
+* Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a
+* `Stream<SSE.Event>`. Handles partial UTF-8 sequences, CRLF/LF line
+* endings, and events split across chunk boundaries.
+*/
+const fromBytes = (self) => self.pipe(decodeText, Stream.map((s) => s.replace(/\r/g, "")), splitOn("\n\n"), Stream.map(parseBlock), Stream.filter((ev) => ev !== null));
+const eventToString = (ev) => {
+	const parts = [];
+	if (ev.event !== void 0) parts.push(`event: ${ev.event}`);
+	if (ev.id !== void 0) parts.push(`id: ${ev.id}`);
+	for (const line of ev.data.split("\n")) parts.push(`data: ${line}`);
+	return parts.join("\n") + "\n\n";
+};
+const encoder = new TextEncoder();
+/**
+* Encode a `Stream<Event>` as `Stream<Uint8Array>` ready to send on an
+* HTTP response with `Content-Type: text/event-stream`.
+*/
+const toBytes = (self) => Stream.map(self, (ev) => encoder.encode(eventToString(ev)));
+//#endregion
+export { fromBytes, SSE_exports as t, toBytes };
+
+//# sourceMappingURL=SSE.mjs.map