e2e 0.16.0 → 0.17.0

package/dist/cli/init/gateways.js

@@ -50,12 +50,22 @@ export const GATEWAYS = [
         id: 'copilot',
         label: 'GitHub Copilot subscription',
         hint: 'your Copilot plan: OpenAI, Anthropic, Google, and SpaceXAI models',
-        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0' },
+        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0', '@ai-sdk/openai': '^4.0.0' },
         import: "import { copilot } from 'e2e/oauth/copilot';",
         comment: 'Your GitHub Copilot subscription serves the model; sign in once with `e2e login github-copilot`, `e2e models github-copilot` lists the ids.',
         login: 'github-copilot',
         model: () => "copilot('claude-sonnet-5')",
     },
+    {
+        id: 'opencode-console',
+        label: 'OpenCode Console',
+        hint: 'the models your OpenCode Console workspace serves',
+        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0', '@ai-sdk/openai': '^4.0.0', '@ai-sdk/anthropic': '^4.0.0', '@ai-sdk/google': '^4.0.0' },
+        import: "import { opencodeConsole } from 'e2e/oauth/opencode-console';",
+        comment: 'Your OpenCode Console workspace serves the model; sign in once with `e2e login opencode-console`, `e2e models opencode-console` lists the ids.',
+        login: 'opencode-console',
+        model: () => "opencodeConsole('deepseek-v4.1-flash')",
+    },
     {
         id: 'grok',
         label: 'SuperGrok subscription',

package/dist/cli/init/sibling-versions.json

@@ -1 +1 @@
-{"@e2e-dev/web":"0.11.2","@e2e-dev/mobile":"0.9.1","playwright":"1.63.0"}
+{"@e2e-dev/web":"0.12.0","@e2e-dev/mobile":"0.9.2"}

package/dist/cli/init/versions.d.ts

@@ -3,7 +3,6 @@
  * build in `sibling-versions.json` next to this module from their manifests.
  * Absent when running from source. Both preset tables read from here.
  */
-export declare const SIBLING_VERSIONS: Readonly<Record<string, string>> | undefined;
 /**
  * The range init writes for the runner and for an engine. Engines version
  * independently of the runner and pin it through their own peer range, so init
@@ -20,10 +19,3 @@ export declare const SIBLING_VERSIONS: Readonly<Record<string, string>> | undefi
 export declare function dependencyRange(version: string | undefined): string;
 /** The range init writes for a sibling `@e2e-dev/*` package released alongside this runner. */
 export declare function siblingDependency(name: string): Readonly<Record<string, string>>;
-/**
- * The range init writes for `playwright`, which `@e2e-dev/web` peers on
- * rather than installs, so an app that already ships Playwright keeps one copy
- * and one browser cache. The build records the version the engine was built
- * and tested against; from source, where nothing is recorded, any 1.x will do.
- */
-export declare function playwrightRange(version: string | undefined): string;

package/dist/cli/init/versions.js

@@ -4,7 +4,7 @@
  * Absent when running from source. Both preset tables read from here.
  */
 import { readJson } from '../../internal/package-version.js';
-export const SIBLING_VERSIONS = readJson(import.meta.url, './sibling-versions.json');
+const SIBLING_VERSIONS = readJson(import.meta.url, './sibling-versions.json');
 /**
  * The range init writes for the runner and for an engine. Engines version
  * independently of the runner and pin it through their own peer range, so init
@@ -27,12 +27,3 @@ export function dependencyRange(version) {
 export function siblingDependency(name) {
     return { [name]: dependencyRange(SIBLING_VERSIONS?.[name]) };
 }
-/**
- * The range init writes for `playwright`, which `@e2e-dev/web` peers on
- * rather than installs, so an app that already ships Playwright keeps one copy
- * and one browser cache. The build records the version the engine was built
- * and tested against; from source, where nothing is recorded, any 1.x will do.
- */
-export function playwrightRange(version) {
-    return version === undefined ? '^1' : `^${version}`;
-}

package/dist/config/resolve.d.ts

@@ -34,6 +34,7 @@ export interface ResolvedConfig {
     readonly assertionTimeout: number;
     readonly cleanupTimeout: number;
     readonly retries: number;
+    readonly failOnSkippedFailure: boolean;
     readonly workers: number;
     /** Host store every produced artifact is handed to; undefined keeps files local only. */
     readonly artifactStore: ArtifactStore | undefined;

package/dist/config/resolve.js

@@ -25,6 +25,7 @@ const TOP_LEVEL_KEYS = new Set([
     'assertionTimeout',
     'cleanupTimeout',
     'retries',
+    'failOnSkippedFailure',
     'workers',
     'artifacts',
     'output',
@@ -111,6 +112,10 @@ export function resolveConfig(raw, options) {
     const workers = boundedInt(cli.workers, '--workers', 1, 1024) ??
         boundedInt(raw.workers, 'workers', 1, 1024) ??
         (ci ? 1 : Math.max(1, Math.floor(os.availableParallelism() / 2)));
+    const failOnSkippedFailure = raw.failOnSkippedFailure === undefined ? false : raw.failOnSkippedFailure;
+    if (typeof failOnSkippedFailure !== 'boolean') {
+        throw new ConfigurationError('INVALID_CONFIG', 'failOnSkippedFailure must be a boolean');
+    }
     const artifactStore = resolveArtifactStore(raw);
     const { reporters, customReporters } = resolveReporters(raw, cli);
     const projectId = resolveProjectId(raw.projectId, options.projectRoot);
@@ -134,6 +139,7 @@ export function resolveConfig(raw, options) {
         assertionTimeout,
         cleanupTimeout,
         retries,
+        failOnSkippedFailure,
         workers,
         artifactStore,
         output,
@@ -533,6 +539,8 @@ function resolveSecrets(raw, env) {
     const credentials = new Map();
     const secrets = new Map();
     const allSecrets = new Map();
+    checkEnvNameCollisions('E2E_USER', 'credentials', Object.keys(raw.credentials ?? {}));
+    checkEnvNameCollisions('E2E_SECRET', 'secrets', Object.keys(raw.secrets ?? {}));
     for (const [name, credential] of Object.entries(raw.credentials ?? {})) {
         const prefix = envName('E2E_USER', name);
         const username = env[`${prefix}_USERNAME`] ?? credential.username;
@@ -561,6 +569,29 @@ function resolveSecrets(raw, env) {
     }
     return { credentials, secrets, allSecrets };
 }
+/**
+ * Two entries of one namespace whose names map to the same override variable
+ * (`api-key` and `api_key` both read `E2E_SECRET_API_KEY`) would both take one
+ * rotated value, so the config load refuses them, whether or not the variable
+ * is set. The message names the entries and the variable, never a value.
+ */
+function checkEnvNameCollisions(prefix, namespace, names) {
+    const byEnvName = new Map();
+    for (const name of names) {
+        const variable = envName(prefix, name);
+        byEnvName.set(variable, [...(byEnvName.get(variable) ?? []), name]);
+    }
+    for (const [variable, group] of byEnvName) {
+        if (group.length < 2)
+            continue;
+        const quoted = group.map((name) => `"${name}"`);
+        const entries = `${quoted.slice(0, -1).join(', ')} and ${quoted.at(-1)}`;
+        const variables = prefix === 'E2E_USER'
+            ? `the override variables ${variable}_USERNAME and ${variable}_PASSWORD`
+            : `the override variable ${variable}`;
+        throw new ConfigurationError('INVALID_CONFIG', `${namespace} ${entries} share ${variables}, so one value set there would replace all of them; rename all but one`);
+    }
+}
 /**
  * Every secret an engine's options hold (a `secrets.get()` the config
  * evaluated before any run existed) names a configured secret, so a typo
@@ -643,9 +674,10 @@ function computeConfigDigest(raw, projectId, targets) {
     // reporter object changes nothing about what a run records, so it never
     // enters the digest either; the built-in ids digest as they always have,
     // so adding a reporter to a config leaves its cache valid.
+    // `failOnSkippedFailure` decides only the exit code, never what runs.
     // `targets` digest by declaration below and never enter the clone: an
     // engine holds `secrets.get()` handles, which refuse to serialize.
-    const { artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
+    const { failOnSkippedFailure: _failOnSkippedFailure, artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
     const sanitized = {
         ...structuredCloneJsonSafe(plain),
         ...(reporters === undefined

package/dist/engine/index.d.ts

@@ -147,8 +147,8 @@ export interface EngineFixtureContext {
         /**
          * Resolves a navigation target against the base URL. Throws
          * `APP_URL_REQUIRED` when the target declares no URL and `POLICY_DENIED`
-         * for a `file:`, `data:`, or `javascript:` scheme, so a fixture never
-         * re-implements the rule the harness owns.
+         * for any scheme but `http:` and `https:` (`about:blank` aside), so a
+         * fixture never re-implements the rule the harness owns.
          */
         resolveUrl(url: string): string;
     };

package/dist/expect/async.js

@@ -144,7 +144,8 @@ class AsyncExpectationImpl {
             const refs = await engine.resolveAll(this.internals.expression, deadline);
             return { count: refs.length, node: null, nodes: [] };
         }
-        const { node, count } = await engine.tryRead(this.internals.expression, deadline);
+        const missingFrame = spec.evaluableWithoutNode === true ? 'empty' : 'wait';
+        const { node, count } = await engine.tryRead(this.internals.expression, deadline, missingFrame);
         return { count, node, nodes: [] };
     }
     /** A state matcher; its Playwright flag set to `false` expects the opposite state. */

package/dist/expect/poll-scope.d.ts

@@ -0,0 +1,52 @@
+/** Which phase of a test owns an `expect.poll`, so one left running fails that phase and nothing later. */
+import { TestError } from '../internal/errors.ts';
+/**
+ * The polls one phase started: a test body with its fixtures and
+ * `beforeEach` hooks, one teardown, or one suite hook. A poll is not a step
+ * and records nothing; what the scope adds is that a poll the phase did not
+ * await ends with the phase instead of failing whatever runs when it times out.
+ */
+export declare class PollScope {
+    private readonly owner;
+    private readonly running;
+    private closed;
+    /** `owner` completes "... returned before", as in `the test body`. */
+    constructor(owner: string);
+    /**
+     * Runs one poll, owned by this scope until it settles. `work` receives the
+     * signal that cancels it when the scope closes first. A poll started after
+     * the scope closed, by work its phase left running (a body past its
+     * timeout), is cancelled before its first read: it belongs to no phase
+     * that could still fail, and must not fail the one running now.
+     */
+    track<T>(label: string, stack: string | undefined, work: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    /**
+     * Ends the scope when its phase has returned: every poll still running is
+     * cancelled and its later rejection observed. Returns the error naming
+     * them, at the line of the first, or nothing when every poll had settled.
+     * A caller whose phase was cut short (a timeout, a throw) may drop the
+     * error: the phase may have been awaiting the poll. Closing twice returns
+     * nothing the second time.
+     */
+    close(): TestError | undefined;
+    private cancel;
+}
+/**
+ * Runs `run` with `scope` owning every poll it starts, however deep in its
+ * async work and however long that work outlives the phase: a poll belongs
+ * to the phase that started it, never to the one running when it is called.
+ */
+export declare function runInPollScope<T>(scope: PollScope, run: () => T): T;
+/** One lineage of async work whose polls go to the scope current where it started, until `handOver`. */
+export interface PollLineage {
+    run<T>(run: () => T): T;
+    /** Sends the lineage's polls from now on to the scope current at this call. */
+    handOver(): void;
+}
+/**
+ * A lineage for work that spans two phases, a fixture: its setup runs in the
+ * body's phase, and the rest of its function after `use` is its teardown's.
+ */
+export declare function pollLineage(): PollLineage;
+/** The scope a poll started here belongs to, or undefined outside any phase (a standalone script). */
+export declare function currentPollScope(): PollScope | undefined;

package/dist/expect/poll-scope.js

@@ -0,0 +1,113 @@
+/** Which phase of a test owns an `expect.poll`, so one left running fails that phase and nothing later. */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { markAbandonedRejection, relocateStack } from '../internal/abandoned.js';
+import { pollScopesBrand } from '../internal/brands.js';
+import { TestError, withHint } from '../internal/errors.js';
+import { realmSlot } from '../internal/realm-slot.js';
+/**
+ * The polls one phase started: a test body with its fixtures and
+ * `beforeEach` hooks, one teardown, or one suite hook. A poll is not a step
+ * and records nothing; what the scope adds is that a poll the phase did not
+ * await ends with the phase instead of failing whatever runs when it times out.
+ */
+export class PollScope {
+    owner;
+    running = new Set();
+    closed = false;
+    /** `owner` completes "... returned before", as in `the test body`. */
+    constructor(owner) {
+        this.owner = owner;
+    }
+    /**
+     * Runs one poll, owned by this scope until it settles. `work` receives the
+     * signal that cancels it when the scope closes first. A poll started after
+     * the scope closed, by work its phase left running (a body past its
+     * timeout), is cancelled before its first read: it belongs to no phase
+     * that could still fail, and must not fail the one running now.
+     */
+    track(label, stack, work) {
+        const poll = { label, stack, controller: new AbortController(), promise: Promise.resolve(), abandoned: false };
+        if (this.closed)
+            this.cancel(poll);
+        const promise = (async () => {
+            try {
+                return await work(poll.controller.signal);
+            }
+            catch (cause) {
+                if (poll.abandoned)
+                    markAbandonedRejection(cause);
+                throw cause;
+            }
+            finally {
+                this.running.delete(poll);
+            }
+        })();
+        poll.promise = promise;
+        if (poll.abandoned)
+            promise.catch(() => undefined);
+        else
+            this.running.add(poll);
+        return promise;
+    }
+    /**
+     * Ends the scope when its phase has returned: every poll still running is
+     * cancelled and its later rejection observed. Returns the error naming
+     * them, at the line of the first, or nothing when every poll had settled.
+     * A caller whose phase was cut short (a timeout, a throw) may drop the
+     * error: the phase may have been awaiting the poll. Closing twice returns
+     * nothing the second time.
+     */
+    close() {
+        this.closed = true;
+        const polls = [...this.running];
+        const [first] = polls;
+        if (first === undefined)
+            return undefined;
+        for (const poll of polls)
+            this.cancel(poll);
+        const more = polls.length > 1 ? ` and ${polls.length - 1} more` : '';
+        const error = new TestError('STEP_NOT_AWAITED', withHint(`${this.owner} returned before ${first.label}${more} finished`, 'put `await` in front of every expect.poll call'));
+        relocateStack(error, first.stack);
+        return error;
+    }
+    cancel(poll) {
+        this.running.delete(poll);
+        poll.abandoned = true;
+        poll.promise.catch(() => undefined);
+        poll.controller.abort();
+    }
+}
+const storage = new AsyncLocalStorage();
+const scopes = { current: () => storage.getStore()?.scope };
+const slot = realmSlot(pollScopesBrand);
+/** Runs `run` in the lineage `owner` names, publishing the runner's context for a test module's `expect`. */
+function enter(owner, run) {
+    if (slot.get(globalThis) !== scopes)
+        slot.set(globalThis, scopes);
+    return storage.run(owner, run);
+}
+/**
+ * Runs `run` with `scope` owning every poll it starts, however deep in its
+ * async work and however long that work outlives the phase: a poll belongs
+ * to the phase that started it, never to the one running when it is called.
+ */
+export function runInPollScope(scope, run) {
+    return enter({ scope }, run);
+}
+/**
+ * A lineage for work that spans two phases, a fixture: its setup runs in the
+ * body's phase, and the rest of its function after `use` is its teardown's.
+ */
+export function pollLineage() {
+    const owner = { scope: scopes.current() };
+    return {
+        run: (run) => enter(owner, run),
+        handOver: () => {
+            owner.scope = scopes.current();
+        },
+    };
+}
+/** The scope a poll started here belongs to, or undefined outside any phase (a standalone script). */
+export function currentPollScope() {
+    return slot.get(globalThis)?.current();
+}

package/dist/expect/poll.js

@@ -2,9 +2,12 @@
 import { ConfigurationError, E2EError, TestError } from '../internal/errors.js';
 import { Deadline, POLL_INTERVAL_MS, sleep, withAbort, withTimeout } from '../internal/time.js';
 import { currentAttempt } from './attempt.js';
+import { currentPollScope } from './poll-scope.js';
 import { createValueExpectation } from './values.js';
 /** Outside an attempt (a standalone script) there is no config to read `assertionTimeout` from. */
 const DEFAULT_TIMEOUT_MS = 5000;
+/** Frames kept for the line a poll was called on; the user's line is a few frames up. */
+const CALL_STACK_FRAMES = 20;
 /** `satisfies` keeps this list equal to the ValueExpectation matcher set. */
 const MATCHERS = {
     toBe: true,
@@ -46,7 +49,21 @@ function sample(read, deadline, signal) {
     const bounded = withTimeout((async () => read())(), deadline.remaining(), () => new ReadHung());
     return signal === undefined ? bounded : withAbort(bounded, signal, () => new ReadAborted());
 }
-async function pollMatcher(read, options, negated, name, args) {
+/** The stack at a poll's call, for the error that names it when its phase did not await it. */
+function callStack() {
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = CALL_STACK_FRAMES;
+    try {
+        return new Error().stack;
+    }
+    finally {
+        Error.stackTraceLimit = limit;
+    }
+}
+function matcherLabel(negated, name) {
+    return `expect.poll(...).${negated ? 'not.' : ''}${name}(...)`;
+}
+async function pollMatcher(read, options, negated, name, args, scopeSignal) {
     const attempt = currentAttempt();
     const timeout = options.timeout ?? attempt?.assertionTimeout ?? DEFAULT_TIMEOUT_MS;
     const interval = options.interval ?? POLL_INTERVAL_MS;
@@ -57,9 +74,14 @@ async function pollMatcher(read, options, negated, name, args) {
     // the moment the attempt is cancelled, so a timed-out test never keeps
     // reading through teardown.
     const deadline = attempt === undefined ? own : Deadline.min(own, attempt.budget.deadline);
-    const signal = attempt?.budget.signal;
+    // The phase that started the poll cancels it when it returns without
+    // awaiting it, so the poll can never fail whatever runs after.
+    const signals = [attempt?.budget.signal, scopeSignal].filter((signal) => signal !== undefined);
+    const signal = signals.length === 0 ? undefined : AbortSignal.any(signals);
     let last;
     while (!deadline.expired()) {
+        if (signal?.aborted === true)
+            throw cancelled();
         let value;
         try {
             value = await sample(read, deadline, signal);
@@ -89,7 +111,7 @@ async function pollMatcher(read, options, negated, name, args) {
         ? `timed out after ${timeout} ms`
         : `stopped at the attempt deadline after ${Date.now() - startedAt} ms`;
     throw new TestError('ASSERTION_FAILED', [
-        `expect.poll(...).${negated ? 'not.' : ''}${name}(...) ${ending}`,
+        `${matcherLabel(negated, name)} ${ending}`,
         ...(options.message === undefined ? [] : [options.message]),
         `last: ${last ?? 'no read completed'}`,
     ].join('\n'));
@@ -107,7 +129,12 @@ function checkOptions(options) {
 function build(read, options, negated) {
     const matchers = Object.fromEntries(Object.keys(MATCHERS).map((name) => [
         name,
-        (...args) => pollMatcher(read, options, negated, name, args),
+        (...args) => {
+            const scope = currentPollScope();
+            if (scope === undefined)
+                return pollMatcher(read, options, negated, name, args, undefined);
+            return scope.track(matcherLabel(negated, name), callStack(), (signal) => pollMatcher(read, options, negated, name, args, signal));
+        },
     ]));
     return {
         ...matchers,

package/dist/expect/values.js

@@ -207,14 +207,21 @@ class ValueExpectationImpl {
         this.check(holds(actual), () => `expected ${actual} to be ${phrase} ${expected}`, () => `expected ${actual} not to be ${phrase} ${expected}`);
     }
 }
-/** Walks `keys` into `value`; `present` says whether the whole path resolved. */
+/**
+ * Walks `keys` into `value`; `present` says whether the whole path resolved.
+ * A primitive on the way is read through its wrapper object, as Jest does,
+ * so a string has its `length` and indices; `null` and `undefined` have no
+ * properties.
+ */
 function lookup(value, keys) {
     let current = value;
     for (const key of keys) {
-        if ((typeof current !== 'object' && typeof current !== 'function') || current === null || !(key in current)) {
+        if (current === null || current === undefined)
             return { present: false, value: undefined };
-        }
-        current = current[key];
+        const holder = Object(current);
+        if (!(key in holder))
+            return { present: false, value: undefined };
+        current = holder[key];
     }
     return { present: true, value: current };
 }

package/dist/internal/abandoned.d.ts

@@ -0,0 +1,11 @@
+/** Work a test left running when its phase returned: steps and polls nobody awaited. */
+/** Records `cause` as the rejection of work already failed as not awaited. */
+export declare function markAbandonedRejection(cause: unknown): void;
+/**
+ * Whether an unhandled rejection is abandoned work's: already recorded as
+ * `STEP_NOT_AWAITED`, reaching the process only because the promise the
+ * test did not await rejected with it. Such a rejection is not a fault.
+ */
+export declare function isAbandonedRejection(cause: unknown): boolean;
+/** Points `error` at the frames of `stack`, keeping its own name and message as the first line. */
+export declare function relocateStack(error: Error, stack: string | undefined): void;

package/dist/internal/abandoned.js

@@ -0,0 +1,23 @@
+/** Work a test left running when its phase returned: steps and polls nobody awaited. */
+/** What abandoned work rejected with. The promise the test holds rejects with the same value, and nobody awaits it. */
+const ABANDONED_REJECTIONS = new WeakSet();
+/** Records `cause` as the rejection of work already failed as not awaited. */
+export function markAbandonedRejection(cause) {
+    if (typeof cause === 'object' && cause !== null)
+        ABANDONED_REJECTIONS.add(cause);
+}
+/**
+ * Whether an unhandled rejection is abandoned work's: already recorded as
+ * `STEP_NOT_AWAITED`, reaching the process only because the promise the
+ * test did not await rejected with it. Such a rejection is not a fault.
+ */
+export function isAbandonedRejection(cause) {
+    return typeof cause === 'object' && cause !== null && ABANDONED_REJECTIONS.has(cause);
+}
+/** Points `error` at the frames of `stack`, keeping its own name and message as the first line. */
+export function relocateStack(error, stack) {
+    if (stack === undefined)
+        return;
+    const frames = stack.split('\n').slice(1).join('\n');
+    error.stack = `${error.name}: ${error.message}\n${frames}`;
+}

package/dist/internal/brands.d.ts

@@ -9,3 +9,5 @@ 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;
+/** Slot on `globalThis` holding the runner's view of which phase owns an `expect.poll`. */
+export declare const pollScopesBrand: unique symbol;

package/dist/internal/brands.js

@@ -9,3 +9,5 @@ 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');
+/** Slot on `globalThis` holding the runner's view of which phase owns an `expect.poll`. */
+export const pollScopesBrand = Symbol.for('e2e.pollScopes.v1');

package/dist/internal/client-identity.d.ts

@@ -0,0 +1,9 @@
+/** How e2e names itself to the vendors it calls. */
+/** `e2e/<version> (<platform>; <arch>)`: what every vendor request identifies as. Never another client's name. */
+export declare const USER_AGENT: string;
+/**
+ * Sent with every model call, whichever provider serves it. The AI SDK appends
+ * its own user agent after ours; `http-referer` and `x-title` are the app
+ * attribution the Vercel AI Gateway and OpenRouter read, and others ignore.
+ */
+export declare const MODEL_REQUEST_HEADERS: Readonly<Record<string, string>>;

package/dist/internal/client-identity.js

@@ -0,0 +1,14 @@
+/** How e2e names itself to the vendors it calls. */
+import { packageVersion } from './package-version.js';
+/** `e2e/<version> (<platform>; <arch>)`: what every vendor request identifies as. Never another client's name. */
+export const USER_AGENT = `e2e/${packageVersion(import.meta.url, '../../package.json', '0.0.0')} (${process.platform}; ${process.arch})`;
+/**
+ * Sent with every model call, whichever provider serves it. The AI SDK appends
+ * its own user agent after ours; `http-referer` and `x-title` are the app
+ * attribution the Vercel AI Gateway and OpenRouter read, and others ignore.
+ */
+export const MODEL_REQUEST_HEADERS = {
+    'user-agent': USER_AGENT,
+    'http-referer': 'https://tester.army/e2e',
+    'x-title': 'e2e',
+};

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`.