@itmetsam/samurai-framework 0.9.0 → 0.12.0

package/dist/recorder/session.js

@@ -1,91 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
-import { Browser } from "../browser/browser.js";
-import { ensureWarm } from "../browser/warm-up.js";
-import { loadConfig, projectDir, readConfig } from "../config/config.js";
+import { loadConfig, projectDir } from "../config/config.js";
 import { loadSecrets } from "../config/secrets.js";
-import { filesFolder, isFolderIgnored, isGitIgnored, } from "../project/index.js";
+import { filesFolder, isFolderIgnored } from "../project/index.js";
 import { withProject } from "../runner/project.js";
-import { parseSpec } from "../steps/parse.js";
-import { applyRecorderEvent } from "./apply.js";
 import { missingFileText, } from "./recorder.js";
-const NEW_SPEC_HEADER = `import { expect, test } from "@itmetsam/samurai-framework";\n\n`;
-function addTest(source, title) {
-    const header = source.trim() === ""
-        ? NEW_SPEC_HEADER
-        : `${source.replace(/\s*$/, "")}\n\n`;
-    return `${header}test(${JSON.stringify(title)}, async ({ page }) => {\n});\n`;
-}
-/** Every `secrets.<NAME>` a parsed value contains, at any depth */
-function secretNames(node, found) {
-    if (Array.isArray(node))
-        node.forEach((item) => secretNames(item, found));
-    else if (node !== null && typeof node === "object") {
-        const record = node;
-        if (record.kind === "secret" && typeof record.name === "string")
-            found.add(record.name);
-        Object.values(record).forEach((item) => secretNames(item, found));
-    }
-}
-/** What the toolbar shows of the project: its environment, variables, secrets and the test's screenshots */
-export async function toolbarOptions(run, source, dir, config, testIndex) {
-    const tests = parseSpec(source);
-    const names = new Set(run.secrets.keys());
-    secretNames(tests, names);
-    const secrets = {};
-    for (const name of names)
-        secrets[name] = run.secrets.get(name);
-    const { environment } = run.settings;
-    return {
-        environment,
-        canAddVariables: typeof config.environments === "object",
-        variables: run.settings.variables,
-        secrets,
-        secretsIgnored: await isGitIgnored(dir, `.env.${environment}`),
-        screenshots: tests[testIndex]?.steps.filter(({ step }) => step.kind === "screenshot")
-            .length ?? 0,
-    };
-}
-/** The secrets a recording needs set: those its steps read, then those added from the panel, once each */
-export function resultSecrets(events, added) {
-    return [
-        ...new Set([
-            ...events.flatMap((event) => event.op !== "remove" &&
-                event.step.kind === "fill" &&
-                event.step.value.kind === "secret"
-                ? [event.step.value.name]
-                : []),
-            ...added,
-        ]),
-    ];
-}
-/** The index of the test `selector` names (see `RecordSpecOptions.test`) */
-export function pickTest(tests, selector) {
-    if (tests.length === 0)
-        throw new Error("The file has no tests; give a title with --new to add one");
-    if (selector === undefined) {
-        if (tests.length === 1)
-            return 0;
-        throw new Error(`The file has ${tests.length} tests; choose one with --test:\n${tests.map((t) => `  ${t.name}`).join("\n")}`);
-    }
-    if (typeof selector === "number") {
-        if (!Number.isInteger(selector) ||
-            selector < 0 ||
-            selector >= tests.length) {
-            throw new Error(`There is no test ${selector}; the file has ${tests.length}`);
-        }
-        return selector;
-    }
-    const exact = tests.findIndex((t) => t.name === selector);
-    if (exact !== -1)
-        return exact;
-    const partial = tests.flatMap((t, index) => t.name.includes(selector) ? [index] : []);
-    if (partial.length === 1)
-        return partial[0];
-    throw new Error(partial.length === 0
-        ? `No test matches "${selector}". Tests:\n${tests.map((t) => `  ${t.name}`).join("\n")}`
-        : `"${selector}" matches ${partial.length} tests; use the full name`);
-}
+import { launchRecordingBrowser, prepareRecordingBrowser, } from "./session-browser.js";
+import { resultSecrets, toolbarOptions } from "./session-secrets.js";
+import { prepareSpec, readSpec, SpecWriter } from "./spec-source.js";
+export { pickTest } from "./spec-source.js";
+export { resultSecrets, toolbarOptions } from "./session-secrets.js";
 /**
  * Opens a browser window and records what the person does into a spec file, step by step, until `signal`
  * aborts or the window is closed. Every step is written to the file as it happens, as a minimal edit.
@@ -96,37 +20,20 @@ export async function recordSpec(options) {
     return withProject(options, async (run) => {
         const { settings } = run;
         const file = path.resolve(projectDir(), options.file);
-        let source = existsSync(file) ? readFileSync(file, "utf8") : undefined;
-        if (source === undefined && options.create === undefined) {
-            throw new Error(`${options.file} does not exist; give a title with --new to create it`);
-        }
+        const existing = readSpec(file, options);
         // Before the spec is touched: a recording without its browser changes nothing
-        const browserName = (await readConfig("browser")) ?? "firefox";
-        await ensureWarm(browserName, { port: options.port ?? 9223 }, options.signal);
-        options.signal?.throwIfAborted();
-        source ??= "";
-        if (options.create !== undefined &&
-            !parseSpec(source).some((t) => t.name === options.create)) {
-            source = addTest(source, options.create);
-            mkdirSync(path.dirname(file), { recursive: true });
-            writeFileSync(file, source);
-        }
-        const tests = parseSpec(source);
-        const testIndex = pickTest(tests, options.create ?? options.test);
-        const test = tests[testIndex];
-        const at = options.at ?? test.steps.length;
-        if (!Number.isInteger(at) || at < 0 || at > test.steps.length) {
-            throw new RangeError(`--at must be between 0 and ${test.steps.length} (the test has ${test.steps.length} steps)`);
-        }
-        const { browser, page } = await Browser.launch(browserName, {
-            port: options.port ?? 9223,
+        const browserName = await prepareRecordingBrowser(options);
+        const spec = prepareSpec(file, existing, options);
+        const { testIndex, at } = spec;
+        const writer = new SpecWriter(spec.source, file, testIndex);
+        const { browser, page } = await launchRecordingBrowser(browserName, {
+            ...options,
             headless: options.headless ?? settings.headless,
-        }, options.signal);
+        });
         const loaded = await loadConfig();
         const folder = filesFolder(projectDir(), loaded.filesDir);
         const hadFolder = existsSync(folder.absolute);
         let recorder;
-        const events = [];
         const addedSecrets = new Set();
         let stopRequested;
         const stopped = new Promise((resolve) => (stopRequested = resolve));
@@ -141,7 +48,7 @@ export async function recordSpec(options) {
                 initialGoto: at === 0 && start !== undefined,
                 ...(settings.baseURL !== undefined && { baseURL: settings.baseURL }),
                 toolbar: {
-                    ...(await toolbarOptions(run, source, projectDir(), loaded, testIndex)),
+                    ...(await toolbarOptions(run, spec.source, projectDir(), loaded, testIndex)),
                     projectDir: projectDir(),
                     ...(options.onStatus && { onStatus: options.onStatus }),
                     onSecretAdded: (name) => addedSecrets.add(name),
@@ -153,10 +60,8 @@ export async function recordSpec(options) {
                     onMissing: (file) => options.onMissingFile?.(file, missingFileText(file, folder.relative)),
                 },
                 onEvent: (event) => {
-                    source = applyRecorderEvent(source, testIndex, event);
-                    writeFileSync(file, source);
-                    events.push(event);
-                    options.onEvent?.(event, source);
+                    const text = writer.write(event);
+                    options.onEvent?.(event, text);
                 },
             });
             await options.onStarted?.({ page, browser });
@@ -178,7 +83,7 @@ export async function recordSpec(options) {
         finally {
             await browser.close().catch(() => undefined);
         }
-        const secrets = resultSecrets(events, addedSecrets);
+        const secrets = resultSecrets(writer.events, addedSecrets);
         // Read again: the toolbar may have written new ones to the .env file
         const set = loadSecrets(settings.environment);
         const unsetSecrets = secrets.filter((name) => !set.has(name));
@@ -186,8 +91,8 @@ export async function recordSpec(options) {
         const missingFiles = recorder?.missingFiles ?? [];
         return {
             file,
-            test: test.name,
-            events,
+            test: spec.testName,
+            events: writer.events,
             secrets,
             unsetSecrets,
             files,

package/dist/recorder/spec-source.d.ts

@@ -0,0 +1,39 @@
+import type { RecorderEvent } from "./normalise.js";
+/** `source` with an empty test called `title` added (a new file gets the import line first) */
+export declare function addTest(source: string, title: string): string;
+/** The index of the test `selector` names (see `RecordSpecOptions.test`) */
+export declare function pickTest(tests: readonly {
+    name: string;
+}[], selector: string | number | undefined): number;
+/** The spec a recording writes into: its text, the test chosen, and where the first new step goes */
+export interface RecordingSpec {
+    source: string;
+    testIndex: number;
+    /** Full name of the test the steps go into */
+    testName: string;
+    at: number;
+}
+/** The spec's text, `undefined` when the file is not there yet; throws when it must exist (no `create`) */
+export declare function readSpec(file: string, options: {
+    file: string;
+    create?: string | undefined;
+}): string | undefined;
+/**
+ * Adds the test called `create` to the spec when it is not there yet (writing the file), and picks the test and the
+ * step index to record from. Throws before writing anything when the test or `at` is wrong.
+ */
+export declare function prepareSpec(file: string, existing: string | undefined, options: {
+    create?: string | undefined;
+    test?: string | number | undefined;
+    at?: number | undefined;
+}): RecordingSpec;
+/** Writes each recorded step into the spec file as a minimal edit and keeps the events */
+export declare class SpecWriter {
+    private source;
+    private readonly file;
+    private readonly testIndex;
+    readonly events: RecorderEvent[];
+    constructor(source: string, file: string, testIndex: number);
+    /** Applies the event, writes the file and returns the file's new content */
+    write(event: RecorderEvent): string;
+}

package/dist/recorder/spec-source.js

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parseSpec } from "../steps/parse.js";
+import { applyRecorderEvent } from "./apply.js";
+const NEW_SPEC_HEADER = `import { expect, test } from "@itmetsam/samurai-framework";\n\n`;
+/** `source` with an empty test called `title` added (a new file gets the import line first) */
+export function addTest(source, title) {
+    const header = source.trim() === ""
+        ? NEW_SPEC_HEADER
+        : `${source.replace(/\s*$/, "")}\n\n`;
+    return `${header}test(${JSON.stringify(title)}, async ({ page }) => {\n});\n`;
+}
+/** The index of the test `selector` names (see `RecordSpecOptions.test`) */
+export function pickTest(tests, selector) {
+    if (tests.length === 0)
+        throw new Error("The file has no tests; give a title with --new to add one");
+    if (selector === undefined) {
+        if (tests.length === 1)
+            return 0;
+        throw new Error(`The file has ${tests.length} tests; choose one with --test:\n${tests.map((t) => `  ${t.name}`).join("\n")}`);
+    }
+    if (typeof selector === "number") {
+        if (!Number.isInteger(selector) ||
+            selector < 0 ||
+            selector >= tests.length) {
+            throw new Error(`There is no test ${selector}; the file has ${tests.length}`);
+        }
+        return selector;
+    }
+    const exact = tests.findIndex((t) => t.name === selector);
+    if (exact !== -1)
+        return exact;
+    const partial = tests.flatMap((t, index) => t.name.includes(selector) ? [index] : []);
+    if (partial.length === 1)
+        return partial[0];
+    throw new Error(partial.length === 0
+        ? `No test matches "${selector}". Tests:\n${tests.map((t) => `  ${t.name}`).join("\n")}`
+        : `"${selector}" matches ${partial.length} tests; use the full name`);
+}
+/** The spec's text, `undefined` when the file is not there yet; throws when it must exist (no `create`) */
+export function readSpec(file, options) {
+    const source = existsSync(file) ? readFileSync(file, "utf8") : undefined;
+    if (source === undefined && options.create === undefined) {
+        throw new Error(`${options.file} does not exist; give a title with --new to create it`);
+    }
+    return source;
+}
+/**
+ * Adds the test called `create` to the spec when it is not there yet (writing the file), and picks the test and the
+ * step index to record from. Throws before writing anything when the test or `at` is wrong.
+ */
+export function prepareSpec(file, existing, options) {
+    let source = existing ?? "";
+    if (options.create !== undefined &&
+        !parseSpec(source).some((t) => t.name === options.create)) {
+        source = addTest(source, options.create);
+        mkdirSync(path.dirname(file), { recursive: true });
+        writeFileSync(file, source);
+    }
+    const tests = parseSpec(source);
+    const testIndex = pickTest(tests, options.create ?? options.test);
+    const test = tests[testIndex];
+    const at = options.at ?? test.steps.length;
+    if (!Number.isInteger(at) || at < 0 || at > test.steps.length) {
+        throw new RangeError(`--at must be between 0 and ${test.steps.length} (the test has ${test.steps.length} steps)`);
+    }
+    return { source, testIndex, testName: test.name, at };
+}
+/** Writes each recorded step into the spec file as a minimal edit and keeps the events */
+export class SpecWriter {
+    constructor(source, file, testIndex) {
+        this.source = source;
+        this.file = file;
+        this.testIndex = testIndex;
+        this.events = [];
+    }
+    /** Applies the event, writes the file and returns the file's new content */
+    write(event) {
+        this.source = applyRecorderEvent(this.source, this.testIndex, event);
+        writeFileSync(this.file, this.source);
+        this.events.push(event);
+        return this.source;
+    }
+}

package/dist/recorder/toolbar/action-guard.d.ts

@@ -0,0 +1,21 @@
+import type { ActionReply } from "./protocol.js";
+import type { Message, Of } from "./types.js";
+/** The messages that expect a reply, and that a double click sends twice */
+type Replying = Of<"assert" | "insert" | "add-insertable">;
+/**
+ * Drops the repeat of an action that is running or was answered `{ ok: true }` (a double click: its first copy
+ * answers), and lets a retry after `{ ok: false }` through.
+ */
+export declare class ActionGuard {
+    /** Ids of `assert`, `insert` and `add-insertable` being processed */
+    private readonly inFlight;
+    /** Ids `accept` let through whose `run` hasn't started yet */
+    private readonly claimed;
+    /** Ids answered `{ ok: true }`: their step exists, a repeat is a double click */
+    private readonly done;
+    /** Whether to process `message`; call it as the message arrives, before queueing it */
+    accept(message: Message): boolean;
+    /** Runs an action that expects a reply, unless it is a repeat (see `accept`); `reply` gets the answer */
+    run(message: Replying, work: () => Promise<ActionReply>, reply: (id: number, result: ActionReply) => void): Promise<void>;
+}
+export {};

package/dist/recorder/toolbar/action-guard.js

@@ -0,0 +1,43 @@
+/**
+ * Drops the repeat of an action that is running or was answered `{ ok: true }` (a double click: its first copy
+ * answers), and lets a retry after `{ ok: false }` through.
+ */
+export class ActionGuard {
+    constructor() {
+        /** Ids of `assert`, `insert` and `add-insertable` being processed */
+        this.inFlight = new Set();
+        /** Ids `accept` let through whose `run` hasn't started yet */
+        this.claimed = new Set();
+        /** Ids answered `{ ok: true }`: their step exists, a repeat is a double click */
+        this.done = new Set();
+    }
+    /** Whether to process `message`; call it as the message arrives, before queueing it */
+    accept(message) {
+        if (message.action !== "assert" &&
+            message.action !== "insert" &&
+            message.action !== "add-insertable")
+            return true;
+        const { id } = message;
+        if (this.inFlight.has(id) || this.done.has(id))
+            return false;
+        this.inFlight.add(id);
+        this.claimed.add(id);
+        return true;
+    }
+    /** Runs an action that expects a reply, unless it is a repeat (see `accept`); `reply` gets the answer */
+    async run(message, work, reply) {
+        const { id } = message;
+        if (!this.claimed.has(id) && !this.accept(message))
+            return;
+        this.claimed.delete(id);
+        try {
+            const result = await work();
+            if (result.ok)
+                this.done.add(id);
+            reply(id, result);
+        }
+        finally {
+            this.inFlight.delete(id);
+        }
+    }
+}

package/dist/recorder/toolbar/actions/assert.d.ts

@@ -0,0 +1,4 @@
+import type { ActionReply } from "../protocol.js";
+import type { ActionContext, Of } from "../types.js";
+/** Turns the Assert panel's choice into an `expect` step for the element that was picked */
+export declare function assertAction(ctx: ActionContext, message: Of<"assert">): Promise<ActionReply>;

package/dist/recorder/toolbar/actions/assert.js

@@ -0,0 +1,52 @@
+import { fail, PAUSED } from "./reply.js";
+/** Turns the Assert panel's choice into an `expect` step for the element that was picked */
+export async function assertAction(ctx, message) {
+    if (ctx.isPaused())
+        return fail(PAUSED);
+    const pick = ctx.pick();
+    if (!pick || pick.id !== message.id)
+        return fail("Pick the element again");
+    let locator = pick.locator;
+    let expectation;
+    const expected = String(message.expected ?? "");
+    switch (message.matcher) {
+        case "toBeVisible":
+            expectation = { matcher: "toBeVisible" };
+            break;
+        case "toHaveText":
+        case "toContainText":
+        case "toHaveValue":
+            expectation = { matcher: message.matcher, expected };
+            break;
+        case "toHaveAttribute":
+            if (!message.attribute)
+                return fail("Choose an attribute");
+            expectation = {
+                matcher: "toHaveAttribute",
+                name: message.attribute,
+                expected,
+            };
+            break;
+        case "toHaveCount": {
+            const call = pick.counts[message.countIndex ?? 0];
+            const count = Number(expected);
+            if (!call)
+                return fail("Choose what to count");
+            if (expected.trim() === "" || !Number.isInteger(count) || count < 0)
+                return fail("A count is a whole number");
+            locator = { chain: [call], fallbacks: [] };
+            expectation = { matcher: "toHaveCount", expected: count };
+            break;
+        }
+        default:
+            return fail("Choose a matcher");
+    }
+    ctx.setPick(undefined);
+    ctx.deps.observe({
+        type: "expect",
+        locator,
+        not: message.not === true,
+        expectation,
+    });
+    return { ok: true };
+}

package/dist/recorder/toolbar/actions/insert.d.ts

@@ -0,0 +1,6 @@
+import type { ActionReply } from "../protocol.js";
+import type { ActionContext, Of } from "../types.js";
+/** Types a variable or secret the tester already has into the field they picked, and records one `insert` step */
+export declare function insertAction(ctx: ActionContext, message: Of<"insert">): Promise<ActionReply>;
+/** Saves a new variable or secret to the project, then types it into the field and records the `insert` step */
+export declare function addInsertableAction(ctx: ActionContext, message: Of<"add-insertable">): Promise<ActionReply>;

package/dist/recorder/toolbar/actions/insert.js

@@ -0,0 +1,93 @@
+import { ConfigEditError } from "../../../project/config-edit.js";
+import { SECRET_NAME } from "../../../project/secrets-file.js";
+import { ExistsError, VARIABLE_NAME } from "../../../project/variables.js";
+import { fail, NO_ENVIRONMENT, PAUSED, TYPE_FAILED, UNIDENTIFIABLE, } from "./reply.js";
+/** Types a variable or secret the tester already has into the field they picked, and records one `insert` step */
+export async function insertAction(ctx, message) {
+    if (ctx.isPaused())
+        return fail(PAUSED);
+    const { kind, name } = message;
+    const value = kind === "secret" ? ctx.secrets.get(name) : ctx.variables.get(name);
+    if (value === undefined)
+        return fail(kind === "secret"
+            ? `Set a value for ${name} first`
+            : `There is no variable "${name}"`);
+    const locator = await locate(ctx, message);
+    if (!locator)
+        return fail(UNIDENTIFIABLE);
+    return typeIn(ctx, locator, kind, name, value);
+}
+/** Saves a new variable or secret to the project, then types it into the field and records the `insert` step */
+export async function addInsertableAction(ctx, message) {
+    if (ctx.isPaused())
+        return fail(PAUSED);
+    const { kind, name } = message;
+    const value = String(message.value ?? "");
+    if (kind === "env" && !ctx.options.canAddVariables)
+        return fail(NO_ENVIRONMENT);
+    const known = kind === "env"
+        ? ctx.variables.has(name)
+        : ctx.secrets.get(name) !== undefined;
+    if (known)
+        return fail(`"${name}" already exists`, "name");
+    // Found before anything is written: an element that can't be filled leaves the project as it was
+    const locator = await locate(ctx, message);
+    if (!locator)
+        return fail(UNIDENTIFIABLE);
+    const written = kind === "env"
+        ? await write(() => ctx.deps.addVariable(name, value), (err) => err instanceof ConfigEditError
+            ? fail(`samurai.config.ts can't be changed automatically. Add ${name} to environments.${ctx.options.environment}.variables yourself.`)
+            : err instanceof ExistsError || !VARIABLE_NAME.test(name)
+                ? fail(errorText(err), "name")
+                : fail(errorText(err)))
+        : await write(() => ctx.deps.setSecret(name, value), (err) => 
+        // An error never echoes the value
+        SECRET_NAME.test(name)
+            ? fail(scrub(errorText(err), value))
+            : fail(scrub(errorText(err), value), "name"));
+    if (written)
+        return written;
+    if (kind === "env")
+        ctx.variables.set(name, value);
+    else {
+        ctx.secrets.set(name, value);
+        ctx.deps.secretAdded(name);
+    }
+    ctx.push();
+    return typeIn(ctx, locator, kind, name, value, true);
+}
+/** Undefined when `work` succeeded, else the reply for its error */
+async function write(work, replyFor) {
+    try {
+        await work();
+        return undefined;
+    }
+    catch (err) {
+        return replyFor(err);
+    }
+}
+async function locate(ctx, message) {
+    if (!message.target)
+        return undefined;
+    try {
+        return await ctx.deps.rank(message.target, message.candidates);
+    }
+    catch {
+        return undefined; // the element went away
+    }
+}
+async function typeIn(ctx, locator, kind, name, value, saved = false) {
+    try {
+        await ctx.deps.type(locator, value);
+    }
+    catch {
+        // Typing clicks the field, which closes the panel the reply is for: the toast is what the tester sees
+        ctx.showToast(saved ? `Saved ${name}, but couldn't type into that field` : TYPE_FAILED);
+        ctx.push();
+        return fail(TYPE_FAILED);
+    }
+    ctx.deps.observe({ type: "insert", locator, value: { kind, name } });
+    return { ok: true };
+}
+const errorText = (err) => err instanceof Error ? err.message : String(err);
+const scrub = (text, secret) => secret === "" ? text : text.split(secret).join("••••••");

package/dist/recorder/toolbar/actions/pick.d.ts

@@ -0,0 +1,8 @@
+import type { PickInfo } from "../protocol.js";
+/**
+ * A field may hold an inserted secret: its value (and any text or attribute equal to a secret) is left out,
+ * and the first matcher follows the Alt+click rule without a value, so neither the page nor the spec gets it.
+ */
+export declare function withoutSecrets(info: PickInfo & {
+    ok: true;
+}, secrets: Map<string, string | undefined>): PickInfo;

package/dist/recorder/toolbar/actions/pick.js

@@ -0,0 +1,26 @@
+import { expectationFor } from "../../expectation.js";
+/**
+ * A field may hold an inserted secret: its value (and any text or attribute equal to a secret) is left out,
+ * and the first matcher follows the Alt+click rule without a value, so neither the page nor the spec gets it.
+ */
+export function withoutSecrets(info, secrets) {
+    const values = [...secrets.values()].filter((value) => value !== undefined && value !== "");
+    const secret = (text) => text !== undefined && values.some((value) => text.includes(value));
+    if (!secret(info.value) &&
+        !secret(info.text) &&
+        !secret(info.first.expected) &&
+        !info.attributes.some((a) => secret(a.value)))
+        return info;
+    const text = secret(info.text) ? "" : info.text;
+    const first = expectationFor(text, undefined);
+    const { value: _value, ...rest } = info;
+    return {
+        ...rest,
+        text,
+        attributes: info.attributes.filter((a) => !secret(a.value)),
+        first: {
+            matcher: first.matcher,
+            ...("expected" in first && { expected: String(first.expected) }),
+        },
+    };
+}

package/dist/recorder/toolbar/actions/reply.d.ts

@@ -0,0 +1,7 @@
+import type { ActionReply } from "../protocol.js";
+export declare const UNIDENTIFIABLE = "This element can't be identified uniquely";
+export declare const TYPE_FAILED = "Couldn't type into that field";
+export declare const NO_ENVIRONMENT = "This recording has no environment";
+export declare const PAUSED = "Nothing you do now is recorded.";
+/** A refusal the toolbar shows; `field` names the form field to mark */
+export declare const fail: (error: string, field?: "name") => ActionReply;

package/dist/recorder/toolbar/actions/reply.js

@@ -0,0 +1,10 @@
+export const UNIDENTIFIABLE = "This element can't be identified uniquely";
+export const TYPE_FAILED = "Couldn't type into that field";
+export const NO_ENVIRONMENT = "This recording has no environment";
+export const PAUSED = "Nothing you do now is recorded.";
+/** A refusal the toolbar shows; `field` names the form field to mark */
+export const fail = (error, field) => ({
+    ok: false,
+    error,
+    ...(field && { field }),
+});

package/dist/recorder/toolbar/controller-fixture.d.ts

@@ -0,0 +1,47 @@
+import { ElementHandle } from "../../script/element-handle.js";
+import type { LocatorCall, LocatorSpec } from "../../steps/model.js";
+import type { Observation } from "../normalise.js";
+import { ToolbarController } from "./controller.js";
+import type { ActionReply, PickInfo, ToolbarMessage, ToolbarState } from "./protocol.js";
+import type { ControllerDeps, ControllerOptions } from "./types.js";
+export declare const SECRET = "hunter2-very-secret";
+export declare const NEW_SECRET = "n3w-s3cr3t-value";
+export declare const TARGET: ElementHandle;
+export declare const CANDIDATES: LocatorCall[];
+export declare const LOCATOR: LocatorSpec;
+export declare const COUNT_CALL: LocatorCall;
+export declare const INFO: PickInfo & {
+    ok: true;
+};
+export declare const lastOf: <T>(items: T[]) => T | undefined;
+export type Message = ToolbarMessage & {
+    target?: ElementHandle;
+};
+export declare const msg: (message: Record<string, unknown>) => Message;
+export declare const insert: (id: number, kind: "env" | "secret", name: string) => Message;
+export declare const add: (id: number, kind: "env" | "secret", name: string, value: string) => Message;
+export declare const pick: (id: number) => Message;
+/** A controller over fakes that record everything */
+export declare function setup(options?: Partial<ControllerOptions>, overrides?: Partial<ControllerDeps>): {
+    controller: ToolbarController;
+    pushes: ToolbarState[];
+    replies: {
+        id: number;
+        result: PickInfo | ActionReply;
+    }[];
+    observed: Observation[];
+    statuses: {
+        state: string;
+        toolbar: boolean;
+    }[];
+    calls: string[];
+    page: {
+        url: string;
+    };
+    last: () => ToolbarState;
+    noSecretLeaks: () => void;
+};
+/** Deps whose `type` fails, as a field that can't be typed into does */
+export declare const failingType: {
+    type: () => Promise<never>;
+};