effect-browser 0.0.0-reserved.0 → 0.2.0-beta.1

package/dist/CaptureData-B5-mXlyq.mjs

@@ -0,0 +1,180 @@
+import { BrowserError } from "./Errors.mjs";
+import { PageInfo, Target } from "./BrowserData.mjs";
+import { Schema } from "effect";
+//#region src/internal/capture/Options.ts
+const Dimension = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 16384
+}));
+const BufferedBytes = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 67108864
+}));
+/**
+* Upper bounds of one interval. Frames can be held for as long as a consumer delays them, so the
+* frame bound is set by memory (the byte bound), not by a short hand-off; an interval can last
+* as long as a session may.
+*/
+const CaptureMaxima = Object.freeze({
+	frames: 1024,
+	durationMillis: 216e5
+});
+/** Defaults shared by runtime admission and the optional public data schema. */
+const CaptureDefaults = Object.freeze({
+	maxFrames: 4,
+	maxBufferedBytes: 16777216,
+	maxFrameBytes: 4194304,
+	maxDurationMillis: 6e4,
+	quality: 80
+});
+const LimitFields = {
+	maxFrames: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: CaptureMaxima.frames
+	})),
+	maxBufferedBytes: BufferedBytes,
+	maxFrameBytes: BufferedBytes,
+	maxDurationMillis: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: CaptureMaxima.durationMillis
+	})),
+	quality: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	}))
+};
+const FrameBudget = Schema.makeFilter((value) => (value.maxFrameBytes ?? CaptureDefaults.maxFrameBytes) <= (value.maxBufferedBytes ?? CaptureDefaults.maxBufferedBytes), { message: "A frame must fit within the resolved buffer budget" });
+/** Fully resolved admission values; callers supply the optional public CaptureOptions instead. */
+const CaptureLimits = Schema.Struct(LimitFields).check(FrameBudget);
+//#endregion
+//#region src/CaptureData.ts
+/**
+* Binary frame data, not a live capability or a JSON/thread/Tool value. Decoding validates
+* fields; it does not copy bytes, decode JPEG pixels, prove target authority, or repair clocks.
+* Capture itself owns the byte copy, freezes its shared target identity, and verifies JPEG framing.
+*/
+const CapturedFrame = Schema.Struct({
+	bytes: Schema.Uint8Array.check(Schema.isMinLength(4), Schema.isMaxLength(67108864)),
+	mediaType: Schema.Literal("image/jpeg"),
+	target: Target,
+	sequence: Schema.Natural,
+	/**
+	* Which document of its page this frame was received during: 0 at the start, one more for each
+	* main-frame navigation the interval observed. It is attribution by receipt order, not proof
+	* of whose pixels these are: a frame received just after a navigation can still show the
+	* document before it. Always 0 for an interval that lasts one document.
+	*/
+	document: Schema.Natural,
+	sourceTimeMillis: Schema.Finite.check(Schema.isGreaterThan(0)),
+	sourceClock: Schema.Literal("presentation-unix-millis"),
+	receivedMonotonicNanos: Schema.BigInt,
+	width: Dimension,
+	height: Dimension,
+	viewportWidth: Dimension,
+	viewportHeight: Dimension
+}).check(Schema.makeFilter((frame) => frame.width * frame.height <= 33554432, { message: "Frame geometry exceeds the capture pixel bound" }));
+/** Source-fit request in pixels. Actual JPEG bounds are checked before any frame is delivered. */
+const CaptureSize = Schema.Struct({
+	width: Dimension,
+	height: Dimension
+});
+/** Optional capture data. Defaults are applied at admission, not during schema decoding. */
+const CaptureOptions = Schema.Struct({
+	/** Pin to a page from `session.pages`; omission preserves selected-page behavior. */
+	target: Schema.optionalKey(PageInfo),
+	/**
+	* Frames held until the consumer takes them (4 by default, at most 1024), oldest dropped first
+	* and counted as `overflow`. A consumer that delays its output leaves frames here, so this and
+	* `maxBufferedBytes` are the delay's memory bound.
+	*/
+	maxFrames: Schema.optionalKey(LimitFields.maxFrames),
+	maxBufferedBytes: Schema.optionalKey(LimitFields.maxBufferedBytes),
+	maxFrameBytes: Schema.optionalKey(LimitFields.maxFrameBytes),
+	/** 60 seconds by default, at most six hours: as long as a session may last. */
+	maxDurationMillis: Schema.optionalKey(LimitFields.maxDurationMillis),
+	quality: Schema.optionalKey(LimitFields.quality),
+	/** Source fit only. Does not resize the viewport or impose an FPS cap. */
+	size: Schema.optionalKey(CaptureSize),
+	/**
+	* `document`, the default, ends the interval when its page navigates. `page` follows the page
+	* across documents, so a capture started before a navigation covers the loading in between.
+	* It applies to a page's main frame; a capture bound to a child frame still ends with it.
+	*/
+	lifetime: Schema.optionalKey(Schema.Literals(["document", "page"]))
+}).check(FrameBudget);
+/** An address as the browser reported it. One longer than this is recorded as null, not cut. */
+const DocumentUrl = Schema.NullOr(Schema.String.check(Schema.isMaxLength(8192)));
+var CaptureSummary = class extends Schema.Class("BrowserCaptureSummary")({
+	target: Target,
+	reason: Schema.String.check(Schema.isMaxLength(64)),
+	received: Schema.Natural,
+	delivered: Schema.Natural,
+	/** All frames this package omitted; the sum of the four disjoint components below. */
+	discarded: Schema.Natural,
+	/** Evicted by the frame-count or buffered-byte bound. */
+	overflow: Schema.Natural,
+	duplicates: Schema.Natural,
+	/** Arrived after a newer frame was accepted; never reordered in. */
+	late: Schema.Natural,
+	/** Other refused frames, including malformed data, bounds and undelivered scope cleanup. */
+	rejected: Schema.Natural,
+	peakBufferedFrames: Schema.Natural,
+	peakBufferedBytes: Schema.Natural,
+	bufferedFrames: Schema.Natural,
+	bufferedBytes: Schema.Natural,
+	sourceFirstMillis: Schema.NullOr(Schema.Finite),
+	sourceLastMillis: Schema.NullOr(Schema.Finite),
+	/**
+	* The captured frame's address when this interval began watching it: the URL of document 0.
+	* It is read in the same turn the watch is installed, so no navigation can fall between them.
+	*/
+	initialUrl: DocumentUrl,
+	/**
+	* Each main-frame navigation a `page` interval observed, in order, with the last frame
+	* received before it and the address the new document committed. The native screencast is
+	* never restarted for one, so a boundary is not a gap this package introduced; what Chromium
+	* omitted while loading stays `upstreamDrops`. A boundary is the commit. When that navigation
+	* started and when its document finished loading are the caller's to stamp, on this same
+	* clock, around the operation that caused it. A title is page state, not part of a transition.
+	*/
+	documentBoundaries: Schema.Array(Schema.Struct({
+		document: Schema.Natural,
+		observedMonotonicNanos: Schema.BigInt,
+		afterSequence: Schema.NullOr(Schema.Natural),
+		url: DocumentUrl
+	})).check(Schema.isMaxLength(64)),
+	/**
+	* More navigations were observed than are recorded above, so the earliest were let go: the
+	* record keeps the latest 64. Frames still count them all.
+	*/
+	documentBoundariesTruncated: Schema.Boolean,
+	nativeStop: Schema.Literals(["confirmed", "unconfirmed"]),
+	/** Package accounting cannot measure frames omitted by Chromium, transport, or the provider. */
+	upstreamDrops: Schema.Literal("unknown"),
+	error: Schema.optionalKey(BrowserError)
+}) {};
+const { reason: StopReason, nativeStop: NativeStop, ...SnapshotFields } = CaptureSummary.fields;
+/**
+* Host-side metadata at one instant, without reading or waking the page. The boundary prefix
+* and loss counters are the same facts as the final summary, independent of frame consumption.
+* `stopped` means native cleanup settled; buffered frames may still be drained afterwards.
+*/
+var CaptureSnapshot = class extends Schema.Class("BrowserCaptureSnapshot")({
+	...SnapshotFields,
+	phase: Schema.Literals([
+		"capturing",
+		"stopping",
+		"stopped"
+	]),
+	observedMonotonicNanos: Schema.BigInt,
+	/** Keeps counting when the bounded boundary prefix is truncated. */
+	currentDocument: Schema.Natural,
+	/** No reason is reported while the capture still accepts frames. */
+	reason: Schema.NullOr(StopReason),
+	/** Null until the native cleanup attempt settles; unconfirmed never means stopped remotely. */
+	nativeStop: Schema.NullOr(NativeStop)
+}) {};
+//#endregion
+export { CapturedFrame as a, CaptureMaxima as c, CaptureSummary as i, CaptureSize as n, CaptureDefaults as o, CaptureSnapshot as r, CaptureLimits as s, CaptureOptions as t };
+
+//# sourceMappingURL=CaptureData-B5-mXlyq.mjs.map

package/dist/CaptureData-B5-mXlyq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaptureData-B5-mXlyq.mjs","names":[],"sources":["../src/internal/capture/Options.ts","../src/CaptureData.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const Dimension = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 16384 }));\nconst BufferedBytes = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 64 * 1024 * 1024 }));\n\n/**\n * Upper bounds of one interval. Frames can be held for as long as a consumer delays them, so the\n * frame bound is set by memory (the byte bound), not by a short hand-off; an interval can last\n * as long as a session may.\n */\nexport const CaptureMaxima = Object.freeze({ frames: 1024, durationMillis: 21_600_000 });\n\n/** Defaults shared by runtime admission and the optional public data schema. */\nexport const CaptureDefaults = Object.freeze({\n  maxFrames: 4,\n  maxBufferedBytes: 16 * 1024 * 1024,\n  maxFrameBytes: 4 * 1024 * 1024,\n  maxDurationMillis: 60000,\n  quality: 80,\n});\n\nexport const LimitFields = {\n  maxFrames: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: CaptureMaxima.frames })),\n  maxBufferedBytes: BufferedBytes,\n  maxFrameBytes: BufferedBytes,\n  maxDurationMillis: Schema.Int.check(\n    Schema.isBetween({ minimum: 1, maximum: CaptureMaxima.durationMillis }),\n  ),\n  quality: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })),\n};\n\nexport const FrameBudget = Schema.makeFilter(\n  (value: { readonly maxFrameBytes?: number; readonly maxBufferedBytes?: number }) =>\n    (value.maxFrameBytes ?? CaptureDefaults.maxFrameBytes) <=\n    (value.maxBufferedBytes ?? CaptureDefaults.maxBufferedBytes),\n  { message: \"A frame must fit within the resolved buffer budget\" },\n);\n\n/** Fully resolved admission values; callers supply the optional public CaptureOptions instead. */\nexport const CaptureLimits = Schema.Struct(LimitFields).check(FrameBudget);\n","import { Schema } from \"effect\";\n\nimport { PageInfo, Target } from \"./BrowserData.ts\";\nimport { BrowserError } from \"./Errors.ts\";\nimport { Dimension, FrameBudget, LimitFields } from \"./internal/capture/Options.ts\";\n\n/**\n * Binary frame data, not a live capability or a JSON/thread/Tool value. Decoding validates\n * fields; it does not copy bytes, decode JPEG pixels, prove target authority, or repair clocks.\n * Capture itself owns the byte copy, freezes its shared target identity, and verifies JPEG framing.\n */\nexport const CapturedFrame = Schema.Struct({\n  bytes: Schema.Uint8Array.check(Schema.isMinLength(4), Schema.isMaxLength(64 * 1024 * 1024)),\n  mediaType: Schema.Literal(\"image/jpeg\"),\n  target: Target,\n  sequence: Schema.Natural,\n  /**\n   * Which document of its page this frame was received during: 0 at the start, one more for each\n   * main-frame navigation the interval observed. It is attribution by receipt order, not proof\n   * of whose pixels these are: a frame received just after a navigation can still show the\n   * document before it. Always 0 for an interval that lasts one document.\n   */\n  document: Schema.Natural,\n  sourceTimeMillis: Schema.Finite.check(Schema.isGreaterThan(0)),\n  sourceClock: Schema.Literal(\"presentation-unix-millis\"),\n  receivedMonotonicNanos: Schema.BigInt,\n  width: Dimension,\n  height: Dimension,\n  viewportWidth: Dimension,\n  viewportHeight: Dimension,\n}).check(\n  Schema.makeFilter((frame) => frame.width * frame.height <= 33_554_432, {\n    message: \"Frame geometry exceeds the capture pixel bound\",\n  }),\n);\n\nexport type CapturedFrame = typeof CapturedFrame.Type;\n\n/** Source-fit request in pixels. Actual JPEG bounds are checked before any frame is delivered. */\nexport const CaptureSize = Schema.Struct({ width: Dimension, height: Dimension });\n\nexport type CaptureSize = typeof CaptureSize.Type;\n\n/** Optional capture data. Defaults are applied at admission, not during schema decoding. */\nexport const CaptureOptions = Schema.Struct({\n  /** Pin to a page from `session.pages`; omission preserves selected-page behavior. */\n  target: Schema.optionalKey(PageInfo),\n  /**\n   * Frames held until the consumer takes them (4 by default, at most 1024), oldest dropped first\n   * and counted as `overflow`. A consumer that delays its output leaves frames here, so this and\n   * `maxBufferedBytes` are the delay's memory bound.\n   */\n  maxFrames: Schema.optionalKey(LimitFields.maxFrames),\n  maxBufferedBytes: Schema.optionalKey(LimitFields.maxBufferedBytes),\n  maxFrameBytes: Schema.optionalKey(LimitFields.maxFrameBytes),\n  /** 60 seconds by default, at most six hours: as long as a session may last. */\n  maxDurationMillis: Schema.optionalKey(LimitFields.maxDurationMillis),\n  quality: Schema.optionalKey(LimitFields.quality),\n  /** Source fit only. Does not resize the viewport or impose an FPS cap. */\n  size: Schema.optionalKey(CaptureSize),\n  /**\n   * `document`, the default, ends the interval when its page navigates. `page` follows the page\n   * across documents, so a capture started before a navigation covers the loading in between.\n   * It applies to a page's main frame; a capture bound to a child frame still ends with it.\n   */\n  lifetime: Schema.optionalKey(Schema.Literals([\"document\", \"page\"])),\n}).check(FrameBudget);\n\nexport type CaptureOptions = typeof CaptureOptions.Type;\n\n/** An address as the browser reported it. One longer than this is recorded as null, not cut. */\nconst DocumentUrl = Schema.NullOr(Schema.String.check(Schema.isMaxLength(8192)));\n\nexport class CaptureSummary extends Schema.Class<CaptureSummary>(\"BrowserCaptureSummary\")({\n  target: Target,\n  reason: Schema.String.check(Schema.isMaxLength(64)),\n  received: Schema.Natural,\n  delivered: Schema.Natural,\n  /** All frames this package omitted; the sum of the four disjoint components below. */\n  discarded: Schema.Natural,\n  /** Evicted by the frame-count or buffered-byte bound. */\n  overflow: Schema.Natural,\n  duplicates: Schema.Natural,\n  /** Arrived after a newer frame was accepted; never reordered in. */\n  late: Schema.Natural,\n  /** Other refused frames, including malformed data, bounds and undelivered scope cleanup. */\n  rejected: Schema.Natural,\n  peakBufferedFrames: Schema.Natural,\n  peakBufferedBytes: Schema.Natural,\n  bufferedFrames: Schema.Natural,\n  bufferedBytes: Schema.Natural,\n  sourceFirstMillis: Schema.NullOr(Schema.Finite),\n  sourceLastMillis: Schema.NullOr(Schema.Finite),\n  /**\n   * The captured frame's address when this interval began watching it: the URL of document 0.\n   * It is read in the same turn the watch is installed, so no navigation can fall between them.\n   */\n  initialUrl: DocumentUrl,\n  /**\n   * Each main-frame navigation a `page` interval observed, in order, with the last frame\n   * received before it and the address the new document committed. The native screencast is\n   * never restarted for one, so a boundary is not a gap this package introduced; what Chromium\n   * omitted while loading stays `upstreamDrops`. A boundary is the commit. When that navigation\n   * started and when its document finished loading are the caller's to stamp, on this same\n   * clock, around the operation that caused it. A title is page state, not part of a transition.\n   */\n  documentBoundaries: Schema.Array(\n    Schema.Struct({\n      document: Schema.Natural,\n      observedMonotonicNanos: Schema.BigInt,\n      afterSequence: Schema.NullOr(Schema.Natural),\n      url: DocumentUrl,\n    }),\n  ).check(Schema.isMaxLength(64)),\n  /**\n   * More navigations were observed than are recorded above, so the earliest were let go: the\n   * record keeps the latest 64. Frames still count them all.\n   */\n  documentBoundariesTruncated: Schema.Boolean,\n  nativeStop: Schema.Literals([\"confirmed\", \"unconfirmed\"]),\n  /** Package accounting cannot measure frames omitted by Chromium, transport, or the provider. */\n  upstreamDrops: Schema.Literal(\"unknown\"),\n  error: Schema.optionalKey(BrowserError),\n}) {}\n\nconst { reason: StopReason, nativeStop: NativeStop, ...SnapshotFields } = CaptureSummary.fields;\n\n/**\n * Host-side metadata at one instant, without reading or waking the page. The boundary prefix\n * and loss counters are the same facts as the final summary, independent of frame consumption.\n * `stopped` means native cleanup settled; buffered frames may still be drained afterwards.\n */\nexport class CaptureSnapshot extends Schema.Class<CaptureSnapshot>(\"BrowserCaptureSnapshot\")({\n  ...SnapshotFields,\n  phase: Schema.Literals([\"capturing\", \"stopping\", \"stopped\"]),\n  observedMonotonicNanos: Schema.BigInt,\n  /** Keeps counting when the bounded boundary prefix is truncated. */\n  currentDocument: Schema.Natural,\n  /** No reason is reported while the capture still accepts frames. */\n  reason: Schema.NullOr(StopReason),\n  /** Null until the native cleanup attempt settles; unconfirmed never means stopped remotely. */\n  nativeStop: Schema.NullOr(NativeStop),\n}) {}\n"],"mappings":"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"}

package/dist/CaptureData.d.mts

@@ -0,0 +1,157 @@
+import { BrowserError } from "./Errors.mjs";
+import { N as PageInfo, X as Target } from "./BrowserData-CRuxEZcn.mjs";
+import { Schema } from "effect";
+//#region src/CaptureData.d.ts
+/**
+ * Binary frame data, not a live capability or a JSON/thread/Tool value. Decoding validates
+ * fields; it does not copy bytes, decode JPEG pixels, prove target authority, or repair clocks.
+ * Capture itself owns the byte copy, freezes its shared target identity, and verifies JPEG framing.
+ */
+export declare const CapturedFrame: Schema.Struct<{
+  readonly bytes: Schema.Uint8Array;
+  readonly mediaType: Schema.Literal<"image/jpeg">;
+  readonly target: typeof Target;
+  readonly sequence: Schema.Natural;
+  /**
+   * Which document of its page this frame was received during: 0 at the start, one more for each
+   * main-frame navigation the interval observed. It is attribution by receipt order, not proof
+   * of whose pixels these are: a frame received just after a navigation can still show the
+   * document before it. Always 0 for an interval that lasts one document.
+   */
+  readonly document: Schema.Natural;
+  readonly sourceTimeMillis: Schema.Finite;
+  readonly sourceClock: Schema.Literal<"presentation-unix-millis">;
+  readonly receivedMonotonicNanos: Schema.BigInt;
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+  readonly viewportWidth: Schema.Int;
+  readonly viewportHeight: Schema.Int;
+}>;
+export type CapturedFrame = typeof CapturedFrame.Type;
+/** Source-fit request in pixels. Actual JPEG bounds are checked before any frame is delivered. */
+export declare const CaptureSize: Schema.Struct<{
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+}>;
+export type CaptureSize = typeof CaptureSize.Type;
+/** Optional capture data. Defaults are applied at admission, not during schema decoding. */
+export declare const CaptureOptions: Schema.Struct<{
+  /** Pin to a page from `session.pages`; omission preserves selected-page behavior. */
+  readonly target: Schema.optionalKey<typeof PageInfo>;
+  /**
+   * Frames held until the consumer takes them (4 by default, at most 1024), oldest dropped first
+   * and counted as `overflow`. A consumer that delays its output leaves frames here, so this and
+   * `maxBufferedBytes` are the delay's memory bound.
+   */
+  readonly maxFrames: Schema.optionalKey<Schema.Int>;
+  readonly maxBufferedBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxFrameBytes: Schema.optionalKey<Schema.Int>;
+  /** 60 seconds by default, at most six hours: as long as a session may last. */
+  readonly maxDurationMillis: Schema.optionalKey<Schema.Int>;
+  readonly quality: Schema.optionalKey<Schema.Int>;
+  /** Source fit only. Does not resize the viewport or impose an FPS cap. */
+  readonly size: Schema.optionalKey<Schema.Struct<{
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+  }>>;
+  /**
+   * `document`, the default, ends the interval when its page navigates. `page` follows the page
+   * across documents, so a capture started before a navigation covers the loading in between.
+   * It applies to a page's main frame; a capture bound to a child frame still ends with it.
+   */
+  readonly lifetime: Schema.optionalKey<Schema.Literals<readonly ["document", "page"]>>;
+}>;
+export type CaptureOptions = typeof CaptureOptions.Type;
+declare const CaptureSummary_base: Schema.Class<CaptureSummary, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly reason: Schema.String;
+  readonly received: Schema.Natural;
+  readonly delivered: Schema.Natural;
+  /** All frames this package omitted; the sum of the four disjoint components below. */
+  readonly discarded: Schema.Natural;
+  /** Evicted by the frame-count or buffered-byte bound. */
+  readonly overflow: Schema.Natural;
+  readonly duplicates: Schema.Natural;
+  /** Arrived after a newer frame was accepted; never reordered in. */
+  readonly late: Schema.Natural;
+  /** Other refused frames, including malformed data, bounds and undelivered scope cleanup. */
+  readonly rejected: Schema.Natural;
+  readonly peakBufferedFrames: Schema.Natural;
+  readonly peakBufferedBytes: Schema.Natural;
+  readonly bufferedFrames: Schema.Natural;
+  readonly bufferedBytes: Schema.Natural;
+  readonly sourceFirstMillis: Schema.NullOr<Schema.Finite>;
+  readonly sourceLastMillis: Schema.NullOr<Schema.Finite>;
+  /**
+   * The captured frame's address when this interval began watching it: the URL of document 0.
+   * It is read in the same turn the watch is installed, so no navigation can fall between them.
+   */
+  readonly initialUrl: Schema.NullOr<Schema.String>;
+  /**
+   * Each main-frame navigation a `page` interval observed, in order, with the last frame
+   * received before it and the address the new document committed. The native screencast is
+   * never restarted for one, so a boundary is not a gap this package introduced; what Chromium
+   * omitted while loading stays `upstreamDrops`. A boundary is the commit. When that navigation
+   * started and when its document finished loading are the caller's to stamp, on this same
+   * clock, around the operation that caused it. A title is page state, not part of a transition.
+   */
+  readonly documentBoundaries: Schema.$Array<Schema.Struct<{
+    readonly document: Schema.Natural;
+    readonly observedMonotonicNanos: Schema.BigInt;
+    readonly afterSequence: Schema.NullOr<Schema.Natural>;
+    readonly url: Schema.NullOr<Schema.String>;
+  }>>;
+  /**
+   * More navigations were observed than are recorded above, so the earliest were let go: the
+   * record keeps the latest 64. Frames still count them all.
+   */
+  readonly documentBoundariesTruncated: Schema.Boolean;
+  readonly nativeStop: Schema.Literals<readonly ["confirmed", "unconfirmed"]>;
+  /** Package accounting cannot measure frames omitted by Chromium, transport, or the provider. */
+  readonly upstreamDrops: Schema.Literal<"unknown">;
+  readonly error: Schema.optionalKey<typeof BrowserError>;
+}>, {}>;
+export declare class CaptureSummary extends CaptureSummary_base {}
+declare const CaptureSnapshot_base: Schema.Class<CaptureSnapshot, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly received: Schema.Natural;
+  readonly delivered: Schema.Natural;
+  readonly discarded: Schema.Natural;
+  readonly overflow: Schema.Natural;
+  readonly duplicates: Schema.Natural;
+  readonly late: Schema.Natural;
+  readonly rejected: Schema.Natural;
+  readonly peakBufferedFrames: Schema.Natural;
+  readonly peakBufferedBytes: Schema.Natural;
+  readonly bufferedFrames: Schema.Natural;
+  readonly bufferedBytes: Schema.Natural;
+  readonly sourceFirstMillis: Schema.NullOr<Schema.Finite>;
+  readonly sourceLastMillis: Schema.NullOr<Schema.Finite>;
+  readonly initialUrl: Schema.NullOr<Schema.String>;
+  readonly documentBoundaries: Schema.$Array<Schema.Struct<{
+    readonly document: Schema.Natural;
+    readonly observedMonotonicNanos: Schema.BigInt;
+    readonly afterSequence: Schema.NullOr<Schema.Natural>;
+    readonly url: Schema.NullOr<Schema.String>;
+  }>>;
+  readonly documentBoundariesTruncated: Schema.Boolean;
+  readonly upstreamDrops: Schema.Literal<"unknown">;
+  readonly error: Schema.optionalKey<typeof BrowserError>;
+  readonly phase: Schema.Literals<readonly ["capturing", "stopping", "stopped"]>;
+  readonly observedMonotonicNanos: Schema.BigInt;
+  /** Keeps counting when the bounded boundary prefix is truncated. */
+  readonly currentDocument: Schema.Natural;
+  /** No reason is reported while the capture still accepts frames. */
+  readonly reason: Schema.NullOr<Schema.String>;
+  /** Null until the native cleanup attempt settles; unconfirmed never means stopped remotely. */
+  readonly nativeStop: Schema.NullOr<Schema.Literals<readonly ["confirmed", "unconfirmed"]>>;
+}>, {}>;
+/**
+ * Host-side metadata at one instant, without reading or waking the page. The boundary prefix
+ * and loss counters are the same facts as the final summary, independent of frame consumption.
+ * `stopped` means native cleanup settled; buffered frames may still be drained afterwards.
+ */
+export declare class CaptureSnapshot extends CaptureSnapshot_base {}
+//#endregion
+export {};
+//# sourceMappingURL=CaptureData.d.mts.map

package/dist/CaptureData.mjs

@@ -0,0 +1,2 @@
+import { a as CapturedFrame, i as CaptureSummary, n as CaptureSize, r as CaptureSnapshot, t as CaptureOptions } from "./CaptureData-B5-mXlyq.mjs";
+export { CaptureOptions, CaptureSize, CaptureSnapshot, CaptureSummary, CapturedFrame };

package/dist/Chromium.d.mts

@@ -0,0 +1,85 @@
+import { BrowserError, InitializationError } from "./Errors.mjs";
+import { a as BrowserPolicy, et as Viewport, n as AutomationOptions } from "./BrowserData-CRuxEZcn.mjs";
+import { BrowserSession, OpenOptions } from "./Browser.mjs";
+import { Context, Crypto, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
+//#region src/internal/chromium/Data.d.ts
+declare const ChromiumReference_base: Schema.Class<ChromiumReference, Schema.Struct<{
+  readonly provider: Schema.Literal<"chromium">;
+  readonly id: Schema.NonEmptyString;
+}>, {}>;
+/** Identifies this Chromium ownership lifetime, not a reusable endpoint. */
+export declare class ChromiumReference extends ChromiumReference_base {}
+declare const ChromiumCleanupIssue_base: Schema.Class<ChromiumCleanupIssue, Schema.Struct<{
+  readonly step: Schema.Literals<readonly ["fence", "capture", "initialization", "disconnect", "terminate", "profile"]>;
+  readonly reason: Schema.Literals<readonly ["timeout", "failed", "interrupted"]>;
+}>, {}>;
+export declare class ChromiumCleanupIssue extends ChromiumCleanupIssue_base {}
+declare const ChromiumCleanupResult_base: Schema.Class<ChromiumCleanupResult, Schema.Struct<{
+  readonly reference: typeof ChromiumReference;
+  readonly ownership: Schema.Literals<readonly ["owned", "borrowed"]>;
+  readonly connection: Schema.Literals<readonly ["closed", "failed", "not-connected", "pending"]>;
+  readonly process: Schema.Literals<readonly ["terminated", "unknown", "not-owned"]>;
+  readonly issues: Schema.$Array<typeof ChromiumCleanupIssue>;
+}>, {}>;
+/** Connection teardown and observed process exit are separate facts; no provider status exists. */
+export declare class ChromiumCleanupResult extends ChromiumCleanupResult_base {}
+export declare const ChromiumLaunch: Schema.Struct<{
+  readonly executablePath: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly headless: Schema.optionalKey<Schema.Boolean>;
+  /** Enabled by default; a trusted host must explicitly choose a sandbox exception. */
+  readonly chromiumSandbox: Schema.optionalKey<Schema.Boolean>;
+  readonly args: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly proxy: Schema.optionalKey<Schema.Struct<{
+    readonly server: Schema.NonEmptyString;
+    readonly bypass: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>;
+  readonly startupTimeoutMillis: Schema.optionalKey<Schema.Int>;
+}>;
+export type ChromiumLaunch = typeof ChromiumLaunch.Type;
+//#endregion
+//#region src/Chromium.d.ts
+/** Host-only process configuration. Building this layer neither loads Playwright nor starts Chromium. */
+export interface ChromiumOptions extends AutomationOptions {
+  readonly launch?: ChromiumLaunch;
+  readonly viewport?: Viewport;
+  readonly onCleanup?: (result: ChromiumCleanupResult) => Effect.Effect<void>;
+}
+/** An owned or borrowed Chromium lifetime with one modeled browser connection. */
+export interface ChromiumSession<E = never> extends BrowserSession<E> {
+  readonly reference: ChromiumReference;
+  readonly closeChecked: Effect.Effect<ChromiumCleanupResult, BrowserError>;
+  readonly close: Effect.Effect<ChromiumCleanupResult>;
+  readonly cleanupResult: Effect.Effect<Option.Option<ChromiumCleanupResult>>;
+}
+export interface ChromiumAcquisition<E = never> {
+  readonly reference: ChromiumReference;
+  readonly failure: Effect.Effect<never, E | InitializationError>;
+  readonly connect: Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E>;
+  readonly close: Effect.Effect<ChromiumCleanupResult>;
+}
+export interface ChromiumAttachRequest<E = never, R = never> extends OpenOptions<E, R> {
+  readonly policy: BrowserPolicy;
+  /** Resolve this exact target; without it, multiple open pages are an ambiguity error. */
+  readonly target?: {
+    readonly targetId: string;
+  };
+}
+declare const Chromium_base: Context.ServiceClass<Chromium, "effect-browser/Chromium", {
+  readonly acquire: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<ChromiumAcquisition<E>, BrowserError, Scope.Scope | Exclude<R, Scope.Scope>>;
+  readonly launch: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E, Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** A concrete loopback ws://.../devtools/browser/... endpoint; this scope owns only its connection. */
+  readonly attach: <E = never, R = never>(endpoint: Redacted.Redacted<string>, request: ChromiumAttachRequest<E, R>) => Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E, Scope.Scope | Exclude<R, Scope.Scope>>;
+}>;
+export declare class Chromium extends Chromium_base {
+  /** Launch through the configured service; compose with Browser.scoped for supervised ownership. */
+  static launch<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<ChromiumSession<E>, E | BrowserError | InitializationError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Acquire the process lifetime before connecting, using the caller's scope. */
+  static acquire<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<ChromiumAcquisition<E>, BrowserError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Borrow a concrete loopback endpoint; cleanup never terminates its external process. */
+  static attach<E = never, R = never>(endpoint: Redacted.Redacted<string>, request: ChromiumAttachRequest<E, R>): Effect.Effect<ChromiumSession<E>, E | BrowserError | InitializationError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Chromium references, connection ids and handoff tokens come from the required `Crypto`. */
+  static layer(options?: ChromiumOptions): Layer.Layer<Chromium, BrowserError, Crypto.Crypto>;
+}
+//#endregion
+export {};
+//# sourceMappingURL=Chromium.d.mts.map