e2e 0.15.2 → 0.16.0

package/dist/expect/async.js

@@ -1,14 +1,25 @@
 /** Runner-owned polling locator assertions. */
 import { TestError } from '../internal/errors.js';
-import { isTextMatch, normalizeText, compareText, matchesText, toTextPattern, describePattern, } from '../internal/text.js';
+import { rejectUnknownOptions } from '../internal/options.js';
+import { isTextMatch, normalizeText, compareText, toTextPattern, describePattern, withIgnoreCase, } from '../internal/text.js';
 import { isValueControl } from '../internal/roles.js';
 import { Deadline, pollCondition } from '../internal/time.js';
 import { attributeOf, denySecureRead, isNodeVisible } from '../locator/engine.js';
 import { describeExpression } from '../locator/expression.js';
 const STATE_MATCHERS = {
-    toBeEnabled: { key: 'disabled', expected: false, describeExpected: 'enabled' },
+    toBeEnabled: {
+        key: 'disabled',
+        expected: false,
+        describeExpected: 'enabled',
+        flag: { option: 'enabled', describeExpected: 'disabled' },
+    },
     toBeDisabled: { key: 'disabled', expected: true, describeExpected: 'disabled' },
-    toBeChecked: { key: 'checked', expected: true, describeExpected: 'checked' },
+    toBeChecked: {
+        key: 'checked',
+        expected: true,
+        describeExpected: 'checked',
+        flag: { option: 'checked', describeExpected: 'unchecked' },
+    },
     toBeSelected: { key: 'selected', expected: true, describeExpected: 'selected' },
     toBeExpanded: { key: 'expanded', expected: true, describeExpected: 'expanded' },
     toBeFocused: { key: 'focused', expected: true, describeExpected: 'focused' },
@@ -19,24 +30,28 @@ const TEXT_MATCHERS = {
         mode: 'equals',
         normalize: true,
         describeExpected: (pattern) => `text ${pattern}`,
+        takesIgnoreCase: true,
     },
     toContainText: {
         field: 'text',
         mode: 'contains',
         normalize: true,
         describeExpected: (pattern) => `text containing ${pattern}`,
+        takesIgnoreCase: true,
     },
     toHaveValue: {
         field: 'value',
         mode: 'equals',
         normalize: false,
         describeExpected: (pattern) => `value ${pattern}`,
+        takesIgnoreCase: false,
     },
     toHaveAccessibleName: {
         field: 'name',
         mode: 'equals',
         normalize: true,
         describeExpected: (pattern) => `accessible name ${pattern}`,
+        takesIgnoreCase: true,
     },
 };
 class AsyncExpectationImpl {
@@ -52,9 +67,28 @@ class AsyncExpectationImpl {
     get label() {
         return describeExpression(this.internals.expression);
     }
+    /** The matcher's name as its step and its errors print it: `expect.not.toBeChecked`. */
+    api(name) {
+        return `expect.${this.negated ? 'not.' : ''}${name}`;
+    }
+    /**
+     * Refuses an option `name` does not take before anything is read: a
+     * JavaScript caller's Playwright option must fail, not run as if absent.
+     * Returns the boolean `flag` option, `undefined` when absent.
+     */
+    readOptions(name, options, flag) {
+        const api = this.api(name);
+        rejectUnknownOptions(api, options, flag === undefined ? ['timeout'] : [flag, 'timeout']);
+        if (flag === undefined || options === undefined)
+            return undefined;
+        const value = Reflect.get(options, flag);
+        if (value === undefined || typeof value === 'boolean')
+            return value;
+        throw new TestError('INVALID_ARGUMENT', `${api} option ${flag} must be a boolean`);
+    }
     async poll(spec, timeout) {
         const { engine } = this.internals.context;
-        const api = `expect.${this.negated ? 'not.' : ''}${spec.name}`;
+        const api = this.api(spec.name);
         await this.internals.context.steps.run('assertion', api, this.label, async () => {
             const deadline = engine.deadline(timeout ?? engine.assertionTimeout);
             let lastSample = { count: 0, node: null, nodes: [] };
@@ -113,29 +147,44 @@ class AsyncExpectationImpl {
         const { node, count } = await engine.tryRead(this.internals.expression, deadline);
         return { count, node, nodes: [] };
     }
-    stateMatcher(name, timeout) {
+    /** A state matcher; its Playwright flag set to `false` expects the opposite state. */
+    stateMatcher(name, options) {
         const def = STATE_MATCHERS[name];
+        const holds = this.readOptions(name, options, def.flag?.option) ?? true;
+        const expected = holds ? def.expected : !def.expected;
         return this.poll({
             name,
-            predicate: (sample) => sample.node !== null && (sample.node.states?.[def.key] === true) === def.expected,
-            describeExpected: def.describeExpected,
+            predicate: (sample) => sample.node !== null && (sample.node.states?.[def.key] === true) === expected,
+            describeExpected: holds || def.flag === undefined ? def.describeExpected : def.flag.describeExpected,
             observed: observedState,
+        }, options?.timeout);
+    }
+    /** `toBeVisible` and `toBeHidden`: not visible means hidden or absent. */
+    visibilityMatcher(name, visible, timeout) {
+        return this.poll({
+            name,
+            evaluableWithoutNode: true,
+            predicate: (sample) => isNodeVisible(sample.node) === visible,
+            describeExpected: visible ? 'visible' : 'hidden or absent',
+            observed: visible ? observedState : (sample) => (isNodeVisible(sample.node) ? 'visible' : 'hidden'),
         }, timeout);
     }
-    textMatcher(name, expected, timeout) {
-        if (isTextMatchList(expected))
-            return this.textListMatcher(name, expected, timeout);
+    textMatcher(name, expected, options) {
         const def = TEXT_MATCHERS[name];
-        const pattern = toTextPattern(expected, { exact: true });
+        const ignoreCase = this.readOptions(name, options, def.takesIgnoreCase ? 'ignoreCase' : undefined);
+        const comparison = { mode: def.mode, normalize: def.normalize, ignoreCase };
+        if (isTextMatchList(expected))
+            return this.textListMatcher(name, expected, comparison, options?.timeout);
+        const pattern = withIgnoreCase(toTextPattern(expected, { exact: true }), ignoreCase);
         return this.poll({
             name,
             readsWithheld: def.field !== 'name',
             evaluableNode: (node) => readField(def, node) !== undefined,
             predicate: (sample) => {
                 const actual = sample.node === null ? undefined : readField(def, sample.node);
-                return actual !== undefined && compareText(actual, pattern, def);
+                return actual !== undefined && compareText(actual, pattern, comparison);
             },
-            describeExpected: def.describeExpected(describePattern(pattern)),
+            describeExpected: def.describeExpected(describeText(pattern, ignoreCase)),
             observed: (sample) => {
                 if (sample.node === null)
                     return 'no node';
@@ -144,23 +193,23 @@ class AsyncExpectationImpl {
                     return `no ${def.field} (not a form control)`;
                 return `${def.field} ${printField(def, actual)}`;
             },
-        }, timeout);
+        }, options?.timeout);
     }
     /**
      * The list form. `toHaveText` needs exactly as many matches as entries,
      * each match satisfying the entry at its position; `toContainText` needs
      * each entry contained by a distinct match, in order, as Playwright's does.
      */
-    textListMatcher(name, expected, timeout) {
+    textListMatcher(name, expected, comparison, timeout) {
         const def = TEXT_MATCHERS[name];
-        const patterns = expected.map((entry) => toTextPattern(entry, { exact: true }));
+        const patterns = expected.map((entry) => withIgnoreCase(toTextPattern(entry, { exact: true }), comparison.ignoreCase));
         const printed = (node) => {
             const actual = readField(def, node);
             return actual === undefined ? `no ${def.field}` : printField(def, actual);
         };
         const satisfies = (node, pattern) => {
             const actual = readField(def, node);
-            return actual !== undefined && compareText(actual, pattern, def);
+            return actual !== undefined && compareText(actual, pattern, comparison);
         };
         const matchesList = def.mode === 'contains' ? matchesSubsequence : matchesPositionally;
         return this.poll({
@@ -168,75 +217,62 @@ class AsyncExpectationImpl {
             readsWithheld: def.field !== 'name',
             wholeSet: 'read',
             predicate: (sample) => matchesList(sample.nodes, patterns, satisfies),
-            describeExpected: def.describeExpected(`[${patterns.map(describePattern).join(', ')}]`),
+            describeExpected: def.describeExpected(`[${patterns.map((pattern) => describeText(pattern, comparison.ignoreCase)).join(', ')}]`),
             observed: (sample) => `${def.field} [${sample.nodes.map(printed).join(', ')}]`,
         }, timeout);
     }
     toBeVisible(options) {
-        return this.poll({
-            name: 'toBeVisible',
-            evaluableWithoutNode: true,
-            predicate: (sample) => isNodeVisible(sample.node),
-            describeExpected: 'visible',
-            observed: observedState,
-        }, options?.timeout);
+        const visible = this.readOptions('toBeVisible', options, 'visible') ?? true;
+        return this.visibilityMatcher('toBeVisible', visible, options?.timeout);
     }
     toBeHidden(options) {
-        return this.poll({
-            name: 'toBeHidden',
-            evaluableWithoutNode: true,
-            predicate: (sample) => !isNodeVisible(sample.node),
-            describeExpected: 'hidden or absent',
-            observed: (sample) => (isNodeVisible(sample.node) ? 'visible' : 'hidden'),
-        }, options?.timeout);
+        this.readOptions('toBeHidden', options);
+        return this.visibilityMatcher('toBeHidden', false, options?.timeout);
     }
     toBeAttached(options) {
+        const attached = this.readOptions('toBeAttached', options, 'attached') ?? true;
         return this.poll({
             name: 'toBeAttached',
             evaluableWithoutNode: true,
-            predicate: (sample) => sample.node !== null,
-            describeExpected: 'attached',
+            predicate: (sample) => (sample.node !== null) === attached,
+            describeExpected: attached ? 'attached' : 'detached',
             observed: (sample) => (sample.node === null ? 'no node' : 'attached'),
         }, options?.timeout);
     }
     toBeEnabled(options) {
-        return this.stateMatcher('toBeEnabled', options?.timeout);
+        return this.stateMatcher('toBeEnabled', options);
     }
     toBeDisabled(options) {
-        return this.stateMatcher('toBeDisabled', options?.timeout);
+        return this.stateMatcher('toBeDisabled', options);
     }
     toBeChecked(options) {
-        return this.stateMatcher('toBeChecked', options?.timeout);
+        return this.stateMatcher('toBeChecked', options);
     }
     toBeSelected(options) {
-        return this.stateMatcher('toBeSelected', options?.timeout);
+        return this.stateMatcher('toBeSelected', options);
     }
     toBeExpanded(options) {
-        return this.stateMatcher('toBeExpanded', options?.timeout);
+        return this.stateMatcher('toBeExpanded', options);
     }
     toBeFocused(options) {
-        return this.stateMatcher('toBeFocused', options?.timeout);
+        return this.stateMatcher('toBeFocused', options);
     }
     toHaveText(expected, options) {
-        return this.textMatcher('toHaveText', expected, options?.timeout);
+        return this.textMatcher('toHaveText', expected, options);
     }
     toContainText(expected, options) {
-        return this.textMatcher('toContainText', expected, options?.timeout);
+        return this.textMatcher('toContainText', expected, options);
     }
     toHaveValue(expected, options) {
-        return this.textMatcher('toHaveValue', expected, options?.timeout);
+        return this.textMatcher('toHaveValue', expected, options);
     }
     toHaveAttribute(name, valueOrOptions, options) {
-        let value;
-        let timeout;
-        if (isTextMatch(valueOrOptions)) {
-            value = valueOrOptions;
-            timeout = options?.timeout;
-        }
-        else {
-            timeout = valueOrOptions?.timeout;
-        }
-        const pattern = value === undefined ? undefined : toTextPattern(value, { exact: true });
+        const hasValue = isTextMatch(valueOrOptions);
+        // Presence reads the third argument too when the value is `undefined`, as Playwright does.
+        const bag = hasValue ? options : valueOrOptions === undefined ? options : valueOrOptions;
+        const ignoreCase = this.readOptions('toHaveAttribute', bag, hasValue ? 'ignoreCase' : undefined);
+        const pattern = hasValue ? withIgnoreCase(toTextPattern(valueOrOptions, { exact: true }), ignoreCase) : undefined;
+        const comparison = { mode: 'equals', normalize: true, ignoreCase };
         return this.poll({
             name: 'toHaveAttribute',
             readsWithheld: true,
@@ -244,11 +280,11 @@ class AsyncExpectationImpl {
                 if (sample.node === null)
                     return false;
                 const attribute = attributeOf(sample.node, name);
-                return attribute !== null && (pattern === undefined || matchesText(attribute, pattern));
+                return attribute !== null && (pattern === undefined || compareText(attribute, pattern, comparison));
             },
             describeExpected: pattern === undefined
                 ? `attribute "${name}"`
-                : `attribute "${name}" ${describePattern(pattern)}`,
+                : `attribute "${name}" ${describeText(pattern, ignoreCase)}`,
             observed: (sample) => {
                 if (sample.node === null)
                     return 'no node';
@@ -257,12 +293,13 @@ class AsyncExpectationImpl {
                     ? `attribute "${name}" absent`
                     : `attribute "${name}" ${JSON.stringify(attribute)}`;
             },
-        }, timeout);
+        }, bag?.timeout);
     }
     toHaveAccessibleName(expected, options) {
-        return this.textMatcher('toHaveAccessibleName', expected, options?.timeout);
+        return this.textMatcher('toHaveAccessibleName', expected, options);
     }
     toHaveCount(expected, options) {
+        this.readOptions('toHaveCount', options);
         return this.poll({
             name: 'toHaveCount',
             wholeSet: true,
@@ -310,6 +347,11 @@ function readField(def, node) {
         return '';
     return isValueControl(node) ? '' : undefined;
 }
+/** A pattern as a failure message prints it, marking a string compared ignoring case. */
+function describeText(pattern, ignoreCase) {
+    const described = describePattern(pattern);
+    return pattern.kind === 'string' && ignoreCase === true ? `${described} (ignoring case)` : described;
+}
 /** The field as the failure message prints it: normalized when the comparison was, so the message shows what got compared. */
 function printField(def, actual) {
     return JSON.stringify(def.normalize ? normalizeText(actual) : actual);
@@ -326,4 +368,3 @@ function observedState(sample) {
 export function createAsyncExpectation(internals) {
     return new AsyncExpectationImpl(internals, false);
 }
-//# sourceMappingURL=async.js.map

package/dist/expect/attempt.d.ts

@@ -16,4 +16,3 @@ export interface PublishedAttempt {
 export declare function publishAttempt(context: PublishedAttempt, until: AbortSignal): void;
 /** The attempt a poll runs inside, or undefined in a standalone script. */
 export declare function currentAttempt(): PublishedAttempt | undefined;
-//# sourceMappingURL=attempt.d.ts.map

package/dist/expect/attempt.js

@@ -30,4 +30,3 @@ export function publishAttempt(context, until) {
 export function currentAttempt() {
     return slot.get(globalThis);
 }
-//# sourceMappingURL=attempt.js.map

package/dist/expect/index.d.ts

@@ -7,4 +7,3 @@ import type { Expect } from '../types.ts';
  * end of the body instead of throwing it.
  */
 export declare const expect: Expect;
-//# sourceMappingURL=index.d.ts.map

package/dist/expect/index.js

@@ -43,4 +43,3 @@ export const expect = Object.assign(dispatch, {
     stringContaining: (sample) => new StringContaining(sample),
     stringMatching: (sample) => new StringMatching(sample),
 });
-//# sourceMappingURL=index.js.map

package/dist/expect/poll.d.ts

@@ -2,4 +2,3 @@
 import type { PollExpectation, PollOptions } from '../types.ts';
 /** Re-reads `read` until the chosen value matcher holds or `options.timeout` passes. */
 export declare function createPollExpectation<T>(read: () => T | Promise<T>, options?: PollOptions): PollExpectation<T>;
-//# sourceMappingURL=poll.d.ts.map

package/dist/expect/poll.js

@@ -121,4 +121,3 @@ export function createPollExpectation(read, options = {}) {
     checkOptions(options);
     return build(read, options, false);
 }
-//# sourceMappingURL=poll.js.map

package/dist/expect/soft.d.ts

@@ -28,4 +28,3 @@ export declare class SoftFailures {
  * attached matchers all go through the one wrapper.
  */
 export declare function soften<E extends object>(expectation: E): E;
-//# sourceMappingURL=soft.d.ts.map

package/dist/expect/soft.js

@@ -85,4 +85,3 @@ export function soften(expectation) {
         },
     });
 }
-//# sourceMappingURL=soft.js.map

package/dist/expect/values.d.ts

@@ -1,4 +1,3 @@
 /** Synchronous plain-value matchers. */
 import type { ValueExpectation } from '../types.ts';
 export declare function createValueExpectation<T>(actual: T, message?: string): ValueExpectation<T>;
-//# sourceMappingURL=values.d.ts.map

package/dist/expect/values.js

@@ -221,4 +221,3 @@ function lookup(value, keys) {
 export function createValueExpectation(actual, message) {
     return new ValueExpectationImpl(actual, false, message);
 }
-//# sourceMappingURL=values.js.map

package/dist/explore/body.d.ts

@@ -37,4 +37,3 @@ export interface ExploreBodyOptions {
 }
 /** Builds the test body for one exploration. */
 export declare function createExploreBody(options: ExploreBodyOptions): TestFn;
-//# sourceMappingURL=body.d.ts.map

package/dist/explore/body.js

@@ -178,4 +178,3 @@ function conclude(state) {
         throw new AgentError(code !== undefined && BLOCKABLE_CODES.has(code) ? code : 'AUTOMATION_UNSUPPORTED', `exploration could not complete a charter: ${first.summary ?? first.title}`, { blocked: true });
     }
 }
-//# sourceMappingURL=body.js.map

package/dist/explore/executor.d.ts

@@ -31,4 +31,3 @@ export interface ExplorerOptions {
 export declare function explorerAgent(options: ExplorerOptions): AgentConfig;
 /** The resolved explorer with the finding tool beside the project's tools. */
 export declare function withFindingTool(explorer: ResolvedAgentConfig, state: ExploreState): ResolvedAgentConfig;
-//# sourceMappingURL=executor.d.ts.map

package/dist/explore/executor.js

@@ -98,4 +98,3 @@ function createFindingTool(state) {
         },
     }, { mutates: false });
 }
-//# sourceMappingURL=executor.js.map

package/dist/explore/index.d.ts

@@ -76,4 +76,3 @@ export interface ExploreOutcome extends RunOutcome {
  * as a bad flag is.
  */
 export declare function explore(options?: ExploreOptions): Promise<ExploreOutcome>;
-//# sourceMappingURL=index.d.ts.map

package/dist/explore/index.js

@@ -15,6 +15,7 @@ import { resolveConfig } from '../config/resolve.js';
 import { ConfigurationError } from '../internal/errors.js';
 import { labelSegment } from '../run/artifacts.js';
 import { run } from '../run/runner.js';
+import { staticSecretLedger } from '../run/secrecy.js';
 import { createExploreBody } from './body.js';
 import { explorerAgent, withFindingTool } from './executor.js';
 import { signedInContext } from './plan.js';
@@ -66,7 +67,7 @@ export async function explore(options = {}) {
     const agentName = resolved.agentNames[0];
     if (agentName !== 'default')
         notice(`exploring with agent "${agentName}"`);
-    const state = new ExploreState(goal, budgets);
+    const state = new ExploreState(redactGoal(goal, resolved.allSecrets), budgets);
     const explorer = explorerAgent({ state, agentName, entry: raw.agents?.[agentName], resolved: resolved.agent, notice });
     const resolvedExplorer = resolveAgentConfig(exploreAgentConfig(explorer), `agents.${agentName}`);
     // Every exploration step calls the model, a custom executor's included,
@@ -121,6 +122,20 @@ function resolveGoal(goal) {
     }
     return trimmed;
 }
+/**
+ * The goal with every static secret value it spells out redacted. The goal
+ * becomes the test's title, its artifact directory, the report's goal, and
+ * model input, so it is redacted once, here, as a test file's titles are at
+ * collection. A marker can be longer than the value it replaces, so the
+ * ceiling is checked again on what the run will keep.
+ */
+function redactGoal(goal, secrets) {
+    const redacted = staticSecretLedger(secrets).redact(goal);
+    if (redacted.length > MAX_GOAL_CHARS) {
+        throw new ConfigurationError('INVALID_CONFIG', `the goal must be at most ${MAX_GOAL_CHARS} characters with its secret values redacted, got ${redacted.length}`);
+    }
+    return redacted;
+}
 function resolveBounded(value, bounds, label) {
     if (value === undefined)
         return bounds.default;
@@ -204,4 +219,3 @@ function exploreRegistration(state, start) {
     };
     return { tests: [test], hooks: [] };
 }
-//# sourceMappingURL=index.js.map

package/dist/explore/plan.d.ts

@@ -79,4 +79,3 @@ export declare function repairPlan(answer: PlanAnswer): PlanDecision;
 /** The planner's instruction: the goal, the record so far, the budget, and how to decide. */
 export declare function planInstruction(state: ExploreState, request: PlanRequest): string;
 export {};
-//# sourceMappingURL=plan.d.ts.map

package/dist/explore/plan.js

@@ -173,4 +173,3 @@ export function planInstruction(state, request) {
         'Respond with every field present: {"decision": "step", "title": "...", "instruction": "...", "summary": ""} or {"decision": "finish", "title": "", "instruction": "", "summary": "..."}.',
     ].join('\n');
 }
-//# sourceMappingURL=plan.js.map

package/dist/explore/progress.d.ts

@@ -40,4 +40,3 @@ export type ExploreProgress =
     readonly summary?: string | undefined;
 };
 export type ExploreListener = (progress: ExploreProgress) => void;
-//# sourceMappingURL=progress.d.ts.map

package/dist/explore/progress.js

@@ -6,4 +6,3 @@
  * report is the record; these are its moments.
  */
 export {};
-//# sourceMappingURL=progress.js.map

package/dist/explore/state.d.ts

@@ -56,4 +56,3 @@ export declare class ExploreState {
  * splits a surrogate pair.
  */
 export declare function clip(text: string, max: number): string;
-//# sourceMappingURL=state.d.ts.map

package/dist/explore/state.js

@@ -161,4 +161,3 @@ export function clip(text, max) {
     const points = Array.from(trimmed);
     return points.length <= max ? trimmed : `${points.slice(0, max - 1).join('')}…`;
 }
-//# sourceMappingURL=state.js.map

package/dist/index.d.ts

@@ -11,4 +11,3 @@ export type { ExecutorActions, ExecutorAttempt, ExecutorBudgets, ExecutorModelCa
 export type { StepTurn, VisionDegradation } from './run/steps.ts';
 export type { RunEvent, RunEventOf, RunExitCode, RunStatus } from './run/events.ts';
 export type { EngineAppDeclaration } from './engine/index.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -7,4 +7,3 @@ export { AgentError, isAgentError } from './agent/error.js';
 // The markdown page the `markdown` reporter writes, for a reporter that posts
 // it elsewhere: @e2e-dev/github renders the pull request comment from it.
 export { renderMarkdownReport } from './report/markdown.js';
-//# sourceMappingURL=index.js.map

package/dist/internal/ai-trace.d.ts

@@ -146,4 +146,3 @@ export declare class AiTraceCollector {
 }
 /** JSON with binary views omitted; arbitrary strings and raw tool JSON are preserved. */
 export declare function stringify(value: unknown): string;
-//# sourceMappingURL=ai-trace.d.ts.map

package/dist/internal/ai-trace.js

@@ -431,4 +431,3 @@ export function stringify(value) {
         return current;
     });
 }
-//# sourceMappingURL=ai-trace.js.map

package/dist/internal/atomic-write.d.ts

@@ -14,4 +14,3 @@ export interface AtomicWriteOptions {
 export declare function writeFileAtomic(filePath: string, content: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;
 /** The synchronous twin, for a store that is read and written from synchronous code. */
 export declare function writeFileAtomicSync(filePath: string, content: string, options?: AtomicWriteOptions): void;
-//# sourceMappingURL=atomic-write.d.ts.map

package/dist/internal/atomic-write.js

@@ -41,4 +41,3 @@ export function writeFileAtomicSync(filePath, content, options = {}) {
         throw cause;
     }
 }
-//# sourceMappingURL=atomic-write.js.map

package/dist/internal/brands.d.ts

@@ -9,4 +9,3 @@ export declare const locatorBrand: unique symbol;
 export declare const expectationBrand: unique symbol;
 /** Slot on `globalThis` naming the running attempt for `expect.poll`. */
 export declare const attemptBrand: unique symbol;
-//# sourceMappingURL=brands.d.ts.map

package/dist/internal/brands.js

@@ -9,4 +9,3 @@ export const locatorBrand = Symbol.for('e2e.locator');
 export const expectationBrand = Symbol.for('e2e.expectation.v1');
 /** Slot on `globalThis` naming the running attempt for `expect.poll`. */
 export const attemptBrand = Symbol.for('e2e.attempt.v1');
-//# sourceMappingURL=brands.js.map

package/dist/internal/debug.d.ts

@@ -40,4 +40,3 @@ export declare class DebugTrace {
 export declare function table(title: string, header: readonly string[], rows: readonly (readonly string[])[], empty: string, leftAligned?: ReadonlySet<number>): string;
 export declare function formatMs(value: number): string;
 export {};
-//# sourceMappingURL=debug.d.ts.map

package/dist/internal/debug.js

@@ -99,4 +99,3 @@ export function formatMs(value) {
         return `${(value / 1000).toFixed(1)}s`;
     return `${Math.round(value)}ms`;
 }
-//# sourceMappingURL=debug.js.map

package/dist/internal/env.d.ts

@@ -3,4 +3,3 @@
 export declare function envValue(env: NodeJS.ProcessEnv, name: string): string | undefined;
 /** True for a set variable that is not blank, `0`, or `false`. */
 export declare function envFlag(env: NodeJS.ProcessEnv, name: string): boolean;
-//# sourceMappingURL=env.d.ts.map

package/dist/internal/env.js

@@ -9,4 +9,3 @@ export function envFlag(env, name) {
     const value = envValue(env, name)?.trim().toLowerCase();
     return value !== undefined && value !== '0' && value !== 'false';
 }
-//# sourceMappingURL=env.js.map

package/dist/internal/errors.d.ts

@@ -172,4 +172,3 @@ export declare function sanitizeText(text: string): string;
 /** Truncates a string so its UTF-8 encoding fits maxBytes without splitting a code point. */
 export declare function truncateUtf8(text: string, maxBytes: number): string;
 export {};
-//# sourceMappingURL=errors.d.ts.map

package/dist/internal/errors.js

@@ -342,4 +342,3 @@ export function truncateUtf8(text, maxBytes) {
         end -= 1;
     return UTF8_DECODER.decode(bytes.subarray(0, end));
 }
-//# sourceMappingURL=errors.js.map

package/dist/internal/geometry.d.ts

@@ -28,4 +28,3 @@ export declare function overlapShare(a: Box, b: Box): number;
  * the main list. 0 for a viewport without area.
  */
 export declare function viewportShare(box: Box, viewport: ViewportSize): number;
-//# sourceMappingURL=geometry.d.ts.map

package/dist/internal/geometry.js

@@ -58,4 +58,3 @@ export function viewportShare(box, viewport) {
         return 0;
     return clamp((width * height) / (viewport.width * viewport.height), 0, 1);
 }
-//# sourceMappingURL=geometry.js.map

package/dist/internal/git.d.ts

@@ -6,4 +6,3 @@
 export declare const COMMIT_HASH: RegExp;
 /** One git command's trimmed stdout; undefined when git is missing, slow, or refuses. */
 export declare function git(cwd: string, args: readonly string[]): Promise<string | undefined>;
-//# sourceMappingURL=git.d.ts.map

package/dist/internal/git.js

@@ -22,4 +22,3 @@ export async function git(cwd, args) {
         return undefined;
     }
 }
-//# sourceMappingURL=git.js.map

package/dist/internal/globs.d.ts

@@ -66,4 +66,3 @@ export declare function discoverFiles(root: string, patterns: readonly string[])
 /** Sorts strings by Unicode code point, the order collection is defined in. */
 export declare function compareCodePoints(a: string, b: string): number;
 export {};
-//# sourceMappingURL=globs.d.ts.map

package/dist/internal/globs.js

@@ -234,4 +234,3 @@ export function compareCodePoints(a, b) {
     }
     return aPoints.length - bPoints.length;
 }
-//# sourceMappingURL=globs.js.map

package/dist/internal/ids.d.ts

@@ -35,4 +35,3 @@ export declare function resultId(test: string, targetId: string, agent: string,
 export declare function uuidv7(now?: number): string;
 /** RFC 3339 UTC timestamp with exactly millisecond precision. */
 export declare function timestamp(date?: Date): string;
-//# sourceMappingURL=ids.d.ts.map

package/dist/internal/ids.js

@@ -127,4 +127,3 @@ export function uuidv7(now = Date.now()) {
 export function timestamp(date = new Date()) {
     return date.toISOString();
 }
-//# sourceMappingURL=ids.js.map

package/dist/internal/json-value.d.ts

@@ -12,4 +12,3 @@ export interface JsonValueRules {
 }
 /** Validates that a value is JSON-safe, throwing a labeled TestError otherwise. */
 export declare function validateJsonValue(value: unknown, label: string, rules?: JsonValueRules): void;
-//# sourceMappingURL=json-value.d.ts.map