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

package/src/internal/timeline/sight.inpage.ts

@@ -0,0 +1,122 @@
+/**
+ * In the page: whether what the recorder marked was in view, and what it showed, judged as the page
+ * renders it. An IntersectionObserver watches each element the record follows: it reports as the
+ * page renders, forces no layout, and leaves a removed element the state it last reported. What
+ * changed counts as seen when it was in the viewport and its style showed it; what went counts as
+ * seen when it was in view before it went. Words that need the page's layout are read on render
+ * too, as `text` reads an element, by the walk's one rule for what shows and with fields masked.
+ * An element whose state alone the record wants, as for a class change on something it does not
+ * follow, is looked at once. See `names.inpage.ts` for what a page-side part may use.
+ */
+import type { Names } from "../reading/names.inpage.ts";
+import type { Texts } from "../reading/text.inpage.ts";
+import type { Walk } from "../reading/walk.inpage.ts";
+import type { Sample, Shown } from "./fold.inpage.ts";
+import type { History } from "./history.inpage.ts";
+
+export const sight = (names: Names, walked: Walk, texts: Texts, kept: History) => {
+  const { clean } = names;
+  const { visible } = walked;
+  // Whether each watched element was in view as the page last rendered it, and whether the style
+  // of one looked at once showed it.
+  let viewed = new WeakMap<Element, boolean>();
+  let watching = new WeakSet<Element>();
+  let states = new WeakMap<Element, boolean>();
+  const waiting = new Map<Element, Array<Sample>>();
+
+  /** What an element shows: its words, if its style shows it. */
+  const shownBy = (element: Element): Shown =>
+    element.isConnected && visible(element)
+      ? clean(texts.lines(element, false), 200) || null
+      : null;
+
+  /** Settle what waited on an element; its words are read once, if one of them needs them. */
+  const judge = (element: Element, pending: ReadonlyArray<Sample>, seen: boolean, was: boolean) => {
+    const shown = pending.some((sample) => sample.shown === undefined)
+      ? shownBy(element)
+      : undefined;
+
+    for (const sample of pending) {
+      const now = sample.shown === undefined ? shown : sample.shown;
+
+      kept.settle(element, sample, now, now === null ? was : seen);
+    }
+  };
+
+  const observer = new IntersectionObserver((entries) => {
+    for (const { target, isIntersecting } of entries) {
+      const was = viewed.get(target) ?? false;
+      const seen = isIntersecting && visible(target);
+      const pending = waiting.get(target);
+
+      viewed.set(target, seen);
+      waiting.delete(target);
+      if (pending !== undefined) judge(target, pending, seen, was);
+      if (!kept.has(target)) {
+        states.set(target, visible(target));
+        unwatch(target);
+      }
+    }
+  });
+
+  /** Watch an element, asking for a fresh report even if it is watched already. */
+  const watch = (element: Element) => {
+    watching.add(element);
+    observer.unobserve(element);
+    observer.observe(element);
+  };
+
+  const unwatch = (element: Element) => {
+    watching.delete(element);
+    observer.unobserve(element);
+  };
+
+  return {
+    /** Judge a sample at once if what it shows and whether it is in view are known, else on render. */
+    look: (element: Element, sample: Sample) => {
+      const view = viewed.get(element);
+
+      if (sample.shown !== undefined && view !== undefined && watching.has(element)) {
+        sample.seen = view;
+
+        return;
+      }
+      waiting.set(element, [...(waiting.get(element) ?? []), sample]);
+      watch(element);
+    },
+    /**
+     * Look at an element once, for its state when it next changes: as it renders, or `now`, by its
+     * style, as for the few the record looks at as it starts.
+     */
+    glance: (element: Element, now = false) => {
+      if (now) states.set(element, visible(element));
+      if (!watching.has(element)) watch(element);
+    },
+    /** Whether the style of an element looked at once showed it, if it was. */
+    state: (element: Element): boolean | undefined => states.get(element),
+    /** Whether a watched element was in view as the page last rendered it. */
+    viewed: (element: Element): boolean => viewed.get(element) ?? false,
+    unwatch,
+    /** Judge now what the page has not rendered since it changed, as a hidden tab never does. */
+    settle: () => {
+      for (const [element, pending] of waiting) {
+        const seen =
+          element.isConnected && walked.inView(element.getBoundingClientRect()) && visible(element);
+
+        judge(element, pending, seen, viewed.get(element) ?? false);
+        viewed.set(element, seen);
+      }
+      waiting.clear();
+      for (const key of kept.forgotten()) if (key instanceof Element) unwatch(key);
+    },
+    clear: () => {
+      observer.disconnect();
+      waiting.clear();
+      viewed = new WeakMap();
+      watching = new WeakSet();
+      states = new WeakMap();
+    },
+  };
+};
+
+export type Sight = ReturnType<typeof sight>;

package/src/internal/timeline/window.ts

@@ -0,0 +1,96 @@
+/**
+ * A page's window over its three tracks on the browser's host clock: the events and frames it
+ * keeps, at no call, and one read of its changes, the first starting its record. A read that fails
+ * is missing, with why, and the window is still made.
+ */
+import { Duration, Effect, Option, Result, Schema } from "effect";
+
+import { type BrowserError, InvalidRequest } from "../../BrowserError.ts";
+import { type BrowserEvent, TrackEvent } from "../../BrowserEvent.ts";
+import type { Changes } from "../../Change.ts";
+import { Frame } from "../../Frame.ts";
+import { Window } from "../../Moment.ts";
+import type { ChangesOptions, WindowOptions } from "../../Page.ts";
+import { failWith, type PageContext } from "../page/context.ts";
+
+const isWindow = Schema.is(Window);
+const isFrame = Schema.is(Frame);
+const isTrackEvent = Schema.is(TrackEvent);
+
+/**
+ * Where a window asked at `now` starts and ends: never after now, nor starting after it ends.
+ * Nothing for a bound that is not finite, or a negative reach back.
+ */
+export const boundsOf = ({ since, until }: Pick<WindowOptions, "since" | "until">, now: number) => {
+  const end = until === undefined ? now : isFrame(until) ? until.hostTime : Math.min(until, now);
+
+  const start = isWindow(since)
+    ? since.until
+    : isFrame(since)
+      ? since.hostTime
+      : !Duration.isDuration(since)
+        ? since
+        : Duration.isNegative(since)
+          ? Number.NaN
+          : end - Duration.toMillis(since);
+
+  return Number.isFinite(start) && Number.isFinite(end)
+    ? Option.some({ since: Math.min(start, end), until: end })
+    : Option.none();
+};
+
+/**
+ * A window's share of the kept tracks: events after its start, frames painted from it, both up to
+ * its end, so consecutive windows hold each event once and the next begins with the frame the last
+ * ended on. Pointer, key and wheel input is the presentation track, not an event here.
+ */
+export const within = (
+  { since, until }: { readonly since: number; readonly until: number },
+  events: ReadonlyArray<BrowserEvent>,
+  frames: ReadonlyArray<Frame>,
+) => ({
+  events: events.filter((event) => event.at > since && event.at <= until && !isTrackEvent(event)),
+  frames: frames.filter((frame) => frame.hostTime >= since && frame.hostTime <= until),
+});
+
+export const make =
+  (
+    page: PageContext,
+    read: (options: ChangesOptions) => Effect.Effect<Changes, BrowserError>,
+    frames: Effect.Effect<ReadonlyArray<Frame>>,
+  ) =>
+  ({ since, until, unmask }: WindowOptions) =>
+    Effect.gen(function* () {
+      const asked = boundsOf({ since, until }, page.now());
+
+      if (Option.isNone(asked))
+        return yield* failWith(
+          "window",
+          new InvalidRequest({
+            detail: "a window's bounds must be finite, its reach not negative",
+          }),
+        );
+      const bounds = asked.value;
+
+      // A previous window's changes go on exactly where they ended, on the page's own clock, and a
+      // frame bounds them at its paint, so that they hold nothing it does not show.
+      const changes = yield* Effect.result(
+        read({
+          since: isWindow(since)
+            ? (since.changes ?? bounds.since)
+            : isFrame(since)
+              ? since
+              : bounds.since,
+          until: isFrame(until) ? until : bounds.until,
+          unmask,
+        }),
+      );
+
+      return new Window({
+        page: page.id,
+        ...bounds,
+        ...within(bounds, yield* page.recentEvents, yield* frames),
+        changes: Result.getOrUndefined(changes),
+        missing: Option.toArray(Result.getFailure(changes)),
+      });
+    }).pipe(page.span("Page.window"), page.owned);

package/src/internal/timeline/words.ts

@@ -0,0 +1,65 @@
+/**
+ * What changed on a page, in words for a model: a change with where it is, and what it is. A moment
+ * tells its changes this way, and a tool's receipt the changes its action caused.
+ */
+import type { Subject, SubjectContext } from "../../BrowserEvent.ts";
+import type { Change } from "../../Change.ts";
+
+export const quoted = (value: string | undefined) => JSON.stringify(value ?? "");
+
+/** A subject in words, such as `button "Play"`; one without a name says where it was. */
+export const named = (subject: Subject, point: string | undefined) => {
+  const kind = subject.role ?? subject.tag;
+
+  if (subject.name !== "") return `${kind} ${JSON.stringify(subject.name)}`;
+
+  return point === undefined ? kind : `${kind} at ${point}`;
+};
+
+/** A change's context in words: `row "Ether", column "1h"` or `beside "Price", under "Bitcoin"`. */
+export const where = ({ row, column, label, heading }: SubjectContext, grouped = false) => {
+  const parts = [
+    row === undefined ? "" : `row ${quoted(row)}`,
+    column === undefined || grouped ? "" : `column ${quoted(column)}`,
+    label === undefined ? "" : `beside ${quoted(label)}`,
+    heading === undefined || grouped ? "" : `under ${quoted(heading)}`,
+  ].filter((part) => part !== "");
+
+  return parts.length === 0 ? "" : ` (${parts.join(", ")})`;
+};
+
+/** A change in words, such as `"$61,240" became "$62,010" (row "Bitcoin", column "Price")`. */
+export const describe = (change: Change, grouped = false): string => {
+  const { subject, before, after, count, lowest, highest } = change;
+  const context = where(subject.context, grouped);
+
+  const range =
+    lowest === undefined || highest === undefined ? "" : `, from ${lowest} to ${highest}`;
+
+  const times = count > 1 ? ` (it changed ${count} times${range})` : "";
+
+  switch (change.kind) {
+    case "title":
+      return `the title ${before === undefined ? "now reads" : `${quoted(before)} became`} ${quoted(after)}`;
+    case "value": {
+      const field = named(subject, undefined);
+
+      if (after === "checked" || after === "not checked") return `${field} is now ${after}`;
+      if (after === undefined || after === "") return `${field} was cleared`;
+
+      return after === "••••" || before === undefined || before === ""
+        ? `${field} was ${after === "••••" ? "edited" : `set to ${quoted(after)}`}`
+        : `${field} changed from ${quoted(before)} to ${quoted(after)}`;
+    }
+    case "appeared":
+      return `${quoted(after)} appeared${context}`;
+    case "disappeared":
+      return `${quoted(before)} disappeared${context}`;
+    case "brief":
+      return `${quoted(after)} appeared and went away again${context}`;
+    case "text":
+      return before === undefined
+        ? `now reads ${quoted(after)}${context}${times}`
+        : `${quoted(before)} became ${quoted(after)}${context}${times}`;
+  }
+};

package/dist/Bootstrap-B9UUXsvF.d.mts

@@ -1,183 +0,0 @@
-import { BrowserError, InitializationError } from "./Errors.mjs";
-import { Cause, Effect, Schema } from "effect";
-declare namespace BindingRegistration_d_exports {
-  export { FailureMode, Origin$1 as Origin, Registration, invoke, make, schema, snapshot };
-}
-declare const Invoke: unique symbol;
-declare const Origin$1: Schema.NonEmptyString;
-declare const FailureMode: Schema.Literals<readonly ["reject-call", "fail-session"]>;
-declare const metadataSchema: Schema.Struct<{
-  readonly name: Schema.NonEmptyString;
-  readonly origins: Schema.$Array<Schema.NonEmptyString>;
-  readonly maxConcurrent: Schema.Int;
-  readonly maxInputBytes: Schema.Int;
-  readonly maxOutputBytes: Schema.Int;
-  readonly timeoutMillis: Schema.Int;
-  readonly failureMode: Schema.Literals<readonly ["reject-call", "fail-session"]>;
-}>;
-type Metadata = typeof metadataSchema.Type;
-interface Registration<E, R> extends Metadata {
-  readonly [Invoke]: (text: string, check: Effect.Effect<void, InitializationError>) => Effect.Effect<string, E | InitializationError, R>;
-}
-/** Retain an issued live capability at schema boundaries; a copied shape is not authority. */
-declare const schema: Schema.declare<Registration<unknown, unknown>, Registration<unknown, unknown>>;
-/** Pack heterogeneous codecs and handlers while their concrete input/output types are known. */
-declare const make: <I, IEncoded, O, OEncoded, E, R>(options: BindingOptions<I, IEncoded, O, OEncoded, E, R>) => Registration<E, R>;
-/** Authentication is identity-based even when a caller copies every enumerable field/symbol. */
-declare const snapshot: <E, R>(registration: Registration<E, R>) => Effect.Effect<Registration<E, R>, BrowserError, never>;
-declare const invoke: <E, R>(registration: Registration<E, R>, text: string, check: Effect.Effect<void, InitializationError>) => Effect.Effect<string, E | InitializationError, R>;
-declare namespace Bootstrap_d_exports {
-  export { BindingDiagnostics, BindingFailure, BindingFailureMode, BindingOptions, BindingRegistration, BindingStatistics, InitScript, Origin, Permission, PermissionGrant, Plan, PlanError, PlanRequirements, Readiness, ReadinessOutcome, binding, combine, empty, init, permissions };
-}
-/**
- * Exact scheme-and-host origin, as a document reports it. Patterns are deliberately absent:
- * a registration that cannot say exactly where it applies does not belong in a plan.
- */
-declare const Origin: Schema.NonEmptyString;
-type Origin = typeof Origin.Type;
-/**
- * The reviewed subset of native permission capabilities. Each name is checked against a real
- * browser in native acceptance; an unsupported capability is refused before it is exposed.
- */
-declare const Permission: Schema.Literals<readonly ["accelerometer", "background-sync", "camera", "clipboard-read", "clipboard-write", "geolocation", "gyroscope", "magnetometer", "microphone", "midi", "notifications", "payment-handler", "storage-access"]>;
-type Permission = typeof Permission.Type;
-declare const PermissionGrant: Schema.Struct<{
-  readonly origin: Schema.NonEmptyString;
-  readonly permissions: Schema.$Array<Schema.Literals<readonly ["accelerometer", "background-sync", "camera", "clipboard-read", "clipboard-write", "geolocation", "gyroscope", "magnetometer", "microphone", "midi", "notifications", "payment-handler", "storage-access"]>>;
-}>;
-type PermissionGrant = typeof PermissionGrant.Type;
-/**
- * Registration is not readiness. A script may start asynchronous work, but it cannot pause the
- * website's own scripts, so a document is ready only when its expression resolves to exactly
- * `true`. A document that was already running when the bundle was registered never ran it:
- * `RequireFreshNavigation` reports that instead of pretending otherwise, and an explicit
- * reload of possibly uncertain work stays a caller's decision.
- */
-declare const Readiness: Schema.Struct<{
-  readonly expression: Schema.NonEmptyString;
-  readonly timeoutMillis: Schema.Int;
-  readonly existingDocuments: Schema.Literals<readonly ["RequireFreshNavigation", "AcceptAlreadyRunning"]>;
-}>;
-type Readiness = typeof Readiness.Type;
-/** Trusted host configuration. Script content is never model output or page input. */
-declare const InitScript: Schema.Struct<{
-  readonly id: Schema.NonEmptyString;
-  readonly content: Schema.NonEmptyString;
-  /** When present, the step runs only on these documents and readiness skips the rest. */
-  readonly origins: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-  readonly readiness: Schema.optionalKey<Schema.Struct<{
-    readonly expression: Schema.NonEmptyString;
-    readonly timeoutMillis: Schema.Int;
-    readonly existingDocuments: Schema.Literals<readonly ["RequireFreshNavigation", "AcceptAlreadyRunning"]>;
-  }>>;
-}>;
-type InitScript = typeof InitScript.Type;
-/** A callback failure can reject one page invocation or permanently fence the session. */
-declare const BindingFailureMode: Schema.Literals<readonly ["reject-call", "fail-session"]>;
-type BindingFailureMode = typeof BindingFailureMode.Type;
-/**
- * A registration issued by `binding`. Its private executable closure carries the real consumer
- * E/R; copying the metadata or fabricating an object does not grant callback authority.
- */
-type BindingRegistration<E = never, R = never> = Registration<E, R>;
-/**
- * Environment-free boundary codecs keep page data validation separate from consumer services.
- * The handler's E/R remain visible on the Plan and are supplied only by the trusted host.
- */
-interface BindingOptions<I, IEncoded, O, OEncoded, E, R> {
-  readonly name: string;
-  readonly origins: ReadonlyArray<Origin>;
-  readonly input: Schema.ConstraintCodec<I, IEncoded, never, never>;
-  readonly output: Schema.ConstraintCodec<O, OEncoded, never, never>;
-  /** Defaults to one concurrent invocation. Explicit values still pass the bounded schema. */
-  readonly maxConcurrent?: number;
-  /** Defaults to 64 KiB. */
-  readonly maxInputBytes?: number;
-  /** Defaults to 64 KiB. */
-  readonly maxOutputBytes?: number;
-  /** Defaults to 10 seconds for the complete invocation. */
-  readonly timeoutMillis?: number;
-  /** Defaults to rejecting this invocation without terminating the session. */
-  readonly failureMode?: BindingFailureMode;
-  readonly handle: (input: I) => Effect.Effect<O, E, R>;
-}
-/**
- * One ordered bundle plus its host capabilities. Callback registrations preserve E/R through
- * their executable closures; static script/permission plans remain serializable values.
- */
-interface Plan<E = unknown, R = unknown> {
-  readonly scripts: ReadonlyArray<InitScript>;
-  readonly permissions: ReadonlyArray<PermissionGrant>;
-  readonly bindings?: ReadonlyArray<BindingRegistration<E, R>>;
-}
-/** Host-only typed evidence. Causes are never logged or returned to page callers. */
-interface BindingFailure<E> {
-  readonly name: string;
-  readonly mode: BindingFailureMode;
-  readonly cause: Cause.Cause<E | InitializationError>;
-}
-interface BindingStatistics {
-  readonly name: string;
-  readonly inFlight: number;
-  readonly pendingNative: number;
-  /** Finished/interrupted invocations whose native work or disposal has not settled. */
-  readonly retired: number;
-  readonly accepted: number;
-  readonly succeeded: number;
-  readonly rejected: number;
-}
-/** Copied snapshot: at most sixteen bindings and the latest thirty-two failure records. */
-interface BindingDiagnostics<E> {
-  readonly faulted: boolean;
-  readonly bindings: ReadonlyArray<BindingStatistics>;
-  readonly failures: ReadonlyArray<BindingFailure<E>>;
-  readonly droppedFailures: number;
-}
-/**
- * Static plans remain serializable. Live binding plans retain issued registrations by identity;
- * this schema neither executes their callbacks nor turns copied metadata into authority. Typed
- * acquisition validates a separate snapshot so consumer E/R is not erased by a generic decoder.
- */
-declare const Plan: Schema.Struct<{
-  readonly scripts: Schema.$Array<Schema.Struct<{
-    readonly id: Schema.NonEmptyString;
-    readonly content: Schema.NonEmptyString;
-    /** When present, the step runs only on these documents and readiness skips the rest. */
-    readonly origins: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-    readonly readiness: Schema.optionalKey<Schema.Struct<{
-      readonly expression: Schema.NonEmptyString;
-      readonly timeoutMillis: Schema.Int;
-      readonly existingDocuments: Schema.Literals<readonly ["RequireFreshNavigation", "AcceptAlreadyRunning"]>;
-    }>>;
-  }>>;
-  readonly permissions: Schema.$Array<Schema.Struct<{
-    readonly origin: Schema.NonEmptyString;
-    readonly permissions: Schema.$Array<Schema.Literals<readonly ["accelerometer", "background-sync", "camera", "clipboard-read", "clipboard-write", "geolocation", "gyroscope", "magnetometer", "microphone", "midi", "notifications", "payment-handler", "storage-access"]>>;
-  }>>;
-  readonly bindings: Schema.optionalKey<Schema.$Array<Schema.declare<Registration<unknown, unknown>, Registration<unknown, unknown>>>>;
-}>;
-type AnyPlan = Plan<unknown, unknown>;
-type PlanError<P extends AnyPlan> = P extends Plan<infer E, infer _R> ? E : never;
-type PlanRequirements<P extends AnyPlan> = P extends Plan<infer _E, infer R> ? R : never;
-declare const empty: Plan<never, never>;
-declare const init: (script: InitScript) => Plan<never, never>;
-declare const permissions: (grant: PermissionGrant) => Plan<never, never>;
-/**
- * Register a page-callable host callback without running it or capturing an ambient runtime.
- * Native installation later owns origin/document checks, bounded admission and disposal.
- */
-declare const binding: <I, IEncoded, O, OEncoded, E, R>(options: BindingOptions<I, IEncoded, O, OEncoded, E, R>) => Plan<E, R>;
-/** Combination is ordered and preserves every callback's consumer E/R union. */
-declare function combine<const Plans extends ReadonlyArray<AnyPlan>>(...plans: Plans): Plan<PlanError<Plans[number]>, PlanRequirements<Plans[number]>>;
-/** What the current document is, not a promise about any other document. */
-type ReadinessOutcome = {
-  readonly _tag: "Ready";
-} | {
-  readonly _tag: "NotApplicable";
-} | {
-  readonly _tag: "RequiresNavigation";
-};
-//#endregion
-export { binding as _, BindingRegistration as a, init as b, InitScript as c, PermissionGrant as d, Plan as f, ReadinessOutcome as g, Readiness as h, BindingOptions as i, Origin as l, PlanRequirements as m, BindingFailure as n, BindingStatistics as o, PlanError as p, BindingFailureMode as r, Bootstrap_d_exports as s, BindingDiagnostics as t, Permission as u, combine as v, permissions as x, empty as y };
-export {};
-//# sourceMappingURL=Bootstrap-B9UUXsvF.d.mts.map

package/dist/Bootstrap-CeQOWBy6.mjs

@@ -1,189 +0,0 @@
-import { BrowserError, InitializationError, Reasons } from "./Errors.mjs";
-import { Identifier } from "./BrowserData.mjs";
-import { Effect, Result, Schema } from "effect";
-//#region src/internal/browser/BindingRegistration.ts
-const Invoke = Symbol("BrowserBindingRegistration");
-const issued = /* @__PURE__ */ new WeakSet();
-const Origin$1 = Schema.NonEmptyString.check(Schema.isMaxLength(2048), Schema.makeFilter((value) => {
-	try {
-		const url = new URL(value);
-		return ["http:", "https:"].includes(url.protocol) && url.origin === value && !url.username && !url.password;
-	} catch {
-		return false;
-	}
-}, { title: "an exact http(s) origin" }));
-const FailureMode = Schema.Literals(["reject-call", "fail-session"]);
-const metadataSchema = Schema.Struct({
-	name: Identifier,
-	origins: Schema.Array(Origin$1).check(Schema.isMaxLength(16), Schema.isUnique(), Schema.makeFilter((origins) => origins.length > 0, { title: "at least one allowed origin" })),
-	maxConcurrent: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 64
-	})),
-	maxInputBytes: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 1048576
-	})),
-	maxOutputBytes: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 4194304
-	})),
-	timeoutMillis: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 12e4
-	})),
-	failureMode: FailureMode
-});
-/** Retain an issued live capability at schema boundaries; a copied shape is not authority. */
-const schema = Schema.declare((value) => typeof value === "object" && value !== null && issued.has(value), { title: "an issued browser binding registration" });
-const issue = (metadata, invoke) => {
-	const registration = Object.freeze({
-		...metadata,
-		origins: Object.freeze([...metadata.origins]),
-		[Invoke]: invoke
-	});
-	issued.add(registration);
-	return registration;
-};
-/** Pack heterogeneous codecs and handlers while their concrete input/output types are known. */
-const make = (options) => {
-	const { maxConcurrent = 1, maxInputBytes = 65536, maxOutputBytes = 65536, timeoutMillis = 1e4, failureMode = "reject-call" } = options;
-	const decoded = Schema.decodeResult(metadataSchema)({
-		...options,
-		maxConcurrent,
-		maxInputBytes,
-		maxOutputBytes,
-		timeoutMillis,
-		failureMode
-	});
-	if (Result.isFailure(decoded)) throw decoded.failure;
-	const metadata = decoded.success;
-	const { input, output, handle } = options;
-	if (!Schema.isSchema(input) || !Schema.isSchema(output) || typeof handle !== "function") throw new TypeError("Invalid binding registration");
-	const fail = (reason) => InitializationError.make({
-		operation: "callback",
-		step: metadata.name,
-		reason
-	});
-	return issue(metadata, Effect.fnUntraced(function* (text, check) {
-		if (new TextEncoder().encode(text).length > metadata.maxInputBytes) return yield* fail("input");
-		const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(input))(text).pipe(Effect.catchCause(() => Effect.fail(fail("input"))));
-		yield* check;
-		const value = yield* Effect.suspend(() => handle(decoded));
-		const encoded = yield* Schema.encodeEffect(output)(value).pipe(Effect.catchCause(() => Effect.fail(fail("output"))));
-		const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.catchCause(() => Effect.fail(fail("output"))));
-		const result = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Json))(json).pipe(Effect.catchCause(() => Effect.fail(fail("output"))));
-		if (new TextEncoder().encode(result).length > metadata.maxOutputBytes) return yield* fail("output");
-		return result;
-	}));
-};
-/** Authentication is identity-based even when a caller copies every enumerable field/symbol. */
-const snapshot = Effect.fnUntraced(function* (registration) {
-	const invalid = () => BrowserError.make({
-		operation: "configure",
-		reason: Reasons.Configuration.make({}),
-		outcome: "undispatched"
-	});
-	if (!issued.has(registration)) return yield* invalid();
-	const metadata = yield* Schema.decodeEffect(metadataSchema)(registration).pipe(Effect.mapError(invalid));
-	return issue(metadata, registration[Invoke]);
-});
-const invoke = (registration, text, check) => registration[Invoke](text, check);
-//#endregion
-//#region src/Bootstrap.ts
-/**
-* Exact scheme-and-host origin, as a document reports it. Patterns are deliberately absent:
-* a registration that cannot say exactly where it applies does not belong in a plan.
-*/
-const Origin = Origin$1;
-/**
-* The reviewed subset of native permission capabilities. Each name is checked against a real
-* browser in native acceptance; an unsupported capability is refused before it is exposed.
-*/
-const Permission = Schema.Literals([
-	"accelerometer",
-	"background-sync",
-	"camera",
-	"clipboard-read",
-	"clipboard-write",
-	"geolocation",
-	"gyroscope",
-	"magnetometer",
-	"microphone",
-	"midi",
-	"notifications",
-	"payment-handler",
-	"storage-access"
-]);
-const PermissionGrant = Schema.Struct({
-	origin: Origin,
-	permissions: Schema.Array(Permission).check(Schema.isMaxLength(16), Schema.isUnique())
-});
-/**
-* Registration is not readiness. A script may start asynchronous work, but it cannot pause the
-* website's own scripts, so a document is ready only when its expression resolves to exactly
-* `true`. A document that was already running when the bundle was registered never ran it:
-* `RequireFreshNavigation` reports that instead of pretending otherwise, and an explicit
-* reload of possibly uncertain work stays a caller's decision.
-*/
-const Readiness = Schema.Struct({
-	expression: Schema.NonEmptyString.check(Schema.isMaxLength(4096)),
-	timeoutMillis: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 12e4
-	})),
-	existingDocuments: Schema.Literals(["RequireFreshNavigation", "AcceptAlreadyRunning"])
-});
-/** Trusted host configuration. Script content is never model output or page input. */
-const InitScript = Schema.Struct({
-	id: Identifier,
-	content: Schema.NonEmptyString.check(Schema.isMaxLength(65536)),
-	/** When present, the step runs only on these documents and readiness skips the rest. */
-	origins: Schema.optionalKey(Schema.Array(Origin).check(Schema.isMaxLength(16), Schema.isUnique())),
-	readiness: Schema.optionalKey(Readiness)
-});
-/** A callback failure can reject one page invocation or permanently fence the session. */
-const BindingFailureMode = FailureMode;
-/**
-* Static plans remain serializable. Live binding plans retain issued registrations by identity;
-* this schema neither executes their callbacks nor turns copied metadata into authority. Typed
-* acquisition validates a separate snapshot so consumer E/R is not erased by a generic decoder.
-*/
-const Plan = Schema.Struct({
-	scripts: Schema.Array(InitScript).check(Schema.isMaxLength(16)),
-	permissions: Schema.Array(PermissionGrant).check(Schema.isMaxLength(16)),
-	bindings: Schema.optionalKey(Schema.Array(schema).check(Schema.isMaxLength(16)))
-});
-const empty = {
-	scripts: [],
-	permissions: []
-};
-const init = (script) => ({
-	scripts: [script],
-	permissions: []
-});
-const permissions = (grant) => ({
-	scripts: [],
-	permissions: [grant]
-});
-/**
-* Register a page-callable host callback without running it or capturing an ambient runtime.
-* Native installation later owns origin/document checks, bounded admission and disposal.
-*/
-const binding = (options) => ({
-	scripts: [],
-	permissions: [],
-	bindings: [make(options)]
-});
-function combine(...plans) {
-	const bindings = plans.flatMap((plan) => plan.bindings === void 0 ? [] : [...plan.bindings]);
-	return {
-		scripts: plans.flatMap((plan) => [...plan.scripts]),
-		permissions: plans.flatMap((plan) => [...plan.permissions]),
-		...bindings.length === 0 ? {} : { bindings }
-	};
-}
-//#endregion
-export { PermissionGrant as a, binding as c, init as d, permissions as f, Permission as i, combine as l, snapshot as m, InitScript as n, Plan as o, invoke as p, Origin as r, Readiness as s, BindingFailureMode as t, empty as u };
-
-//# sourceMappingURL=Bootstrap-CeQOWBy6.mjs.map