@itmetsam/samurai-framework 0.20.0 → 0.21.1

package/dist/runner/reporter.d.ts

@@ -56,6 +56,10 @@ export interface TestEndExtras extends TestRetries {
         name: string;
         path: string;
     }[];
+    /** The test's inputs, when it declares any */
+    inputs?: Record<string, string>;
+    /** The test's saved outputs, when it declares any */
+    outputs?: Record<string, string>;
 }
 export default class TestReporter implements TestSink {
     private testResults;

package/dist/runner/reporter.js

@@ -146,6 +146,8 @@ export default class TestReporter {
             ...(extras?.logs && { logs: extras.logs }),
             ...(extras?.logsDropped && { logsDropped: extras.logsDropped }),
             ...(extras?.screenshots?.length && { screenshots: extras.screenshots }),
+            ...(extras?.inputs && { inputs: extras.inputs }),
+            ...(extras?.outputs && { outputs: extras.outputs }),
             ...(extras?.retry && { retry: extras.retry }),
             ...(extras?.flaky && { flaky: true }),
             ...(extras?.previousAttempts?.length && {

package/dist/runner/run-test.js

@@ -13,6 +13,8 @@ import { isSkipSignal, staticSkip } from "./skip.js";
 import { runOutput } from "./output.js";
 import { testDirOf } from "./test-dir.js";
 import { toTestError } from "./test-error.js";
+import { createInputsFixture, createOutputsFixture, ioOfAttempt, missingOutputs, } from "./test-io.js";
+import { beginOutputs, endOutputs } from "../wait/output-sink.js";
 /**
  * The state of one test run. A test ends once, whichever of finishing, failing, timing out, an abort or a
  * closed browser comes first: that one is reported and the rest are ignored.
@@ -28,6 +30,8 @@ class TestOutcome {
         this.closing = false;
         /** A person closed the browser, or it crashed, while the test ran */
         this.browserClosed = false;
+        /** The test's inputs and outputs, as its report entry lists them when it ends */
+        this.io = () => ({});
     }
     get isEnded() {
         return this.ended;
@@ -49,6 +53,7 @@ class TestOutcome {
         this.reporter.onTestEnd(this.test, this.browser, error, {
             ...logs,
             screenshots: this.evidence?.screenshots,
+            ...this.io(),
         });
     }
 }
@@ -137,6 +142,8 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
                 workerIndex: resources.workerIndex ?? 0,
                 env: createEnvFixture(settings.environment, settings.variables),
                 secrets: createSecretsFixture(settings.environment, secrets),
+                inputs: createInputsFixture(test.inputs, options.inputs),
+                outputs: createOutputsFixture(sink),
             };
             await runWithEachHooks(test.suite, fixtures, timeoutController.signal, () => test.function(fixtures));
             // Already reported as timed out
@@ -146,12 +153,18 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
             if (unawaited.length > 0) {
                 outcome.finish({
                     message: unawaited
-                        .map((matcher) => `expect(locator).${matcher}() was not awaited`)
+                        .map((label) => `${label} was not awaited`)
                         .join("\n"),
                     type: "assertion",
                 }, await judgeLogs(page, true));
                 return;
             }
+            // Checked only after a pass: a test that failed first reports its own failure
+            const missing = missingOutputs(test.outputs, sink);
+            if (missing) {
+                outcome.finish(missing, await judgeLogs(page, true));
+                return;
+            }
             const verdict = await judgeLogs(page, false);
             outcome.finish(verdict.error, verdict);
         }
@@ -168,7 +181,15 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
                 : toTestError(err), await judgeLogs(page, true));
         }
     };
-    await Promise.race([limit, gone, runBody()]);
+    // Open for this attempt only: whatever a capture still saves after the attempt ended is ignored
+    const sink = beginOutputs(test.outputs ?? []);
+    outcome.io = () => ioOfAttempt(test, options.inputs, sink);
+    try {
+        await Promise.race([limit, gone, runBody()]);
+    }
+    finally {
+        endOutputs();
+    }
     clearTimeout(timeoutTimer);
     if (onRunAborted)
         options.signal?.removeEventListener("abort", onRunAborted);

package/dist/runner/run.d.ts

@@ -30,6 +30,13 @@ export interface FoundTest {
     modifier?: Modifier;
     /** The `{ reason }` given with the `skip` or `fixme` that applies */
     reason?: string;
+    /** The inputs the test declares, in declaration order, with their defaults; absent when it declares none */
+    inputs?: {
+        name: string;
+        default: string;
+    }[];
+    /** The names of the outputs the test declares; absent when it declares none */
+    outputs?: string[];
 }
 /**
  * Imports the project's specs without running anything and lists the tests the options select, each with the id

package/dist/runner/run.js

@@ -43,7 +43,7 @@ export async function listTests(options = {}) {
     return inProject(options, async (runner) => {
         const { tests, srcDir } = await runner.list();
         return tests.map((test) => {
-            const { name, file, modifier, reason } = test;
+            const { name, file, modifier, reason, inputs, outputs } = test;
             const relativeFile = toPosix(path.relative(srcDir, file));
             return {
                 id: testId(relativeFile, name),
@@ -52,6 +52,13 @@ export async function listTests(options = {}) {
                 relativeFile,
                 ...(modifier && { modifier }),
                 ...(reason !== undefined && { reason }),
+                ...(inputs && {
+                    inputs: Object.entries(inputs).map(([name, value]) => ({
+                        name,
+                        default: value,
+                    })),
+                }),
+                ...(outputs && { outputs }),
             };
         });
     });

package/dist/runner/test-io.d.ts

@@ -0,0 +1,30 @@
+import type { TestError, TestOptions, TestOutputs } from "../types/test.js";
+import type { OutputSink } from "../wait/output-sink.js";
+/**
+ * Checks the `inputs` and `outputs` of a `test()` options object and returns them, leaving out an empty or absent
+ * list. `call` is the form used (`test`, `test.only`, ...), named in the error.
+ */
+export declare function validateTestIO(call: string, options: TestOptions): {
+    inputs?: Record<string, string>;
+    outputs?: string[];
+};
+/**
+ * The `inputs` fixture: each declared input with the value the run supplies, else its default. Reading a
+ * name the test did not declare throws.
+ */
+export declare function createInputsFixture(declared: Record<string, string> | undefined, supplied: Record<string, string> | undefined): Readonly<Record<string, string>>;
+/**
+ * The `outputs` fixture of one attempt: `save` waits for the element's text (non-empty, or matching the pattern), as
+ * `toHaveText` reads it, and keeps it in `sink`. It keeps to its own attempt's sink, so a late value never lands in a later test.
+ */
+export declare function createOutputsFixture(sink: OutputSink): TestOutputs;
+/** The failure of a passing attempt that did not save every output it declared */
+export declare function missingOutputs(declared: readonly string[] | undefined, sink: OutputSink): TestError | undefined;
+/** What an attempt's result lists: its inputs when it declares any, its outputs so far when it declares any */
+export declare function ioOfAttempt(test: {
+    inputs?: Record<string, string>;
+    outputs?: string[];
+}, supplied: Record<string, string> | undefined, sink: OutputSink): {
+    inputs?: Record<string, string>;
+    outputs?: Record<string, string>;
+};

package/dist/runner/test-io.js

@@ -0,0 +1,111 @@
+import { captured, textCheck } from "../assert/text-match.js";
+import { readEventually } from "../assert/locator-assertions.js";
+import { track } from "../assert/pending-assertions.js";
+import { isPassthroughKey } from "../config/variables.js";
+import { isIoName } from "../flows/core/steps.js";
+function checkName(call, kind, name) {
+    if (typeof name !== "string" || !isIoName(name))
+        throw new Error(`${call}(): ${kind} ${quoted(name)} is not a valid name`);
+}
+const has = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+/** A name in a message: strings quoted, anything else as written */
+function quoted(name) {
+    return typeof name === "string" ? JSON.stringify(name) : String(name);
+}
+/**
+ * Checks the `inputs` and `outputs` of a `test()` options object and returns them, leaving out an empty or absent
+ * list. `call` is the form used (`test`, `test.only`, ...), named in the error.
+ */
+export function validateTestIO(call, options) {
+    const { inputs, outputs } = options;
+    const result = {};
+    if (inputs !== undefined) {
+        if (typeof inputs !== "object" || inputs === null || Array.isArray(inputs))
+            throw new Error(`${call}(): inputs must be an object of names and defaults`);
+        for (const [name, value] of Object.entries(inputs)) {
+            checkName(call, "input", name);
+            if (typeof value !== "string")
+                throw new Error(`${call}(): input "${name}" needs a string default`);
+        }
+        if (Object.keys(inputs).length > 0)
+            result.inputs = { ...inputs };
+    }
+    if (outputs !== undefined) {
+        if (!Array.isArray(outputs))
+            throw new Error(`${call}(): outputs must be an array of names`);
+        const seen = new Set();
+        for (const name of outputs) {
+            checkName(call, "output", name);
+            if (seen.has(name))
+                throw new Error(`${call}(): output "${name}" is listed twice`);
+            seen.add(name);
+        }
+        if (outputs.length > 0)
+            result.outputs = [...outputs];
+    }
+    return result;
+}
+/**
+ * The `inputs` fixture: each declared input with the value the run supplies, else its default. Reading a
+ * name the test did not declare throws.
+ */
+export function createInputsFixture(declared, supplied) {
+    return new Proxy(Object.freeze(resolveInputs(declared, supplied)), {
+        get(target, key, receiver) {
+            if (isPassthroughKey(target, key) || has(target, key))
+                return Reflect.get(target, key, receiver);
+            throw new Error(`inputs.${String(key)}: not declared, add it to the test's inputs`);
+        },
+    });
+}
+/** Each declared input with the supplied value, else its default; names the test does not declare are left out */
+function resolveInputs(declared, supplied) {
+    return Object.fromEntries(Object.entries(declared ?? {}).map(([name, value]) => [
+        name,
+        supplied && has(supplied, name) ? supplied[name] : value,
+    ]));
+}
+/**
+ * The `outputs` fixture of one attempt: `save` waits for the element's text (non-empty, or matching the pattern), as
+ * `toHaveText` reads it, and keeps it in `sink`. It keeps to its own attempt's sink, so a late value never lands in a later test.
+ */
+export function createOutputsFixture(sink) {
+    return {
+        save: (name, locator, pattern) => track("outputs.save()", saveText(sink, name, locator, pattern)),
+    };
+}
+async function saveText(sink, name, locator, pattern) {
+    if (!sink.declares(name))
+        throw new Error(`outputs.save(): output ${JSON.stringify(name)} is not declared`);
+    const matches = pattern ? textCheck(pattern, "exact") : undefined;
+    const text = await readEventually({
+        name: "toHaveText",
+        locator,
+        expected: pattern ?? "an element with text",
+        read: () => locator.textContent(),
+        // Without a pattern, an element that has not rendered its value yet (no text) is waited for
+        check: (actual) => actual !== null && (matches ? matches(actual) : actual !== ""),
+        call: `outputs.save(${JSON.stringify(name)})`,
+    });
+    sink.set(name, pattern ? captured(pattern, text) : text);
+}
+/** The failure of a passing attempt that did not save every output it declared */
+export function missingOutputs(declared, sink) {
+    const saved = sink.values();
+    const missing = (declared ?? []).filter((name) => !has(saved, name));
+    if (missing.length === 0)
+        return undefined;
+    return {
+        message: missing
+            .map((name) => `output ${JSON.stringify(name)} was never saved`)
+            .join("\n"),
+        type: "assertion",
+    };
+}
+/** What an attempt's result lists: its inputs when it declares any, its outputs so far when it declares any */
+export function ioOfAttempt(test, supplied, sink) {
+    return {
+        ...(test.inputs && { inputs: resolveInputs(test.inputs, supplied) }),
+        ...(test.outputs && { outputs: sink.values() }),
+    };
+}

package/dist/runner/test-runner.js

@@ -88,7 +88,7 @@ export default class TestRunner {
             env: process.env.SAMURAI_RETRIES,
             config: config.retries,
         });
-        const plan = planItems(selected, browsers, serialKeyOf(loaded.groups, config.groups, loaded.srcDir));
+        const plan = planItems(selected, browsers, serialKeyOf(loaded.groups, config.groups, loaded.srcDir), this.options.inputs);
         // A pool larger than what can overlap would only hold idle workers: a group that runs one at a time needs one
         const lanes = concurrency(plan.items);
         const mode = poolMode({

package/dist/runner/worker-protocol.d.ts

@@ -13,6 +13,8 @@ export interface WorkItem {
     serialKey?: string;
     /** Where this test's screenshots go, instead of the run's `outputDir` (a flow gives each node its own) */
     outputDir?: string;
+    /** The values the run supplies for the inputs tests declare (`runTests({ inputs })`) */
+    inputs?: Record<string, string>;
 }
 /** What a worker needs to start: the project and the settings that are the same for every test */
 export interface WorkerInit {

package/dist/runner/worker-session.js

@@ -51,6 +51,7 @@ export function openSession(init) {
                         ...((perTest.outputDir ?? init.outputDir) !== undefined && {
                             outputDir: perTest.outputDir ?? init.outputDir,
                         }),
+                        ...(perTest.inputs !== undefined && { inputs: perTest.inputs }),
                         port,
                         signal,
                     };

package/dist/runner/worker.d.ts

@@ -8,6 +8,7 @@ export interface WorkerSession {
     /** Runs one test; `onEvent` gets the reporter's events for it. Aborting `signal` ends the test as aborted */
     runTest(test: RegisteredTestCase, browser: SupportedBrowser, signal: AbortSignal, onEvent: (event: RunEvent) => void, options?: {
         outputDir?: string;
+        inputs?: Record<string, string>;
     }): Promise<void>;
     /** Ends the project's session */
     close(): Promise<void>;

package/dist/runner/worker.js

@@ -54,7 +54,10 @@ export function handleMessages(channel, { open, exit }) {
                     id,
                     result: { ...event.result, worker: workerIndex },
                 });
-            }, item.outputDir !== undefined ? { outputDir: item.outputDir } : {});
+            }, {
+                ...(item.outputDir !== undefined && { outputDir: item.outputDir }),
+                ...(item.inputs !== undefined && { inputs: item.inputs }),
+            });
         }
         finally {
             current = undefined;

package/dist/steps/edit.d.ts

@@ -1,4 +1,4 @@
-import type { Step } from "./model.js";
+import type { Step, TestInput } from "./model.js";
 export type StepEdit = {
     op: "replace";
     test: number;
@@ -32,10 +32,21 @@ export type StepEdit = {
  | {
     op: "remove-test";
     test: number;
+}
+/**
+ * Sets the test's `inputs` and `outputs` in its options object: a given list replaces that list, one left out
+ * stays. When both end up empty the options object goes, unless it holds a `reason`
+ */
+ | {
+    op: "declare";
+    test: number;
+    inputs?: TestInput[];
+    outputs?: string[];
 };
 /**
  * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters
- * when the step reads a fixture (`env`, `secrets`) they don't have yet: everything else, formatting and
- * comments included, stays byte for byte.
+ * when the step reads a fixture (`env`, `secrets`, `inputs`, `outputs`) they don't have yet, and its `outputs`
+ * when the step saves one not declared yet: everything else, formatting and comments included, stays byte for
+ * byte. A step that reads an undeclared input is refused: `declare` it, with its default, first.
  */
 export declare function applyEdit(source: string, edit: StepEdit): string;

package/dist/steps/edit.js

@@ -1,12 +1,9 @@
 import ts from "typescript";
 import { stepToSource } from "./emit.js";
 import { parseSpec } from "./parse.js";
-const lineStart = (source, offset) => source.lastIndexOf("\n", offset - 1) + 1;
-function lineEnd(source, offset) {
-    const newline = source.indexOf("\n", offset);
-    return newline === -1 ? source.length : newline + 1;
-}
-const indentOf = (source, offset) => /^[ \t]*/.exec(source.slice(lineStart(source, offset)))[0];
+import { OUTPUT_MATCHERS } from "./parse/expectation.js";
+import { declareList } from "./test-options.js";
+import { indentOf, lineEnd, lineStart, splice } from "./text.js";
 function pickTest(source, test) {
     const found = parseSpec(source)[test];
     if (!found)
@@ -19,9 +16,6 @@ function pickStep(parsed, index) {
         throw new RangeError(`Test "${parsed.name}" has no step ${index}`);
     return step;
 }
-function splice(source, from, to, text) {
-    return source.slice(0, from) + text + source.slice(to);
-}
 /** Inserts statement text so it becomes step `index`, copying the indentation of the steps around it */
 function insertCode(source, parsed, index, code) {
     if (index < 0 || index > parsed.steps.length) {
@@ -52,11 +46,58 @@ function removeStep(source, parsed, index) {
     const { anchor, end } = pickStep(parsed, index);
     return splice(source, lineStart(source, anchor), lineEnd(source, end), "");
 }
+const VALUE_FIXTURES = { env: "env", secret: "secrets", input: "inputs" };
 /** The fixtures a step's statement reads */
 function fixturesOf(step) {
+    if (step.kind === "saveOutput")
+        return ["outputs"];
     if (step.kind !== "fill" || step.value.kind === "literal")
         return [];
-    return [step.value.kind === "env" ? "env" : "secrets"];
+    return [VALUE_FIXTURES[step.value.kind]];
+}
+/** The output a step saves, if any */
+function outputOf(step) {
+    if (step.kind === "saveOutput")
+        return step.name;
+    return step.kind === "fill" || step.kind === "expect"
+        ? step.output
+        : undefined;
+}
+/** Refuses a step that reads an input the test doesn't declare: the default has to be set first */
+function checkInputs(parsed, step) {
+    if (step.kind !== "fill" || step.value.kind !== "input")
+        return;
+    const { name } = step.value;
+    if (!parsed.inputs?.some((input) => input.name === name))
+        throw new Error(`applyEdit(): input "${name}" is not declared`);
+}
+/** Refuses an output the runtime can't save: from a negated check, or from a matcher that doesn't take one */
+function checkOutput(step) {
+    if (step.kind !== "expect" || step.output === undefined)
+        return;
+    if (step.not)
+        throw new Error("applyEdit(): output can't be saved from a negated check");
+    if (!OUTPUT_MATCHERS.includes(step.expectation.matcher))
+        throw new Error(`applyEdit(): output can't be saved from ${step.expectation.matcher}`);
+}
+/** Adds the output a step saves to the test's `outputs`, when it isn't there yet */
+function withOutput(source, parsed, step) {
+    const name = outputOf(step);
+    const outputs = parsed.outputs ?? [];
+    if (name === undefined || outputs.includes(name))
+        return source;
+    return declareList(source, parsed, "outputs", [...outputs, name]);
+}
+/**
+ * Puts a step's statement in at `[from, to)` of the body, then what it needs: its fixtures, its output and
+ * the `generatedFile` import. Each goes before the last in the file, so the parsed offsets stay valid
+ */
+function withStep(source, parsed, step, place) {
+    checkInputs(parsed, step);
+    checkOutput(step);
+    const next = withOutput(withFixtures(place(source, stepToSource(step)), parsed, step), parsed, step);
+    // Last: the import shifts every offset
+    return usesGeneratedFile(step) ? withGeneratedFileImport(next) : next;
 }
 /** Adds the fixtures the step reads to the test's parameters, when they aren't there yet */
 function withFixtures(source, parsed, step) {
@@ -102,26 +143,27 @@ function withGeneratedFileImport(source) {
 }
 /**
  * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters
- * when the step reads a fixture (`env`, `secrets`) they don't have yet: everything else, formatting and
- * comments included, stays byte for byte.
+ * when the step reads a fixture (`env`, `secrets`, `inputs`, `outputs`) they don't have yet, and its `outputs`
+ * when the step saves one not declared yet: everything else, formatting and comments included, stays byte for
+ * byte. A step that reads an undeclared input is refused: `declare` it, with its default, first.
  */
 export function applyEdit(source, edit) {
     const parsed = pickTest(source, edit.test);
     switch (edit.op) {
         case "replace": {
             const { start, end } = pickStep(parsed, edit.index);
-            // The parameters come before the body: adding to them leaves the step's offsets valid
-            const next = withFixtures(splice(source, start, end, stepToSource(edit.step)), parsed, edit.step);
-            // Last: the import shifts every offset
-            return usesGeneratedFile(edit.step)
-                ? withGeneratedFileImport(next)
-                : next;
+            return withStep(source, parsed, edit.step, (text, code) => splice(text, start, end, code));
         }
-        case "insert": {
-            const next = withFixtures(insertCode(source, parsed, edit.index, stepToSource(edit.step)), parsed, edit.step);
-            return usesGeneratedFile(edit.step)
-                ? withGeneratedFileImport(next)
-                : next;
+        case "insert":
+            return withStep(source, parsed, edit.step, (text, code) => insertCode(text, parsed, edit.index, code));
+        case "declare": {
+            let next = source;
+            for (const key of ["inputs", "outputs"]) {
+                const list = edit[key];
+                if (list)
+                    next = declareList(next, pickTest(next, edit.test), key, list);
+            }
+            return next;
         }
         case "remove":
             return removeStep(source, parsed, edit.index);

package/dist/steps/emit.d.ts

@@ -1,6 +1,8 @@
 import type { FileEntry, LocatorCall, LocatorSpec, Step, TextValue } from "./model.js";
 /** The argument of `setInputFiles` / `dropFiles`: one entry bare, else an array */
 export declare function filesToSource(files: readonly FileEntry[]): string;
+/** A name that can follow a `.` or stand as an object key unquoted */
+export declare const IDENTIFIER: RegExp;
 export declare function callToSource(call: LocatorCall): string;
 export declare function locatorToSource({ chain, fallbacks }: LocatorSpec): string;
 export declare function valueToSource(value: TextValue): string;

package/dist/steps/emit.js

@@ -15,7 +15,8 @@ export function filesToSource(files) {
         ? fileEntryToSource(files[0])
         : `[${files.map(fileEntryToSource).join(", ")}]`;
 }
-const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/** A name that can follow a `.` or stand as an object key unquoted */
+export const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
 function textOptions(call) {
     const parts = [
         call.match !== undefined && `match: ${str(call.match)}`,
@@ -48,17 +49,38 @@ export function locatorToSource({ chain, fallbacks }) {
 export function valueToSource(value) {
     if (value.kind === "literal")
         return str(value.value);
-    const object = value.kind === "env" ? "env" : "secrets";
+    const object = value.kind === "env"
+        ? "env"
+        : value.kind === "secret"
+            ? "secrets"
+            : "inputs";
     return IDENTIFIER.test(value.name)
         ? `${object}.${value.name}`
         : `${object}[${str(value.name)}]`;
 }
+/**
+ * A regex literal for a pattern. The source goes through `RegExp`, which escapes a `/` and a line break and leaves
+ * text that is already escaped alone, so a pattern typed by hand still makes a literal that compiles.
+ */
+function regexToSource({ source, flags }) {
+    let escaped = source;
+    try {
+        escaped = new RegExp(source, flags).source;
+    }
+    catch {
+        // Not a valid pattern: written unchanged
+    }
+    return `/${escaped}/${flags}`;
+}
 function matcherToSource(expected) {
     return typeof expected === "string"
         ? str(expected)
-        : `/${expected.regex.source}/${expected.regex.flags}`;
+        : regexToSource(expected.regex);
 }
-function expectationToSource(expectation) {
+/** The `{ output }` option a fill or a check ends with, as its last argument */
+const outputOption = (output) => output === undefined ? "" : `, { output: ${str(output)} }`;
+function expectationToSource(expectation, output) {
+    const tail = outputOption(output);
     switch (expectation.matcher) {
         case "toBeVisible":
         case "toBeHidden":
@@ -66,13 +88,13 @@ function expectationToSource(expectation) {
         case "toBeChecked":
             return `${expectation.matcher}()`;
         case "toHaveAttribute":
-            return `toHaveAttribute(${str(expectation.name)}, ${matcherToSource(expectation.expected)})`;
+            return `toHaveAttribute(${str(expectation.name)}, ${matcherToSource(expectation.expected)}${tail})`;
         case "toHaveCSS":
             return `toHaveCSS(${str(expectation.name)}, ${matcherToSource(expectation.expected)})`;
         case "toHaveCount":
             return `toHaveCount(${expectation.expected})`;
         default:
-            return `${expectation.matcher}(${matcherToSource(expectation.expected)})`;
+            return `${expectation.matcher}(${matcherToSource(expectation.expected)}${tail})`;
     }
 }
 /** The statement for a step, on one line */
@@ -83,11 +105,11 @@ export function stepToSource(step) {
         case "click":
             return `await ${locatorToSource(step.locator)}.click();`;
         case "fill":
-            return `await ${locatorToSource(step.locator)}.fill(${valueToSource(step.value)});`;
+            return `await ${locatorToSource(step.locator)}.fill(${valueToSource(step.value)}${outputOption(step.output)});`;
         case "press":
             return `await ${locatorToSource(step.locator)}.press(${str(step.key)});`;
         case "expect":
-            return `await expect(${locatorToSource(step.locator)})${step.not ? ".not" : ""}.${expectationToSource(step.expectation)};`;
+            return `await expect(${locatorToSource(step.locator)})${step.not ? ".not" : ""}.${expectationToSource(step.expectation, step.output)};`;
         case "expectPage":
             return `await expect(page)${step.not ? ".not" : ""}.${expectationToSource(step.expectation)};`;
         case "waitForNetworkIdle":
@@ -99,6 +121,8 @@ export function stepToSource(step) {
         case "setInputFiles":
         case "dropFiles":
             return `await ${locatorToSource(step.locator)}.${step.kind}(${filesToSource(step.files)});`;
+        case "saveOutput":
+            return `await outputs.save(${str(step.name)}, ${locatorToSource(step.locator)}${step.pattern ? `, ${regexToSource(step.pattern)}` : ""});`;
         case "custom":
             return step.code;
     }

package/dist/steps/index.d.ts

@@ -3,4 +3,4 @@ export { applyEdit, type StepEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";
 export { locatorFromSpec } from "./build.js";
-export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, PageExpectation, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, UnparsedTest, } from "./model.js";
+export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, PageExpectation, ParsedStep, ParsedTest, Step, TextMatcher, TestInput, TextValue, UnparsedTest, } from "./model.js";