@effect-uai/core 0.2.0 → 0.4.0

package/dist/loop/Loop.d.mts

@@ -1,10 +1,10 @@
-import { l as IncompleteTurn } from "../AiError-CqmYjXyx.mjs";
-import { i as TurnEvent, r as Turn } from "../Turn-Bi83du4I.mjs";
-import { Data, Effect, Stream } from "effect";
+import { l as IncompleteTurn } from "../AiError-csR8Bhxx.mjs";
+import { i as TurnEvent, r as Turn } from "../Turn-7geUcKsf.mjs";
+import { Data, Effect, Stream, SubscriptionRef } from "effect";
 
 //#region src/loop/Loop.d.ts
 declare namespace Loop_d_exports {
-  export { Event, loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, value };
+  export { Event, loop, loopWithState, next, nextAfter, nextAfterFold, onTurnComplete, stop, stopAfter, stopEvent, value };
 }
 /**
  * The tagged union a body emits per pull. `Value` carries a payload that
@@ -48,7 +48,7 @@ declare const stopAfter: <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Str
  * 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
+ * `build: (s) => s`). Used by `Toolkit.continueWith` to collect tool
  * results and build next state without exposing a Ref to recipes.
  */
 declare const nextAfterFold: <A, B, S, E, R>(stream: Stream.Stream<A, E, R>, initial: B, reduce: (acc: B, a: A) => B, build: (b: B) => S) => Stream.Stream<Event<A, S>, E, R>;
@@ -67,7 +67,7 @@ declare const nextAfterFold: <A, B, S, E, R>(stream: Stream.Stream<A, E, R>, ini
  * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
  * you want to recover.
  */
-declare const streamUntilComplete: <S, A, E2 = never, R2 = never>(then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>) => <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
+declare const onTurnComplete: <S, A, E2 = never, R2 = never>(then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>) => <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
 type LoopBody<S, A, E, R> = (state: S) => Stream.Stream<Event<A, S>, E, R> | Effect.Effect<Stream.Stream<Event<A, S>, E, R>, E, R>;
 /**
  * Drive a state-threaded loop body. Each iteration runs `body(state)` to get
@@ -82,6 +82,30 @@ declare const loop: {
   <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>;
   <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>;
 };
+/**
+ * Like `loop`, but exposes the current loop state as a `SubscriptionRef`
+ * alongside the value stream.
+ *
+ * Allocates one `SubscriptionRef<S>` seeded with `initial`, then runs the
+ * loop with a wrapped body that taps every `Next(s)` event into the ref
+ * before forwarding it. The caller decides how to consume both channels:
+ *
+ *   - **Final state**: drain the stream, then `SubscriptionRef.get(state)`
+ *     - the ref holds the state from the last `Next` (or `initial` if the
+ *     loop ended without advancing).
+ *   - **Live transitions**: `SubscriptionRef.changes(state)` is a
+ *     `Stream<S>` of every state observed; subscribe alongside the value
+ *     stream.
+ *   - **Mid-iteration peek**: `SubscriptionRef.get(state)` at any time.
+ *
+ * The returned stream and ref are independent of each other - the ref
+ * lives outside the stream's scope, so reading it after the stream
+ * completes is safe.
+ */
+declare const loopWithState: <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>) => Effect.Effect<{
+  readonly stream: Stream.Stream<A, E, R>;
+  readonly state: SubscriptionRef.SubscriptionRef<S>;
+}>;
 //#endregion
-export { Event, loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, Loop_d_exports as t, value };
+export { Event, loop, loopWithState, next, nextAfter, nextAfterFold, onTurnComplete, stop, stopAfter, stopEvent, Loop_d_exports as t, value };
 //# sourceMappingURL=Loop.d.mts.map

package/dist/loop/Loop.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Loop.d.mts","names":[],"sources":["../../src/loop/Loop.ts"],"mappings":";;;;;;;;;;;;;KAgCY,KAAA,SAAc,IAAA,CAAK,UAAA;EAC7B,KAAA;IAAA,SAAkB,KAAA,EAAO,CAAA;EAAA;EACzB,IAAA;IAAA,SAAiB,KAAA,EAAO,CAAA;EAAA;EACxB,IAAA;AAAA;;cAUW,KAAA,MAAY,CAAA,EAAG,CAAA,KAAI,KAAA,CAAM,CAAA;;cAGzB,IAAA,MAAW,KAAA,EAAO,CAAA,KAAI,KAAA,QAAa,CAAA;;cAGnC,SAAA,EAAW,KAAA;;;;;;cAOX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,KAAA;;;;;;cAOpB,SAAA,eACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,KAAA,EAAO,CAAA,KACN,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;AApBjC;;;;AAAA,cA2Ba,SAAA,YACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAC3B,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,UAAW,CAAA,EAAG,CAAA;;;;;;;;;cAWxB,aAAA,kBACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,OAAA,EAAS,CAAA,EACT,MAAA,GAAS,GAAA,EAAK,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,CAAA,EAC1B,KAAA,GAAQ,CAAA,EAAG,CAAA,KAAM,CAAA,KAChB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;AA1CjC;;;;;AAOA;;;;;;;;;cAqEa,mBAAA,iCAET,IAAA,GAAO,IAAA,EAAM,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,EAAA,GAAK,EAAA,EAAI,EAAA,aAG5E,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,SAAA,GAAY,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,EAAA,GAAK,cAAA,EAAgB,CAAA,GAAI,EAAA;AAAA,KAkEpE,QAAA,gBACH,KAAA,EAAO,CAAA,KACJ,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;;;;;;;;;cAW9E,IAAA;EAAA,aACE,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,OAAA,EAAS,CAAA,KAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA,aACjE,OAAA,EAAS,CAAA,EAAG,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA"}
+{"version":3,"file":"Loop.d.mts","names":[],"sources":["../../src/loop/Loop.ts"],"mappings":"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"}

package/dist/loop/Loop.mjs

@@ -1,7 +1,7 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.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";
+import { Cause, Channel, Data, Effect, Exit, Function, Option, Ref, Scope, Stream, SubscriptionRef } from "effect";
 //#region src/loop/Loop.ts
 /**
 * Pull-based `loop` for state-threaded sub-streams.
@@ -24,13 +24,14 @@ import { Cause, Channel, Data, Effect, Exit, Function, Option, Ref, Scope, Strea
 */
 var Loop_exports = /* @__PURE__ */ __exportAll({
 	loop: () => loop,
+	loopWithState: () => loopWithState,
 	next: () => next,
 	nextAfter: () => nextAfter,
 	nextAfterFold: () => nextAfterFold,
+	onTurnComplete: () => onTurnComplete,
 	stop: () => stop,
 	stopAfter: () => stopAfter,
 	stopEvent: () => stopEvent,
-	streamUntilComplete: () => streamUntilComplete,
 	value: () => value
 });
 const Event = Data.taggedEnum();
@@ -62,7 +63,7 @@ const stopAfter = (stream) => Stream.concat(Stream.map(stream, value), Stream.fr
 * 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
+* `build: (s) => s`). Used by `Toolkit.continueWith` 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* () {
@@ -86,7 +87,7 @@ const nextAfterFold = (stream, initial, reduce, build) => Stream.unwrap(Effect.g
 * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
 * you want to recover.
 */
-const streamUntilComplete = (then) => (deltas) => Stream.unwrap(Effect.gen(function* () {
+const onTurnComplete = (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* () {
@@ -166,7 +167,39 @@ const loop = Function.dual(2, (initial, body) => Stream.scoped(Stream.fromPull(E
 		}
 	});
 }))));
+/**
+* Like `loop`, but exposes the current loop state as a `SubscriptionRef`
+* alongside the value stream.
+*
+* Allocates one `SubscriptionRef<S>` seeded with `initial`, then runs the
+* loop with a wrapped body that taps every `Next(s)` event into the ref
+* before forwarding it. The caller decides how to consume both channels:
+*
+*   - **Final state**: drain the stream, then `SubscriptionRef.get(state)`
+*     - the ref holds the state from the last `Next` (or `initial` if the
+*     loop ended without advancing).
+*   - **Live transitions**: `SubscriptionRef.changes(state)` is a
+*     `Stream<S>` of every state observed; subscribe alongside the value
+*     stream.
+*   - **Mid-iteration peek**: `SubscriptionRef.get(state)` at any time.
+*
+* The returned stream and ref are independent of each other - the ref
+* lives outside the stream's scope, so reading it after the stream
+* completes is safe.
+*/
+const loopWithState = (initial, body) => Effect.gen(function* () {
+	const stateRef = yield* SubscriptionRef.make(initial);
+	const tap = (stream) => stream.pipe(Stream.tap((event) => event._tag === "Next" ? SubscriptionRef.set(stateRef, event.state) : Effect.void));
+	const wrappedBody = (s) => {
+		const result = body(s);
+		return Effect.isEffect(result) ? Effect.map(result, tap) : tap(result);
+	};
+	return {
+		stream: loop(initial, wrappedBody),
+		state: stateRef
+	};
+});
 //#endregion
-export { loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, Loop_exports as t, value };
+export { loop, loopWithState, next, nextAfter, nextAfterFold, onTurnComplete, stop, stopAfter, stopEvent, Loop_exports as t, value };
 
 //# sourceMappingURL=Loop.mjs.map

package/dist/loop/Loop.mjs.map

@@ -1 +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"}
+{"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 {\n  Cause,\n  Channel,\n  Data,\n  Effect,\n  Exit,\n  Function,\n  Option,\n  Ref,\n  Scope,\n  Stream,\n  SubscriptionRef,\n} 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.continueWith` 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// onTurnComplete - 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 onTurnComplete =\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\ntype 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\n// ---------------------------------------------------------------------------\n// loopWithState - same body protocol, plus a live state observable.\n// ---------------------------------------------------------------------------\n\n/**\n * Like `loop`, but exposes the current loop state as a `SubscriptionRef`\n * alongside the value stream.\n *\n * Allocates one `SubscriptionRef<S>` seeded with `initial`, then runs the\n * loop with a wrapped body that taps every `Next(s)` event into the ref\n * before forwarding it. The caller decides how to consume both channels:\n *\n *   - **Final state**: drain the stream, then `SubscriptionRef.get(state)`\n *     - the ref holds the state from the last `Next` (or `initial` if the\n *     loop ended without advancing).\n *   - **Live transitions**: `SubscriptionRef.changes(state)` is a\n *     `Stream<S>` of every state observed; subscribe alongside the value\n *     stream.\n *   - **Mid-iteration peek**: `SubscriptionRef.get(state)` at any time.\n *\n * The returned stream and ref are independent of each other - the ref\n * lives outside the stream's scope, so reading it after the stream\n * completes is safe.\n */\nexport const loopWithState = <S, A, E, R>(\n  initial: S,\n  body: LoopBody<S, A, E, R>,\n): Effect.Effect<{\n  readonly stream: Stream.Stream<A, E, R>\n  readonly state: SubscriptionRef.SubscriptionRef<S>\n}> =>\n  Effect.gen(function* () {\n    const stateRef = yield* SubscriptionRef.make(initial)\n\n    const tap = (stream: Stream.Stream<Event<A, S>, E, R>): Stream.Stream<Event<A, S>, E, R> =>\n      stream.pipe(\n        Stream.tap((event) =>\n          event._tag === \"Next\" ? SubscriptionRef.set(stateRef, event.state) : Effect.void,\n        ),\n      )\n\n    const wrappedBody: LoopBody<S, A, E, R> = (s) => {\n      const result = body(s)\n      return Effect.isEffect(result) ? Effect.map(result, tap) : tap(result)\n    }\n\n    return {\n      stream: loop(initial, wrappedBody),\n      state: stateRef,\n    }\n  })\n"],"mappings":"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"}

package/dist/loop/Loop.test.d.mts

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

package/dist/loop/Loop.test.mjs

@@ -0,0 +1,411 @@
+import { loop, loopWithState, next, nextAfter, stopAfter, stopEvent, value } from "./Loop.mjs";
+import { i as it, n as globalExpect, r as describe } from "../dist-DV5ISja1.mjs";
+import { Deferred, Effect, Fiber, Latch, Ref, Stream, SubscriptionRef } from "effect";
+//#region src/loop/Loop.test.ts
+describe("Loop.loop", () => {
+	it("threads state across iterations and emits each iteration's substream in order", async () => {
+		const stream = loop(0, (n) => n >= 3 ? stopAfter(Stream.fromIterable([n])) : nextAfter(Stream.fromIterable([n, n + .5]), n + 1));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([
+			0,
+			.5,
+			1,
+			1.5,
+			2,
+			2.5,
+			3
+		]);
+	});
+	it("supports iterations that emit zero values and only decide", async () => {
+		const stream = loop(0, (n) => n >= 5 ? Stream.fromIterable([stopEvent]) : Stream.fromIterable([next(n + 1)]));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([]);
+	});
+	it("supports Effect-returning bodies directly (no Stream.unwrap needed)", async () => {
+		const stream = loop(1, (n) => Effect.gen(function* () {
+			const doubled = yield* Effect.succeed(n * 2);
+			return doubled >= 16 ? stopAfter(Stream.fromIterable([doubled])) : nextAfter(Stream.fromIterable([doubled]), doubled);
+		}));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([
+			2,
+			4,
+			8,
+			16
+		]);
+	});
+	it("still accepts Stream.unwrap-wrapped bodies for backward compatibility", async () => {
+		const stream = loop(1, (n) => Stream.unwrap(Effect.gen(function* () {
+			const doubled = yield* Effect.succeed(n * 2);
+			return doubled >= 4 ? stopAfter(Stream.fromIterable([doubled])) : nextAfter(Stream.fromIterable([doubled]), doubled);
+		})));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([2, 4]);
+	});
+	it("propagates errors from the body's stream", async () => {
+		const boom = /* @__PURE__ */ new Error("boom");
+		const stream = loop(0, (n) => n === 2 ? Stream.fail(boom) : Stream.fromIterable([value(n), next(n + 1)]));
+		globalExpect((await Effect.runPromiseExit(Stream.runCollect(stream)))._tag).toBe("Failure");
+	});
+	it("terminates silently if the body emits no Decision (mirrors paginate's silent stop)", async () => {
+		const stream = loop(0, (n) => Stream.fromIterable([value(n), value(n + 1)]));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([0, 1]);
+	});
+	it("short-circuits the body's stream when a Decision is seen", async () => {
+		const stream = loop(0, (n) => n >= 2 ? Stream.fromIterable([value(n), stopEvent]) : Stream.fromIterable([
+			value(n),
+			next(n + 1),
+			value(n + 10)
+		]));
+		globalExpect(await Effect.runPromise(Stream.runCollect(stream))).toEqual([
+			0,
+			1,
+			2
+		]);
+	});
+	it("is stack-safe and linear-time across many iterations", async () => {
+		const N = 1e5;
+		const stream = loop(0, (n) => n >= N ? Stream.fromIterable([value(n), stopEvent]) : Stream.fromIterable([value(n), next(n + 1)]));
+		globalExpect(await Effect.runPromise(Stream.runFold(stream, () => 0, (acc) => acc + 1))).toBe(N + 1);
+	}, 1e4);
+});
+const scriptedModel = (script) => {
+	let i = 0;
+	return { streamTurn: () => {
+		const turn = script[i] ?? [];
+		i += 1;
+		return Stream.fromIterable(turn);
+	} };
+};
+/**
+* Body factored out so both tests share it. Per iteration:
+*   1. Stream the model's deltas; tap captures texts + tool calls into Refs.
+*   2. flatMap projects deltas into UiEvents forwarded to the outer stream.
+*   3. Continuation reads the captured calls; if any, runs them, emits
+*      tool_result events, builds the next state (with model swap if a tool
+*      asked for one), and emits `next(state)`. Otherwise `stop`.
+*/
+const conversationLoop = (initial, runTool) => loop(initial, (state) => Stream.unwrap(Effect.gen(function* () {
+	const textsRef = yield* Ref.make([]);
+	const toolCallsRef = yield* Ref.make([]);
+	const deltas = state.model.streamTurn(state.history).pipe(Stream.tap((d) => d.type === "text" ? Ref.update(textsRef, (t) => [...t, d.text]) : Ref.update(toolCallsRef, (t) => [...t, {
+		id: d.id,
+		name: d.name
+	}])), Stream.flatMap((d) => d.type === "text" ? Stream.fromIterable([value({
+		type: "text",
+		text: d.text
+	})]) : Stream.fromIterable([value({
+		type: "tool_started",
+		id: d.id,
+		name: d.name
+	})])));
+	const continuation = Stream.unwrap(Effect.gen(function* () {
+		const texts = yield* Ref.get(textsRef);
+		const toolCalls = yield* Ref.get(toolCallsRef);
+		if (toolCalls.length === 0) return stopAfter(Stream.empty);
+		const turnItems = [...texts.length > 0 ? [{
+			type: "assistant",
+			text: texts.join("")
+		}] : [], ...toolCalls.map((tc) => ({
+			type: "tool_call",
+			id: tc.id,
+			name: tc.name
+		}))];
+		const outcomes = toolCalls.map((call) => ({
+			call,
+			outcome: runTool(call)
+		}));
+		const events = outcomes.map(({ call, outcome }) => ({
+			type: "tool_result",
+			id: call.id,
+			output: outcome.output
+		}));
+		const resultItems = outcomes.map(({ call, outcome }) => ({
+			type: "tool_result",
+			id: call.id,
+			output: outcome.output
+		}));
+		const nextModel = outcomes.reduce((m, { outcome }) => outcome.nextModel ?? m, state.model);
+		const nextState = {
+			history: [
+				...state.history,
+				...turnItems,
+				...resultItems
+			],
+			model: nextModel
+		};
+		return nextAfter(Stream.fromIterable(events), nextState);
+	}));
+	return Stream.concat(deltas, continuation);
+})));
+describe("Loop.loop - LLM-style scenarios", () => {
+	it("forwards text deltas, tool start, tool result, and post-tool text in order", async () => {
+		const m = scriptedModel([[
+			{
+				type: "text",
+				text: "hello"
+			},
+			{
+				type: "text",
+				text: " "
+			},
+			{
+				type: "text",
+				text: "world"
+			},
+			{
+				type: "tool_call",
+				id: "c1",
+				name: "get_time"
+			}
+		], [{
+			type: "text",
+			text: " time is "
+		}, {
+			type: "text",
+			text: "12:00"
+		}]]);
+		const runTool = (call) => ({ output: call.name === "get_time" ? "12:00" : "?" });
+		const initial = {
+			history: [{
+				type: "user",
+				text: "what time is it?"
+			}],
+			model: m
+		};
+		globalExpect(await Effect.runPromise(Stream.runCollect(conversationLoop(initial, runTool)))).toEqual([
+			{
+				type: "text",
+				text: "hello"
+			},
+			{
+				type: "text",
+				text: " "
+			},
+			{
+				type: "text",
+				text: "world"
+			},
+			{
+				type: "tool_started",
+				id: "c1",
+				name: "get_time"
+			},
+			{
+				type: "tool_result",
+				id: "c1",
+				output: "12:00"
+			},
+			{
+				type: "text",
+				text: " time is "
+			},
+			{
+				type: "text",
+				text: "12:00"
+			}
+		]);
+	});
+	it("model swap mid-stream: m1 calls upgrade, m2 finishes the response", async () => {
+		const m2 = scriptedModel([[{
+			type: "text",
+			text: "I am m2."
+		}, {
+			type: "text",
+			text: " The answer is 42."
+		}]]);
+		const m1 = scriptedModel([[
+			{
+				type: "text",
+				text: "Hard question."
+			},
+			{
+				type: "text",
+				text: " Upgrading."
+			},
+			{
+				type: "tool_call",
+				id: "u1",
+				name: "upgrade"
+			}
+		]]);
+		const runTool = (call) => call.name === "upgrade" ? {
+			output: "ok",
+			nextModel: m2
+		} : { output: "?" };
+		const initial = {
+			history: [{
+				type: "user",
+				text: "what is the meaning of life?"
+			}],
+			model: m1
+		};
+		globalExpect(await Effect.runPromise(Stream.runCollect(conversationLoop(initial, runTool)))).toEqual([
+			{
+				type: "text",
+				text: "Hard question."
+			},
+			{
+				type: "text",
+				text: " Upgrading."
+			},
+			{
+				type: "tool_started",
+				id: "u1",
+				name: "upgrade"
+			},
+			{
+				type: "tool_result",
+				id: "u1",
+				output: "ok"
+			},
+			{
+				type: "text",
+				text: "I am m2."
+			},
+			{
+				type: "text",
+				text: " The answer is 42."
+			}
+		]);
+	});
+});
+describe("Loop.loop - pull-specific stream semantics", () => {
+	it("does not start the next iteration when downstream only takes the first value", async () => {
+		globalExpect(await Effect.runPromise(Effect.gen(function* () {
+			const callsRef = yield* Ref.make(0);
+			yield* loop(0, (n) => Stream.unwrap(Ref.update(callsRef, (calls) => calls + 1).pipe(Effect.as(n >= 10 ? Stream.fromIterable([value(n), stopEvent]) : Stream.fromIterable([value(n), next(n + 1)]))))).pipe(Stream.take(1), Stream.runCollect);
+			return yield* Ref.get(callsRef);
+		}))).toBe(1);
+	});
+	it("propagates defects from the body instead of leaving the consumer waiting", async () => {
+		const defect = /* @__PURE__ */ new Error("defect");
+		const stream = loop(0, () => Stream.die(defect));
+		globalExpect((await Effect.runPromiseExit(Stream.runCollect(stream)))._tag).toBe("Failure");
+	});
+	it("runs body finalizers when a Decision short-circuits the body", async () => {
+		globalExpect(await Effect.runPromise(Effect.gen(function* () {
+			const releasesRef = yield* Ref.make([]);
+			const stream = loop(0, (n) => (n >= 1 ? Stream.fromIterable([value(n), stopEvent]) : Stream.fromIterable([
+				value(n),
+				next(n + 1),
+				value(n + 10)
+			])).pipe(Stream.ensuring(Ref.update(releasesRef, (values) => [...values, n]))));
+			globalExpect(yield* Stream.runCollect(stream)).toEqual([0, 1]);
+			return yield* Ref.get(releasesRef);
+		}))).toEqual([0, 1]);
+	});
+	it("runs the active body finalizer when the downstream consumer is interrupted", async () => {
+		globalExpect(await Effect.runPromise(Effect.gen(function* () {
+			const started = yield* Deferred.make();
+			const releasesRef = yield* Ref.make(0);
+			const body = () => Stream.concat(Stream.fromEffect(Deferred.succeed(started, void 0).pipe(Effect.as(value(0)))), Stream.never).pipe(Stream.ensuring(Ref.update(releasesRef, (n) => n + 1)));
+			const stream = loop(0, body);
+			const fiber = yield* Effect.forkChild(Stream.runCollect(stream));
+			yield* Deferred.await(started);
+			yield* Fiber.interrupt(fiber);
+			return yield* Ref.get(releasesRef);
+		}))).toBe(1);
+	});
+	it("does not create a body scope if constructing the body stream defects", async () => {
+		const defect = /* @__PURE__ */ new Error("body construction failed");
+		globalExpect((await Effect.runPromiseExit(Stream.runCollect(loop(0, () => {
+			throw defect;
+		}))))._tag).toBe("Failure");
+	});
+});
+describe("Loop.loopWithState", () => {
+	it("exposes the final state in the SubscriptionRef after the stream completes", async () => {
+		const program = Effect.gen(function* () {
+			const { stream, state } = yield* loopWithState(0, (n) => n >= 3 ? stopAfter(Stream.fromIterable([n])) : nextAfter(Stream.fromIterable([n]), n + 1));
+			const values = yield* Stream.runCollect(stream);
+			const finalState = yield* SubscriptionRef.get(state);
+			return {
+				values: Array.from(values),
+				finalState
+			};
+		});
+		const { values, finalState } = await Effect.runPromise(program);
+		globalExpect(values).toEqual([
+			0,
+			1,
+			2,
+			3
+		]);
+		globalExpect(finalState).toBe(3);
+	});
+	it("the state ref starts at `initial` and stays there if the loop stops without advancing", async () => {
+		const program = Effect.gen(function* () {
+			const { stream, state } = yield* loopWithState({ count: 7 }, () => Stream.fromIterable([stopEvent]));
+			yield* Stream.runDrain(stream);
+			return yield* SubscriptionRef.get(state);
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual({ count: 7 });
+	});
+	it("a downstream consumer can read the live state between emitted values", async () => {
+		const program = Effect.gen(function* () {
+			const { stream, state } = yield* loopWithState(0, (n) => n >= 3 ? stopAfter(Stream.fromIterable([n])) : nextAfter(Stream.fromIterable([n]), n + 1));
+			const seen = [];
+			yield* Stream.runForEach(stream, (v) => Effect.gen(function* () {
+				seen.push({
+					value: v,
+					stateAfter: yield* SubscriptionRef.get(state)
+				});
+			}));
+			return seen;
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual([
+			{
+				value: 0,
+				stateAfter: 0
+			},
+			{
+				value: 1,
+				stateAfter: 1
+			},
+			{
+				value: 2,
+				stateAfter: 2
+			},
+			{
+				value: 3,
+				stateAfter: 3
+			}
+		]);
+	});
+	it("SubscriptionRef.changes emits every state transition to a concurrent observer", async () => {
+		const program = Effect.gen(function* () {
+			const start = yield* Latch.make(false);
+			const { stream, state } = yield* loopWithState(0, (n) => Effect.gen(function* () {
+				if (n === 0) yield* Latch.await(start);
+				return n >= 3 ? stopAfter(Stream.empty) : nextAfter(Stream.empty, n + 1);
+			}));
+			const observerFiber = yield* Effect.forkChild(SubscriptionRef.changes(state).pipe(Stream.take(4), Stream.runCollect));
+			yield* Effect.sleep("10 millis");
+			yield* Latch.open(start);
+			yield* Stream.runDrain(stream);
+			return Array.from(yield* Fiber.join(observerFiber));
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual([
+			0,
+			1,
+			2,
+			3
+		]);
+	});
+	it("does not interfere with the body's value stream", async () => {
+		const program = Effect.gen(function* () {
+			const { stream } = yield* loopWithState(0, (n) => n >= 3 ? stopAfter(Stream.fromIterable([n])) : nextAfter(Stream.fromIterable([n, n + .5]), n + 1));
+			return Array.from(yield* Stream.runCollect(stream));
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual([
+			0,
+			.5,
+			1,
+			1.5,
+			2,
+			2.5,
+			3
+		]);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Loop.test.mjs.map