effect-browser 0.3.0-beta.15 → 0.3.0-beta.19

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);
@@ -32,12 +31,11 @@ const partsOf = (page: PageContext, bridge: Bridge, viewport: Viewport) => {
 
   return {
     page,
-    bridge,
     ...settling,
     viewportFor: viewport.viewportFor,
     perform: Perform.make(page, dispatch),
     ...guard,
-    ...Targets.make(bridge, viewport, guard, pointer, dispatch, settling),
+    ...Targets.make(viewport, guard, pointer, dispatch, settling),
     ...pointer,
     ...Keyboard.make(page, bridge, dispatch),
     sendMouse: dispatch.sendMouse,
@@ -53,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);
 };
@@ -93,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* () {
@@ -110,16 +102,19 @@ const click = (input: Parts) => {
           yield* marks.at(point);
           yield* marks.on(resolved);
           yield* moveTo("click", marks, point, resolved.cursor);
-          if (approval !== undefined) yield* approval.check({ presses: [{ index: 0, ...point }] });
+          yield* Guard.check(approval, { presses: [{ index: 0, ...point }] });
           const before = mark();
 
           yield* marks.sent;
           for (let index = 1; index <= count; index++) {
             // An earlier click of a multi-click can replace the approved control under the
             // pointer. Under a guard, its handlers run before the next press is checked and sent.
-            if (approval !== undefined && index > 1) {
-              yield* flush("click", marks.input);
-              yield* approval.check({ presses: [{ index: 0, ...point }] }).pipe(
+            if (index > 1)
+              yield* Guard.check(
+                approval,
+                { presses: [{ index: 0, ...point }] },
+                flush("click", marks.input),
+              ).pipe(
                 Effect.catchIf(
                   (error) => error.reason._tag === "StaleRef",
                   () =>
@@ -132,27 +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);
@@ -172,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);
@@ -236,29 +218,16 @@ const drag = (input: Parts) => {
           yield* moveTo("drag", marks, start.point, start.cursor);
           // Both ends are checked before the button goes down: once it is down, a release cannot
           // be withheld, and a dragged element under the pointer would hide the drop target.
-          if (approval !== undefined)
-            yield* approval.check({
-              presses: [
-                { index: 0, ...start.point },
-                { index: 1, ...end.point },
-              ],
-            });
-          yield* marks.sent;
-          yield* sendMouse("drag", marks.input, {
-            type: "mousePressed",
-            ...start.point,
-            button: "left",
-            buttons: 1,
-            clickCount: 1,
+          yield* Guard.check(approval, {
+            presses: [
+              { index: 0, ...start.point },
+              { index: 1, ...end.point },
+            ],
           });
+          yield* marks.sent;
+          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,
@@ -267,7 +236,7 @@ const drag = (input: Parts) => {
 
 const typeText = (input: Parts) => {
   const { settings, now } = input.page;
-  const { perform, preparePolicy, mutate, targetFor, moveTo, sendMouse, flush, bridge } = input;
+  const { perform, preparePolicy, mutate, targetFor, moveTo, sendMouse, flush, evaluate } = input;
   const { currentDocument, sameDocument, keyStroke, typeEvent, mark, settle } = input;
 
   return (text: string, typeOptions: TypeOptions = {}, style: Style = plain) =>
@@ -292,20 +261,15 @@ 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.
           const asked = scriptCall("typeable", into ?? null, typeOptions.secret === true);
 
-          const typeable = yield* (
-            approval === undefined
-              ? bridge.evaluate("type", asked)
-              : mutate("type", asked, approval)
-          ).pipe(Effect.flatMap(decodeWith("type", Script.TypeableResultSchema)));
+          const typeable = yield* evaluate("type", asked, approval).pipe(
+            Effect.flatMap(decodeWith("type", Script.TypeableResultSchema)),
+          );
 
           if ("error" in typeable)
             return yield* failWith(
@@ -327,26 +291,27 @@ const typeText = (input: Parts) => {
             // Viewers see the pointer click into the field.
             if (marks.style.shown) {
               yield* moveTo("type", marks, target.point, target.cursor);
-              if (approval !== undefined)
-                yield* approval.check({ presses: [{ index: 0, ...target.point }] });
+              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)));
 
@@ -354,7 +319,7 @@ const typeText = (input: Parts) => {
             secret ||= focused.secret;
           }
           if (!secret) yield* marks.reveal;
-          if (approval !== undefined) yield* approval.check({ focused: true });
+          yield* Guard.check(approval, { focused: true });
           yield* marks.sent;
 
           // A key's handlers can move focus, and later keys then reach a control nobody approved.
@@ -362,10 +327,7 @@ const typeText = (input: Parts) => {
           // handler can split, and keys typed one at a time check that the field still has focus,
           // once the keys before are answered, before each space, which could press a button, and
           // after the last key.
-          const focusHeld =
-            approval === undefined
-              ? Effect.void
-              : flush("type", marks.input).pipe(Effect.andThen(approval.check({ focused: true })));
+          const focusHeld = Guard.check(approval, { focused: true }, flush("type", marks.input));
 
           if (text === "" && replace && into !== undefined) {
             yield* sameDocument("type", since);
@@ -396,7 +358,7 @@ const typeText = (input: Parts) => {
           yield* flush("type", marks.input);
           if (typeOptions.submit === true) {
             // Typing can move focus or change the form; Enter goes only to the approved field.
-            if (approval !== undefined) yield* approval.check({ focused: true });
+            yield* Guard.check(approval, { focused: true });
             yield* sameDocument("type", since);
             const before = mark();
 
@@ -447,7 +409,7 @@ const press = (input: Parts) => {
             );
 
             if ("error" in focused) return yield* Guard.editFailure("press", on, focused);
-            if (approval !== undefined) yield* approval.check({ focused: true });
+            yield* Guard.check(approval, { focused: true });
           }
           const before = mark();
           let due = now();
@@ -456,10 +418,8 @@ const press = (input: Parts) => {
           for (let index = 0; index < times; index++) {
             // A repeated key stays in the document it began in. Under a guard, a repeated Enter
             // or Space must also reach the approved element after the previous press settled.
-            if (index > 0 && approval !== undefined && activates) {
-              yield* flush("press", marks.input);
-              yield* approval.check({ focused: true });
-            }
+            if (index > 0 && activates)
+              yield* Guard.check(approval, { focused: true }, flush("press", marks.input));
             yield* sameDocument("press", since);
             yield* keyStroke("press", marks.input, parts, hold);
             if (index + 1 < times) {
@@ -488,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",
@@ -500,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

@@ -12,20 +12,35 @@ import {
   TextInserted,
   WheelScrolled,
 } from "../../BrowserEvent.ts";
+import type { Point } from "../../Motion.ts";
 import { type PageContext, reasonOf, undispatched } from "../page/context.ts";
 import * as BrowserClock from "../pictures/clock.ts";
 import type * as Replies from "./replies.ts";
 
-export type MouseEvent = {
+export interface MouseEvent extends Point {
   readonly type: "mouseMoved" | "mousePressed" | "mouseReleased" | "mouseWheel";
-  readonly x: number;
-  readonly y: number;
   readonly button?: "none" | "left" | "right" | "middle";
   readonly buttons?: number;
   readonly clickCount?: number;
   readonly deltaX?: number;
   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;
@@ -99,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

@@ -10,28 +10,23 @@ import type { ContextReader } from "../reading/context.inpage.ts";
 import type { Names } from "../reading/names.inpage.ts";
 import type { Guard } from "./guard.inpage.ts";
 
-export type EditResult =
-  | { readonly ok: true; readonly detail: string }
-  | { readonly error: string; readonly stale?: boolean };
+export type EditResult = typeof EditResultSchema.Encoded;
 
 /** A focused field, and whether it is secret. */
-export type FocusResult =
-  | { readonly ok: true; readonly detail: string; readonly secret: boolean }
-  | { readonly error: string; readonly stale?: boolean };
+export type FocusResult = typeof FocusResultSchema.Encoded;
 
 /**
  * Whether text may be typed, and whether its field is secret. Typing into focus also names the
  * focused field, when it is one, so the action records what it typed into.
  */
-export type TypeableResult =
-  | { readonly ok: true; readonly secret: boolean; readonly subject?: typeof Subject.Encoded }
-  | { readonly error: "stale" | "untypeable"; readonly detail: string };
+export type TypeableResult = typeof TypeableResultSchema.Encoded;
 
 export const edit = (names: Names, guard: Guard, placing: ContextReader) => {
   const {
     activeElement,
     clean,
     describe,
+    inCurrentDocument,
     isDisabled,
     isHtml,
     isInput,
@@ -78,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,28 +7,8 @@ import { Schema } from "effect";
 import type { ContextReader } from "../reading/context.inpage.ts";
 import type { Names } from "../reading/names.inpage.ts";
 
-export interface FormField {
-  readonly type: string;
-  readonly name: string;
-  readonly autocomplete?: string | undefined;
-  readonly filled: boolean;
-}
-
 /** Page text about the first target. It never includes what a field holds. */
-export interface Evidence {
-  readonly title: string;
-  readonly description?: string | undefined;
-  readonly dialog?: string | undefined;
-  readonly heading?: string | undefined;
-  readonly nearby?: string | undefined;
-  readonly form?:
-    | {
-        readonly method: string;
-        readonly action: string;
-        readonly fields: ReadonlyArray<FormField>;
-      }
-    | undefined;
-}
+export type Evidence = typeof EvidenceSchema.Encoded;
 
 type Field = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
 

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

@@ -5,6 +5,7 @@
  */
 import { Schema } from "effect";
 
+import type { Point } from "../../Motion.ts";
 import type { Names } from "../reading/names.inpage.ts";
 import { type Evidence, type EvidenceReader, EvidenceSchema } from "./evidence.inpage.ts";
 import type { Targets } from "./targets.inpage.ts";
@@ -23,48 +24,26 @@ export type Fact = typeof Fact.Type;
 
 export interface InputPlan {
   readonly action: string;
-  readonly targets: ReadonlyArray<string | { readonly x: number; readonly y: number } | null>;
+  readonly targets: ReadonlyArray<string | Point | null>;
   readonly submit: boolean;
   readonly keys: string | null;
   readonly destination: string | null;
 }
 
-export interface InspectedTarget {
-  readonly ref: string;
-  readonly element: string;
-  readonly role: string | null;
-  readonly name: string;
-  readonly cursor: string;
-  readonly href?: string | undefined;
-  /** A field the DOM marks as holding a password, a one-time code or a card's details. */
-  readonly secret: boolean;
-  readonly fingerprint: string;
-}
+export type InspectedTarget = NonNullable<PreparedInput["targets"][number]>;
 
-export interface PreparedInput {
-  readonly url: string;
-  readonly targets: ReadonlyArray<InspectedTarget | null>;
-  readonly facts: ReadonlyArray<Fact>;
-  readonly destination?: string | undefined;
-  readonly evidence: Evidence;
-}
+export type PreparedInput = Exclude<PreparedInputResult, InputFailure>;
 
 /** A refusal; a stale target is named by its index in the plan. */
-export interface InputFailure {
-  readonly error: string;
-  readonly detail: string;
-  readonly index?: number | undefined;
-}
+export type InputFailure = typeof InputPreparationError.Encoded;
 
-export type PreparedInputResult = PreparedInput | InputFailure;
+export type PreparedInputResult = typeof PreparedInputResultSchema.Encoded;
 
-export type ValidatedInputResult = { readonly ok: true } | InputFailure;
+export type ValidatedInputResult = typeof ValidatedInputResultSchema.Encoded;
 
 /** A point where a target, by its index in the plan, is about to receive a press. */
-export interface Press {
+export interface Press extends Point {
   readonly index: number;
-  readonly x: number;
-  readonly y: number;
 }
 
 export interface ValidationOptions {
@@ -587,6 +566,7 @@ export const PreparedInputResultSchema = Schema.Union([
           name: Schema.String,
           cursor: Schema.String,
           href: Schema.optional(Schema.String),
+          /** A field the DOM marks as holding a password, a one-time code or a card's details. */
           secret: Schema.Boolean,
           fingerprint: Schema.String,
         }),

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";
 
@@ -22,6 +22,13 @@ export interface PolicyPlan {
   readonly validate: Effect.Effect<Approval, BrowserError>;
 }
 
+/** Recheck an approval, after any pending input it must see; neither runs without a guard. */
+export const check = (
+  approval: Approval | undefined,
+  options: Script.ValidationOptions = {},
+  before: Effect.Effect<void, BrowserError> = Effect.void,
+) => (approval === undefined ? Effect.void : before.pipe(Effect.andThen(approval.check(options))));
+
 // A ref that names nothing is stale on every path, named by the target that failed.
 export const inputFailure = (
   operation: string,
@@ -67,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 = {
@@ -178,7 +179,11 @@ export const make = (page: PageContext, bridge: Bridge) => {
       ),
     );
 
-  return { preparePolicy, mutate };
+  /** A read may follow the current document only when no approval binds it to one. */
+  const evaluate = (operation: string, call: string, approval: Approval | undefined) =>
+    approval === undefined ? bridge.evaluate(operation, call) : mutate(operation, call, approval);
+
+  return { preparePolicy, mutate, evaluate };
 };
 
 export type Guard = ReturnType<typeof make>;

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.