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

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

@@ -0,0 +1,123 @@
+/**
+ * In the page: one element's history in the change record, and its fold over a window. A fold gives
+ * what the element showed at the window's start and at its end, how often that changed between,
+ * the lowest and highest of a number that changed more than once, and when it last changed before
+ * the window. Only what was seen in view as it changed is told. It touches no DOM, so it also runs
+ * outside a page. See `names.inpage.ts` for what a page-side part may use.
+ */
+
+/** What an element shows: its words, `null` while it shows nothing, `undefined` until judged. */
+export type Shown = string | null | undefined;
+
+export interface Sample {
+  readonly at: number;
+  shown: Shown;
+  /** Whether it was in view as the page rendered it; undefined until then. */
+  seen: boolean | undefined;
+}
+
+/** One element's history, oldest change first. */
+export interface Track {
+  key: object;
+  readonly kind: "content" | "value" | "title";
+  /** What it showed before its oldest kept change; undefined when that is unknown. */
+  initial: Shown;
+  /** Before this, the record let some of its changes go. */
+  known: number;
+  readonly samples: Array<Sample>;
+}
+
+export type Kind = "text" | "appeared" | "disappeared" | "brief" | "value" | "title";
+
+/** One element's changes over a window, before the page names the element. */
+export interface Folded {
+  readonly track: Track;
+  readonly kind: Kind;
+  readonly startedAt: number;
+  readonly at: number;
+  readonly before: string | undefined;
+  readonly after: string | undefined;
+  readonly count: number;
+  readonly lowest: string | undefined;
+  readonly highest: string | undefined;
+  readonly earlier: number | undefined;
+}
+
+export const fold = () => {
+  /** The one number some words show, such as 61240 in "$61,240"; none for none or several. */
+  const number = (words: string): ReadonlyArray<number> => {
+    const found = words.match(/[-+−]?\d[\d,]*(?:\.\d+)?/g);
+
+    const value = Number(
+      found?.length === 1 ? found[0]?.replaceAll(",", "").replace("−", "-") : "",
+    );
+
+    return found?.length === 1 && Number.isFinite(value) ? [value] : [];
+  };
+
+  /** A track's changes after `since`, up to `until`, if one was seen in view. */
+  const over = (track: Track, since: number, until: number): Folded | undefined => {
+    const inside = track.samples.filter((sample) => sample.at > since && sample.at <= until);
+    const first = inside[0];
+    const last = inside.at(-1);
+
+    if (first === undefined || last === undefined || !inside.some((sample) => sample.seen === true))
+      return undefined;
+    const prior = track.samples[track.samples.indexOf(first) - 1];
+    // What it showed at `since` is lost when the record let go of changes after it.
+    const lost = track.known <= since ? track.known : undefined;
+
+    const start =
+      prior === undefined ? (lost === undefined ? undefined : track.initial) : prior.shown;
+
+    const words = [start, ...inside.map((sample) => sample.shown)].filter(
+      (each) => typeof each === "string",
+    );
+
+    const numbers = words.flatMap(number);
+    const ranged = inside.length > 1 && numbers.length === words.length;
+
+    const kind: Kind =
+      track.kind !== "content"
+        ? track.kind
+        : last.shown === null
+          ? start === null
+            ? "brief"
+            : "disappeared"
+          : start === null
+            ? "appeared"
+            : "text";
+
+    return {
+      track,
+      kind,
+      startedAt: first.at,
+      at: last.at,
+      before: kind === "disappeared" ? words.at(-1) : (start ?? undefined),
+      after: kind === "brief" ? words.at(-1) : (last.shown ?? undefined),
+      count: inside.length,
+      lowest: ranged ? words[numbers.indexOf(Math.min(...numbers))] : undefined,
+      highest: ranged ? words[numbers.indexOf(Math.max(...numbers))] : undefined,
+      earlier: prior?.at ?? (lost === Number.NEGATIVE_INFINITY ? undefined : lost),
+    };
+  };
+
+  /**
+   * How readily a track gives way when the record is full: one that holds no change first, then
+   * one that keeps changing, one never seen in view and one that has gone; news never does.
+   */
+  const rank = ({ samples: [only, ...more] }: Track): number =>
+    only === undefined
+      ? 4
+      : more.length > 0
+        ? 3
+        : only.seen === false
+          ? 2
+          : only.shown === null
+            ? 1
+            : 0;
+
+  return { number, over, rank };
+};
+
+export type Fold = ReturnType<typeof fold>;

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

@@ -0,0 +1,229 @@
+/**
+ * In the page: a document's record of what changed, element by element, within fixed bounds. It
+ * touches no DOM, so it also runs outside a page.
+ *
+ * - **A change** is a new state: other words, or presence gained or lost. Within one batch of
+ *   mutations the latest state stands, so an element moved in one step has not changed.
+ * - **Bounds.** 256 elements, each with its latest 32 changes, kept a minute. On a busier page an
+ *   element that keeps changing gives way first, then one never seen in view, then one that has
+ *   gone, so news stays. What gives way, and what finds no room, is counted, and the record says it
+ *   is whole only after the latest such loss.
+ *
+ * Each element's history is folded over a window by `fold.inpage.ts`. See `names.inpage.ts` for
+ * what a page-side part may use.
+ */
+import type { Fold, Sample, Shown, Track } from "./fold.inpage.ts";
+
+/** How much the record keeps: elements, changes of each, and for how long. */
+export interface Bounds {
+  readonly tracks: number;
+  readonly samples: number;
+  readonly retention: number;
+}
+
+export const history = (
+  folding: Fold,
+  bounds: Bounds = { tracks: 256, samples: 32, retention: 60_000 },
+) => {
+  const { tracks: maxTracks, samples: maxSamples, retention } = bounds;
+  const tracks = new Map<object, Track>();
+  // Keys that gave way or found no room: their later changes are counted, not kept.
+  let refused = new WeakSet<object>();
+  // When the record let changes go, and how many, and the latest such time; keys whose tracks went.
+  let losses: Array<[number, number]> = [];
+  let lastLoss = Number.NEGATIVE_INFINITY;
+  const gone: Array<object> = [];
+  let begun: number | undefined;
+
+  // Losses at one time count together. Beyond 256 times the first noted go, so a count falls short
+  // rather than over.
+  const lose = (at: number, count: number) => {
+    const last = losses.at(-1);
+
+    if (count <= 0) return;
+    lastLoss = Math.max(lastLoss, at);
+    if (last?.[0] === at) last[1] += count;
+    else losses.push([at, count]);
+    if (losses.length > 256) losses.shift();
+  };
+
+  const latest = (track: Track) => track.samples.at(-1)?.at ?? Number.NEGATIVE_INFINITY;
+
+  const drop = (track: Track) => {
+    tracks.delete(track.key);
+    gone.push(track.key);
+  };
+
+  // How often the tracks' samples have changed, and when a search found none to give way, which
+  // holds until they change again, so a burst of newcomers pays for one search.
+  let version = 0;
+  let barren = -1;
+
+  /** What gives way for a newcomer: one that holds no change, then one that keeps changing. */
+  const victim = (): Track | undefined => {
+    let chosen: Track | undefined;
+    let rank = 0;
+
+    for (const track of barren === version ? [] : tracks.values()) {
+      const next = folding.rank(track);
+
+      if (next > rank) [chosen, rank] = [track, next];
+      if (rank === 4) break;
+    }
+    if (chosen === undefined) barren = version;
+
+    return chosen;
+  };
+
+  const evict = (track: Track) => {
+    drop(track);
+    if (track.samples.length > 0) refused.add(track.key);
+    for (const sample of track.samples) lose(sample.at, 1);
+  };
+
+  /** A key the record cannot keep: its change is counted. */
+  const refuse = (key: object, at: number): undefined => {
+    refused.add(key);
+    lose(at, 1);
+
+    return undefined;
+  };
+
+  /**
+   * A new state for `key` at `at`: its sample, or none when it is no change or finds no room.
+   * `initial` says what a key not yet kept showed before.
+   */
+  const note = (
+    key: object,
+    kind: Track["kind"],
+    at: number,
+    shown: Shown,
+    initial: () => Shown,
+  ): Sample | undefined => {
+    let track = tracks.get(key);
+
+    if (track === undefined) {
+      const full = !refused.has(key) && tracks.size >= maxTracks;
+      const out = full ? victim() : undefined;
+
+      if (refused.has(key) || (full && out === undefined)) return refuse(key, at);
+      const before = initial();
+
+      if (shown !== undefined && shown === before) return undefined;
+      if (out !== undefined) evict(out);
+      track = { key, kind, initial: before, known: Number.NEGATIVE_INFINITY, samples: [] };
+      tracks.set(key, track);
+    }
+    const { samples } = track;
+
+    version++;
+
+    if (samples.at(-1)?.at === at) samples.pop();
+    const previous = samples.length === 0 ? track.initial : samples.at(-1)?.shown;
+
+    if (shown !== undefined && shown === previous) return undefined;
+    const oldest = samples.length >= maxSamples ? samples.shift() : undefined;
+
+    if (oldest !== undefined) {
+      track.initial = oldest.shown;
+      track.known = oldest.at;
+      lose(oldest.at, 1);
+    }
+    const sample: Sample = { at, shown, seen: undefined };
+
+    samples.push(sample);
+
+    return sample;
+  };
+
+  /** Judge a sample as the page rendered it; a state that repeats the one before is no change. */
+  const settle = (key: object, sample: Sample, shown: Shown, seen: boolean) => {
+    const track = tracks.get(key);
+
+    // `null` is a state, what shows nothing, so only `undefined` is unjudged.
+    version++;
+    if (sample.shown === undefined) sample.shown = shown;
+    if (sample.seen === undefined) sample.seen = seen;
+    if (track === undefined) return;
+    let previous = track.initial;
+
+    const changes = track.samples.filter((each) => {
+      const same = each.shown !== undefined && each.shown === previous;
+
+      if (!same) previous = each.shown;
+
+      return !same;
+    });
+
+    track.samples.splice(0, track.samples.length, ...changes);
+  };
+
+  /**
+   * The window after `since`, up to `until`: where the record is whole, how many changes in it the
+   * record let go, and each element's changes, oldest first by when they began.
+   */
+  const read = (since: number, until: number, now: number) => {
+    for (const track of tracks.values()) if (latest(track) < now - retention) drop(track);
+
+    return {
+      from: Math.min(until, Math.max(begun ?? now, now - retention, lastLoss)),
+      dropped: losses.reduce(
+        (sum, [at, count]) => (at > since && at <= until ? sum + count : sum),
+        0,
+      ),
+      folded: [...tracks.values()]
+        .flatMap((track) => folding.over(track, since, until) ?? [])
+        .toSorted((left, right) => left.startedAt - right.startedAt),
+    };
+  };
+
+  /** When something in view last changed, or something not yet judged; for a wait for stillness. */
+  const changing = (): number =>
+    Math.max(
+      Number.NEGATIVE_INFINITY,
+      ...Array.from(
+        tracks.values(),
+        (track) =>
+          track.samples.findLast((sample) => sample.seen !== false)?.at ?? Number.NEGATIVE_INFINITY,
+      ),
+    );
+
+  return {
+    begin: (at: number) => {
+      begun = at;
+    },
+    begun: () => begun !== undefined,
+    clear: () => {
+      for (const track of tracks.values()) drop(track);
+      refused = new WeakSet();
+      losses = [];
+      lastLoss = Number.NEGATIVE_INFINITY;
+      begun = undefined;
+    },
+    changing,
+    /** Keys whose tracks went since this was last asked, for the recorder to stop watching. */
+    forgotten: (): ReadonlyArray<object> => gone.splice(0),
+    has: (key: object) => tracks.has(key),
+    /** Whether the record has let `key` go: its later changes are counted, never kept. */
+    refuses: (key: object) => refused.has(key),
+    lose,
+    note,
+    read,
+    /** Each element's history, and when the record let changes go, for a read to judge causes. */
+    recent: () => ({ tracks: [...tracks.values()], losses: losses.map(([at]) => at) }),
+    /** A track moves to the element that took its key's place, as a re-rendered price does. */
+    rekey: (from: object, to: object): boolean => {
+      const track = tracks.get(from);
+
+      if (track === undefined || tracks.has(to)) return false;
+      tracks.delete(from);
+      track.key = to;
+      tracks.set(to, track);
+
+      return true;
+    },
+    settle,
+  };
+};
+
+export type History = ReturnType<typeof history>;

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

@@ -0,0 +1,207 @@
+/**
+ * In the page: what one batch of mutations changed, marked for the record as cheaply as it can be.
+ *
+ * - **An element whose own text changed.** One that holds only text, as most prices and labels do,
+ *   is read whole at once, since that text is all it shows, and the batch is undone to say what it
+ *   said before; any other is read as it renders. Once followed, a text-only element's changes are
+ *   taken as its text's, with no look at the nodes that came and went.
+ * - **An element added** is read as it renders; one that moved in the same batch did not arrive.
+ *   What came with text its parent gained is part of the parent's change, and what takes a removed
+ *   element's place, as a re-rendered price does, takes its history. **An element removed** is
+ *   noted only if the record follows it, so a removal it never saw is not told.
+ * - **`hidden`, `open`, `aria-hidden`, `class` or `style`** may show or hide an element. The old
+ *   value says whether it was hidden before, except for a class, where only the element's state as
+ *   the record last saw it can: what it follows, what alerts, status lines, dialogs and popovers
+ *   showed when it started, and what an earlier class change showed. A style that neither hid it
+ *   nor hides it, such as a transform, shows nothing new.
+ * - **The document's title.**
+ *
+ * See `names.inpage.ts` for what a page-side part may use.
+ */
+import type { Names } from "../reading/names.inpage.ts";
+import type { Shown } from "./fold.inpage.ts";
+import type { History } from "./history.inpage.ts";
+import type { Sight } from "./sight.inpage.ts";
+
+interface Batch {
+  readonly at: number;
+  readonly owners: Set<Element>;
+  readonly arrived: Set<Node>;
+  readonly left: Set<Node>;
+}
+
+export const marks = (names: Names, kept: History, seeing: Sight) => {
+  const { clean, isElement, isHtml } = names;
+  const unwritten = new Set("SCRIPT STYLE NOSCRIPT TEMPLATE TITLE".split(" "));
+  const hiding = /display\s*:\s*none|visibility\s*:\s*hidden|opacity\s*:\s*0(?![.\d])/i;
+  // Where removed elements were, which gives their context, and the title as last seen.
+  let places = new WeakMap<object, Element>();
+  let title = "";
+
+  const words = (text: string | null | undefined): Shown => clean(text, 200) || null;
+
+  const content = (element: Element, at: number, shown: Shown, initial: () => Shown) => {
+    const sample = kept.note(element, "content", at, shown, initial);
+
+    if (sample !== undefined) seeing.look(element, sample);
+  };
+
+  /** What a text-only element said before this batch: its text with the batch undone. */
+  const before = (leaf: Element, records: ReadonlyArray<MutationRecord>): Shown => {
+    let nodes: Array<Node> = Array.from(leaf.childNodes);
+    const old = new Map<Node, string>();
+
+    for (const record of records.toReversed())
+      if (record.type === "characterData") old.set(record.target, record.oldValue ?? "");
+      else {
+        const added = new Set(Array.from(record.addedNodes));
+
+        nodes = nodes.filter((node) => !added.has(node));
+        const next = record.nextSibling === null ? -1 : nodes.indexOf(record.nextSibling);
+
+        nodes.splice(next === -1 ? nodes.length : next, 0, ...Array.from(record.removedNodes));
+      }
+
+    return words(nodes.map((node) => old.get(node) ?? node.textContent).join(""));
+  };
+
+  const attribute = (
+    element: Element,
+    { attributeName: name, oldValue: old }: MutationRecord,
+    at: number,
+  ) => {
+    // Whether the old value hid it; a class can say only through the page's style.
+    const was =
+      name === "hidden"
+        ? old !== null
+        : name === "aria-hidden"
+          ? old === "true"
+          : name === "open"
+            ? element.tagName === "DIALOG" && old === null
+            : name === "style" && hiding.test(old ?? "");
+
+    if (name === "style" && !was && !hiding.test(element.getAttribute("style") ?? "")) return;
+    const state = seeing.state(element);
+
+    if (!kept.has(element) && !was && state === undefined && name !== "open")
+      return seeing.glance(element);
+    content(element, at, undefined, () =>
+      was || state === false
+        ? null
+        : name === "open" && old === null
+          ? words(element.querySelector(":scope > summary")?.textContent)
+          : words(element.textContent),
+    );
+  };
+
+  /** What one mutation added to and removed from `target`. */
+  const nodes = (change: MutationRecord, target: Element, batch: Batch) => {
+    const added = Array.from(change.addedNodes).slice(0, 64);
+    const removed = Array.from(change.removedNodes).slice(0, 64);
+
+    const text = [...added, ...removed].some(
+      (node) => !isElement(node) && /\S/.test(node.textContent ?? ""),
+    );
+
+    kept.lose(batch.at, Math.max(change.addedNodes.length, change.removedNodes.length) - 64);
+    if (text) batch.owners.add(target);
+    removed.forEach((gone, index) => {
+      const node = added[index];
+
+      if (!isElement(gone)) return;
+      batch.left.add(gone);
+      if (node !== undefined && isElement(node) && kept.rekey(gone, node)) seeing.unwatch(gone);
+      else if (kept.has(gone)) {
+        places.set(gone, target);
+        const sample = kept.note(gone, "content", batch.at, null, () => undefined);
+
+        if (sample !== undefined) sample.seen = seeing.viewed(gone);
+        seeing.unwatch(gone);
+      }
+    });
+    for (const node of added)
+      if (
+        isElement(node) &&
+        isHtml(node) &&
+        !unwritten.has(node.tagName) &&
+        !node.isContentEditable
+      )
+        if (kept.has(node) || (!text && !batch.left.has(node))) {
+          batch.arrived.add(node);
+          content(node, batch.at, undefined, () => null);
+        }
+  };
+
+  /** Whether `element` is inside something this batch added, which tells it with its own words. */
+  const inside = (element: Element, arrived: ReadonlySet<Node>): boolean => {
+    for (let up = element.parentElement; arrived.size > 0 && up !== null; up = up.parentElement)
+      if (arrived.has(up)) return true;
+
+    return false;
+  };
+
+  const ownerOf = (change: MutationRecord): Node | null =>
+    change.type === "characterData" ? change.target.parentElement : change.target;
+
+  /** Mark what one batch of mutations changed, at `at`. */
+  const mark = (records: ReadonlyArray<MutationRecord>, at: number) => {
+    const batch: Batch = { at, owners: new Set(), arrived: new Set(), left: new Set() };
+    let byOwner: Map<Node | null, Array<MutationRecord>> | undefined;
+
+    for (const change of records) {
+      const target = ownerOf(change);
+
+      if (target === null || !isElement(target) || inside(target, batch.arrived)) continue;
+      // A text-only element the record follows, or has let go, changes only its text, as a
+      // ticking price does, so its nodes need no look: each would cost this world a wrapper.
+      const known = kept.has(target) || kept.refuses(target);
+
+      if (change.type !== "attributes")
+        if (change.type === "characterData" || (target.childElementCount === 0 && known))
+          batch.owners.add(target);
+        else nodes(change, target, batch);
+      else if (isHtml(target) && target !== document.body && target !== document.documentElement)
+        attribute(target, change, at);
+    }
+    for (const owner of batch.owners) {
+      const leaf = owner.childElementCount === 0;
+
+      // What the record let go is counted, with no word of it read.
+      if (kept.refuses(owner)) kept.lose(at, 1);
+      if (kept.refuses(owner) || !isHtml(owner) || unwritten.has(owner.tagName)) continue;
+      // What is typed into an editable region is a field's value, told masked as one.
+      if (owner === document.body || owner.isContentEditable) continue;
+      if (batch.arrived.has(owner) || inside(owner, batch.arrived)) continue;
+      content(owner, at, leaf ? words(owner.textContent) : undefined, () => {
+        byOwner ??= Map.groupBy(records, ownerOf);
+
+        return leaf ? before(owner, byOwner.get(owner) ?? []) : undefined;
+      });
+    }
+    if (document.title === title) return;
+    const previous = words(title);
+
+    const sample = kept.note(
+      document,
+      "title",
+      at,
+      words((title = document.title)),
+      () => previous,
+    );
+
+    if (sample !== undefined) sample.seen = true;
+  };
+
+  return {
+    mark,
+    /** Where a removed element was, which gives its context. */
+    placeOf: (key: object): Element | undefined => places.get(key),
+    /** Start afresh, from the document's title now. */
+    reset: () => {
+      places = new WeakMap();
+      title = document.title;
+    },
+  };
+};
+
+export type Marks = ReturnType<typeof marks>;

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

@@ -0,0 +1,133 @@
+/**
+ * In the page: the change recorder. It starts at a read of the page's changes, and from then on at
+ * the start of each document the page loads, once that document is parsed; it stops in a document
+ * nobody has read for two minutes. While it runs, a MutationObserver hands each batch to
+ * `marks.inpage.ts`, and an IntersectionObserver judges as the page renders whether what was marked
+ * was in view (`sight.inpage.ts`). A field reports its value as it is edited, a secret one only as
+ * `••••`, and trusted pointer and key input is kept, for a read to name causes by. Nothing unmarked
+ * is read: no walk, no words, no layout. 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 { History } from "./history.inpage.ts";
+import type { Marks } from "./marks.inpage.ts";
+import type { Sight } from "./sight.inpage.ts";
+
+export const record = (
+  names: Names,
+  texts: Texts,
+  kept: History,
+  seeing: Sight,
+  marking: Marks,
+) => {
+  const { isElement, isInput } = names;
+  const epoch = () => performance.timeOrigin + performance.now();
+
+  const declared =
+    "[role=alert],[role=status],[role=log],[role=dialog],[role=alertdialog],[aria-live],dialog,[popover]";
+
+  let running = false;
+  let lastRead = 0;
+  // What fields held as they took focus, and the latest trusted input, newest last.
+  let focused = new WeakMap<Element, string>();
+  const inputs: Array<{ readonly at: number; readonly target: Element }> = [];
+
+  const targetOf = (event: Event): Element | undefined => {
+    const target = event.composedPath()[0];
+
+    return target instanceof Node && isElement(target) ? target : undefined;
+  };
+
+  /** A field's value as the record keeps it: a secret one's as `••••`, a box's checked or not. */
+  const valueOf = (field: Element): string | undefined =>
+    isInput(field) && (field.type === "checkbox" || field.type === "radio")
+      ? field.checked
+        ? "checked"
+        : "not checked"
+      : texts.shown(field, true);
+
+  const onFocus = (event: Event) => {
+    const field = targetOf(event);
+    const value = field === undefined ? undefined : valueOf(field);
+
+    if (field !== undefined && value !== undefined) focused.set(field, value);
+  };
+
+  const onValue = (event: Event) => {
+    const field = targetOf(event);
+    const value = field === undefined ? undefined : valueOf(field);
+
+    if (field === undefined || value === undefined) return;
+    const sample = kept.note(field, "value", epoch(), value, () => focused.get(field) ?? null);
+
+    if (sample !== undefined) seeing.look(field, sample);
+  };
+
+  const onInput = (event: Event) => {
+    const target = targetOf(event);
+
+    if (!event.isTrusted || target === undefined) return;
+    inputs.push({ at: performance.timeOrigin + event.timeStamp, target });
+    if (inputs.length > 8) inputs.shift();
+  };
+
+  const listeners = [
+    ["focusin", onFocus],
+    ["input", onValue],
+    ["change", onValue],
+    ["pointerdown", onInput],
+    ["keydown", onInput],
+  ] as const;
+
+  const options = { capture: true, passive: true };
+
+  const stop = () => {
+    running = false;
+    observer.disconnect();
+    for (const [type, listener] of listeners) document.removeEventListener(type, listener, options);
+    seeing.clear();
+    kept.clear();
+    kept.forgotten();
+    inputs.length = 0;
+    focused = new WeakMap();
+  };
+
+  const observer = new MutationObserver((records) => {
+    const at = epoch();
+
+    if (at - lastRead > 120_000) stop();
+    else marking.mark(records, at);
+  });
+
+  const begin = () => {
+    if (!running || kept.begun()) return;
+    observer.observe(document, {
+      subtree: true,
+      childList: true,
+      characterData: true,
+      characterDataOldValue: true,
+      attributeFilter: ["hidden", "open", "aria-hidden", "class", "style"],
+      attributeOldValue: true,
+    });
+    for (const [type, listener] of listeners) document.addEventListener(type, listener, options);
+    marking.reset();
+    for (const element of Array.from(document.querySelectorAll(declared)).slice(0, 64))
+      seeing.glance(element, true);
+    kept.begin(epoch());
+  };
+
+  return {
+    /** Record from now, once the document is parsed; each read keeps the record going. */
+    start: () => {
+      lastRead = epoch();
+      if (running) return;
+      running = true;
+      if (document.readyState === "loading")
+        document.addEventListener("DOMContentLoaded", begin, { once: true });
+      else begin();
+    },
+    inputs: (): ReadonlyArray<{ readonly at: number; readonly target: Element }> => inputs,
+  };
+};
+
+export type Recorder = ReturnType<typeof record>;