@gobing-ai/knowledge-kit 0.0.34 → 0.0.36

package/dist/board/collect/index.js

@@ -0,0 +1,787 @@
+// ../board/src/collect/index.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// ../board/src/shared/api.ts
+var DEFAULT_READER_ORIGIN = "http://127.0.0.1:4340";
+function readerOriginFrom(search) {
+  const override = new URLSearchParams(search).get("kkApi");
+  if (override === null)
+    return { origin: DEFAULT_READER_ORIGIN, diagnostic: null };
+  if (isLoopbackHttpOrigin(override))
+    return { origin: override, diagnostic: null };
+  return {
+    origin: DEFAULT_READER_ORIGIN,
+    diagnostic: {
+      code: "board.reader.origin-invalid",
+      message: "Ignored a non-loopback kkApi origin; using the default reader."
+    }
+  };
+}
+function isLoopbackHttpOrigin(origin) {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:")
+    return false;
+  if (url.username !== "" || url.password !== "")
+    return false;
+  if (url.pathname !== "/" || url.search !== "" || url.hash !== "")
+    return false;
+  return url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]";
+}
+function origin(base) {
+  return base.replace(/\/+$/, "");
+}
+function createBoardClient(options) {
+  if (!isLoopbackHttpOrigin(options.readerOrigin)) {
+    throw new Error(`reader origin must be loopback http, got '${options.readerOrigin}'`);
+  }
+  if (!isLoopbackHttpOrigin(options.boardOrigin)) {
+    throw new Error(`board origin must be loopback http, got '${options.boardOrigin}'`);
+  }
+  const reader = origin(options.readerOrigin);
+  const board = origin(options.boardOrigin);
+  const doFetch = options.fetchImpl ?? fetch;
+  async function getJson(url) {
+    const response = await doFetch(url, { headers: { accept: "application/json" } });
+    if (!response.ok) {
+      throw new Error(`request failed (${response.status}): ${url}`);
+    }
+    return await response.json();
+  }
+  return {
+    health: () => getJson(`${reader}/api/health`),
+    results: (workflow, runId) => getJson(`${reader}/api/workflows/${encodeURIComponent(workflow)}/runs/${encodeURIComponent(runId)}/results`),
+    config: (workflow, runId) => getJson(`${reader}/api/workflows/${encodeURIComponent(workflow)}/runs/${encodeURIComponent(runId)}/config`),
+    artifactUrl: (workflow, runId, artifactId) => `${reader}/api/workflows/${encodeURIComponent(workflow)}/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}`,
+    runs: (workflow, cursor) => {
+      const params = new URLSearchParams({ workflow, limit: "25" });
+      if (cursor !== undefined)
+        params.set("cursor", cursor);
+      return getJson(`${board}/api/runs?${params.toString()}`);
+    },
+    runDetail: (runId) => getJson(`${board}/api/runs/${encodeURIComponent(runId)}`),
+    progress: (runId) => getJson(`${board}/api/runs/${encodeURIComponent(runId)}/progress`)
+  };
+}
+
+// ../board/src/shared/format.ts
+function availabilityLabel(availability) {
+  switch (availability) {
+    case "available":
+      return "Available";
+    case "pending":
+      return "Not yet written";
+    case "missing":
+      return "Missing";
+    case "invalid":
+      return "Malformed";
+    case "oversized":
+      return "Too large to preview";
+    case "superseded":
+      return "Superseded by a later run";
+    case "unverified":
+      return "Unverified";
+  }
+}
+function diagnosticLine(diagnostic) {
+  return `${diagnostic.code}: ${diagnostic.message}`;
+}
+function formatElapsed(startedAt, now) {
+  if (startedAt === null || startedAt === undefined)
+    return "elapsed unknown";
+  const start = Date.parse(startedAt);
+  if (Number.isNaN(start))
+    return "elapsed unknown";
+  const seconds = Math.max(0, Math.round((now - start) / 1000));
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function dedupeDiagnostics(diagnostics) {
+  const seen = new Set;
+  return diagnostics.filter((diagnostic) => {
+    if (seen.has(diagnostic.code))
+      return false;
+    seen.add(diagnostic.code);
+    return true;
+  });
+}
+function formatTimestamp(iso) {
+  if (iso === null || iso === undefined)
+    return "time unknown";
+  const epoch = Date.parse(iso);
+  if (Number.isNaN(epoch))
+    return "time unknown";
+  return `${new Date(epoch).toLocaleString()} (${new Date(epoch).toISOString()})`;
+}
+
+// ../board/src/shared/collect.ts
+function asCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asText(value) {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function collectSummary(results) {
+  const raw = results.summary ?? {};
+  const sources = raw.sourceCounts;
+  const sourceCounts = typeof sources === "object" && sources !== null && !Array.isArray(sources) ? sources : null;
+  return {
+    status: asText(raw.status),
+    startedAt: asText(raw.startedAt),
+    completedAt: asText(raw.completedAt),
+    sourceCounts,
+    inserted: asCount(raw.inserted),
+    updated: asCount(raw.updated),
+    unchanged: asCount(raw.unchanged),
+    labeled: asCount(raw.labeled),
+    model: asCount(raw.model),
+    fallback: asCount(raw.fallback),
+    verdict: asText(raw.verdict),
+    confidence: asText(raw.confidence),
+    factsPreview: asText(raw.factsPreview)
+  };
+}
+function count(value) {
+  return value === null ? "unavailable" : String(value);
+}
+function collectSummaryFacts(results, now) {
+  const summary = collectSummary(results);
+  const available = results.artifacts.filter((artifact) => artifact.availability === "available").length;
+  const facts = [
+    {
+      label: "Execution status",
+      value: summary.status ?? "unavailable",
+      availability: summary.status === null ? "unverified" : "available"
+    },
+    {
+      label: "Result availability",
+      value: `${available}/${results.artifacts.length} artifacts available`,
+      availability: results.availability
+    },
+    {
+      label: "Started",
+      value: formatTimestamp(summary.startedAt),
+      availability: summary.startedAt === null ? "unverified" : "available"
+    },
+    {
+      label: "Elapsed",
+      value: formatElapsed(summary.startedAt, now),
+      availability: summary.startedAt === null ? "unverified" : "available"
+    },
+    {
+      label: "Inserted",
+      value: count(summary.inserted),
+      availability: summary.inserted === null ? "unverified" : "available"
+    },
+    {
+      label: "Updated",
+      value: count(summary.updated),
+      availability: summary.updated === null ? "unverified" : "available"
+    },
+    {
+      label: "Unchanged",
+      value: count(summary.unchanged),
+      availability: summary.unchanged === null ? "unverified" : "available"
+    },
+    {
+      label: "Labeled",
+      value: count(summary.labeled),
+      availability: summary.labeled === null ? "unverified" : "available"
+    },
+    {
+      label: "Model labeled",
+      value: count(summary.model),
+      availability: summary.model === null ? "unverified" : "available"
+    },
+    {
+      label: "Fallback labeled",
+      value: count(summary.fallback),
+      availability: summary.fallback === null ? "unverified" : "available"
+    }
+  ];
+  if (summary.factsPreview !== null) {
+    const preview = truncatePreview(summary.factsPreview, PREVIEW_CHARS);
+    facts.push({
+      label: "Core facts",
+      value: preview.truncated ? `${preview.text} (truncated — the facts artifact holds the full text)` : preview.text,
+      availability: preview.truncated ? "oversized" : "available"
+    });
+  }
+  if (summary.verdict !== null) {
+    facts.push({
+      label: "Label verdict",
+      value: summary.confidence === null ? summary.verdict : `${summary.verdict} (${summary.confidence})`,
+      availability: "available"
+    });
+  }
+  for (const [file, sources] of Object.entries(summary.sourceCounts ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+    facts.push({ label: `Source ${file}`, value: String(sources), availability: "available" });
+  }
+  return facts;
+}
+var PREVIEW_CHARS = 160;
+function truncatePreview(text, max) {
+  const flat = text.replaceAll(/\s+/g, " ").trim();
+  if (flat === "")
+    return { text: "unavailable", truncated: false };
+  if (flat.length <= max)
+    return { text: flat, truncated: false };
+  return { text: `${flat.slice(0, max).trimEnd()}…`, truncated: true };
+}
+function timingOf(record) {
+  const durationMs = record.durationMs;
+  if (typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs >= 0) {
+    return durationMs < 1000 ? `${Math.round(durationMs)}ms` : `${Math.round(durationMs / 1000)}s`;
+  }
+  const started = record.startedAt;
+  const completed = record.completedAt;
+  if (typeof started === "string" && typeof completed === "string")
+    return `${started} → ${completed}`;
+  return "timing unknown";
+}
+function operatorWaitOf(status, actions) {
+  const waitRe = /wait|pause|approv|hitl|question|escalat/i;
+  if (waitRe.test(status))
+    return true;
+  return actions.some((action) => {
+    if (typeof action !== "object" || action === null)
+      return false;
+    const key = action.actionKey;
+    return typeof key === "string" && waitRe.test(key);
+  });
+}
+function progressRows(progress) {
+  if (typeof progress !== "object" || progress === null)
+    return [];
+  const states = progress.states;
+  if (!Array.isArray(states))
+    return [];
+  const rows = [];
+  for (const entry of states) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    const record = entry;
+    if (typeof record.state !== "string")
+      continue;
+    const actions = Array.isArray(record.actions) ? record.actions : [];
+    rows.push({
+      state: record.state,
+      visit: typeof record.visit === "number" ? record.visit : 1,
+      status: typeof record.status === "string" ? record.status : "unknown",
+      timing: timingOf(record),
+      operatorWait: operatorWaitOf(typeof record.status === "string" ? record.status : "", actions),
+      actions: actions.map((action) => typeof action === "object" && action !== null ? `${String(action.actionKey ?? "action")} — ${String(action.status ?? "unknown")}` : null).filter((line) => line !== null)
+    });
+  }
+  return rows;
+}
+function artifactViews(results, readerOrigin) {
+  return results.artifacts.map((artifact) => ({
+    id: artifact.id,
+    label: artifact.label,
+    kind: artifact.kind,
+    availability: artifact.availability,
+    state: availabilityLabel(artifact.availability),
+    href: artifact.availability === "available" ? `${readerOrigin}/api/workflows/${results.workflow}/runs/${results.runId}/artifacts/${artifact.id}` : null
+  }));
+}
+
+// ../board/src/shared/refresh.ts
+var ACTIVE_POLL_MS = 5000;
+var HISTORY_POLL_MS = 30000;
+var MAX_BACKOFF_MS = 30000;
+function initialRefresh(intervalMs) {
+  return { pending: false, failures: 0, backoffMs: intervalMs, lastSuccessAt: null, failingSince: null };
+}
+function tick(state) {
+  return state.pending ? state : { ...state, pending: true };
+}
+function succeeded(now, intervalMs) {
+  return { pending: false, failures: 0, backoffMs: intervalMs, lastSuccessAt: now, failingSince: null };
+}
+function failed(state, now) {
+  const failures = state.failures + 1;
+  return {
+    pending: false,
+    failures,
+    backoffMs: Math.min(state.backoffMs * 2, MAX_BACKOFF_MS),
+    lastSuccessAt: state.lastSuccessAt,
+    failingSince: state.failingSince ?? now
+  };
+}
+function delayMs(state, intervalMs) {
+  return state.failures > 0 ? state.backoffMs : intervalMs;
+}
+function isStale(state) {
+  return state.failures > 0;
+}
+function freshnessLabel(state) {
+  if (state.lastSuccessAt === null)
+    return "Not yet loaded";
+  const updated = new Date(state.lastSuccessAt).toISOString();
+  return isStale(state) ? `Stale — last success ${updated}` : `Updated ${updated}`;
+}
+
+// ../board/src/shared/run-selection.ts
+var BOARD_TABS = ["summary", "results", "progress", "config"];
+function isBoardTab(value) {
+  return value !== null && value !== undefined && BOARD_TABS.includes(value);
+}
+function parseDeepLink(search) {
+  const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+  const diagnostics = [];
+  const rawTab = params.get("tab");
+  const rawRun = params.get("run");
+  let tab;
+  if (rawTab !== null) {
+    if (isBoardTab(rawTab)) {
+      tab = rawTab;
+    } else {
+      diagnostics.push({
+        code: "board.deeplink.unknown-tab",
+        message: `Unknown tab '${rawTab}'; showing Summary.`
+      });
+    }
+  }
+  let runId;
+  if (rawRun !== null) {
+    if (rawRun === "") {
+      diagnostics.push({ code: "board.deeplink.empty-run", message: "Empty run id ignored." });
+    } else {
+      runId = rawRun;
+    }
+  }
+  return { ...runId === undefined ? {} : { runId }, ...tab === undefined ? {} : { tab }, diagnostics };
+}
+function resolveSelection(rows, link) {
+  const tab = link.tab ?? "summary";
+  const diagnostics = [...link.diagnostics];
+  if (link.runId !== undefined) {
+    if (rows.some((row) => row.id === link.runId)) {
+      return { runId: link.runId, tab, diagnostics };
+    }
+    diagnostics.push({
+      code: "board.selection.unknown-run",
+      message: `Run '${link.runId}' is not in the loaded history; select a run.`
+    });
+    return { runId: null, tab, diagnostics };
+  }
+  return { runId: rows[0]?.id ?? null, tab, diagnostics };
+}
+function selectionQuery(selection, search = "") {
+  const params = new URLSearchParams;
+  if (selection.runId !== null)
+    params.set("run", selection.runId);
+  params.set("tab", selection.tab);
+  for (const [key, value] of new URLSearchParams(search)) {
+    if (key === "run" || key === "tab")
+      continue;
+    params.set(key, value);
+  }
+  return `?${params.toString()}`;
+}
+var COLLECT_MODULE_PATH = "/board/modules/kk-collect";
+function selectionPath(selection, search = "", modulePath = COLLECT_MODULE_PATH) {
+  return `${modulePath}${selectionQuery(selection, search)}`;
+}
+function syncSelectionUrl(selection, target, modulePath = COLLECT_MODULE_PATH) {
+  if (target.location.pathname !== modulePath)
+    return;
+  const url = selectionPath(selection, target.location.search, modulePath);
+  if (`${target.location.pathname}${target.location.search}` === url)
+    return;
+  target.history.replaceState(target.history.state, "", url);
+}
+function mergeRunPages(existing, page) {
+  const seen = new Set(existing.map((row) => row.id));
+  const merged = [...existing, ...page.runs.filter((row) => !seen.has(row.id))];
+  return { runs: merged, count: merged.length, nextCursor: page.nextCursor, hasMore: page.hasMore };
+}
+
+// ../board/src/collect/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var TAB_LABELS = {
+  summary: "Summary",
+  results: "Results",
+  progress: "Execution progress",
+  config: "Workflow Config Summary"
+};
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function usePolling(loader, intervalMs, refresh) {
+  const loaderRef = useRef(loader);
+  loaderRef.current = loader;
+  const refreshRef = useRef(refresh);
+  refreshRef.current = refresh;
+  useEffect(() => {
+    let cancelled = false;
+    let timer;
+    const loop = async () => {
+      if (!document.hidden) {
+        await loaderRef.current();
+      }
+      if (!cancelled)
+        timer = setTimeout(() => void loop(), delayMs(refreshRef.current, intervalMs));
+    };
+    loop();
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [intervalMs]);
+}
+function CollectModule() {
+  const [link] = useState(() => parseDeepLink(window.location.search));
+  const [reader] = useState(() => readerOriginFrom(window.location.search));
+  const readerOrigin = reader.origin;
+  const client = useMemo(() => createBoardClient({ readerOrigin, boardOrigin: window.location.origin }), [readerOrigin]);
+  const [rows, setRows] = useState([]);
+  const [cursor, setCursor] = useState(null);
+  const [selection, setSelection] = useState({ runId: link.runId ?? null, tab: link.tab ?? "summary" });
+  const [diagnostics, setDiagnostics] = useState(() => [
+    ...link.diagnostics,
+    ...reader.diagnostic === null ? [] : [reader.diagnostic]
+  ]);
+  const [historyRefresh, setHistoryRefresh] = useState(() => initialRefresh(HISTORY_POLL_MS));
+  const [readerRefresh, setReaderRefresh] = useState(() => initialRefresh(ACTIVE_POLL_MS));
+  const [results, setResults] = useState(null);
+  const [config, setConfig] = useState(null);
+  const [progress, setProgress] = useState(null);
+  const historyBusy = useRef(false);
+  const readerBusy = useRef(false);
+  const loadHistory = useCallback(async () => {
+    if (historyBusy.current)
+      return;
+    historyBusy.current = true;
+    setHistoryRefresh((state) => tick(state));
+    try {
+      const page = await client.runs("kk-collect");
+      setRows((existing) => mergeRunPages(existing, page).runs);
+      setCursor(page.nextCursor);
+      setHistoryRefresh(() => succeeded(Date.now(), HISTORY_POLL_MS));
+    } catch (error) {
+      setDiagnostics((existing) => [
+        ...existing,
+        { code: "board.history.unavailable", message: messageOf(error) }
+      ]);
+      setHistoryRefresh((state) => failed(state, Date.now()));
+    } finally {
+      historyBusy.current = false;
+    }
+  }, [client]);
+  const loadReader = useCallback(async () => {
+    if (readerBusy.current)
+      return;
+    const runId = selectionRef.current.runId;
+    if (runId === null)
+      return;
+    readerBusy.current = true;
+    setReaderRefresh((state) => tick(state));
+    try {
+      const [nextResults, nextConfig] = await Promise.all([
+        client.results("kk-collect", runId),
+        client.config("kk-collect", runId)
+      ]);
+      setResults(nextResults);
+      setConfig(nextConfig);
+      setReaderRefresh(() => succeeded(Date.now(), ACTIVE_POLL_MS));
+    } catch (error) {
+      setDiagnostics((existing) => [
+        ...existing,
+        { code: "board.reader.unavailable", message: messageOf(error) }
+      ]);
+      setReaderRefresh((state) => failed(state, Date.now()));
+    } finally {
+      readerBusy.current = false;
+    }
+    try {
+      setProgress(await client.progress(runId));
+    } catch {}
+  }, [client]);
+  const selectionRef = useRef(selection);
+  selectionRef.current = selection;
+  usePolling(loadHistory, HISTORY_POLL_MS, historyRefresh);
+  usePolling(loadReader, ACTIVE_POLL_MS, readerRefresh);
+  useEffect(() => {
+    if (selection.runId === null && rows.length > 0) {
+      setSelection((state) => state.runId === null ? resolveSelection(rows, link) : state);
+    }
+  }, [rows, selection.runId, link]);
+  useEffect(() => {
+    syncSelectionUrl(selection, { location: window.location, history: window.history });
+  }, [selection]);
+  const tab = selection.tab;
+  const now = Date.now();
+  const facts = results === null ? [] : collectSummaryFacts(results, now);
+  const artifacts = results === null ? [] : artifactViews(results, readerOrigin);
+  const steps = progressRows(progress);
+  const selectedRow = rows.find((row) => row.id === selection.runId);
+  return /* @__PURE__ */ jsxs("div", {
+    className: "kk-board kk-board-collect",
+    children: [
+      /* @__PURE__ */ jsxs("header", {
+        className: "kk-board-header",
+        children: [
+          /* @__PURE__ */ jsx("h1", {
+            children: "Collect"
+          }),
+          /* @__PURE__ */ jsxs("p", {
+            children: [
+              "Run ",
+              /* @__PURE__ */ jsx("code", {
+                children: selection.runId ?? "none selected"
+              }),
+              " · ",
+              selectedRow?.status ?? "status unknown",
+              " ·",
+              " ",
+              freshnessLabel(readerRefresh)
+            ]
+          }),
+          results === null ? null : /* @__PURE__ */ jsxs("p", {
+            children: [
+              "Results ",
+              results.availability
+            ]
+          }),
+          /* @__PURE__ */ jsx("button", {
+            type: "button",
+            onClick: () => void loadReader(),
+            children: "Refresh"
+          }),
+          selection.runId === null ? null : /* @__PURE__ */ jsx("a", {
+            href: selectionPath(selection, window.location.search),
+            children: "Permanent link to this view"
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx("nav", {
+        className: "kk-board-tabs",
+        "aria-label": "Collect tabs",
+        children: BOARD_TABS.map((candidate) => /* @__PURE__ */ jsx("button", {
+          type: "button",
+          "aria-current": candidate === tab ? "page" : undefined,
+          onClick: () => setSelection((state) => ({ ...state, tab: candidate })),
+          children: TAB_LABELS[candidate]
+        }, candidate))
+      }),
+      /* @__PURE__ */ jsxs("label", {
+        className: "kk-board-run-selector",
+        children: [
+          "Run",
+          /* @__PURE__ */ jsxs("select", {
+            value: selection.runId ?? "",
+            onChange: (event) => setSelection((state) => ({ ...state, runId: event.target.value || null })),
+            children: [
+              /* @__PURE__ */ jsx("option", {
+                value: "",
+                children: rows.length === 0 ? "No runs recorded" : "Select a run"
+              }),
+              rows.map((row) => /* @__PURE__ */ jsxs("option", {
+                value: row.id,
+                children: [
+                  row.id,
+                  " — ",
+                  row.status
+                ]
+              }, row.id))
+            ]
+          })
+        ]
+      }),
+      rows.length === 0 ? /* @__PURE__ */ jsxs("p", {
+        className: "kk-board-empty",
+        children: [
+          "No runs recorded for kk-collect. Configure the workflow in",
+          " ",
+          /* @__PURE__ */ jsx("a", {
+            href: "/board/settings/workflows",
+            children: "Settings → Workflows"
+          }),
+          "."
+        ]
+      }) : null,
+      tab === "summary" ? /* @__PURE__ */ jsx(SummaryPanel, {
+        facts,
+        results
+      }) : null,
+      tab === "results" ? /* @__PURE__ */ jsx(ResultsPanel, {
+        artifacts
+      }) : null,
+      tab === "progress" ? /* @__PURE__ */ jsx(ProgressPanel, {
+        steps
+      }) : null,
+      tab === "config" ? /* @__PURE__ */ jsx(ConfigPanel, {
+        config
+      }) : null,
+      dedupeDiagnostics([...diagnostics, ...results?.diagnostics ?? []]).map((diagnostic) => /* @__PURE__ */ jsx("p", {
+        role: "status",
+        className: "kk-board-diagnostic",
+        children: diagnosticLine(diagnostic)
+      }, diagnostic.code)),
+      cursor === null ? null : /* @__PURE__ */ jsx("button", {
+        type: "button",
+        onClick: () => void loadHistory(),
+        children: "Load more runs"
+      }),
+      /* @__PURE__ */ jsxs("p", {
+        className: "kk-board-footnote",
+        children: [
+          "Run history every ",
+          HISTORY_POLL_MS / 1000,
+          "s; selected run every ",
+          ACTIVE_POLL_MS / 1000,
+          "s."
+        ]
+      })
+    ]
+  });
+}
+function SummaryPanel({
+  facts,
+  results
+}) {
+  if (results === null)
+    return /* @__PURE__ */ jsx("p", {
+      children: "No captured results for the selected run."
+    });
+  return /* @__PURE__ */ jsx("dl", {
+    className: "kk-board-facts",
+    children: facts.map((fact) => /* @__PURE__ */ jsxs("div", {
+      children: [
+        /* @__PURE__ */ jsx("dt", {
+          children: fact.label
+        }),
+        /* @__PURE__ */ jsxs("dd", {
+          children: [
+            fact.value,
+            " ",
+            /* @__PURE__ */ jsx("span", {
+              className: "kk-board-state",
+              children: fact.availability
+            })
+          ]
+        })
+      ]
+    }, fact.label))
+  });
+}
+function ResultsPanel({ artifacts }) {
+  if (artifacts.length === 0)
+    return /* @__PURE__ */ jsx("p", {
+      children: "No artifact evidence for the selected run."
+    });
+  return /* @__PURE__ */ jsx("ul", {
+    className: "kk-board-artifacts",
+    children: artifacts.map((artifact) => /* @__PURE__ */ jsx("li", {
+      children: artifact.href === null ? /* @__PURE__ */ jsxs("span", {
+        children: [
+          artifact.label,
+          " — ",
+          artifact.state
+        ]
+      }) : /* @__PURE__ */ jsxs("a", {
+        href: artifact.href,
+        children: [
+          artifact.label,
+          " — ",
+          artifact.state
+        ]
+      })
+    }, artifact.id))
+  });
+}
+function ProgressPanel({ steps }) {
+  if (steps.length === 0)
+    return /* @__PURE__ */ jsx("p", {
+      children: "Recorded progress is unavailable for the selected run."
+    });
+  return /* @__PURE__ */ jsx("ul", {
+    className: "kk-board-progress",
+    children: steps.map((step) => /* @__PURE__ */ jsxs("li", {
+      children: [
+        /* @__PURE__ */ jsx("strong", {
+          children: step.state
+        }),
+        " visit ",
+        step.visit,
+        " — ",
+        step.status,
+        " · ",
+        step.timing,
+        step.operatorWait ? /* @__PURE__ */ jsx("span", {
+          className: "kk-board-state",
+          children: " operator wait"
+        }) : null,
+        step.actions.length === 0 ? null : /* @__PURE__ */ jsx("ul", {
+          children: step.actions.map((action) => /* @__PURE__ */ jsx("li", {
+            children: action
+          }, action))
+        })
+      ]
+    }, `${step.state}-${step.visit}`))
+  });
+}
+function ConfigPanel({ config }) {
+  if (config === null)
+    return /* @__PURE__ */ jsx("p", {
+      children: "No captured configuration for the selected run."
+    });
+  const entries = Object.entries(config.settings);
+  return /* @__PURE__ */ jsxs("div", {
+    className: "kk-board-config",
+    children: [
+      /* @__PURE__ */ jsxs("p", {
+        children: [
+          "Captured ",
+          formatTimestamp(config.capturedAt)
+        ]
+      }),
+      entries.length === 0 ? /* @__PURE__ */ jsx("p", {
+        children: "Recorded configuration unavailable for this run."
+      }) : null,
+      /* @__PURE__ */ jsx("dl", {
+        children: entries.map(([key, value]) => /* @__PURE__ */ jsxs("div", {
+          children: [
+            /* @__PURE__ */ jsx("dt", {
+              children: key
+            }),
+            /* @__PURE__ */ jsx("dd", {
+              children: value
+            })
+          ]
+        }, key))
+      }),
+      config.unavailableKeys.length === 0 ? null : /* @__PURE__ */ jsxs("p", {
+        children: [
+          "Uncaptured keys: ",
+          config.unavailableKeys.join(", ")
+        ]
+      }),
+      /* @__PURE__ */ jsxs("p", {
+        children: [
+          "Current definitions and defaults live in ",
+          /* @__PURE__ */ jsx("a", {
+            href: "/board/settings/workflows",
+            children: "Settings → Workflows"
+          }),
+          "."
+        ]
+      })
+    ]
+  });
+}
+var webModule = { apiVersion: 1, component: CollectModule };
+export {
+  CollectModule,
+  webModule
+};