Render run list miniatures from compact per-stage route evidence
This commit is contained in:
+14
-7
@@ -10,6 +10,8 @@ const NS = "http://www.w3.org/2000/svg";
|
||||
const STATUSES = new Set(["succeeded", "failed", "running", "waiting", "queued",
|
||||
"interrupted", "canceled", "blocked", "skipped"]);
|
||||
export function miniatureColor(status) {
|
||||
if (status === "waiting") return "var(--warn)";
|
||||
if (status === "running") return "var(--accent)";
|
||||
return `var(--status-${STATUSES.has(status) ? status : "unknown"})`;
|
||||
}
|
||||
|
||||
@@ -20,20 +22,22 @@ export function miniatureModel(graph, run = null) {
|
||||
edges: Object.fromEntries(Object.entries(stage.edges ?? {}).filter(([, target]) => keys.has(target))),
|
||||
})) };
|
||||
const layout = layoutGraph(shape, METRICS);
|
||||
const evidence = run && Array.isArray(run.steps) ? runGraphState(run) : null;
|
||||
const visits = new Map((run?.steps ?? []).map((step) => [step.stage, step]));
|
||||
const steps = Array.isArray(run?.steps) ? run.steps : run?.graph_evidence?.visits;
|
||||
const evidence = Array.isArray(steps) ? runGraphState({ ...run, steps }) : null;
|
||||
const visits = new Map((steps ?? []).map((step) => [step.stage, step]));
|
||||
return { ...layout, evidence: evidence != null,
|
||||
complete: Array.isArray(run?.steps) || run?.graph_evidence?.complete === true,
|
||||
nodes: layout.nodes.map((node) => {
|
||||
const step = visits.get(node.key);
|
||||
// A recorded current stage is evidence even in a compact list summary.
|
||||
const current = run?.executing && run.current_stage === node.key;
|
||||
const status = current ? run.status : step?.status;
|
||||
const status = step?.status ?? (current ? run.status : null);
|
||||
const color = status === "completed" ? edgeStrokeColor(step.outcome) : status ? miniatureColor(status) : null;
|
||||
return { ...node, color,
|
||||
untaken: evidence != null && !step && !current };
|
||||
untaken: Boolean(run) && !step && !current };
|
||||
}),
|
||||
edges: layout.edges.map((edge) => ({ ...edge,
|
||||
untaken: evidence != null && !edgeIsExecuted(edge, evidence),
|
||||
untaken: Boolean(run) && (!evidence || !edgeIsExecuted(edge, evidence)),
|
||||
color: evidence && edgeIsExecuted(edge, evidence) ? edgeStrokeColor(edge.outcome) : null,
|
||||
})),
|
||||
};
|
||||
@@ -53,6 +57,7 @@ export function renderMiniGraph(graph, run = null) {
|
||||
if (edge.points.length < 2) continue;
|
||||
const line = document.createElementNS(NS, "polyline");
|
||||
line.setAttribute("class", `pipeline-mini-edge${edge.untaken ? " mini-untaken" : ""}`);
|
||||
line.setAttribute("data-route", `${edge.source}:${edge.outcome}:${edge.target}`);
|
||||
line.setAttribute("points", edge.points.map((p) => `${p.x},${p.y}`).join(" "));
|
||||
if (edge.color) line.style.color = edge.color;
|
||||
svg.append(line);
|
||||
@@ -60,14 +65,16 @@ export function renderMiniGraph(graph, run = null) {
|
||||
for (const node of model.nodes) {
|
||||
const rect = document.createElementNS(NS, "rect");
|
||||
rect.setAttribute("class", `pipeline-mini-node${node.untaken ? " mini-untaken" : ""}`);
|
||||
rect.setAttribute("data-stage", node.key);
|
||||
for (const key of ["x", "y", "width", "height"]) rect.setAttribute(key, String(node[key]));
|
||||
rect.setAttribute("rx", "3");
|
||||
if (node.color) rect.style.color = node.color;
|
||||
svg.append(rect);
|
||||
}
|
||||
const wrap = h("span", { class: `pipeline-mini${run ? " run-mini" : ""}`,
|
||||
"aria-hidden": "true", "data-evidence": model.evidence ? "visits" : "summary" }, svg);
|
||||
if (run) wrap.style.color = miniatureColor(run.status);
|
||||
"aria-hidden": "true", "data-evidence": model.evidence ? model.complete ? "visits" : "partial" : "unknown" }, svg);
|
||||
// Unknown/unvisited graph elements must never inherit the aggregate result.
|
||||
if (run) wrap.style.color = "var(--color-muted)";
|
||||
return wrap;
|
||||
}
|
||||
|
||||
|
||||
+32
-1
@@ -215,7 +215,10 @@ function applyRunStateFields(current, frame) {
|
||||
cancel_requested: before.cancel_requested || frame.cancel_requested === true,
|
||||
cleanup_unconfirmed: before.cleanup_unconfirmed || frame.cleanup_unconfirmed === true,
|
||||
};
|
||||
// Detail already maintains full visits below; compact evidence is list-only.
|
||||
const graphEvidence = Array.isArray(current.steps) ? current.graph_evidence : mergeGraphEvidence(current.graph_evidence, frame);
|
||||
const changed =
|
||||
graphEvidence !== current.graph_evidence ||
|
||||
merged.notify_mode !== before.notify_mode ||
|
||||
!sameResourceWait(merged.resource_wait, before.resource_wait) ||
|
||||
merged.status !== before.status ||
|
||||
@@ -227,7 +230,33 @@ function applyRunStateFields(current, frame) {
|
||||
merged.executing !== before.executing ||
|
||||
merged.cancel_requested !== before.cancel_requested ||
|
||||
merged.cleanup_unconfirmed !== before.cleanup_unconfirmed;
|
||||
return changed ? { ...current, ...merged } : current;
|
||||
return changed ? { ...current, ...merged, ...(graphEvidence ? { graph_evidence: graphEvidence } : {}) } : current;
|
||||
}
|
||||
|
||||
// Reuse the detail's monotonic visit merge, then compact by last stage visit and
|
||||
// distinct route. Keep completeness separate: a delta from an older server or
|
||||
// a mid-run first frame cannot prove that earlier stages were never visited.
|
||||
function mergeGraphEvidence(current, frame) {
|
||||
if (!frame.graph_evidence && !frame.graph_visits?.length && !frame.step) return current;
|
||||
let visits = current?.visits ?? [];
|
||||
const incoming = [...(frame.graph_evidence?.visits ?? []), ...(frame.graph_visits ?? []),
|
||||
...(frame.step ? [frame.step] : [])];
|
||||
for (const step of incoming) {
|
||||
const { sequence, stage, status, outcome, target } = step;
|
||||
visits = upsertStep(visits, { sequence, stage, status, outcome, target });
|
||||
}
|
||||
const latest = new Map();
|
||||
const routes = new Map();
|
||||
for (const visit of visits) {
|
||||
latest.set(visit.stage, visit.sequence);
|
||||
if (visit.outcome && visit.target) routes.set(JSON.stringify([visit.stage, visit.outcome, visit.target]), visit.sequence);
|
||||
}
|
||||
visits = visits.filter((visit) => latest.get(visit.stage) === visit.sequence ||
|
||||
(visit.outcome && visit.target && routes.get(JSON.stringify([visit.stage, visit.outcome, visit.target])) === visit.sequence));
|
||||
// Explicit allowlist: graph evidence never copies diagnostic/private fields.
|
||||
visits = visits.map(({ sequence, stage, status, outcome, target }) => ({ sequence, stage, status, outcome, target }));
|
||||
const result = { complete: Boolean(current?.complete || frame.graph_evidence?.complete), visits };
|
||||
return JSON.stringify(result) === JSON.stringify(current) ? current : result;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -240,7 +269,9 @@ export function newRunSummaryFromFrame(frame) {
|
||||
const pipelineId = Number(frame?.pipeline_id);
|
||||
const name = String(frame?.name ?? "");
|
||||
if (!(pipelineId > 0) || blank(name)) return null;
|
||||
const graphEvidence = mergeGraphEvidence(null, frame);
|
||||
return {
|
||||
...(graphEvidence ? { graph_evidence: graphEvidence } : {}),
|
||||
resource_wait: frame.resource_wait ?? null,
|
||||
id: Number(frame.run_id),
|
||||
pipeline_id: pipelineId,
|
||||
|
||||
Reference in New Issue
Block a user