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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-browser",
-  "version": "0.3.0-beta.15",
+  "version": "0.3.0-beta.16",
   "description": "Effect browser sessions, page control, screencast and moments over Playwright and CDP.",
   "license": "MIT",
   "repository": {

package/src/Browser.ts

@@ -492,7 +492,7 @@ export const make = Effect.fn("Browser.make")(function* (
 ) {
   const clock = yield* Clock.Clock;
   const connection = yield* Identity.make;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => BrowserClock.monotonicMillis(clock);
   const { settings, eventHistory, maxPages } = yield* settingsOf(options);
   // Measured on first need: the first capture of any page measures it, and input never waits.
   const mapping = BrowserClock.mapping(now);

package/src/BrowserEvent.ts

@@ -119,8 +119,7 @@ const Button = Schema.Literals(["left", "right", "middle"]);
 
 /** An element's box in viewport CSS pixels; it may lie partly or wholly outside the viewport. */
 export const Box = Schema.Struct({
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   width: Schema.Finite,
   height: Schema.Finite,
 });
@@ -169,8 +168,8 @@ export class Action extends Schema.TaggedClass<Action>()("Action", {
   /** For an action at a point, the box of what it found there. */
   box: Schema.optional(Box),
   text: Schema.optional(Schema.String),
-  x: Schema.optional(Schema.Finite),
-  y: Schema.optional(Schema.Finite),
+  x: Schema.optional(Motion.Point.fields.x),
+  y: Schema.optional(Motion.Point.fields.y),
   ok: Schema.Boolean,
   dispatched: Schema.Boolean,
   error: Schema.optional(Schema.String),
@@ -196,16 +195,14 @@ export class TrackPerformed extends Schema.TaggedClass<TrackPerformed>()("TrackP
   page: Schema.String,
   plan: Sequence,
   dispatched: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   complete: Schema.Boolean,
 }) {}
 
 export class PointerPressed extends Schema.TaggedClass<PointerPressed>()("PointerPressed", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   button: Button,
   clickCount: Schema.Int.check(Schema.isGreaterThan(0)),
 }) {}
@@ -213,8 +210,7 @@ export class PointerPressed extends Schema.TaggedClass<PointerPressed>()("Pointe
 export class PointerReleased extends Schema.TaggedClass<PointerReleased>()("PointerReleased", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   button: Button,
   clickCount: Schema.Int.check(Schema.isGreaterThan(0)),
 }) {}
@@ -222,8 +218,7 @@ export class PointerReleased extends Schema.TaggedClass<PointerReleased>()("Poin
 export class WheelScrolled extends Schema.TaggedClass<WheelScrolled>()("WheelScrolled", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   dx: Schema.Finite,
   dy: Schema.Finite,
 }) {}

package/src/Motion.ts

@@ -13,8 +13,7 @@ export const Point = Schema.Struct({ x: Schema.Finite, y: Schema.Finite });
 export type Point = typeof Point.Type;
 
 export const Sample = Schema.Struct({
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Point.fields,
   afterMillis: Schema.Finite.check(
     Schema.isGreaterThanOrEqualTo(0),
     Schema.isLessThanOrEqualTo(maximumDurationMillis),

package/src/Page.ts

@@ -27,12 +27,10 @@ import * as Guard from "./internal/input/guard.inpage.ts";
 import { Correlation, FailFast } from "./internal/page/lane.ts";
 import * as Url from "./internal/page/url.ts";
 import type { Window } from "./Moment.ts";
+import * as Motion from "./Motion.ts";
 import { type Snapshot, type SnapshotOptions } from "./Snapshot.ts";
 
-export interface Point {
-  readonly x: number;
-  readonly y: number;
-}
+export type Point = Motion.Point;
 
 /** A ref from a snapshot, such as `"e12"`, or a viewport point. */
 export type Target = string | Point;
@@ -54,7 +52,7 @@ 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: Schema.Struct({ x: Schema.Finite, y: Schema.Finite }),
+  point: Motion.Point,
   element: Schema.String,
   /** The element's lowercase tag name. */
   tag: Schema.String,
@@ -131,9 +129,7 @@ export interface ScreenshotOptions {
   /** The oldest a reused frame may be, as for `frame`. Defaults to 250 milliseconds. */
   readonly maxAge?: Duration.Input | undefined;
   /** A region of the viewport, captured in CSS pixels at the viewport's own scale; always new. */
-  readonly clip?:
-    | { readonly x: number; readonly y: number; readonly width: number; readonly height: number }
-    | undefined;
+  readonly clip?: Box | undefined;
   /** JPEG quality, 0 to 100. Defaults to 80. */
   readonly quality?: number | undefined;
   /** `"jpeg"`, the default, or `"png"`, which is always a new picture. */
@@ -335,7 +331,7 @@ export class InputRequest extends Schema.Class<InputRequest>("effect-browser/Inp
   target: Schema.optional(Schema.String),
   element: Schema.optional(Schema.String),
   /** Literal pixel targets only; ref coordinates are resolved after the policy allows them. */
-  point: Schema.optional(Schema.Struct({ x: Schema.Finite, y: Schema.Finite })),
+  point: Schema.optional(Motion.Point),
   text: Schema.optional(Schema.String),
   role: Schema.optional(Schema.NullOr(Schema.String)),
   name: Schema.optional(Schema.String),

package/src/Plan.ts

@@ -33,6 +33,7 @@ import {
 } from "./BrowserEvent.ts";
 import { undispatched } from "./internal/page/context.ts";
 import { Ambiguous, choose, Drifted, Missing } from "./internal/reading/choose.ts";
+import { Point as ViewportPoint } from "./Motion.ts";
 import {
   type Found,
   type Page,
@@ -44,8 +45,6 @@ import {
 
 export { Ambiguous, Drifted, Missing } from "./internal/reading/choose.ts";
 
-const ViewportPoint = Schema.Struct({ x: Schema.Finite, y: Schema.Finite });
-
 export const StepAction = Schema.Literals([
   "navigate",
   "back",

package/src/Presentation.ts

@@ -20,6 +20,7 @@ import { Clock, Duration, Effect, Fiber, MutableRef, Option, Semaphore } from "e
 import type { BrowserError } from "./BrowserError.ts";
 import * as Style from "./internal/input/style.ts";
 import { type Internals, internalsOf, viewOf } from "./internal/page/page.ts";
+import { monotonicMillis } from "./internal/pictures/clock.ts";
 import * as Motion from "./Motion.ts";
 import type { Page, Point, Target } from "./Page.ts";
 
@@ -81,7 +82,7 @@ export const make = Effect.fn("Presentation.make")(function* (options: Options =
   const pacing = options.pacing ?? human;
   const clock = yield* Clock.Clock;
   const scope = yield* Effect.scope;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => monotonicMillis(clock);
   const pointer = MutableRef.make(Option.none<Point>());
   const hand = yield* Semaphore.make(1);
 

package/src/Stage.ts

@@ -26,6 +26,7 @@ import { type BrowserError, Closed, consequence, InvalidRequest, Timeout } from
 import type { CaptureStats, Frame, ScreencastOptions } from "./Frame.ts";
 import { failWith, 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";
 
 export interface Options extends ScreencastOptions {
@@ -390,7 +391,7 @@ export const make = Effect.fn("Stage.make")(function* (
 ): Effect.fn.Return<Stage, BrowserError, Scope.Scope> {
   const clock = yield* Clock.Clock;
   const owner = yield* Effect.scope;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => monotonicMillis(clock);
   const waited = Duration.fromInput(options.firstFrame ?? Duration.seconds(5));
 
   if (

package/src/Supervisor.ts

@@ -107,7 +107,8 @@ export interface Admission {
 /**
  * Optional service supplied during `open`. Providers report failed-attempt cleanup here before
  * their scope closes; successful generations instead return `Opened.release`. Reporting does
- * not release resources or replace the original acquisition failure.
+ * not release resources or replace the original acquisition failure. Terminal `Down` and opening
+ * `Closed` states publish the reported outcomes of their own generation's tries.
  */
 export class Releasing extends Context.Service<
   Releasing,
@@ -556,7 +557,7 @@ const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
         return yield* options.open.pipe(
           Effect.provideService(Releasing, {
             released: (released) =>
-              apply({ _tag: "AttemptReleased", released }).pipe(Effect.asVoid),
+              apply({ _tag: "AttemptReleased", number, released }).pipe(Effect.asVoid),
           }),
         );
       }),

package/src/internal/input/actions.ts

@@ -32,12 +32,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,
@@ -110,16 +109,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,7 +134,6 @@ const click = (input: Parts) => {
                     ),
                 ),
               );
-            }
             yield* sendMouse("click", marks.input, {
               type: "mousePressed",
               ...point,
@@ -236,13 +237,12 @@ 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* Guard.check(approval, {
+            presses: [
+              { index: 0, ...start.point },
+              { index: 1, ...end.point },
+            ],
+          });
           yield* marks.sent;
           yield* sendMouse("drag", marks.input, {
             type: "mousePressed",
@@ -267,7 +267,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) =>
@@ -301,11 +301,9 @@ const typeText = (input: Parts) => {
           // 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,8 +325,7 @@ 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, {
@@ -354,7 +351,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 +359,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 +390,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 +441,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 +450,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) {

package/src/internal/input/dispatch.ts

@@ -12,20 +12,19 @@ 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;
-};
+}
 
 export const make = (page: PageContext) => {
   const { id, pointer, publish, now, noteInput, closedBy } = page;

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

@@ -10,22 +10,16 @@ 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 {

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

@@ -7,28 +7,10 @@ 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;
-}
+export type FormField = typeof FormFieldSchema.Encoded;
 
 /** 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

@@ -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,
@@ -178,7 +185,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/targets.inpage.ts

@@ -6,6 +6,7 @@
 import { Schema } from "effect";
 
 import { Box, SubjectContext } from "../../BrowserEvent.ts";
+import { Point } from "../../Motion.ts";
 import type { ContextReader } from "../reading/context.inpage.ts";
 import type { Names } from "../reading/names.inpage.ts";
 import type { Walk } from "../reading/walk.inpage.ts";
@@ -78,10 +79,7 @@ export const targets = (names: Names, walked: Walk, placing: ContextReader) => {
     };
   };
 
-  const point = (
-    target: string | { readonly x: number; readonly y: number },
-    scroll = true,
-  ): PointResult => {
+  const point = (target: string | Point, scroll = true): PointResult => {
     if (typeof target !== "string") {
       const { x, y } = target;
 
@@ -263,8 +261,7 @@ export const targets = (names: Names, walked: Walk, placing: ContextReader) => {
 export type Targets = ReturnType<typeof targets>;
 
 const ResolvedPointSchema = Schema.Struct({
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Point.fields,
   element: Schema.String,
   tag: Schema.String,
   role: Schema.NullOr(Schema.String),
@@ -285,8 +282,7 @@ export const PointResultSchema = Schema.Union([
 
 export const ScrollPlanSchema = Schema.NullOr(
   Schema.Struct({
-    x: Schema.Finite,
-    y: Schema.Finite,
+    ...Point.fields,
     dx: Schema.Finite,
     dy: Schema.Finite,
   }),

package/src/internal/input/targets.ts

@@ -7,11 +7,11 @@ import { Effect } from "effect";
 
 import { InvalidRequest, NotActionable, StaleRef } from "../../BrowserError.ts";
 import { ResolvedTarget, type Target } from "../../Page.ts";
-import { type Bridge, scriptCall } from "../page/bridge.ts";
+import { scriptCall } from "../page/bridge.ts";
 import { decodeWith, failWith } from "../page/context.ts";
 import type { Viewport } from "../page/viewport.ts";
 import type { Dispatch } from "./dispatch.ts";
-import type { Approval, Guard } from "./guard.ts";
+import { type Approval, check, type Guard } from "./guard.ts";
 import type { InputMarks } from "./perform.ts";
 import type { Pointer } from "./pointer.ts";
 import type { Settle } from "./settle.ts";
@@ -45,15 +45,13 @@ const resolvedTarget = (result: Script.ResolvedPoint): ResolvedTarget =>
   });
 
 export const make = (
-  bridge: Bridge,
   viewport: Viewport,
   guard: Guard,
   pointer: Pointer,
   dispatch: Dispatch,
   settling: Settle,
 ) => {
-  const { evaluate } = bridge;
-  const { mutate } = guard;
+  const { evaluate, mutate } = guard;
   const { moveTo, wheel } = pointer;
   const { flush } = dispatch;
 
@@ -63,10 +61,9 @@ export const make = (
     approval: Approval | undefined,
     scroll: boolean,
   ) =>
-    (approval === undefined
-      ? evaluate(operation, scriptCall("point", target, scroll))
-      : mutate(operation, scriptCall("point", target, scroll), approval)
-    ).pipe(Effect.flatMap(decodeWith(operation, Script.PointResultSchema)));
+    evaluate(operation, scriptCall("point", target, scroll), approval).pipe(
+      Effect.flatMap(decodeWith(operation, Script.PointResultSchema)),
+    );
 
   const resolve = (operation: string, target: Target, approval?: Approval, scroll = true) => {
     if (typeof target === "string" && !/^e\d+$/.test(target))
@@ -127,7 +124,7 @@ export const make = (
       );
       yield* flush(operation, marks.input);
       yield* settling.settle(operation, before);
-      if (approval !== undefined) yield* approval.check();
+      yield* check(approval);
     }
 
     // Wheels may be prevented or the target may need unsupported nested/frame geometry. One
@@ -137,7 +134,7 @@ export const make = (
 
     yield* resolve(operation, target, approval);
     yield* settling.settle(operation, before);
-    if (approval !== undefined) yield* approval.check();
+    yield* check(approval);
 
     return yield* resolve(operation, target, approval, false);
   });

package/src/internal/page/context.ts

@@ -22,7 +22,7 @@ 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 BrowserClock from "../pictures/clock.ts";
 import * as Lane from "./lane.ts";
 import type { Openings } from "./openings.ts";
 import * as Url from "./url.ts";
@@ -168,7 +168,7 @@ export const decodeWith =
 
 export const make = (options: MakeOptions, scope: Scope.Scope) => {
   const { id, clock } = options;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => BrowserClock.monotonicMillis(clock);
   // Deadlines and pacing guard the page's lane, so page operations run on the owner's clock; a
   // caller's clock, such as a TestClock, cannot stall or stretch them.
   const owned = Effect.provideService(Clock.Clock, clock);