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

package/dist/Expect.mjs

@@ -0,0 +1,114 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { InvalidRequest } from "./BrowserError.mjs";
+import { s as undispatched } from "./context-B6xr8nVi.mjs";
+import { t as internalsOf } from "./page-B8tUQELg.mjs";
+import { Cause, Duration, Effect, Exit, Option, Schedule } from "effect";
+//#region src/Expect.ts
+/**
+* Expectations: what an action is for, checked on the page, so that an action whose outcome is
+* uncertain is sent again only where it did not take effect. An action that failed after its input
+* went, a `Timeout` or a `Closed` with `dispatched`, may have done what it was for; repeating it
+* blindly may do it twice, such as placing an order twice.
+*
+* An attempt takes its expectation's baseline from the page once, as it begins. Each `run` then
+* checks first: where the expectation holds already, it sends nothing and is `AlreadyDone`.
+* Otherwise it acts, and waits for the expectation: `Done`, or `NotDone` when it did not come in
+* time. An action that fails after its input went is checked too, `Done` if its effect came, and
+* otherwise fails as it did, so a later `run` of the same attempt checks before it acts again,
+* on the same page or on the one a reconnect finds by its id.
+*
+* ```ts
+* const placing = yield* Expect.attempt(page, Expect.appeared({ text: "Order placed" }))
+* const outcome = yield* placing.run(page, (page) => page.click("e12"))
+* // After a Timeout that left `dispatched`, the same call clicks again only if no order shows.
+* ```
+*
+* A query is `Page.find`'s, over the whole document unless it says otherwise, and each check is one
+* call to the page, a wait included; `navigated` reads the page's address and document, at no
+* call. What `changed` compares stays in the page: text, field values and states, focus aside.
+*
+* @since 0.3.0
+*/
+var Expect_exports = /* @__PURE__ */ __exportAll({
+	appeared: () => appeared,
+	attempt: () => attempt,
+	changed: () => changed,
+	gone: () => gone,
+	navigated: () => navigated
+});
+/** Something the query finds. */
+const appeared = (query) => ({
+	_tag: "Appeared",
+	query
+});
+/** Nothing the query finds. */
+const gone = (query) => ({
+	_tag: "Gone",
+	query
+});
+/**
+* What the query finds shows something other than it did as the attempt began: other elements, or
+* their text, values or states.
+*/
+const changed = (query) => ({
+	_tag: "Changed",
+	query
+});
+/**
+* The page is at `url`, the whole address or a pattern; without one, at an address or in a
+* document other than the attempt's first.
+*/
+const navigated = (url) => ({
+	_tag: "Navigated",
+	url
+});
+const refused = (detail) => undispatched("expect", new InvalidRequest({ detail }));
+const internalsFor = (page) => {
+	const internals = internalsOf(page);
+	return internals === void 0 ? Effect.fail(refused("only a page a Browser opened, or a presenter's view of one, can be checked")) : Effect.succeed(internals);
+};
+const atUrl = (url, wanted) => typeof wanted === "string" ? url === wanted : new RegExp(wanted.source, wanted.flags).test(url);
+/** Begin an attempt at `expectation` on `page`, which takes its baseline from the page now. */
+const attempt = Effect.fn("Expect.attempt")(function* (page, expectation, options = {}) {
+	const wait = Duration.fromInput(options.wait ?? Duration.seconds(5));
+	if (Option.isNone(wait) || Duration.isNegative(wait.value)) return yield* refused("wait must be a duration, not negative");
+	const waitMillis = Duration.toMillis(wait.value);
+	const first = yield* page.state;
+	const internals = yield* internalsFor(page);
+	const from = expectation._tag === "Changed" ? (yield* internals.until(expectation.query, "some", 0)).mark : void 0;
+	const navigatedOn = (target, url) => Effect.map(target.state, (now) => url !== void 0 ? atUrl(now.url, url) : now.url !== first.url || internalsOf(target) === internals && now.document !== first.document);
+	const holdsWithin = (target, millis) => {
+		if (expectation._tag === "Navigated") {
+			const look = navigatedOn(target, expectation.url);
+			return look.pipe(Effect.repeat({
+				until: (held) => held,
+				schedule: Schedule.spaced(Duration.millis(50))
+			}), Effect.timeoutOrElse({
+				duration: Duration.millis(millis),
+				orElse: () => look
+			}));
+		}
+		const want = expectation._tag === "Appeared" ? "some" : expectation._tag === "Gone" ? "none" : { other: from ?? "" };
+		return internalsFor(target).pipe(Effect.flatMap((own) => own.until(expectation.query, want, millis)), Effect.map(({ met }) => met));
+	};
+	return {
+		expectation,
+		holds: (target) => holdsWithin(target, 0),
+		run: Effect.fn("Expect.run")(function* (target, act) {
+			if (yield* holdsWithin(target, 0)) return "AlreadyDone";
+			const acted = yield* Effect.exit(act(target));
+			if (Exit.isSuccess(acted)) return (yield* holdsWithin(target, waitMillis)) ? "Done" : "NotDone";
+			const error = Cause.findErrorOption(acted.cause);
+			if (Option.isNone(error) || !error.value.dispatched) return yield* Effect.failCause(acted.cause);
+			const held = yield* Effect.exit(holdsWithin(target, waitMillis));
+			return Exit.isSuccess(held) && held.value ? "Done" : yield* Effect.failCause(acted.cause);
+		}, Effect.tap((outcome) => Effect.annotateCurrentSpan({
+			expectation: expectation._tag,
+			outcome
+		})))
+	};
+});
+//#endregion
+export { appeared, attempt, changed, gone, navigated, Expect_exports as t };
+
+//# sourceMappingURL=Expect.mjs.map

package/dist/Expect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expect.mjs","names":[],"sources":["../src/Expect.ts"],"sourcesContent":["/**\n * Expectations: what an action is for, checked on the page, so that an action whose outcome is\n * uncertain is sent again only where it did not take effect. An action that failed after its input\n * went, a `Timeout` or a `Closed` with `dispatched`, may have done what it was for; repeating it\n * blindly may do it twice, such as placing an order twice.\n *\n * An attempt takes its expectation's baseline from the page once, as it begins. Each `run` then\n * checks first: where the expectation holds already, it sends nothing and is `AlreadyDone`.\n * Otherwise it acts, and waits for the expectation: `Done`, or `NotDone` when it did not come in\n * time. An action that fails after its input went is checked too, `Done` if its effect came, and\n * otherwise fails as it did, so a later `run` of the same attempt checks before it acts again,\n * on the same page or on the one a reconnect finds by its id.\n *\n * ```ts\n * const placing = yield* Expect.attempt(page, Expect.appeared({ text: \"Order placed\" }))\n * const outcome = yield* placing.run(page, (page) => page.click(\"e12\"))\n * // After a Timeout that left `dispatched`, the same call clicks again only if no order shows.\n * ```\n *\n * A query is `Page.find`'s, over the whole document unless it says otherwise, and each check is one\n * call to the page, a wait included; `navigated` reads the page's address and document, at no\n * call. What `changed` compares stays in the page: text, field values and states, focus aside.\n *\n * @since 0.3.0\n */\nimport { Cause, Duration, Effect, Exit, Option, Schedule } from \"effect\";\n\nimport { type BrowserError, InvalidRequest } from \"./BrowserError.ts\";\nimport { undispatched } from \"./internal/page/context.ts\";\nimport { type Internals, internalsOf } from \"./internal/page/page.ts\";\nimport type { FindQuery, Page } from \"./Page.ts\";\n\n/** What an action is for, as the page can tell it. */\nexport type Expectation =\n  | { readonly _tag: \"Appeared\"; readonly query: FindQuery }\n  | { readonly _tag: \"Gone\"; readonly query: FindQuery }\n  | { readonly _tag: \"Changed\"; readonly query: FindQuery }\n  | { readonly _tag: \"Navigated\"; readonly url: string | RegExp | undefined };\n\n/** Something the query finds. */\nexport const appeared = (query: FindQuery): Expectation => ({ _tag: \"Appeared\", query });\n\n/** Nothing the query finds. */\nexport const gone = (query: FindQuery): Expectation => ({ _tag: \"Gone\", query });\n\n/**\n * What the query finds shows something other than it did as the attempt began: other elements, or\n * their text, values or states.\n */\nexport const changed = (query: FindQuery): Expectation => ({ _tag: \"Changed\", query });\n\n/**\n * The page is at `url`, the whole address or a pattern; without one, at an address or in a\n * document other than the attempt's first.\n */\nexport const navigated = (url?: string | RegExp): Expectation => ({ _tag: \"Navigated\", url });\n\n/**\n * `Done`: the action ran, and what it was for came. `AlreadyDone`: it held before the action was\n * sent, so it was not. `NotDone`: the action ran, and it did not come within the attempt's wait.\n */\nexport type Outcome = \"Done\" | \"AlreadyDone\" | \"NotDone\";\n\nexport interface Options {\n  /** How long an action's effect may take to show. Defaults to 5 seconds. */\n  readonly wait?: Duration.Input | undefined;\n}\n\nexport interface Attempt {\n  readonly expectation: Expectation;\n  /** Whether the expectation holds on `page` now. */\n  readonly holds: (page: Page) => Effect.Effect<boolean, BrowserError>;\n  /**\n   * `act` on `page`, unless the expectation holds there already: see the module's comment. A\n   * failure before its input went is the action's own, and nothing is checked.\n   */\n  readonly run: (\n    page: Page,\n    act: (page: Page) => Effect.Effect<unknown, BrowserError>,\n  ) => Effect.Effect<Outcome, BrowserError>;\n}\n\nconst refused = (detail: string) => undispatched(\"expect\", new InvalidRequest({ detail }));\n\nconst internalsFor = (page: Page): Effect.Effect<Internals, BrowserError> => {\n  const internals = internalsOf(page);\n\n  return internals === undefined\n    ? Effect.fail(\n        refused(\"only a page a Browser opened, or a presenter's view of one, can be checked\"),\n      )\n    : Effect.succeed(internals);\n};\n\nconst atUrl = (url: string, wanted: string | RegExp) =>\n  typeof wanted === \"string\" ? url === wanted : new RegExp(wanted.source, wanted.flags).test(url);\n\n/** Begin an attempt at `expectation` on `page`, which takes its baseline from the page now. */\nexport const attempt = Effect.fn(\"Expect.attempt\")(function* (\n  page: Page,\n  expectation: Expectation,\n  options: Options = {},\n) {\n  const wait = Duration.fromInput(options.wait ?? Duration.seconds(5));\n\n  if (Option.isNone(wait) || Duration.isNegative(wait.value))\n    return yield* refused(\"wait must be a duration, not negative\");\n  const waitMillis = Duration.toMillis(wait.value);\n  const first = yield* page.state;\n  const internals = yield* internalsFor(page);\n\n  // What `changed` compares with: the mark of what the query found as the attempt began.\n  const from =\n    expectation._tag === \"Changed\"\n      ? (yield* internals.until(expectation.query, \"some\", 0)).mark\n      : undefined;\n\n  // Navigated: at the address asked, or, without one, somewhere other than the attempt's first,\n  // where a document counts only on the page that counted it, not on one a reconnect found.\n  const navigatedOn = (target: Page, url: string | RegExp | undefined) =>\n    Effect.map(target.state, (now) =>\n      url !== undefined\n        ? atUrl(now.url, url)\n        : now.url !== first.url ||\n          (internalsOf(target) === internals && now.document !== first.document),\n    );\n\n  const holdsWithin = (target: Page, millis: number): Effect.Effect<boolean, BrowserError> => {\n    if (expectation._tag === \"Navigated\") {\n      const look = navigatedOn(target, expectation.url);\n\n      return look.pipe(\n        Effect.repeat({\n          until: (held) => held,\n          schedule: Schedule.spaced(Duration.millis(50)),\n        }),\n        Effect.timeoutOrElse({ duration: Duration.millis(millis), orElse: () => look }),\n      );\n    }\n\n    const want =\n      expectation._tag === \"Appeared\"\n        ? \"some\"\n        : expectation._tag === \"Gone\"\n          ? \"none\"\n          : { other: from ?? \"\" };\n\n    return internalsFor(target).pipe(\n      Effect.flatMap((own) => own.until(expectation.query, want, millis)),\n      Effect.map(({ met }) => met),\n    );\n  };\n\n  const run = Effect.fn(\"Expect.run\")(\n    function* (target: Page, act: (page: Page) => Effect.Effect<unknown, BrowserError>) {\n      if (yield* holdsWithin(target, 0)) return \"AlreadyDone\" as const;\n      const acted = yield* Effect.exit(act(target));\n\n      if (Exit.isSuccess(acted))\n        return (yield* holdsWithin(target, waitMillis)) ? (\"Done\" as const) : (\"NotDone\" as const);\n      const error = Cause.findErrorOption(acted.cause);\n\n      // A failure before the input went did nothing; one after it may have done what it was for.\n      if (Option.isNone(error) || !error.value.dispatched)\n        return yield* Effect.failCause(acted.cause);\n      const held = yield* Effect.exit(holdsWithin(target, waitMillis));\n\n      return Exit.isSuccess(held) && held.value\n        ? (\"Done\" as const)\n        : yield* Effect.failCause(acted.cause);\n    },\n    Effect.tap((outcome) => Effect.annotateCurrentSpan({ expectation: expectation._tag, outcome })),\n  );\n\n  return {\n    expectation,\n    holds: (target) => holdsWithin(target, 0),\n    run,\n  } satisfies Attempt;\n});\n"],"mappings":"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"}

package/dist/Frame-BERmf_gM.d.mts

@@ -0,0 +1,117 @@
+import { Schema } from "effect";
+declare namespace Frame_d_exports {
+  export { BrowserPaint, CaptureStats, Frame, Image, ScreencastOptions, Screenshot };
+}
+declare const Image_base: Schema.Class<Image, Schema.Struct<{
+  readonly data: Schema.Uint8Array;
+  readonly mediaType: Schema.Literals<readonly ["image/jpeg", "image/png"]>;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+}>, {}>;
+/** An encoded picture with its pixel dimensions. Crops also need their viewport origin. */
+declare class Image extends Image_base {}
+declare const BrowserPaint_base: Schema.Class<BrowserPaint, Schema.TaggedStruct<"BrowserPaint", {
+  readonly timestamp: Schema.Finite;
+  readonly hostTime: Schema.Finite;
+  readonly uncertaintyMillis: Schema.Finite;
+}>, {}>;
+/** Native CDP paint time mapped to the owning host clock, with transport uncertainty retained. */
+declare class BrowserPaint extends BrowserPaint_base {}
+declare const Screenshot_base: Schema.Class<Screenshot, Schema.TaggedStruct<"Screenshot", {
+  readonly hostTime: Schema.Finite;
+  readonly uncertaintyMillis: Schema.Finite;
+}>, {}>;
+/** A screenshot's host capture interval; it has no native browser paint timestamp. */
+declare class Screenshot extends Screenshot_base {}
+declare const Frame_base: Schema.Class<Frame, Schema.Struct<{
+  readonly page: Schema.String;
+  /** The page's browser session: its provider's session id, as `Browser.Service.id` gives it. */
+  readonly session: Schema.String;
+  readonly data: Schema.Uint8Array;
+  readonly timing: Schema.Union<readonly [typeof BrowserPaint, typeof Screenshot]>;
+  readonly receivedAt: Schema.Finite;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+  /**
+   * The page's document committed before the frame arrived, as `Navigated` counts them. Just
+   * after a commit a browser can still show the old document's paint, so a frame may show the
+   * document before its own, never one after it.
+   */
+  readonly document: Schema.Int;
+  /** The page's address when the frame arrived. */
+  readonly url: Schema.String;
+}>, {}>;
+/**
+ * An image and its timing evidence. Paint time and screenshot capture time cannot be confused in
+ * serialized data. `receivedAt` records delivery on the owning host's monotonic clock; it does
+ * not make an old paint current.
+ */
+declare class Frame extends Frame_base {
+  get timestamp(): number | undefined;
+  get hostTime(): number;
+  get image(): Image;
+}
+declare const CaptureStats_base: Schema.Class<CaptureStats, Schema.Struct<{
+  readonly received: Schema.Int;
+  readonly accepted: Schema.Int;
+  /**
+   * Frames Chromium finished encoding after a newer one, dropped rather than reordered. It encodes
+   * several at once, so a busy machine makes more of them; none was a paint readers missed.
+   */
+  readonly late: Schema.Int;
+  readonly missingTimestamp: Schema.Int;
+  /**
+   * Frames dropped for their size. Most are other captures' frames, which a clipped screenshot
+   * draws into a screencast. The rest are the page's own frames of a new size, dropped while still
+   * unconfirmed: when another size replaced it, when its capture stopped, or beyond the 16 held.
+   */
+  readonly foreignSize: Schema.Int;
+  /**
+   * Frames dropped because they may have been painted, or arrived, while the library took a clipped
+   * or scaled picture of the page, such as a zoom: Chromium draws those into the screencast too.
+   * Where Playwright emulates the viewport, the page's own frames from that time are among them; a
+   * crop on the page's own session leaves out only frames of another size than the page's.
+   */
+  readonly duringPictures: Schema.Int;
+  /**
+   * Frames a reader missed by falling behind. Each reader counts its own, so with several readers
+   * this can exceed the frames accepted.
+   */
+  readonly lost: Schema.Int;
+  /**
+   * Acknowledgements of frames sent and not yet answered, now, whatever the window. Chromium sends
+   * a frame only while few are unacknowledged, so a backlog means fewer frames.
+   */
+  readonly ackBacklog: Schema.Int;
+  /** Paint-time gaps between consecutive accepted frames. */
+  readonly gaps: Schema.Struct<{
+    readonly count: Schema.Int;
+    readonly totalMillis: Schema.Finite;
+    readonly minMillis: Schema.NullOr<Schema.Finite>;
+    readonly maxMillis: Schema.NullOr<Schema.Finite>;
+    readonly lastMillis: Schema.NullOr<Schema.Finite>;
+  }>;
+}>, {}>;
+/**
+ * A page's capture counts, over its life or a window of the latest minute: what Chromium sent,
+ * what readers got, and why the rest went no further. Frames that came late are counted apart from
+ * those a reader lost.
+ */
+declare class CaptureStats extends CaptureStats_base {}
+/**
+ * Settings for a page's one native capture. Readers that join a running capture share its
+ * settings: one without options accepts them, and one whose explicit options differ fails with
+ * `InvalidRequest`.
+ */
+interface ScreencastOptions {
+  /** JPEG quality, 0 to 100. Defaults to 80. */
+  readonly quality?: number | undefined;
+  /** Frames are scaled down to fit this box. Defaults to the viewport in CSS pixels. */
+  readonly size?: {
+    readonly width: number;
+    readonly height: number;
+  } | undefined;
+}
+//#endregion
+export { Image as a, Frame_d_exports as i, CaptureStats as n, ScreencastOptions as o, Frame as r, Screenshot as s, BrowserPaint as t };
+//# sourceMappingURL=Frame-BERmf_gM.d.mts.map

package/dist/Frame.d.mts

@@ -0,0 +1,2 @@
+import { a as Image, n as CaptureStats, o as ScreencastOptions, r as Frame, s as Screenshot, t as BrowserPaint } from "./Frame-BERmf_gM.mjs";
+export { BrowserPaint, CaptureStats, Frame, Image, ScreencastOptions, Screenshot };

package/dist/Frame.mjs

@@ -0,0 +1,123 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Schema } from "effect";
+//#region src/Frame.ts
+/**
+* Pictures of a page: screenshots, and screencast frames stamped with the browser's clock.
+*
+* @since 0.3.0
+*/
+var Frame_exports = /* @__PURE__ */ __exportAll({
+	BrowserPaint: () => BrowserPaint,
+	CaptureStats: () => CaptureStats,
+	Frame: () => Frame,
+	Image: () => Image,
+	Screenshot: () => Screenshot
+});
+/** An encoded picture with its pixel dimensions. Crops also need their viewport origin. */
+var Image = class extends Schema.Class("effect-browser/Image")({
+	data: Schema.Uint8Array,
+	mediaType: Schema.Literals(["image/jpeg", "image/png"]),
+	width: Schema.Finite,
+	height: Schema.Finite
+}) {};
+const Nonnegative = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+/** Native CDP paint time mapped to the owning host clock, with transport uncertainty retained. */
+var BrowserPaint = class extends Schema.TaggedClass()("BrowserPaint", {
+	timestamp: Schema.Finite,
+	hostTime: Schema.Finite,
+	uncertaintyMillis: Nonnegative
+}) {};
+/** A screenshot's host capture interval; it has no native browser paint timestamp. */
+var Screenshot = class extends Schema.TaggedClass()("Screenshot", {
+	hostTime: Schema.Finite,
+	uncertaintyMillis: Nonnegative
+}) {};
+/**
+* An image and its timing evidence. Paint time and screenshot capture time cannot be confused in
+* serialized data. `receivedAt` records delivery on the owning host's monotonic clock; it does
+* not make an old paint current.
+*/
+var Frame = class extends Schema.Class("effect-browser/Frame")({
+	page: Schema.String,
+	/** The page's browser session: its provider's session id, as `Browser.Service.id` gives it. */
+	session: Schema.String,
+	data: Schema.Uint8Array,
+	timing: Schema.Union([BrowserPaint, Screenshot]),
+	receivedAt: Schema.Finite,
+	width: Schema.Finite,
+	height: Schema.Finite,
+	/**
+	* The page's document committed before the frame arrived, as `Navigated` counts them. Just
+	* after a commit a browser can still show the old document's paint, so a frame may show the
+	* document before its own, never one after it.
+	*/
+	document: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	/** The page's address when the frame arrived. */
+	url: Schema.String
+}) {
+	get timestamp() {
+		return this.timing._tag === "BrowserPaint" ? this.timing.timestamp : void 0;
+	}
+	get hostTime() {
+		return this.timing.hostTime;
+	}
+	get image() {
+		return new Image({
+			data: this.data,
+			mediaType: "image/jpeg",
+			width: this.width,
+			height: this.height
+		});
+	}
+};
+/**
+* A page's capture counts, over its life or a window of the latest minute: what Chromium sent,
+* what readers got, and why the rest went no further. Frames that came late are counted apart from
+* those a reader lost.
+*/
+var CaptureStats = class extends Schema.Class("effect-browser/CaptureStats")({
+	received: Count,
+	accepted: Count,
+	/**
+	* Frames Chromium finished encoding after a newer one, dropped rather than reordered. It encodes
+	* several at once, so a busy machine makes more of them; none was a paint readers missed.
+	*/
+	late: Count,
+	missingTimestamp: Count,
+	/**
+	* Frames dropped for their size. Most are other captures' frames, which a clipped screenshot
+	* draws into a screencast. The rest are the page's own frames of a new size, dropped while still
+	* unconfirmed: when another size replaced it, when its capture stopped, or beyond the 16 held.
+	*/
+	foreignSize: Count,
+	/**
+	* Frames dropped because they may have been painted, or arrived, while the library took a clipped
+	* or scaled picture of the page, such as a zoom: Chromium draws those into the screencast too.
+	* Where Playwright emulates the viewport, the page's own frames from that time are among them; a
+	* crop on the page's own session leaves out only frames of another size than the page's.
+	*/
+	duringPictures: Count,
+	/**
+	* Frames a reader missed by falling behind. Each reader counts its own, so with several readers
+	* this can exceed the frames accepted.
+	*/
+	lost: Count,
+	/**
+	* Acknowledgements of frames sent and not yet answered, now, whatever the window. Chromium sends
+	* a frame only while few are unacknowledged, so a backlog means fewer frames.
+	*/
+	ackBacklog: Count,
+	/** Paint-time gaps between consecutive accepted frames. */
+	gaps: Schema.Struct({
+		count: Count,
+		totalMillis: Nonnegative,
+		minMillis: Schema.NullOr(Nonnegative),
+		maxMillis: Schema.NullOr(Nonnegative),
+		lastMillis: Schema.NullOr(Nonnegative)
+	})
+}) {};
+//#endregion
+export { BrowserPaint, CaptureStats, Frame, Image, Screenshot, Frame_exports as t };
+
+//# sourceMappingURL=Frame.mjs.map

package/dist/Frame.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Frame.mjs","names":[],"sources":["../src/Frame.ts"],"sourcesContent":["/**\n * Pictures of a page: screenshots, and screencast frames stamped with the browser's clock.\n *\n * @since 0.3.0\n */\nimport { Schema } from \"effect\";\n\n/** An encoded picture with its pixel dimensions. Crops also need their viewport origin. */\nexport class Image extends Schema.Class<Image>(\"effect-browser/Image\")({\n  data: Schema.Uint8Array,\n  mediaType: Schema.Literals([\"image/jpeg\", \"image/png\"]),\n  width: Schema.Finite,\n  height: Schema.Finite,\n}) {}\n\nconst Nonnegative = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));\nconst Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));\n\n/** Native CDP paint time mapped to the owning host clock, with transport uncertainty retained. */\nexport class BrowserPaint extends Schema.TaggedClass<BrowserPaint>()(\"BrowserPaint\", {\n  timestamp: Schema.Finite,\n  hostTime: Schema.Finite,\n  uncertaintyMillis: Nonnegative,\n}) {}\n\n/** A screenshot's host capture interval; it has no native browser paint timestamp. */\nexport class Screenshot extends Schema.TaggedClass<Screenshot>()(\"Screenshot\", {\n  hostTime: Schema.Finite,\n  uncertaintyMillis: Nonnegative,\n}) {}\n\n/**\n * An image and its timing evidence. Paint time and screenshot capture time cannot be confused in\n * serialized data. `receivedAt` records delivery on the owning host's monotonic clock; it does\n * not make an old paint current.\n */\nexport class Frame extends Schema.Class<Frame>(\"effect-browser/Frame\")({\n  page: Schema.String,\n  /** The page's browser session: its provider's session id, as `Browser.Service.id` gives it. */\n  session: Schema.String,\n  data: Schema.Uint8Array,\n  timing: Schema.Union([BrowserPaint, Screenshot]),\n  receivedAt: Schema.Finite,\n  width: Schema.Finite,\n  height: Schema.Finite,\n  /**\n   * The page's document committed before the frame arrived, as `Navigated` counts them. Just\n   * after a commit a browser can still show the old document's paint, so a frame may show the\n   * document before its own, never one after it.\n   */\n  document: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  /** The page's address when the frame arrived. */\n  url: Schema.String,\n}) {\n  get timestamp(): number | undefined {\n    return this.timing._tag === \"BrowserPaint\" ? this.timing.timestamp : undefined;\n  }\n\n  get hostTime(): number {\n    return this.timing.hostTime;\n  }\n\n  get image(): Image {\n    return new Image({\n      data: this.data,\n      mediaType: \"image/jpeg\",\n      width: this.width,\n      height: this.height,\n    });\n  }\n}\n\n/**\n * A page's capture counts, over its life or a window of the latest minute: what Chromium sent,\n * what readers got, and why the rest went no further. Frames that came late are counted apart from\n * those a reader lost.\n */\nexport class CaptureStats extends Schema.Class<CaptureStats>(\"effect-browser/CaptureStats\")({\n  received: Count,\n  accepted: Count,\n  /**\n   * Frames Chromium finished encoding after a newer one, dropped rather than reordered. It encodes\n   * several at once, so a busy machine makes more of them; none was a paint readers missed.\n   */\n  late: Count,\n  missingTimestamp: Count,\n  /**\n   * Frames dropped for their size. Most are other captures' frames, which a clipped screenshot\n   * draws into a screencast. The rest are the page's own frames of a new size, dropped while still\n   * unconfirmed: when another size replaced it, when its capture stopped, or beyond the 16 held.\n   */\n  foreignSize: Count,\n  /**\n   * Frames dropped because they may have been painted, or arrived, while the library took a clipped\n   * or scaled picture of the page, such as a zoom: Chromium draws those into the screencast too.\n   * Where Playwright emulates the viewport, the page's own frames from that time are among them; a\n   * crop on the page's own session leaves out only frames of another size than the page's.\n   */\n  duringPictures: Count,\n  /**\n   * Frames a reader missed by falling behind. Each reader counts its own, so with several readers\n   * this can exceed the frames accepted.\n   */\n  lost: Count,\n  /**\n   * Acknowledgements of frames sent and not yet answered, now, whatever the window. Chromium sends\n   * a frame only while few are unacknowledged, so a backlog means fewer frames.\n   */\n  ackBacklog: Count,\n  /** Paint-time gaps between consecutive accepted frames. */\n  gaps: Schema.Struct({\n    count: Count,\n    totalMillis: Nonnegative,\n    minMillis: Schema.NullOr(Nonnegative),\n    maxMillis: Schema.NullOr(Nonnegative),\n    lastMillis: Schema.NullOr(Nonnegative),\n  }),\n}) {}\n\n/**\n * Settings for a page's one native capture. Readers that join a running capture share its\n * settings: one without options accepts them, and one whose explicit options differ fails with\n * `InvalidRequest`.\n */\nexport interface ScreencastOptions {\n  /** JPEG quality, 0 to 100. Defaults to 80. */\n  readonly quality?: number | undefined;\n  /** Frames are scaled down to fit this box. Defaults to the viewport in CSS pixels. */\n  readonly size?: { readonly width: number; readonly height: number } | undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAQA,IAAa,QAAb,cAA2B,OAAO,MAAa,sBAAsB,CAAC,CAAC;CACrE,MAAM,OAAO;CACb,WAAW,OAAO,SAAS,CAAC,cAAc,WAAW,CAAC;CACtD,OAAO,OAAO;CACd,QAAQ,OAAO;AACjB,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAM,cAAc,OAAO,OAAO,MAAM,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,QAAQ,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;;AAG/D,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,gBAAgB;CACnF,WAAW,OAAO;CAClB,UAAU,OAAO;CACjB,mBAAmB;AACrB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,aAAb,cAAgC,OAAO,YAAwB,CAAC,CAAC,cAAc;CAC7E,UAAU,OAAO;CACjB,mBAAmB;AACrB,CAAC,CAAC,CAAC,CAAC;;;;;;AAOJ,IAAa,QAAb,cAA2B,OAAO,MAAa,sBAAsB,CAAC,CAAC;CACrE,MAAM,OAAO;;CAEb,SAAS,OAAO;CAChB,MAAM,OAAO;CACb,QAAQ,OAAO,MAAM,CAAC,cAAc,UAAU,CAAC;CAC/C,YAAY,OAAO;CACnB,OAAO,OAAO;CACd,QAAQ,OAAO;;;;;;CAMf,UAAU,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;;CAE3D,KAAK,OAAO;AACd,CAAC,CAAC,CAAC;CACD,IAAI,YAAgC;EAClC,OAAO,KAAK,OAAO,SAAS,iBAAiB,KAAK,OAAO,YAAY,KAAA;CACvE;CAEA,IAAI,WAAmB;EACrB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,QAAe;EACjB,OAAO,IAAI,MAAM;GACf,MAAM,KAAK;GACX,WAAW;GACX,OAAO,KAAK;GACZ,QAAQ,KAAK;EACf,CAAC;CACH;AACF;;;;;;AAOA,IAAa,eAAb,cAAkC,OAAO,MAAoB,6BAA6B,CAAC,CAAC;CAC1F,UAAU;CACV,UAAU;;;;;CAKV,MAAM;CACN,kBAAkB;;;;;;CAMlB,aAAa;;;;;;;CAOb,gBAAgB;;;;;CAKhB,MAAM;;;;;CAKN,YAAY;;CAEZ,MAAM,OAAO,OAAO;EAClB,OAAO;EACP,aAAa;EACb,WAAW,OAAO,OAAO,WAAW;EACpC,WAAW,OAAO,OAAO,WAAW;EACpC,YAAY,OAAO,OAAO,WAAW;CACvC,CAAC;AACH,CAAC,CAAC,CAAC,CAAC"}

package/dist/Moment.d.mts

@@ -0,0 +1,2 @@
+import { A as Account, F as account, I as capture, L as toPrompt, M as Moment, P as Window, j as CaptureOptions } from "./Page-BlPjfibv.mjs";
+export { Account, CaptureOptions, Moment, Window, account, capture, toPrompt };