e2e 0.15.2 → 0.17.0

package/dist/internal/keys.d.ts

@@ -1,4 +1,3 @@
 /** The harness-side check of a `press` key against the contract's key grammar. */
 /** Throws `INVALID_ARGUMENT` for anything but a key in the grammar `parseKey` accepts. */
 export declare function requireKey(key: unknown): asserts key is string;
-//# sourceMappingURL=keys.d.ts.map

package/dist/internal/keys.js

@@ -9,4 +9,3 @@ export function requireKey(key) {
         `and one key joined by "+", where the key is a single character or one of ${KEY_NAMES.join(', ')} ` +
         '(for example "Enter", "Control+a", "Shift+Tab")');
 }
-//# sourceMappingURL=keys.js.map

package/dist/internal/node-version.d.ts

@@ -7,4 +7,3 @@
 export declare const MINIMUM_NODE_VERSION = "22.12.0";
 /** Explains an unsupported runtime, or undefined when `current` meets the floor. */
 export declare function unsupportedNodeMessage(current: string, minimum?: string): string | undefined;
-//# sourceMappingURL=node-version.d.ts.map

package/dist/internal/node-version.js

@@ -25,4 +25,3 @@ export function unsupportedNodeMessage(current, minimum = MINIMUM_NODE_VERSION)
     }
     return undefined;
 }
-//# sourceMappingURL=node-version.js.map

package/dist/internal/objects.d.ts

@@ -18,4 +18,3 @@ type PlainObject<T> = T extends readonly unknown[] ? never : T;
  */
 export declare function obj<T extends object>(value: PlainObject<T>): WithoutUndefined<T>;
 export {};
-//# sourceMappingURL=objects.d.ts.map

package/dist/internal/objects.js

@@ -11,4 +11,3 @@
 export function obj(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-//# sourceMappingURL=objects.js.map

package/dist/internal/options.d.ts

@@ -26,4 +26,3 @@ export declare function unknownKeyMessage(label: string, value: object, keys: re
  * for an argument a test passes.
  */
 export declare function rejectUnknownKeys(label: string, value: object, keys: readonly string[], code?: 'INVALID_CONFIG' | 'INVALID_ARGUMENT'): void;
-//# sourceMappingURL=options.d.ts.map

package/dist/internal/options.js

@@ -61,4 +61,3 @@ export function rejectUnknownKeys(label, value, keys, code = 'INVALID_CONFIG') {
         return;
     throw code === 'INVALID_CONFIG' ? new ConfigurationError(code, message) : new TestError(code, message);
 }
-//# sourceMappingURL=options.js.map

package/dist/internal/package-manager.d.ts

@@ -11,4 +11,3 @@ export declare function runScriptCommand(manager: PackageManager, name: string):
 export declare function execCommand(manager: PackageManager, command: string): string;
 /** The command that adds `name` as a dev dependency with the given manager. */
 export declare function addDevDependencyCommand(manager: PackageManager, name: string): string;
-//# sourceMappingURL=package-manager.d.ts.map

package/dist/internal/package-manager.js

@@ -66,4 +66,3 @@ export function addDevDependencyCommand(manager, name) {
             return `bun add -d ${name}`;
     }
 }
-//# sourceMappingURL=package-manager.js.map

package/dist/internal/package-version.d.ts

@@ -5,4 +5,3 @@
 export declare function packageVersion(fromUrl: string, specifier: string, fallback: string): string;
 /** Reads a JSON file through require resolution relative to the caller's module URL, or undefined when absent. */
 export declare function readJson(fromUrl: string, specifier: string): unknown;
-//# sourceMappingURL=package-version.d.ts.map

package/dist/internal/package-version.js

@@ -20,4 +20,3 @@ export function readJson(fromUrl, specifier) {
         return undefined;
     }
 }
-//# sourceMappingURL=package-version.js.map

package/dist/internal/paths.d.ts

@@ -20,4 +20,3 @@ export declare function realpathOfExisting(target: string): string;
 export declare function relativeToProjectRoot(projectRoot: string, target: string): string | undefined;
 /** Whether `target` is a path strictly below the project root; see `relativeToProjectRoot`. */
 export declare function insideProjectRoot(projectRoot: string, target: string): boolean;
-//# sourceMappingURL=paths.d.ts.map

package/dist/internal/paths.js

@@ -63,4 +63,3 @@ export function relativeToProjectRoot(projectRoot, target) {
 export function insideProjectRoot(projectRoot, target) {
     return relativeToProjectRoot(projectRoot, target) !== undefined;
 }
-//# sourceMappingURL=paths.js.map

package/dist/internal/realm-slot.d.ts

@@ -10,4 +10,3 @@ export interface RealmSlot<T> {
     delete(host: object): void;
 }
 export declare function realmSlot<T>(key: string | symbol): RealmSlot<T>;
-//# sourceMappingURL=realm-slot.d.ts.map

package/dist/internal/realm-slot.js

@@ -20,4 +20,3 @@ export function realmSlot(key) {
         },
     };
 }
-//# sourceMappingURL=realm-slot.js.map

package/dist/internal/recording-modes.d.ts

@@ -54,4 +54,3 @@ export declare function isRetryMode(mode: RecordingMode): boolean;
 export declare function attemptRecording(recording: ResolvedRecording, attemptIndex: number): AttemptRecording | undefined;
 /** Whether any attempt of a test with `retries` records under `mode`: what the engine has to be able to honour before the run starts. */
 export declare function recordsOnSomeAttempt(mode: RecordingMode, retries: number): boolean;
-//# sourceMappingURL=recording-modes.d.ts.map

package/dist/internal/recording-modes.js

@@ -48,4 +48,3 @@ export function attemptRecording(recording, attemptIndex) {
 export function recordsOnSomeAttempt(mode, retries) {
     return isRetryMode(mode) ? retries >= 1 : mode !== 'off';
 }
-//# sourceMappingURL=recording-modes.js.map

package/dist/internal/redact.d.ts

@@ -47,9 +47,12 @@ export declare class SecretLedger {
      * `FRAGMENT_LENGTH` characters, or half of a value shorter than twice that.
      * A cut is one position, so a boundary this short seldom matches plain text
      * by chance. Matched as the value is written, in any case (`caseKey`), as
-     * a CSS `text-transform` shows it: the cut falls on text as the engine read
-     * it, before any serializer spells it. A case mapping that changes length
-     * (`ß` to `SS`) is not followed, nor is collapsed whitespace. The part is found before whole values are
+     * a CSS `text-transform` shows it, and with every whitespace run on both
+     * sides read as one space (`readingKey`) and the value's leading whitespace
+     * dropped where whole-value matching trims it (`valuePattern`), as an
+     * engine that collapses text before cutting it shows it: the cut falls on
+     * text as the engine read it, before any serializer spells it. A case
+     * mapping that changes length (`ß` to `SS`) is not followed. The part is found before whole values are
      * rewritten, so a value that starts with another registered value is not
      * half rewritten as the shorter one, and an occurrence running into the
      * part joins its marker. Bound like `redact`.
@@ -61,7 +64,7 @@ export declare class SecretLedger {
      * becomes its marker. For a recording that keeps what an engine read raw
      * (a Playwright trace holds the page's cut text and selections), where a
      * value cut or selected partway through survives whole-value matching.
-     * Matched as the value is written, in any case, like `redactCut`. A
+     * Matched in any case and with whitespace runs collapsed, like `redactCut`. A
      * base64 or base64url run that decodes to text holding a value or a
      * fragment is rewritten whole (a basic-auth header the engine sent). Bound
      * like `redact`.
@@ -111,4 +114,3 @@ export declare class StreamRedactor {
     /** Redacts and returns whatever is held, an unfinished character included; nothing more will follow. */
     flush(): string;
 }
-//# sourceMappingURL=redact.d.ts.map

package/dist/internal/redact.js

@@ -63,24 +63,31 @@ function compile(values) {
     });
     // `split` on a capturing pattern returns the markers at the odd indexes; those pass through untouched.
     const redact = (text) => text.split(known).map((piece, index) => (index % 2 === 1 ? piece : rewrite(piece))).join('');
-    const valueKeys = entries.map(([, value]) => caseKey(value));
+    const valueKeys = entries.map(([, value]) => readingKey(value).key);
+    // A reader trims a value's leading whitespace as it trims any text's, so a cut part may begin past it.
+    const leadingForms = entries.map(([, value], index) => {
+        const key = valueKeys[index] ?? '';
+        return secretLength(value.trim()) >= MIN_SECRET_LENGTH && key.trimStart() !== key ? [key, key.trimStart()] : [key];
+    });
     const redactCut = (text) => {
         // Only what follows the last marker can end in a value cut short.
         const tail = text.split(known).at(-1) ?? '';
-        const tailKey = caseKey(tail);
+        const tailKey = readingKey(tail);
         let cut = 0;
         let marker = '';
-        valueKeys.forEach((value, index) => {
-            const length = leadingPartAtEnd(tailKey, value, Math.min(FRAGMENT_LENGTH, Math.ceil(value.length / 2)));
-            if (length > cut) {
-                cut = length;
-                marker = markers[index] ?? '';
+        leadingForms.forEach((forms, index) => {
+            for (const value of forms) {
+                const length = leadingPartAtEnd(tailKey.key, value, Math.min(FRAGMENT_LENGTH, Math.ceil(value.length / 2)));
+                if (length > cut) {
+                    cut = length;
+                    marker = markers[index] ?? '';
+                }
             }
         });
         if (cut === 0)
             return redact(text);
         // An occurrence the whole-value pass would rewrite across the fragment's start joins the fragment.
-        let start = tail.length - cut;
+        let start = tailKey.at(tailKey.key.length - cut);
         pattern.lastIndex = 0;
         for (let match = pattern.exec(tail); match !== null && match.index < start; match = pattern.exec(tail)) {
             if (match.index + match[0].length > start) {
@@ -221,6 +228,87 @@ function caseKey(text) {
         out += ch.charCodeAt(0) < 128 ? ch.toLowerCase() : caseKeyOf(ch);
     return out;
 }
+/** Whitespace a reader rewrites: a run of two or more, or one character other than a plain space. */
+const COLLAPSIBLE = /\s\s|[^\S ]/u;
+/** UTF-16 units joined into one string at a time when the key is rebuilt. */
+const KEY_CHUNK = 8192;
+/**
+ * `text` as a cut or a fragment of a value is compared: `caseKey`, with each
+ * whitespace run read as one space, as an engine that collapses whitespace
+ * (`normalizeText`) shows it before cutting. A value holding a line break, a
+ * tab, a CRLF, a no-break space, or a run of spaces then agrees with what a
+ * collapsed text keeps of it, and a stretch of the key maps back to the text
+ * through `at`. `caseKey` keeps every index, so text with nothing to collapse
+ * is its own key. Otherwise the key is rebuilt unit by unit into a typed
+ * array, and `at` keeps one pair of offsets per collapsed run: a trace text
+ * of many megabytes costs a few times its size, never an object per unit.
+ */
+function readingKey(text) {
+    const cased = caseKey(text);
+    if (!COLLAPSIBLE.test(cased))
+        return { key: cased, at: (index) => index };
+    const units = new Uint16Array(cased.length);
+    // Pairs of where a stretch after a collapsed run starts, in the key and in the text.
+    let breaks = new Int32Array(64);
+    let pairs = 0;
+    let length = 0;
+    for (let index = 0; index < cased.length; index += 1) {
+        const unit = cased.charCodeAt(index);
+        if (!isWhitespace(unit)) {
+            units[length++] = unit;
+            continue;
+        }
+        let end = index + 1;
+        while (end < cased.length && isWhitespace(cased.charCodeAt(end)))
+            end += 1;
+        units[length++] = 0x20;
+        if (end - index > 1 || unit !== 0x20) {
+            if (2 * pairs + 2 > breaks.length) {
+                const grown = new Int32Array(breaks.length * 2);
+                grown.set(breaks);
+                breaks = grown;
+            }
+            breaks[2 * pairs] = length;
+            breaks[2 * pairs + 1] = end;
+            pairs += 1;
+        }
+        index = end - 1;
+    }
+    const chunks = [];
+    for (let start = 0; start < length; start += KEY_CHUNK) {
+        chunks.push(String.fromCharCode(...units.subarray(start, Math.min(length, start + KEY_CHUNK))));
+    }
+    return {
+        key: chunks.join(''),
+        at: (index) => {
+            // The last stretch starting at or before `index`; before the first run the key and the text agree.
+            let low = -1;
+            let high = pairs - 1;
+            while (low < high) {
+                const middle = (low + high + 1) >> 1;
+                if ((breaks[2 * middle] ?? 0) <= index)
+                    low = middle;
+                else
+                    high = middle - 1;
+            }
+            return low === -1 ? index : (breaks[2 * low + 1] ?? 0) + index - (breaks[2 * low] ?? 0);
+        },
+    };
+}
+/** Whether a UTF-16 unit is one `\s` matches: what `normalizeText` collapses. */
+function isWhitespace(unit) {
+    return (unit === 0x20 ||
+        (unit >= 0x09 && unit <= 0x0d) ||
+        unit === 0xa0 ||
+        unit === 0x1680 ||
+        (unit >= 0x2000 && unit <= 0x200a) ||
+        unit === 0x2028 ||
+        unit === 0x2029 ||
+        unit === 0x202f ||
+        unit === 0x205f ||
+        unit === 0x3000 ||
+        unit === 0xfeff);
+}
 /** One non-ASCII character's `caseKey`, the same length as `ch`. */
 function caseKeyOf(ch) {
     const upper = sameLength(ch.toUpperCase(), ch);
@@ -306,8 +394,9 @@ function leadingPartAtEnd(text, value, minimum) {
 /**
  * Every run of `FRAGMENT_LENGTH` characters of every value, mapped to the
  * index of the first value holding it; values come longest first, so a run
- * two values share names the longer one. The values come as `caseKey`
- * reads them, so a run in any case finds its owner.
+ * two values share names the longer one. The values come as `readingKey`
+ * reads them, so a run in any case or with its whitespace collapsed finds
+ * its owner.
  */
 function fragmentOwners(values) {
     const owners = new Map();
@@ -323,29 +412,30 @@ function fragmentOwners(values) {
 /**
  * `text` with every stretch whose windows of `FRAGMENT_LENGTH` characters
  * each occur in a value replaced by the marker of the value owning its first
- * window. Windows are looked up by `caseKey`, as `owners` is keyed, so a
- * fragment in another case is one too. The stretch grows one window at a time, so the
- * scan is linear in the text and a run spanning two values becomes one
- * marker.
+ * window. Windows are looked up by `readingKey`, as `owners` is keyed, so a
+ * fragment in another case or with another whitespace run is one too, and
+ * the stretch is cut back out of `text` whole, its whitespace runs included.
+ * The stretch grows one window at a time, so the scan is linear in the text
+ * and a run spanning two values becomes one marker.
  */
 function rewriteFragments(text, owners, markers) {
     if (owners.size === 0)
         return text;
-    const key = caseKey(text);
+    const { key, at } = readingKey(text);
     let out = '';
     let kept = 0;
     let start = 0;
-    while (start + FRAGMENT_LENGTH <= text.length) {
+    while (start + FRAGMENT_LENGTH <= key.length) {
         const owner = owners.get(key.slice(start, start + FRAGMENT_LENGTH));
         if (owner === undefined) {
             start += 1;
             continue;
         }
         let end = start + FRAGMENT_LENGTH;
-        while (end < text.length && owners.has(key.slice(end + 1 - FRAGMENT_LENGTH, end + 1)))
+        while (end < key.length && owners.has(key.slice(end + 1 - FRAGMENT_LENGTH, end + 1)))
             end += 1;
-        out += `${text.slice(kept, start)}${markers[owner] ?? ''}`;
-        kept = end;
+        out += `${text.slice(kept, at(start))}${markers[owner] ?? ''}`;
+        kept = at(end);
         start = end;
     }
     return out + text.slice(kept);
@@ -449,9 +539,12 @@ export class SecretLedger {
      * `FRAGMENT_LENGTH` characters, or half of a value shorter than twice that.
      * A cut is one position, so a boundary this short seldom matches plain text
      * by chance. Matched as the value is written, in any case (`caseKey`), as
-     * a CSS `text-transform` shows it: the cut falls on text as the engine read
-     * it, before any serializer spells it. A case mapping that changes length
-     * (`ß` to `SS`) is not followed, nor is collapsed whitespace. The part is found before whole values are
+     * a CSS `text-transform` shows it, and with every whitespace run on both
+     * sides read as one space (`readingKey`) and the value's leading whitespace
+     * dropped where whole-value matching trims it (`valuePattern`), as an
+     * engine that collapses text before cutting it shows it: the cut falls on
+     * text as the engine read it, before any serializer spells it. A case
+     * mapping that changes length (`ß` to `SS`) is not followed. The part is found before whole values are
      * rewritten, so a value that starts with another registered value is not
      * half rewritten as the shorter one, and an occurrence running into the
      * part joins its marker. Bound like `redact`.
@@ -463,7 +556,7 @@ export class SecretLedger {
      * becomes its marker. For a recording that keeps what an engine read raw
      * (a Playwright trace holds the page's cut text and selections), where a
      * value cut or selected partway through survives whole-value matching.
-     * Matched as the value is written, in any case, like `redactCut`. A
+     * Matched in any case and with whitespace runs collapsed, like `redactCut`. A
      * base64 or base64url run that decodes to text holding a value or a
      * fragment is rewritten whole (a basic-auth header the engine sent). Bound
      * like `redact`.
@@ -548,4 +641,3 @@ export class StreamRedactor {
         return this.ledger.redact(text);
     }
 }
-//# sourceMappingURL=redact.js.map

package/dist/internal/regexp.d.ts

@@ -7,4 +7,3 @@ export declare function escapeRegexpChar(ch: string): string;
  * sticky/global state can never leak between matches.
  */
 export declare function testPattern(source: string, flags: string, input: string): boolean;
-//# sourceMappingURL=regexp.d.ts.map

package/dist/internal/regexp.js

@@ -24,4 +24,3 @@ export function testPattern(source, flags, input) {
     pattern.lastIndex = 0;
     return pattern.test(input);
 }
-//# sourceMappingURL=regexp.js.map

package/dist/internal/roles.d.ts

@@ -8,4 +8,3 @@ export declare function isEditable(node: Pick<SemanticNode, 'role'>): boolean;
  * told apart from a heading, which has no value at all, by its role.
  */
 export declare function isValueControl(node: Pick<SemanticNode, 'role'>): boolean;
-//# sourceMappingURL=roles.d.ts.map

package/dist/internal/roles.js

@@ -19,4 +19,3 @@ export function isEditable(node) {
 export function isValueControl(node) {
     return VALUE_ROLES.has(node.role ?? '');
 }
-//# sourceMappingURL=roles.js.map

package/dist/internal/skip.d.ts

@@ -38,4 +38,3 @@ export declare function parseSkipCall(first: unknown, second: unknown): SkipCall
  */
 export declare function skipRunningTest(condition: boolean, reason: string | undefined): void;
 export {};
-//# sourceMappingURL=skip.d.ts.map

package/dist/internal/skip.js

@@ -55,4 +55,3 @@ export function skipRunningTest(condition, reason) {
     }
     throw new RuntimeSkip(reason);
 }
-//# sourceMappingURL=skip.js.map

package/dist/internal/source.d.ts

@@ -29,4 +29,3 @@ export declare function projectRelativePath(projectRoot: string, file: string):
 export declare function userFrame(stack: string | undefined, projectRoot: string | undefined): StackFrame | undefined;
 /** The user's frame in a stack as the report keeps it: project-relative, POSIX; nothing when the stack named no project line. */
 export declare function sourceLocation(stack: string | undefined, projectRoot: string | undefined): SourceLocation | undefined;
-//# sourceMappingURL=source.d.ts.map

package/dist/internal/source.js

@@ -61,4 +61,3 @@ export function sourceLocation(stack, projectRoot) {
         return undefined;
     return { file: relative, line: Math.max(1, frame.line), column: Math.max(1, frame.column) };
 }
-//# sourceMappingURL=source.js.map

package/dist/internal/standard-schema.d.ts

@@ -4,4 +4,3 @@ import type { StandardSchemaV1 } from '../types.ts';
 export declare function requireStandardSchema(schema: unknown, label: string): asserts schema is StandardSchemaV1;
 /** One issue as `users.0.email: Invalid email`, or the bare message for an issue at the root. */
 export declare function describeIssue(issue: StandardSchemaV1.Issue): string;
-//# sourceMappingURL=standard-schema.d.ts.map

package/dist/internal/standard-schema.js

@@ -14,4 +14,3 @@ export function describeIssue(issue) {
         .join('.');
     return fieldPath === '' ? issue.message : `${fieldPath}: ${issue.message}`;
 }
-//# sourceMappingURL=standard-schema.js.map

package/dist/internal/suggest.d.ts

@@ -17,4 +17,3 @@ export declare function isTypoOf(word: string, candidate: string): boolean;
 export declare function didYouMean(word: string, candidates: readonly string[]): string;
 /** ` (did you mean x?)` for a note right after the word in a list, or the empty string. */
 export declare function suggestionNote(word: string, candidates: readonly string[]): string;
-//# sourceMappingURL=suggest.d.ts.map

package/dist/internal/suggest.js

@@ -74,4 +74,3 @@ function editDistance(a, b) {
     }
     return rows[a.length][b.length];
 }
-//# sourceMappingURL=suggest.js.map

package/dist/internal/text.d.ts

@@ -32,6 +32,8 @@ export interface TextComparison {
     readonly mode: 'equals' | 'contains';
     /** Whether both sides are whitespace-normalized first. `false` compares the raw strings, as a form control's value is. */
     readonly normalize: boolean;
+    /** Compares a string pattern case-insensitively. A RegExp reads case from its flags; `withIgnoreCase` sets them. */
+    readonly ignoreCase?: boolean | undefined;
 }
 /**
  * Matches normalized text against a pattern. String matching is exact by
@@ -46,6 +48,11 @@ export declare function matchesText(actual: string, pattern: TextPattern): boole
  * platform reports verbatim.
  */
 export declare function compareText(actual: string, pattern: TextPattern, comparison: TextComparison): boolean;
+/**
+ * The pattern under Playwright's `ignoreCase`: `true` adds a RegExp's `i`
+ * flag, `false` removes it, `undefined` keeps the flags it came with. A string
+ * pattern is returned as it is; `compareText` folds its case.
+ */
+export declare function withIgnoreCase(pattern: TextPattern, ignoreCase: boolean | undefined): TextPattern;
 /** Renders a pattern for diagnostics. */
 export declare function describePattern(pattern: TextPattern): string;
-//# sourceMappingURL=text.d.ts.map

package/dist/internal/text.js

@@ -63,7 +63,19 @@ export function compareText(actual, pattern, comparison) {
     const expected = comparison.normalize ? normalizeText(pattern.value) : pattern.value;
     if (!pattern.exact)
         return subject.toLowerCase().includes(expected.toLowerCase());
-    return comparison.mode === 'equals' ? subject === expected : subject.includes(expected);
+    const fold = (text) => (comparison.ignoreCase === true ? text.toLowerCase() : text);
+    return comparison.mode === 'equals' ? fold(subject) === fold(expected) : fold(subject).includes(fold(expected));
+}
+/**
+ * The pattern under Playwright's `ignoreCase`: `true` adds a RegExp's `i`
+ * flag, `false` removes it, `undefined` keeps the flags it came with. A string
+ * pattern is returned as it is; `compareText` folds its case.
+ */
+export function withIgnoreCase(pattern, ignoreCase) {
+    if (pattern.kind !== 'regexp' || ignoreCase === undefined)
+        return pattern;
+    const flags = pattern.flags.replace('i', '');
+    return { ...pattern, flags: normalizeRegexpFlags(ignoreCase ? `${flags}i` : flags) };
 }
 /** Renders a pattern for diagnostics. */
 export function describePattern(pattern) {
@@ -71,4 +83,3 @@ export function describePattern(pattern) {
         return JSON.stringify(pattern.value);
     return `/${pattern.source}/${pattern.flags}`;
 }
-//# sourceMappingURL=text.js.map

package/dist/internal/time.d.ts

@@ -30,6 +30,12 @@ export interface PollConditionOptions {
  * Polls a condition until it holds (or, when negated, until its negation has
  * held continuously for the negation grace window), throwing the caller's
  * error at the deadline.
+ *
+ * A negation holds from the moment the read that first saw it was issued, so
+ * a slow read counts toward the window. A budget shorter than the window
+ * still has to be satisfiable: the negation then only needs to hold for the
+ * whole budget, and passes at the deadline on what it has seen, since a read
+ * past the deadline has no budget left.
  */
 export declare function pollCondition(options: PollConditionOptions): Promise<void>;
 /** Races a promise against a timeout; on timeout invokes onTimeout to build the error. */
@@ -53,4 +59,3 @@ export declare function withinCleanupBudget(promise: Promise<unknown>, budget: {
     readonly signal: AbortSignal;
     readonly timeoutMs: number;
 }): Promise<void>;
-//# sourceMappingURL=time.d.ts.map

package/dist/internal/time.js

@@ -47,29 +47,41 @@ export const NEGATION_GRACE_MS = 1000;
  * Polls a condition until it holds (or, when negated, until its negation has
  * held continuously for the negation grace window), throwing the caller's
  * error at the deadline.
+ *
+ * A negation holds from the moment the read that first saw it was issued, so
+ * a slow read counts toward the window. A budget shorter than the window
+ * still has to be satisfiable: the negation then only needs to hold for the
+ * whole budget, and passes at the deadline on what it has seen, since a read
+ * past the deadline has no budget left.
  */
 export async function pollCondition(options) {
-    // A budget shorter than the grace window still has to be satisfiable: the
-    // negation then only needs to hold for the budget itself.
-    const grace = Math.min(NEGATION_GRACE_MS, Math.max(0, options.deadline.remaining()));
-    let negatedTrueSince;
+    const { deadline, negated } = options;
+    const startedAt = Date.now();
+    const grace = Math.min(NEGATION_GRACE_MS, deadline.remaining(startedAt));
+    let readAt = startedAt;
+    let holdingSince;
+    const holds = (now) => holdingSince !== undefined && now - holdingSince >= grace;
     for (;;) {
         const value = await options.evaluate();
-        if (!options.negated) {
+        if (!negated) {
             if (value === true)
                 return;
         }
-        else if (value === false) {
-            negatedTrueSince ??= Date.now();
-            if (Date.now() - negatedTrueSince >= grace)
-                return;
-        }
         else {
-            negatedTrueSince = undefined;
+            holdingSince = value === false ? (holdingSince ?? readAt) : undefined;
         }
-        if (options.deadline.expired())
+        const now = Date.now();
+        if (holds(now))
+            return;
+        if (deadline.expired(now))
             throw await options.onTimeout();
-        await sleep(POLL_INTERVAL_MS, options.signal);
+        await sleep(negated ? Math.min(POLL_INTERVAL_MS, deadline.remaining(now)) : POLL_INTERVAL_MS, options.signal);
+        readAt = Date.now();
+        if (negated && deadline.expired(readAt)) {
+            if (holds(readAt))
+                return;
+            throw await options.onTimeout();
+        }
     }
 }
 /** Races a promise against a timeout; on timeout invokes onTimeout to build the error. */
@@ -151,4 +163,3 @@ export function withinCleanupBudget(promise, budget) {
             settle();
     });
 }
-//# sourceMappingURL=time.js.map

package/dist/internal/urls.d.ts

@@ -23,10 +23,12 @@ export declare function isLoopbackHost(hostname: string): boolean;
 /** True when environment may default to `test` (loopback, .localhost, .test hosts). */
 export declare function isImplicitTestHost(hostname: string): boolean;
 /**
- * Resolves a navigation URL against the base and refuses the schemes no test
- * may open. Returns the absolute URL string. Any http(s) origin is admitted:
- * a click can reach one just as well, so a gate on typed navigation alone
- * would guard nothing.
+ * Resolves a navigation URL against the base and refuses every scheme but
+ * http(s), except the exact `about:blank`. Returns the absolute URL string.
+ * Any http(s) origin is admitted: a click can reach one just as well, so a
+ * gate on typed navigation alone would guard nothing. The rule is an
+ * allowlist because a browser wraps and nests schemes (`view-source:file:`,
+ * `blob:`, `filesystem:`), and a list of forbidden ones misses the wrapper.
  */
 export declare function resolveNavigationUrl(input: string, base: NormalizedBaseUrl | undefined): {
     url: string;
@@ -53,6 +55,7 @@ export declare function sameSite(url: string | URL, site: string): boolean;
  * Relative expected strings resolve against the base URL; string comparison is
  * exact after WHATWG serialization; regexps test the complete serialized URL.
  * Anything else is `INVALID_ARGUMENT`, the `toTextPattern` rule.
+ * `ignoreCase` is Playwright's: `true` compares a string case-insensitively
+ * and adds the `i` flag to a regexp, `false` removes it.
  */
-export declare function urlMatches(current: string, expected: string | RegExp, baseHref: string): boolean;
-//# sourceMappingURL=urls.d.ts.map
+export declare function urlMatches(current: string, expected: string | RegExp, baseHref: string, ignoreCase?: boolean): boolean;