@continuous-excellence/ze-great-dashboard-aws 0.31.56 → 0.31.57

package/dist/cli.js

@@ -577,6 +577,12 @@ var testCountSchema = z4.discriminatedUnion("status", [
     type: z4.literal("test-count"),
     status: z4.literal("reported"),
     total: z4.number().int().nonnegative(),
+    /** Public identity for browser-local comparisons, never observation time. */
+    run: z4.object({
+      id: z4.string().min(1),
+      attempt: z4.number().int().positive(),
+      updatedAt: z4.iso.datetime()
+    }).optional(),
     passed: z4.number().int().nonnegative().optional(),
     failed: z4.number().int().nonnegative().optional(),
     skipped: z4.number().int().nonnegative().optional()
@@ -669,8 +675,29 @@ var securityDetailsResponseSchema = z5.strictObject({
   ])
 });
 
+// packages/shared/src/test-history.ts
+import { z as z6 } from "zod";
+var testHistorySampleSchema = z6.object({
+  id: z6.string().min(1),
+  attempt: z6.number().int().positive(),
+  updatedAt: z6.iso.datetime(),
+  total: z6.number().int().nonnegative()
+});
+var testHistorySchema = z6.object({
+  inspectedAt: z6.iso.datetime(),
+  inspectedRuns: z6.number().int().min(0).max(8),
+  complete: z6.boolean(),
+  samples: z6.array(testHistorySampleSchema).max(8),
+  retryAt: z6.iso.datetime().optional()
+});
+function retryAfterTime(value2, now) {
+  if (!value2) return void 0;
+  const at = /^\d+$/.test(value2) ? now + Number(value2) * 1e3 : Date.parse(value2);
+  return Number.isFinite(at) && at > now ? at : void 0;
+}
+
 // packages/server/src/adapters/github-actions.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // packages/server/src/credentials.ts
 function environmentCredentials(env = process.env) {
@@ -851,6 +878,9 @@ function base64url(value2) {
   return Buffer.from(value2).toString("base64url");
 }
 
+// packages/server/src/adapters/github-test-evidence.ts
+import { z as z8 } from "zod";
+
 // node_modules/fflate/esm/browser.js
 var u8 = Uint8Array;
 var u16 = Uint16Array;
@@ -1290,10 +1320,10 @@ function strFromU8(dat, latin1) {
     return s;
   }
 }
-var z64hs = function(d, b, l, z11, sc, su, off) {
+var z64hs = function(d, b, l, z13, sc, su, off) {
   var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
   var nf = nsc + nsu + noff;
-  if (z11 && nf) {
+  if (z13 && nf) {
     for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
       if (b2(d, b) == 1) {
         return [
@@ -1304,7 +1334,7 @@ var z64hs = function(d, b, l, z11, sc, su, off) {
         ];
       }
     }
-    if (z11 < 2)
+    if (z13 < 2)
       err(13);
   }
   return [sc, su, off, 0];
@@ -1468,18 +1498,18 @@ var Unzip = /* @__PURE__ */ (function() {
 })();
 
 // packages/server/src/workflow-artifact-summary.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var maxArtifactBytes = 64 * 1024;
-var testResultsSummarySchema = z6.object({
-  schemaVersion: z6.literal(1),
-  runId: z6.number().int().positive(),
-  runAttempt: z6.number().int().positive(),
-  headSha: z6.string().min(1),
-  total: z6.number().int().nonnegative(),
-  passed: z6.number().int().nonnegative().optional(),
-  failed: z6.number().int().nonnegative().optional(),
-  skipped: z6.number().int().nonnegative().optional(),
-  metadata: z6.record(z6.string(), z6.unknown()).optional()
+var testResultsSummarySchema = z7.object({
+  schemaVersion: z7.literal(1),
+  runId: z7.number().int().positive(),
+  runAttempt: z7.number().int().positive(),
+  headSha: z7.string().min(1),
+  total: z7.number().int().nonnegative(),
+  passed: z7.number().int().nonnegative().optional(),
+  failed: z7.number().int().nonnegative().optional(),
+  skipped: z7.number().int().nonnegative().optional(),
+  metadata: z7.record(z7.string(), z7.unknown()).optional()
 }).superRefine((summary, ctx) => {
   const outcomeTotal = (summary.passed ?? 0) + (summary.failed ?? 0) + (summary.skipped ?? 0);
   for (const key of ["passed", "failed", "skipped"]) {
@@ -1555,71 +1585,165 @@ function concat(chunks, length) {
   return result;
 }
 
+// packages/server/src/adapters/github-test-evidence.ts
+var artifactsSchema = z8.object({
+  artifacts: z8.array(
+    z8.object({ id: z8.number().int().positive(), name: z8.string().min(1), expired: z8.boolean() })
+  )
+});
+function testArtifactHttpFailure(response) {
+  const retry = retryAfterTime(response.headers.get("retry-after"), Date.now());
+  return {
+    kind: "failed",
+    observedAt: observedAt(response.headers.get("date")),
+    errorKind: upstreamErrorKind(response.status),
+    httpStatus: response.status,
+    ...retry === void 0 ? {} : { retryAt: new Date(retry).toISOString() }
+  };
+}
+async function inspectGithubTestArtifact(args2, selected, config) {
+  const { run: run2 } = selected;
+  let at = selected.observedAt;
+  const failed = (errorKind3) => ({
+    kind: "failed",
+    observedAt: at,
+    errorKind: errorKind3
+  });
+  const get = (url) => args2.githubClient.get({
+    source: args2.source,
+    fetcher: args2.fetcher,
+    url,
+    requestHeaders: new Headers()
+  });
+  const observe = (response) => {
+    const value2 = observedAt(response.headers.get("date"));
+    if (Date.parse(value2) < Date.parse(at)) at = value2;
+  };
+  try {
+    if (!run2.id) return failed("upstream-error");
+    if (run2.status !== "completed") return { kind: "pending", observedAt: at };
+    const url = new URL(
+      `https://api.github.com/repos/${args2.source.repo}/actions/runs/${run2.id}/artifacts`
+    );
+    url.searchParams.set("name", config.artifact);
+    url.searchParams.set("per_page", "100");
+    const artifacts = await get(url.toString());
+    if (!artifacts.ok) return testArtifactHttpFailure(artifacts);
+    observe(artifacts);
+    const matches = artifactsSchema.parse(await artifacts.json()).artifacts.filter((item) => item.name === config.artifact);
+    if (!matches.length) return { kind: "absent", observedAt: at };
+    const [artifact] = matches;
+    if (matches.length !== 1 || !artifact) return failed("upstream-error");
+    if (artifact.expired) return { kind: "expired", observedAt: at };
+    const archive = await get(
+      `https://api.github.com/repos/${args2.source.repo}/actions/artifacts/${artifact.id}/zip`
+    );
+    if (!archive.ok) return testArtifactHttpFailure(archive);
+    observe(archive);
+    const summary = testResultsSummarySchema.parse(
+      JSON.parse(await readTestResultsArtifact(archive, config.entry))
+    );
+    if (summary.runId !== run2.id || summary.runAttempt !== run2.run_attempt || summary.headSha !== run2.head_sha)
+      return failed("upstream-error");
+    const updatedAt = z8.iso.datetime().safeParse(run2.updated_at);
+    const tests = {
+      type: "test-count",
+      status: "reported",
+      total: summary.total,
+      ...updatedAt.success ? { run: { id: String(run2.id), attempt: summary.runAttempt, updatedAt: updatedAt.data } } : {},
+      ...summary.passed === void 0 ? {} : { passed: summary.passed },
+      ...summary.failed === void 0 ? {} : { failed: summary.failed },
+      ...summary.skipped === void 0 ? {} : { skipped: summary.skipped }
+    };
+    return { kind: "reported", observedAt: at, tests };
+  } catch (error) {
+    return failed(error instanceof GithubAuthenticationError ? "unauthorized" : "upstream-error");
+  }
+}
+function currentTestEvidence(inspection) {
+  const { observedAt: at } = inspection;
+  switch (inspection.kind) {
+    case "reported":
+      return { state: "ok", observedAt: at, signal: inspection.tests };
+    case "pending":
+      return { state: "ok", observedAt: at, signal: { type: "test-count", status: "pending" } };
+    case "absent":
+      return { state: "ok", observedAt: at, signal: { type: "test-count", status: "not-reported" } };
+    case "expired":
+      return {
+        state: "error",
+        observedAt: at,
+        error: { kind: "upstream-error", message: publicErrorMessage("upstream-error") }
+      };
+    case "failed":
+      return {
+        state: "error",
+        observedAt: at,
+        error: { kind: inspection.errorKind, message: publicErrorMessage(inspection.errorKind) }
+      };
+  }
+}
+
 // packages/server/src/adapters/github-actions.ts
-var pipelinePanelSchema = z7.object({
+var pipelinePanelSchema = z9.object({
   test_results: testResultsArtifactSchema.optional(),
-  id: z7.string().min(1),
-  type: z7.literal("pipeline-status"),
-  source: z7.string().min(1),
+  id: z9.string().min(1),
+  type: z9.literal("pipeline-status"),
+  source: z9.string().min(1),
   /** GitHub accepts a workflow filename or numeric workflow id in this URL segment. */
-  pipeline: z7.string().min(1)
+  pipeline: z9.string().min(1)
 });
-var pullRequestHealthPanelSchema = z7.object({
-  id: z7.string().min(1),
-  type: z7.literal("pull-request-health"),
-  source: z7.string().min(1),
-  base_branch: z7.string().min(1),
-  update_workflows: z7.array(
-    z7.object({
-      workflow: z7.string().min(1),
-      branch_prefixes: z7.array(z7.string().min(1)).min(1)
+var pullRequestHealthPanelSchema = z9.object({
+  id: z9.string().min(1),
+  type: z9.literal("pull-request-health"),
+  source: z9.string().min(1),
+  base_branch: z9.string().min(1),
+  update_workflows: z9.array(
+    z9.object({
+      workflow: z9.string().min(1),
+      branch_prefixes: z9.array(z9.string().min(1)).min(1)
     })
   ).min(1),
-  build_workflow: z7.string().min(1),
+  build_workflow: z9.string().min(1),
   build_events: githubActionsBuildEventsSchema.optional()
 });
-var runSchema = z7.object({
-  id: z7.number().int().positive().optional(),
-  run_attempt: z7.number().int().positive().optional(),
-  head_sha: z7.string().min(1).optional(),
-  status: z7.string(),
-  conclusion: z7.string().nullable(),
-  name: z7.string().min(1),
-  html_url: z7.url(),
+var runSchema = z9.object({
+  id: z9.number().int().positive().optional(),
+  run_attempt: z9.number().int().positive().optional(),
+  head_sha: z9.string().min(1).optional(),
+  status: z9.string(),
+  conclusion: z9.string().nullable(),
+  name: z9.string().min(1),
+  html_url: z9.url(),
   /** The GitHub Actions trigger that started this run. */
-  event: z7.string().min(1).optional(),
+  event: z9.string().min(1).optional(),
   /** The branch that produced this run; absent for some event types. */
-  head_branch: z7.string().min(1).nullable().optional(),
+  head_branch: z9.string().min(1).nullable().optional(),
   // Timestamp quality should only remove timing advice, never make an otherwise useful run unreadable.
-  run_started_at: z7.string().nullable().optional(),
-  updated_at: z7.string().optional(),
-  created_at: z7.string().optional()
+  run_started_at: z9.string().nullable().optional(),
+  updated_at: z9.string().optional(),
+  created_at: z9.string().optional()
 });
-var artifactsSchema = z7.object({
-  artifacts: z7.array(
-    z7.object({ id: z7.number().int().positive(), name: z7.string().min(1), expired: z7.boolean() })
-  )
-});
-var runsSchema = z7.object({ workflow_runs: z7.array(runSchema) });
-var jobsSchema = z7.object({
-  jobs: z7.array(
-    z7.object({
-      name: z7.string().min(1),
-      status: z7.string(),
-      steps: z7.array(z7.object({ name: z7.string().min(1), status: z7.string() })).optional()
+var runsSchema = z9.object({ workflow_runs: z9.array(runSchema) });
+var jobsSchema = z9.object({
+  jobs: z9.array(
+    z9.object({
+      name: z9.string().min(1),
+      status: z9.string(),
+      steps: z9.array(z9.object({ name: z9.string().min(1), status: z9.string() })).optional()
     })
   )
 });
-var pullRequestsSchema = z7.array(
-  z7.object({
-    number: z7.number().int().positive(),
-    html_url: z7.url(),
-    head: z7.object({ ref: z7.string().min(1) }),
-    base: z7.object({ ref: z7.string().min(1) })
+var pullRequestsSchema = z9.array(
+  z9.object({
+    number: z9.number().int().positive(),
+    html_url: z9.url(),
+    head: z9.object({ ref: z9.string().min(1) }),
+    base: z9.object({ ref: z9.string().min(1) })
   })
 );
 function permittedGithubActionsCalls(panel, source, _credentials) {
-  const { panel: parsedPanel, source: parsedSource } = z7.object({ panel: pipelinePanelSchema, source: githubActionsSourceSchema }).parse({ panel, source });
+  const { panel: parsedPanel, source: parsedSource } = z9.object({ panel: pipelinePanelSchema, source: githubActionsSourceSchema }).parse({ panel, source });
   const url = new URL(
     `https://api.github.com/repos/${parsedSource.repo}/actions/workflows/${encodeURIComponent(parsedPanel.pipeline)}/runs`
   );
@@ -1628,7 +1752,7 @@ function permittedGithubActionsCalls(panel, source, _credentials) {
   return [{ url: url.toString(), headers: new Headers() }];
 }
 function testCountCapabilities(panel, source) {
-  return z7.object({ panel: testCountPanelSchema, source: githubActionsSourceSchema }).parse({ panel, source });
+  return z9.object({ panel: testCountPanelSchema, source: githubActionsSourceSchema }).parse({ panel, source });
 }
 async function fetchGithubActionsTestCount(args2) {
   const { panel, source } = testCountCapabilities(args2.panel, args2.source);
@@ -1646,13 +1770,15 @@ async function fetchGithubActionsTestCount(args2) {
       return testCountEnvelope(
         noRunEnvelope(panel.id, source, panel.pipeline, selected.response.headers.get("date"))
       );
-    const evidence = await readGithubRunTestEvidence(
-      { ...args2, source, githubClient },
-      {
-        run: selected.run,
-        observedAt: selected.observedAt
-      },
-      panel.test_results
+    const evidence = currentTestEvidence(
+      await inspectGithubTestArtifact(
+        { ...args2, source, githubClient },
+        {
+          run: selected.run,
+          observedAt: selected.observedAt
+        },
+        panel.test_results
+      )
     );
     return testCountEnvelope({ ...evidence, panelId: panel.id, link: selected.run.html_url });
   } catch (error) {
@@ -1666,82 +1792,8 @@ async function fetchGithubActionsTestCount(args2) {
     );
   }
 }
-async function readGithubRunTestEvidence(args2, selected, artifactConfig) {
-  const { run: run2, observedAt: runObservedAt } = selected;
-  const { source, githubClient } = args2;
-  const noValidators = new Headers();
-  let failureObservedAt = runObservedAt;
-  const evidenceError = (kind, at = failureObservedAt) => ({
-    state: "error",
-    observedAt: at,
-    error: { kind, message: publicErrorMessage(kind) }
-  });
-  const failedResponse = (response) => evidenceError(errorKind(response.status), observedAt2(response.headers.get("date")));
-  try {
-    if (!run2.id) return evidenceError("upstream-error");
-    if (run2.status !== "completed")
-      return {
-        state: "ok",
-        observedAt: runObservedAt,
-        signal: { type: "test-count", status: "pending" }
-      };
-    const artifactsResponse = await githubFetch(
-      githubArtifactsCall(source, run2.id, artifactConfig),
-      {
-        ...args2,
-        source,
-        requestHeaders: noValidators,
-        githubClient
-      }
-    );
-    if (!artifactsResponse.ok) return failedResponse(artifactsResponse);
-    const artifactObservedAt = observedAt2(artifactsResponse.headers.get("date"));
-    failureObservedAt = oldestObservation(runObservedAt, artifactObservedAt);
-    const artifacts = artifactsSchema.parse(await artifactsResponse.json()).artifacts;
-    const matches = artifacts.filter((artifact2) => artifact2.name === artifactConfig.artifact);
-    if (matches.length === 0)
-      return {
-        state: "ok",
-        observedAt: oldestObservation(runObservedAt, artifactObservedAt),
-        signal: { type: "test-count", status: "not-reported" }
-      };
-    const [artifact] = matches;
-    if (matches.length !== 1 || !artifact || artifact.expired)
-      return evidenceError("upstream-error");
-    const archiveResponse = await githubFetch(githubArtifactDownloadCall(source, artifact.id), {
-      ...args2,
-      source,
-      requestHeaders: noValidators,
-      githubClient
-    });
-    if (!archiveResponse.ok) return failedResponse(archiveResponse);
-    const archiveObservedAt = observedAt2(archiveResponse.headers.get("date"));
-    failureObservedAt = oldestObservation(runObservedAt, artifactObservedAt, archiveObservedAt);
-    const summary = testResultsSummarySchema.parse(
-      JSON.parse(await readTestResultsArtifact(archiveResponse, artifactConfig.entry))
-    );
-    if (summary.runId !== run2.id || summary.runAttempt !== run2.run_attempt || summary.headSha !== run2.head_sha)
-      throw new Error("Test-results manifest does not belong to the selected workflow run.");
-    return {
-      state: "ok",
-      observedAt: oldestObservation(runObservedAt, artifactObservedAt, archiveObservedAt),
-      signal: {
-        type: "test-count",
-        status: "reported",
-        total: summary.total,
-        ...summary.passed === void 0 ? {} : { passed: summary.passed },
-        ...summary.failed === void 0 ? {} : { failed: summary.failed },
-        ...summary.skipped === void 0 ? {} : { skipped: summary.skipped }
-      }
-    };
-  } catch (error) {
-    return evidenceError(
-      error instanceof GithubAuthenticationError ? "unauthorized" : "upstream-error"
-    );
-  }
-}
 function pullRequestHealthCapabilities(panel) {
-  const { panel: parsed } = z7.object({ panel: pullRequestHealthPanelSchema }).parse({ panel });
+  const { panel: parsed } = z9.object({ panel: pullRequestHealthPanelSchema }).parse({ panel });
   return {
     panel: parsed,
     configuredUpdateWorkflow(workflow) {
@@ -1843,10 +1895,12 @@ async function fetchGithubActionsPipeline(args2) {
       if (activity) signal.activity = activity;
     }
     if (parsedPanel.test_results) {
-      signal.testResults = await readGithubRunTestEvidence(
-        { ...args2, source: parsedSource, githubClient },
-        { run: run2, observedAt: selected.observedAt },
-        parsedPanel.test_results
+      signal.testResults = currentTestEvidence(
+        await inspectGithubTestArtifact(
+          { ...args2, source: parsedSource, githubClient },
+          { run: run2, observedAt: selected.observedAt },
+          parsedPanel.test_results
+        )
       );
     }
     const envelope = {
@@ -1965,18 +2019,6 @@ function githubJobsCall(source, runId) {
   url.searchParams.set("per_page", "100");
   return { url: url.toString(), headers: new Headers() };
 }
-function githubArtifactsCall(source, runId, testResults) {
-  const url = new URL(`https://api.github.com/repos/${source.repo}/actions/runs/${runId}/artifacts`);
-  url.searchParams.set("name", testResults.artifact);
-  url.searchParams.set("per_page", "100");
-  return { url: url.toString(), headers: new Headers() };
-}
-function githubArtifactDownloadCall(source, artifactId) {
-  return {
-    url: `https://api.github.com/repos/${source.repo}/actions/artifacts/${artifactId}/zip`,
-    headers: new Headers()
-  };
-}
 function noRunEnvelope(panelId, source, pipeline, date) {
   return {
     panelId,
@@ -2015,7 +2057,7 @@ function completedRunDuration(run2) {
   return Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs } : {};
 }
 function timestamp(value2) {
-  if (!value2 || !z7.iso.datetime().safeParse(value2).success) return void 0;
+  if (!value2 || !z9.iso.datetime().safeParse(value2).success) return void 0;
   return Number.isFinite(new Date(value2).valueOf()) ? value2 : void 0;
 }
 function normalizeStatus(status, conclusion) {
@@ -2032,7 +2074,7 @@ function errorEnvelope(panelId, kind, error, link, observedAt4 = (/* @__PURE__ *
   return upstreamErrorEnvelope({ panelId, kind, error, link, upstreamDate: observedAt4 });
 }
 function sourceLink(panel, source) {
-  const parsedPanel = z7.object({ pipeline: z7.string().min(1) }).parse(panel);
+  const parsedPanel = z9.object({ pipeline: z9.string().min(1) }).parse(panel);
   const parsedSource = githubActionsSourceSchema.parse(source);
   return sourceLinkForWorkflow(parsedSource, parsedPanel.pipeline);
 }
@@ -2042,6 +2084,81 @@ function sourceLinkForWorkflow(source, pipeline) {
 function observedAt2(value2) {
   return observedAt(value2);
 }
+async function fetchGithubTestHistory(args2) {
+  const source = githubActionsSourceSchema.parse(args2.source);
+  const fetcher = (input, init) => args2.fetcher(input, { ...init, ...args2.signal ? { signal: args2.signal } : {} });
+  const artifact = testResultsArtifactSchema.parse(args2.panel.test_results);
+  const workflow = z9.string().min(1).parse(args2.panel.pipeline);
+  const now = Date.now();
+  const cutoff = now - 14 * 864e5;
+  const history = {
+    inspectedAt: new Date(now).toISOString(),
+    inspectedRuns: 0,
+    complete: true,
+    samples: []
+  };
+  let stop = false;
+  const recordFailure = (failure2) => {
+    history.complete = false;
+    if (failure2.errorKind === "unauthorized" || failure2.httpStatus === 429) stop = true;
+    if (failure2.retryAt && (!history.retryAt || Date.parse(failure2.retryAt) > Date.parse(history.retryAt)))
+      history.retryAt = failure2.retryAt;
+  };
+  try {
+    const call = githubRunsCall(
+      source,
+      workflow,
+      source.branch,
+      void 0,
+      8,
+      new Date(cutoff).toISOString()
+    );
+    const url = new URL(call.url);
+    url.searchParams.set("status", "completed");
+    const response = await githubFetch(
+      { ...call, url: url.toString() },
+      { ...args2, fetcher, source, requestHeaders: new Headers() }
+    );
+    if (!response.ok) recordFailure(testArtifactHttpFailure(response));
+    else {
+      const runs = runsSchema.parse(await response.json()).workflow_runs.slice(0, 8);
+      for (const run2 of runs) {
+        if (stop || args2.signal?.aborted) {
+          history.complete = false;
+          break;
+        }
+        if (run2.status !== "completed") continue;
+        if (run2.updated_at && Date.parse(run2.updated_at) < cutoff) continue;
+        history.inspectedRuns++;
+        const inspection = await inspectGithubTestArtifact(
+          { ...args2, fetcher, source },
+          { run: run2, observedAt: observedAt2(response.headers.get("date")) },
+          artifact
+        );
+        switch (inspection.kind) {
+          case "failed":
+            recordFailure(inspection);
+            break;
+          case "reported": {
+            const { run: identity, total } = inspection.tests;
+            if (identity) history.samples.push({ ...identity, total });
+            else history.complete = false;
+            break;
+          }
+          case "absent":
+          case "expired":
+            break;
+          case "pending":
+            history.complete = false;
+            break;
+        }
+      }
+    }
+  } catch {
+    history.complete = false;
+  }
+  return Response.json(history, { headers: { "cache-control": "no-store" } });
+}
 
 // packages/server/src/configuration-error.ts
 var ConfigurationError = class extends Error {
@@ -2095,37 +2212,37 @@ function correctiveConstraint(issue) {
 
 // packages/server/src/adapters/azure-devops.ts
 import { readFile } from "node:fs/promises";
-import { z as z8 } from "zod";
-var pipelinePanelSchema2 = z8.object({
-  id: z8.string().min(1),
-  type: z8.literal("pipeline-status"),
-  source: z8.string().min(1),
-  pipeline: z8.number().int().positive()
+import { z as z10 } from "zod";
+var pipelinePanelSchema2 = z10.object({
+  id: z10.string().min(1),
+  type: z10.literal("pipeline-status"),
+  source: z10.string().min(1),
+  pipeline: z10.number().int().positive()
 });
-var buildSchema = z8.object({
-  id: z8.number().int().positive(),
-  buildNumber: z8.string().min(1),
-  status: z8.string().nullable().optional(),
-  result: z8.string().nullable().optional(),
-  sourceBranch: z8.string().min(1).nullable().optional(),
-  startTime: z8.string().nullable().optional(),
-  finishTime: z8.string().nullable().optional(),
-  lastChangedDate: z8.string().nullable().optional()
+var buildSchema = z10.object({
+  id: z10.number().int().positive(),
+  buildNumber: z10.string().min(1),
+  status: z10.string().nullable().optional(),
+  result: z10.string().nullable().optional(),
+  sourceBranch: z10.string().min(1).nullable().optional(),
+  startTime: z10.string().nullable().optional(),
+  finishTime: z10.string().nullable().optional(),
+  lastChangedDate: z10.string().nullable().optional()
 });
-var buildsSchema = z8.object({ value: z8.array(buildSchema) });
-var timelineSchema = z8.object({
-  records: z8.array(
-    z8.object({
-      id: z8.string().min(1),
-      parentId: z8.string().min(1).nullable().optional(),
-      type: z8.string().min(1),
-      name: z8.string().min(1),
-      state: z8.string().nullable().optional()
+var buildsSchema = z10.object({ value: z10.array(buildSchema) });
+var timelineSchema = z10.object({
+  records: z10.array(
+    z10.object({
+      id: z10.string().min(1),
+      parentId: z10.string().min(1).nullable().optional(),
+      type: z10.string().min(1),
+      name: z10.string().min(1),
+      state: z10.string().nullable().optional()
     })
   )
 });
 function permittedAzureDevOpsCalls(panel, source) {
-  const { panel: parsedPanel, source: parsedSource } = z8.object({ panel: pipelinePanelSchema2, source: azureDevOpsSourceSchema }).parse({ panel, source });
+  const { panel: parsedPanel, source: parsedSource } = z10.object({ panel: pipelinePanelSchema2, source: azureDevOpsSourceSchema }).parse({ panel, source });
   return [buildsCall(parsedPanel.pipeline, parsedSource)];
 }
 async function fetchAzureDevOpsPipeline(args2) {
@@ -2238,9 +2355,9 @@ async function fetchAzureDevOpsPipeline(args2) {
     };
   }
 }
-var delegatedTokenFileSchema = z8.object({
-  accessToken: z8.string().min(1),
-  expiresAt: z8.string().min(1)
+var delegatedTokenFileSchema = z10.object({
+  accessToken: z10.string().min(1),
+  expiresAt: z10.string().min(1)
 });
 async function azureDevOpsAuthorization(source, credentials) {
   if (source.token_env) {
@@ -2321,7 +2438,7 @@ function completedBuildDuration(build) {
   return Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs } : {};
 }
 function timestamp2(value2) {
-  if (!value2 || !z8.iso.datetime().safeParse(value2).success) return void 0;
+  if (!value2 || !z10.iso.datetime().safeParse(value2).success) return void 0;
   return Number.isFinite(new Date(value2).valueOf()) ? value2 : void 0;
 }
 function copyValidators(requestHeaders, upstreamHeaders) {
@@ -2347,23 +2464,23 @@ function observedAt3(value2) {
 }
 
 // packages/server/src/adapters/gitlab-ci.ts
-import { z as z9 } from "zod";
-var pipelinePanelSchema3 = z9.object({
-  id: z9.string().min(1),
-  type: z9.literal("pipeline-status"),
-  source: z9.string().min(1)
+import { z as z11 } from "zod";
+var pipelinePanelSchema3 = z11.object({
+  id: z11.string().min(1),
+  type: z11.literal("pipeline-status"),
+  source: z11.string().min(1)
 });
-var pipelineSchema = z9.object({
-  id: z9.number().int().positive(),
-  name: z9.string().min(1).nullable().optional(),
-  status: z9.string(),
-  ref: z9.string().min(1).nullable().optional(),
-  created_at: z9.string().nullable().optional(),
-  updated_at: z9.string().nullable().optional(),
-  web_url: z9.url()
+var pipelineSchema = z11.object({
+  id: z11.number().int().positive(),
+  name: z11.string().min(1).nullable().optional(),
+  status: z11.string(),
+  ref: z11.string().min(1).nullable().optional(),
+  created_at: z11.string().nullable().optional(),
+  updated_at: z11.string().nullable().optional(),
+  web_url: z11.url()
 });
 function permittedGitlabCiCalls(panel, source) {
-  const { source: parsedSource } = z9.object({ panel: pipelinePanelSchema3, source: gitlabCiSourceSchema }).parse({ panel, source });
+  const { source: parsedSource } = z11.object({ panel: pipelinePanelSchema3, source: gitlabCiSourceSchema }).parse({ panel, source });
   return [pipelinesCall(parsedSource)];
 }
 async function fetchGitlabCiPipeline(args2) {
@@ -2402,7 +2519,7 @@ async function fetchGitlabCiPipeline(args2) {
     );
   }
   try {
-    const pipeline = z9.array(pipelineSchema).parse(await upstream.json())[0];
+    const pipeline = z11.array(pipelineSchema).parse(await upstream.json())[0];
     if (!pipeline) {
       const detail = source.branch ? `No pipelines found for ref "${source.branch}". Check the source's branch setting.` : "No pipelines found.";
       return failure(
@@ -2468,7 +2585,7 @@ function normalizeStatus3(status) {
   return "unknown";
 }
 function timestamp3(value2) {
-  if (!value2 || !z9.iso.datetime().safeParse(value2).success) return void 0;
+  if (!value2 || !z11.iso.datetime().safeParse(value2).success) return void 0;
   return Number.isFinite(new Date(value2).valueOf()) ? value2 : void 0;
 }
 function failure(panelId, kind, error, link, date, failure2) {
@@ -2481,10 +2598,10 @@ function failure(panelId, kind, error, link, date, failure2) {
 }
 
 // packages/server/src/adapters/http-value.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 function permittedHttpValueCalls(panel) {
   const grouped = httpValueGroupedPanelSchema.safeParse(panel);
-  const urls = grouped.success ? grouped.data.facts.map((fact) => fact.url) : [z10.object({ panel: httpValueScalarPanelSchema }).parse({ panel }).panel.url];
+  const urls = grouped.success ? grouped.data.facts.map((fact) => fact.url) : [z12.object({ panel: httpValueScalarPanelSchema }).parse({ panel }).panel.url];
   return urls.map(permittedCall);
 }
 async function fetchHttpValue(args2) {
@@ -2583,6 +2700,9 @@ function readPanelAdapter(panel, source) {
   if (panel.type === "pipeline-status" && source?.type === "github-actions") {
     permittedGithubActionsCalls(panel, source);
     return {
+      ...panel.test_results ? {
+        testHistory: ({ source: _source, ...args2 }) => fetchGithubTestHistory({ ...args2, source })
+      } : {},
       destination: () => "https://api.github.com",
       fetch: ({ source: _configuredSource, ...args2 }) => fetchGithubActionsPipeline({ ...args2, source })
     };
@@ -2590,6 +2710,9 @@ function readPanelAdapter(panel, source) {
   if (panel.type === "test-count" && source?.type === "github-actions") {
     testCountCapabilities(panel, source);
     return {
+      ...panel.test_results ? {
+        testHistory: ({ source: _source, ...args2 }) => fetchGithubTestHistory({ ...args2, source })
+      } : {},
       destination: () => "https://api.github.com",
       fetch: ({ source: _configuredSource, ...args2 }) => fetchGithubActionsTestCount({ ...args2, source })
     };
@@ -2668,7 +2791,9 @@ function derive(config, rejectUnsupported) {
   return allowed;
 }
 function panelCapability(panel, source) {
-  if (readPanelAdapter(panel, source)) return { kind: "server", operations: ["read"] };
+  const adapter = readPanelAdapter(panel, source);
+  if (adapter)
+    return { kind: "server", operations: adapter.testHistory ? ["read", "test-history"] : ["read"] };
   if (panel.type === "pull-request-health" && source?.type === "github-actions") {
     pullRequestHealthCapabilities(panel);
     return {