effect-browser 0.2.0-beta.9 → 0.3.0-beta.11

package/dist/Plan-Akcac63g.d.mts

@@ -0,0 +1,209 @@
+import { t as BrowserError } from "./BrowserError-Coy7EW1N.mjs";
+import { b as Subject, i as BrowserEvent } from "./BrowserEvent-BRu2juEz.mjs";
+import { m as ReadyOptions, o as Found, u as Page } from "./Page-B7X6DQUn.mjs";
+import { Duration, Effect, Schema } from "effect";
+//#region src/internal/reading/choose.d.ts
+declare const Missing_base: Schema.Class<Missing, Schema.TaggedStruct<"Missing", {}>, import("effect/Cause").YieldableError>;
+/** Nothing on the page has the step's role and name. */
+declare class Missing extends Missing_base {
+  get message(): string;
+}
+declare const Ambiguous_base: Schema.Class<Ambiguous, Schema.TaggedStruct<"Ambiguous", {
+  readonly count: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** Several elements match the step's subject equally well, and nothing tells them apart. */
+declare class Ambiguous extends Ambiguous_base {
+  get message(): string;
+}
+declare const Drifted_base: Schema.Class<Drifted, Schema.TaggedStruct<"Drifted", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The page is not where the recording was: another site, or no element with its context. */
+declare class Drifted extends Drifted_base {
+  get message(): string;
+}
+declare namespace Plan_d_exports {
+  export { Ambiguous, Drifted, Expected, Missing, Plan, Receipt, ReplayError, ReplayOptions, Step, StepAction, Stopped, TakeOptions, Uncertain, fromEvents, locate, repeatable, replay, restore, take };
+}
+declare const StepAction: Schema.Literals<readonly ["navigate", "back", "reload", "click", "hover", "drag", "type", "press", "scroll", "select"]>;
+type StepAction = typeof StepAction.Type;
+/**
+ * What a step leaves. `durable` asserts an author-chosen, lasting read-back of this operation,
+ * such as its uniquely named saved receipt. A toast or an intermediate address is not durable.
+ * Even a durable check's absence never authorizes repeating unknown consequential input.
+ */
+declare const Expected: Schema.Union<readonly [Schema.TaggedStruct<"Checked", {
+  readonly checked: Schema.Boolean;
+}>, Schema.TaggedStruct<"Appeared", {
+  readonly query: Schema.Struct<{
+    readonly role: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+  }>;
+  readonly durable: Schema.optional<Schema.Literal<true>>;
+}>, Schema.TaggedStruct<"Gone", {
+  readonly query: Schema.Struct<{
+    readonly role: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+  }>;
+  readonly durable: Schema.optional<Schema.Literal<true>>;
+}>, Schema.TaggedStruct<"Navigated", {
+  readonly url: Schema.optional<Schema.String>;
+  readonly durable: Schema.optional<Schema.Literal<true>>;
+}>]>;
+type Expected = typeof Expected.Type;
+declare const Step_base: Schema.Class<Step, Schema.Struct<{
+  readonly action: Schema.Literals<readonly ["navigate", "back", "reload", "click", "hover", "drag", "type", "press", "scroll", "select"]>;
+  /**
+   * The ending address, or a later recorded navigation before the next action began. Empty when
+   * unknown; a delayed navigation can be stronger arrival evidence than the action's ending URL.
+   */
+  readonly url: Schema.String;
+  /** A navigation's requested address, or the keys a press pressed. */
+  readonly target: Schema.optional<Schema.String>;
+  readonly subject: Schema.optional<typeof Subject>;
+  /** Where a drag ended. */
+  readonly to: Schema.optional<typeof Subject>;
+  /** The viewport point a step aimed at, when it aimed at a point, and a drag's end point. */
+  readonly point: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>>;
+  readonly toPoint: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>>;
+  /** The box of what a step aimed at by point found there, so replay aims at the same place in it. */
+  readonly box: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+    readonly width: Schema.Finite;
+    readonly height: Schema.Finite;
+  }>>;
+  /**
+   * The input slot whose text a `type` step types, or whose address a `navigate` step goes to, as
+   * its recorded address had a credential withheld.
+   */
+  readonly input: Schema.optional<Schema.String>;
+  /** The slot's text went into a secret field, so replay types it into nothing else. */
+  readonly secret: Schema.optional<Schema.Literal<true>>;
+  readonly options: Schema.optional<Schema.Struct<{
+    readonly button: Schema.optional<Schema.Literals<readonly ["left", "right", "middle"]>>;
+    readonly clickCount: Schema.optional<Schema.Finite>;
+    readonly holdMillis: Schema.optional<Schema.Finite>;
+    readonly replace: Schema.optional<Schema.Boolean>;
+    readonly submit: Schema.optional<Schema.Boolean>;
+    readonly times: Schema.optional<Schema.Finite>;
+    readonly dx: Schema.optional<Schema.Finite>;
+    readonly dy: Schema.optional<Schema.Finite>;
+    readonly values: Schema.optional<Schema.$Array<Schema.String>>;
+  }>>;
+  readonly expect: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"Checked", {
+    readonly checked: Schema.Boolean;
+  }>, Schema.TaggedStruct<"Appeared", {
+    readonly query: Schema.Struct<{
+      readonly role: Schema.optional<Schema.String>;
+      readonly name: Schema.optional<Schema.String>;
+      readonly text: Schema.optional<Schema.String>;
+    }>;
+    readonly durable: Schema.optional<Schema.Literal<true>>;
+  }>, Schema.TaggedStruct<"Gone", {
+    readonly query: Schema.Struct<{
+      readonly role: Schema.optional<Schema.String>;
+      readonly name: Schema.optional<Schema.String>;
+      readonly text: Schema.optional<Schema.String>;
+    }>;
+    readonly durable: Schema.optional<Schema.Literal<true>>;
+  }>, Schema.TaggedStruct<"Navigated", {
+    readonly url: Schema.optional<Schema.String>;
+    readonly durable: Schema.optional<Schema.Literal<true>>;
+  }>]>>;
+}>, {}>;
+/** One recorded step: the action, what it acted on, and what else it was asked. */
+declare class Step extends Step_base {}
+declare const Plan_base: Schema.Class<Plan, Schema.Struct<{
+  readonly version: Schema.Literals<readonly [1, 2]>;
+  readonly steps: Schema.$Array<typeof Step>;
+}>, {}>;
+declare class Plan extends Plan_base {
+  /** Choose the encoding version from the steps; simple recordings remain version 1. */
+  static new(steps: ReadonlyArray<Step>): Plan;
+  /** The input slots its steps type, in order; replay needs text for each. */
+  get inputs(): ReadonlyArray<string>;
+}
+declare const Receipt_base: Schema.Class<Receipt, Schema.Struct<{
+  readonly step: Schema.Int;
+  readonly outcome: Schema.Literals<readonly ["taken", "verified", "skipped"]>;
+  readonly startedAt: Schema.Finite;
+  readonly at: Schema.Finite;
+}>, {}>;
+/** One completed step, on the page's host clock. `verified` means its expected effect was seen. */
+declare class Receipt extends Receipt_base {}
+declare const Stopped_base: Schema.Class<Stopped, Schema.Struct<{
+  readonly step: Schema.Int;
+  readonly input: Schema.Literals<readonly ["unsent", "unknown"]>;
+}>, {}>;
+/** Durable stopping data. A begun step without a receipt must be restored as `unknown`. */
+declare class Stopped extends Stopped_base {}
+declare const Uncertain_base: Schema.Class<Uncertain, Schema.TaggedStruct<"Uncertain", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Repeating this step could repeat an unresolved effect; the consumer must reconcile it. */
+declare class Uncertain extends Uncertain_base {
+  get message(): string;
+}
+declare const ReplayError_base: Schema.Class<ReplayError, Schema.TaggedStruct<"ReplayError", {
+  readonly step: Schema.Int;
+  readonly reason: Schema.Union<readonly [typeof Missing, typeof Ambiguous, typeof Drifted, typeof BrowserError, typeof Uncertain]>;
+  readonly input: Schema.Literals<readonly ["unsent", "unknown"]>;
+  readonly receipts: Schema.$Array<typeof Receipt>;
+}>, import("effect/Cause").YieldableError>;
+/** Where replay stopped, counting steps from 0, why, and the steps that completed before it. */
+declare class ReplayError extends ReplayError_base {
+  get stopped(): Stopped;
+  get message(): string;
+}
+/**
+ * The walk one page's events record: the completed actions of the page that acted first, in
+ * order. `page.recentEvents` gives them, or `browser.events()` read until the walk ends.
+ */
+declare const fromEvents: (events: Iterable<BrowserEvent>) => Plan;
+/**
+ * The one element on the page that a subject names, by role, name and context (see `Plan`),
+ * looking again for two seconds while the page may still be drawing it.
+ */
+declare const locate: (page: Page, subject: Subject) => Effect.Effect<Found, Ambiguous | BrowserError | Drifted | Missing, never>;
+interface TakeOptions {
+  /** How each step waits for the page first, or false not to wait. */
+  readonly settle?: ReadyOptions | false | undefined;
+  readonly inputs?: Readonly<Record<string, string>> | undefined;
+  /**
+   * Bound for recorded arrival and expected effect, each. Defaults to 5 seconds. Zero makes one
+   * read without polling; that read retains the page operation's timeout.
+   */
+  readonly arrival?: Duration.Input | undefined;
+}
+interface ReplayOptions extends TakeOptions {
+  readonly from?: number | Stopped | undefined;
+}
+/**
+ * Input that can be repeated without repeating a commitment. `take` also validates a Checked
+ * target's boolean state before input. Back/reload can resubmit a form.
+ */
+declare const repeatable: (step: Step) => boolean;
+/**
+ * Take one step. Unknown non-repeatable input is never resent: only positive durable read-back
+ * can skip it. An interrupted call remains interrupted; persist begun-before-call in the consumer
+ * and treat a missing receipt as Stopped{input: "unknown"}, including after process restart.
+ */
+declare const take: (page: Page, plan: Plan, at: number | Stopped, options?: TakeOptions | undefined) => Effect.Effect<Receipt, ReplayError, never>;
+/** Take a plan's steps from a fresh index or durable stopping point, returning completed receipts. */
+declare const replay: (page: Page, plan: Plan, options?: ReplayOptions) => Effect.Effect<Receipt[], ReplayError, never>;
+/** Restore prior steps on a fresh page; unresolved commitments require positive durable evidence. */
+declare const restore: (page: Page, plan: Plan, options?: TakeOptions & {
+  readonly upTo?: number | undefined;
+}) => Effect.Effect<Receipt[], ReplayError, never>;
+//#endregion
+export { take as _, ReplayError as a, Missing as b, StepAction as c, Uncertain as d, fromEvents as f, restore as g, replay as h, Receipt as i, Stopped as l, repeatable as m, Plan as n, ReplayOptions as o, locate as p, Plan_d_exports as r, Step as s, Expected as t, TakeOptions as u, Ambiguous as v, Drifted as y };
+//# sourceMappingURL=Plan-Akcac63g.d.mts.map