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

package/dist/Bootstrap-CeQOWBy6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Bootstrap-CeQOWBy6.mjs","names":["Origin","Registration.Origin","Registration.FailureMode","Registration.schema","Registration.make"],"sources":["../src/internal/browser/BindingRegistration.ts","../src/Bootstrap.ts"],"sourcesContent":["import { Effect, Result, Schema } from \"effect\";\n\nimport type * as Bootstrap from \"../../Bootstrap.ts\";\nimport { Identifier } from \"../../BrowserData.ts\";\nimport { BrowserError, InitializationError, Reasons } from \"../../Errors.ts\";\n\nconst Invoke = Symbol(\"BrowserBindingRegistration\");\nconst issued = new WeakSet<object>();\n\nexport const Origin = Schema.NonEmptyString.check(\n  Schema.isMaxLength(2048),\n  Schema.makeFilter(\n    (value) => {\n      try {\n        const url = new URL(value);\n\n        return (\n          [\"http:\", \"https:\"].includes(url.protocol) &&\n          url.origin === value &&\n          !url.username &&\n          !url.password\n        );\n      } catch {\n        return false;\n      }\n    },\n    { title: \"an exact http(s) origin\" },\n  ),\n);\n\nexport const FailureMode = Schema.Literals([\"reject-call\", \"fail-session\"]);\n\nconst metadataSchema = Schema.Struct({\n  name: Identifier,\n  origins: Schema.Array(Origin).check(\n    Schema.isMaxLength(16),\n    Schema.isUnique(),\n    Schema.makeFilter((origins) => origins.length > 0, { title: \"at least one allowed origin\" }),\n  ),\n  maxConcurrent: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 64 })),\n  maxInputBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1024 * 1024 })),\n  maxOutputBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 4 * 1024 * 1024 })),\n  timeoutMillis: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 120_000 })),\n  failureMode: FailureMode,\n});\n\ntype Metadata = typeof metadataSchema.Type;\n\nexport interface Registration<E, R> extends Metadata {\n  readonly [Invoke]: (\n    text: string,\n    check: Effect.Effect<void, InitializationError>,\n  ) => Effect.Effect<string, E | InitializationError, R>;\n}\n\n/** Retain an issued live capability at schema boundaries; a copied shape is not authority. */\nexport const schema = Schema.declare<Registration<unknown, unknown>>(\n  (value): value is Registration<unknown, unknown> =>\n    typeof value === \"object\" && value !== null && issued.has(value),\n  { title: \"an issued browser binding registration\" },\n);\n\nconst issue = <E, R>(\n  metadata: Metadata,\n  invoke: Registration<E, R>[typeof Invoke],\n): Registration<E, R> => {\n  const registration = Object.freeze({\n    ...metadata,\n    origins: Object.freeze([...metadata.origins]),\n    [Invoke]: invoke,\n  });\n\n  issued.add(registration);\n\n  return registration;\n};\n\n/** Pack heterogeneous codecs and handlers while their concrete input/output types are known. */\nexport const make = <I, IEncoded, O, OEncoded, E, R>(\n  options: Bootstrap.BindingOptions<I, IEncoded, O, OEncoded, E, R>,\n): Registration<E, R> => {\n  const {\n    maxConcurrent = 1,\n    maxInputBytes = 65536,\n    maxOutputBytes = 65536,\n    timeoutMillis = 10000,\n    failureMode = \"reject-call\",\n  } = options;\n\n  const decoded = Schema.decodeResult(metadataSchema)({\n    ...options,\n    maxConcurrent,\n    maxInputBytes,\n    maxOutputBytes,\n    timeoutMillis,\n    failureMode,\n  });\n\n  if (Result.isFailure(decoded)) throw decoded.failure;\n  const metadata = decoded.success;\n\n  const { input, output, handle } = options;\n\n  if (!Schema.isSchema(input) || !Schema.isSchema(output) || typeof handle !== \"function\") {\n    throw new TypeError(\"Invalid binding registration\");\n  }\n\n  const fail = (reason: \"input\" | \"output\") =>\n    InitializationError.make({ operation: \"callback\", step: metadata.name, reason });\n\n  return issue(\n    metadata,\n    Effect.fnUntraced(function* (text, check) {\n      if (new TextEncoder().encode(text).length > metadata.maxInputBytes)\n        return yield* fail(\"input\");\n\n      const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(input))(text).pipe(\n        Effect.catchCause(() => Effect.fail(fail(\"input\"))),\n      );\n\n      yield* check;\n      const value = yield* Effect.suspend(() => handle(decoded));\n\n      const encoded = yield* Schema.encodeEffect(output)(value).pipe(\n        Effect.catchCause(() => Effect.fail(fail(\"output\"))),\n      );\n\n      const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(\n        Effect.catchCause(() => Effect.fail(fail(\"output\"))),\n      );\n\n      const result = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Json))(json).pipe(\n        Effect.catchCause(() => Effect.fail(fail(\"output\"))),\n      );\n\n      if (new TextEncoder().encode(result).length > metadata.maxOutputBytes)\n        return yield* fail(\"output\");\n\n      return result;\n    }),\n  );\n};\n\n/** Authentication is identity-based even when a caller copies every enumerable field/symbol. */\nexport const snapshot = Effect.fnUntraced(function* <E, R>(\n  registration: Registration<E, R>,\n): Effect.fn.Return<Registration<E, R>, BrowserError> {\n  const invalid = () =>\n    BrowserError.make({\n      operation: \"configure\",\n      reason: Reasons.Configuration.make({}),\n      outcome: \"undispatched\",\n    });\n\n  if (!issued.has(registration)) return yield* invalid();\n\n  const metadata = yield* Schema.decodeEffect(metadataSchema)(registration).pipe(\n    Effect.mapError(invalid),\n  );\n\n  return issue(metadata, registration[Invoke]);\n});\n\nexport const invoke = <E, R>(\n  registration: Registration<E, R>,\n  text: string,\n  check: Effect.Effect<void, InitializationError>,\n): Effect.Effect<string, E | InitializationError, R> => registration[Invoke](text, check);\n","import { type Cause, type Effect, Schema } from \"effect\";\n\nimport { Identifier } from \"./BrowserData.ts\";\nimport type { InitializationError } from \"./Errors.ts\";\nimport * as Registration from \"./internal/browser/BindingRegistration.ts\";\n\n/**\n * Exact scheme-and-host origin, as a document reports it. Patterns are deliberately absent:\n * a registration that cannot say exactly where it applies does not belong in a plan.\n */\nexport const Origin = Registration.Origin;\n\nexport type Origin = typeof Origin.Type;\n\n/**\n * The reviewed subset of native permission capabilities. Each name is checked against a real\n * browser in native acceptance; an unsupported capability is refused before it is exposed.\n */\nexport const Permission = Schema.Literals([\n  \"accelerometer\",\n  \"background-sync\",\n  \"camera\",\n  \"clipboard-read\",\n  \"clipboard-write\",\n  \"geolocation\",\n  \"gyroscope\",\n  \"magnetometer\",\n  \"microphone\",\n  \"midi\",\n  \"notifications\",\n  \"payment-handler\",\n  \"storage-access\",\n]);\n\nexport type Permission = typeof Permission.Type;\n\nexport const PermissionGrant = Schema.Struct({\n  origin: Origin,\n  permissions: Schema.Array(Permission).check(Schema.isMaxLength(16), Schema.isUnique()),\n});\n\nexport type PermissionGrant = typeof PermissionGrant.Type;\n\n/**\n * Registration is not readiness. A script may start asynchronous work, but it cannot pause the\n * website's own scripts, so a document is ready only when its expression resolves to exactly\n * `true`. A document that was already running when the bundle was registered never ran it:\n * `RequireFreshNavigation` reports that instead of pretending otherwise, and an explicit\n * reload of possibly uncertain work stays a caller's decision.\n */\nexport const Readiness = Schema.Struct({\n  expression: Schema.NonEmptyString.check(Schema.isMaxLength(4096)),\n  timeoutMillis: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 120_000 })),\n  existingDocuments: Schema.Literals([\"RequireFreshNavigation\", \"AcceptAlreadyRunning\"]),\n});\n\nexport type Readiness = typeof Readiness.Type;\n\n/** Trusted host configuration. Script content is never model output or page input. */\nexport const InitScript = Schema.Struct({\n  id: Identifier,\n  content: Schema.NonEmptyString.check(Schema.isMaxLength(64 * 1024)),\n  /** When present, the step runs only on these documents and readiness skips the rest. */\n  origins: Schema.optionalKey(\n    Schema.Array(Origin).check(Schema.isMaxLength(16), Schema.isUnique()),\n  ),\n  readiness: Schema.optionalKey(Readiness),\n});\n\nexport type InitScript = typeof InitScript.Type;\n\n/** A callback failure can reject one page invocation or permanently fence the session. */\nexport const BindingFailureMode = Registration.FailureMode;\n\nexport type BindingFailureMode = typeof BindingFailureMode.Type;\n\n/**\n * A registration issued by `binding`. Its private executable closure carries the real consumer\n * E/R; copying the metadata or fabricating an object does not grant callback authority.\n */\nexport type BindingRegistration<E = never, R = never> = Registration.Registration<E, R>;\n\n/**\n * Environment-free boundary codecs keep page data validation separate from consumer services.\n * The handler's E/R remain visible on the Plan and are supplied only by the trusted host.\n */\nexport interface BindingOptions<I, IEncoded, O, OEncoded, E, R> {\n  readonly name: string;\n  readonly origins: ReadonlyArray<Origin>;\n  readonly input: Schema.ConstraintCodec<I, IEncoded, never, never>;\n  readonly output: Schema.ConstraintCodec<O, OEncoded, never, never>;\n  /** Defaults to one concurrent invocation. Explicit values still pass the bounded schema. */\n  readonly maxConcurrent?: number;\n  /** Defaults to 64 KiB. */\n  readonly maxInputBytes?: number;\n  /** Defaults to 64 KiB. */\n  readonly maxOutputBytes?: number;\n  /** Defaults to 10 seconds for the complete invocation. */\n  readonly timeoutMillis?: number;\n  /** Defaults to rejecting this invocation without terminating the session. */\n  readonly failureMode?: BindingFailureMode;\n  readonly handle: (input: I) => Effect.Effect<O, E, R>;\n}\n\n/**\n * One ordered bundle plus its host capabilities. Callback registrations preserve E/R through\n * their executable closures; static script/permission plans remain serializable values.\n */\nexport interface Plan<E = unknown, R = unknown> {\n  readonly scripts: ReadonlyArray<InitScript>;\n  readonly permissions: ReadonlyArray<PermissionGrant>;\n  readonly bindings?: ReadonlyArray<BindingRegistration<E, R>>;\n}\n\n/** Host-only typed evidence. Causes are never logged or returned to page callers. */\nexport interface BindingFailure<E> {\n  readonly name: string;\n  readonly mode: BindingFailureMode;\n  readonly cause: Cause.Cause<E | InitializationError>;\n}\n\nexport interface BindingStatistics {\n  readonly name: string;\n  readonly inFlight: number;\n  readonly pendingNative: number;\n  /** Finished/interrupted invocations whose native work or disposal has not settled. */\n  readonly retired: number;\n  readonly accepted: number;\n  readonly succeeded: number;\n  readonly rejected: number;\n}\n\n/** Copied snapshot: at most sixteen bindings and the latest thirty-two failure records. */\nexport interface BindingDiagnostics<E> {\n  readonly faulted: boolean;\n  readonly bindings: ReadonlyArray<BindingStatistics>;\n  readonly failures: ReadonlyArray<BindingFailure<E>>;\n  readonly droppedFailures: number;\n}\n\n/**\n * Static plans remain serializable. Live binding plans retain issued registrations by identity;\n * this schema neither executes their callbacks nor turns copied metadata into authority. Typed\n * acquisition validates a separate snapshot so consumer E/R is not erased by a generic decoder.\n */\nexport const Plan = Schema.Struct({\n  scripts: Schema.Array(InitScript).check(Schema.isMaxLength(16)),\n  permissions: Schema.Array(PermissionGrant).check(Schema.isMaxLength(16)),\n  bindings: Schema.optionalKey(Schema.Array(Registration.schema).check(Schema.isMaxLength(16))),\n});\n\ntype AnyPlan = Plan<unknown, unknown>;\n\nexport type PlanError<P extends AnyPlan> = P extends Plan<infer E, infer _R> ? E : never;\nexport type PlanRequirements<P extends AnyPlan> = P extends Plan<infer _E, infer R> ? R : never;\n\nexport const empty: Plan<never, never> = { scripts: [], permissions: [] };\n\nexport const init = (script: InitScript): Plan<never, never> => ({\n  scripts: [script],\n  permissions: [],\n});\n\nexport const permissions = (grant: PermissionGrant): Plan<never, never> => ({\n  scripts: [],\n  permissions: [grant],\n});\n\n/**\n * Register a page-callable host callback without running it or capturing an ambient runtime.\n * Native installation later owns origin/document checks, bounded admission and disposal.\n */\nexport const binding = <I, IEncoded, O, OEncoded, E, R>(\n  options: BindingOptions<I, IEncoded, O, OEncoded, E, R>,\n): Plan<E, R> => ({\n  scripts: [],\n  permissions: [],\n  bindings: [Registration.make(options)],\n});\n\n/** Combination is ordered and preserves every callback's consumer E/R union. */\nexport function combine<const Plans extends ReadonlyArray<AnyPlan>>(\n  ...plans: Plans\n): Plan<PlanError<Plans[number]>, PlanRequirements<Plans[number]>>;\n\nexport function combine(...plans: ReadonlyArray<AnyPlan>): AnyPlan {\n  const bindings = plans.flatMap((plan) => (plan.bindings === undefined ? [] : [...plan.bindings]));\n\n  return {\n    scripts: plans.flatMap((plan) => [...plan.scripts]),\n    permissions: plans.flatMap((plan) => [...plan.permissions]),\n    ...(bindings.length === 0 ? {} : { bindings }),\n  };\n}\n\n/** What the current document is, not a promise about any other document. */\nexport type ReadinessOutcome =\n  | { readonly _tag: \"Ready\" }\n  | { readonly _tag: \"NotApplicable\" }\n  | { readonly _tag: \"RequiresNavigation\" };\n"],"mappings":"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"}

package/dist/Bootstrap.d.mts

@@ -1,3 +0,0 @@
-import { _ as binding, a as BindingRegistration, b as init, c as InitScript, d as PermissionGrant, f as Plan, g as ReadinessOutcome, h as Readiness, i as BindingOptions, l as Origin, m as PlanRequirements, n as BindingFailure, o as BindingStatistics, p as PlanError, r as BindingFailureMode, t as BindingDiagnostics, u as Permission, v as combine, x as permissions, y as empty } from "./Bootstrap-B9UUXsvF.mjs";
-export { BindingDiagnostics, BindingFailure, BindingFailureMode, BindingOptions, BindingRegistration, BindingStatistics, InitScript, Origin, Permission, PermissionGrant, Plan, PlanError, PlanRequirements, Readiness, ReadinessOutcome, binding, combine, empty, init, permissions };
-export {};

package/dist/Bootstrap.mjs

@@ -1,2 +0,0 @@
-import { a as PermissionGrant, c as binding, d as init, f as permissions, i as Permission, l as combine, n as InitScript, o as Plan, r as Origin, s as Readiness, t as BindingFailureMode, u as empty } from "./Bootstrap-CeQOWBy6.mjs";
-export { BindingFailureMode, InitScript, Origin, Permission, PermissionGrant, Plan, Readiness, binding, combine, empty, init, permissions };

package/dist/Browser-BF9_sORP.d.mts

@@ -1,388 +0,0 @@
-import { f as Plan, g as ReadinessOutcome, s as Bootstrap_d_exports, t as BindingDiagnostics } from "./Bootstrap-B9UUXsvF.mjs";
-import { BrowserError, BrowserOperation, Containment, InitializationError } from "./Errors.mjs";
-import { $ as Target, A as NavigationResult, B as PressRequest, D as KeyStroke, G as ScreenshotResult, I as PageInfo, K as ScrollRequest, M as ObservationOptions, P as ObservedElement, Q as StartNavigationRequest, R as PointerMoveRequest, V as ReadTextRequest, W as ScreenshotRequest, Z as SessionStatus, a as BrowserDiagnostics, b as HoverRequest, c as CheckpointOptions, ct as WaitForElementRequest, f as FillFormOptions, h as FillRequest, it as Viewport, j as Observation, k as NavigateRequest, l as ClickRequest, lt as WheelRequest, m as FillFormResult, p as FillFormRequest, q as SelectOptions, rt as TypeRequest, s as Checkpoint, t as ActionResult, tt as TextResult, u as ControlFacts, w as InputReceipt, y as FrameInfo } from "./BrowserData-CPIIIHol.mjs";
-import { A as PlanEncoded, D as PerformedEncoded, K as StepAttempt, N as Ran, P as RanStep, U as SettledEvidence, a as AttemptSnapshot, b as LivePlanEncoded, f as DescriptorEncoded, h as InputBindings, k as Plan$1, y as LivePlan, z as ResolveGuard } from "./PlanData-B668RxbQ.mjs";
-import { R as TimelineError, y as PageEvent } from "./TimelineData-BsOn-YGZ.mjs";
-import { t as Timeline } from "./Timeline-fV22Xk-S.mjs";
-import { Duration, Effect, Schema, Scope, Stream } from "effect";
-//#region src/Plan.d.ts
-/** All execution stays on the issued Page/Frame and its original scoped owner. */
-interface RunOptions extends OperationOptions {
-  readonly style?: "plain" | PerformedEncoded;
-  /** Intended boundary in this owner's original monotonic runtime, measured when executed. */
-  readonly startAt?: bigint;
-  readonly within?: Duration.Input;
-  readonly through?: string;
-  readonly inputs?: InputBindings;
-  readonly policy?: ElementAdmission;
-  readonly checkpoint?: CheckpointOptions;
-}
-/**
- * Check and normalize host run options exactly as `page.start` and `page.run` will, without
- * exposing private deadline/queue accounting fields. A caller that builds options from untrusted
- * configuration can fail early with the same `Configuration` refusal.
- */
-declare const checkRunOptions: (value: unknown) => Effect.Effect<RunOptions, BrowserError>;
-interface StepFailure {
-  readonly stage: "PreparationFailed" | "AttemptFailed";
-  readonly stepId?: string;
-  readonly completed: ReadonlyArray<RanStep>;
-  readonly attempt?: StepAttempt;
-  readonly error: BrowserError;
-}
-declare const StepFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "StepFailed";
-} & Readonly<A>;
-/**
- * Live host failure evidence is not a durable plan or a serialization schema. Its message names
- * only the stage, step and reason; the evidence fields can retain authored literal values, so
- * log the message rather than the whole value.
- */
-declare class StepFailed extends StepFailed_base<StepFailure & {
-  readonly message: string;
-}> {
-  constructor(failure: StepFailure);
-}
-declare const RecordingIncomplete_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "RecordingIncomplete";
-} & Readonly<A>;
-declare class RecordingIncomplete extends RecordingIncomplete_base<{
-  readonly stepId?: string;
-  readonly reason: "InvalidThrough" | "NoCompletedSteps" | "IncompleteCapture" | "Unacknowledged";
-}> {}
-/** A retained value keeps its evidence after interruption; joining never submits another walk. */
-interface RunOperation {
-  readonly id: string;
-  readonly attempts: Effect.Effect<AttemptSnapshot>;
-  readonly completed: Effect.Effect<Ran, StepFailed>;
-  readonly cancel: Effect.Effect<void>;
-}
-interface PlanOperations {
-  readonly start: (plan: LivePlanEncoded | PlanEncoded, options?: RunOptions) => Effect.Effect<RunOperation, StepFailed, Scope.Scope>;
-  readonly run: (plan: LivePlanEncoded | PlanEncoded, options?: RunOptions) => Effect.Effect<Ran, StepFailed>;
-}
-/** Validate and normalize authored data, including explicit document/Strict defaults. */
-declare const make: (value: LivePlanEncoded) => Effect.Effect<LivePlan, Schema.SchemaError>;
-/** Descriptor-only ingress for stored intent; it never decodes a live Ref. */
-declare const decode: (value: unknown) => Effect.Effect<Plan$1, Schema.SchemaError>;
-/** The normalized scope and guards are always included in encoded durable intent. */
-declare const encode: (value: Plan$1) => Effect.Effect<PlanEncoded, Schema.SchemaError>;
-/** A named input a plan reads: the step and action path that read it, and how it is used. */
-interface InputSlot {
-  readonly name: string;
-  readonly stepId: string;
-  readonly path: ReadonlyArray<string>;
-  /** `text` is typed key by key into focus; `value` replaces a field's whole contents. */
-  readonly kind: "text" | "value";
-}
-/**
- * The named inputs a stored or live plan reads, in step order. A recorded plan's literal fill and
- * type values are such slots; bind each `name` in `inputs` to replay it.
- */
-declare const inputSlots: (plan: Plan$1 | LivePlan) => ReadonlyArray<InputSlot>;
-/**
- * Project only acknowledged, faithfully captured intent. An explicitly chosen completed prefix
- * can be retained after a later failure by passing the operation's host snapshot and `through`.
- * Literal input values are replaced during capture with deterministic named input slots.
- */
-declare const recorded: (value: Ran | AttemptSnapshot, options?: {
-  readonly through?: string;
-}) => Effect.Effect<Plan$1, RecordingIncomplete>;
-/**
- * Project one `startNavigation` operation, such as an agent-browser `Navigation` receipt's, as a
- * plan of one `Navigate` step named `id` ("navigate" by default). It joins `completed`, which
- * stops nothing: only a navigation that reached DOMContentLoaded is acknowledged, and one that
- * failed, was stopped or interrupted, or whose outcome is unknown is refused `Unacknowledged`.
- * The step repeats the request, not the address a redirect reached, as a recorded run's
- * Navigate step does. An `id` that is not a step identifier fails `IncompleteCapture`.
- */
-declare const recordedNavigation: (operation: NavigationOperation, options?: {
-  readonly id?: string;
-}) => Effect.Effect<Plan$1, RecordingIncomplete>;
-//#endregion
-//#region src/Browser.d.ts
-/**
- * Host-only ordinary admission. Omission or zero fails immediately; positive finite duration
- * queues FIFO. Page closure uses reserved fail-fast admission and a deadline-bounded shared close.
- */
-interface AdmissionOptions {
-  readonly queue?: Duration.Input;
-}
-/** Explicit host options, separate from request data and exact-element admission callbacks. */
-interface OperationOptions {
-  readonly timeoutMillis?: number;
-  readonly admission?: AdmissionOptions;
-}
-/** Explicit descriptor guard and ordinary host admission; no selector or geometry fallback. */
-interface ResolveOptions extends OperationOptions {
-  readonly guard?: typeof ResolveGuard.Encoded;
-}
-/** Named native quiet signals within the original positive finite deadline. */
-interface SettledRequest {
-  readonly quiet: Duration.Input;
-  readonly within: Duration.Input;
-}
-/** A bounded host-memory snapshot; it grants no priority or native authority. */
-interface AdmissionStatus {
-  readonly active: BrowserOperation | null;
-  readonly waiting: number;
-  readonly maximum: number;
-  readonly oldestWaitMillis: number | null;
-  readonly nativePending: number;
-  readonly nativeWaitPending: boolean;
-  readonly stopSetupPending: boolean;
-}
-interface SessionAdmissionStatus {
-  readonly waiting: number;
-  readonly maximum: number;
-  readonly nativePending: number;
-  readonly nativeMaximum: number;
-  readonly nativeWaits: number;
-  readonly stopSetups: number;
-  readonly registry: AdmissionStatus;
-}
-/** Terminal facts remain readable after this page loses live authority. */
-interface PageStatus {
-  readonly identity: Target;
-  readonly phase: "open" | "paused" | "closing" | "closed" | "stale";
-  readonly containment: Containment;
-  readonly admission: AdmissionStatus;
-}
-interface PageOperations {
-  readonly navigate: (request: NavigateRequest, options?: OperationOptions) => Effect.Effect<NavigationResult, BrowserError>;
-  /** `navigate`, left in flight: the same single dispatch, completed by the caller. */
-  readonly startNavigation: (request: StartNavigationRequest, options?: OperationOptions) => Effect.Effect<NavigationOperation, BrowserError, Scope.Scope>;
-  readonly readText: (request: ReadTextRequest, options?: OperationOptions) => Effect.Effect<TextResult, BrowserError>;
-  readonly click: (request: ClickRequest, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  readonly fill: (request: FillRequest, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  /** Script in the page: instantaneous, and it raises no wheel event. */
-  readonly scroll: (request: ScrollRequest, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  /** One real pointer move, in main-frame viewport pixels. */
-  readonly pointerMove: (request: PointerMoveRequest, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Places the pointer on one exact element where it is, or fails `not-visible` unsent. */
-  readonly hover: (request: HoverRequest, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** One real wheel event; the browser decides what under the pointer scrolls. */
-  readonly wheel: (request: WheelRequest, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** One real key stroke to whatever has focus, or fails `not-focused` unsent if `into` lacks it. */
-  readonly press: (request: PressRequest, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Text as the real key strokes that produce it, under the same focus rule as `press`. */
-  readonly type: (request: TypeRequest, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  readonly screenshot: (request: ScreenshotRequest, options?: OperationOptions) => Effect.Effect<ScreenshotResult, BrowserError>;
-  /**
-   * The one observation whose nodes later actions may name. `scope: "viewport"` keeps only text
-   * and controls that are on screen and reachable, plus bounded choices of visible native
-   * selects; the default reads the whole document. It carries no destination, form or field value.
-   */
-  readonly observe: (options?: ObservationOptions, operationOptions?: OperationOptions) => Effect.Effect<Observation, BrowserError>;
-  /**
-   * Passive evidence for a recorder, with a picture when asked. It issues no references and
-   * leaves the observation above exactly as it was. Host-only: it carries control facts.
-   */
-  readonly checkpoint: (options?: CheckpointOptions, operationOptions?: OperationOptions) => Effect.Effect<Checkpoint, BrowserError>;
-  /** Host-only facts about one observed control, read from that exact node just now. */
-  readonly controlFacts: (reference: ObservedElement, options?: OperationOptions) => Effect.Effect<ControlFacts, BrowserError>;
-  /**
-   * After a page hold, nothing observed on that page may be acted on unchecked. This checks one
-   * reference: still attached, and still the control that was inspected. It never searches by
-   * selector or label for a substitute, and it sends nothing.
-   */
-  readonly revalidateElement: (reference: ObservedElement, options?: OperationOptions) => Effect.Effect<ObservedElement, BrowserError>;
-  readonly clickElement: (reference: ObservedElement, admission?: ElementAdmission, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  readonly fillElement: (reference: ObservedElement, value: string, admission?: ElementAdmission, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  /** One selection using this exact select and its issued option element IDs, with fresh checks. */
-  readonly selectOption: (reference: ObservedElement, options: SelectOptions, admission?: ElementAdmission, operationOptions?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  readonly hoverElement: (reference: ObservedElement, admission?: ElementAdmission, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** A key stroke sent only if the exact node an observation named already has focus. */
-  readonly pressElement: (reference: ObservedElement, stroke: KeyStroke, admission?: ElementAdmission, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Real typing with `fillElement`'s exactness: that node must already have focus. */
-  readonly typeElement: (reference: ObservedElement, text: string, admission?: ElementAdmission, options?: OperationOptions) => Effect.Effect<InputReceipt, BrowserError>;
-  /**
-   * Set several controls of one observation in order, then optionally click one submit control.
-   * Every step acts on the exact observed node after the same fresh checks as `fillElement`,
-   * except that a control may have become enabled since it was observed, and each is admitted
-   * and charged as its own action. The observation stays usable for this form's own steps only;
-   * anything else that changes the page still retires it, and the form retires it when it ends.
-   * The first refused or uncertain step ends the form. Submit is sent only after every field
-   * succeeded and, unless `verify` is false, still holds what its step left there. Fields set
-   * before a stop stay set. It fails only when its first step does; otherwise `stopped` says
-   * where it ended and why.
-   */
-  readonly fillForm: (request: FillFormRequest, admission?: ElementAdmission, options?: FillFormOptions, operationOptions?: OperationOptions) => Effect.Effect<FillFormResult, BrowserError>;
-  /**
-   * Wait on the original observed node within the host deadline. Hidden includes its detachment;
-   * document replacement is stale. Success observes a condition, without authorizing later input.
-   */
-  readonly waitForElement: (request: WaitForElementRequest, options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-  readonly waitFor: (request: {
-    readonly selector: string;
-    readonly state: "visible" | "hidden" | "attached" | "detached";
-  }, options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-  /** Navigation observation is registered before the single click dispatch. */
-  readonly clickAndWait: (request: ClickRequest, options?: OperationOptions) => Effect.Effect<ActionResult, BrowserError>;
-  /**
-   * Readiness of the current document only. Dependent operations wait for it themselves;
-   * this reports it without charging an action, so a caller can decide what to do about a
-   * document that predates the registrations.
-   */
-  readonly ready: (options?: OperationOptions) => Effect.Effect<ReadinessOutcome, InitializationError>;
-}
-/**
- * Issued live authority for one native frame; navigation keeps the frame and retires its references.
- *
- * Pass the issued object itself. Capture, page control, provider transfers, agent tools and
- * `checkPage` authenticate it by identity, so a spread copy, wrapper or Proxy is refused
- * `UnregisteredSession` even though its copied methods still run. Observe work through the
- * timeline and run receipts rather than by wrapping methods.
- */
-interface Frame extends PageOperations, PlanOperations {
-  readonly identity: Target;
-  readonly status: Effect.Effect<PageStatus>;
-  /**
-   * The original owner's host monotonic clock, the same one `session.monotonicTimeNanos` reads,
-   * so a host bound to this Page or Frame can compute a plan's `startAt` without the session.
-   */
-  readonly monotonicTimeNanos: Effect.Effect<bigint>;
-  /** Resolve full descriptor intent against the complete current native candidate inventory. */
-  readonly resolve: (descriptor: DescriptorEncoded, options?: ResolveOptions) => Effect.Effect<ObservedElement, BrowserError>;
-  /**
-   * Quiet DOM mutation, scroll, root geometry and viewport signals in one pinned document.
-   * This does not establish network, animation or business completion.
-   */
-  readonly settled: (request: SettledRequest, options?: OperationOptions) => Effect.Effect<SettledEvidence, BrowserError>;
-}
-/** Issued live authority for one native page on its original connection; pass it as issued, see `Frame`. */
-interface Page extends Frame {
-  /** Evidence for this issued Page's original domain; navigation does not change its journal. */
-  readonly timeline: Timeline;
-  /**
-   * Read this page's address and title. Like `listFrames`, it is a read of the page and shares
-   * its permit; pass `admission.queue` to wait behind work already running there.
-   */
-  readonly describe: (options?: OperationOptions) => Effect.Effect<PageInfo, BrowserError>;
-  readonly listFrames: (options?: OperationOptions) => Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;
-  /** Issue a child Frame. Like `session.page`, issuing takes the registry permit, not this page's. */
-  readonly frame: (info: FrameInfo, options?: OperationOptions) => Effect.Effect<Frame, BrowserError>;
-  readonly resizeViewport: (viewport: Viewport, options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-  /** Reserved fail-fast admission; timeoutMillis bounds joining a close, not admission.queue. */
-  readonly close: (options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-}
-/**
- * A host's decision about one control, made on facts read from the exact node immediately
- * before input. Returning anything but `true`, or throwing, sends nothing and fails `denied`.
- * It is a plain synchronous function on purpose: it runs while the owner's permit is held, where
- * waiting on a model or a network call would stall other ordinary operations on that Page. It is not an atomic
- * check-and-input transaction, because page script can still run before the native input lands.
- */
-interface ElementAdmission {
-  readonly admit: (facts: ControlFacts) => boolean;
-}
-/**
- * A navigation the browser is still performing. The owner's permit was released when it was
- * dispatched, so while it loads a host may read, `checkpoint`, hold and resume this page, and
- * use any other page. Anything that would change this page fails `busy` until it settles.
- *
- * Leaving its scope unsettled revokes and attempts to close its exact page. Positive closure
- * preserves healthy peers; unconfirmed closure fences the session. Its outcome remains unknown
- * because nothing then knows what the browser did. It is never replayed.
- */
-interface NavigationOperation {
-  /** What was navigated, read before dispatch. */
-  readonly target: Target;
-  /**
-   * What was asked for, as checked before dispatch. `Plan.recordedNavigation` records this
-   * request, not the address `completed` reports after any redirect.
-   */
-  readonly request: StartNavigationRequest;
-  /**
-   * The document reached DOMContentLoaded. It belongs to this one navigation: a successor that
-   * reaches the same URL fails it instead. Interrupting a waiter stops nothing in the browser.
-   */
-  readonly completed: Effect.Effect<NavigationResult, BrowserError>;
-  /**
-   * Asks the browser to stop loading and waits for this navigation to settle, after which
-   * `completed` fails `interrupted`. Success is a known outcome and the session stays usable:
-   * the page holds whatever had loaded. It does not undo anything the page already did.
-   * An already-completed navigation cannot stop a successor. Concurrent callers share their
-   * active attempt. Before dispatch, cancellation or a busy refusal permits a later request
-   * once native setup has retired. A dispatched attempt's outcome, including failure or
-   * interruption, is retained permanently; an uncertain stop is never replayed.
-   */
-  readonly stop: Effect.Effect<void, BrowserError>;
-}
-/**
- * Host control over one owned browser. This is not a serializable model value: copying a
- * session object cannot copy its capture, page-control or connection authority.
- *
- * Browser operations belong to issued Page and Frame objects. Display selection and owner
- * lifecycle are separate from those exact capabilities.
- */
-interface BrowserSession<E = never> {
-  /** The original owner's host clock, for same-runtime absolute cue scheduling. */
-  readonly monotonicTimeNanos: Effect.Effect<bigint>;
-  /** Stable facade: each snapshot/stream captures the current journal when it executes. */
-  readonly timeline: Timeline;
-  /** Atomic cached Inventory baseline followed by lifecycle evidence on its pinned journal. */
-  readonly pages: Stream.Stream<PageEvent, TimelineError>;
-  /** The page acquired on the initial connection, independent of later display selection. */
-  readonly initialPage: Page;
-  /**
-   * Authenticate `info` against the live native page and return its canonical issued Page. This
-   * takes the registry permit, not the page's own: it never waits for, or fails `busy` on, work
-   * already running on that page.
-   */
-  readonly page: (info: PageInfo, options?: OperationOptions) => Effect.Effect<Page, BrowserError>;
-  readonly listPages: (options?: OperationOptions) => Effect.Effect<ReadonlyArray<PageInfo>, BrowserError>;
-  /** The implementation which owns this live connection. */
-  readonly implementation: string;
-  /** Copied host-only state, readable without admission in every lifecycle phase. */
-  readonly status: Effect.Effect<SessionStatus>;
-  /** Bounded native/policy diagnostics. Typed callback causes remain in bindingDiagnostics. */
-  readonly diagnostics: Effect.Effect<BrowserDiagnostics>;
-  readonly admission: Effect.Effect<SessionAdmissionStatus>;
-  /** Close this scope and require its own ownership-specific cleanup evidence. */
-  readonly closeChecked: Effect.Effect<void, BrowserError>;
-  /** First fail-session callback cause, preserving the consumer's error type on the host. */
-  readonly failure: Effect.Effect<never, E | InitializationError>;
-  /** Bounded host-only evidence; consumer causes are never projected into a page reply. */
-  readonly bindingDiagnostics: Effect.Effect<BindingDiagnostics<E>>;
-  /**
-   * Choose the displayed page, which is also the page `detach` records and `reconnect` resumes on.
-   * Nothing else: it never retargets a Page or Frame operation, which keep their own exact
-   * authority. Pass a Page this session issued; a closed or stale one is refused unsent.
-   */
-  readonly selectPage: (page: Page, options?: OperationOptions) => Effect.Effect<void, BrowserError>;
-  /**
-   * Open a page in its own window, sized like the others, without selecting it, and return the
-   * Page issued for it. Chromium paints every window, so any page can be pictured and read at
-   * speed, not only the one in front. Registry admission fails immediately by default; pass a
-   * positive finite admission.queue to wait FIFO within the operation deadline.
-   */
-  readonly createPage: (options?: OperationOptions) => Effect.Effect<Page, BrowserError>;
-}
-/** Helpers that do not supervise callback failures accept any live browser session. */
-type AnySession = BrowserSession<unknown>;
-/**
- * Check that `page` is a Page or Frame this session issued, by identity, and that its authority
- * is still current: a foreign or copied object fails `UnregisteredSession`, a closed, stale or
- * detached one fails with the same refusal its own operations would report. Adapters such as
- * agent-browser hosts call it once when they bind, so a wrong target fails before any work.
- */
-declare const checkPage: (session: AnySession, page: Page | Frame) => Effect.Effect<void, BrowserError>;
-/** Dependencies are captured at acquisition, not erased into an environment-free service Layer. */
-interface OpenOptions<E = never, R = never> {
-  readonly bootstrap?: Plan<E, R>;
-}
-/**
- * Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete
- * Chromium or provider session type. Its scoped work is joined before checked browser cleanup,
- * and cleanup failures remain typed even when the callback has already failed or was cancelled.
- * Acquisition is evaluated once; an uncertain result is never retried.
- */
-declare const scoped: {
-  <S extends BrowserSession<unknown>, A, E2, R2>(f: (session: S) => Effect.Effect<A, E2, R2>): <E, AE, AR>(open: Effect.Effect<S & BrowserSession<E>, AE, AR>) => Effect.Effect<A, AE | E | E2 | InitializationError | BrowserError, Exclude<AR | R2, Scope.Scope>>;
-  <S, E, AE, AR, A, E2, R2>(open: Effect.Effect<S & BrowserSession<E>, AE, AR>, f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>): Effect.Effect<A, AE | E | E2 | InitializationError | BrowserError, Exclude<AR | R2, Scope.Scope>>;
-};
-//#endregion
-export { recordedNavigation as A, StepFailed as C, inputSlots as D, encode as E, make as O, RunOptions as S, decode as T, scoped as _, ElementAdmission as a, RecordingIncomplete as b, OpenOptions as c, PageOperations as d, PageStatus as f, checkPage as g, SettledRequest as h, BrowserSession as i, recorded as k, OperationOptions as l, SessionAdmissionStatus as m, AdmissionStatus as n, Frame as o, ResolveOptions as p, AnySession as r, NavigationOperation as s, AdmissionOptions as t, Page as u, InputSlot as v, checkRunOptions as w, RunOperation as x, PlanOperations as y };
-export {};
-//# sourceMappingURL=Browser-BF9_sORP.d.mts.map

package/dist/Browser.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Browser.mjs","names":[],"sources":["../src/Browser.ts"],"sourcesContent":["import { type Duration, Effect, type Scope, type Stream } from \"effect\";\nimport { dual } from \"effect/Function\";\n\nimport type * as Bootstrap from \"./Bootstrap.ts\";\nimport type {\n  BrowserDiagnostics,\n  Checkpoint,\n  CheckpointOptions,\n  FillFormOptions,\n  FillFormRequest,\n  FillFormResult,\n  FillRequest,\n  HoverRequest,\n  InputReceipt,\n  KeyStroke,\n  NavigateRequest,\n  NavigationResult,\n  ObservationOptions,\n  ObservedElement,\n  PointerMoveRequest,\n  PressRequest,\n  ReadTextRequest,\n  ScreenshotRequest,\n  ScreenshotResult,\n  ScrollRequest,\n  SelectOptions,\n  SessionStatus,\n  StartNavigationRequest,\n  TextResult,\n  TypeRequest,\n  WaitForElementRequest,\n  WheelRequest,\n  ControlFacts,\n  ActionResult,\n  ClickRequest,\n  FrameInfo,\n  Observation,\n  PageInfo,\n  Target,\n  Viewport,\n} from \"./BrowserData.ts\";\nimport type { BrowserError, BrowserOperation, Containment, InitializationError } from \"./Errors.ts\";\nimport { resolveTargetControlsForSession } from \"./internal/browser/PageRegistry.ts\";\nimport type { PlanOperations } from \"./Plan.ts\";\nimport type { DescriptorEncoded, ResolveGuard, SettledEvidence } from \"./PlanData.ts\";\nimport type { Timeline } from \"./Timeline.ts\";\nimport type { PageEvent, TimelineError } from \"./TimelineData.ts\";\n\n/**\n * Host-only ordinary admission. Omission or zero fails immediately; positive finite duration\n * queues FIFO. Page closure uses reserved fail-fast admission and a deadline-bounded shared close.\n */\nexport interface AdmissionOptions {\n  readonly queue?: Duration.Input;\n}\n\n/** Explicit host options, separate from request data and exact-element admission callbacks. */\nexport interface OperationOptions {\n  readonly timeoutMillis?: number;\n  readonly admission?: AdmissionOptions;\n}\n\n/** Explicit descriptor guard and ordinary host admission; no selector or geometry fallback. */\nexport interface ResolveOptions extends OperationOptions {\n  readonly guard?: typeof ResolveGuard.Encoded;\n}\n\n/** Named native quiet signals within the original positive finite deadline. */\nexport interface SettledRequest {\n  readonly quiet: Duration.Input;\n  readonly within: Duration.Input;\n}\n\n/** A bounded host-memory snapshot; it grants no priority or native authority. */\nexport interface AdmissionStatus {\n  readonly active: BrowserOperation | null;\n  readonly waiting: number;\n  readonly maximum: number;\n  readonly oldestWaitMillis: number | null;\n  readonly nativePending: number;\n  readonly nativeWaitPending: boolean;\n  readonly stopSetupPending: boolean;\n}\n\nexport interface SessionAdmissionStatus {\n  readonly waiting: number;\n  readonly maximum: number;\n  readonly nativePending: number;\n  readonly nativeMaximum: number;\n  readonly nativeWaits: number;\n  readonly stopSetups: number;\n  readonly registry: AdmissionStatus;\n}\n\n/** Terminal facts remain readable after this page loses live authority. */\nexport interface PageStatus {\n  readonly identity: Target;\n  readonly phase: \"open\" | \"paused\" | \"closing\" | \"closed\" | \"stale\";\n  readonly containment: Containment;\n  readonly admission: AdmissionStatus;\n}\n\nexport interface PageOperations {\n  readonly navigate: (\n    request: NavigateRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<NavigationResult, BrowserError>;\n  /** `navigate`, left in flight: the same single dispatch, completed by the caller. */\n  readonly startNavigation: (\n    request: StartNavigationRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<NavigationOperation, BrowserError, Scope.Scope>;\n  readonly readText: (\n    request: ReadTextRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<TextResult, BrowserError>;\n  readonly click: (\n    request: ClickRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  readonly fill: (\n    request: FillRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  /** Script in the page: instantaneous, and it raises no wheel event. */\n  readonly scroll: (\n    request: ScrollRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  /** One real pointer move, in main-frame viewport pixels. */\n  readonly pointerMove: (\n    request: PointerMoveRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Places the pointer on one exact element where it is, or fails `not-visible` unsent. */\n  readonly hover: (\n    request: HoverRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** One real wheel event; the browser decides what under the pointer scrolls. */\n  readonly wheel: (\n    request: WheelRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** One real key stroke to whatever has focus, or fails `not-focused` unsent if `into` lacks it. */\n  readonly press: (\n    request: PressRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Text as the real key strokes that produce it, under the same focus rule as `press`. */\n  readonly type: (\n    request: TypeRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  readonly screenshot: (\n    request: ScreenshotRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<ScreenshotResult, BrowserError>;\n  /**\n   * The one observation whose nodes later actions may name. `scope: \"viewport\"` keeps only text\n   * and controls that are on screen and reachable, plus bounded choices of visible native\n   * selects; the default reads the whole document. It carries no destination, form or field value.\n   */\n  readonly observe: (\n    options?: ObservationOptions,\n    operationOptions?: OperationOptions,\n  ) => Effect.Effect<Observation, BrowserError>;\n  /**\n   * Passive evidence for a recorder, with a picture when asked. It issues no references and\n   * leaves the observation above exactly as it was. Host-only: it carries control facts.\n   */\n  readonly checkpoint: (\n    options?: CheckpointOptions,\n    operationOptions?: OperationOptions,\n  ) => Effect.Effect<Checkpoint, BrowserError>;\n  /** Host-only facts about one observed control, read from that exact node just now. */\n  readonly controlFacts: (\n    reference: ObservedElement,\n    options?: OperationOptions,\n  ) => Effect.Effect<ControlFacts, BrowserError>;\n  /**\n   * After a page hold, nothing observed on that page may be acted on unchecked. This checks one\n   * reference: still attached, and still the control that was inspected. It never searches by\n   * selector or label for a substitute, and it sends nothing.\n   */\n  readonly revalidateElement: (\n    reference: ObservedElement,\n    options?: OperationOptions,\n  ) => Effect.Effect<ObservedElement, BrowserError>;\n  readonly clickElement: (\n    reference: ObservedElement,\n    admission?: ElementAdmission,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  readonly fillElement: (\n    reference: ObservedElement,\n    value: string,\n    admission?: ElementAdmission,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  /** One selection using this exact select and its issued option element IDs, with fresh checks. */\n  readonly selectOption: (\n    reference: ObservedElement,\n    options: SelectOptions,\n    admission?: ElementAdmission,\n    operationOptions?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  readonly hoverElement: (\n    reference: ObservedElement,\n    admission?: ElementAdmission,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** A key stroke sent only if the exact node an observation named already has focus. */\n  readonly pressElement: (\n    reference: ObservedElement,\n    stroke: KeyStroke,\n    admission?: ElementAdmission,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Real typing with `fillElement`'s exactness: that node must already have focus. */\n  readonly typeElement: (\n    reference: ObservedElement,\n    text: string,\n    admission?: ElementAdmission,\n    options?: OperationOptions,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /**\n   * Set several controls of one observation in order, then optionally click one submit control.\n   * Every step acts on the exact observed node after the same fresh checks as `fillElement`,\n   * except that a control may have become enabled since it was observed, and each is admitted\n   * and charged as its own action. The observation stays usable for this form's own steps only;\n   * anything else that changes the page still retires it, and the form retires it when it ends.\n   * The first refused or uncertain step ends the form. Submit is sent only after every field\n   * succeeded and, unless `verify` is false, still holds what its step left there. Fields set\n   * before a stop stay set. It fails only when its first step does; otherwise `stopped` says\n   * where it ended and why.\n   */\n  readonly fillForm: (\n    request: FillFormRequest,\n    admission?: ElementAdmission,\n    options?: FillFormOptions,\n    operationOptions?: OperationOptions,\n  ) => Effect.Effect<FillFormResult, BrowserError>;\n  /**\n   * Wait on the original observed node within the host deadline. Hidden includes its detachment;\n   * document replacement is stale. Success observes a condition, without authorizing later input.\n   */\n  readonly waitForElement: (\n    request: WaitForElementRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<void, BrowserError>;\n  readonly waitFor: (\n    request: {\n      readonly selector: string;\n      readonly state: \"visible\" | \"hidden\" | \"attached\" | \"detached\";\n    },\n    options?: OperationOptions,\n  ) => Effect.Effect<void, BrowserError>;\n  /** Navigation observation is registered before the single click dispatch. */\n  readonly clickAndWait: (\n    request: ClickRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  /**\n   * Readiness of the current document only. Dependent operations wait for it themselves;\n   * this reports it without charging an action, so a caller can decide what to do about a\n   * document that predates the registrations.\n   */\n  readonly ready: (\n    options?: OperationOptions,\n  ) => Effect.Effect<Bootstrap.ReadinessOutcome, InitializationError>;\n}\n\n/**\n * Issued live authority for one native frame; navigation keeps the frame and retires its references.\n *\n * Pass the issued object itself. Capture, page control, provider transfers, agent tools and\n * `checkPage` authenticate it by identity, so a spread copy, wrapper or Proxy is refused\n * `UnregisteredSession` even though its copied methods still run. Observe work through the\n * timeline and run receipts rather than by wrapping methods.\n */\nexport interface Frame extends PageOperations, PlanOperations {\n  readonly identity: Target;\n  readonly status: Effect.Effect<PageStatus>;\n  /**\n   * The original owner's host monotonic clock, the same one `session.monotonicTimeNanos` reads,\n   * so a host bound to this Page or Frame can compute a plan's `startAt` without the session.\n   */\n  readonly monotonicTimeNanos: Effect.Effect<bigint>;\n  /** Resolve full descriptor intent against the complete current native candidate inventory. */\n  readonly resolve: (\n    descriptor: DescriptorEncoded,\n    options?: ResolveOptions,\n  ) => Effect.Effect<ObservedElement, BrowserError>;\n  /**\n   * Quiet DOM mutation, scroll, root geometry and viewport signals in one pinned document.\n   * This does not establish network, animation or business completion.\n   */\n  readonly settled: (\n    request: SettledRequest,\n    options?: OperationOptions,\n  ) => Effect.Effect<SettledEvidence, BrowserError>;\n}\n\n/** Issued live authority for one native page on its original connection; pass it as issued, see `Frame`. */\nexport interface Page extends Frame {\n  /** Evidence for this issued Page's original domain; navigation does not change its journal. */\n  readonly timeline: Timeline;\n  /**\n   * Read this page's address and title. Like `listFrames`, it is a read of the page and shares\n   * its permit; pass `admission.queue` to wait behind work already running there.\n   */\n  readonly describe: (options?: OperationOptions) => Effect.Effect<PageInfo, BrowserError>;\n  readonly listFrames: (\n    options?: OperationOptions,\n  ) => Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;\n  /** Issue a child Frame. Like `session.page`, issuing takes the registry permit, not this page's. */\n  readonly frame: (\n    info: FrameInfo,\n    options?: OperationOptions,\n  ) => Effect.Effect<Frame, BrowserError>;\n  readonly resizeViewport: (\n    viewport: Viewport,\n    options?: OperationOptions,\n  ) => Effect.Effect<void, BrowserError>;\n  /** Reserved fail-fast admission; timeoutMillis bounds joining a close, not admission.queue. */\n  readonly close: (options?: OperationOptions) => Effect.Effect<void, BrowserError>;\n}\n\n/**\n * A host's decision about one control, made on facts read from the exact node immediately\n * before input. Returning anything but `true`, or throwing, sends nothing and fails `denied`.\n * It is a plain synchronous function on purpose: it runs while the owner's permit is held, where\n * waiting on a model or a network call would stall other ordinary operations on that Page. It is not an atomic\n * check-and-input transaction, because page script can still run before the native input lands.\n */\nexport interface ElementAdmission {\n  readonly admit: (facts: ControlFacts) => boolean;\n}\n\n/**\n * A navigation the browser is still performing. The owner's permit was released when it was\n * dispatched, so while it loads a host may read, `checkpoint`, hold and resume this page, and\n * use any other page. Anything that would change this page fails `busy` until it settles.\n *\n * Leaving its scope unsettled revokes and attempts to close its exact page. Positive closure\n * preserves healthy peers; unconfirmed closure fences the session. Its outcome remains unknown\n * because nothing then knows what the browser did. It is never replayed.\n */\nexport interface NavigationOperation {\n  /** What was navigated, read before dispatch. */\n  readonly target: Target;\n  /**\n   * What was asked for, as checked before dispatch. `Plan.recordedNavigation` records this\n   * request, not the address `completed` reports after any redirect.\n   */\n  readonly request: StartNavigationRequest;\n  /**\n   * The document reached DOMContentLoaded. It belongs to this one navigation: a successor that\n   * reaches the same URL fails it instead. Interrupting a waiter stops nothing in the browser.\n   */\n  readonly completed: Effect.Effect<NavigationResult, BrowserError>;\n  /**\n   * Asks the browser to stop loading and waits for this navigation to settle, after which\n   * `completed` fails `interrupted`. Success is a known outcome and the session stays usable:\n   * the page holds whatever had loaded. It does not undo anything the page already did.\n   * An already-completed navigation cannot stop a successor. Concurrent callers share their\n   * active attempt. Before dispatch, cancellation or a busy refusal permits a later request\n   * once native setup has retired. A dispatched attempt's outcome, including failure or\n   * interruption, is retained permanently; an uncertain stop is never replayed.\n   */\n  readonly stop: Effect.Effect<void, BrowserError>;\n}\n\n/**\n * Host control over one owned browser. This is not a serializable model value: copying a\n * session object cannot copy its capture, page-control or connection authority.\n *\n * Browser operations belong to issued Page and Frame objects. Display selection and owner\n * lifecycle are separate from those exact capabilities.\n */\nexport interface BrowserSession<E = never> {\n  /** The original owner's host clock, for same-runtime absolute cue scheduling. */\n  readonly monotonicTimeNanos: Effect.Effect<bigint>;\n  /** Stable facade: each snapshot/stream captures the current journal when it executes. */\n  readonly timeline: Timeline;\n  /** Atomic cached Inventory baseline followed by lifecycle evidence on its pinned journal. */\n  readonly pages: Stream.Stream<PageEvent, TimelineError>;\n  /** The page acquired on the initial connection, independent of later display selection. */\n  readonly initialPage: Page;\n  /**\n   * Authenticate `info` against the live native page and return its canonical issued Page. This\n   * takes the registry permit, not the page's own: it never waits for, or fails `busy` on, work\n   * already running on that page.\n   */\n  readonly page: (info: PageInfo, options?: OperationOptions) => Effect.Effect<Page, BrowserError>;\n  readonly listPages: (\n    options?: OperationOptions,\n  ) => Effect.Effect<ReadonlyArray<PageInfo>, BrowserError>;\n  /** The implementation which owns this live connection. */\n  readonly implementation: string;\n  /** Copied host-only state, readable without admission in every lifecycle phase. */\n  readonly status: Effect.Effect<SessionStatus>;\n  /** Bounded native/policy diagnostics. Typed callback causes remain in bindingDiagnostics. */\n  readonly diagnostics: Effect.Effect<BrowserDiagnostics>;\n  readonly admission: Effect.Effect<SessionAdmissionStatus>;\n  /** Close this scope and require its own ownership-specific cleanup evidence. */\n  readonly closeChecked: Effect.Effect<void, BrowserError>;\n  /** First fail-session callback cause, preserving the consumer's error type on the host. */\n  readonly failure: Effect.Effect<never, E | InitializationError>;\n  /** Bounded host-only evidence; consumer causes are never projected into a page reply. */\n  readonly bindingDiagnostics: Effect.Effect<Bootstrap.BindingDiagnostics<E>>;\n  /**\n   * Choose the displayed page, which is also the page `detach` records and `reconnect` resumes on.\n   * Nothing else: it never retargets a Page or Frame operation, which keep their own exact\n   * authority. Pass a Page this session issued; a closed or stale one is refused unsent.\n   */\n  readonly selectPage: (\n    page: Page,\n    options?: OperationOptions,\n  ) => Effect.Effect<void, BrowserError>;\n  /**\n   * Open a page in its own window, sized like the others, without selecting it, and return the\n   * Page issued for it. Chromium paints every window, so any page can be pictured and read at\n   * speed, not only the one in front. Registry admission fails immediately by default; pass a\n   * positive finite admission.queue to wait FIFO within the operation deadline.\n   */\n  readonly createPage: (options?: OperationOptions) => Effect.Effect<Page, BrowserError>;\n}\n\n/** Helpers that do not supervise callback failures accept any live browser session. */\nexport type AnySession = BrowserSession<unknown>;\n\n/**\n * Check that `page` is a Page or Frame this session issued, by identity, and that its authority\n * is still current: a foreign or copied object fails `UnregisteredSession`, a closed, stale or\n * detached one fails with the same refusal its own operations would report. Adapters such as\n * agent-browser hosts call it once when they bind, so a wrong target fails before any work.\n */\nexport const checkPage = (\n  session: AnySession,\n  page: Page | Frame,\n): Effect.Effect<void, BrowserError> =>\n  resolveTargetControlsForSession(session, page).pipe(Effect.asVoid);\n\n/** Dependencies are captured at acquisition, not erased into an environment-free service Layer. */\nexport interface OpenOptions<E = never, R = never> {\n  readonly bootstrap?: Bootstrap.Plan<E, R>;\n}\n\n/**\n * Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete\n * Chromium or provider session type. Its scoped work is joined before checked browser cleanup,\n * and cleanup failures remain typed even when the callback has already failed or was cancelled.\n * Acquisition is evaluated once; an uncertain result is never retried.\n */\nexport const scoped: {\n  <S extends BrowserSession<unknown>, A, E2, R2>(\n    f: (session: S) => Effect.Effect<A, E2, R2>,\n  ): <E, AE, AR>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n  ) => Effect.Effect<\n    A,\n    AE | E | E2 | InitializationError | BrowserError,\n    Exclude<AR | R2, Scope.Scope>\n  >;\n  <S, E, AE, AR, A, E2, R2>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n    f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>,\n  ): Effect.Effect<\n    A,\n    AE | E | E2 | InitializationError | BrowserError,\n    Exclude<AR | R2, Scope.Scope>\n  >;\n} = dual(\n  2,\n  <S, E, AE, AR, A, E2, R2>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n    f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>,\n  ) =>\n    Effect.scoped(\n      Effect.flatMap(open, (session) =>\n        Effect.scoped(\n          Effect.raceFirst(\n            session.failure,\n            Effect.suspend(() => f(session)),\n          ),\n        ).pipe(Effect.onExit(() => session.closeChecked)),\n      ),\n    ),\n);\n"],"mappings":";;;;;;;;;;AAubA,MAAa,aACX,SACA,SAEA,gCAAgC,SAAS,IAAI,CAAC,CAAC,KAAK,OAAO,MAAM;;;;;;;AAanE,MAAa,SAkBT,KACF,IAEE,MACA,MAEA,OAAO,OACL,OAAO,QAAQ,OAAO,YACpB,OAAO,OACL,OAAO,UACL,QAAQ,SACR,OAAO,cAAc,EAAE,OAAO,CAAC,CACjC,CACF,CAAC,CAAC,KAAK,OAAO,aAAa,QAAQ,YAAY,CAAC,CAClD,CACF,CACJ"}