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

package/dist/Errors.d.mts

@@ -1,158 +0,0 @@
-import { Schema } from "effect";
-//#region src/Errors.d.ts
-/**
- * What a caller asked the owned browser to do. The vocabulary is closed: the owner stamps it
- * when it admits an operation, so a native step's own name can never become API, and a new
- * spelling is a deliberate edit here rather than a string that merely compiles.
- */
-export declare const BrowserOperation: Schema.Literals<readonly ["configure", "launch", "connect", "reconnect", "detach", "disconnect", "close", "handoff", "resume", "live-view", "target", "handle", "list-pages", "describe-page", "list-frames", "select-page", "new-page", "close-page", "resize", "ready", "observe", "checkpoint", "control-facts", "revalidate", "read-text", "screenshot", "wait", "resolve", "run", "settled", "navigate", "navigate-stop", "click", "fill", "fill-form", "select-option", "scroll", "click-and-wait", "download-action", "select-files", "file-chooser", "action-result", "pointer-move", "hover", "wheel", "press", "type", "page-control", "page-state", "page-suspend", "page-resume", "capture", "capture-start", "capture-stop", "capture-consume"]>;
-export type BrowserOperation = typeof BrowserOperation.Type;
-/** Dispatch evidence belongs to the operation, independently of its failure reason. */
-export declare const BrowserOutcome: Schema.Literals<readonly ["undispatched", "rejected", "performed", "unknown"]>;
-export type BrowserOutcome = typeof BrowserOutcome.Type;
-/** Limits report measured producer facts; an unavailable measurement is never invented. */
-export declare const LimitDimension: Schema.Literals<readonly ["runs", "actions", "elapsed", "returned-bytes", "pages", "frames", "frame-depth", "buffered-frames", "buffered-bytes", "host-reads", "controls", "text", "code-points", "captures", "frame-bytes", "width", "height", "pixels", "observation-snapshots", "observation-handles", "observation-bytes", "native-operations"]>;
-/** Validated constructors for host reasons. The model receives a separate bounded projection. */
-export declare const Reasons: {
-  readonly Configuration: Schema.TaggedStruct<"Configuration", {
-    readonly path: Schema.optionalKey<Schema.String>;
-  }>;
-  readonly UnregisteredSession: Schema.TaggedStruct<"UnregisteredSession", {}>;
-  readonly Unsupported: Schema.TaggedStruct<"Unsupported", {}>;
-  readonly Busy: Schema.TaggedStruct<"Busy", {}>;
-  readonly QueueFull: Schema.TaggedStruct<"QueueFull", {
-    readonly scope: Schema.Literals<readonly ["page", "session", "registry"]>;
-    readonly maximum: Schema.Natural;
-    readonly observed: Schema.Natural;
-  }>;
-  readonly QueueExpired: Schema.TaggedStruct<"QueueExpired", {}>;
-  readonly Closed: Schema.TaggedStruct<"Closed", {}>;
-  readonly Stale: Schema.TaggedStruct<"Stale", {}>;
-  readonly NotFound: Schema.TaggedStruct<"NotFound", {}>;
-  readonly Missing: Schema.TaggedStruct<"Missing", {}>;
-  readonly Ambiguous: Schema.TaggedStruct<"Ambiguous", {
-    readonly count: Schema.optionalKey<Schema.Natural>;
-  }>;
-  readonly Incomplete: Schema.TaggedStruct<"Incomplete", {}>;
-  readonly Drifted: Schema.TaggedStruct<"Drifted", {}>;
-  readonly Malformed: Schema.TaggedStruct<"Malformed", {
-    readonly path: Schema.optionalKey<Schema.String>;
-  }>;
-  readonly Limit: Schema.TaggedStruct<"Limit", {
-    readonly dimension: Schema.Literals<readonly ["runs", "actions", "elapsed", "returned-bytes", "pages", "frames", "frame-depth", "buffered-frames", "buffered-bytes", "host-reads", "controls", "text", "code-points", "captures", "frame-bytes", "width", "height", "pixels", "observation-snapshots", "observation-handles", "observation-bytes", "native-operations"]>;
-    readonly maximum: Schema.Natural;
-    readonly observed: Schema.Natural;
-  }>;
-  readonly Timeout: Schema.TaggedStruct<"Timeout", {}>;
-  readonly ScheduleMissed: Schema.TaggedStruct<"ScheduleMissed", {}>;
-  readonly TimingBudgetExceeded: Schema.TaggedStruct<"TimingBudgetExceeded", {}>;
-  readonly Transport: Schema.TaggedStruct<"Transport", {
-    readonly status: Schema.optionalKey<Schema.Int>;
-  }>;
-  readonly Provider: Schema.TaggedStruct<"Provider", {
-    readonly status: Schema.optionalKey<Schema.Int>;
-    readonly detail: Schema.optionalKey<Schema.String>;
-  }>;
-  readonly Authorization: Schema.TaggedStruct<"Authorization", {}>;
-  readonly RateLimited: Schema.TaggedStruct<"RateLimited", {
-    readonly retryAfterMillis: Schema.optionalKey<Schema.Natural>;
-  }>;
-  readonly Disconnected: Schema.TaggedStruct<"Disconnected", {}>;
-  readonly Active: Schema.TaggedStruct<"Active", {}>;
-  readonly Disabled: Schema.TaggedStruct<"Disabled", {}>;
-  readonly Expired: Schema.TaggedStruct<"Expired", {}>;
-  readonly Failed: Schema.TaggedStruct<"Failed", {}>;
-  readonly UnsafeUrl: Schema.TaggedStruct<"UnsafeUrl", {}>;
-  readonly ContentType: Schema.TaggedStruct<"ContentType", {}>;
-  readonly Timestamp: Schema.TaggedStruct<"Timestamp", {}>;
-  readonly Resized: Schema.TaggedStruct<"Resized", {}>;
-  readonly TargetChanged: Schema.TaggedStruct<"TargetChanged", {}>;
-  readonly Interrupted: Schema.TaggedStruct<"Interrupted", {}>;
-  readonly ContextLease: Schema.TaggedStruct<"ContextLease", {}>;
-  readonly NotVisible: Schema.TaggedStruct<"NotVisible", {}>;
-  readonly Denied: Schema.TaggedStruct<"Denied", {}>;
-  readonly NotFocused: Schema.TaggedStruct<"NotFocused", {}>;
-};
-export declare const BrowserReason: Schema.Union<(Schema.TaggedStruct<"Active", {}> | Schema.TaggedStruct<"Ambiguous", {
-  readonly count: Schema.optionalKey<Schema.Natural>;
-}> | Schema.TaggedStruct<"Authorization", {}> | Schema.TaggedStruct<"Busy", {}> | Schema.TaggedStruct<"Closed", {}> | Schema.TaggedStruct<"Configuration", {
-  readonly path: Schema.optionalKey<Schema.String>;
-}> | Schema.TaggedStruct<"ContentType", {}> | Schema.TaggedStruct<"ContextLease", {}> | Schema.TaggedStruct<"Denied", {}> | Schema.TaggedStruct<"Disabled", {}> | Schema.TaggedStruct<"Disconnected", {}> | Schema.TaggedStruct<"Drifted", {}> | Schema.TaggedStruct<"Expired", {}> | Schema.TaggedStruct<"Failed", {}> | Schema.TaggedStruct<"Incomplete", {}> | Schema.TaggedStruct<"Interrupted", {}> | Schema.TaggedStruct<"Limit", {
-  readonly dimension: Schema.Literals<readonly ["runs", "actions", "elapsed", "returned-bytes", "pages", "frames", "frame-depth", "buffered-frames", "buffered-bytes", "host-reads", "controls", "text", "code-points", "captures", "frame-bytes", "width", "height", "pixels", "observation-snapshots", "observation-handles", "observation-bytes", "native-operations"]>;
-  readonly maximum: Schema.Natural;
-  readonly observed: Schema.Natural;
-}> | Schema.TaggedStruct<"Malformed", {
-  readonly path: Schema.optionalKey<Schema.String>;
-}> | Schema.TaggedStruct<"Missing", {}> | Schema.TaggedStruct<"NotFocused", {}> | Schema.TaggedStruct<"NotFound", {}> | Schema.TaggedStruct<"NotVisible", {}> | Schema.TaggedStruct<"Provider", {
-  readonly status: Schema.optionalKey<Schema.Int>;
-  readonly detail: Schema.optionalKey<Schema.String>;
-}> | Schema.TaggedStruct<"QueueExpired", {}> | Schema.TaggedStruct<"QueueFull", {
-  readonly scope: Schema.Literals<readonly ["page", "session", "registry"]>;
-  readonly maximum: Schema.Natural;
-  readonly observed: Schema.Natural;
-}> | Schema.TaggedStruct<"RateLimited", {
-  readonly retryAfterMillis: Schema.optionalKey<Schema.Natural>;
-}> | Schema.TaggedStruct<"Resized", {}> | Schema.TaggedStruct<"ScheduleMissed", {}> | Schema.TaggedStruct<"Stale", {}> | Schema.TaggedStruct<"TargetChanged", {}> | Schema.TaggedStruct<"Timeout", {}> | Schema.TaggedStruct<"Timestamp", {}> | Schema.TaggedStruct<"TimingBudgetExceeded", {}> | Schema.TaggedStruct<"Transport", {
-  readonly status: Schema.optionalKey<Schema.Int>;
-}> | Schema.TaggedStruct<"UnregisteredSession", {}> | Schema.TaggedStruct<"UnsafeUrl", {}> | Schema.TaggedStruct<"Unsupported", {}>)[]>;
-export type BrowserReason = typeof BrowserReason.Type;
-/**
- * Containment never changes an uncertain mutation into a known action outcome. `PagePaused` is
- * a page's own popup/dialog-policy quarantine: the page stays open for an operator and refuses
- * automation until a drained handoff and explicit release.
- */
-export declare const Containment: Schema.Union<readonly [Schema.TaggedStruct<"NotRequired", {}>, Schema.TaggedStruct<"PageClosed", {
-  readonly pageId: Schema.String;
-  readonly generation: Schema.Natural;
-}>, Schema.TaggedStruct<"PagePaused", {
-  readonly pageId: Schema.String;
-  readonly generation: Schema.Natural;
-}>, Schema.TaggedStruct<"SessionFenced", {
-  readonly generation: Schema.Natural;
-}>]>;
-export type Containment = typeof Containment.Type;
-declare const BrowserError_base: Schema.Class<BrowserError, Schema.TaggedStruct<"BrowserError", {
-  readonly operation: Schema.Literals<readonly ["configure", "launch", "connect", "reconnect", "detach", "disconnect", "close", "handoff", "resume", "live-view", "target", "handle", "list-pages", "describe-page", "list-frames", "select-page", "new-page", "close-page", "resize", "ready", "observe", "checkpoint", "control-facts", "revalidate", "read-text", "screenshot", "wait", "resolve", "run", "settled", "navigate", "navigate-stop", "click", "fill", "fill-form", "select-option", "scroll", "click-and-wait", "download-action", "select-files", "file-chooser", "action-result", "pointer-move", "hover", "wheel", "press", "type", "page-control", "page-state", "page-suspend", "page-resume", "capture", "capture-start", "capture-stop", "capture-consume"]>;
-  readonly reason: Schema.Union<(Schema.TaggedStruct<"Active", {}> | Schema.TaggedStruct<"Ambiguous", {
-    readonly count: Schema.optionalKey<Schema.Natural>;
-  }> | Schema.TaggedStruct<"Authorization", {}> | Schema.TaggedStruct<"Busy", {}> | Schema.TaggedStruct<"Closed", {}> | Schema.TaggedStruct<"Configuration", {
-    readonly path: Schema.optionalKey<Schema.String>;
-  }> | Schema.TaggedStruct<"ContentType", {}> | Schema.TaggedStruct<"ContextLease", {}> | Schema.TaggedStruct<"Denied", {}> | Schema.TaggedStruct<"Disabled", {}> | Schema.TaggedStruct<"Disconnected", {}> | Schema.TaggedStruct<"Drifted", {}> | Schema.TaggedStruct<"Expired", {}> | Schema.TaggedStruct<"Failed", {}> | Schema.TaggedStruct<"Incomplete", {}> | Schema.TaggedStruct<"Interrupted", {}> | Schema.TaggedStruct<"Limit", {
-    readonly dimension: Schema.Literals<readonly ["runs", "actions", "elapsed", "returned-bytes", "pages", "frames", "frame-depth", "buffered-frames", "buffered-bytes", "host-reads", "controls", "text", "code-points", "captures", "frame-bytes", "width", "height", "pixels", "observation-snapshots", "observation-handles", "observation-bytes", "native-operations"]>;
-    readonly maximum: Schema.Natural;
-    readonly observed: Schema.Natural;
-  }> | Schema.TaggedStruct<"Malformed", {
-    readonly path: Schema.optionalKey<Schema.String>;
-  }> | Schema.TaggedStruct<"Missing", {}> | Schema.TaggedStruct<"NotFocused", {}> | Schema.TaggedStruct<"NotFound", {}> | Schema.TaggedStruct<"NotVisible", {}> | Schema.TaggedStruct<"Provider", {
-    readonly status: Schema.optionalKey<Schema.Int>;
-    readonly detail: Schema.optionalKey<Schema.String>;
-  }> | Schema.TaggedStruct<"QueueExpired", {}> | Schema.TaggedStruct<"QueueFull", {
-    readonly scope: Schema.Literals<readonly ["page", "session", "registry"]>;
-    readonly maximum: Schema.Natural;
-    readonly observed: Schema.Natural;
-  }> | Schema.TaggedStruct<"RateLimited", {
-    readonly retryAfterMillis: Schema.optionalKey<Schema.Natural>;
-  }> | Schema.TaggedStruct<"Resized", {}> | Schema.TaggedStruct<"ScheduleMissed", {}> | Schema.TaggedStruct<"Stale", {}> | Schema.TaggedStruct<"TargetChanged", {}> | Schema.TaggedStruct<"Timeout", {}> | Schema.TaggedStruct<"Timestamp", {}> | Schema.TaggedStruct<"TimingBudgetExceeded", {}> | Schema.TaggedStruct<"Transport", {
-    readonly status: Schema.optionalKey<Schema.Int>;
-  }> | Schema.TaggedStruct<"UnregisteredSession", {}> | Schema.TaggedStruct<"UnsafeUrl", {}> | Schema.TaggedStruct<"Unsupported", {}>)[]>;
-  readonly outcome: Schema.Literals<readonly ["undispatched", "rejected", "performed", "unknown"]>;
-  readonly containment: Schema.optionalKey<Schema.Union<readonly [Schema.TaggedStruct<"NotRequired", {}>, Schema.TaggedStruct<"PageClosed", {
-    readonly pageId: Schema.String;
-    readonly generation: Schema.Natural;
-  }>, Schema.TaggedStruct<"PagePaused", {
-    readonly pageId: Schema.String;
-    readonly generation: Schema.Natural;
-  }>, Schema.TaggedStruct<"SessionFenced", {
-    readonly generation: Schema.Natural;
-  }>]>>;
-}>, import("effect/Cause").YieldableError>;
-export declare class BrowserError extends BrowserError_base {}
-declare const InitializationError_base: Schema.Class<InitializationError, Schema.TaggedStruct<"InitializationError", {
-  readonly operation: Schema.Literals<readonly ["configure", "register", "ready", "callback", "dispose"]>;
-  readonly step: Schema.String;
-  readonly reason: Schema.Literals<readonly ["configuration", "unsupported", "origin", "stale", "busy", "closed", "timeout", "input", "output", "native"]>;
-}>, import("effect/Cause").YieldableError>;
-export declare class InitializationError extends InitializationError_base {}
-//#endregion
-export {};
-//# sourceMappingURL=Errors.d.mts.map

package/dist/Errors.mjs

@@ -1,207 +0,0 @@
-import { Schema } from "effect";
-//#region src/Errors.ts
-/**
-* What a caller asked the owned browser to do. The vocabulary is closed: the owner stamps it
-* when it admits an operation, so a native step's own name can never become API, and a new
-* spelling is a deliberate edit here rather than a string that merely compiles.
-*/
-const BrowserOperation = Schema.Literals([
-	"configure",
-	"launch",
-	"connect",
-	"reconnect",
-	"detach",
-	"disconnect",
-	"close",
-	"handoff",
-	"resume",
-	"live-view",
-	"target",
-	"handle",
-	"list-pages",
-	"describe-page",
-	"list-frames",
-	"select-page",
-	"new-page",
-	"close-page",
-	"resize",
-	"ready",
-	"observe",
-	"checkpoint",
-	"control-facts",
-	"revalidate",
-	"read-text",
-	"screenshot",
-	"wait",
-	"resolve",
-	"run",
-	"settled",
-	"navigate",
-	"navigate-stop",
-	"click",
-	"fill",
-	"fill-form",
-	"select-option",
-	"scroll",
-	"click-and-wait",
-	"download-action",
-	"select-files",
-	"file-chooser",
-	"action-result",
-	"pointer-move",
-	"hover",
-	"wheel",
-	"press",
-	"type",
-	"page-control",
-	"page-state",
-	"page-suspend",
-	"page-resume",
-	"capture",
-	"capture-start",
-	"capture-stop",
-	"capture-consume"
-]);
-/** Dispatch evidence belongs to the operation, independently of its failure reason. */
-const BrowserOutcome = Schema.Literals([
-	"undispatched",
-	"rejected",
-	"performed",
-	"unknown"
-]);
-/** Limits report measured producer facts; an unavailable measurement is never invented. */
-const LimitDimension = Schema.Literals([
-	"runs",
-	"actions",
-	"elapsed",
-	"returned-bytes",
-	"pages",
-	"frames",
-	"frame-depth",
-	"buffered-frames",
-	"buffered-bytes",
-	"host-reads",
-	"controls",
-	"text",
-	"code-points",
-	"captures",
-	"frame-bytes",
-	"width",
-	"height",
-	"pixels",
-	"observation-snapshots",
-	"observation-handles",
-	"observation-bytes",
-	"native-operations"
-]);
-const SchemaPath = Schema.String.check(Schema.isMaxLength(512));
-/**
-* What the native engine said about a failure it raised: its first line, without escape codes,
-* with every address cut to its origin. A host diagnostic, never part of the model projection.
-*/
-const NativeDetail = Schema.String.check(Schema.isMaxLength(512));
-/** Validated constructors for host reasons. The model receives a separate bounded projection. */
-const Reasons = {
-	Configuration: Schema.TaggedStruct("Configuration", { path: Schema.optionalKey(SchemaPath) }),
-	UnregisteredSession: Schema.TaggedStruct("UnregisteredSession", {}),
-	Unsupported: Schema.TaggedStruct("Unsupported", {}),
-	Busy: Schema.TaggedStruct("Busy", {}),
-	QueueFull: Schema.TaggedStruct("QueueFull", {
-		scope: Schema.Literals([
-			"page",
-			"session",
-			"registry"
-		]),
-		maximum: Schema.Natural,
-		observed: Schema.Natural
-	}),
-	QueueExpired: Schema.TaggedStruct("QueueExpired", {}),
-	Closed: Schema.TaggedStruct("Closed", {}),
-	Stale: Schema.TaggedStruct("Stale", {}),
-	NotFound: Schema.TaggedStruct("NotFound", {}),
-	Missing: Schema.TaggedStruct("Missing", {}),
-	Ambiguous: Schema.TaggedStruct("Ambiguous", { count: Schema.optionalKey(Schema.Natural) }),
-	Incomplete: Schema.TaggedStruct("Incomplete", {}),
-	Drifted: Schema.TaggedStruct("Drifted", {}),
-	Malformed: Schema.TaggedStruct("Malformed", { path: Schema.optionalKey(SchemaPath) }),
-	Limit: Schema.TaggedStruct("Limit", {
-		dimension: LimitDimension,
-		maximum: Schema.Natural,
-		observed: Schema.Natural
-	}),
-	Timeout: Schema.TaggedStruct("Timeout", {}),
-	ScheduleMissed: Schema.TaggedStruct("ScheduleMissed", {}),
-	TimingBudgetExceeded: Schema.TaggedStruct("TimingBudgetExceeded", {}),
-	Transport: Schema.TaggedStruct("Transport", { status: Schema.optionalKey(Schema.Int) }),
-	Provider: Schema.TaggedStruct("Provider", {
-		status: Schema.optionalKey(Schema.Int),
-		detail: Schema.optionalKey(NativeDetail)
-	}),
-	Authorization: Schema.TaggedStruct("Authorization", {}),
-	RateLimited: Schema.TaggedStruct("RateLimited", { retryAfterMillis: Schema.optionalKey(Schema.Natural) }),
-	Disconnected: Schema.TaggedStruct("Disconnected", {}),
-	Active: Schema.TaggedStruct("Active", {}),
-	Disabled: Schema.TaggedStruct("Disabled", {}),
-	Expired: Schema.TaggedStruct("Expired", {}),
-	Failed: Schema.TaggedStruct("Failed", {}),
-	UnsafeUrl: Schema.TaggedStruct("UnsafeUrl", {}),
-	ContentType: Schema.TaggedStruct("ContentType", {}),
-	Timestamp: Schema.TaggedStruct("Timestamp", {}),
-	Resized: Schema.TaggedStruct("Resized", {}),
-	TargetChanged: Schema.TaggedStruct("TargetChanged", {}),
-	Interrupted: Schema.TaggedStruct("Interrupted", {}),
-	ContextLease: Schema.TaggedStruct("ContextLease", {}),
-	NotVisible: Schema.TaggedStruct("NotVisible", {}),
-	Denied: Schema.TaggedStruct("Denied", {}),
-	NotFocused: Schema.TaggedStruct("NotFocused", {})
-};
-const BrowserReason = Schema.Union(Object.values(Reasons));
-/**
-* Containment never changes an uncertain mutation into a known action outcome. `PagePaused` is
-* a page's own popup/dialog-policy quarantine: the page stays open for an operator and refuses
-* automation until a drained handoff and explicit release.
-*/
-const Containment = Schema.Union([
-	Schema.TaggedStruct("NotRequired", {}),
-	Schema.TaggedStruct("PageClosed", {
-		pageId: Schema.String,
-		generation: Schema.Natural
-	}),
-	Schema.TaggedStruct("PagePaused", {
-		pageId: Schema.String,
-		generation: Schema.Natural
-	}),
-	Schema.TaggedStruct("SessionFenced", { generation: Schema.Natural })
-]);
-var BrowserError = class extends Schema.TaggedError()("BrowserError", {
-	operation: BrowserOperation,
-	reason: BrowserReason,
-	outcome: BrowserOutcome,
-	containment: Schema.optionalKey(Containment)
-}) {};
-var InitializationError = class extends Schema.TaggedError()("InitializationError", {
-	operation: Schema.Literals([
-		"configure",
-		"register",
-		"ready",
-		"callback",
-		"dispose"
-	]),
-	step: Schema.String.check(Schema.isMaxLength(128)),
-	reason: Schema.Literals([
-		"configuration",
-		"unsupported",
-		"origin",
-		"stale",
-		"busy",
-		"closed",
-		"timeout",
-		"input",
-		"output",
-		"native"
-	])
-}) {};
-//#endregion
-export { BrowserError, BrowserOperation, BrowserOutcome, BrowserReason, Containment, InitializationError, LimitDimension, Reasons };
-
-//# sourceMappingURL=Errors.mjs.map

package/dist/Errors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Errors.mjs","names":[],"sources":["../src/Errors.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/**\n * What a caller asked the owned browser to do. The vocabulary is closed: the owner stamps it\n * when it admits an operation, so a native step's own name can never become API, and a new\n * spelling is a deliberate edit here rather than a string that merely compiles.\n */\nexport const BrowserOperation = Schema.Literals([\n  // configuration and lifetime\n  \"configure\",\n  \"launch\",\n  \"connect\",\n  \"reconnect\",\n  \"detach\",\n  \"disconnect\",\n  \"close\",\n  \"handoff\",\n  \"resume\",\n  \"live-view\",\n  // targets\n  \"target\",\n  \"handle\",\n  \"list-pages\",\n  \"describe-page\",\n  \"list-frames\",\n  \"select-page\",\n  \"new-page\",\n  \"close-page\",\n  \"resize\",\n  // reading\n  \"ready\",\n  \"observe\",\n  \"checkpoint\",\n  \"control-facts\",\n  \"revalidate\",\n  \"read-text\",\n  \"screenshot\",\n  \"wait\",\n  \"resolve\",\n  \"run\",\n  \"settled\",\n  // input\n  \"navigate\",\n  \"navigate-stop\",\n  \"click\",\n  \"fill\",\n  \"fill-form\",\n  \"select-option\",\n  \"scroll\",\n  \"click-and-wait\",\n  \"download-action\",\n  \"select-files\",\n  \"file-chooser\",\n  \"action-result\",\n  // native pointer input\n  \"pointer-move\",\n  \"hover\",\n  \"wheel\",\n  // native key input\n  \"press\",\n  \"type\",\n  // page control\n  \"page-control\",\n  \"page-state\",\n  \"page-suspend\",\n  \"page-resume\",\n  // capture\n  \"capture\",\n  \"capture-start\",\n  \"capture-stop\",\n  \"capture-consume\",\n]);\n\nexport type BrowserOperation = typeof BrowserOperation.Type;\n\n/** Dispatch evidence belongs to the operation, independently of its failure reason. */\nexport const BrowserOutcome = Schema.Literals([\"undispatched\", \"rejected\", \"performed\", \"unknown\"]);\n\nexport type BrowserOutcome = typeof BrowserOutcome.Type;\n\n/** Limits report measured producer facts; an unavailable measurement is never invented. */\nexport const LimitDimension = Schema.Literals([\n  \"runs\",\n  \"actions\",\n  \"elapsed\",\n  \"returned-bytes\",\n  \"pages\",\n  \"frames\",\n  \"frame-depth\",\n  \"buffered-frames\",\n  \"buffered-bytes\",\n  \"host-reads\",\n  \"controls\",\n  \"text\",\n  \"code-points\",\n  \"captures\",\n  \"frame-bytes\",\n  \"width\",\n  \"height\",\n  \"pixels\",\n  \"observation-snapshots\",\n  \"observation-handles\",\n  \"observation-bytes\",\n  \"native-operations\",\n]);\n\nconst SchemaPath = Schema.String.check(Schema.isMaxLength(512));\n\n/**\n * What the native engine said about a failure it raised: its first line, without escape codes,\n * with every address cut to its origin. A host diagnostic, never part of the model projection.\n */\nconst NativeDetail = Schema.String.check(Schema.isMaxLength(512));\n\n/** Validated constructors for host reasons. The model receives a separate bounded projection. */\nexport const Reasons = {\n  Configuration: Schema.TaggedStruct(\"Configuration\", { path: Schema.optionalKey(SchemaPath) }),\n  UnregisteredSession: Schema.TaggedStruct(\"UnregisteredSession\", {}),\n  Unsupported: Schema.TaggedStruct(\"Unsupported\", {}),\n  Busy: Schema.TaggedStruct(\"Busy\", {}),\n  QueueFull: Schema.TaggedStruct(\"QueueFull\", {\n    scope: Schema.Literals([\"page\", \"session\", \"registry\"]),\n    maximum: Schema.Natural,\n    observed: Schema.Natural,\n  }),\n  QueueExpired: Schema.TaggedStruct(\"QueueExpired\", {}),\n  Closed: Schema.TaggedStruct(\"Closed\", {}),\n  Stale: Schema.TaggedStruct(\"Stale\", {}),\n  NotFound: Schema.TaggedStruct(\"NotFound\", {}),\n  Missing: Schema.TaggedStruct(\"Missing\", {}),\n  Ambiguous: Schema.TaggedStruct(\"Ambiguous\", { count: Schema.optionalKey(Schema.Natural) }),\n  Incomplete: Schema.TaggedStruct(\"Incomplete\", {}),\n  Drifted: Schema.TaggedStruct(\"Drifted\", {}),\n  Malformed: Schema.TaggedStruct(\"Malformed\", { path: Schema.optionalKey(SchemaPath) }),\n  Limit: Schema.TaggedStruct(\"Limit\", {\n    dimension: LimitDimension,\n    maximum: Schema.Natural,\n    observed: Schema.Natural,\n  }),\n  Timeout: Schema.TaggedStruct(\"Timeout\", {}),\n  ScheduleMissed: Schema.TaggedStruct(\"ScheduleMissed\", {}),\n  TimingBudgetExceeded: Schema.TaggedStruct(\"TimingBudgetExceeded\", {}),\n  Transport: Schema.TaggedStruct(\"Transport\", { status: Schema.optionalKey(Schema.Int) }),\n  Provider: Schema.TaggedStruct(\"Provider\", {\n    status: Schema.optionalKey(Schema.Int),\n    detail: Schema.optionalKey(NativeDetail),\n  }),\n  Authorization: Schema.TaggedStruct(\"Authorization\", {}),\n  RateLimited: Schema.TaggedStruct(\"RateLimited\", {\n    retryAfterMillis: Schema.optionalKey(Schema.Natural),\n  }),\n  Disconnected: Schema.TaggedStruct(\"Disconnected\", {}),\n  Active: Schema.TaggedStruct(\"Active\", {}),\n  Disabled: Schema.TaggedStruct(\"Disabled\", {}),\n  Expired: Schema.TaggedStruct(\"Expired\", {}),\n  Failed: Schema.TaggedStruct(\"Failed\", {}),\n  UnsafeUrl: Schema.TaggedStruct(\"UnsafeUrl\", {}),\n  ContentType: Schema.TaggedStruct(\"ContentType\", {}),\n  Timestamp: Schema.TaggedStruct(\"Timestamp\", {}),\n  Resized: Schema.TaggedStruct(\"Resized\", {}),\n  TargetChanged: Schema.TaggedStruct(\"TargetChanged\", {}),\n  Interrupted: Schema.TaggedStruct(\"Interrupted\", {}),\n  ContextLease: Schema.TaggedStruct(\"ContextLease\", {}),\n  NotVisible: Schema.TaggedStruct(\"NotVisible\", {}),\n  Denied: Schema.TaggedStruct(\"Denied\", {}),\n  NotFocused: Schema.TaggedStruct(\"NotFocused\", {}),\n} as const;\n\nexport const BrowserReason = Schema.Union(Object.values(Reasons));\n\nexport type BrowserReason = typeof BrowserReason.Type;\n\n/**\n * Containment never changes an uncertain mutation into a known action outcome. `PagePaused` is\n * a page's own popup/dialog-policy quarantine: the page stays open for an operator and refuses\n * automation until a drained handoff and explicit release.\n */\nexport const Containment = Schema.Union([\n  Schema.TaggedStruct(\"NotRequired\", {}),\n  Schema.TaggedStruct(\"PageClosed\", { pageId: Schema.String, generation: Schema.Natural }),\n  Schema.TaggedStruct(\"PagePaused\", { pageId: Schema.String, generation: Schema.Natural }),\n  Schema.TaggedStruct(\"SessionFenced\", { generation: Schema.Natural }),\n]);\n\nexport type Containment = typeof Containment.Type;\n\nexport class BrowserError extends Schema.TaggedError<BrowserError>()(\"BrowserError\", {\n  operation: BrowserOperation,\n  reason: BrowserReason,\n  outcome: BrowserOutcome,\n  containment: Schema.optionalKey(Containment),\n}) {}\n\nexport class InitializationError extends Schema.TaggedError<InitializationError>()(\n  \"InitializationError\",\n  {\n    operation: Schema.Literals([\"configure\", \"register\", \"ready\", \"callback\", \"dispose\"]),\n    step: Schema.String.check(Schema.isMaxLength(128)),\n    reason: Schema.Literals([\n      \"configuration\",\n      \"unsupported\",\n      \"origin\",\n      \"stale\",\n      \"busy\",\n      \"closed\",\n      \"timeout\",\n      \"input\",\n      \"output\",\n      \"native\",\n    ]),\n  },\n) {}\n"],"mappings":";;;;;;;AAOA,MAAa,mBAAmB,OAAO,SAAS;CAE9C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CAEA;CACA;CAEA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;AACF,CAAC;;AAKD,MAAa,iBAAiB,OAAO,SAAS;CAAC;CAAgB;CAAY;CAAa;AAAS,CAAC;;AAKlG,MAAa,iBAAiB,OAAO,SAAS;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,aAAa,OAAO,OAAO,MAAM,OAAO,YAAY,GAAG,CAAC;;;;;AAM9D,MAAM,eAAe,OAAO,OAAO,MAAM,OAAO,YAAY,GAAG,CAAC;;AAGhE,MAAa,UAAU;CACrB,eAAe,OAAO,aAAa,iBAAiB,EAAE,MAAM,OAAO,YAAY,UAAU,EAAE,CAAC;CAC5F,qBAAqB,OAAO,aAAa,uBAAuB,CAAC,CAAC;CAClE,aAAa,OAAO,aAAa,eAAe,CAAC,CAAC;CAClD,MAAM,OAAO,aAAa,QAAQ,CAAC,CAAC;CACpC,WAAW,OAAO,aAAa,aAAa;EAC1C,OAAO,OAAO,SAAS;GAAC;GAAQ;GAAW;EAAU,CAAC;EACtD,SAAS,OAAO;EAChB,UAAU,OAAO;CACnB,CAAC;CACD,cAAc,OAAO,aAAa,gBAAgB,CAAC,CAAC;CACpD,QAAQ,OAAO,aAAa,UAAU,CAAC,CAAC;CACxC,OAAO,OAAO,aAAa,SAAS,CAAC,CAAC;CACtC,UAAU,OAAO,aAAa,YAAY,CAAC,CAAC;CAC5C,SAAS,OAAO,aAAa,WAAW,CAAC,CAAC;CAC1C,WAAW,OAAO,aAAa,aAAa,EAAE,OAAO,OAAO,YAAY,OAAO,OAAO,EAAE,CAAC;CACzF,YAAY,OAAO,aAAa,cAAc,CAAC,CAAC;CAChD,SAAS,OAAO,aAAa,WAAW,CAAC,CAAC;CAC1C,WAAW,OAAO,aAAa,aAAa,EAAE,MAAM,OAAO,YAAY,UAAU,EAAE,CAAC;CACpF,OAAO,OAAO,aAAa,SAAS;EAClC,WAAW;EACX,SAAS,OAAO;EAChB,UAAU,OAAO;CACnB,CAAC;CACD,SAAS,OAAO,aAAa,WAAW,CAAC,CAAC;CAC1C,gBAAgB,OAAO,aAAa,kBAAkB,CAAC,CAAC;CACxD,sBAAsB,OAAO,aAAa,wBAAwB,CAAC,CAAC;CACpE,WAAW,OAAO,aAAa,aAAa,EAAE,QAAQ,OAAO,YAAY,OAAO,GAAG,EAAE,CAAC;CACtF,UAAU,OAAO,aAAa,YAAY;EACxC,QAAQ,OAAO,YAAY,OAAO,GAAG;EACrC,QAAQ,OAAO,YAAY,YAAY;CACzC,CAAC;CACD,eAAe,OAAO,aAAa,iBAAiB,CAAC,CAAC;CACtD,aAAa,OAAO,aAAa,eAAe,EAC9C,kBAAkB,OAAO,YAAY,OAAO,OAAO,EACrD,CAAC;CACD,cAAc,OAAO,aAAa,gBAAgB,CAAC,CAAC;CACpD,QAAQ,OAAO,aAAa,UAAU,CAAC,CAAC;CACxC,UAAU,OAAO,aAAa,YAAY,CAAC,CAAC;CAC5C,SAAS,OAAO,aAAa,WAAW,CAAC,CAAC;CAC1C,QAAQ,OAAO,aAAa,UAAU,CAAC,CAAC;CACxC,WAAW,OAAO,aAAa,aAAa,CAAC,CAAC;CAC9C,aAAa,OAAO,aAAa,eAAe,CAAC,CAAC;CAClD,WAAW,OAAO,aAAa,aAAa,CAAC,CAAC;CAC9C,SAAS,OAAO,aAAa,WAAW,CAAC,CAAC;CAC1C,eAAe,OAAO,aAAa,iBAAiB,CAAC,CAAC;CACtD,aAAa,OAAO,aAAa,eAAe,CAAC,CAAC;CAClD,cAAc,OAAO,aAAa,gBAAgB,CAAC,CAAC;CACpD,YAAY,OAAO,aAAa,cAAc,CAAC,CAAC;CAChD,QAAQ,OAAO,aAAa,UAAU,CAAC,CAAC;CACxC,YAAY,OAAO,aAAa,cAAc,CAAC,CAAC;AAClD;AAEA,MAAa,gBAAgB,OAAO,MAAM,OAAO,OAAO,OAAO,CAAC;;;;;;AAShE,MAAa,cAAc,OAAO,MAAM;CACtC,OAAO,aAAa,eAAe,CAAC,CAAC;CACrC,OAAO,aAAa,cAAc;EAAE,QAAQ,OAAO;EAAQ,YAAY,OAAO;CAAQ,CAAC;CACvF,OAAO,aAAa,cAAc;EAAE,QAAQ,OAAO;EAAQ,YAAY,OAAO;CAAQ,CAAC;CACvF,OAAO,aAAa,iBAAiB,EAAE,YAAY,OAAO,QAAQ,CAAC;AACrE,CAAC;AAID,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,gBAAgB;CACnF,WAAW;CACX,QAAQ;CACR,SAAS;CACT,aAAa,OAAO,YAAY,WAAW;AAC7C,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,WAAW,OAAO,SAAS;EAAC;EAAa;EAAY;EAAS;EAAY;CAAS,CAAC;CACpF,MAAM,OAAO,OAAO,MAAM,OAAO,YAAY,GAAG,CAAC;CACjD,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;AACH,CACF,CAAC,CAAC,CAAC"}

package/dist/Images-yCG9BmRU.mjs

@@ -1,76 +0,0 @@
-import { Reasons } from "./Errors.mjs";
-import { y as failure } from "./PublicSession-DCSMMqOj.mjs";
-//#region src/internal/browser/Images.ts
-const malformed = () => failure(Reasons.Malformed.make({}));
-/** A checked read: a truncated segment is malformed framing, never `undefined` arithmetic. */
-const byteAt = (bytes, index) => {
-	const byte = bytes[index];
-	if (byte === void 0) throw malformed();
-	return byte;
-};
-/** Parse framing only; a caller decoding media must still validate its complete bitstream. */
-const pngGeometry = (bytes) => {
-	if (bytes.length < 33 || [
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	].some((b, i) => bytes[i] !== b) || bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82) throw malformed();
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	if (view.getUint32(8) !== 13) throw malformed();
-	const width = view.getUint32(16), height = view.getUint32(20);
-	if (width === 0 || height === 0) throw malformed();
-	return {
-		width,
-		height
-	};
-};
-/** JPEG SOF dimensions avoid trusting the requested size or CSS viewport dimensions. */
-const jpegGeometry = (bytes) => {
-	if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) throw malformed();
-	let offset = 2;
-	while (offset + 3 < bytes.length) {
-		if (bytes[offset++] !== 255) throw malformed();
-		while (bytes[offset] === 255) offset++;
-		const marker = bytes[offset++];
-		if (marker === void 0 || marker === 217 || marker === 218) break;
-		if (marker === 1 || marker >= 208 && marker <= 215) continue;
-		if (offset + 1 >= bytes.length) throw malformed();
-		const size = byteAt(bytes, offset) * 256 + byteAt(bytes, offset + 1);
-		if (size < 2 || offset + size > bytes.length) throw malformed();
-		if ([
-			192,
-			193,
-			194,
-			195,
-			197,
-			198,
-			199,
-			201,
-			202,
-			203,
-			205,
-			206,
-			207
-		].includes(marker)) {
-			if (size < 8) throw malformed();
-			const height = byteAt(bytes, offset + 3) * 256 + byteAt(bytes, offset + 4);
-			const width = byteAt(bytes, offset + 5) * 256 + byteAt(bytes, offset + 6);
-			if (width === 0 || height === 0) throw malformed();
-			return {
-				width,
-				height
-			};
-		}
-		offset += size;
-	}
-	throw malformed();
-};
-//#endregion
-export { pngGeometry as n, jpegGeometry as t };
-
-//# sourceMappingURL=Images-yCG9BmRU.mjs.map

package/dist/Images-yCG9BmRU.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Images-yCG9BmRU.mjs","names":[],"sources":["../src/internal/browser/Images.ts"],"sourcesContent":["import { Reasons } from \"../../Errors.ts\";\nimport { failure } from \"./NativeCalls.ts\";\n\nconst malformed = () => failure(Reasons.Malformed.make({}));\n\n/** A checked read: a truncated segment is malformed framing, never `undefined` arithmetic. */\nconst byteAt = (bytes: Uint8Array, index: number): number => {\n  const byte = bytes[index];\n\n  if (byte === undefined) throw malformed();\n\n  return byte;\n};\n\n/** Parse framing only; a caller decoding media must still validate its complete bitstream. */\nexport const pngGeometry = (bytes: Uint8Array): { width: number; height: number } => {\n  const signature = [137, 80, 78, 71, 13, 10, 26, 10];\n\n  if (\n    bytes.length < 33 ||\n    signature.some((b, i) => bytes[i] !== b) ||\n    bytes[12] !== 73 ||\n    bytes[13] !== 72 ||\n    bytes[14] !== 68 ||\n    bytes[15] !== 82\n  )\n    throw malformed();\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n\n  if (view.getUint32(8) !== 13) throw malformed();\n\n  const width = view.getUint32(16),\n    height = view.getUint32(20);\n\n  if (width === 0 || height === 0) throw malformed();\n\n  return { width, height };\n};\n\n/** JPEG SOF dimensions avoid trusting the requested size or CSS viewport dimensions. */\nexport const jpegGeometry = (bytes: Uint8Array): { width: number; height: number } => {\n  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) throw malformed();\n  let offset = 2;\n\n  while (offset + 3 < bytes.length) {\n    if (bytes[offset++] !== 255) throw malformed();\n    while (bytes[offset] === 255) offset++;\n    const marker = bytes[offset++];\n\n    if (marker === undefined || marker === 217 || marker === 218) break;\n    if (marker === 1 || (marker >= 208 && marker <= 215)) continue;\n    if (offset + 1 >= bytes.length) throw malformed();\n    const size = byteAt(bytes, offset) * 256 + byteAt(bytes, offset + 1);\n\n    if (size < 2 || offset + size > bytes.length) throw malformed();\n    if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker)) {\n      if (size < 8) throw malformed();\n      const height = byteAt(bytes, offset + 3) * 256 + byteAt(bytes, offset + 4);\n      const width = byteAt(bytes, offset + 5) * 256 + byteAt(bytes, offset + 6);\n\n      if (width === 0 || height === 0) throw malformed();\n\n      return { width, height };\n    }\n    offset += size;\n  }\n  throw malformed();\n};\n"],"mappings":";;;AAGA,MAAM,kBAAkB,QAAQ,QAAQ,UAAU,KAAK,CAAC,CAAC,CAAC;;AAG1D,MAAM,UAAU,OAAmB,UAA0B;CAC3D,MAAM,OAAO,MAAM;CAEnB,IAAI,SAAS,KAAA,GAAW,MAAM,UAAU;CAExC,OAAO;AACT;;AAGA,MAAa,eAAe,UAAyD;CAGnF,IACE,MAAM,SAAS,MACf;EAJiB;EAAK;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;CAItC,CAAC,CAAC,MAAM,GAAG,MAAM,MAAM,OAAO,CAAC,KACvC,MAAM,QAAQ,MACd,MAAM,QAAQ,MACd,MAAM,QAAQ,MACd,MAAM,QAAQ,IAEd,MAAM,UAAU;CAClB,MAAM,OAAO,IAAI,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;CAE1E,IAAI,KAAK,UAAU,CAAC,MAAM,IAAI,MAAM,UAAU;CAE9C,MAAM,QAAQ,KAAK,UAAU,EAAE,GAC7B,SAAS,KAAK,UAAU,EAAE;CAE5B,IAAI,UAAU,KAAK,WAAW,GAAG,MAAM,UAAU;CAEjD,OAAO;EAAE;EAAO;CAAO;AACzB;;AAGA,MAAa,gBAAgB,UAAyD;CACpF,IAAI,MAAM,SAAS,KAAK,MAAM,OAAO,OAAO,MAAM,OAAO,KAAK,MAAM,UAAU;CAC9E,IAAI,SAAS;CAEb,OAAO,SAAS,IAAI,MAAM,QAAQ;EAChC,IAAI,MAAM,cAAc,KAAK,MAAM,UAAU;EAC7C,OAAO,MAAM,YAAY,KAAK;EAC9B,MAAM,SAAS,MAAM;EAErB,IAAI,WAAW,KAAA,KAAa,WAAW,OAAO,WAAW,KAAK;EAC9D,IAAI,WAAW,KAAM,UAAU,OAAO,UAAU,KAAM;EACtD,IAAI,SAAS,KAAK,MAAM,QAAQ,MAAM,UAAU;EAChD,MAAM,OAAO,OAAO,OAAO,MAAM,IAAI,MAAM,OAAO,OAAO,SAAS,CAAC;EAEnE,IAAI,OAAO,KAAK,SAAS,OAAO,MAAM,QAAQ,MAAM,UAAU;EAC9D,IAAI;GAAC;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;GAAK;EAAG,CAAC,CAAC,SAAS,MAAM,GAAG;GACtF,IAAI,OAAO,GAAG,MAAM,UAAU;GAC9B,MAAM,SAAS,OAAO,OAAO,SAAS,CAAC,IAAI,MAAM,OAAO,OAAO,SAAS,CAAC;GACzE,MAAM,QAAQ,OAAO,OAAO,SAAS,CAAC,IAAI,MAAM,OAAO,OAAO,SAAS,CAAC;GAExE,IAAI,UAAU,KAAK,WAAW,GAAG,MAAM,UAAU;GAEjD,OAAO;IAAE;IAAO;GAAO;EACzB;EACA,UAAU;CACZ;CACA,MAAM,UAAU;AAClB"}

package/dist/OperationOptions-DAeRS6O9.mjs

@@ -1,55 +0,0 @@
-import { Duration, Option, Schema } from "effect";
-//#region src/internal/browser/OperationOptions.ts
-const FiniteDurationValue = Schema.Union([Schema.TaggedStruct("Millis", { millis: Schema.Finite }), Schema.TaggedStruct("Nanos", { nanos: Schema.BigInt })]);
-const FiniteDurationInput = Schema.Union([
-	Schema.Duration.check(Schema.makeFilter((duration) => Schema.is(FiniteDurationValue)(duration.value))),
-	Schema.Finite,
-	Schema.BigInt,
-	Schema.TemplateLiteral([
-		Schema.Finite,
-		" ",
-		Schema.Literals([
-			"nano",
-			"nanos",
-			"micro",
-			"micros",
-			"milli",
-			"millis",
-			"second",
-			"seconds",
-			"minute",
-			"minutes",
-			"hour",
-			"hours",
-			"day",
-			"days",
-			"week",
-			"weeks"
-		])
-	]),
-	Schema.Literals(["Infinity", "-Infinity"]),
-	Schema.Tuple([Schema.Finite, Schema.Finite]),
-	Schema.Struct({
-		weeks: Schema.optionalKey(Schema.Finite),
-		days: Schema.optionalKey(Schema.Finite),
-		hours: Schema.optionalKey(Schema.Finite),
-		minutes: Schema.optionalKey(Schema.Finite),
-		seconds: Schema.optionalKey(Schema.Finite),
-		milliseconds: Schema.optionalKey(Schema.Finite),
-		microseconds: Schema.optionalKey(Schema.Finite),
-		nanoseconds: Schema.optionalKey(Schema.Finite)
-	})
-]).check(Schema.makeFilter((input) => Option.exists(Duration.fromInput(input), (duration) => Duration.isFinite(duration) && !Duration.isNegative(duration) && Number.isFinite(Duration.toMillis(duration))), { message: "Queue duration must be finite and nonnegative" }));
-/** Host configuration only; never part of model-facing request schemas. */
-const AdmissionOptionsSchema = Schema.Struct({ queue: Schema.optionalKey(FiniteDurationInput) });
-const OperationOptionsSchema = Schema.Struct({
-	timeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e4
-	}))),
-	admission: Schema.optionalKey(AdmissionOptionsSchema)
-});
-//#endregion
-export { FiniteDurationInput as n, OperationOptionsSchema as r, AdmissionOptionsSchema as t };
-
-//# sourceMappingURL=OperationOptions-DAeRS6O9.mjs.map

package/dist/OperationOptions-DAeRS6O9.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"OperationOptions-DAeRS6O9.mjs","names":[],"sources":["../src/internal/browser/OperationOptions.ts"],"sourcesContent":["import { Duration, Option, Schema } from \"effect\";\n\nconst FiniteDurationValue = Schema.Union([\n  Schema.TaggedStruct(\"Millis\", { millis: Schema.Finite }),\n  Schema.TaggedStruct(\"Nanos\", { nanos: Schema.BigInt }),\n]);\n\n// Duration.fromInput intentionally normalizes raw NaN to zero. Validate raw components first\n// so an invalid queue allowance cannot silently become fail-fast admission.\nexport const FiniteDurationInput = Schema.Union([\n  // The built-in declaration checks only the Duration marker. Validate its representation\n  // before arithmetic so a malformed host value is a typed refusal rather than a defect.\n  Schema.Duration.check(\n    Schema.makeFilter((duration) => Schema.is(FiniteDurationValue)(duration.value)),\n  ),\n  Schema.Finite,\n  Schema.BigInt,\n  Schema.TemplateLiteral([\n    Schema.Finite,\n    \" \",\n    Schema.Literals([\n      \"nano\",\n      \"nanos\",\n      \"micro\",\n      \"micros\",\n      \"milli\",\n      \"millis\",\n      \"second\",\n      \"seconds\",\n      \"minute\",\n      \"minutes\",\n      \"hour\",\n      \"hours\",\n      \"day\",\n      \"days\",\n      \"week\",\n      \"weeks\",\n    ]),\n  ]),\n  Schema.Literals([\"Infinity\", \"-Infinity\"]),\n  Schema.Tuple([Schema.Finite, Schema.Finite]),\n  Schema.Struct({\n    weeks: Schema.optionalKey(Schema.Finite),\n    days: Schema.optionalKey(Schema.Finite),\n    hours: Schema.optionalKey(Schema.Finite),\n    minutes: Schema.optionalKey(Schema.Finite),\n    seconds: Schema.optionalKey(Schema.Finite),\n    milliseconds: Schema.optionalKey(Schema.Finite),\n    microseconds: Schema.optionalKey(Schema.Finite),\n    nanoseconds: Schema.optionalKey(Schema.Finite),\n  }),\n]).check(\n  Schema.makeFilter(\n    (input) =>\n      Option.exists(\n        Duration.fromInput(input),\n        (duration) =>\n          Duration.isFinite(duration) &&\n          !Duration.isNegative(duration) &&\n          Number.isFinite(Duration.toMillis(duration)),\n      ),\n    { message: \"Queue duration must be finite and nonnegative\" },\n  ),\n);\n\n/** Host configuration only; never part of model-facing request schemas. */\nexport const AdmissionOptionsSchema = Schema.Struct({\n  queue: Schema.optionalKey(FiniteDurationInput),\n});\n\nexport const OperationOptionsSchema = Schema.Struct({\n  timeoutMillis: Schema.optionalKey(\n    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 60000 })),\n  ),\n  admission: Schema.optionalKey(AdmissionOptionsSchema),\n});\n"],"mappings":";;AAEA,MAAM,sBAAsB,OAAO,MAAM,CACvC,OAAO,aAAa,UAAU,EAAE,QAAQ,OAAO,OAAO,CAAC,GACvD,OAAO,aAAa,SAAS,EAAE,OAAO,OAAO,OAAO,CAAC,CACvD,CAAC;AAID,MAAa,sBAAsB,OAAO,MAAM;CAG9C,OAAO,SAAS,MACd,OAAO,YAAY,aAAa,OAAO,GAAG,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAC,CAChF;CACA,OAAO;CACP,OAAO;CACP,OAAO,gBAAgB;EACrB,OAAO;EACP;EACA,OAAO,SAAS;GACd;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EACF,CAAC;CACH,CAAC;CACD,OAAO,SAAS,CAAC,YAAY,WAAW,CAAC;CACzC,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,MAAM,CAAC;CAC3C,OAAO,OAAO;EACZ,OAAO,OAAO,YAAY,OAAO,MAAM;EACvC,MAAM,OAAO,YAAY,OAAO,MAAM;EACtC,OAAO,OAAO,YAAY,OAAO,MAAM;EACvC,SAAS,OAAO,YAAY,OAAO,MAAM;EACzC,SAAS,OAAO,YAAY,OAAO,MAAM;EACzC,cAAc,OAAO,YAAY,OAAO,MAAM;EAC9C,cAAc,OAAO,YAAY,OAAO,MAAM;EAC9C,aAAa,OAAO,YAAY,OAAO,MAAM;CAC/C,CAAC;AACH,CAAC,CAAC,CAAC,MACD,OAAO,YACJ,UACC,OAAO,OACL,SAAS,UAAU,KAAK,IACvB,aACC,SAAS,SAAS,QAAQ,KAC1B,CAAC,SAAS,WAAW,QAAQ,KAC7B,OAAO,SAAS,SAAS,SAAS,QAAQ,CAAC,CAC/C,GACF,EAAE,SAAS,gDAAgD,CAC7D,CACF;;AAGA,MAAa,yBAAyB,OAAO,OAAO,EAClD,OAAO,OAAO,YAAY,mBAAmB,EAC/C,CAAC;AAED,MAAa,yBAAyB,OAAO,OAAO;CAClD,eAAe,OAAO,YACpB,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAM,CAAC,CAAC,CACnE;CACA,WAAW,OAAO,YAAY,sBAAsB;AACtD,CAAC"}

package/dist/PageControl.d.mts

@@ -1,15 +0,0 @@
-import { BrowserError } from "./Errors.mjs";
-import { F as PageExecutionState, L as PageSuspension } from "./BrowserData-CPIIIHol.mjs";
-import { l as OperationOptions, u as Page } from "./Browser-BF9_sORP.mjs";
-import { Effect } from "effect";
-//#region src/PageControl.d.ts
-/** Last acknowledged state; no remote guarantee survives connection loss or external control. */
-export declare const state: (page: Page, options?: OperationOptions) => Effect.Effect<PageExecutionState, BrowserError>;
-/** Explicit host-only hold requiring pageControl support; capture ACKs never invoke it. */
-export declare const suspend: (page: Page, options?: OperationOptions) => Effect.Effect<PageSuspension, BrowserError>;
-/** Consumes the exact live receipt. Activation is intentional; stale receipts never replay commands. */
-export declare const resume: (page: Page, receipt: PageSuspension, options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-//#endregion
-export { PageExecutionState, PageSuspension };
-export {};
-//# sourceMappingURL=PageControl.d.mts.map

package/dist/PageControl.mjs

@@ -1,34 +0,0 @@
-import { BrowserError, Reasons } from "./Errors.mjs";
-import { PageExecutionState, PageSuspension } from "./BrowserData.mjs";
-import { s as pageControl } from "./PageRegistry-B3q9DS3g.mjs";
-import { n as checkedOperationOptions } from "./PublicSession-DCSMMqOj.mjs";
-import { Effect, Schema } from "effect";
-//#region src/PageControl.ts
-const owner = (page) => Effect.suspend(() => {
-	const association = pageControl(page);
-	return association === void 0 ? Effect.fail(BrowserError.make({
-		operation: "page-control",
-		reason: Reasons.UnregisteredSession.make({}),
-		outcome: "undispatched"
-	})) : Effect.succeed(association);
-});
-const invalid = () => BrowserError.make({
-	operation: "page-control",
-	reason: Reasons.Configuration.make({}),
-	outcome: "undispatched"
-});
-const requested = (page, options) => owner(page).pipe(Effect.flatMap((association) => checkedOperationOptions(options, "page-control").pipe(Effect.map((options) => ({
-	port: association.port,
-	page: association.page,
-	options
-})))));
-/** Last acknowledged state; no remote guarantee survives connection loss or external control. */
-const state = (page, options) => requested(page, options).pipe(Effect.flatMap(({ port, page, options }) => port.state(page, options)));
-/** Explicit host-only hold requiring pageControl support; capture ACKs never invoke it. */
-const suspend = (page, options) => requested(page, options).pipe(Effect.flatMap(({ port, page, options }) => port.suspend(page, options)));
-/** Consumes the exact live receipt. Activation is intentional; stale receipts never replay commands. */
-const resume = (page, receipt, options) => Schema.decodeEffect(PageSuspension)(receipt).pipe(Effect.mapError(invalid), Effect.map((value) => Object.freeze(PageSuspension.make({ ...value }))), Effect.flatMap((value) => owner(page).pipe(Effect.flatMap(({ port, page }) => page.pageId !== value.pageId || page.targetId !== value.targetId ? Effect.fail(invalid()) : checkedOperationOptions(options, "page-control").pipe(Effect.flatMap((options) => port.resume(value, options)))))));
-//#endregion
-export { PageExecutionState, PageSuspension, resume, state, suspend };
-
-//# sourceMappingURL=PageControl.mjs.map

package/dist/PageControl.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PageControl.mjs","names":[],"sources":["../src/PageControl.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport type { OperationOptions, Page } from \"./Browser.ts\";\nimport { type PageExecutionState, PageSuspension } from \"./BrowserData.ts\";\nimport { BrowserError, Reasons } from \"./Errors.ts\";\nimport { pageControl } from \"./internal/browser/PageRegistry.ts\";\nimport { checkedOperationOptions } from \"./internal/browser/PublicSession.ts\";\nexport { PageExecutionState, PageSuspension } from \"./BrowserData.ts\";\n\nconst owner = (page: Page) =>\n  Effect.suspend(() => {\n    const association = pageControl(page);\n\n    return association === undefined\n      ? Effect.fail(\n          BrowserError.make({\n            operation: \"page-control\",\n            reason: Reasons.UnregisteredSession.make({}),\n            outcome: \"undispatched\",\n          }),\n        )\n      : Effect.succeed(association);\n  });\n\nconst invalid = () =>\n  BrowserError.make({\n    operation: \"page-control\",\n    reason: Reasons.Configuration.make({}),\n    outcome: \"undispatched\",\n  });\n\nconst requested = (page: Page, options?: OperationOptions) =>\n  owner(page).pipe(\n    Effect.flatMap((association) =>\n      checkedOperationOptions(options, \"page-control\").pipe(\n        Effect.map((options) => ({ port: association.port, page: association.page, options })),\n      ),\n    ),\n  );\n\n/** Last acknowledged state; no remote guarantee survives connection loss or external control. */\nexport const state = (\n  page: Page,\n  options?: OperationOptions,\n): Effect.Effect<PageExecutionState, BrowserError> =>\n  requested(page, options).pipe(\n    Effect.flatMap(({ port, page, options }) => port.state(page, options)),\n  );\n\n/** Explicit host-only hold requiring pageControl support; capture ACKs never invoke it. */\nexport const suspend = (\n  page: Page,\n  options?: OperationOptions,\n): Effect.Effect<PageSuspension, BrowserError> =>\n  requested(page, options).pipe(\n    Effect.flatMap(({ port, page, options }) => port.suspend(page, options)),\n  );\n\n/** Consumes the exact live receipt. Activation is intentional; stale receipts never replay commands. */\nexport const resume = (\n  page: Page,\n  receipt: PageSuspension,\n  options?: OperationOptions,\n): Effect.Effect<void, BrowserError> =>\n  Schema.decodeEffect(PageSuspension)(receipt).pipe(\n    Effect.mapError(invalid),\n    Effect.map((value) => Object.freeze(PageSuspension.make({ ...value }))),\n    Effect.flatMap((value) =>\n      owner(page).pipe(\n        Effect.flatMap(({ port, page }) =>\n          page.pageId !== value.pageId || page.targetId !== value.targetId\n            ? Effect.fail(invalid())\n            : checkedOperationOptions(options, \"page-control\").pipe(\n                Effect.flatMap((options) => port.resume(value, options)),\n              ),\n        ),\n      ),\n    ),\n  );\n"],"mappings":";;;;;;AASA,MAAM,SAAS,SACb,OAAO,cAAc;CACnB,MAAM,cAAc,YAAY,IAAI;CAEpC,OAAO,gBAAgB,KAAA,IACnB,OAAO,KACL,aAAa,KAAK;EAChB,WAAW;EACX,QAAQ,QAAQ,oBAAoB,KAAK,CAAC,CAAC;EAC3C,SAAS;CACX,CAAC,CACH,IACA,OAAO,QAAQ,WAAW;AAChC,CAAC;AAEH,MAAM,gBACJ,aAAa,KAAK;CAChB,WAAW;CACX,QAAQ,QAAQ,cAAc,KAAK,CAAC,CAAC;CACrC,SAAS;AACX,CAAC;AAEH,MAAM,aAAa,MAAY,YAC7B,MAAM,IAAI,CAAC,CAAC,KACV,OAAO,SAAS,gBACd,wBAAwB,SAAS,cAAc,CAAC,CAAC,KAC/C,OAAO,KAAK,aAAa;CAAE,MAAM,YAAY;CAAM,MAAM,YAAY;CAAM;AAAQ,EAAE,CACvF,CACF,CACF;;AAGF,MAAa,SACX,MACA,YAEA,UAAU,MAAM,OAAO,CAAC,CAAC,KACvB,OAAO,SAAS,EAAE,MAAM,MAAM,cAAc,KAAK,MAAM,MAAM,OAAO,CAAC,CACvE;;AAGF,MAAa,WACX,MACA,YAEA,UAAU,MAAM,OAAO,CAAC,CAAC,KACvB,OAAO,SAAS,EAAE,MAAM,MAAM,cAAc,KAAK,QAAQ,MAAM,OAAO,CAAC,CACzE;;AAGF,MAAa,UACX,MACA,SACA,YAEA,OAAO,aAAa,cAAc,CAAC,CAAC,OAAO,CAAC,CAAC,KAC3C,OAAO,SAAS,OAAO,GACvB,OAAO,KAAK,UAAU,OAAO,OAAO,eAAe,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,GACtE,OAAO,SAAS,UACd,MAAM,IAAI,CAAC,CAAC,KACV,OAAO,SAAS,EAAE,MAAM,WACtB,KAAK,WAAW,MAAM,UAAU,KAAK,aAAa,MAAM,WACpD,OAAO,KAAK,QAAQ,CAAC,IACrB,wBAAwB,SAAS,cAAc,CAAC,CAAC,KAC/C,OAAO,SAAS,YAAY,KAAK,OAAO,OAAO,OAAO,CAAC,CACzD,CACN,CACF,CACF,CACF"}