@opencode/codemode 2.1.0 → 2.1.2

package/dist/interpreter/execute.js

@@ -26,16 +26,19 @@ export const executeProgram = (code, prepared, limits, hooks, globals) => {
             const program = parseProgram(code);
             const pending = new Pending(scope, builtins.Promise);
             const ctx = new Interpreter({ tools, pending, builtins, logs, globals });
-            const result = (yield* toBoundary(ctx, yield* ctx.run(program))) ?? null;
-            returned = { value: result, pending };
-            const warnings = yield* pending.interrupt();
-            return {
-                ok: true,
-                value: result,
-                ...(warnings.length > 0 ? { warnings } : {}),
-                ...logged(),
-                toolCalls: tools.calls,
-            };
+            // The main job holds the turn until leftover promise work is interrupted.
+            return yield* pending.turn.hold(Effect.gen(function* () {
+                const result = (yield* toBoundary(ctx, yield* ctx.run(program))) ?? null;
+                returned = { value: result, pending };
+                const warnings = yield* pending.interrupt();
+                return {
+                    ok: true,
+                    value: result,
+                    ...(warnings.length > 0 ? { warnings } : {}),
+                    ...logged(),
+                    toolCalls: tools.calls,
+                };
+            }));
         }), (scope, exit) => Scope.close(scope, exit));
         const timeoutMs = limits.timeoutMs;
         const operation = timeoutMs === undefined

package/dist/interpreter/extensions.js

@@ -140,7 +140,7 @@ export const extensionGlobals = (ctx, extensions) => {
         }
         if (!(result instanceof Promise))
             return settle(Effect.succeed(result));
-        return ctx.pending.create(settle(Effect.tryPromise({ try: () => result, catch: (reason) => reason })));
+        return ctx.pending.createHost(settle(Effect.tryPromise({ try: () => result, catch: (reason) => reason })));
     });
     return extensions.flatMap((extension) => Object.entries(extension.globals).map(([name, value]) => [name, wrap(value, name, (args) => ({ extension: extension.name, name, args }))]));
 };

package/dist/interpreter/interpreter.js

@@ -286,18 +286,24 @@ class Frame {
             return value;
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
-    // Fork at the call site so admission and hooks occur when the call is made.
+    // Fork at the call site so admission and hooks occur when the call is made. Arguments cross on the caller's turn,
+    // since `toJSON` is program code; the host call runs without it, so tool calls stay concurrent.
     createToolCallPromise(path, args) {
-        return this.ctx.pending.create(this.ctx.tool((json) => this.ctx.tools.execute(path, json), args));
+        const pending = this.ctx.pending;
+        return pending.create(this.ctx.tool((json) => pending.turn.leave(this.ctx.tools.execute(path, json)), args));
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
     await(promise) {
         const pending = this.ctx.pending;
         return Effect.suspend(() => {
             pending.markObserved(promise);
-            return Effect.flatMap(pending.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
+            return Effect.flatten(pending.turn.suspend(Effect.flatMap(pending.await(promise), (exit) => Effect.as(Effect.yieldNow, exit))));
         });
     }
+    // End this job; the program continues in a later one, after the jobs already waiting.
+    nextJob() {
+        return this.ctx.pending.turn.suspend(Effect.yieldNow);
+    }
     evaluateStatement(node) {
         switch (node.type) {
             case "ExpressionStatement":
@@ -549,7 +555,7 @@ class Frame {
             const close = () => iterator
                 ? self.closeIterator(iterator, node, awaiting)
                 : awaiting
-                    ? Effect.andThen(cursor?.close ?? Effect.void, Effect.yieldNow)
+                    ? Effect.andThen(cursor?.close ?? Effect.void, self.nextJob())
                     : (cursor?.close ?? Effect.void);
             if (left.type === "RestElement" || left.type === "AssignmentPattern") {
                 throw typeError("Unsupported for...of binding.", left);
@@ -675,7 +681,7 @@ class Frame {
             const called = yield* Effect.exit(self.call(iterator.next, iterator.iterator, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
-                    yield* Effect.yieldNow;
+                    yield* self.nextJob();
                 return yield* Effect.failCause(called.cause);
             }
             const captured = yield* Effect.exit(Effect.sync(() => {
@@ -684,7 +690,7 @@ class Frame {
             }));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
-                    yield* Effect.yieldNow;
+                    yield* self.nextJob();
                 return yield* Effect.failCause(captured.cause);
             }
             return {
@@ -697,8 +703,9 @@ class Frame {
     }
     closeIterator(iterator, node, awaiting = true) {
         const close = get(iterator.iterator, "return");
-        if (close === undefined || close === null)
-            return iterator.asynchronous || !awaiting ? Effect.void : Effect.yieldNow;
+        if (close === undefined || close === null) {
+            return iterator.asynchronous || !awaiting ? Effect.void : this.nextJob();
+        }
         const self = this;
         return Effect.gen(function* () {
             const method = self.requireIteratorMethod(close, "Iterator return", node);
@@ -709,13 +716,13 @@ class Frame {
             const called = yield* Effect.exit(self.call(method, iterator.iterator, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
-                    yield* Effect.yieldNow;
+                    yield* self.nextJob();
                 return yield* Effect.failCause(called.cause);
             }
             const captured = yield* Effect.exit(Effect.sync(() => get(self.requireIteratorObject(called.value, "Iterator return() result", node), "value")));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
-                    yield* Effect.yieldNow;
+                    yield* self.nextJob();
                 return yield* Effect.failCause(captured.cause);
             }
             if (awaiting)
@@ -1506,8 +1513,14 @@ class Frame {
         invocation.generatorAsync = asynchronous;
         const builtins = this.ctx.builtins;
         const result = (value, done) => record(builtins.Object, { value, done });
+        const turn = this.ctx.pending.turn;
         const request = (kind, value) => {
             const request = { kind, value, response: Deferred.makeUnsafe() };
+            // A body that ran on the caller's turn has answered or suspended when it hands the turn back. An answer still
+            // pending can only be an async generator's: its promise settles when the body answers, without the turn.
+            const answer = Effect.suspend(() => Deferred.isDoneUnsafe(request.response)
+                ? Deferred.await(request.response)
+                : turn.leave(Deferred.await(request.response)));
             if (!asynchronous && state.active)
                 return Effect.die(typeError("Generator is already running."));
             if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
@@ -1515,11 +1528,11 @@ class Frame {
                 state.completed = true;
                 state.pending.push(request);
                 if (state.draining)
-                    return Deferred.await(request.response);
+                    return answer;
                 state.draining = true;
                 return Effect.andThen(this.ctx.pending.fork(invocation
                     .completeGeneratorRequests(state, true)
-                    .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), Deferred.await(request.response));
+                    .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), answer);
             }
             if (state.completed) {
                 if (kind === "throw")
@@ -1534,9 +1547,10 @@ class Frame {
             }
             state.pending.push(request);
             if (state.available) {
+                // The body is parked waiting for a request: it runs this step on the caller's turn.
                 const available = state.available;
                 state.available = undefined;
-                Deferred.doneUnsafe(available, Exit.succeed(undefined));
+                return Effect.andThen(turn.handOff(Effect.sync(() => Deferred.doneUnsafe(available, Exit.succeed(undefined)))), answer);
             }
             if (!state.started) {
                 state.started = true;
@@ -1555,9 +1569,9 @@ class Frame {
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
                 });
-                return Effect.andThen(this.ctx.pending.fork(body), Deferred.await(request.response));
+                return Effect.andThen(this.ctx.pending.fork(body), answer);
             }
-            return Deferred.await(request.response);
+            return answer;
         };
         const proto = get(fn, "prototype");
         return new GeneratorObj(proto instanceof Obj ? proto : builtins.Generator, asynchronous, request);
@@ -1588,7 +1602,7 @@ class Frame {
         if (next)
             return Effect.succeed(next);
         state.available = Deferred.makeUnsafe();
-        return Effect.andThen(Deferred.await(state.available), Effect.sync(() => this.dequeueGeneratorRequest(state)));
+        return Effect.andThen(this.ctx.pending.turn.park(Deferred.await(state.available)), Effect.sync(() => this.dequeueGeneratorRequest(state)));
     }
     dequeueGeneratorRequest(state) {
         const request = state.pending[state.pendingIndex];

package/dist/interpreter/promises.d.ts

@@ -1,10 +1,36 @@
-import { Effect, Exit, Scope } from "effect";
+import { Effect, Exit, Fiber, Scope } from "effect";
 import type { Diagnostic } from "../codemode.js";
 import { Obj, PromiseObj, type Value } from "./objects.js";
 import type { Interpreter } from "./interpreter.js";
+/**
+ * The right to run program code. JavaScript runs one job at a time: code between two awaits finishes before another
+ * job starts. Effect preempts a busy fiber so timeouts and host work still run, so only the fiber holding the turn may
+ * run program code. A synchronous call into another fiber (an async function's body up to its first await, a
+ * generator step) lends that fiber the turn and gets it back when the callee suspends or ends. An await gives the turn
+ * to the next waiting job and queues to take it back. Work that only settles a promise or runs host code leaves
+ * without it, so tool calls stay concurrent and resolvers settle in the call, as in JavaScript.
+ */
+export declare class Turn {
+    private holder;
+    private readonly handbacks;
+    private first;
+    private last;
+    private nesting;
+    readonly take: Effect.Effect<void>;
+    hold<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+    release(fiber: Fiber.Fiber<unknown, unknown>): void;
+    suspend<A, E, R>(wait: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+    leave<A, E, R>(wait: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+    handOff<A, E, R>(start: Effect.Effect<A, E, R>): Effect.Effect<void, E, R>;
+    park<A, E, R>(wait: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+    fork<A, E, R>(effect: Effect.Effect<A, E, R>, scope: Scope.Scope): Effect.Effect<Fiber.Fiber<A, E>, never, R>;
+    private handBack;
+    private nest;
+}
 export declare class Pending<R> {
     private readonly scope;
     private readonly proto;
+    readonly turn: Turn;
     private readonly active;
     private readonly ids;
     private readonly observed;
@@ -15,6 +41,8 @@ export declare class Pending<R> {
         promise?: PromiseObj;
     }) => Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R>;
     create(effect: Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    createHost(effect: Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    private register;
     markObserved(promise: PromiseObj): void;
     await(promise: PromiseObj): Effect.Effect<Exit.Exit<Value, unknown>>;
     fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;

package/dist/interpreter/promises.js

@@ -11,10 +11,165 @@ const capability = (ctx, name, settle) => fn(ctx.builtins, name, 1, (_, args) =>
     settle(args[0]);
     return undefined;
 });
+// Program fibers that synchronous starts and handbacks may nest on the host stack. Deeper ones start and resume
+// through the scheduler, so deep recursion through async calls cannot overflow the host stack.
+const MAX_NESTING = 100;
+/**
+ * The right to run program code. JavaScript runs one job at a time: code between two awaits finishes before another
+ * job starts. Effect preempts a busy fiber so timeouts and host work still run, so only the fiber holding the turn may
+ * run program code. A synchronous call into another fiber (an async function's body up to its first await, a
+ * generator step) lends that fiber the turn and gets it back when the callee suspends or ends. An await gives the turn
+ * to the next waiting job and queues to take it back. Work that only settles a promise or runs host code leaves
+ * without it, so tool calls stay concurrent and resolvers settle in the call, as in JavaScript.
+ */
+export class Turn {
+    holder;
+    // Callers waiting for a callee to hand the turn back, innermost last.
+    handbacks = [];
+    // Jobs waiting to take the turn, in the order they became ready.
+    first;
+    last;
+    nesting = 0;
+    // Take the turn when it is free, after the jobs already waiting.
+    take = Effect.withFiber((fiber) => {
+        if (this.holder === undefined) {
+            this.holder = fiber;
+            return Effect.void;
+        }
+        return Effect.callback((resume) => {
+            const waiter = { fiber, resume, removed: false };
+            if (this.last === undefined)
+                this.first = waiter;
+            else
+                this.last.next = waiter;
+            this.last = waiter;
+            // Interrupted while waiting, or after the turn was granted but before it ran.
+            return Effect.sync(() => {
+                if (this.holder === fiber)
+                    this.release(fiber);
+                else
+                    waiter.removed = true;
+            });
+        });
+    });
+    // Run `effect` holding the turn, as the program's main job does.
+    hold(effect) {
+        return Effect.withFiber((fiber) => Effect.andThen(this.take, effect).pipe(Effect.ensuring(Effect.sync(() => this.release(fiber)))));
+    }
+    // Give up the turn, back to the innermost caller waiting for it or to the next waiting job.
+    release(fiber) {
+        if (this.holder !== fiber)
+            return;
+        const back = this.handbacks.pop();
+        if (back !== undefined) {
+            this.holder = back.fiber;
+            this.handBack(back);
+            return;
+        }
+        let next = this.first;
+        while (next !== undefined && next.removed)
+            next = next.next;
+        this.first = next?.next;
+        if (this.first === undefined)
+            this.last = undefined;
+        this.holder = next?.fiber;
+        // Resume in the scheduler, as a yield would: release can run inside another fiber's step.
+        if (next !== undefined)
+            next.fiber.currentDispatcher.scheduleTask(() => next.resume(Effect.void), 0);
+    }
+    // Wait without the turn, then queue for it like any job that became ready. An interrupted fiber stops without it.
+    suspend(wait) {
+        return Effect.uninterruptibleMask((restore) => Effect.withFiber((fiber) => {
+            this.release(fiber);
+            return Effect.flatMap(Effect.exit(restore(wait)), (exit) => Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) ? exit : Effect.andThen(restore(this.take), exit));
+        }));
+    }
+    // Wait without the turn and finish without it, for work that only settles a promise or runs host code.
+    leave(wait) {
+        return Effect.withFiber((fiber) => {
+            this.release(fiber);
+            return wait;
+        });
+    }
+    // Run `start`, which wakes a fiber parked with `park`, and continue once it hands the turn back.
+    handOff(start) {
+        return Effect.withFiber((fiber) => {
+            const back = { fiber, returned: false };
+            this.handbacks.push(back);
+            return Effect.andThen(this.nest(start), awaitHandback(back));
+        });
+    }
+    // Wait without the turn for a caller to hand it over with `handOff`.
+    park(wait) {
+        return Effect.uninterruptibleMask((restore) => Effect.withFiber((fiber) => {
+            this.release(fiber);
+            // The wake runs inside the caller's step; when that is deep, yield so the body continues on its own stack.
+            return Effect.tap(restore(wait), () => {
+                this.holder = fiber;
+                return this.nesting > MAX_NESTING ? Effect.yieldNow : Effect.void;
+            });
+        }));
+    }
+    // Fork a fiber that runs program code. It starts with the caller's turn, and the caller continues once the fiber
+    // suspends or ends; the fiber gives up the turn whenever it ends.
+    fork(effect, scope) {
+        return Effect.withFiber((caller) => {
+            const back = { fiber: caller, returned: false };
+            this.handbacks.push(back);
+            let started = false;
+            const body = Effect.withFiber((fiber) => {
+                started = true;
+                this.holder = fiber;
+                return effect;
+            });
+            const forked = this.nesting < MAX_NESTING
+                ? this.nest(Effect.forkIn(body, scope, { startImmediately: true }))
+                : Effect.forkIn(body, scope);
+            return Effect.flatMap(forked, (fiber) => {
+                fiber.addObserver(() => {
+                    if (started)
+                        return this.release(fiber);
+                    // Forked into a closing scope: it never took the turn, so the caller keeps it.
+                    const index = this.handbacks.lastIndexOf(back);
+                    if (index >= 0)
+                        this.handbacks.splice(index, 1);
+                    this.handBack(back);
+                });
+                // A callee that suspends without blocking hands the turn back before `forkIn` returns.
+                return back.returned ? Effect.succeed(fiber) : Effect.as(awaitHandback(back), fiber);
+            });
+        });
+    }
+    // Resume a parked caller in the scheduler: resumed inline, it would run to its next await and queue before the callee
+    // that just suspended has queued its own continuation.
+    handBack(back) {
+        back.returned = true;
+        const resume = back.resume;
+        if (resume !== undefined)
+            back.fiber.currentDispatcher.scheduleTask(() => resume(Effect.void), 0);
+    }
+    // Run `effect`, which can run another program fiber inside the current step, counting the nesting.
+    nest(effect) {
+        return Effect.suspend(() => {
+            this.nesting++;
+            return Effect.ensuring(effect, Effect.sync(() => {
+                this.nesting--;
+            }));
+        });
+    }
+}
+// The check runs when the caller suspends: it can be preempted after deciding to wait.
+const awaitHandback = (back) => Effect.callback((resume) => {
+    if (back.returned)
+        resume(Effect.void);
+    else
+        back.resume = resume;
+});
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class Pending {
     scope;
     proto;
+    turn = new Turn();
     active = new Set();
     ids = new WeakMap();
     observed = new WeakSet();
@@ -32,7 +187,15 @@ export class Pending {
             return promise;
         });
     }
+    // A promise whose work runs program code, on the turn. Host work that runs no program code uses `createHost`.
     create(effect) {
+        return this.register(effect, (body) => this.turn.fork(body, this.scope));
+    }
+    // Starts now, without the turn, so host work stays concurrent and attaches to host promises at once.
+    createHost(effect) {
+        return this.register(effect, (body) => Effect.forkIn(body, this.scope, { startImmediately: true }));
+    }
+    register(effect, fork) {
         return Effect.flatMap(CallSite, (site) => {
             if (this.active.size >= MAX_PENDING_PROMISES) {
                 throw rangeError(`Too many pending promises (limit ${MAX_PENDING_PROMISES}); await promises before creating more.`);
@@ -40,7 +203,7 @@ export class Pending {
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
             const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));
-            return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
+            return Effect.map(fork(body), (fiber) => {
                 const promise = new PromiseObj(this.proto, fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
@@ -72,7 +235,7 @@ export class Pending {
         return Fiber.await(promise.fiber);
     }
     fork(effect) {
-        return Effect.asVoid(Effect.forkIn(effect, this.scope, { startImmediately: true }));
+        return Effect.asVoid(this.turn.fork(effect, this.scope));
     }
     diagnostics() {
         return [...this.failures].sort(([left], [right]) => left - right).map(([, failure]) => failure);
@@ -101,7 +264,7 @@ export const resolvePromiseValue = (ctx, value, own) => {
         return Effect.succeed(value);
     return Effect.gen(function* () {
         // Promise resolution invokes a thenable's method in a later job.
-        yield* Effect.yieldNow;
+        yield* ctx.pending.turn.suspend(Effect.yieldNow);
         const deferred = Deferred.makeUnsafe();
         const resolve = capability(ctx, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
         const reject = capability(ctx, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(reason))));
@@ -111,7 +274,7 @@ export const resolvePromiseValue = (ctx, value, own) => {
                 return yield* Effect.failCause(executed.cause);
             Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
         }
-        return yield* resolvePromiseValue(ctx, yield* Deferred.await(deferred), own);
+        return yield* resolvePromiseValue(ctx, yield* ctx.pending.turn.leave(Deferred.await(deferred)), own);
     });
 };
 export const resolvePromise = (ctx, value) => {
@@ -157,31 +320,33 @@ const invokePromiseMethod = (ctx, name, args) => {
             items.push(item);
         }
         if (name === "all") {
-            return new Arr(ctx.builtins.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(ctx.pending.await(item))), { concurrency: "unbounded" })));
+            return new Arr(ctx.builtins.Array, yield* settleAfterTurn(ctx, Effect.all(items.map((item) => Effect.flatten(ctx.pending.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
-            const outcomes = [];
-            for (const item of items) {
-                const exit = yield* ctx.pending.await(item);
-                if (Exit.isSuccess(exit)) {
-                    outcomes.push(record(ctx.builtins.Object, { status: "fulfilled", value: exit.value }));
-                    continue;
+            return yield* ctx.pending.turn.suspend(Effect.gen(function* () {
+                const outcomes = [];
+                for (const item of items) {
+                    const exit = yield* ctx.pending.await(item);
+                    if (Exit.isSuccess(exit)) {
+                        outcomes.push(record(ctx.builtins.Object, { status: "fulfilled", value: exit.value }));
+                        continue;
+                    }
+                    if (Cause.hasInterruptsOnly(exit.cause))
+                        return yield* Effect.failCause(exit.cause);
+                    outcomes.push(record(ctx.builtins.Object, {
+                        status: "rejected",
+                        reason: materialize(ctx, Cause.squash(exit.cause)),
+                    }));
                 }
-                if (Cause.hasInterruptsOnly(exit.cause))
-                    return yield* Effect.failCause(exit.cause);
-                outcomes.push(record(ctx.builtins.Object, {
-                    status: "rejected",
-                    reason: materialize(ctx, Cause.squash(exit.cause)),
-                }));
-            }
-            yield* Effect.yieldNow;
-            return new Arr(ctx.builtins.Array, outcomes);
+                yield* Effect.yieldNow;
+                return new Arr(ctx.builtins.Array, outcomes);
+            }));
         }
         if (name === "race") {
             if (items.length === 0) {
                 throw typeError("Promise.race([]) would never settle; provide at least one promise or value.");
             }
-            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => ctx.pending.await(item)))));
+            return yield* settleAfterTurn(ctx, Effect.flatten(Effect.raceAll(items.map((item) => ctx.pending.await(item)))));
         }
         const flipped = items.map((item) => Effect.flatMap(ctx.pending.await(item), (exit) => {
             if (Exit.isSuccess(exit))
@@ -190,7 +355,7 @@ const invokePromiseMethod = (ctx, name, args) => {
                 return Effect.failCause(exit.cause);
             return Effect.succeed(materialize(ctx, Cause.squash(exit.cause)));
         }));
-        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new Throw(createAggregateErrorValue(ctx, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
+        return yield* settleAfterTurn(ctx, Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new Throw(createAggregateErrorValue(ctx, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
     }));
 };
 const instanceMethod = (ctx, name, thisValue, args) => {
@@ -207,7 +372,7 @@ const instanceMethod = (ctx, name, thisValue, args) => {
 /** NewPromiseCapability: a pending promise with the resolve/reject callables that settle it exactly once. */
 const promiseCapability = (ctx) => Effect.gen(function* () {
     const deferred = Deferred.makeUnsafe();
-    const promise = yield* ctx.pending.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(ctx, value, self)));
+    const promise = yield* ctx.pending.createWithSelf((self) => Effect.flatMap(ctx.pending.turn.leave(Deferred.await(deferred)), (value) => resolvePromiseValue(ctx, value, self)));
     const resolve = capability(ctx, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
     const reject = capability(ctx, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(value))));
     return { promise, resolve, reject, deferred };
@@ -227,8 +392,9 @@ const constructPromise = (ctx, executor) => {
         return made.promise;
     });
 };
-// Settle one reaction turn after the deciding member, after its existing reactions.
-const settleAfterTurn = (body) => Effect.flatMap(Effect.exit(body), (exit) => Effect.andThen(Effect.yieldNow, exit));
+// Settle one reaction turn after the deciding member, after its existing reactions. That reaction is a job: it queues
+// for the turn behind the jobs ready before it and settles holding it.
+const settleAfterTurn = (ctx, body) => Effect.flatten(ctx.pending.turn.suspend(Effect.flatMap(Effect.exit(body), (exit) => Effect.as(Effect.yieldNow, exit))));
 class PromiseAnyFulfilled {
     value;
     constructor(value) {
@@ -244,13 +410,13 @@ const reactionHandler = (value, method) => {
     return undefined;
 };
 // Teardown bypasses handlers; settled reactions yield once so handlers never run inline.
-const reactionExit = (ctx, source) => Effect.gen(function* () {
+const reactionExit = (ctx, source) => ctx.pending.turn.suspend(Effect.gen(function* () {
     const exit = yield* ctx.pending.await(source);
     if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause))
         return yield* Effect.failCause(exit.cause);
     yield* Effect.yieldNow;
     return exit;
-});
+}));
 const chainReaction = (ctx, source, onFulfilled, onRejected, method) => {
     return ctx.pending.createWithSelf((self) => Effect.gen(function* () {
         const exit = yield* reactionExit(ctx, source);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",