@itmetsam/samurai-framework 0.20.0 → 0.21.1

package/dist/steps/model.d.ts

@@ -39,6 +39,11 @@ export type TextValue = {
 } | {
     kind: "secret";
     name: string;
+}
+/** One of the test's declared `inputs`, `inputs.name` */
+ | {
+    kind: "input";
+    name: string;
 };
 /** What an assertion expects of text: a string or a regular expression */
 export type TextMatcher = string | {
@@ -95,15 +100,33 @@ export type Step = {
 } | {
     kind: "click";
     locator: LocatorSpec;
-} | {
+}
+/** `output` saves the typed value as that output, `{ output: "name" }` */
+ | {
     kind: "fill";
     locator: LocatorSpec;
     value: TextValue;
+    output?: string;
 } | {
     kind: "expect";
     locator: LocatorSpec;
     not: boolean;
     expectation: Expectation;
+    /**
+     * Saves what passed as that output. Read only with `toHaveText`, `toContainText`, `toHaveValue` and
+     * `toHaveAttribute`, never with `not`: any other shape is `custom`
+     */
+    output?: string;
+}
+/** Saves an element's text as an output, `outputs.save(name, locator, /pattern/)`: the first group, else the whole match */
+ | {
+    kind: "saveOutput";
+    name: string;
+    locator: LocatorSpec;
+    pattern?: {
+        source: string;
+        flags: string;
+    };
 }
 /** An assertion on the page, `expect(page).toHaveURL(…)` */
  | {
@@ -187,6 +210,22 @@ export interface ParsedTest {
     modifier?: Modifier;
     /** The `{ reason }` written with the `skip` or `fixme` that applies, when it is a string literal */
     reason?: string;
+    /** The `inputs` of the test's options object, in source order; undefined without the key */
+    inputs?: TestInput[];
+    /** The `outputs` of the test's options object; undefined without the key */
+    outputs?: string[];
+    /** The range of the test's options object (`test(title, { … }, fn)`), when it has one */
+    options?: {
+        start: number;
+        end: number;
+    };
+    /** Offset just after the title argument, where an options object goes */
+    titleEnd: number;
+}
+/** A declared input and the value it gets when nothing supplies one */
+export interface TestInput {
+    name: string;
+    default: string;
 }
 /** A `test` or `describe` call the codec can't read: its title isn't a plain string, or its function isn't written inline */
 export interface UnparsedTest {
@@ -194,5 +233,6 @@ export interface UnparsedTest {
     /** The statement's range, as for `ParsedTest` */
     start: number;
     end: number;
-    reason: "dynamic-title" | "not-inline";
+    /** `dynamic-options`: the options object isn't a literal the codec can read (`{ inputs: defaults }`, a variable) */
+    reason: "dynamic-title" | "not-inline" | "dynamic-options";
 }

package/dist/steps/parse/expectation.d.ts

@@ -1,6 +1,13 @@
 import ts from "typescript";
 import type { Expectation, PageExpectation, TextValue } from "../model.js";
-/** `env.NAME`, `env["NAME"]`, `secrets.NAME`, `secrets["NAME"]` or a string literal */
+/** `env.NAME`, `secrets.NAME`, `inputs.NAME` (or `env["NAME"]` and so on) or a string literal */
 export declare function readValue(node: ts.Expression | undefined): TextValue | undefined;
+/** `/source/flags` */
+export declare function readRegex(node: ts.Expression | undefined): {
+    source: string;
+    flags: string;
+} | undefined;
+/** The matchers that take `{ output }` as their last argument */
+export declare const OUTPUT_MATCHERS: readonly string[];
 export declare function readExpectation(matcher: string, args: readonly ts.Expression[]): Expectation | undefined;
 export declare function readPageExpectation(matcher: string, args: readonly ts.Expression[]): PageExpectation | undefined;

package/dist/steps/parse/expectation.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { stringOf } from "./literals.js";
 const TEXT_MATCHERS = ["toHaveText", "toContainText", "toHaveValue"];
-/** `env.NAME`, `env["NAME"]`, `secrets.NAME`, `secrets["NAME"]` or a string literal */
+/** `env.NAME`, `secrets.NAME`, `inputs.NAME` (or `env["NAME"]` and so on) or a string literal */
 export function readValue(node) {
     if (!node)
         return undefined;
@@ -26,25 +26,31 @@ export function readValue(node) {
         return { kind: "env", name };
     if (object.text === "secrets")
         return { kind: "secret", name };
+    if (object.text === "inputs")
+        return { kind: "input", name };
     return undefined;
 }
+/** `/source/flags` */
+export function readRegex(node) {
+    if (!node || !ts.isRegularExpressionLiteral(node))
+        return undefined;
+    const end = node.text.lastIndexOf("/");
+    return { source: node.text.slice(1, end), flags: node.text.slice(end + 1) };
+}
 function readTextMatcher(node) {
     if (!node)
         return undefined;
     const literal = stringOf(node);
     if (literal !== undefined)
         return literal;
-    if (ts.isRegularExpressionLiteral(node)) {
-        const end = node.text.lastIndexOf("/");
-        return {
-            regex: {
-                source: node.text.slice(1, end),
-                flags: node.text.slice(end + 1),
-            },
-        };
-    }
-    return undefined;
+    const regex = readRegex(node);
+    return regex && { regex };
 }
+/** The matchers that take `{ output }` as their last argument */
+export const OUTPUT_MATCHERS = [
+    ...TEXT_MATCHERS,
+    "toHaveAttribute",
+];
 export function readExpectation(matcher, args) {
     if (matcher === "toBeVisible" ||
         matcher === "toBeHidden" ||

package/dist/steps/parse/step.js

@@ -1,8 +1,58 @@
 import ts from "typescript";
 import { readLocator } from "./call.js";
-import { readExpectation, readPageExpectation, readValue, } from "./expectation.js";
+import { OUTPUT_MATCHERS, readExpectation, readPageExpectation, readRegex, readValue, } from "./expectation.js";
 import { readFiles } from "./file-entry.js";
 import { readObject, stringOf } from "./literals.js";
+/**
+ * The name in a trailing `{ output: "name" }`: undefined without one, null when the argument is there but
+ * isn't exactly that
+ */
+function outputOf(node) {
+    if (!node)
+        return undefined;
+    const output = readObject(node, ["output"])?.output;
+    return typeof output === "string" ? output : null;
+}
+/** `outputs.save("name", locator)` or `outputs.save("name", locator, /pattern/)` */
+function readSaveOutput(args) {
+    const name = stringOf(args[0]);
+    const locator = args[1] && readLocator(args[1]);
+    const pattern = readRegex(args[2]);
+    if (name === undefined ||
+        !locator ||
+        args.length > 3 ||
+        (args.length === 3 && !pattern))
+        return undefined;
+    return {
+        kind: "saveOutput",
+        name,
+        locator,
+        ...(pattern && { pattern }),
+    };
+}
+/** `expect(locator)…matcher(…)`, with a trailing `{ output }` only on the matchers that take one and never with `not` */
+function readLocatorExpect(subject, negated, matcher, args) {
+    const locator = readLocator(subject);
+    if (!locator)
+        return undefined;
+    const last = args[args.length - 1];
+    const takesOutput = OUTPUT_MATCHERS.includes(matcher) &&
+        !!last &&
+        ts.isObjectLiteralExpression(last);
+    const output = takesOutput ? outputOf(last) : undefined;
+    if (output === null || (output !== undefined && negated))
+        return undefined;
+    const expectation = readExpectation(matcher, takesOutput ? args.slice(0, -1) : args);
+    return expectation
+        ? {
+            kind: "expect",
+            locator,
+            not: negated,
+            expectation,
+            ...(output !== undefined && { output }),
+        }
+        : undefined;
+}
 /** The step a statement stands for, or undefined when it is outside the recorder's set */
 export function readStep(statement) {
     if (!ts.isExpressionStatement(statement) ||
@@ -58,12 +108,10 @@ export function readStep(statement) {
                 ? { kind: "expectPage", not: negated, expectation }
                 : undefined;
         }
-        const locator = readLocator(arg);
-        const expectation = readExpectation(name.text, args);
-        return locator && expectation
-            ? { kind: "expect", locator, not: negated, expectation }
-            : undefined;
+        return readLocatorExpect(arg, negated, name.text, args);
     }
+    if (ts.isIdentifier(target) && target.text === "outputs")
+        return name.text === "save" ? readSaveOutput(args) : undefined;
     const locator = readLocator(target);
     if (!locator)
         return undefined;
@@ -73,9 +121,17 @@ export function readStep(statement) {
         const key = stringOf(args[0]);
         return key === undefined ? undefined : { kind: "press", locator, key };
     }
-    if (name.text === "fill" && args.length === 1) {
+    if (name.text === "fill" && (args.length === 1 || args.length === 2)) {
         const value = readValue(args[0]);
-        return value ? { kind: "fill", locator, value } : undefined;
+        const output = outputOf(args[1]);
+        return value && output !== null
+            ? {
+                kind: "fill",
+                locator,
+                value,
+                ...(output !== undefined && { output }),
+            }
+            : undefined;
     }
     if ((name.text === "setInputFiles" || name.text === "dropFiles") &&
         args.length === 1) {

package/dist/steps/parse.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
-import { readObject, stringOf } from "./parse/literals.js";
+import { stringOf } from "./parse/literals.js";
 import { readStep } from "./parse/step.js";
+import { readTestOptions } from "./test-options.js";
 function parseStatement(source, statement, sourceFile) {
     const start = statement.getStart(sourceFile);
     const end = statement.end;
@@ -58,21 +59,19 @@ function calleeOf(expression) {
     return undefined;
 }
 /**
- * The callback of `test(title, fn)` and `describe(title, fn)`, and for a skip or fixme also of
- * `(title, { reason }, fn)` with the reason when it is a literal
+ * The callback of `test(title, fn)` and `describe(title, fn)`, and of `(title, options, fn)` with what the
+ * options say and where they sit. Undefined when the options object isn't one the codec can read
  */
-function callbackOf(node, modifier) {
+function argumentsOf(node, kind, modifier) {
     const [, second, third] = node.arguments;
-    if ((modifier === "skip" || modifier === "fixme") &&
-        second &&
-        ts.isObjectLiteralExpression(second)) {
-        const reason = readObject(second, ["reason"])?.reason;
-        return {
-            callback: third,
-            ...(typeof reason === "string" && { reason }),
-        };
-    }
-    return { callback: second };
+    if (node.arguments.length < 3)
+        return { callback: second };
+    const options = readTestOptions(second, kind, modifier);
+    return (options && {
+        callback: third,
+        options,
+        range: { start: second.getStart(), end: second.end },
+    });
 }
 /** What the runner applies to a test (see `modifierOf` in the runner): the innermost `skip` or `fixme` with its reason, else `only` */
 function effectiveMark(own, describes) {
@@ -128,12 +127,18 @@ export function parseSpecFile(source) {
             !(callee.name === "test" && isConditionForm(node, callee))) {
             const kind = callee.name;
             const title = stringOf(node.arguments[0]);
-            const { callback, reason } = callbackOf(node, callee.modifier);
-            const body = callbackBody(callback);
             if (title === undefined) {
                 unparsed.push(unreadable(node, kind, "dynamic-title"));
                 return;
             }
+            const args = argumentsOf(node, kind, callee.modifier);
+            if (!args) {
+                unparsed.push(unreadable(node, kind, "dynamic-options"));
+                return;
+            }
+            const { callback, options = {}, range } = args;
+            const { reason, inputs, outputs } = options;
+            const body = callbackBody(callback);
             if (!body) {
                 unparsed.push(unreadable(node, kind, "not-inline"));
                 return;
@@ -154,6 +159,10 @@ export function parseSpecFile(source) {
                     removable: isRemovable(node),
                     fixtures: callbackFixtures(callback, sourceFile),
                     ...effectiveMark(mark, describes),
+                    ...(inputs && { inputs }),
+                    ...(outputs && { outputs }),
+                    ...(range && { options: range }),
+                    titleEnd: node.arguments[0].end,
                 });
                 return;
             }

package/dist/steps/test-options.d.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import type { Modifier } from "../types/test.js";
+import type { ParsedTest, TestInput } from "./model.js";
+/** What a `test()` or `describe()` options object says, as far as the codec reads it */
+export interface TestOptionsRead {
+    reason?: string;
+    inputs?: TestInput[];
+    outputs?: string[];
+}
+type ListKey = "inputs" | "outputs";
+/**
+ * The options object of a test or describe call: a describe takes only `reason`, a test also `inputs` and
+ * `outputs`. Undefined when the object isn't a literal the codec can read, so the call is left unparsed. An
+ * empty list is left out, as the runtime leaves it out. A `reason` counts only for skip and fixme, and one that
+ * isn't a string literal is passed over, as before
+ */
+export declare function readTestOptions(node: ts.Expression, kind: "test" | "describe", modifier: Modifier | undefined): TestOptionsRead | undefined;
+/**
+ * Sets one list of the test's options object: replaces it, adds it (making the object when there is none) or,
+ * for an empty list, removes it, and the whole object when nothing but empty lists would be left. The rest of
+ * the object, its layout and a `reason`, stays as it is; an unchanged list leaves the source as it is. Throws for
+ * names the runtime rejects, before writing
+ */
+export declare function declareList(source: string, parsed: ParsedTest, key: ListKey, list: TestInput[] | string[]): string;
+export {};

package/dist/steps/test-options.js

@@ -0,0 +1,158 @@
+import ts from "typescript";
+import { isIoName } from "../flows/core/steps.js";
+import { IDENTIFIER } from "./emit.js";
+import { stringOf } from "./parse/literals.js";
+import { indentOf, splice } from "./text.js";
+function keyOf(name) {
+    return ts.isIdentifier(name) || ts.isStringLiteral(name)
+        ? name.text
+        : undefined;
+}
+/** `{ name: "default", … }`; undefined for anything but string literals under plain keys */
+function readInputs(node) {
+    if (!ts.isObjectLiteralExpression(node))
+        return undefined;
+    const inputs = [];
+    for (const property of node.properties) {
+        if (!ts.isPropertyAssignment(property))
+            return undefined;
+        const name = keyOf(property.name);
+        const value = stringOf(property.initializer);
+        if (name === undefined || value === undefined)
+            return undefined;
+        inputs.push({ name, default: value });
+    }
+    return inputs;
+}
+/** `["name", …]`; undefined for anything but string literals */
+function readOutputs(node) {
+    if (!ts.isArrayLiteralExpression(node))
+        return undefined;
+    const names = node.elements.map(stringOf);
+    return names.every((name) => name !== undefined)
+        ? names
+        : undefined;
+}
+/**
+ * The options object of a test or describe call: a describe takes only `reason`, a test also `inputs` and
+ * `outputs`. Undefined when the object isn't a literal the codec can read, so the call is left unparsed. An
+ * empty list is left out, as the runtime leaves it out. A `reason` counts only for skip and fixme, and one that
+ * isn't a string literal is passed over, as before
+ */
+export function readTestOptions(node, kind, modifier) {
+    if (!ts.isObjectLiteralExpression(node))
+        return undefined;
+    const read = {};
+    for (const property of node.properties) {
+        if (!ts.isPropertyAssignment(property))
+            return undefined;
+        const key = keyOf(property.name);
+        const value = property.initializer;
+        if (key === "reason") {
+            const reason = stringOf(value);
+            if (reason !== undefined && (modifier === "skip" || modifier === "fixme"))
+                read.reason = reason;
+        }
+        else if (kind === "test" && key === "inputs") {
+            const inputs = readInputs(value);
+            if (!inputs)
+                return undefined;
+            if (inputs.length > 0)
+                read.inputs = inputs;
+        }
+        else if (kind === "test" && key === "outputs") {
+            const outputs = readOutputs(value);
+            if (!outputs)
+                return undefined;
+            if (outputs.length > 0)
+                read.outputs = outputs;
+        }
+        else
+            return undefined;
+    }
+    return read;
+}
+const str = (value) => JSON.stringify(value);
+function listToSource(key, list) {
+    if (key === "outputs")
+        return `[${list.map(str).join(", ")}]`;
+    const entries = list.map(({ name, default: value }) => `${IDENTIFIER.test(name) ? name : str(name)}: ${str(value)}`);
+    return `{ ${entries.join(", ")} }`;
+}
+const sameList = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** Throws for a list the runtime's `test()` would reject: a name that isn't valid, a name twice, a default that isn't text */
+function checkList(key, list) {
+    const kind = key === "inputs" ? "input" : "output";
+    const seen = new Set();
+    for (const entry of list) {
+        const name = typeof entry === "string" ? entry : entry.name;
+        if (!isIoName(name))
+            throw new Error(`applyEdit(): ${kind} ${JSON.stringify(name)} is not a valid name`);
+        if (seen.has(name))
+            throw new Error(`applyEdit(): ${kind} "${name}" is listed twice`);
+        seen.add(name);
+        if (typeof entry !== "string" && typeof entry.default !== "string")
+            throw new Error(`applyEdit(): input "${name}" needs a string default`);
+    }
+}
+/** The options object at `range`, parsed on its own, with offsets mapped back into the source */
+function optionsObject(source, range) {
+    const file = ts.createSourceFile("options.ts", `(${source.slice(range.start, range.end)})`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const statement = file.statements[0];
+    const object = statement.expression
+        .expression;
+    const at = (offset) => offset - 1 + range.start;
+    return object.properties.map((property) => {
+        const assignment = property;
+        return {
+            key: keyOf(assignment.name),
+            start: at(assignment.getStart(file)),
+            end: at(assignment.end),
+            valueStart: at(assignment.initializer.getStart(file)),
+            emptyList: (ts.isObjectLiteralExpression(assignment.initializer) &&
+                assignment.initializer.properties.length === 0) ||
+                (ts.isArrayLiteralExpression(assignment.initializer) &&
+                    assignment.initializer.elements.length === 0),
+        };
+    });
+}
+/**
+ * Sets one list of the test's options object: replaces it, adds it (making the object when there is none) or,
+ * for an empty list, removes it, and the whole object when nothing but empty lists would be left. The rest of
+ * the object, its layout and a `reason`, stays as it is; an unchanged list leaves the source as it is. Throws for
+ * names the runtime rejects, before writing
+ */
+export function declareList(source, parsed, key, list) {
+    checkList(key, list);
+    if (list.length > 0 && sameList(parsed[key], list))
+        return source;
+    const text = `${key}: ${listToSource(key, list)}`;
+    if (!parsed.options)
+        return list.length === 0
+            ? source
+            : splice(source, parsed.titleEnd, parsed.titleEnd, `, { ${text} }`);
+    const properties = optionsObject(source, parsed.options);
+    const index = properties.findIndex((property) => property.key === key);
+    const property = properties[index];
+    if (list.length === 0) {
+        // An empty list that is there still goes (the parse leaves it out), so an object of only empty lists is removed
+        if (!property)
+            return source;
+        const others = properties.filter((_, i) => i !== index);
+        if (others.every((other) => other.emptyList))
+            return splice(source, parsed.titleEnd, parsed.options.end, "");
+        return index > 0
+            ? splice(source, properties[index - 1].end, property.end, "")
+            : splice(source, property.start, properties[1].start, "");
+    }
+    if (property)
+        return splice(source, property.valueStart, property.end, listToSource(key, list));
+    const last = properties[properties.length - 1];
+    if (!last)
+        return splice(source, parsed.options.start, parsed.options.end, `{ ${text} }`);
+    const multiline = source
+        .slice(parsed.options.start, properties[0].start)
+        .includes("\n");
+    const separator = multiline ? `\n${indentOf(source, last.start)}` : " ";
+    return splice(source, last.end, last.end, `,${separator}${text}`);
+}

package/dist/steps/text.d.ts

@@ -0,0 +1,7 @@
+/** Offset of the first character of the line `offset` is on */
+export declare const lineStart: (source: string, offset: number) => number;
+/** Offset just after the newline that ends the line `offset` is on, or the end of the source */
+export declare function lineEnd(source: string, offset: number): number;
+/** The spaces and tabs that start the line `offset` is on */
+export declare const indentOf: (source: string, offset: number) => string;
+export declare function splice(source: string, from: number, to: number, text: string): string;

package/dist/steps/text.js

@@ -0,0 +1,12 @@
+/** Offset of the first character of the line `offset` is on */
+export const lineStart = (source, offset) => source.lastIndexOf("\n", offset - 1) + 1;
+/** Offset just after the newline that ends the line `offset` is on, or the end of the source */
+export function lineEnd(source, offset) {
+    const newline = source.indexOf("\n", offset);
+    return newline === -1 ? source.length : newline + 1;
+}
+/** The spaces and tabs that start the line `offset` is on */
+export const indentOf = (source, offset) => /^[ \t]*/.exec(source.slice(lineStart(source, offset)))[0];
+export function splice(source, from, to, text) {
+    return source.slice(0, from) + text + source.slice(to);
+}

package/dist/types/test.d.ts

@@ -1,5 +1,6 @@
 import type { Browser } from "../browser/browser.js";
 import type Page from "../browser/page.js";
+import type Locator from "../locator/locator.js";
 import type { SupportedBrowser } from "./browser.js";
 
 /** What a test function receives */
@@ -14,6 +15,19 @@ export interface TestFixtures {
   env: Readonly<Record<string, string | number | boolean>>;
   /** Secrets by name (SAMURAI_SECRET_<NAME>); reading an unset name throws */
   secrets: Readonly<Record<string, string>>;
+  /** The inputs the test declared: the value the run supplies, else the default; reading another name throws */
+  inputs: Readonly<Record<string, string>>;
+  /** Saves the text values the test declared as outputs */
+  outputs: TestOutputs;
+}
+
+/** The `outputs` fixture */
+export interface TestOutputs {
+  /**
+   * Waits up to the expect timeout for the element to have text and saves its trimmed text as output `name`.
+   * With `pattern`, waits until the text matches and saves the first capture group, else the whole match.
+   */
+  save(name: string, locator: Locator, pattern?: RegExp): Promise<void>;
 }
 
 export type TestCase = TestCaseBase;
@@ -27,6 +41,14 @@ export interface TestDetails {
   reason?: string;
 }
 
+/** The optional second argument of `test`, `test.only`, `test.skip` and `test.fixme` */
+export interface TestOptions extends TestDetails {
+  /** Named text values the test reads, each with the default it gets when nothing supplies one */
+  inputs?: Record<string, string>;
+  /** Names of the text values the test saves for later tests to use */
+  outputs?: string[];
+}
+
 /** Runs before or after each test of a suite, in the test's browser, with the test's fixtures */
 export type EachHook = (fixtures: TestFixtures) => Promise<void> | void;
 
@@ -64,6 +86,10 @@ export interface RegisteredTestCase extends TestCaseBase {
   modifier?: Modifier;
   /** The reason given with the `skip` or `fixme` that applies */
   reason?: string;
+  /** The inputs the test declared, with their defaults */
+  inputs?: Record<string, string>;
+  /** The names of the outputs the test declared */
+  outputs?: string[];
 }
 
 export interface TestCaseBase {
@@ -88,6 +114,10 @@ interface TestResultSuccess extends TestResultIdentity, TestRetries {
   logsDropped?: number;
   /** Named screenshots the test saved, relative to the result folder */
   screenshots?: { name: string; path: string }[];
+  /** The inputs the test declared, with the values this attempt read; absent when it declares none */
+  inputs?: Record<string, string>;
+  /** The outputs the test saved; absent when it declares none */
+  outputs?: Record<string, string>;
 }
 
 /** The error sits flat on the entry, as in the report: `message`, `type`, `stack`, and for assertions `expected` and `actual` */
@@ -98,6 +128,10 @@ interface TestResultFailed extends TestResultIdentity, TestError, TestRetries {
   logsDropped?: number;
   /** Named screenshots the test saved, relative to the result folder */
   screenshots?: { name: string; path: string }[];
+  /** The inputs the test declared, with the values this attempt read; absent when it declares none */
+  inputs?: Record<string, string>;
+  /** The outputs the test saved; absent when it declares none */
+  outputs?: Record<string, string>;
 }
 
 /** What a result says about the retries of its test; absent when it passed or failed on the first attempt */

package/dist/wait/output-sink.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where one attempt of a test keeps the outputs it saves. Once closed it ignores what still arrives, so a
+ * capture that outlives its test (it timed out, or nobody awaited it) never lands in the next one.
+ */
+export interface OutputSink {
+    /** Whether the test declared `name` */
+    declares(name: string): boolean;
+    /** Keeps `value` under `name`; throws for a name the test did not declare, ignores it once closed */
+    set(name: string, value: string): void;
+    /** What was saved so far */
+    values(): Record<string, string>;
+}
+/** Opens the sink of an attempt that declared `declared`, closing any one still open */
+export declare function beginOutputs(declared: readonly string[]): OutputSink;
+/** The open sink, or none outside a test. A capture takes it when it starts and saves into that one */
+export declare function currentOutputSink(): OutputSink | undefined;
+/** Closes the open sink and returns what it holds */
+export declare function endOutputs(): Record<string, string>;
+/**
+ * Takes the open sink for a capture that starts now (`method` names the call in the errors) and returns the
+ * function that saves `value` under `name` into it. The sink is bound here: a value that arrives after the test
+ * ended goes to its own closed sink and is ignored.
+ */
+export declare function bindOutput(method: string, name: string): (value: string) => void;