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

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);

package/src/internal/pictures/capture.ts

@@ -18,7 +18,7 @@ import {
 import { type BrowserError, InvalidRequest } from "../../BrowserError.ts";
 import { BrowserPaint, CaptureStats, Frame, type ScreencastOptions } from "../../Frame.ts";
 import { undispatched } from "../page/context.ts";
-import { type Estimate, toHostTime, uncertaintyAt } from "./clock.ts";
+import { type Estimate, monotonicMillis, toHostTime, uncertaintyAt } from "./clock.ts";
 import { tally } from "./counts.ts";
 import * as Quiescence from "./quiescence.ts";
 import type { NativeFrame, Transport } from "./transport.ts";
@@ -154,7 +154,7 @@ const timed = (
       hostTime,
       uncertaintyMillis: uncertaintyAt(estimate, hostTime),
     }),
-    receivedAt: Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6,
+    receivedAt: monotonicMillis(options.clock),
     width: size.width,
     height: size.height,
     ...generation.transport.frameTag(),
@@ -222,7 +222,7 @@ const sizeFilter = (
       Queue.offerUnsafe(wake, undefined);
     };
 
-    const now = () => Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6;
+    const now = () => monotonicMillis(options.clock);
 
     const adopt = (adopted: Run) => {
       run = undefined;
@@ -470,7 +470,7 @@ export const make = (options: Options) =>
     let latest = Option.none<Frame>();
     let history: ReadonlyArray<Frame> = [];
     const keepMillis = Duration.toMillis(options.frameHistory);
-    const now = () => Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6;
+    const now = () => monotonicMillis(options.clock);
     const counts = tally(now);
     // Frames delivered, which number them so that a reader can tell what it missed.
     let delivered = 0;

package/src/internal/pictures/clock.ts

@@ -1,8 +1,13 @@
 /**
- * The browser's clock read on the owner's: estimates of their offset from timed probes, how an
- * estimate ages, and the one mapping a browser's pages share. `pictures.ts` takes the probes.
+ * Host monotonic milliseconds and the browser's clock read on the owner's: estimates of their
+ * offset from timed probes, how an estimate ages, and the mapping a browser's pages share.
+ * `pictures.ts` takes the probes.
  */
-import { Duration, Effect, Option } from "effect";
+import { type Clock, Duration, Effect, Option } from "effect";
+
+/** Read the captured owner's clock, including from native callbacks, without changing its origin. */
+export const monotonicMillis = (clock: Clock.Clock): number =>
+  Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
 
 export interface Probe {
   readonly hostStart: number;

package/src/internal/pictures/pictures.ts

@@ -8,6 +8,7 @@ import { Duration, Effect, Option, Schedule, Schema } from "effect";
 
 import { BrowserError, Failed, InvalidRequest } from "../../BrowserError.ts";
 import { Frame, Image, Screenshot } from "../../Frame.ts";
+import type { Point } from "../../Motion.ts";
 import { type FrameOptions, Region, type ScreenshotOptions, Zoom } from "../../Page.ts";
 import { type Bridge, scriptCall } from "../page/bridge.ts";
 import { decodeWith, failWith, type PageContext, reasonOf, undispatched } from "../page/context.ts";
@@ -219,7 +220,7 @@ const camera = (
     operation: string,
     format: Format,
     quality: number,
-    clip?: Capture.Size & { readonly x: number; readonly y: number; readonly scale: number },
+    clip?: Capture.Size & Point & { readonly scale: number },
   ) =>
     take(operation, format, () =>
       send("Page.captureScreenshot", {

package/src/internal/reading/controls.inpage.ts

@@ -3,6 +3,8 @@
  * read to; and a condition `Page.waitFor` waits for. See `names.inpage.ts` for what a page-side part
  * may use.
  */
+import { Schema } from "effect";
+
 import type { Control } from "../../Snapshot.ts";
 import type { Names } from "./names.inpage.ts";
 import type { Subjects } from "./subjects.inpage.ts";
@@ -17,7 +19,7 @@ export interface ConditionRequest {
 }
 
 /** Whether the condition held by the deadline, or why the selector is not CSS. */
-export type ConditionResult = { readonly met: boolean } | { readonly invalid: string };
+export type ConditionResult = typeof ConditionResultSchema.Encoded;
 
 export const controls = (names: Names, walked: Walk, subjects: Subjects, texts: Texts) => {
   const { clean, isDisabled, isHtml, isInput, isSelect, isTextArea, refFor, textOf } = names;
@@ -156,3 +158,8 @@ export const controls = (names: Names, walked: Walk, subjects: Subjects, texts:
 };
 
 export type Controls = ReturnType<typeof controls>;
+
+export const ConditionResultSchema = Schema.Union([
+  Schema.Struct({ met: Schema.Boolean }),
+  Schema.Struct({ invalid: Schema.String }),
+]);

package/src/internal/reading/match.inpage.ts

@@ -10,6 +10,7 @@
  *   its row, column, label or heading. Replay chooses among candidates by the same rule.
  */
 import type { SubjectContext } from "../../BrowserEvent.ts";
+import type { Point } from "../../Motion.ts";
 
 /** A string, or a pattern sent to the page as its source and flags. */
 export type Wanted = string | { readonly source: string; readonly flags: string };
@@ -19,7 +20,7 @@ export interface FindRequest {
   readonly name: Wanted | null;
   readonly text: Wanted | null;
   readonly near: string | null;
-  readonly at: { readonly x: number; readonly y: number } | null;
+  readonly at: Point | null;
   readonly scope: "viewport" | "document";
   readonly firstRef: number;
 }

package/src/internal/reading/outline.inpage.ts

@@ -4,7 +4,7 @@
  */
 import { Schema } from "effect";
 
-import type { Control, Snapshot } from "../../Snapshot.ts";
+import { type Control, Snapshot } from "../../Snapshot.ts";
 import type { addresses } from "../page/url.ts";
 import type { Controls } from "./controls.inpage.ts";
 import type { Names } from "./names.inpage.ts";
@@ -25,9 +25,7 @@ export interface SnapshotRequest {
  * The outline as a `Snapshot` reads it, and the next ref the page may give, or why `within` is not
  * a selector.
  */
-export type SnapshotResult =
-  | { readonly snapshot: typeof Snapshot.Encoded; readonly nextRef: number }
-  | { readonly invalid: string };
+export type SnapshotResult = typeof SnapshotResultSchema.Encoded;
 
 /** The rule every address the library reports goes by, which a link's address goes by too. */
 type Url = ReturnType<typeof addresses>;
@@ -254,6 +252,11 @@ export const outline = (
 
 export type Outline = ReturnType<typeof outline>;
 
+export const SnapshotResultSchema = Schema.Union([
+  Schema.Struct({ snapshot: Snapshot, nextRef: Schema.Finite }),
+  Schema.Struct({ invalid: Schema.String }),
+]);
+
 export const ViewportResultSchema = Schema.Struct({
   width: Schema.Finite,
   height: Schema.Finite,

package/src/internal/reading/reading.ts

@@ -11,28 +11,17 @@ import { Snapshot, type SnapshotOptions } from "../../Snapshot.ts";
 import { type Bridge, scriptCall } from "../page/bridge.ts";
 import { contextGone, decodeWith, failWith, type PageContext } from "../page/context.ts";
 import * as Url from "../page/url.ts";
-import type { ConditionRequest } from "./controls.inpage.ts";
+import { type ConditionRequest, ConditionResultSchema } from "./controls.inpage.ts";
 import type { Want } from "./expect.inpage.ts";
 import type { FindRequest, Wanted } from "./match.inpage.ts";
-import type { SnapshotRequest } from "./outline.inpage.ts";
+import { type SnapshotRequest, SnapshotResultSchema } from "./outline.inpage.ts";
 import { type TextRequest, TextResultSchema } from "./text.inpage.ts";
 
-// What `snapshot` and `find` read back, each with the next ref the page may give, and why a
-// snapshot's selector is not CSS.
-const SnapshotResult = Schema.Union([
-  Schema.Struct({ snapshot: Snapshot, nextRef: Schema.Finite }),
-  Schema.Struct({ invalid: Schema.String }),
-]);
-
+// What `find` reads back, with the next ref the page may give.
 const FindResults = Schema.Struct({ found: Schema.Array(Found), nextRef: Schema.Finite });
 
 const UntilResult = Schema.Struct({ met: Schema.Boolean, mark: Schema.String });
 
-const ConditionResult = Schema.Union([
-  Schema.Struct({ met: Schema.Boolean }),
-  Schema.Struct({ invalid: Schema.String }),
-]);
-
 // A pattern crosses into the page as its source and flags.
 const wanted = (value: string | RegExp | undefined): Wanted | null =>
   value === undefined
@@ -76,7 +65,7 @@ export const make = Effect.fnUntraced(function* (page: PageContext, bridge: Brid
         const request: SnapshotRequest = { ...asked, firstRef: yield* Ref.get(nextRef) };
 
         const result = yield* evaluate("snapshot", scriptCall("snapshot", request)).pipe(
-          Effect.flatMap(decodeWith("snapshot", SnapshotResult)),
+          Effect.flatMap(decodeWith("snapshot", SnapshotResultSchema)),
         );
 
         if ("invalid" in result)
@@ -167,7 +156,7 @@ export const make = Effect.fnUntraced(function* (page: PageContext, bridge: Brid
     const unmet = () => failWith("waitFor", new Timeout({ millis }));
 
     const look = evaluate("waitFor", scriptCall("waitUntil", request, millis)).pipe(
-      Effect.flatMap(decodeWith("waitFor", ConditionResult)),
+      Effect.flatMap(decodeWith("waitFor", ConditionResultSchema)),
       Effect.flatMap((result) =>
         "invalid" in result
           ? failWith("waitFor", new InvalidRequest({ detail: result.invalid }))