@flanksource/clicky-ui 0.2.4 → 0.2.5

package/dist/data.js

@@ -24,15 +24,21 @@ import { ProgressBar } from "./data/ProgressBar.js";
 import { SignedDeltaBar } from "./data/SignedDeltaBar.js";
 import { SortableHeader } from "./data/SortableHeader.js";
 import { TabButton } from "./data/TabButton.js";
+import { TimeseriesPanel, resolveBreakdown, resolveSeries } from "./data/TimeseriesPanel.js";
 import { Tree } from "./data/Tree.js";
 import { TreeNode } from "./data/TreeNode.js";
 import { TreeGroupHeader } from "./data/TreeGroupHeader.js";
+import { allGroupsTerminal, isTerminalStatus } from "./data/TaskSnapshot.js";
+import { bucketTasks, logLevelColor, taskSegments, taskStatusBg, taskStatusColor, taskStatusIcon } from "./data/task-status.js";
+import { TaskProgress } from "./data/TaskProgress.js";
+import { TaskManager } from "./data/TaskManager.js";
 import { DiagnosticsTree } from "./data/diagnostics/DiagnosticsTree.js";
 import { DiagnosticsDetailPanel } from "./data/diagnostics/DiagnosticsDetailPanel.js";
 import { countProcesses, findProcessByPID, processLabel, processStateColor, processStateIcon } from "./data/diagnostics/utils.js";
 import { countGoroutinesByState, countStackByState, detectDumpFormat, parseGoroutineDump, parseStackDump } from "./data/diagnostics/stacktrace.js";
 import { countThreadsByState, parseJvmThreadDump } from "./data/diagnostics/jvm-stacktrace.js";
 import { JvmStackFrameRow, JvmStackTrace } from "./data/diagnostics/JvmStackTrace.js";
+import { FrameSourceWindow, frameHasSource } from "./data/diagnostics/FrameSourceWindow.js";
 import { StackTrace } from "./data/diagnostics/RenderedStackTrace.js";
 import { parseJavaStackTrace } from "./data/diagnostics/stacktrace-parse.js";
 import { CopyBadge, ErrorDetails, PrettyStackTrace } from "./data/diagnostics/ErrorDetails.js";
@@ -312,6 +318,7 @@ export {
   FilterPill,
   FilterPillGroup,
   FilterSeparator,
+  FrameSourceWindow,
   Gauge,
   HarPanel,
   Icon,
@@ -335,6 +342,9 @@ export {
   TabButton,
   TagActionsProvider,
   TagList,
+  TaskManager,
+  TaskProgress,
+  TimeseriesPanel,
   Timestamp,
   Tree,
   TreeGroupHeader,
@@ -828,7 +838,9 @@ export {
   UiZoomInFilled,
   UiZoomOut,
   UiZoomOutFilled,
+  allGroupsTerminal,
   badgeVariants,
+  bucketTasks,
   changeIconAliases,
   chooseTimestampFormat,
   compactStackPath,
@@ -840,9 +852,12 @@ export {
   findProcessByPID,
   formatPropertyLabel,
   formatTimestamp,
+  frameHasSource,
   getChangeIcon,
   inferColumns,
   isApplicationStackFrame,
+  isTerminalStatus,
+  logLevelColor,
   modeToFormat,
   normalizeErrorDiagnostics,
   normalizeLogsTableRows,
@@ -858,10 +873,16 @@ export {
   processLabel,
   processStateColor,
   processStateIcon,
+  resolveBreakdown,
+  resolveSeries,
   setFallbackIconProvider,
   splitTagToken,
   tagActionsFromRecord,
   tagFilterTokens,
+  taskSegments,
+  taskStatusBg,
+  taskStatusColor,
+  taskStatusIcon,
   useTagActions,
   useTagActionsValue
 };

package/dist/data.js.map

@@ -1 +1 @@
-{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/hooks/use-task-run.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const TaskSnapshot = require("../data/TaskSnapshot.cjs");
+const DEFAULT_BASE = "/api/v1";
+const DEFAULT_POLL_MS = 2e3;
+function streamUrl(base, query) {
+  return `${base}/tasks/stream${query ? `?${query}` : ""}`;
+}
+function hasEventSource() {
+  return typeof globalThis !== "undefined" && typeof globalThis.EventSource !== "undefined";
+}
+function useTaskRun(options = {}) {
+  const {
+    id,
+    kind,
+    basePath = DEFAULT_BASE,
+    enabled = true,
+    pollMs = DEFAULT_POLL_MS,
+    forcePoll = false
+  } = options;
+  const [byId, setById] = react.useState({});
+  const [status, setStatus] = react.useState("idle");
+  const [isComplete, setIsComplete] = react.useState(false);
+  const targetKey = `${id ?? ""}|${kind ?? ""}|${enabled}`;
+  const prevKey = react.useRef(targetKey);
+  if (prevKey.current !== targetKey) {
+    prevKey.current = targetKey;
+  }
+  react.useEffect(() => {
+    if (!enabled || !id && !kind) {
+      return;
+    }
+    setById({});
+    setIsComplete(false);
+    const params = new URLSearchParams();
+    if (id) params.set("tasks", id);
+    if (kind) params.set("kind", kind);
+    const query = params.toString();
+    const merge = (incoming) => {
+      setById((prev) => {
+        const next = { ...prev };
+        for (const snap of incoming) next[snap.id] = snap;
+        return next;
+      });
+    };
+    if (forcePoll || !hasEventSource()) {
+      let stopped = false;
+      let timer;
+      const tick = async () => {
+        try {
+          const res = await fetch(`${basePath}/tasks/${encodeURIComponent(id ?? "")}`, {
+            headers: { Accept: "application/json" }
+          });
+          if (res.ok) {
+            const snaps = await res.json();
+            merge(snaps);
+            setStatus("polling");
+            if (TaskSnapshot.allGroupsTerminal(snaps)) {
+              setIsComplete(true);
+              return;
+            }
+          }
+        } catch {
+          setStatus("connection lost — retrying");
+        }
+        if (!stopped) timer = setTimeout(tick, pollMs);
+      };
+      void tick();
+      return () => {
+        stopped = true;
+        if (timer) clearTimeout(timer);
+      };
+    }
+    const es = new EventSource(streamUrl(basePath, query));
+    setStatus("connected");
+    es.addEventListener("task", (e) => {
+      try {
+        merge([JSON.parse(e.data)]);
+      } catch {
+      }
+    });
+    es.addEventListener("done", () => {
+      setStatus("complete");
+      setIsComplete(true);
+      es.close();
+    });
+    es.onerror = () => setStatus("connection lost — retrying");
+    return () => es.close();
+  }, [id, kind, basePath, enabled, pollMs, forcePoll]);
+  return { snapshots: Object.values(byId), status, isComplete };
+}
+function useTaskRuns(options = {}) {
+  const {
+    kind,
+    status: statusFilter,
+    labels,
+    basePath = DEFAULT_BASE,
+    enabled = true,
+    pollMs = DEFAULT_POLL_MS
+  } = options;
+  const [runs, setRuns] = react.useState([]);
+  const [status, setStatus] = react.useState("idle");
+  react.useEffect(() => {
+    if (!enabled) return;
+    let stopped = false;
+    let timer;
+    const params = new URLSearchParams();
+    if (kind) params.set("kind", kind);
+    if (statusFilter) params.set("status", statusFilter);
+    for (const [k, v] of Object.entries(labels ?? {})) params.append("label", `${k}=${v}`);
+    const query = params.toString();
+    const tick = async () => {
+      try {
+        const res = await fetch(`${basePath}/tasks${query ? `?${query}` : ""}`, {
+          headers: { Accept: "application/json" }
+        });
+        if (res.ok) {
+          setRuns(await res.json());
+          setStatus("ok");
+        }
+      } catch {
+        setStatus("connection lost — retrying");
+      }
+      if (!stopped) timer = setTimeout(tick, pollMs);
+    };
+    void tick();
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs]);
+  return { runs, status };
+}
+exports.useTaskRun = useTaskRun;
+exports.useTaskRuns = useTaskRuns;
+//# sourceMappingURL=use-task-run.cjs.map

package/dist/hooks/use-task-run.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-task-run.cjs","sources":["../../src/hooks/use-task-run.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\nimport {\n  allGroupsTerminal,\n  type TaskRunMeta,\n  type TaskSnapshot,\n} from \"../data/TaskSnapshot\";\n\n// use-task-run / use-task-runs are the generic clicky-ui task clients. They are\n// SSE-first: they subscribe to clicky's SSEHandler (event: task / event: done)\n// and fall back to polling the JSON endpoints only when EventSource is\n// unavailable. They speak only TaskSnapshot / TaskRunMeta — no app concepts.\n\nexport interface TaskTransportOptions {\n  /** Base path of the clicky task API, e.g. \"/api/v1\". */\n  basePath?: string | undefined;\n  /** Disable the subscription entirely (e.g. before an id is known). */\n  enabled?: boolean | undefined;\n  /** Poll interval (ms) for the fallback / runs listing. */\n  pollMs?: number | undefined;\n  /** Force the polling transport even when EventSource exists (mainly tests). */\n  forcePoll?: boolean | undefined;\n}\n\nconst DEFAULT_BASE = \"/api/v1\";\nconst DEFAULT_POLL_MS = 2_000;\n\nfunction streamUrl(base: string, query: string): string {\n  return `${base}/tasks/stream${query ? `?${query}` : \"\"}`;\n}\n\nfunction hasEventSource(): boolean {\n  return typeof globalThis !== \"undefined\" && typeof globalThis.EventSource !== \"undefined\";\n}\n\nexport interface UseTaskRunResult {\n  snapshots: TaskSnapshot[];\n  status: string;\n  isComplete: boolean;\n}\n\nexport interface UseTaskRunOptions extends TaskTransportOptions {\n  /** Stable run id to follow (drill-down). Mutually exclusive with kind. */\n  id?: string | undefined;\n  /** Follow every run of a kind. */\n  kind?: string | undefined;\n}\n\n// useTaskRun follows one run (by id) or a kind, SSE-first. It accumulates the\n// latest snapshot per task/group id and reports completion once every group is\n// terminal.\nexport function useTaskRun(options: UseTaskRunOptions = {}): UseTaskRunResult {\n  const {\n    id,\n    kind,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n\n  const [byId, setById] = useState<Record<string, TaskSnapshot>>({});\n  const [status, setStatus] = useState(\"idle\");\n  const [isComplete, setIsComplete] = useState(false);\n  // Reset accumulator whenever the subscription target changes.\n  const targetKey = `${id ?? \"\"}|${kind ?? \"\"}|${enabled}`;\n  const prevKey = useRef(targetKey);\n  if (prevKey.current !== targetKey) {\n    prevKey.current = targetKey;\n  }\n\n  useEffect(() => {\n    if (!enabled || (!id && !kind)) {\n      return;\n    }\n    setById({});\n    setIsComplete(false);\n\n    const params = new URLSearchParams();\n    if (id) params.set(\"tasks\", id);\n    if (kind) params.set(\"kind\", kind);\n    const query = params.toString();\n\n    const merge = (incoming: TaskSnapshot[]) => {\n      setById((prev) => {\n        const next = { ...prev };\n        for (const snap of incoming) next[snap.id] = snap;\n        return next;\n      });\n    };\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const res = await fetch(`${basePath}/tasks/${encodeURIComponent(id ?? \"\")}`, {\n            headers: { Accept: \"application/json\" },\n          });\n          if (res.ok) {\n            const snaps = (await res.json()) as TaskSnapshot[];\n            merge(snaps);\n            setStatus(\"polling\");\n            if (allGroupsTerminal(snaps)) {\n              setIsComplete(true);\n              return; // stop polling\n            }\n          }\n        } catch {\n          setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(streamUrl(basePath, query));\n    setStatus(\"connected\");\n    es.addEventListener(\"task\", (e) => {\n      try {\n        merge([JSON.parse((e as MessageEvent).data) as TaskSnapshot]);\n      } catch {\n        /* ignore malformed frame */\n      }\n    });\n    es.addEventListener(\"done\", () => {\n      setStatus(\"complete\");\n      setIsComplete(true);\n      es.close();\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [id, kind, basePath, enabled, pollMs, forcePoll]);\n\n  return { snapshots: Object.values(byId), status, isComplete };\n}\n\nexport interface UseTaskRunsOptions extends TaskTransportOptions {\n  kind?: string | undefined;\n  status?: string | undefined;\n  /** Label equality filters (k=v). */\n  labels?: Record<string, string> | undefined;\n}\n\nexport interface UseTaskRunsResult {\n  runs: TaskRunMeta[];\n  status: string;\n}\n\n// useTaskRuns lists all runs (TaskRunMeta) for the manager view by polling the\n// runs endpoint. The listing has no completion terminal of its own, so it polls\n// on an interval (cheap GET) regardless of transport.\nexport function useTaskRuns(options: UseTaskRunsOptions = {}): UseTaskRunsResult {\n  const {\n    kind,\n    status: statusFilter,\n    labels,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n  } = options;\n\n  const [runs, setRuns] = useState<TaskRunMeta[]>([]);\n  const [status, setStatus] = useState(\"idle\");\n\n  useEffect(() => {\n    if (!enabled) return;\n    let stopped = false;\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const params = new URLSearchParams();\n    if (kind) params.set(\"kind\", kind);\n    if (statusFilter) params.set(\"status\", statusFilter);\n    for (const [k, v] of Object.entries(labels ?? {})) params.append(\"label\", `${k}=${v}`);\n    const query = params.toString();\n\n    const tick = async () => {\n      try {\n        const res = await fetch(`${basePath}/tasks${query ? `?${query}` : \"\"}`, {\n          headers: { Accept: \"application/json\" },\n        });\n        if (res.ok) {\n          setRuns((await res.json()) as TaskRunMeta[]);\n          setStatus(\"ok\");\n        }\n      } catch {\n        setStatus(\"connection lost — retrying\");\n      }\n      if (!stopped) timer = setTimeout(tick, pollMs);\n    };\n    void tick();\n    return () => {\n      stopped = true;\n      if (timer) clearTimeout(timer);\n    };\n  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs]);\n\n  return { runs, status };\n}\n"],"names":["useState","useRef","useEffect","allGroupsTerminal"],"mappings":"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"}

package/dist/hooks/use-task-run.d.ts

@@ -0,0 +1,35 @@
+import { TaskRunMeta, TaskSnapshot } from '../data/TaskSnapshot';
+export interface TaskTransportOptions {
+    /** Base path of the clicky task API, e.g. "/api/v1". */
+    basePath?: string | undefined;
+    /** Disable the subscription entirely (e.g. before an id is known). */
+    enabled?: boolean | undefined;
+    /** Poll interval (ms) for the fallback / runs listing. */
+    pollMs?: number | undefined;
+    /** Force the polling transport even when EventSource exists (mainly tests). */
+    forcePoll?: boolean | undefined;
+}
+export interface UseTaskRunResult {
+    snapshots: TaskSnapshot[];
+    status: string;
+    isComplete: boolean;
+}
+export interface UseTaskRunOptions extends TaskTransportOptions {
+    /** Stable run id to follow (drill-down). Mutually exclusive with kind. */
+    id?: string | undefined;
+    /** Follow every run of a kind. */
+    kind?: string | undefined;
+}
+export declare function useTaskRun(options?: UseTaskRunOptions): UseTaskRunResult;
+export interface UseTaskRunsOptions extends TaskTransportOptions {
+    kind?: string | undefined;
+    status?: string | undefined;
+    /** Label equality filters (k=v). */
+    labels?: Record<string, string> | undefined;
+}
+export interface UseTaskRunsResult {
+    runs: TaskRunMeta[];
+    status: string;
+}
+export declare function useTaskRuns(options?: UseTaskRunsOptions): UseTaskRunsResult;
+//# sourceMappingURL=use-task-run.d.ts.map

package/dist/hooks/use-task-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-task-run.d.ts","sourceRoot":"","sources":["../../src/hooks/use-task-run.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAO9B,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,sEAAsE;IACtE,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,+EAA+E;IAC/E,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACjC;AAaD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,0EAA0E;IAC1E,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAKD,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CA0F5E;AAED,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC9D,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAKD,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,iBAAiB,CA8C/E"}

package/dist/hooks/use-task-run.js

@@ -0,0 +1,137 @@
+import { useState, useRef, useEffect } from "react";
+import { allGroupsTerminal } from "../data/TaskSnapshot.js";
+const DEFAULT_BASE = "/api/v1";
+const DEFAULT_POLL_MS = 2e3;
+function streamUrl(base, query) {
+  return `${base}/tasks/stream${query ? `?${query}` : ""}`;
+}
+function hasEventSource() {
+  return typeof globalThis !== "undefined" && typeof globalThis.EventSource !== "undefined";
+}
+function useTaskRun(options = {}) {
+  const {
+    id,
+    kind,
+    basePath = DEFAULT_BASE,
+    enabled = true,
+    pollMs = DEFAULT_POLL_MS,
+    forcePoll = false
+  } = options;
+  const [byId, setById] = useState({});
+  const [status, setStatus] = useState("idle");
+  const [isComplete, setIsComplete] = useState(false);
+  const targetKey = `${id ?? ""}|${kind ?? ""}|${enabled}`;
+  const prevKey = useRef(targetKey);
+  if (prevKey.current !== targetKey) {
+    prevKey.current = targetKey;
+  }
+  useEffect(() => {
+    if (!enabled || !id && !kind) {
+      return;
+    }
+    setById({});
+    setIsComplete(false);
+    const params = new URLSearchParams();
+    if (id) params.set("tasks", id);
+    if (kind) params.set("kind", kind);
+    const query = params.toString();
+    const merge = (incoming) => {
+      setById((prev) => {
+        const next = { ...prev };
+        for (const snap of incoming) next[snap.id] = snap;
+        return next;
+      });
+    };
+    if (forcePoll || !hasEventSource()) {
+      let stopped = false;
+      let timer;
+      const tick = async () => {
+        try {
+          const res = await fetch(`${basePath}/tasks/${encodeURIComponent(id ?? "")}`, {
+            headers: { Accept: "application/json" }
+          });
+          if (res.ok) {
+            const snaps = await res.json();
+            merge(snaps);
+            setStatus("polling");
+            if (allGroupsTerminal(snaps)) {
+              setIsComplete(true);
+              return;
+            }
+          }
+        } catch {
+          setStatus("connection lost — retrying");
+        }
+        if (!stopped) timer = setTimeout(tick, pollMs);
+      };
+      void tick();
+      return () => {
+        stopped = true;
+        if (timer) clearTimeout(timer);
+      };
+    }
+    const es = new EventSource(streamUrl(basePath, query));
+    setStatus("connected");
+    es.addEventListener("task", (e) => {
+      try {
+        merge([JSON.parse(e.data)]);
+      } catch {
+      }
+    });
+    es.addEventListener("done", () => {
+      setStatus("complete");
+      setIsComplete(true);
+      es.close();
+    });
+    es.onerror = () => setStatus("connection lost — retrying");
+    return () => es.close();
+  }, [id, kind, basePath, enabled, pollMs, forcePoll]);
+  return { snapshots: Object.values(byId), status, isComplete };
+}
+function useTaskRuns(options = {}) {
+  const {
+    kind,
+    status: statusFilter,
+    labels,
+    basePath = DEFAULT_BASE,
+    enabled = true,
+    pollMs = DEFAULT_POLL_MS
+  } = options;
+  const [runs, setRuns] = useState([]);
+  const [status, setStatus] = useState("idle");
+  useEffect(() => {
+    if (!enabled) return;
+    let stopped = false;
+    let timer;
+    const params = new URLSearchParams();
+    if (kind) params.set("kind", kind);
+    if (statusFilter) params.set("status", statusFilter);
+    for (const [k, v] of Object.entries(labels ?? {})) params.append("label", `${k}=${v}`);
+    const query = params.toString();
+    const tick = async () => {
+      try {
+        const res = await fetch(`${basePath}/tasks${query ? `?${query}` : ""}`, {
+          headers: { Accept: "application/json" }
+        });
+        if (res.ok) {
+          setRuns(await res.json());
+          setStatus("ok");
+        }
+      } catch {
+        setStatus("connection lost — retrying");
+      }
+      if (!stopped) timer = setTimeout(tick, pollMs);
+    };
+    void tick();
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs]);
+  return { runs, status };
+}
+export {
+  useTaskRun,
+  useTaskRuns
+};
+//# sourceMappingURL=use-task-run.js.map

package/dist/hooks/use-task-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-task-run.js","sources":["../../src/hooks/use-task-run.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\nimport {\n  allGroupsTerminal,\n  type TaskRunMeta,\n  type TaskSnapshot,\n} from \"../data/TaskSnapshot\";\n\n// use-task-run / use-task-runs are the generic clicky-ui task clients. They are\n// SSE-first: they subscribe to clicky's SSEHandler (event: task / event: done)\n// and fall back to polling the JSON endpoints only when EventSource is\n// unavailable. They speak only TaskSnapshot / TaskRunMeta — no app concepts.\n\nexport interface TaskTransportOptions {\n  /** Base path of the clicky task API, e.g. \"/api/v1\". */\n  basePath?: string | undefined;\n  /** Disable the subscription entirely (e.g. before an id is known). */\n  enabled?: boolean | undefined;\n  /** Poll interval (ms) for the fallback / runs listing. */\n  pollMs?: number | undefined;\n  /** Force the polling transport even when EventSource exists (mainly tests). */\n  forcePoll?: boolean | undefined;\n}\n\nconst DEFAULT_BASE = \"/api/v1\";\nconst DEFAULT_POLL_MS = 2_000;\n\nfunction streamUrl(base: string, query: string): string {\n  return `${base}/tasks/stream${query ? `?${query}` : \"\"}`;\n}\n\nfunction hasEventSource(): boolean {\n  return typeof globalThis !== \"undefined\" && typeof globalThis.EventSource !== \"undefined\";\n}\n\nexport interface UseTaskRunResult {\n  snapshots: TaskSnapshot[];\n  status: string;\n  isComplete: boolean;\n}\n\nexport interface UseTaskRunOptions extends TaskTransportOptions {\n  /** Stable run id to follow (drill-down). Mutually exclusive with kind. */\n  id?: string | undefined;\n  /** Follow every run of a kind. */\n  kind?: string | undefined;\n}\n\n// useTaskRun follows one run (by id) or a kind, SSE-first. It accumulates the\n// latest snapshot per task/group id and reports completion once every group is\n// terminal.\nexport function useTaskRun(options: UseTaskRunOptions = {}): UseTaskRunResult {\n  const {\n    id,\n    kind,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n\n  const [byId, setById] = useState<Record<string, TaskSnapshot>>({});\n  const [status, setStatus] = useState(\"idle\");\n  const [isComplete, setIsComplete] = useState(false);\n  // Reset accumulator whenever the subscription target changes.\n  const targetKey = `${id ?? \"\"}|${kind ?? \"\"}|${enabled}`;\n  const prevKey = useRef(targetKey);\n  if (prevKey.current !== targetKey) {\n    prevKey.current = targetKey;\n  }\n\n  useEffect(() => {\n    if (!enabled || (!id && !kind)) {\n      return;\n    }\n    setById({});\n    setIsComplete(false);\n\n    const params = new URLSearchParams();\n    if (id) params.set(\"tasks\", id);\n    if (kind) params.set(\"kind\", kind);\n    const query = params.toString();\n\n    const merge = (incoming: TaskSnapshot[]) => {\n      setById((prev) => {\n        const next = { ...prev };\n        for (const snap of incoming) next[snap.id] = snap;\n        return next;\n      });\n    };\n\n    // Polling fallback transport.\n    if (forcePoll || !hasEventSource()) {\n      let stopped = false;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const tick = async () => {\n        try {\n          const res = await fetch(`${basePath}/tasks/${encodeURIComponent(id ?? \"\")}`, {\n            headers: { Accept: \"application/json\" },\n          });\n          if (res.ok) {\n            const snaps = (await res.json()) as TaskSnapshot[];\n            merge(snaps);\n            setStatus(\"polling\");\n            if (allGroupsTerminal(snaps)) {\n              setIsComplete(true);\n              return; // stop polling\n            }\n          }\n        } catch {\n          setStatus(\"connection lost — retrying\");\n        }\n        if (!stopped) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n      return () => {\n        stopped = true;\n        if (timer) clearTimeout(timer);\n      };\n    }\n\n    // SSE transport (default).\n    const es = new EventSource(streamUrl(basePath, query));\n    setStatus(\"connected\");\n    es.addEventListener(\"task\", (e) => {\n      try {\n        merge([JSON.parse((e as MessageEvent).data) as TaskSnapshot]);\n      } catch {\n        /* ignore malformed frame */\n      }\n    });\n    es.addEventListener(\"done\", () => {\n      setStatus(\"complete\");\n      setIsComplete(true);\n      es.close();\n    });\n    es.onerror = () => setStatus(\"connection lost — retrying\");\n    return () => es.close();\n  }, [id, kind, basePath, enabled, pollMs, forcePoll]);\n\n  return { snapshots: Object.values(byId), status, isComplete };\n}\n\nexport interface UseTaskRunsOptions extends TaskTransportOptions {\n  kind?: string | undefined;\n  status?: string | undefined;\n  /** Label equality filters (k=v). */\n  labels?: Record<string, string> | undefined;\n}\n\nexport interface UseTaskRunsResult {\n  runs: TaskRunMeta[];\n  status: string;\n}\n\n// useTaskRuns lists all runs (TaskRunMeta) for the manager view by polling the\n// runs endpoint. The listing has no completion terminal of its own, so it polls\n// on an interval (cheap GET) regardless of transport.\nexport function useTaskRuns(options: UseTaskRunsOptions = {}): UseTaskRunsResult {\n  const {\n    kind,\n    status: statusFilter,\n    labels,\n    basePath = DEFAULT_BASE,\n    enabled = true,\n    pollMs = DEFAULT_POLL_MS,\n  } = options;\n\n  const [runs, setRuns] = useState<TaskRunMeta[]>([]);\n  const [status, setStatus] = useState(\"idle\");\n\n  useEffect(() => {\n    if (!enabled) return;\n    let stopped = false;\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const params = new URLSearchParams();\n    if (kind) params.set(\"kind\", kind);\n    if (statusFilter) params.set(\"status\", statusFilter);\n    for (const [k, v] of Object.entries(labels ?? {})) params.append(\"label\", `${k}=${v}`);\n    const query = params.toString();\n\n    const tick = async () => {\n      try {\n        const res = await fetch(`${basePath}/tasks${query ? `?${query}` : \"\"}`, {\n          headers: { Accept: \"application/json\" },\n        });\n        if (res.ok) {\n          setRuns((await res.json()) as TaskRunMeta[]);\n          setStatus(\"ok\");\n        }\n      } catch {\n        setStatus(\"connection lost — retrying\");\n      }\n      if (!stopped) timer = setTimeout(tick, pollMs);\n    };\n    void tick();\n    return () => {\n      stopped = true;\n      if (timer) clearTimeout(timer);\n    };\n  }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs]);\n\n  return { runs, status };\n}\n"],"names":[],"mappings":"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"}

package/dist/hooks.cjs

@@ -4,6 +4,7 @@ const useTheme = require("./hooks/use-theme.cjs");
 const useDensity = require("./hooks/use-density.cjs");
 const useSort = require("./hooks/use-sort.cjs");
 const useHistoryRoute = require("./hooks/use-history-route.cjs");
+const useTaskRun = require("./hooks/use-task-run.cjs");
 exports.ThemeProvider = useTheme.ThemeProvider;
 exports.useOptionalTheme = useTheme.useOptionalTheme;
 exports.useResolvedTheme = useTheme.useResolvedTheme;
@@ -13,4 +14,6 @@ exports.useDensity = useDensity.useDensity;
 exports.useDensityValue = useDensity.useDensityValue;
 exports.useSort = useSort.useSort;
 exports.useHistoryRoute = useHistoryRoute.useHistoryRoute;
+exports.useTaskRun = useTaskRun.useTaskRun;
+exports.useTaskRuns = useTaskRun.useTaskRuns;
 //# sourceMappingURL=hooks.cjs.map

package/dist/hooks.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"hooks.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

package/dist/hooks.d.ts

@@ -2,4 +2,5 @@ export { ThemeProvider, useTheme, useOptionalTheme, useResolvedTheme, type Theme
 export { DensityProvider, useDensity, useDensityValue, type Density } from './hooks/use-density';
 export { useSort, type SortDir, type SortState, type UseSortOptions, type UseSortReturn, } from './hooks/use-sort';
 export { useHistoryRoute, type UseHistoryRouteOptions } from './hooks/use-history-route';
+export { useTaskRun, useTaskRuns, type UseTaskRunOptions, type UseTaskRunResult, type UseTaskRunsOptions, type UseTaskRunsResult, type TaskTransportOptions, } from './hooks/use-task-run';
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,KAAK,EACV,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACjG,OAAO,EACL,OAAO,EACP,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,KAAK,EACV,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACjG,OAAO,EACL,OAAO,EACP,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACzF,OAAO,EACL,UAAU,EACV,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/hooks.js

@@ -2,6 +2,7 @@ import { ThemeProvider, useOptionalTheme, useResolvedTheme, useTheme } from "./h
 import { DensityProvider, useDensity, useDensityValue } from "./hooks/use-density.js";
 import { useSort } from "./hooks/use-sort.js";
 import { useHistoryRoute } from "./hooks/use-history-route.js";
+import { useTaskRun, useTaskRuns } from "./hooks/use-task-run.js";
 export {
   DensityProvider,
   ThemeProvider,
@@ -11,6 +12,8 @@ export {
   useOptionalTheme,
   useResolvedTheme,
   useSort,
+  useTaskRun,
+  useTaskRuns,
   useTheme
 };
 //# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}
+{"version":3,"file":"hooks.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/index.cjs

@@ -3,11 +3,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const utils = require("./lib/utils.cjs");
 const palette = require("./lib/palette.cjs");
 const size = require("./lib/size.cjs");
+const format = require("./lib/format.cjs");
 const useTheme = require("./hooks/use-theme.cjs");
 const useDensity = require("./hooks/use-density.cjs");
 const useSort = require("./hooks/use-sort.cjs");
 const useHistoryRoute = require("./hooks/use-history-route.cjs");
+const useTaskRun = require("./hooks/use-task-run.cjs");
 const button = require("./components/button.cjs");
+const SplitButton = require("./components/SplitButton.cjs");
+const FormatOptionsDropdown = require("./components/FormatOptionsDropdown.cjs");
 const DateField = require("./components/DateField.cjs");
 const DatePicker = require("./components/DatePicker.cjs");
 const DateTimePicker = require("./components/DateTimePicker.cjs");
@@ -16,6 +20,7 @@ const RangeSlider = require("./components/RangeSlider.cjs");
 const FilterBar = require("./components/FilterBar.cjs");
 const MultiSelect = require("./components/MultiSelect.cjs");
 const select = require("./components/select.cjs");
+const Combobox = require("./components/Combobox.cjs");
 const themeSwitcher = require("./components/theme-switcher.cjs");
 const densitySwitcher = require("./components/density-switcher.cjs");
 const iconMenuPicker = require("./components/icon-menu-picker.cjs");
@@ -50,15 +55,21 @@ const ProgressBar = require("./data/ProgressBar.cjs");
 const SignedDeltaBar = require("./data/SignedDeltaBar.cjs");
 const SortableHeader = require("./data/SortableHeader.cjs");
 const TabButton = require("./data/TabButton.cjs");
+const TimeseriesPanel = require("./data/TimeseriesPanel.cjs");
 const Tree = require("./data/Tree.cjs");
 const TreeNode = require("./data/TreeNode.cjs");
 const TreeGroupHeader = require("./data/TreeGroupHeader.cjs");
+const TaskSnapshot = require("./data/TaskSnapshot.cjs");
+const taskStatus = require("./data/task-status.cjs");
+const TaskProgress = require("./data/TaskProgress.cjs");
+const TaskManager = require("./data/TaskManager.cjs");
 const DiagnosticsTree = require("./data/diagnostics/DiagnosticsTree.cjs");
 const DiagnosticsDetailPanel = require("./data/diagnostics/DiagnosticsDetailPanel.cjs");
 const utils$1 = require("./data/diagnostics/utils.cjs");
 const stacktrace = require("./data/diagnostics/stacktrace.cjs");
 const jvmStacktrace = require("./data/diagnostics/jvm-stacktrace.cjs");
 const JvmStackTrace = require("./data/diagnostics/JvmStackTrace.cjs");
+const FrameSourceWindow = require("./data/diagnostics/FrameSourceWindow.cjs");
 const RenderedStackTrace = require("./data/diagnostics/RenderedStackTrace.cjs");
 const stacktraceParse = require("./data/diagnostics/stacktrace-parse.cjs");
 const ErrorDetails = require("./data/diagnostics/ErrorDetails.cjs");
@@ -345,6 +356,11 @@ exports.fnv1a32 = palette.fnv1a32;
 exports.paletteClass = palette.paletteClass;
 exports.SIZE_TOKENS = size.SIZE_TOKENS;
 exports.resolveSize = size.resolveSize;
+exports.formatBytes = format.formatBytes;
+exports.formatBytesPerSecond = format.formatBytesPerSecond;
+exports.formatDuration = format.formatDuration;
+exports.formatShort = format.formatShort;
+exports.formatUnit = format.formatUnit;
 exports.ThemeProvider = useTheme.ThemeProvider;
 exports.useOptionalTheme = useTheme.useOptionalTheme;
 exports.useResolvedTheme = useTheme.useResolvedTheme;
@@ -354,8 +370,13 @@ exports.useDensity = useDensity.useDensity;
 exports.useDensityValue = useDensity.useDensityValue;
 exports.useSort = useSort.useSort;
 exports.useHistoryRoute = useHistoryRoute.useHistoryRoute;
+exports.useTaskRun = useTaskRun.useTaskRun;
+exports.useTaskRuns = useTaskRun.useTaskRuns;
 exports.Button = button.Button;
 exports.buttonVariants = button.buttonVariants;
+exports.SplitButton = SplitButton.SplitButton;
+exports.CLICKY_FORMAT_OPTIONS = FormatOptionsDropdown.CLICKY_FORMAT_OPTIONS;
+exports.FormatOptionsDropdown = FormatOptionsDropdown.FormatOptionsDropdown;
 exports.DateField = DateField.DateField;
 exports.DatePicker = DatePicker.DatePicker;
 exports.DateTimePicker = DateTimePicker.DateTimePicker;
@@ -364,6 +385,7 @@ exports.RangeSlider = RangeSlider.RangeSlider;
 exports.FilterBar = FilterBar.FilterBar;
 exports.MultiSelect = MultiSelect.MultiSelect;
 exports.Select = select.Select;
+exports.Combobox = Combobox.Combobox;
 exports.ThemeSwitcher = themeSwitcher.ThemeSwitcher;
 exports.DensitySwitcher = densitySwitcher.DensitySwitcher;
 exports.IconMenuPicker = iconMenuPicker.IconMenuPicker;
@@ -417,9 +439,22 @@ exports.ProgressBar = ProgressBar.ProgressBar;
 exports.SignedDeltaBar = SignedDeltaBar.SignedDeltaBar;
 exports.SortableHeader = SortableHeader.SortableHeader;
 exports.TabButton = TabButton.TabButton;
+exports.TimeseriesPanel = TimeseriesPanel.TimeseriesPanel;
+exports.resolveBreakdown = TimeseriesPanel.resolveBreakdown;
+exports.resolveSeries = TimeseriesPanel.resolveSeries;
 exports.Tree = Tree.Tree;
 exports.TreeNode = TreeNode.TreeNode;
 exports.TreeGroupHeader = TreeGroupHeader.TreeGroupHeader;
+exports.allGroupsTerminal = TaskSnapshot.allGroupsTerminal;
+exports.isTerminalStatus = TaskSnapshot.isTerminalStatus;
+exports.bucketTasks = taskStatus.bucketTasks;
+exports.logLevelColor = taskStatus.logLevelColor;
+exports.taskSegments = taskStatus.taskSegments;
+exports.taskStatusBg = taskStatus.taskStatusBg;
+exports.taskStatusColor = taskStatus.taskStatusColor;
+exports.taskStatusIcon = taskStatus.taskStatusIcon;
+exports.TaskProgress = TaskProgress.TaskProgress;
+exports.TaskManager = TaskManager.TaskManager;
 exports.DiagnosticsTree = DiagnosticsTree.DiagnosticsTree;
 exports.DiagnosticsDetailPanel = DiagnosticsDetailPanel.DiagnosticsDetailPanel;
 exports.countProcesses = utils$1.countProcesses;
@@ -436,6 +471,8 @@ exports.countThreadsByState = jvmStacktrace.countThreadsByState;
 exports.parseJvmThreadDump = jvmStacktrace.parseJvmThreadDump;
 exports.JvmStackFrameRow = JvmStackTrace.JvmStackFrameRow;
 exports.JvmStackTrace = JvmStackTrace.JvmStackTrace;
+exports.FrameSourceWindow = FrameSourceWindow.FrameSourceWindow;
+exports.frameHasSource = FrameSourceWindow.frameHasSource;
 exports.StackTrace = RenderedStackTrace.StackTrace;
 exports.parseJavaStackTrace = stacktraceParse.parseJavaStackTrace;
 exports.CopyBadge = ErrorDetails.CopyBadge;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}