@fairfox/polly 0.86.0 → 0.88.0

package/dist/tools/test/src/browser/runner-core.d.ts

@@ -11,7 +11,71 @@ export interface FileTally {
     passed: number;
     failed: number;
 }
+/** One test's outcome, as the in-page harness reports it. */
+export interface TestResult {
+    name: string;
+    passed: boolean;
+    error?: string;
+}
+/**
+ * What the page pushes to the runner as it works through a file.
+ *
+ * The final `__pollyReport` call carries the whole tally, but it never
+ * arrives when the page stops running. These events arrive as the suite
+ * goes, so a timed-out file can still say how far it got (polly#177).
+ */
+export type ProgressEvent = {
+    kind: "plan";
+    total: number;
+} | {
+    kind: "start";
+    name: string;
+} | {
+    kind: "result";
+    name: string;
+    passed: boolean;
+    error?: string;
+};
+/** Everything the page managed to say before it went quiet. */
+export interface SuiteProgress {
+    /** Test count the page announced up front; absent if it never got that far. */
+    planned?: number;
+    /** Names of tests that began, in order. */
+    started: string[];
+    /** Outcomes of tests that finished. */
+    completed: TestResult[];
+}
+/**
+ * What the renderer was doing when the file timed out.
+ *
+ * - `looping`   — the main thread never yielded, so JavaScript is still
+ *                 running: a runaway loop in the code under test.
+ * - `idle`      — the page answers, so the thread is free; an awaited
+ *                 promise never settled, or `done()` was never called.
+ * - `unknown`   — the state could not be probed (the page or the browser
+ *                 had already gone).
+ */
+export type StallState = "looping" | "idle" | "unknown";
 export declare function errMessage(err: unknown): string;
+/** Empty progress, for a file whose page said nothing at all. */
+export declare function emptyProgress(): SuiteProgress;
+/** Fold one page-pushed event into the accumulated progress. */
+export declare function applyProgress(progress: SuiteProgress, event: ProgressEvent): void;
+/**
+ * Turn a timed-out file into a tally and the lines to print for it.
+ *
+ * A timed-out file used to count as a single failure, so the tests it held
+ * vanished from the run's totals with no indication — a 9-test file that
+ * stalled on its 4th test reported `1 failed` and the tier's count silently
+ * lost 9 tests (polly#177). Every test the page announced is now accounted
+ * for: the ones that finished keep their real outcome, and the ones that
+ * never ran are counted as failures so the tier's total still matches the
+ * number of tests in the files.
+ */
+export declare function summariseTimeout(progress: SuiteProgress, timeoutMs: number, state: StallState): {
+    tally: FileTally;
+    lines: string[];
+};
 /**
  * Run every test file, isolating each file's failure.
  *

package/dist/tools/test/src/browser/source-map.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal source-map lookup for the browser runner's stack reports.
+ *
+ * When a page wedges, the runner pauses it and prints the frames it was
+ * executing. Those positions are in the served bundle, which is one long
+ * generated file — "(inline):199:4" names the right line of the wrong file.
+ * Resolving them through the bundle's own inline source map turns the report
+ * into the position in the test or component the author wrote (polly#177).
+ *
+ * Only what that needs is implemented: decode `mappings`, and answer
+ * "which original position covers this generated one". No names, no
+ * `sourcesContent`, no index maps — Bun.build does not emit those here.
+ */
+interface SourceMap {
+    sources: string[];
+    mappings: string;
+}
+/** Resolves a generated position to `source:line:column`, or undefined. */
+export type SourceMapLookup = (line: number, column: number) => string | undefined;
+/** Pull the inline source map out of a bundle, if it carries one. */
+export declare function parseInlineSourceMap(bundle: string): SourceMap | undefined;
+/**
+ * Build a lookup over a bundle's inline source map.
+ *
+ * `lineOffset` is how many lines of wrapper HTML sit above the bundle in the
+ * served document, since the debugger reports positions in the document, not
+ * in the script. Returns undefined when the bundle carries no usable map, so
+ * callers can fall back to the raw generated position.
+ */
+export declare function createSourceMapLookup(bundle: string, lineOffset?: number): SourceMapLookup | undefined;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fairfox/polly",
-  "version": "0.86.0",
+  "version": "0.88.0",
   "private": false,
   "type": "module",
   "description": "Multi-execution-context framework with reactive state and cross-context messaging for Chrome extensions, PWAs, and worker-based applications",