@itmetsam/samurai-framework 0.6.0 → 0.7.0

package/dist/recorder/candidates.js

@@ -0,0 +1,118 @@
+/**
+ * Declarations that turn an element into locator candidates (test id, role and name, label, text, css and
+ * an absolute xpath), plus `inToolbar(event)`, which is true for events from the recorder toolbar. A string
+ * of plain declarations, interpolated into the capture script (page realm) and the toolbar script
+ * (sandbox realm), so no transpiler helper can end up in it.
+ */
+export const CANDIDATES_JS = String.raw `
+const norm = (text) => String(text == null ? "" : text).replace(/\s+/g, " ").trim();
+const textOf = (node) => norm(node.innerText != null ? node.innerText : node.textContent);
+const NO_ROLE_TYPES = ["hidden", "password", "file", "color", "date", "datetime-local", "month", "time", "week"];
+const TEXT_TYPES = ["", "text", "email", "search", "tel", "url", "password", "number"];
+
+const roleOf = (el) => {
+  const explicit = norm(el.getAttribute("role")).split(" ")[0];
+  if (explicit) return explicit;
+  const tag = el.tagName.toLowerCase();
+  if (tag === "a") return el.hasAttribute("href") ? "link" : undefined;
+  if (tag === "button" || tag === "summary") return "button";
+  if (tag === "select") return el.multiple || el.size > 1 ? "listbox" : "combobox";
+  if (tag === "textarea") return "textbox";
+  if (/^h[1-6]$/.test(tag)) return "heading";
+  if (tag === "img") return "img";
+  if (tag === "input") {
+    const type = (el.getAttribute("type") || "text").toLowerCase();
+    if (NO_ROLE_TYPES.indexOf(type) >= 0) return undefined;
+    if (type === "checkbox" || type === "radio") return type;
+    if (type === "button" || type === "submit" || type === "reset" || type === "image") return "button";
+    if (type === "range") return "slider";
+    if (type === "number") return "spinbutton";
+    if (type === "search") return "searchbox";
+    return "textbox";
+  }
+  return undefined;
+};
+
+const labelTexts = (el) => {
+  const texts = [];
+  if (el.labels) for (const label of el.labels) texts.push(textOf(label));
+  const by = el.getAttribute("aria-labelledby");
+  if (by) {
+    for (const id of by.split(/\s+/)) {
+      const named = id && document.getElementById(id);
+      if (named) texts.push(textOf(named));
+    }
+  }
+  const own = el.getAttribute("aria-label");
+  if (own) texts.push(norm(own));
+  return texts.filter(Boolean);
+};
+
+const nameOf = (el, role) => {
+  const labelled = labelTexts(el)[0];
+  if (labelled) return labelled;
+  const tag = el.tagName.toLowerCase();
+  if (tag === "input") {
+    const type = (el.getAttribute("type") || "").toLowerCase();
+    return type === "submit" || type === "button" || type === "reset" ? norm(el.value) : "";
+  }
+  if (tag === "img") return norm(el.getAttribute("alt"));
+  if (role === "textbox" || role === "combobox" || role === "listbox") return "";
+  return textOf(el) || norm(el.getAttribute("title"));
+};
+
+const plain = (value) => value.indexOf('"') < 0 && value.indexOf("\\") < 0;
+
+const xpathOf = (el) => {
+  const parts = [];
+  for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+    let index = 1;
+    for (let sibling = node.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+      if (sibling.tagName === node.tagName) index++;
+    }
+    parts.unshift(node.tagName.toLowerCase() + "[" + index + "]");
+  }
+  return "/" + parts.join("/");
+};
+
+const candidatesOf = (el) => {
+  const found = [];
+  const tag = el.tagName.toLowerCase();
+  const testId = el.getAttribute("data-testid");
+  if (testId) found.push({ method: "getByTestId", testId });
+  const role = roleOf(el);
+  if (role) {
+    const name = nameOf(el, role);
+    if (name && name.length <= 80) found.push({ method: "getByRole", role, name });
+  }
+  const label = labelTexts(el)[0];
+  if (label && label.length <= 80 && el.labels !== undefined) found.push({ method: "getByLabel", text: label });
+  const text = textOf(el);
+  if (text && text.length <= 60 && tag !== "input" && tag !== "textarea" && tag !== "select") {
+    found.push({ method: "getByText", text });
+  }
+  if (el.id && /^[A-Za-z][\w-]*$/.test(el.id) && !/\d{3,}/.test(el.id)) found.push({ method: "getByCss", css: "#" + el.id });
+  const name = el.getAttribute("name");
+  if (name && plain(name)) found.push({ method: "getByCss", css: tag + '[name="' + name + '"]' });
+  const placeholder = el.getAttribute("placeholder");
+  if (placeholder && plain(placeholder)) found.push({ method: "getByCss", css: tag + '[placeholder="' + placeholder + '"]' });
+  found.push({ method: "locator", xpath: xpathOf(el) });
+  return found;
+};
+
+const isTextEntry = (el) => {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "textarea") return true;
+  if (tag === "input") return TEXT_TYPES.indexOf((el.getAttribute("type") || "").toLowerCase()) >= 0;
+  return Boolean(el.isContentEditable);
+};
+
+const INTERACTIVE = "a[href],button,input,select,textarea,label,summary,[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=option],[role=switch]";
+const interactiveAt = (target) => {
+  const found = target.closest(INTERACTIVE) || target;
+  return found.tagName === "LABEL" && found.control ? found.control : found;
+};
+const TOOLBAR_TAG = "SAMURAI-RECORDER-TOOLBAR";
+const inToolbar = (event) =>
+  event.composedPath().some((node) => node && node.tagName === TOOLBAR_TAG);
+`;

package/dist/recorder/capture.d.ts

@@ -1,6 +1,9 @@
 /**
  * Function declaration installed as a preload script, called as `(send)` where `send` is the recorder's
- * channel. Reports what the tester does in the top-level document:
+ * channel. `send` stays in this closure and is never put on the page's window, so a page script cannot
+ * report anything. A second run in a document that was recorded before (a new recording) adds its own
+ * listeners; those of the earlier run go quiet, as their run is no longer the current one.
+ * Reports what the tester does in the top-level document:
  *
  * - `{ type: "click", target, candidates, textEntry }`: a click, retargeted to the nearest interactive
  *   element (a label click reports its control; the click the browser forwards to the control is dropped).
@@ -18,3 +21,7 @@
 export declare const CAPTURE_SOURCE: string;
 /** Run in every loaded document to stop its capture script reporting and swallowing Alt+clicks */
 export declare const CAPTURE_OFF = "() => { window[Symbol.for(\"samurai.recorder.off\")] = true; }";
+/** Run in every loaded document to pause its capture script (the toolbar's Pause, and while it types a value) */
+export declare const CAPTURE_MUTE = "() => { window[Symbol.for(\"samurai.recorder.muted\")] = true; }";
+/** Run in every loaded document to resume what `CAPTURE_MUTE` paused */
+export declare const CAPTURE_UNMUTE = "() => { window[Symbol.for(\"samurai.recorder.muted\")] = false; }";

package/dist/recorder/capture.js

@@ -1,8 +1,16 @@
+import { CANDIDATES_JS } from "./candidates.js";
 /** Name of the window flag that tells the capture script to stop reporting (see `CAPTURE_OFF`) */
 const OFF_KEY = "samurai.recorder.off";
+/** Name of the window flag that pauses the capture script (see `CAPTURE_MUTE`) */
+const MUTED_KEY = "samurai.recorder.muted";
+/** Name of the window counter that tells a document's capture scripts which run is the current one */
+const RUN_KEY = "samurai.recorder.run";
 /**
  * Function declaration installed as a preload script, called as `(send)` where `send` is the recorder's
- * channel. Reports what the tester does in the top-level document:
+ * channel. `send` stays in this closure and is never put on the page's window, so a page script cannot
+ * report anything. A second run in a document that was recorded before (a new recording) adds its own
+ * listeners; those of the earlier run go quiet, as their run is no longer the current one.
+ * Reports what the tester does in the top-level document:
  *
  * - `{ type: "click", target, candidates, textEntry }`: a click, retargeted to the nearest interactive
  *   element (a label click reports its control; the click the browser forwards to the control is dropped).
@@ -19,125 +27,17 @@ const OFF_KEY = "samurai.recorder.off";
  */
 export const CAPTURE_SOURCE = String.raw `(send) => {
   const OFF = Symbol.for("${OFF_KEY}");
-  const ON = Symbol.for("samurai.recorder.on");
-  const SEND = Symbol.for("samurai.recorder.send");
+  const RUN = Symbol.for("${RUN_KEY}");
   if (window !== window.top) return;
-  // A document that was recorded before gets the new channel; its listeners are already in place
   window[OFF] = false;
-  window[SEND] = send;
-  if (window[ON]) return;
-  window[ON] = true;
-  const report = (message) => window[SEND](message);
+  // This run's number; the listeners of an earlier run in this document stop reporting
+  const run = (window[RUN] = (typeof window[RUN] === "number" ? window[RUN] : 0) + 1);
+  const report = (message) => send(message);
 
-  const norm = (text) => String(text == null ? "" : text).replace(/\s+/g, " ").trim();
-  const textOf = (node) => norm(node.innerText != null ? node.innerText : node.textContent);
-  const NO_ROLE_TYPES = ["hidden", "password", "file", "color", "date", "datetime-local", "month", "time", "week"];
-  const TEXT_TYPES = ["", "text", "email", "search", "tel", "url", "password", "number"];
+  ${CANDIDATES_JS}
 
-  const roleOf = (el) => {
-    const explicit = norm(el.getAttribute("role")).split(" ")[0];
-    if (explicit) return explicit;
-    const tag = el.tagName.toLowerCase();
-    if (tag === "a") return el.hasAttribute("href") ? "link" : undefined;
-    if (tag === "button" || tag === "summary") return "button";
-    if (tag === "select") return el.multiple || el.size > 1 ? "listbox" : "combobox";
-    if (tag === "textarea") return "textbox";
-    if (/^h[1-6]$/.test(tag)) return "heading";
-    if (tag === "img") return "img";
-    if (tag === "input") {
-      const type = (el.getAttribute("type") || "text").toLowerCase();
-      if (NO_ROLE_TYPES.indexOf(type) >= 0) return undefined;
-      if (type === "checkbox" || type === "radio") return type;
-      if (type === "button" || type === "submit" || type === "reset" || type === "image") return "button";
-      if (type === "range") return "slider";
-      if (type === "number") return "spinbutton";
-      if (type === "search") return "searchbox";
-      return "textbox";
-    }
-    return undefined;
-  };
-
-  const labelTexts = (el) => {
-    const texts = [];
-    if (el.labels) for (const label of el.labels) texts.push(textOf(label));
-    const by = el.getAttribute("aria-labelledby");
-    if (by) {
-      for (const id of by.split(/\s+/)) {
-        const named = id && document.getElementById(id);
-        if (named) texts.push(textOf(named));
-      }
-    }
-    const own = el.getAttribute("aria-label");
-    if (own) texts.push(norm(own));
-    return texts.filter(Boolean);
-  };
-
-  const nameOf = (el, role) => {
-    const labelled = labelTexts(el)[0];
-    if (labelled) return labelled;
-    const tag = el.tagName.toLowerCase();
-    if (tag === "input") {
-      const type = (el.getAttribute("type") || "").toLowerCase();
-      return type === "submit" || type === "button" || type === "reset" ? norm(el.value) : "";
-    }
-    if (tag === "img") return norm(el.getAttribute("alt"));
-    if (role === "textbox" || role === "combobox" || role === "listbox") return "";
-    return textOf(el) || norm(el.getAttribute("title"));
-  };
-
-  const plain = (value) => value.indexOf('"') < 0 && value.indexOf("\\") < 0;
-
-  const xpathOf = (el) => {
-    const parts = [];
-    for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
-      let index = 1;
-      for (let sibling = node.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
-        if (sibling.tagName === node.tagName) index++;
-      }
-      parts.unshift(node.tagName.toLowerCase() + "[" + index + "]");
-    }
-    return "/" + parts.join("/");
-  };
-
-  const candidatesOf = (el) => {
-    const found = [];
-    const tag = el.tagName.toLowerCase();
-    const testId = el.getAttribute("data-testid");
-    if (testId) found.push({ method: "getByTestId", testId });
-    const role = roleOf(el);
-    if (role) {
-      const name = nameOf(el, role);
-      if (name && name.length <= 80) found.push({ method: "getByRole", role, name });
-    }
-    const label = labelTexts(el)[0];
-    if (label && label.length <= 80 && el.labels !== undefined) found.push({ method: "getByLabel", text: label });
-    const text = textOf(el);
-    if (text && text.length <= 60 && tag !== "input" && tag !== "textarea" && tag !== "select") {
-      found.push({ method: "getByText", text });
-    }
-    if (el.id && /^[A-Za-z][\w-]*$/.test(el.id) && !/\d{3,}/.test(el.id)) found.push({ method: "getByCss", css: "#" + el.id });
-    const name = el.getAttribute("name");
-    if (name && plain(name)) found.push({ method: "getByCss", css: tag + '[name="' + name + '"]' });
-    const placeholder = el.getAttribute("placeholder");
-    if (placeholder && plain(placeholder)) found.push({ method: "getByCss", css: tag + '[placeholder="' + placeholder + '"]' });
-    found.push({ method: "locator", xpath: xpathOf(el) });
-    return found;
-  };
-
-  const isTextEntry = (el) => {
-    const tag = el.tagName.toLowerCase();
-    if (tag === "textarea") return true;
-    if (tag === "input") return TEXT_TYPES.indexOf((el.getAttribute("type") || "").toLowerCase()) >= 0;
-    return Boolean(el.isContentEditable);
-  };
-
-  const INTERACTIVE = "a[href],button,input,select,textarea,label,summary,[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=option],[role=switch]";
-  const interactiveAt = (target) => {
-    const found = target.closest(INTERACTIVE) || target;
-    return found.tagName === "LABEL" && found.control ? found.control : found;
-  };
-
-  const off = () => window[OFF] === true;
+  const MUTED = Symbol.for("${MUTED_KEY}");
+  const off = () => window[RUN] !== run || window[OFF] === true || window[MUTED] === true;
   let lastClick = { el: null, at: 0 };
   let outlined = null;
   let outlinedStyle = "";
@@ -147,6 +47,7 @@ export const CAPTURE_SOURCE = String.raw `(send) => {
   };
 
   document.addEventListener("click", (event) => {
+    if (inToolbar(event)) return;
     if (off() || !event.isTrusted || !(event.target instanceof Element)) return;
     if (event.altKey) {
       event.preventDefault();
@@ -173,6 +74,7 @@ export const CAPTURE_SOURCE = String.raw `(send) => {
   }, true);
 
   document.addEventListener("input", (event) => {
+    if (inToolbar(event)) return;
     const el = event.target;
     if (off() || !event.isTrusted || !(el instanceof Element) || !isTextEntry(el) || el.isContentEditable) return;
     const secret = el.tagName === "INPUT" && (el.getAttribute("type") || "").toLowerCase() === "password";
@@ -191,6 +93,7 @@ export const CAPTURE_SOURCE = String.raw `(send) => {
   // Enter on these is a click, which is recorded as one
   const ACTIVATES = "a[href],button,summary,select,input[type=button],input[type=submit],input[type=reset],input[type=checkbox],input[type=radio]";
   document.addEventListener("keydown", (event) => {
+    if (inToolbar(event)) return;
     if (off() || !event.isTrusted || event.isComposing || event.ctrlKey || event.altKey || event.metaKey || event.shiftKey) return;
     if (RECORDED_KEYS.indexOf(event.key) < 0 || !(event.target instanceof Element)) return;
     const el = event.target;
@@ -199,6 +102,8 @@ export const CAPTURE_SOURCE = String.raw `(send) => {
   }, true);
 
   document.addEventListener("mousemove", (event) => {
+    // Alt+click on the toolbar asserts nothing, so nothing there (or behind it) is outlined
+    if (inToolbar(event)) return unhighlight();
     if (off() || !event.altKey || !(event.target instanceof Element) || event.target === outlined) return;
     unhighlight();
     outlined = event.target;
@@ -210,3 +115,7 @@ export const CAPTURE_SOURCE = String.raw `(send) => {
 }`;
 /** Run in every loaded document to stop its capture script reporting and swallowing Alt+clicks */
 export const CAPTURE_OFF = `() => { window[Symbol.for("${OFF_KEY}")] = true; }`;
+/** Run in every loaded document to pause its capture script (the toolbar's Pause, and while it types a value) */
+export const CAPTURE_MUTE = `() => { window[Symbol.for("${MUTED_KEY}")] = true; }`;
+/** Run in every loaded document to resume what `CAPTURE_MUTE` paused */
+export const CAPTURE_UNMUTE = `() => { window[Symbol.for("${MUTED_KEY}")] = false; }`;

package/dist/recorder/index.d.ts

@@ -1,3 +1,3 @@
-export { Recorder, type RecorderOptions, type RecorderEvent, } from "./recorder.js";
+export { Recorder, type RecorderOptions, type RecorderEvent, type ToolbarOptions, } from "./recorder.js";
 export { applyRecorderEvent } from "./apply.js";
 export { recordSpec, pickTest, type RecordSpecOptions, type RecordResult, } from "./session.js";

package/dist/recorder/normalise.d.ts

@@ -1,4 +1,4 @@
-import type { LocatorSpec, Step } from "../steps/model.js";
+import type { Expectation, LocatorSpec, Step } from "../steps/model.js";
 /** What the recorder does to the step list: a new step at `index`, or a step rewritten in place */
 export type RecorderEvent = {
     op: "insert";
@@ -33,6 +33,30 @@ export type Observation = {
     locator: LocatorSpec;
     text: string;
     value?: string;
+} | {
+    type: "expect";
+    locator: LocatorSpec;
+    not: boolean;
+    expectation: Expectation;
+} | {
+    type: "insert";
+    locator: LocatorSpec;
+    value: {
+        kind: "env" | "secret";
+        name: string;
+    };
+} | {
+    type: "wait-idle";
+} | {
+    type: "wait-time";
+    ms: number;
+} | {
+    type: "screenshot";
+    name: string;
+    fullPage: boolean;
+} | {
+    type: "goto";
+    url: string;
 };
 export interface NormaliserOptions {
     /** Index the first recorded step gets */
@@ -44,6 +68,7 @@ export interface NormaliserOptions {
 }
 /** The name a secret gets in `secrets.<NAME>`: the field's name or id, upper snake case */
 export declare function secretNameFor(hint: string | undefined): string;
+export declare function expectationFor(text: string, value: string | undefined): Expectation;
 /**
  * Turns what the tester did into steps:
  * - typing into a field becomes one `fill`, rewritten as the text grows (a password becomes a secret reference);
@@ -65,6 +90,8 @@ export declare class Normaliser {
     private insert;
     /** The path (and query) of `url` when it is inside the base URL, else `url` */
     relative(url: string): string;
+    /** Steps the toolbar asks for directly; undefined for page observations */
+    private toolbarStep;
     observe(observation: Observation, at: number): RecorderEvent[];
     /** A top-level navigation started */
     navigated(url: string, at: number): RecorderEvent[];

package/dist/recorder/normalise.js

@@ -8,7 +8,7 @@ export function secretNameFor(hint) {
         .toUpperCase();
     return name === "" || /^\d/.test(name) ? "PASSWORD" : name;
 }
-function expectationFor(text, value) {
+export function expectationFor(text, value) {
     if (value !== undefined)
         return { matcher: "toHaveValue", expected: value };
     if (text === "")
@@ -52,7 +52,44 @@ export class Normaliser {
         }
         return url;
     }
+    /** Steps the toolbar asks for directly; undefined for page observations */
+    toolbarStep(observation) {
+        switch (observation.type) {
+            case "expect":
+                return {
+                    kind: "expect",
+                    locator: observation.locator,
+                    not: observation.not,
+                    expectation: observation.expectation,
+                };
+            case "insert":
+                return {
+                    kind: "fill",
+                    locator: observation.locator,
+                    value: observation.value,
+                };
+            case "wait-idle":
+                return { kind: "waitForNetworkIdle" };
+            case "wait-time":
+                return { kind: "waitForTimeout", ms: observation.ms };
+            case "screenshot":
+                return {
+                    kind: "screenshot",
+                    name: observation.name,
+                    fullPage: observation.fullPage,
+                };
+            case "goto":
+                return { kind: "goto", url: this.relative(observation.url) };
+            default:
+                return undefined;
+        }
+    }
     observe(observation, at) {
+        const fromToolbar = this.toolbarStep(observation);
+        if (fromToolbar) {
+            this.lastFill = undefined;
+            return [this.insert(fromToolbar)];
+        }
         if (observation.type === "click") {
             if (observation.textEntry)
                 return []; // focusing a field: the fill that follows needs no click
@@ -83,6 +120,8 @@ export class Normaliser {
                 }),
             ];
         }
+        if (observation.type !== "input")
+            return [];
         this.lastAction = at;
         const step = {
             kind: "fill",

package/dist/recorder/recorder.d.ts

@@ -1,7 +1,26 @@
 import type Page from "../browser/page.js";
 import type { BiDiConnector } from "../transport/bidi-connection.js";
 import { type RecorderEvent } from "./normalise.js";
+import { type ControllerDeps, type ControllerOptions } from "./toolbar/controller.js";
 export type { RecorderEvent } from "./normalise.js";
+/** The toolbar's settings: the recording's environment, and where its variables and secrets are written */
+export type ToolbarOptions = ControllerOptions & {
+    /** The project folder: `samurai.config.ts` and `.env.<environment>` */
+    projectDir: string;
+    /**
+     * Called when the recording is paused or resumed, or the toolbar fails (or comes back) on a page.
+     * There is no initial call: until the first one the recording is `{ state: "recording", toolbar: true }`
+     */
+    onStatus?: ControllerDeps["onStatus"];
+    /** A secret was saved to `.env.<environment>` from the panel (before its value is typed) */
+    onSecretAdded?: (name: string) => void;
+    /**
+     * The toolbar's Stop; the caller then stops the recording (`recorder.stop()`), as `recordSpec` does.
+     * Without it, Stop runs `recorder.stop()` itself: the toolbar goes away and nothing more is recorded, but
+     * nothing tells the `page.record()` caller, so pass `onStop` to learn of it.
+     */
+    onStop?: () => void;
+};
 export interface RecorderOptions {
     /** Called for every step the tester produces, in order. Steps get indexes from `at` on */
     onEvent: (event: RecorderEvent) => void;
@@ -15,6 +34,8 @@ export interface RecorderOptions {
     initialGoto?: boolean;
     /** URLs inside it are written relative to it, as `page.goto` resolves them */
     baseURL?: string;
+    /** Shows the recorder toolbar in the page (pause, assert, insert, wait, screenshot, stop). Without it, no toolbar */
+    toolbar?: ToolbarOptions;
 }
 /**
  * Watches the tester use the page and reports steps as they happen. A preload script reports clicks,
@@ -27,26 +48,59 @@ export declare class Recorder {
     private readonly context;
     private readonly normaliser;
     private readonly options;
+    /** The capture script's channel: page messages only */
     private readonly channel;
+    /** The toolbar's channel, handed only to the toolbar's sandbox: toolbar messages only */
+    private readonly toolbarChannel;
     private readonly queue;
     private readonly known;
     private stopped;
+    private stopping;
+    private controller;
     private constructor();
+    /** The context's `samurai-toolbar` sandbox realms, as last listed: the only realms toolbar messages are taken from */
+    private toolbarRealms;
+    /** Toolbar messages waiting for a realm lookup, and those that arrived behind them (kept in order) */
+    private toolbarBacklog;
+    private toolbarWaiting;
     static start(target: {
         page: Page;
         connector: BiDiConnector;
         context: string;
     }, options: RecorderOptions): Promise<Recorder>;
+    /**
+     * Page messages come only on the capture channel; toolbar messages only on the toolbar channel and
+     * only from the toolbar's sandbox realm. Neither channel is reachable from page script (each stays in
+     * its script's closure, and the toolbar's in a sandbox the page cannot see); the realm check also
+     * holds if a page realm ever got the toolbar's channel.
+     */
     private readonly onMessage;
+    private listToolbarRealms;
+    /** A message from the toolbar's own sandbox */
+    private fromToolbar;
+    private readonly onLoad;
     private readonly onNavigation;
     private subscription;
     private preload;
+    private toolbarPreload;
     private begin;
+    private createController;
+    /** Calls the toolbar hook's `method` in the loaded document; a document between loads has no toolbar yet */
+    private callToolbar;
     private enqueue;
     private emit;
     private locatorFor;
     private handle;
     private release;
+    /**
+     * Pauses capture in the loaded document: clicks and typing are not reported until `unmute`.
+     * @internal
+     */
+    mute(): Promise<void>;
+    /** @internal */
+    unmute(): Promise<void>;
+    private setMuted;
     /** Stops recording. Events already received are still processed and reported first */
     stop(): Promise<void>;
+    private end;
 }