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

package/dist/Browser.mjs

@@ -1,22 +1,2 @@
-import { l as resolveTargetControlsForSession } from "./PageRegistry-B3q9DS3g.mjs";
-import { Effect } from "effect";
-import { dual } from "effect/Function";
-//#region src/Browser.ts
-/**
-* Check that `page` is a Page or Frame this session issued, by identity, and that its authority
-* is still current: a foreign or copied object fails `UnregisteredSession`, a closed, stale or
-* detached one fails with the same refusal its own operations would report. Adapters such as
-* agent-browser hosts call it once when they bind, so a wrong target fails before any work.
-*/
-const checkPage = (session, page) => resolveTargetControlsForSession(session, page).pipe(Effect.asVoid);
-/**
-* Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete
-* Chromium or provider session type. Its scoped work is joined before checked browser cleanup,
-* and cleanup failures remain typed even when the callback has already failed or was cancelled.
-* Acquisition is evaluated once; an uncertain result is never retried.
-*/
-const scoped = dual(2, (open, f) => Effect.scoped(Effect.flatMap(open, (session) => Effect.scoped(Effect.raceFirst(session.failure, Effect.suspend(() => f(session)))).pipe(Effect.onExit(() => session.closeChecked)))));
-//#endregion
-export { checkPage, scoped };
-
-//# sourceMappingURL=Browser.mjs.map
+import { r as make, t as Browser } from "./Browser-B5AV7zPS.mjs";
+export { Browser, make };

package/dist/BrowserError-DXXIA6Rk.d.mts

@@ -0,0 +1,135 @@
+import { Schema } from "effect";
+declare namespace BrowserError_d_exports {
+  export { BrowserError, Busy, Closed, Consequence, EventHistoryExpired, Failed, InvalidRequest, Limit, NavigationFailed, NotActionable, NotFound, PolicyDenied, PolicyTimeout, Reason, StaleRef, Timeout, consequence };
+}
+declare const Timeout_base: Schema.Class<Timeout, Schema.TaggedStruct<"Timeout", {
+  readonly millis: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The operation did not finish in time. */
+declare class Timeout extends Timeout_base {
+  get message(): string;
+}
+declare const Busy_base: Schema.Class<Busy, Schema.TaggedStruct<"Busy", {
+  readonly waitedMillis: Schema.Finite;
+  /** The operations ahead of it: those holding the page and those asked before it. */
+  readonly ahead: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The operation waited its turn behind others on its page and was not given one in time, or was
+ * asked to fail fast: the page may be well, only busy.
+ */
+declare class Busy extends Busy_base {
+  get message(): string;
+}
+declare const Limit_base: Schema.Class<Limit, Schema.TaggedStruct<"Limit", {
+  readonly maxPages: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The browser has as many pages open as `maxPages` allows, and none closed in time. */
+declare class Limit extends Limit_base {
+  get message(): string;
+}
+declare const StaleRef_base: Schema.Class<StaleRef, Schema.TaggedStruct<"StaleRef", {
+  readonly ref: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A ref from an earlier snapshot no longer names an element on the page. */
+declare class StaleRef extends StaleRef_base {
+  get message(): string;
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+  readonly target: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** What the operation looked for is not on the page. */
+declare class NotFound extends NotFound_base {
+  get message(): string;
+}
+declare const NotActionable_base: Schema.Class<NotActionable, Schema.TaggedStruct<"NotActionable", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The element exists but cannot take this input: covered, disabled, hidden or the wrong kind. */
+declare class NotActionable extends NotActionable_base {
+  get message(): string;
+}
+declare const NavigationFailed_base: Schema.Class<NavigationFailed, Schema.TaggedStruct<"NavigationFailed", {
+  readonly url: Schema.String;
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A navigation failed, for example on a DNS error or a refused connection. */
+declare class NavigationFailed extends NavigationFailed_base {
+  get message(): string;
+}
+declare const Closed_base: Schema.Class<Closed, Schema.TaggedStruct<"Closed", {
+  readonly cause: Schema.Literals<readonly ["page", "crashed", "connection", "session", "released"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The page is gone: it was closed (`page`) or crashed, or its browser was lost for one of the
+ * browser's `DisconnectCause`s.
+ */
+declare class Closed extends Closed_base {
+  get message(): string;
+}
+declare const InvalidRequest_base: Schema.Class<InvalidRequest, Schema.TaggedStruct<"InvalidRequest", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The request itself is invalid, such as a ref that is not a ref or a point off the screen. */
+declare class InvalidRequest extends InvalidRequest_base {
+  get message(): string;
+}
+declare const PolicyDenied_base: Schema.Class<PolicyDenied, Schema.TaggedStruct<"PolicyDenied", {
+  readonly detail: Schema.String;
+  /** What made the policy deny, such as the failure of the judge it asked. */
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The input policy refused the action before any input was sent. */
+declare class PolicyDenied extends PolicyDenied_base {
+  get message(): string;
+}
+declare const PolicyTimeout_base: Schema.Class<PolicyTimeout, Schema.TaggedStruct<"PolicyTimeout", {
+  readonly millis: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The input policy did not release its hold within its own bound. */
+declare class PolicyTimeout extends PolicyTimeout_base {
+  get message(): string;
+}
+declare const EventHistoryExpired_base: Schema.Class<EventHistoryExpired, Schema.TaggedStruct<"EventHistoryExpired", {
+  readonly after: Schema.Int;
+  readonly oldest: Schema.Int;
+  readonly latest: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The requested event cursor fell behind the browser's bounded replay history. */
+declare class EventHistoryExpired extends EventHistoryExpired_base {
+  get message(): string;
+}
+declare const Failed_base: Schema.Class<Failed, Schema.TaggedStruct<"Failed", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The browser, the connection or the provider failed in a way the other reasons do not cover. */
+declare class Failed extends Failed_base {
+  get message(): string;
+}
+declare const Reason: Schema.Union<readonly [typeof Timeout, typeof Busy, typeof Limit, typeof StaleRef, typeof NotFound, typeof NotActionable, typeof NavigationFailed, typeof Closed, typeof InvalidRequest, typeof PolicyDenied, typeof PolicyTimeout, typeof EventHistoryExpired, typeof Failed]>;
+type Reason = typeof Reason.Type;
+declare const BrowserError_base: Schema.Class<BrowserError, Schema.TaggedStruct<"BrowserError", {
+  readonly operation: Schema.String;
+  readonly reason: Schema.Union<readonly [typeof Timeout, typeof Busy, typeof Limit, typeof StaleRef, typeof NotFound, typeof NotActionable, typeof NavigationFailed, typeof Closed, typeof InvalidRequest, typeof PolicyDenied, typeof PolicyTimeout, typeof EventHistoryExpired, typeof Failed]>;
+  readonly dispatched: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+declare class BrowserError extends BrowserError_base {
+  get message(): string;
+}
+/**
+ * What a failure leaves. `lost` is `"page"` when the page is gone and its browser stands, and
+ * `"session"` when the browser is gone with its pages. `repeat` says whether the call can be made
+ * again, on what still stands: `"safe"`, as nothing reached the browser; `"check"`, as it may have
+ * taken effect, so look first, as an `Expect` attempt does; `"pointless"`, as it fails again unless
+ * something changes, such as
+ * a new ref; or `"resume"`, reading events again from a newer cursor.
+ */
+interface Consequence {
+  readonly lost: "nothing" | "page" | "session";
+  readonly repeat: "safe" | "check" | "pointless" | "resume";
+}
+/** What `error` leaves, from its reason and whether it was dispatched alone. */
+declare const consequence: ({ reason, dispatched }: BrowserError) => Consequence;
+//#endregion
+export { Timeout as _, Consequence as a, InvalidRequest as c, NotActionable as d, NotFound as f, StaleRef as g, Reason as h, Closed as i, Limit as l, PolicyTimeout as m, BrowserError_d_exports as n, EventHistoryExpired as o, PolicyDenied as p, Busy as r, Failed as s, BrowserError as t, NavigationFailed as u, consequence as v };
+//# sourceMappingURL=BrowserError-DXXIA6Rk.d.mts.map

package/dist/BrowserError.d.mts

@@ -0,0 +1,2 @@
+import { _ as Timeout, a as Consequence, c as InvalidRequest, d as NotActionable, f as NotFound, g as StaleRef, h as Reason, i as Closed, l as Limit, m as PolicyTimeout, o as EventHistoryExpired, p as PolicyDenied, r as Busy, s as Failed, t as BrowserError, u as NavigationFailed, v as consequence } from "./BrowserError-DXXIA6Rk.mjs";
+export { BrowserError, Busy, Closed, Consequence, EventHistoryExpired, Failed, InvalidRequest, Limit, NavigationFailed, NotActionable, NotFound, PolicyDenied, PolicyTimeout, Reason, StaleRef, Timeout, consequence };

package/dist/BrowserError.mjs

@@ -0,0 +1,202 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DisconnectCause } from "./BrowserEvent.mjs";
+import { Schema } from "effect";
+//#region src/BrowserError.ts
+/**
+* The one error every browser operation fails with.
+*
+* `reason` says what went wrong and `dispatched` says whether the action's own input (a press,
+* key, wheel, selection or hover, not the pointer travelling toward a press) or a navigation
+* reached the browser first. `consequence` says what that leaves: what was lost, and whether the
+* call can be repeated. `message` is a sentence for operators.
+*
+* @since 0.3.0
+*/
+var BrowserError_exports = /* @__PURE__ */ __exportAll({
+	BrowserError: () => BrowserError,
+	Busy: () => Busy,
+	Closed: () => Closed,
+	EventHistoryExpired: () => EventHistoryExpired,
+	Failed: () => Failed,
+	InvalidRequest: () => InvalidRequest,
+	Limit: () => Limit,
+	NavigationFailed: () => NavigationFailed,
+	NotActionable: () => NotActionable,
+	NotFound: () => NotFound,
+	PolicyDenied: () => PolicyDenied,
+	PolicyTimeout: () => PolicyTimeout,
+	Reason: () => Reason,
+	StaleRef: () => StaleRef,
+	Timeout: () => Timeout,
+	consequence: () => consequence
+});
+/** The operation did not finish in time. */
+var Timeout = class extends Schema.TaggedError()("Timeout", { millis: Schema.Finite }) {
+	get message() {
+		return `timed out after ${this.millis} ms`;
+	}
+};
+/**
+* The operation waited its turn behind others on its page and was not given one in time, or was
+* asked to fail fast: the page may be well, only busy.
+*/
+var Busy = class extends Schema.TaggedError()("Busy", {
+	waitedMillis: Schema.Finite,
+	/** The operations ahead of it: those holding the page and those asked before it. */
+	ahead: Schema.Int
+}) {
+	get message() {
+		const others = this.ahead === 1 ? "operation" : "operations";
+		return `the page was busy: it waited ${this.waitedMillis} ms behind ${this.ahead} other ${others}`;
+	}
+};
+/** The browser has as many pages open as `maxPages` allows, and none closed in time. */
+var Limit = class extends Schema.TaggedError()("Limit", { maxPages: Schema.Int }) {
+	get message() {
+		return `the browser already has ${this.maxPages} pages open, as many as it allows`;
+	}
+};
+/** A ref from an earlier snapshot no longer names an element on the page. */
+var StaleRef = class extends Schema.TaggedError()("StaleRef", { ref: Schema.String }) {
+	get message() {
+		return `${this.ref} is not on the page any more`;
+	}
+};
+/** What the operation looked for is not on the page. */
+var NotFound = class extends Schema.TaggedError()("NotFound", { target: Schema.String }) {
+	get message() {
+		return `${this.target} was not found`;
+	}
+};
+/** The element exists but cannot take this input: covered, disabled, hidden or the wrong kind. */
+var NotActionable = class extends Schema.TaggedError()("NotActionable", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** A navigation failed, for example on a DNS error or a refused connection. */
+var NavigationFailed = class extends Schema.TaggedError()("NavigationFailed", {
+	url: Schema.String,
+	detail: Schema.String
+}) {
+	get message() {
+		return `could not load ${this.url}: ${this.detail}`;
+	}
+};
+const closedBy = {
+	page: "the page was closed",
+	crashed: "the page crashed",
+	connection: "the connection to the browser was lost",
+	session: "the browser's session ended",
+	released: "the browser was released"
+};
+/**
+* The page is gone: it was closed (`page`) or crashed, or its browser was lost for one of the
+* browser's `DisconnectCause`s.
+*/
+var Closed = class extends Schema.TaggedError()("Closed", { cause: Schema.Literals([
+	"page",
+	"crashed",
+	...DisconnectCause.literals
+]) }) {
+	get message() {
+		return closedBy[this.cause];
+	}
+};
+/** The request itself is invalid, such as a ref that is not a ref or a point off the screen. */
+var InvalidRequest = class extends Schema.TaggedError()("InvalidRequest", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** The input policy refused the action before any input was sent. */
+var PolicyDenied = class extends Schema.TaggedError()("PolicyDenied", {
+	detail: Schema.String,
+	/** What made the policy deny, such as the failure of the judge it asked. */
+	cause: Schema.optional(Schema.Defect())
+}) {
+	get message() {
+		return `the input policy denied this action: ${this.detail}`;
+	}
+};
+/** The input policy did not release its hold within its own bound. */
+var PolicyTimeout = class extends Schema.TaggedError()("PolicyTimeout", { millis: Schema.Finite }) {
+	get message() {
+		return `the input policy did not allow this action within ${this.millis} ms`;
+	}
+};
+/** The requested event cursor fell behind the browser's bounded replay history. */
+var EventHistoryExpired = class extends Schema.TaggedError()("EventHistoryExpired", {
+	after: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	oldest: Schema.Int.check(Schema.isGreaterThan(0)),
+	latest: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {
+	get message() {
+		return `event history after ${this.after} expired; retained sequences are ${this.oldest}–${this.latest}`;
+	}
+};
+/** The browser, the connection or the provider failed in a way the other reasons do not cover. */
+var Failed = class extends Schema.TaggedError()("Failed", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+const Reason = Schema.Union([
+	Timeout,
+	Busy,
+	Limit,
+	StaleRef,
+	NotFound,
+	NotActionable,
+	NavigationFailed,
+	Closed,
+	InvalidRequest,
+	PolicyDenied,
+	PolicyTimeout,
+	EventHistoryExpired,
+	Failed
+]);
+var BrowserError = class extends Schema.TaggedError()("BrowserError", {
+	operation: Schema.String,
+	reason: Reason,
+	dispatched: Schema.Boolean
+}) {
+	get message() {
+		return `${this.operation} failed${this.dispatched ? " after it was sent" : ""}: ${this.reason.message}`;
+	}
+};
+/** What `error` leaves, from its reason and whether it was dispatched alone. */
+const consequence = ({ reason, dispatched }) => {
+	const repeat = dispatched ? "check" : "safe";
+	switch (reason._tag) {
+		case "Closed": return {
+			lost: reason.cause === "page" || reason.cause === "crashed" ? "page" : "session",
+			repeat
+		};
+		case "Busy":
+		case "Timeout":
+		case "Failed":
+		case "NavigationFailed": return {
+			lost: "nothing",
+			repeat
+		};
+		case "EventHistoryExpired": return {
+			lost: "nothing",
+			repeat: "resume"
+		};
+		case "StaleRef":
+		case "NotFound":
+		case "NotActionable":
+		case "InvalidRequest":
+		case "Limit":
+		case "PolicyDenied":
+		case "PolicyTimeout": return {
+			lost: "nothing",
+			repeat: "pointless"
+		};
+	}
+};
+//#endregion
+export { BrowserError, Busy, Closed, EventHistoryExpired, Failed, InvalidRequest, Limit, NavigationFailed, NotActionable, NotFound, PolicyDenied, PolicyTimeout, Reason, StaleRef, Timeout, consequence, BrowserError_exports as t };
+
+//# sourceMappingURL=BrowserError.mjs.map

package/dist/BrowserError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserError.mjs","names":[],"sources":["../src/BrowserError.ts"],"sourcesContent":["/**\n * The one error every browser operation fails with.\n *\n * `reason` says what went wrong and `dispatched` says whether the action's own input (a press,\n * key, wheel, selection or hover, not the pointer travelling toward a press) or a navigation\n * reached the browser first. `consequence` says what that leaves: what was lost, and whether the\n * call can be repeated. `message` is a sentence for operators.\n *\n * @since 0.3.0\n */\nimport { Schema } from \"effect\";\n\nimport { DisconnectCause } from \"./BrowserEvent.ts\";\n\n/** The operation did not finish in time. */\nexport class Timeout extends Schema.TaggedError<Timeout>()(\"Timeout\", {\n  millis: Schema.Finite,\n}) {\n  override get message() {\n    return `timed out after ${this.millis} ms`;\n  }\n}\n\n/**\n * The operation waited its turn behind others on its page and was not given one in time, or was\n * asked to fail fast: the page may be well, only busy.\n */\nexport class Busy extends Schema.TaggedError<Busy>()(\"Busy\", {\n  waitedMillis: Schema.Finite,\n  /** The operations ahead of it: those holding the page and those asked before it. */\n  ahead: Schema.Int,\n}) {\n  override get message() {\n    const others = this.ahead === 1 ? \"operation\" : \"operations\";\n\n    return `the page was busy: it waited ${this.waitedMillis} ms behind ${this.ahead} other ${others}`;\n  }\n}\n\n/** The browser has as many pages open as `maxPages` allows, and none closed in time. */\nexport class Limit extends Schema.TaggedError<Limit>()(\"Limit\", {\n  maxPages: Schema.Int,\n}) {\n  override get message() {\n    return `the browser already has ${this.maxPages} pages open, as many as it allows`;\n  }\n}\n\n/** A ref from an earlier snapshot no longer names an element on the page. */\nexport class StaleRef extends Schema.TaggedError<StaleRef>()(\"StaleRef\", {\n  ref: Schema.String,\n}) {\n  override get message() {\n    return `${this.ref} is not on the page any more`;\n  }\n}\n\n/** What the operation looked for is not on the page. */\nexport class NotFound extends Schema.TaggedError<NotFound>()(\"NotFound\", {\n  target: Schema.String,\n}) {\n  override get message() {\n    return `${this.target} was not found`;\n  }\n}\n\n/** The element exists but cannot take this input: covered, disabled, hidden or the wrong kind. */\nexport class NotActionable extends Schema.TaggedError<NotActionable>()(\"NotActionable\", {\n  detail: Schema.String,\n}) {\n  override get message() {\n    return this.detail;\n  }\n}\n\n/** A navigation failed, for example on a DNS error or a refused connection. */\nexport class NavigationFailed extends Schema.TaggedError<NavigationFailed>()(\"NavigationFailed\", {\n  url: Schema.String,\n  detail: Schema.String,\n}) {\n  override get message() {\n    return `could not load ${this.url}: ${this.detail}`;\n  }\n}\n\nconst closedBy = {\n  page: \"the page was closed\",\n  crashed: \"the page crashed\",\n  connection: \"the connection to the browser was lost\",\n  session: \"the browser's session ended\",\n  released: \"the browser was released\",\n};\n\n/**\n * The page is gone: it was closed (`page`) or crashed, or its browser was lost for one of the\n * browser's `DisconnectCause`s.\n */\nexport class Closed extends Schema.TaggedError<Closed>()(\"Closed\", {\n  cause: Schema.Literals([\"page\", \"crashed\", ...DisconnectCause.literals]),\n}) {\n  override get message() {\n    return closedBy[this.cause];\n  }\n}\n\n/** The request itself is invalid, such as a ref that is not a ref or a point off the screen. */\nexport class InvalidRequest extends Schema.TaggedError<InvalidRequest>()(\"InvalidRequest\", {\n  detail: Schema.String,\n}) {\n  override get message() {\n    return this.detail;\n  }\n}\n\n/** The input policy refused the action before any input was sent. */\nexport class PolicyDenied extends Schema.TaggedError<PolicyDenied>()(\"PolicyDenied\", {\n  detail: Schema.String,\n  /** What made the policy deny, such as the failure of the judge it asked. */\n  cause: Schema.optional(Schema.Defect()),\n}) {\n  override get message() {\n    return `the input policy denied this action: ${this.detail}`;\n  }\n}\n\n/** The input policy did not release its hold within its own bound. */\nexport class PolicyTimeout extends Schema.TaggedError<PolicyTimeout>()(\"PolicyTimeout\", {\n  millis: Schema.Finite,\n}) {\n  override get message() {\n    return `the input policy did not allow this action within ${this.millis} ms`;\n  }\n}\n\n/** The requested event cursor fell behind the browser's bounded replay history. */\nexport class EventHistoryExpired extends Schema.TaggedError<EventHistoryExpired>()(\n  \"EventHistoryExpired\",\n  {\n    after: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n    oldest: Schema.Int.check(Schema.isGreaterThan(0)),\n    latest: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  },\n) {\n  override get message() {\n    return `event history after ${this.after} expired; retained sequences are ${this.oldest}–${this.latest}`;\n  }\n}\n\n/** The browser, the connection or the provider failed in a way the other reasons do not cover. */\nexport class Failed extends Schema.TaggedError<Failed>()(\"Failed\", {\n  detail: Schema.String,\n}) {\n  override get message() {\n    return this.detail;\n  }\n}\n\nexport const Reason = Schema.Union([\n  Timeout,\n  Busy,\n  Limit,\n  StaleRef,\n  NotFound,\n  NotActionable,\n  NavigationFailed,\n  Closed,\n  InvalidRequest,\n  PolicyDenied,\n  PolicyTimeout,\n  EventHistoryExpired,\n  Failed,\n]);\n\nexport type Reason = typeof Reason.Type;\n\nexport class BrowserError extends Schema.TaggedError<BrowserError>()(\"BrowserError\", {\n  operation: Schema.String,\n  reason: Reason,\n  dispatched: Schema.Boolean,\n}) {\n  override get message() {\n    return `${this.operation} failed${this.dispatched ? \" after it was sent\" : \"\"}: ${this.reason.message}`;\n  }\n}\n\n/**\n * What a failure leaves. `lost` is `\"page\"` when the page is gone and its browser stands, and\n * `\"session\"` when the browser is gone with its pages. `repeat` says whether the call can be made\n * again, on what still stands: `\"safe\"`, as nothing reached the browser; `\"check\"`, as it may have\n * taken effect, so look first, as an `Expect` attempt does; `\"pointless\"`, as it fails again unless\n * something changes, such as\n * a new ref; or `\"resume\"`, reading events again from a newer cursor.\n */\nexport interface Consequence {\n  readonly lost: \"nothing\" | \"page\" | \"session\";\n  readonly repeat: \"safe\" | \"check\" | \"pointless\" | \"resume\";\n}\n\n/** What `error` leaves, from its reason and whether it was dispatched alone. */\nexport const consequence = ({ reason, dispatched }: BrowserError): Consequence => {\n  const repeat = dispatched ? \"check\" : \"safe\";\n\n  switch (reason._tag) {\n    case \"Closed\":\n      return {\n        lost: reason.cause === \"page\" || reason.cause === \"crashed\" ? \"page\" : \"session\",\n        repeat,\n      };\n    case \"Busy\":\n    case \"Timeout\":\n    case \"Failed\":\n    case \"NavigationFailed\":\n      return { lost: \"nothing\", repeat };\n    case \"EventHistoryExpired\":\n      return { lost: \"nothing\", repeat: \"resume\" };\n    case \"StaleRef\":\n    case \"NotFound\":\n    case \"NotActionable\":\n    case \"InvalidRequest\":\n    case \"Limit\":\n    case \"PolicyDenied\":\n    case \"PolicyTimeout\":\n      return { lost: \"nothing\", repeat: \"pointless\" };\n  }\n};\n"],"mappings":"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"}

package/dist/BrowserEvent-DzdNdvoh.d.mts

@@ -0,0 +1,277 @@
+import { Schema } from "effect";
+declare namespace BrowserEvent_d_exports {
+  export { Action, ActionOptions, Box, BrowserEvent, CursorChanged, DialogShown, DisconnectCause, Disconnected, KeyChanged, Navigated, PageClosed, PageLoaded, PageOpened, PageUntracked, PointerPressed, PointerReleased, RecordedEvent, SessionEnding, Subject, SubjectContext, TextInserted, TrackEvent, TrackPerformed, TrackPlanned, WheelScrolled };
+}
+declare const PageOpened_base: Schema.Class<PageOpened, Schema.TaggedStruct<"PageOpened", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly url: Schema.String;
+  readonly opener: Schema.optional<Schema.String>;
+}>, {}>;
+/** A page opened, and the page that opened it, as a link or `window.open` does, if one did. */
+declare class PageOpened extends PageOpened_base {}
+declare const PageClosed_base: Schema.Class<PageClosed, Schema.TaggedStruct<"PageClosed", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly cause: Schema.Literals<readonly ["page", "crashed"]>;
+}>, {}>;
+/**
+ * The page closed (`page`), or crashed and was closed (`crashed`). A page lost with its browser
+ * has no event of its own: `Disconnected` stands for all of them.
+ */
+declare class PageClosed extends PageClosed_base {}
+declare const PageUntracked_base: Schema.Class<PageUntracked, Schema.TaggedStruct<"PageUntracked", {
+  readonly at: Schema.Finite;
+  readonly url: Schema.String;
+  readonly detail: Schema.String;
+}>, {}>;
+/**
+ * A tab the site opened that the library could not track, as its registration failed with
+ * `detail`. A tab that closed as it opened has no event.
+ */
+declare class PageUntracked extends PageUntracked_base {}
+declare const Navigated_base: Schema.Class<Navigated, Schema.TaggedStruct<"Navigated", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly url: Schema.String;
+  /**
+   * The page's documents counted from 0, the one it had when this browser began tracking it, one
+   * more for each new document. The count belongs to the page within one `Browser` and starts at
+   * 0 again on a new connection, so compare it only with the same page's in the same browser.
+   */
+  readonly document: Schema.Int;
+  readonly sameDocument: Schema.Boolean;
+}>, {}>;
+/**
+ * The page's main frame moved to `url`: into a new document, or within the current one
+ * (`sameDocument`), as `pushState` and fragment links do. Frames carry the document they followed.
+ */
+declare class Navigated extends Navigated_base {}
+declare const PageLoaded_base: Schema.Class<PageLoaded, Schema.TaggedStruct<"PageLoaded", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly state: Schema.Literals<readonly ["domcontentloaded", "load"]>;
+}>, {}>;
+/** The page's document finished parsing (`domcontentloaded`) or loading (`load`). */
+declare class PageLoaded extends PageLoaded_base {}
+/**
+ * Why a browser was lost to its owner: its connection dropped (`connection`), its provider ended
+ * its session, at or after the session's `expiresAt` (`session`), or its owner released it.
+ */
+declare const DisconnectCause: Schema.Literals<readonly ["connection", "session", "released"]>;
+type DisconnectCause = typeof DisconnectCause.Type;
+declare const Disconnected_base: Schema.Class<Disconnected, Schema.TaggedStruct<"Disconnected", {
+  readonly at: Schema.Finite;
+  readonly cause: Schema.Literals<readonly ["connection", "session", "released"]>;
+}>, {}>;
+/** The browser was lost to its owner, with every page in it. It happens once. */
+declare class Disconnected extends Disconnected_base {}
+declare const SessionEnding_base: Schema.Class<SessionEnding, Schema.TaggedStruct<"SessionEnding", {
+  readonly at: Schema.Finite;
+  readonly expiresAt: Schema.DateTimeUtc;
+}>, {}>;
+/** The provider ends this browser's session at `expiresAt`, a wall-clock instant. */
+declare class SessionEnding extends SessionEnding_base {}
+/**
+ * The words around a subject that say which one it is, each bound to it in the page rather than
+ * read off nearby text later. In a table, `row` is the row's header or first cell with text and
+ * `column` the header over it; elsewhere, `label` is the words just before it in its row, item,
+ * group or block, at most 40 characters. `heading` is the nearest heading above it, left out for
+ * what is pinned to the viewport. Row, column and heading are at most 60 characters.
+ */
+declare const SubjectContext: Schema.Struct<{
+  readonly row: Schema.optional<Schema.String>;
+  readonly column: Schema.optional<Schema.String>;
+  readonly label: Schema.optional<Schema.String>;
+  readonly heading: Schema.optional<Schema.String>;
+}>;
+type SubjectContext = typeof SubjectContext.Type;
+declare const Subject_base: Schema.Class<Subject, Schema.Struct<{
+  readonly role: Schema.NullOr<Schema.String>;
+  readonly name: Schema.String;
+  readonly tag: Schema.String;
+  readonly context: Schema.Struct<{
+    readonly row: Schema.optional<Schema.String>;
+    readonly column: Schema.optional<Schema.String>;
+    readonly label: Schema.optional<Schema.String>;
+    readonly heading: Schema.optional<Schema.String>;
+  }>;
+}>, {}>;
+/**
+ * What an input acted on, or what `Page.find` found, as the page named it then: its role (null
+ * when it has none), its accessible name (empty when it has none), its lowercase tag and its
+ * context. For a point, it is the control under the point, or else the element painted there.
+ * Unlike a ref, it keeps its meaning after the page changes.
+ */
+declare class Subject extends Subject_base {}
+/** An element's box in viewport CSS pixels; it may lie partly or wholly outside the viewport. */
+declare const Box: Schema.Struct<{
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+}>;
+type Box = typeof Box.Type;
+/**
+ * What else an action was asked, where it changes what the action does: a click's button, count
+ * and hold, how `type` enters its text, how often and how long `press` holds its keys, how far
+ * `scroll` moves, and the options `select` chose. Only a completed action records them.
+ */
+declare const ActionOptions: 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>>;
+}>;
+type ActionOptions = typeof ActionOptions.Type;
+declare const Action_base: Schema.Class<Action, Schema.TaggedStruct<"Action", {
+  readonly at: Schema.Finite;
+  readonly startedAt: Schema.Finite;
+  readonly page: Schema.String;
+  readonly name: Schema.String;
+  readonly correlation: Schema.optional<Schema.String>;
+  readonly target: Schema.optional<Schema.String>;
+  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 subject: Schema.optional<typeof Subject>;
+  readonly to: Schema.optional<typeof Subject>;
+  /** For an action at a point, the box of what it found there. */
+  readonly box: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+    readonly width: Schema.Finite;
+    readonly height: Schema.Finite;
+  }>>;
+  readonly text: Schema.optional<Schema.String>;
+  readonly x: Schema.optional<Schema.Finite>;
+  readonly y: Schema.optional<Schema.Finite>;
+  readonly ok: Schema.Boolean;
+  readonly dispatched: Schema.Boolean;
+  readonly error: Schema.optional<Schema.String>;
+}>, {}>;
+/**
+ * One page operation ended, including one its caller interrupted (`error: "interrupted"`).
+ * `target` is what the caller asked for: a ref, a point, a URL or keys, and `options` the rest.
+ * `subject` is what an element or point action found there, and `to` where a drag ended; an
+ * action that failed before finding its target has neither. Point actions carry the viewport
+ * point they used. `correlation` is the id its caller gave it with `Page.correlate`, such as a
+ * model's tool call id.
+ */
+declare class Action extends Action_base {}
+declare const TrackPlanned_base: Schema.Class<TrackPlanned, Schema.TaggedStruct<"TrackPlanned", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly from: Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>;
+  readonly samples: Schema.$Array<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+    readonly afterMillis: Schema.Finite;
+  }>>;
+}>, {}>;
+/** One whole glide, published before its first input. Offsets use the host monotonic clock. */
+declare class TrackPlanned extends TrackPlanned_base {}
+declare const TrackPerformed_base: Schema.Class<TrackPerformed, Schema.TaggedStruct<"TrackPerformed", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly plan: Schema.Int;
+  readonly dispatched: Schema.Int;
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly complete: Schema.Boolean;
+}>, {}>;
+/**
+ * The submitted prefix of a glide. `plan` is its TrackPlanned envelope sequence; `dispatched`
+ * counts samples. `complete` means every sample was submitted, not acknowledged by the browser.
+ * The terminal point clips a canceled plan so a compositor never draws its unrealized future.
+ */
+declare class TrackPerformed extends TrackPerformed_base {}
+declare const PointerPressed_base: Schema.Class<PointerPressed, Schema.TaggedStruct<"PointerPressed", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly button: Schema.Literals<readonly ["left", "right", "middle"]>;
+  readonly clickCount: Schema.Int;
+}>, {}>;
+declare class PointerPressed extends PointerPressed_base {}
+declare const PointerReleased_base: Schema.Class<PointerReleased, Schema.TaggedStruct<"PointerReleased", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly button: Schema.Literals<readonly ["left", "right", "middle"]>;
+  readonly clickCount: Schema.Int;
+}>, {}>;
+declare class PointerReleased extends PointerReleased_base {}
+declare const WheelScrolled_base: Schema.Class<WheelScrolled, Schema.TaggedStruct<"WheelScrolled", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly dx: Schema.Finite;
+  readonly dy: Schema.Finite;
+}>, {}>;
+declare class WheelScrolled extends WheelScrolled_base {}
+declare const KeyChanged_base: Schema.Class<KeyChanged, Schema.TaggedStruct<"KeyChanged", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly key: Schema.String;
+  readonly phase: Schema.Literals<readonly ["down", "up"]>;
+}>, {}>;
+declare class KeyChanged extends KeyChanged_base {}
+declare const TextInserted_base: Schema.Class<TextInserted, Schema.TaggedStruct<"TextInserted", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly text: Schema.String;
+}>, {}>;
+/** Literal text insertion has no corresponding key events, including Unicode and newlines. */
+declare class TextInserted extends TextInserted_base {}
+declare const CursorChanged_base: Schema.Class<CursorChanged, Schema.TaggedStruct<"CursorChanged", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly cursor: Schema.String;
+}>, {}>;
+/** The target's CSS cursor, obtained during target resolution without another browser call. */
+declare class CursorChanged extends CursorChanged_base {}
+declare const TrackEvent: Schema.Union<readonly [typeof TrackPlanned, typeof TrackPerformed, typeof PointerPressed, typeof PointerReleased, typeof WheelScrolled, typeof KeyChanged, typeof TextInserted, typeof CursorChanged]>;
+type TrackEvent = typeof TrackEvent.Type;
+declare const DialogShown_base: Schema.Class<DialogShown, Schema.TaggedStruct<"DialogShown", {
+  readonly at: Schema.Finite;
+  readonly page: Schema.String;
+  readonly kind: Schema.String;
+  readonly message: Schema.String;
+  readonly answer: Schema.Literals<readonly ["accepted", "dismissed"]>;
+}>, {}>;
+/**
+ * A JavaScript dialog appeared and was answered: an alert or a leave-page prompt accepted, a
+ * confirm or a prompt dismissed, as if its Cancel were pressed.
+ */
+declare class DialogShown extends DialogShown_base {}
+declare const BrowserEvent: Schema.Union<readonly [typeof PageOpened, typeof PageClosed, typeof PageUntracked, typeof Navigated, typeof PageLoaded, typeof Action, typeof TrackPlanned, typeof TrackPerformed, typeof PointerPressed, typeof PointerReleased, typeof WheelScrolled, typeof KeyChanged, typeof TextInserted, typeof CursorChanged, typeof DialogShown, typeof Disconnected, typeof SessionEnding]>;
+type BrowserEvent = typeof BrowserEvent.Type;
+declare const RecordedEvent_base: Schema.Class<RecordedEvent, Schema.Struct<{
+  readonly sequence: Schema.Int;
+  readonly event: Schema.Union<readonly [typeof PageOpened, typeof PageClosed, typeof PageUntracked, typeof Navigated, typeof PageLoaded, typeof Action, typeof TrackPlanned, typeof TrackPerformed, typeof PointerPressed, typeof PointerReleased, typeof WheelScrolled, typeof KeyChanged, typeof TextInserted, typeof CursorChanged, typeof DialogShown, typeof Disconnected, typeof SessionEnding]>;
+}>, {}>;
+/** A position in the browser's one replayable event history. Sequences begin at one. */
+declare class RecordedEvent extends RecordedEvent_base {}
+//#endregion
+export { TrackEvent as C, WheelScrolled as E, TextInserted as S, TrackPlanned as T, PointerReleased as _, BrowserEvent_d_exports as a, Subject as b, DisconnectCause as c, Navigated as d, PageClosed as f, PointerPressed as g, PageUntracked as h, BrowserEvent as i, Disconnected as l, PageOpened as m, ActionOptions as n, CursorChanged as o, PageLoaded as p, Box as r, DialogShown as s, Action as t, KeyChanged as u, RecordedEvent as v, TrackPerformed as w, SubjectContext as x, SessionEnding as y };
+//# sourceMappingURL=BrowserEvent-DzdNdvoh.d.mts.map