effect-browser 0.3.0-beta.7 → 0.3.0-beta.9

package/src/internal/input/gate.ts

@@ -0,0 +1,224 @@
+/**
+ * A browser's input authority: stop admitting writes, drain admitted operations through their
+ * records and native replies, then retain the stop for its scopes. Reads never enter this gate.
+ */
+import { Clock, Deferred, Duration, Effect, Exit, Option, type Scope } from "effect";
+
+import { BrowserError, Busy, Closed, InvalidRequest, Suspended } from "../../BrowserError.ts";
+import type { DisconnectCause } from "../../BrowserEvent.ts";
+
+interface Stopped {
+  readonly since: number;
+  readonly at: number;
+}
+
+type State =
+  | { readonly _tag: "Open"; readonly inputs: ReadonlySet<number> }
+  | {
+      readonly _tag: "Draining";
+      readonly inputs: ReadonlySet<number>;
+      readonly claims: ReadonlySet<number>;
+      readonly startedAt: number;
+      readonly deadline: number;
+    }
+  | { readonly _tag: "Held"; readonly claims: ReadonlySet<number>; readonly stopped: Stopped };
+
+type Input =
+  | { readonly _tag: "Enter" | "End" | "Leave"; readonly id: number }
+  | { readonly _tag: "Suspend"; readonly id: number; readonly drain: number }
+  | { readonly _tag: "Expire" };
+
+const without = (set: ReadonlySet<number>, id: number) =>
+  new Set([...set].filter((each) => each !== id));
+
+const step = (state: State, input: Input, stopped: Stopped): State => {
+  switch (input._tag) {
+    case "Enter":
+      return state._tag === "Open"
+        ? { ...state, inputs: new Set([...state.inputs, input.id]) }
+        : state;
+    case "End": {
+      if (state._tag === "Held") return state;
+      const inputs = without(state.inputs, input.id);
+
+      return state._tag === "Draining" && inputs.size === 0
+        ? { _tag: "Held", claims: state.claims, stopped }
+        : { ...state, inputs };
+    }
+    case "Suspend":
+      if (state._tag !== "Open") return { ...state, claims: new Set([...state.claims, input.id]) };
+
+      return state.inputs.size === 0
+        ? { _tag: "Held", claims: new Set([input.id]), stopped }
+        : {
+            _tag: "Draining",
+            inputs: state.inputs,
+            claims: new Set([input.id]),
+            startedAt: stopped.at,
+            deadline: stopped.at + input.drain,
+          };
+    case "Leave": {
+      if (state._tag === "Open" || !state.claims.has(input.id)) return state;
+      const claims = without(state.claims, input.id);
+
+      return claims.size > 0
+        ? { ...state, claims }
+        : { _tag: "Open", inputs: state._tag === "Draining" ? state.inputs : new Set() };
+    }
+    case "Expire":
+      return state._tag === "Draining" && stopped.at >= state.deadline
+        ? { _tag: "Open", inputs: state.inputs }
+        : state;
+  }
+};
+
+export const make = (options: {
+  readonly now: () => number;
+  readonly sequence: () => number;
+  readonly closedBy: () => DisconnectCause | undefined;
+  readonly lost: Effect.Effect<DisconnectCause>;
+  readonly clock: Clock.Clock;
+  readonly drain: Duration.Duration;
+}) => {
+  let state: State = { _tag: "Open", inputs: new Set() };
+  let next = 0;
+  let refused = Deferred.makeUnsafe<void>();
+  let ready = Deferred.makeUnsafe<Stopped, BrowserError>();
+
+  const error = (operation: string) =>
+    new BrowserError({
+      operation,
+      reason:
+        options.closedBy() === undefined
+          ? new Suspended()
+          : new Closed({ cause: options.closedBy() ?? "connection" }),
+      dispatched: false,
+    });
+
+  const stopped = (): Stopped => ({ since: options.sequence(), at: options.now() });
+
+  // Every change to authority happens here, synchronously with its admission or scope closure.
+  const apply = (input: Input): State => {
+    if (input._tag !== "Expire" && state._tag === "Draining" && options.now() >= state.deadline)
+      apply({ _tag: "Expire" });
+    const before = state;
+
+    state = step(state, input, stopped());
+    if (input._tag === "Expire" && before._tag === "Draining" && state._tag === "Open")
+      Deferred.doneUnsafe(
+        ready,
+        Exit.fail(
+          new BrowserError({
+            operation: "suspend",
+            reason: new Busy({
+              waitedMillis: Math.round(options.now() - before.startedAt),
+              ahead: before.inputs.size,
+            }),
+            dispatched: false,
+          }),
+        ),
+      );
+    if (before._tag === "Open" && state._tag !== "Open") Deferred.doneUnsafe(refused, Exit.void);
+    if (before._tag === "Draining" && state._tag === "Held")
+      Deferred.doneUnsafe(ready, Exit.succeed(state.stopped));
+    if (before._tag !== "Open" && state._tag === "Open") {
+      refused = Deferred.makeUnsafe();
+      ready = Deferred.makeUnsafe();
+    }
+
+    return state;
+  };
+
+  const check = (operation: string) =>
+    Effect.suspend(() =>
+      state._tag === "Open" && options.closedBy() === undefined
+        ? Effect.void
+        : Effect.fail(error(operation)),
+    );
+
+  const suspend = (
+    drain: Duration.Input = options.drain,
+  ): Effect.Effect<Stopped, BrowserError, Scope.Scope> =>
+    Effect.suspend(() => {
+      const duration = Duration.fromInput(drain);
+
+      if (
+        Option.isNone(duration) ||
+        !Duration.isFinite(duration.value) ||
+        Duration.toMillis(duration.value) < 0
+      )
+        return Effect.fail(
+          new BrowserError({
+            operation: "suspend",
+            reason: new InvalidRequest({ detail: "drain must be a finite nonnegative duration" }),
+            dispatched: false,
+          }),
+        );
+      const id = ++next;
+      const leave = Effect.sync(() => apply({ _tag: "Leave", id }));
+
+      return Effect.acquireRelease(
+        Effect.gen(function* () {
+          if (options.closedBy() !== undefined) return yield* error("suspend");
+          const current = apply({ _tag: "Suspend", id, drain: Duration.toMillis(duration.value) });
+
+          if (current._tag === "Held") return current.stopped;
+          if (current._tag !== "Draining")
+            return yield* Effect.die("suspension did not retain authority");
+          const pending = ready;
+
+          // Native completion and timer callbacks both check the same monotonic deadline. A
+          // timer may wake a fraction early, so it sleeps the remaining time instead of hanging.
+          const expire: Effect.Effect<Stopped, BrowserError> = Effect.suspend(() => {
+            const left = current.deadline - options.now();
+
+            return left > 0
+              ? Effect.sleep(Duration.millis(left)).pipe(Effect.andThen(expire))
+              : Effect.sync(() => apply({ _tag: "Expire" })).pipe(
+                  Effect.andThen(Deferred.await(pending)),
+                );
+          });
+
+          const wait = Effect.raceFirst(Deferred.await(pending), expire);
+
+          return yield* Effect.raceFirst(
+            wait,
+            options.lost.pipe(Effect.flatMap(() => Effect.fail(error("suspend")))),
+          ).pipe(
+            Effect.interruptible,
+            Effect.filterOrFail(
+              () => options.closedBy() === undefined,
+              () => error("suspend"),
+            ),
+            Effect.onError(() => leave),
+          );
+        }),
+        () => leave,
+      );
+    }).pipe(Effect.provideService(Clock.Clock, options.clock));
+
+  return {
+    check,
+    suspend,
+    refused: (operation: string): Effect.Effect<never, BrowserError> =>
+      Effect.suspend(() =>
+        state._tag === "Open"
+          ? Deferred.await(refused).pipe(Effect.andThen(Effect.fail(error(operation))))
+          : Effect.fail(error(operation)),
+      ),
+    enter: (operation: string): Effect.Effect<() => void, BrowserError> =>
+      Effect.suspend(() => {
+        if (state._tag !== "Open" || options.closedBy() !== undefined)
+          return Effect.fail(error(operation));
+        const id = ++next;
+
+        apply({ _tag: "Enter", id });
+
+        return Effect.succeed(() => {
+          apply({ _tag: "End", id });
+        });
+      }),
+  };
+};
+
+export type Gate = ReturnType<typeof make>;

package/src/internal/input/guard.ts

@@ -150,8 +150,8 @@ export const make = (page: PageContext, bridge: Bridge) => {
       return { request, validate };
     });
 
-  // `mayHaveRun` hears of a failure the script may have started before: without its context or
-  // the library's API in it, the call never ran.
+  // `mayHaveRun` hears of a failure or interruption after the script may have started. A known
+  // missing context or API means it never ran; acquiring the context itself sends no mutation.
   const mutate = (
     operation: string,
     call: string,
@@ -161,6 +161,7 @@ export const make = (page: PageContext, bridge: Bridge) => {
     (approval === undefined ? current(operation) : Effect.succeed(approval.contextId)).pipe(
       Effect.flatMap((contextId) =>
         evaluateIn(operation, call, contextId).pipe(
+          Effect.onInterrupt(() => mayHaveRun),
           Effect.tapError((error) =>
             error.reason._tag === "Failed" &&
             /Cannot find context|__effectBrowser/i.test(error.reason.detail)

package/src/internal/input/perform.ts

@@ -2,7 +2,7 @@
  * Performing one action: its turn on the page, the input guard's step, the input run that owns its
  * replies, and the action's record. Its deadline leaves out the time its style takes to show it.
  */
-import { Duration, Effect, Exit, Option, Ref } from "effect";
+import { Deferred, Duration, Effect, Exit, Option, Ref } from "effect";
 
 import { BrowserError, PolicyTimeout, Timeout } from "../../BrowserError.ts";
 import { Action, type ActionOptions, Subject } from "../../BrowserEvent.ts";
@@ -97,10 +97,67 @@ const deadline =
       return Effect.raceFirst(effect, expiry);
     });
 
+/** An admitted operation stays owned through its Action and any unanswered native replies. */
+const admission = (page: PageContext, pending: Set<Deferred.Deferred<void>>, name: string) => {
+  let run: Replies.Run | undefined;
+  let end: (() => void) | undefined;
+
+  const enter = Effect.uninterruptible(
+    Effect.gen(function* () {
+      const released = page.inputGate === undefined ? undefined : yield* page.inputGate.enter(name);
+      const done = Deferred.makeUnsafe<void>();
+
+      pending.add(done);
+      end = () => {
+        const finish = () => {
+          released?.();
+          pending.delete(done);
+          Deferred.doneUnsafe(done, Exit.void);
+        };
+
+        if (run === undefined) finish();
+        else run.afterIdle(finish);
+      };
+    }),
+  );
+
+  return {
+    enter,
+    using: (current: Replies.Run) => {
+      run = current;
+    },
+    end: Effect.sync(() => end?.()),
+  };
+};
+
+/** Close a run on every exit while preserving its native replies for the page's next input. */
+const useRun = <A>(
+  page: PageContext,
+  sender: Dispatch,
+  name: string,
+  run: Replies.Run,
+  action: Effect.Effect<A, BrowserError>,
+) =>
+  action.pipe(
+    Effect.matchEffect({
+      onFailure: (error) =>
+        run.close.pipe(
+          Effect.andThen(sender.flush(name, run).pipe(Effect.ignore)),
+          Effect.andThen(Effect.fail(error)),
+        ),
+      onSuccess: (value) =>
+        run.close.pipe(Effect.andThen(sender.flush(name, run)), Effect.as(value)),
+    }),
+    // Cleanup submits missing releases; the page retains replies after caller interruption.
+    Effect.ensuring(run.close.pipe(Effect.andThen(page.openings.clear))),
+    Effect.provideService(Replies.Current, run),
+  );
+
 export const make = (page: PageContext, sender: Dispatch) => {
   const { id, settings, mapping, lane, publish, now, noteInput, span, owned } = page;
-  const { inputClocks, flush } = sender;
+  const { inputClocks } = sender;
   const input = Replies.make();
+  const admitted = new Set<Deferred.Deferred<void>>();
 
   // Record the whole operation, but never hold the page's turn or spend its action timeout while
   // a policy is waiting. Validation binds approval to the document and targets it saw.
@@ -127,6 +184,7 @@ export const make = (page: PageContext, sender: Dispatch) => {
       let revealed = info.secret !== true;
       // The time the style has planned to show the input, which the deadline leaves out.
       let presented = 0;
+      const ticket = admission(page, admitted, name);
 
       const marks = {
         style,
@@ -160,27 +218,13 @@ export const make = (page: PageContext, sender: Dispatch) => {
         input.begin.pipe(
           // A capture can recalibrate while input is running. One run, including delayed cleanup
           // releases, keeps one mapping so epoch stamps cannot jump backwards during a stroke.
-          Effect.tap((run) =>
+          Effect.tap((current) =>
             Effect.sync(() => {
-              if (estimate !== undefined) inputClocks.set(run, estimate);
+              ticket.using(current);
+              if (estimate !== undefined) inputClocks.set(current, estimate);
             }),
           ),
-          Effect.flatMap((run) =>
-            action(run).pipe(
-              Effect.matchEffect({
-                onFailure: (error) =>
-                  run.close.pipe(
-                    Effect.andThen(flush(name, run).pipe(Effect.ignore)),
-                    Effect.andThen(Effect.fail(error)),
-                  ),
-                onSuccess: (value) =>
-                  run.close.pipe(Effect.andThen(flush(name, run)), Effect.as(value)),
-              }),
-              // The finalizer only submits missing releases. It cannot wait forever for a
-              // disconnected peer; the page retains those replies and gates its next action.
-              Effect.ensuring(run.close.pipe(Effect.andThen(page.openings.clear))),
-            ),
-          ),
+          Effect.flatMap((run) => useRun(page, sender, name, run, action(run))),
         );
 
       // How long its turn and the page's replies kept the action waiting, once it had both.
@@ -198,16 +242,19 @@ export const make = (page: PageContext, sender: Dispatch) => {
             name,
             timeout,
           )(
-            Effect.suspend(() =>
-              admit.pipe(
-                Effect.timeoutOrElse({
-                  duration: Duration.millis(
-                    Math.max(0, Duration.toMillis(timeout) - (now() - asked)),
+            ticket.enter.pipe(
+              Effect.andThen(
+                Effect.suspend(() =>
+                  admit.pipe(
+                    Effect.timeoutOrElse({
+                      duration: Duration.millis(
+                        Math.max(0, Duration.toMillis(timeout) - (now() - asked)),
+                      ),
+                      orElse: () => timedOut(name, timeout),
+                    }),
                   ),
-                  orElse: () => timedOut(name, timeout),
-                }),
+                ),
               ),
-            ).pipe(
               Effect.tap(() =>
                 Effect.sync(() => {
                   queuedMillis = Math.round(now() - asked);
@@ -221,7 +268,7 @@ export const make = (page: PageContext, sender: Dispatch) => {
       const guard = settings.guard;
 
       // Only an approval needs binding: without a guard, input goes straight to the page.
-      const run =
+      const action =
         guard === undefined
           ? dispatch(useInput((run) => body({ ...marks, input: run }, undefined)))
           : Effect.gen(function* () {
@@ -257,7 +304,10 @@ export const make = (page: PageContext, sender: Dispatch) => {
       // Record the outcome even when the caller interrupts: its input may already be in the page.
       return yield* Effect.uninterruptibleMask((restore) =>
         Effect.gen(function* () {
-          const exit = yield* Effect.exit(restore(run));
+          const exit = yield* Effect.exit(
+            restore((page.inputGate?.check(name) ?? Effect.void).pipe(Effect.andThen(action))),
+          );
+
           const dispatched = yield* Ref.get(sent);
           const point = yield* Ref.get(at);
           const { subject, to, box } = yield* Ref.get(acted);
@@ -315,10 +365,12 @@ export const make = (page: PageContext, sender: Dispatch) => {
 
           return yield* exit;
         }),
-      );
+      ).pipe(Effect.ensuring(ticket.end));
     }).pipe(span(`Page.${name}`, info.target === undefined ? {} : { target: info.target }), owned);
 
-  return perform;
+  return Object.assign(perform, {
+    idle: Effect.suspend(() => Effect.forEach(admitted, Deferred.await, { discard: true })),
+  });
 };
 
 export type Perform = ReturnType<typeof make>;

package/src/internal/input/replies.ts

@@ -3,7 +3,7 @@
  * Canceling a caller cannot cancel a protocol command already sent. The next action waits for
  * those replies, while a stopped run releases only held keys or buttons whose release was never submitted.
  */
-import { Data, Effect } from "effect";
+import { Context, Data, Effect } from "effect";
 
 import { maximumSamples } from "../../Motion.ts";
 
@@ -14,6 +14,10 @@ export class InputFailure extends Data.TaggedError("InputFailure")<{
 }> {}
 
 export interface Run {
+  /** A native call made by this operation: cancellation cannot cancel its actual reply. */
+  readonly track: <A>(reply: Promise<A>) => Promise<A>;
+  /** End ownership after the record and all this operation's native replies have settled. */
+  readonly afterIdle: (ended: () => void) => void;
   /** Reserve a complete stroke, including its releases, before sending its first event. */
   readonly reserve: (commands: number) => Effect.Effect<void, InputFailure>;
   /** Admit every sample before a motion starts its published clock; ordinary input stays bounded separately. */
@@ -30,6 +34,11 @@ export interface Run {
   readonly close: Effect.Effect<void>;
 }
 
+/** Native page calls join their operation's reply ownership, including script mutations. */
+export const Current = Context.Reference<Run | undefined>("effect-browser/internal/input/Current", {
+  defaultValue: () => undefined,
+});
+
 export const make = () => {
   const outstanding = new Set<Promise<void>>();
 
@@ -46,6 +55,42 @@ export const make = () => {
     let failure: InputFailure | undefined;
     let reserved = 0;
     let closed = false;
+    const observed = new WeakMap<Promise<unknown>, { input: boolean }>();
+    const endings = new Set<() => void>();
+
+    const track = <A>(response: Promise<A>, input = false): Promise<A> => {
+      const existing = observed.get(response);
+
+      if (existing !== undefined) {
+        existing.input ||= input;
+
+        return response;
+      }
+      const entry = { input };
+
+      observed.set(response, entry);
+
+      const reply = response
+        .then(
+          () => undefined,
+          (cause: unknown) => {
+            if (entry.input) failure ??= new InputFailure({ cause });
+          },
+        )
+        .then(() => {
+          pending.delete(reply);
+          outstanding.delete(reply);
+          if (pending.size === 0) {
+            for (const end of endings) end();
+            endings.clear();
+          }
+        });
+
+      pending.add(reply);
+      outstanding.add(reply);
+
+      return response;
+    };
 
     const requireOpen = Effect.suspend(() =>
       closed
@@ -70,21 +115,7 @@ export const make = () => {
         return;
       }
 
-      // Every rejection is observed immediately; a failure does not abandon later replies.
-      const reply = response.then(
-        () => {
-          pending.delete(reply);
-          outstanding.delete(reply);
-        },
-        (cause: unknown) => {
-          failure ??= new InputFailure({ cause });
-          pending.delete(reply);
-          outstanding.delete(reply);
-        },
-      );
-
-      pending.add(reply);
-      outstanding.add(reply);
+      void track(response, true);
     };
 
     const reserve = (commands: number, maximum: number, limit: number) =>
@@ -102,6 +133,11 @@ export const make = () => {
       });
 
     const run: Run = {
+      track,
+      afterIdle: (end) => {
+        if (pending.size === 0) end();
+        else endings.add(end);
+      },
       reserve: (commands) => reserve(commands, capacity, capacity),
       // A dense stroke cannot wait for replies midway without changing its published timing.
       // Its finite reservation also leaves room for the ordinary pool's already-owned releases.

package/src/internal/page/context.ts

@@ -20,6 +20,8 @@ import type { CaptureSource } from "../../Browser.ts";
 import { BrowserError, Closed, Failed, type Reason, Timeout } from "../../BrowserError.ts";
 import type { BrowserEvent } from "../../BrowserEvent.ts";
 import type { InputGuard, Point } from "../../Page.ts";
+import type { Gate } from "../input/gate.ts";
+import { Current } from "../input/replies.ts";
 import type * as BrowserClock from "../pictures/clock.ts";
 import * as Lane from "./lane.ts";
 import type { Openings } from "./openings.ts";
@@ -51,6 +53,8 @@ export interface MakeOptions {
   readonly untilLost: <A>(reply: Promise<A>) => Promise<A>;
   readonly settings: Settings;
   readonly clock: Clock.Clock;
+  /** Browser-wide input authority; direct internal page fixtures need not provide one. */
+  readonly inputGate?: Gate | undefined;
   /** The browser's epoch mapping: its first capture measures it, and later ones renew it. */
   readonly mapping: BrowserClock.Mapping;
   readonly publish: (event: BrowserEvent) => number;
@@ -139,6 +143,9 @@ const CurrentCost = Context.Reference<Cost | undefined>(
   },
 );
 
+/** Track the promise returned to the action, after tracing wraps it, so input counts once. */
+const track = <A>(reply: Promise<A>) => Fiber.getCurrent()?.getRef(Current)?.track(reply) ?? reply;
+
 // A message's size on the wire, give or take its envelope.
 const sizeOf = (value: unknown) =>
   value === undefined ? 0 : Buffer.byteLength(JSON.stringify(value));
@@ -217,7 +224,7 @@ export const make = (options: MakeOptions, scope: Scope.Scope) => {
     }
     const reply = options.untilLost(options.cdp.send(method, params));
 
-    if (cost === undefined) return reply;
+    if (cost === undefined) return track(reply);
 
     const settle = (bytesIn: number) => {
       const at = now();
@@ -228,24 +235,26 @@ export const make = (options: MakeOptions, scope: Scope.Scope) => {
       }
     };
 
-    return reply.then(
-      (result) => {
-        settle(sizeOf(result));
+    return track(
+      reply.then(
+        (result) => {
+          settle(sizeOf(result));
 
-        return result;
-      },
-      (cause: unknown) => {
-        settle(0);
+          return result;
+        },
+        (cause: unknown) => {
+          settle(0);
 
-        return Promise.reject(cause);
-      },
+          return Promise.reject(cause);
+        },
+      ),
     );
   };
 
   // Every protocol or Playwright call. Errors are undispatched here; `perform` marks them
   // dispatched once input has gone out.
   const native = <A>(operation: string, run: () => Promise<A>, timeoutMillis?: number) =>
-    call(operation, run, options.closedBy, timeoutMillis);
+    call(operation, () => track(run()), options.closedBy, timeoutMillis);
 
   /** Fail with `Timeout` once `duration` has passed, the action timeout unless another is given. */
   const within =
@@ -274,6 +283,7 @@ export const make = (options: MakeOptions, scope: Scope.Scope) => {
     documentAt: () => activity.documentAt,
     gone: (operation) => undispatched(operation, new Closed({ cause: options.closedBy() })),
     scope,
+    inputGate: options.inputGate,
   });
 
   // Where this page's latest move left its pointer, which is where its next plain glide starts and

package/src/internal/page/lane.ts

@@ -17,6 +17,7 @@
 import { Context, Deferred, Duration, Effect, Exit, type Fiber, type Scope } from "effect";
 
 import { BrowserError, Busy } from "../../BrowserError.ts";
+import type { Gate } from "../input/gate.ts";
 
 export type Kind = "read" | "write";
 
@@ -128,6 +129,7 @@ export const make = (options: {
   readonly gone: (operation: string) => BrowserError;
   /** The page's scope, which shared reads run in. */
   readonly scope: Scope.Scope;
+  readonly inputGate?: Gate | undefined;
 }) => {
   const { now, actionTimeout } = options;
   let state = initial;
@@ -169,23 +171,30 @@ export const make = (options: {
           const ticket: Ticket = { id: ++tickets, kind };
           const askedAt = now();
 
+          if (kind === "write" && options.inputGate !== undefined)
+            yield* options.inputGate.check(operation);
+
           if ((yield* FailFast) && !admitsNow(state, kind)) return yield* busy(operation, askedAt);
           const admitted = Deferred.makeUnsafe<void>();
 
           admissions.set(ticket.id, admitted);
           apply({ _tag: "Ask", ticket });
 
+          const waiting = Deferred.await(admitted).pipe(
+            Effect.timeoutOrElse({
+              duration: wait,
+              orElse: () =>
+                Deferred.isDoneUnsafe(admitted)
+                  ? Effect.void
+                  : Effect.fail(busy(operation, askedAt, ticket.id)),
+            }),
+          );
+
           const given = yield* Effect.exit(
             restore(
-              Deferred.await(admitted).pipe(
-                Effect.timeoutOrElse({
-                  duration: wait,
-                  orElse: () =>
-                    Deferred.isDoneUnsafe(admitted)
-                      ? Effect.void
-                      : Effect.fail(busy(operation, askedAt, ticket.id)),
-                }),
-              ),
+              kind === "write" && options.inputGate !== undefined
+                ? Effect.raceFirst(waiting, options.inputGate.refused(operation))
+                : waiting,
             ),
           );
 
@@ -293,7 +302,8 @@ export const make = (options: {
     /** A turn alone, for an action: `wait` bounds the wait for it. */
     write: (operation: string, wait: Duration.Duration) => turn("write", operation, wait),
     /** A turn beside other reads, waited for within the action timeout. */
-    read: (operation: string) => turn("read", operation, actionTimeout),
+    read: (operation: string, wait: Duration.Duration = actionTimeout) =>
+      turn("read", operation, wait),
     shared,
   };
 };