e2e 0.15.2 → 0.17.0

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

@@ -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,
@@ -121,4 +148,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

@@ -207,18 +207,24 @@ 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 };
 }
 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/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/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,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;
-//# sourceMappingURL=brands.d.ts.map
+/** 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,4 +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');
-//# sourceMappingURL=brands.js.map
+/** 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/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

package/dist/internal/json-value.js

@@ -58,4 +58,3 @@ export function validateJsonValue(value, label, rules = {}) {
     };
     visit(value);
 }
-//# sourceMappingURL=json-value.js.map