effect-browser 0.3.0-beta.16 → 0.3.0-beta.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-browser",
-  "version": "0.3.0-beta.16",
+  "version": "0.3.0-beta.20",
   "description": "Effect browser sessions, page control, screencast and moments over Playwright and CDP.",
   "license": "MIT",
   "repository": {
@@ -115,9 +115,9 @@
     "test": "vp test --run"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0",
+    "@effect/vitest": "4.0.3",
     "@types/node": "26.1.2",
-    "effect": "4.0.0",
+    "effect": "4.0.3",
     "playwright-core": "1.63.0",
     "typescript": "7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
@@ -125,7 +125,7 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "effect": "~4.0.0",
+    "effect": "~4.0.3",
     "playwright-core": "^1.63.0"
   },
   "engines": {

package/src/Moment.ts

@@ -27,11 +27,11 @@
 import { Duration, Effect, Option, Result, Schema } from "effect";
 import { Prompt } from "effect/ai";
 
-import { BrowserError, InvalidRequest } from "./BrowserError.ts";
+import { BrowserError } from "./BrowserError.ts";
 import { type Action, BrowserEvent } from "./BrowserEvent.ts";
 import { type Change, Changes } from "./Change.ts";
 import { Frame } from "./Frame.ts";
-import { undispatched } from "./internal/page/context.ts";
+import { refuse } from "./internal/page/context.ts";
 import { describe, named, quoted, where } from "./internal/timeline/words.ts";
 import type * as Page from "./Page.ts";
 import { Snapshot, type SnapshotOptions } from "./Snapshot.ts";
@@ -116,10 +116,7 @@ export const capture = Effect.fn("Moment.capture")(function* (
   const count = options.frames ?? 2;
 
   if (!Number.isSafeInteger(count) || count < 1)
-    return yield* undispatched(
-      "moment",
-      new InvalidRequest({ detail: "frames must be a positive safe integer" }),
-    );
+    return yield* refuse("moment", "frames must be a positive safe integer");
   const outline = options.snapshot ?? false;
 
   // The picture comes first, at no call with a running screencast, and the window ends at its

package/src/Page.ts

@@ -19,7 +19,7 @@ import { type Duration, Effect, Schema, type Stream } from "effect";
 import type { Page as PlaywrightPage } from "playwright-core";
 
 import { type BrowserError, type PolicyDenied } from "./BrowserError.ts";
-import { Box, type BrowserEvent, PageLoaded, Subject, SubjectContext } from "./BrowserEvent.ts";
+import { Box, type BrowserEvent, PageLoaded, Subject } from "./BrowserEvent.ts";
 import type { Changes } from "./Change.ts";
 import { type CaptureStats, Frame, Image, type ScreencastOptions } from "./Frame.ts";
 import { FormFieldSchema } from "./internal/input/evidence.inpage.ts";
@@ -53,12 +53,8 @@ export class Zoom extends Schema.Class<Zoom>("effect-browser/Zoom")({
 /** The target as it read before input. Point coordinates are never snapped to another position. */
 export class ResolvedTarget extends Schema.Class<ResolvedTarget>("effect-browser/ResolvedTarget")({
   point: Motion.Point,
+  ...Subject.fields,
   element: Schema.String,
-  /** The element's lowercase tag name. */
-  tag: Schema.String,
-  role: Schema.NullOr(Schema.String),
-  name: Schema.String,
-  context: SubjectContext,
   /** For a point target, the box of what it found there. */
   box: Schema.optional(Box),
   cursor: Schema.String,
@@ -222,8 +218,11 @@ export interface WaitCondition {
 }
 
 export interface ReadyOptions {
-  /** What must stay still during quietMillis: screen paint (default), or recorded content. */
-  readonly still?: "screen" | "content" | undefined;
+  /**
+   * What must stay still during quietMillis: screen paint (default); recorded content; or the
+   * `"foreground"`, the screen but for what was already moving before the page's latest input.
+   */
+  readonly still?: "screen" | "content" | "foreground" | undefined;
   /** How long the selected evidence must stay still; screen paint by default. */
   readonly quietMillis?: number | undefined;
   readonly timeout?: Duration.Input | undefined;
@@ -493,9 +492,12 @@ export interface Page {
    * view have loaded, and the viewport shows something. With `quietMillis`, the screen must then
    * also stay still that long: nothing in view changed, where the page's changes are recorded, and
    * no frame comes, counted from the first frame of a capture the wait starts itself. A canvas
-   * that keeps drawing, such as a live chart, is never still, and a page
-   * is never ready without a painted frame, as a hidden tab may be. `Timeout` after `timeout`,
-   * 15 seconds by default.
+   * that keeps drawing, such as a live chart, is never still. With `still: "foreground"`, frames
+   * may keep coming, but nothing may move in them outside what moved in the frames of the 1.5 s
+   * before the page's latest input, such as an idle animation; reels set spinning, or a counter
+   * set rolling, by the input keep the wait going. Without those frames, as where they are older
+   * than the browser's `frameHistory`, nothing may move at all. A page is never ready without a
+   * painted frame, as a hidden tab may be. `Timeout` after `timeout`, 15 seconds by default.
    */
   readonly ready: (options?: ReadyOptions) => Effect.Effect<void, BrowserError>;
 

package/src/Stage.ts

@@ -24,7 +24,7 @@ import {
 
 import { type BrowserError, Closed, consequence, InvalidRequest, Timeout } from "./BrowserError.ts";
 import type { CaptureStats, Frame, ScreencastOptions } from "./Frame.ts";
-import { failWith, undispatched } from "./internal/page/context.ts";
+import { failWith, refuse, undispatched } from "./internal/page/context.ts";
 import { internalsOf } from "./internal/page/page.ts";
 import { monotonicMillis } from "./internal/pictures/clock.ts";
 import type { Page } from "./Page.ts";
@@ -240,16 +240,14 @@ const evidence = (
 
       const probe = Effect.gen(function* () {
         yield* until(Math.max(checkedAt, current()?.changedAt ?? checkedAt) + millis, now);
-        checkedAt = now();
         const before = current();
         const frame = before?.frame;
 
-        if (
-          before === undefined ||
-          frame === undefined ||
-          gone === before.feed ||
-          checkedAt - before.changedAt < millis
-        )
+        // Paint during the wait moves the deadline; an early wake is not a silence check.
+        if (before !== undefined && now() - before.changedAt < millis)
+          return Option.none<Evidence>();
+        checkedAt = now();
+        if (before === undefined || frame === undefined || gone === before.feed)
           return Option.none<Evidence>();
         const { feed } = before;
 
@@ -399,10 +397,7 @@ export const make = Effect.fn("Stage.make")(function* (
     !Duration.isFinite(waited.value) ||
     !Duration.isPositive(waited.value)
   )
-    return yield* failWith(
-      "stage",
-      new InvalidRequest({ detail: "firstFrame must be a finite positive duration" }),
-    );
+    return yield* refuse("stage", "firstFrame must be a finite positive duration");
   const firstFrame = waited.value;
   const settings = { quality: options.quality, size: options.size };
   const output = yield* PubSub.sliding<Paint>(16);
@@ -434,10 +429,7 @@ export const make = Effect.fn("Stage.make")(function* (
       return switching(
         Effect.gen(function* () {
           if (!Number.isFinite(asked))
-            return yield* failWith(
-              "cue",
-              new InvalidRequest({ detail: "at must be finite host milliseconds" }),
-            );
+            return yield* refuse("cue", "at must be finite host milliseconds");
           yield* firstOf(feed, firstFrame);
           const old = showing;
 

package/src/Supervisor.ts

@@ -598,21 +598,20 @@ const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
 
   const retire = yield* Effect.cached(stop({ _tag: "Retire" }));
 
+  // The browser of the generation serving, or of the one `target` names once it serves.
+  const browserOf = (target?: number) =>
+    Effect.map(waitFor(state, waitTimeout, clock, target), (live) => live.value.opened.browser);
+
   yield* Effect.addFinalizer(() => (options.keep === true ? stop({ _tag: "Keep" }) : retire));
   yield* perform(started);
 
   return {
-    browser: Effect.map(waitFor(state, waitTimeout, clock), (live) => live.value.opened.browser),
+    browser: browserOf(),
     use: leasing(state, apply, waitTimeout, now, clock),
     states: Stream.fromPubSubTake(events),
     rotate: apply({ _tag: "Rotate" }).pipe(
       Effect.flatMap(({ reply }) =>
-        reply === undefined
-          ? Effect.fail(retired())
-          : Effect.map(
-              waitFor(state, waitTimeout, clock, reply),
-              (live) => live.value.opened.browser,
-            ),
+        reply === undefined ? Effect.fail(retired()) : browserOf(reply),
       ),
     ),
     retire,

package/src/internal/input/actions.ts

@@ -6,12 +6,13 @@
  */
 import { Duration, Effect } from "effect";
 
-import { InvalidRequest, NotActionable, StaleRef } from "../../BrowserError.ts";
+import { NotActionable, StaleRef } from "../../BrowserError.ts";
 import type { ClickOptions, PressOptions, ScrollOptions, Target, TypeOptions } from "../../Page.ts";
 import { type Bridge, scriptCall } from "../page/bridge.ts";
-import { decodeWith, failWith, type PageContext } from "../page/context.ts";
+import { decodeWith, failWith, type PageContext, refuse } from "../page/context.ts";
 import type { Viewport } from "../page/viewport.ts";
 import * as Dispatch from "./dispatch.ts";
+import { buttonAt } from "./dispatch.ts";
 import * as Script from "./edit.inpage.ts";
 import * as Guard from "./guard.ts";
 import * as Keyboard from "./keyboard.ts";
@@ -22,8 +23,6 @@ import * as Settle from "./settle.ts";
 import { plain, type Style } from "./style.ts";
 import * as Targets from "./targets.ts";
 
-const buttonMask = { none: 0, left: 1, right: 2, middle: 4 } as const;
-
 const partsOf = (page: PageContext, bridge: Bridge, viewport: Viewport) => {
   const dispatch = Dispatch.make(page);
   const pointer = Pointer.make(page, dispatch, viewport);
@@ -52,25 +51,23 @@ const finite = (...values: ReadonlyArray<number | undefined>) =>
 
 const named = (target: Target) => (typeof target === "string" ? target : `${target.x},${target.y}`);
 
+/** The ref a target names, if it names one rather than a point. */
+const refOf = (target: Target | undefined) => (typeof target === "string" ? target : undefined);
+
 /** A click's options, once its counts are finite. */
 const clickable = (options: ClickOptions) =>
   finite(options.clickCount, options.holdMillis)
     ? Effect.void
-    : failWith("click", new InvalidRequest({ detail: "clickCount and holdMillis must be finite" }));
+    : refuse("click", "clickCount and holdMillis must be finite");
 
 /** The keys a press sends, once they and its options are valid. */
 const pressed = (keys: string, options: PressOptions) => {
   const parts = Keys.parts(keys);
 
   if (!finite(options.times, options.holdMillis))
-    return failWith("press", new InvalidRequest({ detail: "times and holdMillis must be finite" }));
+    return refuse("press", "times and holdMillis must be finite");
   if (parts === undefined)
-    return failWith(
-      "press",
-      new InvalidRequest({
-        detail: `"${keys}" is not a key; try Enter, Space, ArrowLeft or Control+A`,
-      }),
-    );
+    return refuse("press", `"${keys}" is not a key; try Enter, Space, ArrowLeft or Control+A`);
 
   return Effect.succeed(parts);
 };
@@ -92,11 +89,7 @@ const click = (input: Parts) => {
       },
       settings.actionTimeout,
       Effect.suspend(() => clickable(clickOptions)).pipe(
-        Effect.andThen(
-          preparePolicy("click", { target: typeof target === "string" ? target : undefined }, [
-            target,
-          ]),
-        ),
+        Effect.andThen(preparePolicy("click", { target: refOf(target) }, [target])),
       ),
       (marks, approval) =>
         Effect.gen(function* () {
@@ -134,26 +127,14 @@ const click = (input: Parts) => {
                     ),
                 ),
               );
-            yield* sendMouse("click", marks.input, {
-              type: "mousePressed",
-              ...point,
-              button,
-              buttons: buttonMask[button],
-              clickCount: index,
-            });
+            yield* sendMouse("click", marks.input, buttonAt("mousePressed", point, button, index));
 
             // A hold the caller asks for is the click's own; the style's is presentation.
             const hold = clickOptions.holdMillis ?? (yield* marks.style.hold);
 
             if (clickOptions.holdMillis === undefined) yield* marks.present(hold);
             if (hold > 0) yield* Effect.sleep(Duration.millis(hold));
-            yield* sendMouse("click", marks.input, {
-              type: "mouseReleased",
-              ...point,
-              button,
-              buttons: 0,
-              clickCount: index,
-            });
+            yield* sendMouse("click", marks.input, buttonAt("mouseReleased", point, button, index));
           }
           yield* flush("click", marks.input);
           yield* settle("click", before);
@@ -173,7 +154,7 @@ const hover = (input: Parts) => {
       "hover",
       { target: named(target) },
       settings.actionTimeout,
-      preparePolicy("hover", { target: typeof target === "string" ? target : undefined }, [target]),
+      preparePolicy("hover", { target: refOf(target) }, [target]),
       (marks, approval) =>
         Effect.gen(function* () {
           const resolved = yield* targetFor("hover", target, approval, marks);
@@ -244,21 +225,9 @@ const drag = (input: Parts) => {
             ],
           });
           yield* marks.sent;
-          yield* sendMouse("drag", marks.input, {
-            type: "mousePressed",
-            ...start.point,
-            button: "left",
-            buttons: 1,
-            clickCount: 1,
-          });
+          yield* sendMouse("drag", marks.input, buttonAt("mousePressed", start.point));
           yield* moveTo("drag", marks, end.point, end.cursor, "drag");
-          yield* sendMouse("drag", marks.input, {
-            type: "mouseReleased",
-            ...end.point,
-            button: "left",
-            buttons: 0,
-            clickCount: 1,
-          });
+          yield* sendMouse("drag", marks.input, buttonAt("mouseReleased", end.point));
           yield* flush("drag", marks.input);
         }),
       style,
@@ -292,10 +261,7 @@ const typeText = (input: Parts) => {
           const into = typeOptions.into;
 
           if (into !== undefined && !/^e\d+$/.test(into))
-            return yield* failWith(
-              "type",
-              new InvalidRequest({ detail: `"${into}" is not a ref; refs look like e12` }),
-            );
+            return yield* refuse("type", `"${into}" is not a ref; refs look like e12`);
 
           // A typed space or letter can press a focused button or change a control. Refuse
           // those before any input, on every path.
@@ -328,22 +294,24 @@ const typeText = (input: Parts) => {
               yield* Guard.check(approval, { presses: [{ index: 0, ...target.point }] });
               yield* marks.sent;
               for (const type of ["mousePressed", "mouseReleased"] as const)
-                yield* sendMouse("type", marks.input, {
-                  type,
-                  ...target.point,
-                  button: "left",
-                  buttons: type === "mousePressed" ? 1 : 0,
-                  clickCount: 1,
-                });
+                yield* sendMouse("type", marks.input, buttonAt(type, target.point));
               yield* flush("type", marks.input);
             }
 
             // Focusing can run page handlers, including navigation, before the script returns.
             yield* marks.sent;
 
+            // A page may answer the press with another field of the same name in the field's
+            // place, focused, as a typeahead does: the keys follow it, unless a guard approved
+            // this field and no other, or the field is secret, as its replacement may not be.
+            const follow =
+              marks.style.shown && approval === undefined && !secret && target.name !== ""
+                ? target.name
+                : null;
+
             const focused = yield* mutate(
               "type",
-              scriptCall("focus", into, replace),
+              scriptCall("focus", into, replace, follow),
               approval,
             ).pipe(Effect.flatMap(decodeWith("type", Script.FocusResultSchema)));
 
@@ -480,7 +448,7 @@ const scroll = (input: Parts) => {
     const valid =
       Number.isFinite(scrollOptions.dx ?? 0) && Number.isFinite(scrollOptions.dy ?? 0)
         ? Effect.void
-        : failWith("scroll", new InvalidRequest({ detail: "scroll deltas must be finite" }));
+        : refuse("scroll", "scroll deltas must be finite");
 
     return perform(
       "scroll",
@@ -492,11 +460,7 @@ const scroll = (input: Parts) => {
       valid.pipe(
         Effect.andThen(
           // Scrolling the page has no target: whatever sits mid-viewport is not what is scrolled.
-          preparePolicy(
-            "scroll",
-            { target: typeof target === "string" ? target : undefined },
-            target === undefined ? [] : [target],
-          ),
+          preparePolicy("scroll", { target: refOf(target) }, target === undefined ? [] : [target]),
         ),
       ),
       (marks, approval) =>

package/src/internal/input/dispatch.ts

@@ -26,6 +26,22 @@ export interface MouseEvent extends Point {
   readonly deltaY?: number;
 }
 
+const buttonMask = { none: 0, left: 1, right: 2, middle: 4 } as const;
+
+/** A mouse button going down or up at a point, as the `clickCount`th click. */
+export const buttonAt = (
+  type: "mousePressed" | "mouseReleased",
+  point: Point,
+  button: keyof typeof buttonMask = "left",
+  clickCount = 1,
+): MouseEvent => ({
+  type,
+  ...point,
+  button,
+  buttons: type === "mousePressed" ? buttonMask[button] : 0,
+  clickCount,
+});
+
 export const make = (page: PageContext) => {
   const { id, pointer, publish, now, noteInput, closedBy } = page;
   const { send } = page.protocol;
@@ -98,13 +114,12 @@ export const make = (page: PageContext) => {
             () => dispatchMouse(event, estimate, submitted),
             () =>
               dispatchMouse(
-                {
-                  type: "mouseReleased",
-                  ...Option.getOrElse(MutableRef.get(pointer), () => ({ x: event.x, y: event.y })),
-                  button: event.button ?? "left",
-                  buttons: 0,
-                  clickCount: event.clickCount ?? 1,
-                },
+                buttonAt(
+                  "mouseReleased",
+                  Option.getOrElse(MutableRef.get(pointer), () => ({ x: event.x, y: event.y })),
+                  event.button,
+                  event.clickCount,
+                ),
                 estimate,
               ),
           );

package/src/internal/input/edit.inpage.ts

@@ -26,6 +26,7 @@ export const edit = (names: Names, guard: Guard, placing: ContextReader) => {
     activeElement,
     clean,
     describe,
+    inCurrentDocument,
     isDisabled,
     isHtml,
     isInput,
@@ -72,8 +73,28 @@ export const edit = (names: Names, guard: Guard, placing: ContextReader) => {
     };
   };
 
-  const focus = (ref: string, replace: boolean): FocusResult => {
-    const element = lookup(ref);
+  /**
+   * The focused field, when it is a text field named `name`: one a page put in place of a field
+   * just pressed and gave focus to, as a typeahead does.
+   */
+  const replacement = (name: string): Element | undefined => {
+    const active = activeElement();
+
+    return active !== null &&
+      textEntry(active) &&
+      inCurrentDocument(active) &&
+      nameOf(active, roleOf(active)) === name
+      ? active
+      : undefined;
+  };
+
+  /**
+   * Focus a field to type into. `follow` is the field's name when the action pressed it first: a
+   * page may answer the press with another field of that name in its place, focused, and the keys
+   * follow focus there, as a person's would.
+   */
+  const focus = (ref: string, replace: boolean, follow: string | null): FocusResult => {
+    const element = lookup(ref) ?? (follow === null ? undefined : replacement(follow));
 
     if (element === undefined) return { error: `${ref} is not on the page any more`, stale: true };
     if (isDisabled(element)) return { error: `${ref} is disabled` };

package/src/internal/input/evidence.inpage.ts

@@ -7,8 +7,6 @@ import { Schema } from "effect";
 import type { ContextReader } from "../reading/context.inpage.ts";
 import type { Names } from "../reading/names.inpage.ts";
 
-export type FormField = typeof FormFieldSchema.Encoded;
-
 /** Page text about the first target. It never includes what a field holds. */
 export type Evidence = typeof EvidenceSchema.Encoded;
 

package/src/internal/input/guard.ts

@@ -8,7 +8,7 @@ import { Effect } from "effect";
 import { type BrowserError, InvalidRequest, NotActionable, StaleRef } from "../../BrowserError.ts";
 import { InputRequest, redacted } from "../../Page.ts";
 import { type Bridge, scriptCall } from "../page/bridge.ts";
-import { contextGone, decodeWith, failWith, type PageContext } from "../page/context.ts";
+import { contextGone, decodeWith, failWith, type PageContext, refuse } from "../page/context.ts";
 import * as Url from "../page/url.ts";
 import * as Script from "./guard.inpage.ts";
 
@@ -74,19 +74,13 @@ export const make = (page: PageContext, bridge: Bridge) => {
     Effect.gen(function* () {
       for (const target of targets) {
         if (typeof target === "string" && !/^e\d+$/.test(target))
-          return yield* failWith(
-            action,
-            new InvalidRequest({ detail: `"${target}" is not a ref; refs look like e12` }),
-          );
+          return yield* refuse(action, `"${target}" is not a ref; refs look like e12`);
         if (
           target !== null &&
           typeof target !== "string" &&
           (!Number.isFinite(target.x) || !Number.isFinite(target.y))
         )
-          return yield* failWith(
-            action,
-            new InvalidRequest({ detail: "point coordinates must be finite" }),
-          );
+          return yield* refuse(action, "point coordinates must be finite");
       }
 
       const input: Script.InputPlan = {

package/src/internal/input/perform.ts

@@ -137,19 +137,14 @@ const useRun = <A>(
   name: string,
   run: Replies.Run,
   action: Effect.Effect<A, BrowserError>,
+  canStop: Effect.Effect<boolean>,
 ) =>
   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)),
-    }),
+    Effect.tapError(() => run.close.pipe(Effect.andThen(sender.flush(name, run)), Effect.ignore)),
+    Effect.tap(() => run.close.pipe(Effect.andThen(sender.flush(name, run)))),
     // Cleanup submits missing releases; the page retains replies after caller interruption.
     Effect.ensuring(run.close.pipe(Effect.andThen(page.openings.clear))),
+    Effect.onError(() => run.recover(page.stopLoading, page.scope).pipe(Effect.when(canStop))),
     Effect.provideService(Replies.Current, run),
   );
 
@@ -224,7 +219,16 @@ export const make = (page: PageContext, sender: Dispatch) => {
               if (estimate !== undefined) inputClocks.set(current, estimate);
             }),
           ),
-          Effect.flatMap((run) => useRun(page, sender, name, run, action(run))),
+          Effect.flatMap((run) =>
+            useRun(
+              page,
+              sender,
+              name,
+              run,
+              action(run),
+              info.input === false ? Effect.succeed(false) : Ref.get(sent),
+            ),
+          ),
         );
 
       // How long its turn and the page's replies kept the action waiting, once it had both.

package/src/internal/input/pointer.ts

@@ -5,11 +5,10 @@
  */
 import { Duration, Effect, MutableRef, Option, Schema } from "effect";
 
-import { InvalidRequest } from "../../BrowserError.ts";
 import { CursorChanged, TrackPerformed, TrackPlanned } from "../../BrowserEvent.ts";
 import * as Motion from "../../Motion.ts";
 import type { Point } from "../../Page.ts";
-import { failWith, type PageContext } from "../page/context.ts";
+import { type PageContext, refuse } from "../page/context.ts";
 import type { Viewport } from "../page/viewport.ts";
 import type { Dispatch } from "./dispatch.ts";
 import type { InputMarks } from "./perform.ts";
@@ -47,11 +46,9 @@ export const make = (page: PageContext, dispatch: Dispatch, viewport: Viewport)
 
       // A custom planner is a boundary. Decoding reads each sample once into a fresh copy and
       // checks that copy, so neither accessors nor later mutation can change what is admitted.
-      const invalid = failWith(
+      const invalid = refuse(
         operation,
-        new InvalidRequest({
-          detail: "motion must be a bounded, ordered schedule ending at the target",
-        }),
+        "motion must be a bounded, ordered schedule ending at the target",
       );
 
       const samples = yield* Schema.decodeEffect(Motion.Plan)(planned).pipe(

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 { Context, Data, Effect } from "effect";
+import { Context, Data, Effect, type Scope } from "effect";
 
 import { maximumSamples } from "../../Motion.ts";
 
@@ -18,6 +18,8 @@ export interface Run {
   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;
+  /** Retain authority through scoped cleanup after the replies already submitted. */
+  readonly recover: (cleanup: Effect.Effect<void>, scope: Scope.Scope) => Effect.Effect<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. */
@@ -105,17 +107,11 @@ export const make = () => {
     const submit = (command: () => Promise<unknown>) => {
       if (reserved < 1) throw new Error("input must reserve capacity before dispatch");
       reserved--;
-      let response: Promise<unknown>;
-
       try {
-        response = command();
+        void track(command(), true);
       } catch (cause) {
         failure ??= new InputFailure({ cause });
-
-        return;
       }
-
-      void track(response, true);
     };
 
     const reserve = (commands: number, maximum: number, limit: number) =>
@@ -138,6 +134,21 @@ export const make = () => {
         if (pending.size === 0) end();
         else endings.add(end);
       },
+      recover: (cleanup, scope) =>
+        Effect.gen(function* () {
+          const replies = [...pending];
+          const done = Promise.withResolvers<void>();
+
+          // This reservation prevents a new action or suspension from overtaking cleanup.
+          void track(done.promise);
+          yield* Effect.promise(() => Promise.all(replies)).pipe(
+            Effect.andThen(cleanup),
+            Effect.ensuring(Effect.sync(() => done.resolve())),
+            Effect.provideService(Current, run),
+            Effect.interruptible,
+            Effect.forkIn(scope),
+          );
+        }),
       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/input/settle.ts

@@ -39,12 +39,13 @@ export const make = (page: PageContext, bridge: Bridge) => {
         // evaluate after the settling deadline, without retaining browser input authority.
         Effect.provideService(Current, undefined),
         Effect.catchIf(contextGone, () => Effect.void),
-        Effect.onError(() => page.stopLoading),
       );
       while (document() > before.document && parsed < document()) yield* Deferred.await(changed);
     }).pipe(
       Effect.timeoutOrElse({ duration: settling, orElse: () => Effect.fail("unsettled") }),
-      Effect.catch(() => Effect.annotateCurrentSpan("settled", false)),
+      Effect.catch(() =>
+        page.stopLoading.pipe(Effect.andThen(Effect.annotateCurrentSpan("settled", false))),
+      ),
       Effect.andThen(page.openings.settle(before.openings)),
       page.span("Page.settle", {}, "Debug"),
     );