✨ Export reducer internals via experimental and label infrastructure effects

Export ReducerContext, Instruction, InstructionQueue, and DelimiterContext
through the experimental entry point, enabling external packages to build
custom reducers (e.g., for durable execution) without forking Effection.

Add description labels to withResolvers() calls in core infrastructure
effects (callcc, delimiter, each, future, scope-internal) so that custom
reducers can distinguish infrastructure effects from user-facing effects
by their description strings.

Author: Taras Mankovski

experimental.ts

@@ -1 +1,8 @@
 export * from "./lib/api.ts";
+export {
+  Reducer,
+  ReducerContext,
+  InstructionQueue,
+  type Instruction,
+} from "./lib/reducer.ts";
+export { DelimiterContext } from "./lib/delimiter.ts";

lib/callcc.ts

@@ -11,7 +11,7 @@ export function* callcc<T>(
     reject: (error: Error) => Operation<void>,
   ) => Operation<void>,
 ): Operation<T> {
-  let result = withResolvers<Result<T>>();
+  let result = withResolvers<Result<T>>("await callcc");
 
   let resolve = lift((value: T) => result.resolve(Ok(value)));
 

lib/delimiter.ts

@@ -10,7 +10,7 @@ export class Delimiter<T>
   implements Operation<Maybe<Result<T>>>, ErrorBoundary {
   level = 0;
   finalized = false;
-  future = withResolvers<Maybe<Result<T>>>();
+  future = withResolvers<Maybe<Result<T>>>("await delimiter");
   computed = false;
   routine?: Coroutine;
   outcome?: Maybe<Result<T>>;

lib/each.ts

@@ -37,8 +37,8 @@ export function each<T>(stream: Stream<T, unknown>): Operation<Iterable<T>> {
         scope.set(EachStack, []);
       }
 
-      let done = withResolvers<void>();
-      let cxt = withResolvers<EachLoop<T>>();
+      let done = withResolvers<void>("await each done");
+      let cxt = withResolvers<EachLoop<T>>("await each context");
 
       yield* spawn(function* () {
         let subscription = yield* stream;

lib/future.ts

@@ -9,7 +9,7 @@ export interface FutureWithResolvers<T> {
 }
 export function createFuture<T>(): FutureWithResolvers<T> {
   let promise = lazyPromiseWithResolvers<T>();
-  let operation = withResolvers<T>();
+  let operation = withResolvers<T>("await future");
 
   let resolve = (value: T) => {
     promise.resolve(value);

lib/reducer.ts

@@ -58,15 +58,15 @@ export class Reducer {
   };
 }
 
-type Instruction = [
+export type Instruction = [
   number,
   Coroutine<unknown>,
   Result<unknown>,
   () => boolean,
   "return" | "next",
 ];
 
-class InstructionQueue extends PriorityQueue<Instruction> {
+export class InstructionQueue extends PriorityQueue<Instruction> {
   enqueue(instruction: Instruction): void {
     let [priority] = instruction;
     this.push(priority, instruction);

lib/scope-internal.ts

@@ -133,7 +133,7 @@ export function buildScopeInternal(
       if (destruction) {
         return yield* destruction.operation;
       }
-      destruction = withResolvers<void>();
+      destruction = withResolvers<void>("await destruction");
       parent?.expect(Children).delete(scope);
       unbind();
       let outcome = Ok();