@empiricalrun/playwright-utils 0.58.6 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @empiricalrun/playwright-utils
 
+## 0.60.0
+
+### Minor Changes
+
+- 12c3b00: feat: report per-project worker caps as scheduling groups
+
+### Patch Changes
+
+- @empiricalrun/cua@0.4.2
+- @empiricalrun/llm@0.27.1
+- @empiricalrun/reporter@0.30.0
+
+## 0.59.0
+
+### Minor Changes
+
+- 17d8ac5: feat: report Playwright default-mode groups for scheduling
+
+### Patch Changes
+
+- @empiricalrun/cua@0.4.2
+- @empiricalrun/llm@0.27.1
+- @empiricalrun/reporter@0.30.0
+
 ## 0.58.6
 
 ### Patch Changes

package/dist/generated/api-worker-openapi.d.ts

@@ -255,6 +255,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/test-runs/{id}/shard-plan": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * ⚙️ 🧪 Store a test run's shard plan
+         * @description Stores the partition of a run's test selection across its run_test shards, keyed by the external run_id. Each shard reads its own slice back from `/{id}/shards/{shard_index}/assigned-tests` to build a `--test-list`. Idempotent: the first plan for a run wins.
+         */
+        post: operations["createTestRunShardPlan"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/test-runs/{id}/shards": {
         parameters: {
             query?: never;
@@ -275,6 +295,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/test-runs/{id}/shards/{shard_index}/assigned-tests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * ⚙️ 🧪 Get test run shard assigned tests
+         * @description Returns the duration-based shard plan's test-case ids for one shard, addressed by the run's external run_id. Used by the test-run-worker to build its `--test-list`. Returns 417 when the run has no plan, so the worker falls back to Playwright's `--shard=i/N` split.
+         */
+        get: operations["getTestRunShardAssignedTests"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/test-runs/{id}/shards/{shard_index}/resume": {
         parameters: {
             query?: never;
@@ -355,6 +395,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/test-runs/{id}/test-case-durations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * ⚙️ 🧪 Get test case durations for shard planning
+         * @description Returns the run's project's 7-day average duration per test case, keyed by the normalized 41-char Playwright test id, addressed by the run's external run_id. Used by the `run_setup` container to pack a shard plan: the analytics token is account-scoped and cannot be handed to a sandbox running customer test code, so the api-worker holds it and serves the numbers. Project-wide rather than per-run — the container filters to the tests it listed. A project with no history returns an empty object; a broken analytics query returns 503, so the container can tell the two apart and fall back rather than plan off nothing.
+         */
+        get: operations["getTestRunTestCaseDurations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/test-runs/{id}/triage-session": {
         parameters: {
             query?: never;
@@ -10361,7 +10421,6 @@ export interface components {
                     /** @enum {string} */
                     job_type: "merge_reports";
                     storage_bucket?: string;
-                    assigned_shard_manifest_formula?: string;
                     resume_run_from_shard?: number;
                 } | null;
             };
@@ -10549,6 +10608,29 @@ export interface components {
                 resume_from: number | null;
             };
         };
+        TestRunTestCaseDurationsResponse: {
+            data: {
+                /** @description Length of the analytics window the averages cover. */
+                days: number;
+                /** @description Per-test-case history, keyed by the normalized 41-char Playwright test id. */
+                durations: {
+                    [key: string]: {
+                        /** @description Mean total duration over the window, in ms. */
+                        avg_duration_total: number;
+                        /** @description Results the average was taken over. */
+                        total_runs: number;
+                    };
+                };
+            };
+        };
+        TestRunShardAssignedTestsResponse: {
+            data: {
+                /** @description Playwright test-case ids this shard is assigned to execute. */
+                test_case_ids: string[];
+                /** @description Shard count the plan was built for. */
+                total_shards: number;
+            };
+        };
         TestRunLogsResponse: {
             /** @description Response payload. */
             data: {
@@ -10601,7 +10683,7 @@ export interface components {
             /** @description Zero-based shard index, when stopping a sharded run. */
             shard_index?: number;
             /**
-             * @description Job type of the shard to stop. merge_reports and run_setup share shard_index 0. Defaults to merge_reports for index 0 (legacy callers), run_test otherwise.
+             * @description Job type of the shard to stop. merge_reports and run_setup share shard_index 0. When omitted, the job is resolved from the run's shard rows; an index that carries more than one stoppable job is a 400. `run_setup` is never stoppable and is always rejected.
              * @enum {string}
              */
             job_type?: "run_test" | "merge_reports" | "run_setup";
@@ -10649,8 +10731,8 @@ export interface components {
             };
         };
         PutRunManifestRequest: {
-            /** @description Structured scheduled tests (preferred). */
-            tests?: {
+            /** @description Structured scheduled tests. */
+            tests: {
                 /** @description Full test title. */
                 name: string;
                 /** @description Playwright test id, if known. */
@@ -10673,13 +10755,46 @@ export interface components {
                     dependency_order: number;
                 }[];
             }[];
-            /** @description Legacy base64-gzip manifest blob. Ignored when `tests` is present. */
-            run_manifest?: string;
             /** @description Zero-based shard index, when the run is sharded. */
             shard_index?: number;
             /** @description Total number of shards, when the run is sharded. */
             total_shards?: number;
         };
+        ShardPlanResponse: {
+            /** @description Response payload. */
+            data: {
+                /** @description Rows inserted. Zero when the run was already planned — the first plan wins and a retried POST is a no-op. */
+                shards_written: number;
+                /** @description Tests across the posted partition. */
+                total_tests: number;
+            };
+        };
+        PostShardPlanRequest: {
+            /** @description Shard count this partition was built for. Stored on every row and checked against the shard's own total_shards when the plan is read. */
+            total_shards: number;
+            /** @description One entry per run_test shard. */
+            shards: {
+                /** @description 1-based index of the run_test shard. Index 0 is the run_setup job and never carries an assignment. */
+                shard_index: number;
+                /** @description Tests assigned to this shard. */
+                tests: {
+                    /** @description Playwright test id (`pw_test_id`) assigned to this shard. */
+                    id: string;
+                    /** @description Scheduled test line (`[project] › file › suite › title`). Not stored yet; the server-written run manifest is its consumer. */
+                    name: string;
+                }[];
+            }[];
+            /** @description How the partition was chosen, stored verbatim for provenance (e.g. `equal split over the canonical listing`). */
+            reason?: string;
+            /** @description Modelled wall-clock of the slowest shard, in ms. */
+            predicted_makespan_ms?: number;
+            /** @description Modelled wall-clock at the ceiling — what the run would have done without the reduction, in ms. */
+            baseline_makespan_ms?: number;
+            /** @description Heaviest single schedulable unit, in ms. The floor no shard count can beat. */
+            longest_unit_ms?: number;
+            /** @description Fraction of planned tests that had a real historical duration. */
+            coverage?: number;
+        };
         SkipTestRunResponse: {
             data: {
                 /** @description ID of the GitHub check run created as skipped, or null if no GitHub reporter app is installed for the repo. */
@@ -13035,6 +13150,51 @@ export interface operations {
             };
         };
     };
+    createTestRunShardPlan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description External run_id of the test run. */
+                id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["PostShardPlanRequest"];
+            };
+        };
+        responses: {
+            /** @description The shard plan was stored. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ShardPlanResponse"];
+                };
+            };
+            /** @description The posted plan is not a valid partition. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Test run not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     listTestRunShards: {
         parameters: {
             query?: never;
@@ -13067,6 +13227,49 @@ export interface operations {
             };
         };
     };
+    getTestRunShardAssignedTests: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description External run_id of the test run. */
+                id: number;
+                /** @description Zero-based shard index within the run. */
+                shard_index: number | null;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The shard's assigned test-case ids. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TestRunShardAssignedTestsResponse"];
+                };
+            };
+            /** @description Test run not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No shard plan for this run or shard. */
+            417: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     getTestRunShardResume: {
         parameters: {
             query?: never;
@@ -13230,6 +13433,47 @@ export interface operations {
             };
         };
     };
+    getTestRunTestCaseDurations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Test run identifier (database id or external run_id). */
+                id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The project's test-case duration history. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TestRunTestCaseDurationsResponse"];
+                };
+            };
+            /** @description Test run not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Analytics is unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     createTestRunTriageSession: {
         parameters: {
             query?: never;
@@ -17354,7 +17598,7 @@ export interface operations {
                     "application/json": components["schemas"]["GithubProxyError"];
                 };
             };
-            /** @description A sandbox proxy rule forbade the request. */
+            /** @description The target repository is blocked, or a sandbox proxy rule forbade the request. */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -18776,8 +19020,8 @@ export interface operations {
             content: {
                 "application/json": {
                     message: string;
-                    /** @enum {string|null} */
-                    send_action?: "queue" | "stop" | "follow_up" | null;
+                    /** @enum {string} */
+                    send_action: "steer" | "follow_up" | "stop";
                     created_by?: string | null;
                 };
             };