@flanksource/clicky-ui 0.3.34 → 0.3.36

package/dist/data/task-streams.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const emptyTaskStreams = {
+  stdoutTruncated: false,
+  stderrTruncated: false,
+  stdoutEnd: 0,
+  stderrEnd: 0
+};
+const encoder = new TextEncoder();
+function utf8Length(data) {
+  return encoder.encode(data).byteLength;
+}
+function applyTaskOutputDelta(current, delta) {
+  const held = delta.stream === "stdout" ? current.stdout : current.stderr;
+  const end = delta.stream === "stdout" ? current.stdoutEnd : current.stderrEnd;
+  const continues = delta.reset !== true && held !== void 0 && end === delta.offset;
+  const text = continues ? `${held}${delta.data}` : delta.data;
+  const wasTruncated = delta.stream === "stdout" ? current.stdoutTruncated : current.stderrTruncated;
+  const truncated = delta.truncated ?? (continues && wasTruncated);
+  const streamEnd = delta.offset + utf8Length(delta.data);
+  return delta.stream === "stdout" ? { ...current, stdout: text, stdoutTruncated: truncated, stdoutEnd: streamEnd } : { ...current, stderr: text, stderrTruncated: truncated, stderrEnd: streamEnd };
+}
+function withTaskStreams(snapshot, streams) {
+  if (!streams) return snapshot;
+  const merged = { ...snapshot };
+  if (streams.stdout !== void 0) {
+    merged.stdout = streams.stdout;
+    merged.stdoutTruncated = streams.stdoutTruncated;
+  }
+  if (streams.stderr !== void 0) {
+    merged.stderr = streams.stderr;
+    merged.stderrTruncated = streams.stderrTruncated;
+  }
+  return merged;
+}
+exports.applyTaskOutputDelta = applyTaskOutputDelta;
+exports.emptyTaskStreams = emptyTaskStreams;
+exports.withTaskStreams = withTaskStreams;
+//# sourceMappingURL=task-streams.cjs.map

package/dist/data/task-streams.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-streams.cjs","sources":["../../src/data/task-streams.ts"],"sourcesContent":["import type { TaskSnapshot } from \"./TaskSnapshot\";\n\n/**\n * A task's stdout/stderr arrive as append-only deltas on their own SSE frames,\n * never on the task frames — clicky strips them there deliberately, so the tail\n * of a long-running process is not re-sent every time a duration ticks over.\n *\n * That makes where a client keeps the accumulated text a correctness question,\n * not a style one. Kept on the snapshot object, it is destroyed the next time a\n * task frame replaces that object, and since the server only sends what a client\n * has not seen it is never sent again — the output appears, vanishes a moment\n * later, and only flickers back when the process happens to write more. So it is\n * kept here instead, beside the snapshots rather than inside them, and merged in\n * at the boundary.\n */\nexport interface TaskStreams {\n  stdout?: string;\n  stderr?: string;\n  stdoutTruncated: boolean;\n  stderrTruncated: boolean;\n  /** Absolute stream offset one past the last byte held, per stream. */\n  stdoutEnd: number;\n  stderrEnd: number;\n}\n\nexport const emptyTaskStreams: TaskStreams = {\n  stdoutTruncated: false,\n  stderrTruncated: false,\n  stdoutEnd: 0,\n  stderrEnd: 0,\n};\n\n/**\n * One `event: output` frame. `offset` is an ABSOLUTE position in the task's\n * stream, not a length into what this client holds: on an append it is where\n * `data` belongs, and on a `reset` it is where the server's retained tail now\n * begins. `truncated` says bytes ahead of that point are gone for good.\n */\nexport interface TaskOutputDelta {\n  id: string;\n  groupId?: string;\n  stream: \"stdout\" | \"stderr\";\n  data: string;\n  offset: number;\n  reset?: boolean;\n  truncated?: boolean;\n}\n\nconst encoder = new TextEncoder();\n\n/**\n * How far `data` advances the stream. Offsets are byte positions in the\n * process's own output, and a JS string measures UTF-16 code units — so `\"é\"`\n * counts as one there and as the two bytes the server actually wrote. Measuring\n * the wrong unit puts the client's end short of the next delta's start, and\n * every following frame is then read as a gap and replaces the text it should\n * have continued.\n */\nfunction utf8Length(data: string): number {\n  return encoder.encode(data).byteLength;\n}\n\n/**\n * Applies one delta to what a task's streams already hold.\n *\n * Appending is only correct where the two actually meet — the client's own end\n * is exactly the delta's start. Anything else is a replacement: an explicit\n * `reset`, or a gap opened by a retained window that rolled past what this\n * client last saw. Concatenating across such a gap would silently splice\n * together two pieces of output that never ran together.\n *\n * Truncation carries across an append: dropping the head of a stream is not\n * undone by writing more to its tail, so a frame that simply says nothing about\n * it leaves the flag as it was, and only an explicit value changes it.\n */\nexport function applyTaskOutputDelta(current: TaskStreams, delta: TaskOutputDelta): TaskStreams {\n  const held = delta.stream === \"stdout\" ? current.stdout : current.stderr;\n  const end = delta.stream === \"stdout\" ? current.stdoutEnd : current.stderrEnd;\n  const continues = delta.reset !== true && held !== undefined && end === delta.offset;\n  const text = continues ? `${held}${delta.data}` : delta.data;\n  const wasTruncated = delta.stream === \"stdout\" ? current.stdoutTruncated : current.stderrTruncated;\n  const truncated = delta.truncated ?? (continues && wasTruncated);\n  const streamEnd = delta.offset + utf8Length(delta.data);\n\n  return delta.stream === \"stdout\"\n    ? { ...current, stdout: text, stdoutTruncated: truncated, stdoutEnd: streamEnd }\n    : { ...current, stderr: text, stderrTruncated: truncated, stderrEnd: streamEnd };\n}\n\n/**\n * Projects accumulated streams back onto a snapshot for rendering. The offset\n * bookkeeping stays here: it is how this client tracks its own position, not\n * something a consumer of a snapshot has any use for.\n */\nexport function withTaskStreams(snapshot: TaskSnapshot, streams: TaskStreams | undefined): TaskSnapshot {\n  if (!streams) return snapshot;\n  const merged: TaskSnapshot = { ...snapshot };\n  if (streams.stdout !== undefined) {\n    merged.stdout = streams.stdout;\n    merged.stdoutTruncated = streams.stdoutTruncated;\n  }\n  if (streams.stderr !== undefined) {\n    merged.stderr = streams.stderr;\n    merged.stderrTruncated = streams.stderrTruncated;\n  }\n  return merged;\n}\n"],"names":[],"mappings":";;AAyBO,MAAM,mBAAgC;AAAA,EAC3C,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX,WAAW;AACb;AAkBA,MAAM,UAAU,IAAI,YAAA;AAUpB,SAAS,WAAW,MAAsB;AACxC,SAAO,QAAQ,OAAO,IAAI,EAAE;AAC9B;AAeO,SAAS,qBAAqB,SAAsB,OAAqC;AAC9F,QAAM,OAAO,MAAM,WAAW,WAAW,QAAQ,SAAS,QAAQ;AAClE,QAAM,MAAM,MAAM,WAAW,WAAW,QAAQ,YAAY,QAAQ;AACpE,QAAM,YAAY,MAAM,UAAU,QAAQ,SAAS,UAAa,QAAQ,MAAM;AAC9E,QAAM,OAAO,YAAY,GAAG,IAAI,GAAG,MAAM,IAAI,KAAK,MAAM;AACxD,QAAM,eAAe,MAAM,WAAW,WAAW,QAAQ,kBAAkB,QAAQ;AACnF,QAAM,YAAY,MAAM,cAAc,aAAa;AACnD,QAAM,YAAY,MAAM,SAAS,WAAW,MAAM,IAAI;AAEtD,SAAO,MAAM,WAAW,WACpB,EAAE,GAAG,SAAS,QAAQ,MAAM,iBAAiB,WAAW,WAAW,UAAA,IACnE,EAAE,GAAG,SAAS,QAAQ,MAAM,iBAAiB,WAAW,WAAW,UAAA;AACzE;AAOO,SAAS,gBAAgB,UAAwB,SAAgD;AACtG,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,SAAuB,EAAE,GAAG,SAAA;AAClC,MAAI,QAAQ,WAAW,QAAW;AAChC,WAAO,SAAS,QAAQ;AACxB,WAAO,kBAAkB,QAAQ;AAAA,EACnC;AACA,MAAI,QAAQ,WAAW,QAAW;AAChC,WAAO,SAAS,QAAQ;AACxB,WAAO,kBAAkB,QAAQ;AAAA,EACnC;AACA,SAAO;AACT;;;;"}

package/dist/data/task-streams.d.ts

@@ -0,0 +1,60 @@
+import { TaskSnapshot } from './TaskSnapshot';
+/**
+ * A task's stdout/stderr arrive as append-only deltas on their own SSE frames,
+ * never on the task frames — clicky strips them there deliberately, so the tail
+ * of a long-running process is not re-sent every time a duration ticks over.
+ *
+ * That makes where a client keeps the accumulated text a correctness question,
+ * not a style one. Kept on the snapshot object, it is destroyed the next time a
+ * task frame replaces that object, and since the server only sends what a client
+ * has not seen it is never sent again — the output appears, vanishes a moment
+ * later, and only flickers back when the process happens to write more. So it is
+ * kept here instead, beside the snapshots rather than inside them, and merged in
+ * at the boundary.
+ */
+export interface TaskStreams {
+    stdout?: string;
+    stderr?: string;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    /** Absolute stream offset one past the last byte held, per stream. */
+    stdoutEnd: number;
+    stderrEnd: number;
+}
+export declare const emptyTaskStreams: TaskStreams;
+/**
+ * One `event: output` frame. `offset` is an ABSOLUTE position in the task's
+ * stream, not a length into what this client holds: on an append it is where
+ * `data` belongs, and on a `reset` it is where the server's retained tail now
+ * begins. `truncated` says bytes ahead of that point are gone for good.
+ */
+export interface TaskOutputDelta {
+    id: string;
+    groupId?: string;
+    stream: "stdout" | "stderr";
+    data: string;
+    offset: number;
+    reset?: boolean;
+    truncated?: boolean;
+}
+/**
+ * Applies one delta to what a task's streams already hold.
+ *
+ * Appending is only correct where the two actually meet — the client's own end
+ * is exactly the delta's start. Anything else is a replacement: an explicit
+ * `reset`, or a gap opened by a retained window that rolled past what this
+ * client last saw. Concatenating across such a gap would silently splice
+ * together two pieces of output that never ran together.
+ *
+ * Truncation carries across an append: dropping the head of a stream is not
+ * undone by writing more to its tail, so a frame that simply says nothing about
+ * it leaves the flag as it was, and only an explicit value changes it.
+ */
+export declare function applyTaskOutputDelta(current: TaskStreams, delta: TaskOutputDelta): TaskStreams;
+/**
+ * Projects accumulated streams back onto a snapshot for rendering. The offset
+ * bookkeeping stays here: it is how this client tracks its own position, not
+ * something a consumer of a snapshot has any use for.
+ */
+export declare function withTaskStreams(snapshot: TaskSnapshot, streams: TaskStreams | undefined): TaskSnapshot;
+//# sourceMappingURL=task-streams.d.ts.map

package/dist/data/task-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-streams.d.ts","sourceRoot":"","sources":["../../src/data/task-streams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,gBAAgB,EAAE,WAK9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAgBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,WAAW,CAY9F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,YAAY,CAYtG"}

package/dist/data/task-streams.js

@@ -0,0 +1,39 @@
+const emptyTaskStreams = {
+  stdoutTruncated: false,
+  stderrTruncated: false,
+  stdoutEnd: 0,
+  stderrEnd: 0
+};
+const encoder = new TextEncoder();
+function utf8Length(data) {
+  return encoder.encode(data).byteLength;
+}
+function applyTaskOutputDelta(current, delta) {
+  const held = delta.stream === "stdout" ? current.stdout : current.stderr;
+  const end = delta.stream === "stdout" ? current.stdoutEnd : current.stderrEnd;
+  const continues = delta.reset !== true && held !== void 0 && end === delta.offset;
+  const text = continues ? `${held}${delta.data}` : delta.data;
+  const wasTruncated = delta.stream === "stdout" ? current.stdoutTruncated : current.stderrTruncated;
+  const truncated = delta.truncated ?? (continues && wasTruncated);
+  const streamEnd = delta.offset + utf8Length(delta.data);
+  return delta.stream === "stdout" ? { ...current, stdout: text, stdoutTruncated: truncated, stdoutEnd: streamEnd } : { ...current, stderr: text, stderrTruncated: truncated, stderrEnd: streamEnd };
+}
+function withTaskStreams(snapshot, streams) {
+  if (!streams) return snapshot;
+  const merged = { ...snapshot };
+  if (streams.stdout !== void 0) {
+    merged.stdout = streams.stdout;
+    merged.stdoutTruncated = streams.stdoutTruncated;
+  }
+  if (streams.stderr !== void 0) {
+    merged.stderr = streams.stderr;
+    merged.stderrTruncated = streams.stderrTruncated;
+  }
+  return merged;
+}
+export {
+  applyTaskOutputDelta,
+  emptyTaskStreams,
+  withTaskStreams
+};
+//# sourceMappingURL=task-streams.js.map

package/dist/data/task-streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-streams.js","sources":["../../src/data/task-streams.ts"],"sourcesContent":["import type { TaskSnapshot } from \"./TaskSnapshot\";\n\n/**\n * A task's stdout/stderr arrive as append-only deltas on their own SSE frames,\n * never on the task frames — clicky strips them there deliberately, so the tail\n * of a long-running process is not re-sent every time a duration ticks over.\n *\n * That makes where a client keeps the accumulated text a correctness question,\n * not a style one. Kept on the snapshot object, it is destroyed the next time a\n * task frame replaces that object, and since the server only sends what a client\n * has not seen it is never sent again — the output appears, vanishes a moment\n * later, and only flickers back when the process happens to write more. So it is\n * kept here instead, beside the snapshots rather than inside them, and merged in\n * at the boundary.\n */\nexport interface TaskStreams {\n  stdout?: string;\n  stderr?: string;\n  stdoutTruncated: boolean;\n  stderrTruncated: boolean;\n  /** Absolute stream offset one past the last byte held, per stream. */\n  stdoutEnd: number;\n  stderrEnd: number;\n}\n\nexport const emptyTaskStreams: TaskStreams = {\n  stdoutTruncated: false,\n  stderrTruncated: false,\n  stdoutEnd: 0,\n  stderrEnd: 0,\n};\n\n/**\n * One `event: output` frame. `offset` is an ABSOLUTE position in the task's\n * stream, not a length into what this client holds: on an append it is where\n * `data` belongs, and on a `reset` it is where the server's retained tail now\n * begins. `truncated` says bytes ahead of that point are gone for good.\n */\nexport interface TaskOutputDelta {\n  id: string;\n  groupId?: string;\n  stream: \"stdout\" | \"stderr\";\n  data: string;\n  offset: number;\n  reset?: boolean;\n  truncated?: boolean;\n}\n\nconst encoder = new TextEncoder();\n\n/**\n * How far `data` advances the stream. Offsets are byte positions in the\n * process's own output, and a JS string measures UTF-16 code units — so `\"é\"`\n * counts as one there and as the two bytes the server actually wrote. Measuring\n * the wrong unit puts the client's end short of the next delta's start, and\n * every following frame is then read as a gap and replaces the text it should\n * have continued.\n */\nfunction utf8Length(data: string): number {\n  return encoder.encode(data).byteLength;\n}\n\n/**\n * Applies one delta to what a task's streams already hold.\n *\n * Appending is only correct where the two actually meet — the client's own end\n * is exactly the delta's start. Anything else is a replacement: an explicit\n * `reset`, or a gap opened by a retained window that rolled past what this\n * client last saw. Concatenating across such a gap would silently splice\n * together two pieces of output that never ran together.\n *\n * Truncation carries across an append: dropping the head of a stream is not\n * undone by writing more to its tail, so a frame that simply says nothing about\n * it leaves the flag as it was, and only an explicit value changes it.\n */\nexport function applyTaskOutputDelta(current: TaskStreams, delta: TaskOutputDelta): TaskStreams {\n  const held = delta.stream === \"stdout\" ? current.stdout : current.stderr;\n  const end = delta.stream === \"stdout\" ? current.stdoutEnd : current.stderrEnd;\n  const continues = delta.reset !== true && held !== undefined && end === delta.offset;\n  const text = continues ? `${held}${delta.data}` : delta.data;\n  const wasTruncated = delta.stream === \"stdout\" ? current.stdoutTruncated : current.stderrTruncated;\n  const truncated = delta.truncated ?? (continues && wasTruncated);\n  const streamEnd = delta.offset + utf8Length(delta.data);\n\n  return delta.stream === \"stdout\"\n    ? { ...current, stdout: text, stdoutTruncated: truncated, stdoutEnd: streamEnd }\n    : { ...current, stderr: text, stderrTruncated: truncated, stderrEnd: streamEnd };\n}\n\n/**\n * Projects accumulated streams back onto a snapshot for rendering. The offset\n * bookkeeping stays here: it is how this client tracks its own position, not\n * something a consumer of a snapshot has any use for.\n */\nexport function withTaskStreams(snapshot: TaskSnapshot, streams: TaskStreams | undefined): TaskSnapshot {\n  if (!streams) return snapshot;\n  const merged: TaskSnapshot = { ...snapshot };\n  if (streams.stdout !== undefined) {\n    merged.stdout = streams.stdout;\n    merged.stdoutTruncated = streams.stdoutTruncated;\n  }\n  if (streams.stderr !== undefined) {\n    merged.stderr = streams.stderr;\n    merged.stderrTruncated = streams.stderrTruncated;\n  }\n  return merged;\n}\n"],"names":[],"mappings":"AAyBO,MAAM,mBAAgC;AAAA,EAC3C,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX,WAAW;AACb;AAkBA,MAAM,UAAU,IAAI,YAAA;AAUpB,SAAS,WAAW,MAAsB;AACxC,SAAO,QAAQ,OAAO,IAAI,EAAE;AAC9B;AAeO,SAAS,qBAAqB,SAAsB,OAAqC;AAC9F,QAAM,OAAO,MAAM,WAAW,WAAW,QAAQ,SAAS,QAAQ;AAClE,QAAM,MAAM,MAAM,WAAW,WAAW,QAAQ,YAAY,QAAQ;AACpE,QAAM,YAAY,MAAM,UAAU,QAAQ,SAAS,UAAa,QAAQ,MAAM;AAC9E,QAAM,OAAO,YAAY,GAAG,IAAI,GAAG,MAAM,IAAI,KAAK,MAAM;AACxD,QAAM,eAAe,MAAM,WAAW,WAAW,QAAQ,kBAAkB,QAAQ;AACnF,QAAM,YAAY,MAAM,cAAc,aAAa;AACnD,QAAM,YAAY,MAAM,SAAS,WAAW,MAAM,IAAI;AAEtD,SAAO,MAAM,WAAW,WACpB,EAAE,GAAG,SAAS,QAAQ,MAAM,iBAAiB,WAAW,WAAW,UAAA,IACnE,EAAE,GAAG,SAAS,QAAQ,MAAM,iBAAiB,WAAW,WAAW,UAAA;AACzE;AAOO,SAAS,gBAAgB,UAAwB,SAAgD;AACtG,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,SAAuB,EAAE,GAAG,SAAA;AAClC,MAAI,QAAQ,WAAW,QAAW;AAChC,WAAO,SAAS,QAAQ;AACxB,WAAO,kBAAkB,QAAQ;AAAA,EACnC;AACA,MAAI,QAAQ,WAAW,QAAW;AAChC,WAAO,SAAS,QAAQ;AACxB,WAAO,kBAAkB,QAAQ;AAAA,EACnC;AACA,SAAO;AACT;"}

package/dist/data/task-work-progress.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function taskWorkProgress(run) {
+  const work = run.work;
+  const total = (work == null ? void 0 : work.total) ?? run.total ?? 0;
+  const completed = work ? work.completed + work.cached : run.completed ?? 0;
+  const failed = (work == null ? void 0 : work.failed) ?? run.failed ?? 0;
+  const running = (work == null ? void 0 : work.running) ?? run.running ?? 0;
+  const canceled = (work == null ? void 0 : work.canceled) ?? run.canceled ?? 0;
+  const unstarted = (work == null ? void 0 : work.unstarted) ?? 0;
+  return {
+    total,
+    completed,
+    failed,
+    running,
+    canceled,
+    unstarted,
+    done: completed + failed,
+    label: `${completed + failed}/${total} done${failed ? `, ${failed} failed` : ""}${(work == null ? void 0 : work.cached) ? `, ${work.cached} cached` : ""}${canceled ? `, ${canceled} canceled` : ""}${unstarted ? `, ${unstarted} unstarted` : ""}`,
+    counts: { ok: completed, warn: 0, fail: failed, run: running, canceled, unstarted, pending: Math.max(0, total - completed - failed - running - canceled - unstarted) }
+  };
+}
+exports.taskWorkProgress = taskWorkProgress;
+//# sourceMappingURL=task-work-progress.cjs.map

package/dist/data/task-work-progress.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-work-progress.cjs","sources":["../../src/data/task-work-progress.ts"],"sourcesContent":["import type { TaskRunMeta, TaskSnapshot } from \"./TaskSnapshot\";\n\nexport function taskWorkProgress(run: TaskSnapshot | TaskRunMeta) {\n  const work = run.work;\n  const total = work?.total ?? run.total ?? 0;\n  const completed = work ? work.completed + work.cached : run.completed ?? 0;\n  const failed = work?.failed ?? run.failed ?? 0;\n  const running = work?.running ?? run.running ?? 0;\n  const canceled = work?.canceled ?? run.canceled ?? 0;\n  const unstarted = work?.unstarted ?? 0;\n  return {\n    total, completed, failed, running, canceled, unstarted,\n    done: completed + failed,\n    label: `${completed + failed}/${total} done${failed ? `, ${failed} failed` : \"\"}${work?.cached ? `, ${work.cached} cached` : \"\"}${canceled ? `, ${canceled} canceled` : \"\"}${unstarted ? `, ${unstarted} unstarted` : \"\"}`,\n    counts: { ok: completed, warn: 0, fail: failed, run: running, canceled, unstarted, pending: Math.max(0, total - completed - failed - running - canceled - unstarted) },\n  };\n}\n"],"names":[],"mappings":";;AAEO,SAAS,iBAAiB,KAAiC;AAChE,QAAM,OAAO,IAAI;AACjB,QAAM,SAAQ,6BAAM,UAAS,IAAI,SAAS;AAC1C,QAAM,YAAY,OAAO,KAAK,YAAY,KAAK,SAAS,IAAI,aAAa;AACzE,QAAM,UAAS,6BAAM,WAAU,IAAI,UAAU;AAC7C,QAAM,WAAU,6BAAM,YAAW,IAAI,WAAW;AAChD,QAAM,YAAW,6BAAM,aAAY,IAAI,YAAY;AACnD,QAAM,aAAY,6BAAM,cAAa;AACrC,SAAO;AAAA,IACL;AAAA,IAAO;AAAA,IAAW;AAAA,IAAQ;AAAA,IAAS;AAAA,IAAU;AAAA,IAC7C,MAAM,YAAY;AAAA,IAClB,OAAO,GAAG,YAAY,MAAM,IAAI,KAAK,QAAQ,SAAS,KAAK,MAAM,YAAY,EAAE,IAAG,6BAAM,UAAS,KAAK,KAAK,MAAM,YAAY,EAAE,GAAG,WAAW,KAAK,QAAQ,cAAc,EAAE,GAAG,YAAY,KAAK,SAAS,eAAe,EAAE;AAAA,IACxN,QAAQ,EAAE,IAAI,WAAW,MAAM,GAAG,MAAM,QAAQ,KAAK,SAAS,UAAU,WAAW,SAAS,KAAK,IAAI,GAAG,QAAQ,YAAY,SAAS,UAAU,WAAW,SAAS,EAAA;AAAA,EAAE;AAEzK;;"}

package/dist/data/task-work-progress.d.ts

@@ -0,0 +1,21 @@
+import { TaskRunMeta, TaskSnapshot } from './TaskSnapshot';
+export declare function taskWorkProgress(run: TaskSnapshot | TaskRunMeta): {
+    total: number;
+    completed: number;
+    failed: number;
+    running: number;
+    canceled: number;
+    unstarted: number;
+    done: number;
+    label: string;
+    counts: {
+        ok: number;
+        warn: number;
+        fail: number;
+        run: number;
+        canceled: number;
+        unstarted: number;
+        pending: number;
+    };
+};
+//# sourceMappingURL=task-work-progress.d.ts.map

package/dist/data/task-work-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-work-progress.d.ts","sourceRoot":"","sources":["../../src/data/task-work-progress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEhE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,WAAW;;;;;;;;;;;;;;;;;;EAc/D"}

package/dist/data/task-work-progress.js

@@ -0,0 +1,24 @@
+function taskWorkProgress(run) {
+  const work = run.work;
+  const total = (work == null ? void 0 : work.total) ?? run.total ?? 0;
+  const completed = work ? work.completed + work.cached : run.completed ?? 0;
+  const failed = (work == null ? void 0 : work.failed) ?? run.failed ?? 0;
+  const running = (work == null ? void 0 : work.running) ?? run.running ?? 0;
+  const canceled = (work == null ? void 0 : work.canceled) ?? run.canceled ?? 0;
+  const unstarted = (work == null ? void 0 : work.unstarted) ?? 0;
+  return {
+    total,
+    completed,
+    failed,
+    running,
+    canceled,
+    unstarted,
+    done: completed + failed,
+    label: `${completed + failed}/${total} done${failed ? `, ${failed} failed` : ""}${(work == null ? void 0 : work.cached) ? `, ${work.cached} cached` : ""}${canceled ? `, ${canceled} canceled` : ""}${unstarted ? `, ${unstarted} unstarted` : ""}`,
+    counts: { ok: completed, warn: 0, fail: failed, run: running, canceled, unstarted, pending: Math.max(0, total - completed - failed - running - canceled - unstarted) }
+  };
+}
+export {
+  taskWorkProgress
+};
+//# sourceMappingURL=task-work-progress.js.map

package/dist/data/task-work-progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-work-progress.js","sources":["../../src/data/task-work-progress.ts"],"sourcesContent":["import type { TaskRunMeta, TaskSnapshot } from \"./TaskSnapshot\";\n\nexport function taskWorkProgress(run: TaskSnapshot | TaskRunMeta) {\n  const work = run.work;\n  const total = work?.total ?? run.total ?? 0;\n  const completed = work ? work.completed + work.cached : run.completed ?? 0;\n  const failed = work?.failed ?? run.failed ?? 0;\n  const running = work?.running ?? run.running ?? 0;\n  const canceled = work?.canceled ?? run.canceled ?? 0;\n  const unstarted = work?.unstarted ?? 0;\n  return {\n    total, completed, failed, running, canceled, unstarted,\n    done: completed + failed,\n    label: `${completed + failed}/${total} done${failed ? `, ${failed} failed` : \"\"}${work?.cached ? `, ${work.cached} cached` : \"\"}${canceled ? `, ${canceled} canceled` : \"\"}${unstarted ? `, ${unstarted} unstarted` : \"\"}`,\n    counts: { ok: completed, warn: 0, fail: failed, run: running, canceled, unstarted, pending: Math.max(0, total - completed - failed - running - canceled - unstarted) },\n  };\n}\n"],"names":[],"mappings":"AAEO,SAAS,iBAAiB,KAAiC;AAChE,QAAM,OAAO,IAAI;AACjB,QAAM,SAAQ,6BAAM,UAAS,IAAI,SAAS;AAC1C,QAAM,YAAY,OAAO,KAAK,YAAY,KAAK,SAAS,IAAI,aAAa;AACzE,QAAM,UAAS,6BAAM,WAAU,IAAI,UAAU;AAC7C,QAAM,WAAU,6BAAM,YAAW,IAAI,WAAW;AAChD,QAAM,YAAW,6BAAM,aAAY,IAAI,YAAY;AACnD,QAAM,aAAY,6BAAM,cAAa;AACrC,SAAO;AAAA,IACL;AAAA,IAAO;AAAA,IAAW;AAAA,IAAQ;AAAA,IAAS;AAAA,IAAU;AAAA,IAC7C,MAAM,YAAY;AAAA,IAClB,OAAO,GAAG,YAAY,MAAM,IAAI,KAAK,QAAQ,SAAS,KAAK,MAAM,YAAY,EAAE,IAAG,6BAAM,UAAS,KAAK,KAAK,MAAM,YAAY,EAAE,GAAG,WAAW,KAAK,QAAQ,cAAc,EAAE,GAAG,YAAY,KAAK,SAAS,eAAe,EAAE;AAAA,IACxN,QAAQ,EAAE,IAAI,WAAW,MAAM,GAAG,MAAM,QAAQ,KAAK,SAAS,UAAU,WAAW,SAAS,KAAK,IAAI,GAAG,QAAQ,YAAY,SAAS,UAAU,WAAW,SAAS,EAAA;AAAA,EAAE;AAEzK;"}

package/dist/data/test-runner/TestRunner.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { RunMeta, SnapshotStatus, Test } from './types';
 import { TestFilters } from './filterState';
 import { TestNodeAdapter, TestNodeAdapterRegistry } from './adapter';

package/dist/data/test-runner/adapter.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { Test } from './types';
 import { TestRunnerContext } from './context';
 export type AdapterContext = {

package/dist/data/test-runner/context.d.ts

@@ -42,6 +42,6 @@ export type TestRunnerContext = {
     /** Node adapters driving domain-specific rendering. */
     adapters: TestNodeAdapterRegistry;
 };
-export declare const TestRunnerProvider: import('../../../../../node_modules/@types/react/index.d.ts').Provider<TestRunnerContext | null>;
+export declare const TestRunnerProvider: import('react').Provider<TestRunnerContext | null>;
 export declare function useTestRunner(): TestRunnerContext;
 //# sourceMappingURL=context.d.ts.map

package/dist/data/use-data-table-virtual.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const reactVirtual = require("@tanstack/react-virtual");
+const DEFAULT_OVERSCAN = 8;
+const DEFAULT_ESTIMATE_ROW_HEIGHT = 40;
+function resolveVirtualizeOptions(virtualize) {
+  if (!virtualize) return null;
+  const opts = typeof virtualize === "object" ? virtualize : {};
+  return {
+    overscan: opts.overscan ?? DEFAULT_OVERSCAN,
+    estimateRowHeight: opts.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT
+  };
+}
+function spacerHeights(items, totalSize, scrollMargin) {
+  const first = items[0];
+  const last = items[items.length - 1];
+  if (!first || !last) return { top: 0, bottom: 0 };
+  return {
+    top: Math.max(0, first.start - scrollMargin),
+    bottom: Math.max(0, totalSize - (last.end - scrollMargin))
+  };
+}
+function useDataTableVirtual({
+  count,
+  options,
+  getItemKey
+}) {
+  const [scrollEl, setScrollEl] = react.useState(null);
+  const [tbodyEl, setTbodyEl] = react.useState(null);
+  const [scrollMargin, setScrollMargin] = react.useState(0);
+  react.useEffect(() => {
+    if (!options || !tbodyEl) return;
+    const measure = () => setScrollMargin(tbodyEl.offsetTop);
+    measure();
+    if (typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(measure);
+    if (tbodyEl.parentElement) observer.observe(tbodyEl.parentElement);
+    return () => observer.disconnect();
+  }, [options, tbodyEl]);
+  const estimateSize = react.useCallback(
+    () => (options == null ? void 0 : options.estimateRowHeight) ?? DEFAULT_ESTIMATE_ROW_HEIGHT,
+    [options == null ? void 0 : options.estimateRowHeight]
+  );
+  const virtualizer = reactVirtual.useVirtualizer({
+    count: options ? count : 0,
+    getScrollElement: () => scrollEl,
+    estimateSize,
+    overscan: (options == null ? void 0 : options.overscan) ?? DEFAULT_OVERSCAN,
+    getItemKey,
+    scrollMargin
+  });
+  const virtualItems = options ? virtualizer.getVirtualItems() : [];
+  const spacers = react.useMemo(
+    () => spacerHeights(virtualItems, virtualizer.getTotalSize(), scrollMargin),
+    // getTotalSize() is derived from the measurement cache, which the
+    // virtualizer mutates; virtualItems changing is the signal that it moved.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [virtualItems, scrollMargin]
+  );
+  return {
+    enabled: !!options,
+    setScrollEl,
+    setTbodyEl,
+    virtualizer,
+    virtualItems,
+    spacers
+  };
+}
+exports.resolveVirtualizeOptions = resolveVirtualizeOptions;
+exports.spacerHeights = spacerHeights;
+exports.useDataTableVirtual = useDataTableVirtual;
+//# sourceMappingURL=use-data-table-virtual.cjs.map

package/dist/data/use-data-table-virtual.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-virtual.cjs","sources":["../../src/data/use-data-table-virtual.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useState } from \"react\";\nimport { useVirtualizer } from \"@tanstack/react-virtual\";\n\n// Row virtualization for DataTable. A table of a few thousand rows costs tens of\n// thousands of DOM nodes (measured at ~48 per row on a real dashboard), which is\n// enough to stall first paint and make every subsequent re-render expensive.\n// Virtualizing keeps only the rows near the viewport in the DOM and represents\n// the rest with two spacer rows.\n//\n// This replaces an earlier `clientReveal` batch window, which kept a\n// `visibleCount` in component state and reset it whenever the `data` array\n// changed identity — so a parent that rebuilt its rows array (even with\n// identical contents) threw away everything the reader had scrolled to. There is\n// deliberately no window state here: scroll offset lives in the DOM and row\n// measurements are keyed by row id, so a same-content-new-identity array is a\n// no-op.\n//\n// Row heights are measured rather than assumed. Cells are `align-top` with\n// density padding and arbitrary caller-rendered content, so a fixed row height\n// would be wrong for any table with wrapping cells.\n\n/** Resolved form of the `virtualize` prop. */\nexport interface VirtualizeOptions {\n  overscan: number;\n  estimateRowHeight: number;\n}\n\n// Overscan is deliberately higher than the virtualizer's default of 5: a row\n// carrying wrapped text or a tag list can be several times the estimate, so a\n// tight window shows gaps while fast-scrolling.\nconst DEFAULT_OVERSCAN = 8;\n// A comfortable-density single-line row. Only the starting guess — every\n// rendered row is measured and the estimate stops mattering once it has been.\nconst DEFAULT_ESTIMATE_ROW_HEIGHT = 40;\n\nexport function resolveVirtualizeOptions(\n  virtualize: boolean | Partial<VirtualizeOptions> | undefined,\n): VirtualizeOptions | null {\n  if (!virtualize) return null;\n  const opts = typeof virtualize === \"object\" ? virtualize : {};\n  return {\n    overscan: opts.overscan ?? DEFAULT_OVERSCAN,\n    estimateRowHeight: opts.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT,\n  };\n}\n\n/** Heights of the spacer rows that stand in for the rows outside the window.\n *  `scrollMargin` is the distance from the scroll container's top to the first\n *  virtualized row — the sticky `<thead>` occupies real layout space, so\n *  without subtracting it every offset is shifted by the header's height. */\nexport function spacerHeights(\n  items: readonly { start: number; end: number }[],\n  totalSize: number,\n  scrollMargin: number,\n): { top: number; bottom: number } {\n  const first = items[0];\n  const last = items[items.length - 1];\n  if (!first || !last) return { top: 0, bottom: 0 };\n  return {\n    top: Math.max(0, first.start - scrollMargin),\n    bottom: Math.max(0, totalSize - (last.end - scrollMargin)),\n  };\n}\n\n/**\n * Wires a virtualizer to DataTable's own scroll container.\n *\n * The scroll element is tracked in state rather than a ref because\n * `getScrollElement` is read during render, before a ref would be attached, and\n * nothing would re-run the virtualizer once it was.\n */\nexport function useDataTableVirtual({\n  count,\n  options,\n  getItemKey,\n}: {\n  count: number;\n  options: VirtualizeOptions | null;\n  getItemKey: (index: number) => string;\n}) {\n  const [scrollEl, setScrollEl] = useState<HTMLDivElement | null>(null);\n  const [tbodyEl, setTbodyEl] = useState<HTMLTableSectionElement | null>(null);\n  const [scrollMargin, setScrollMargin] = useState(0);\n\n  // The sticky header sits inside the scroll container, so the first row starts\n  // below it. Re-measure when the header can change height: density switches and\n  // a filter bar that wraps at narrow widths both move it.\n  useEffect(() => {\n    if (!options || !tbodyEl) return;\n    const measure = () => setScrollMargin(tbodyEl.offsetTop);\n    measure();\n    if (typeof ResizeObserver === \"undefined\") return;\n    const observer = new ResizeObserver(measure);\n    if (tbodyEl.parentElement) observer.observe(tbodyEl.parentElement);\n    return () => observer.disconnect();\n  }, [options, tbodyEl]);\n\n  const estimateSize = useCallback(\n    () => options?.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT,\n    [options?.estimateRowHeight],\n  );\n\n  const virtualizer = useVirtualizer({\n    count: options ? count : 0,\n    getScrollElement: () => scrollEl,\n    estimateSize,\n    overscan: options?.overscan ?? DEFAULT_OVERSCAN,\n    getItemKey,\n    scrollMargin,\n  });\n\n  const virtualItems = options ? virtualizer.getVirtualItems() : [];\n  const spacers = useMemo(\n    () => spacerHeights(virtualItems, virtualizer.getTotalSize(), scrollMargin),\n    // getTotalSize() is derived from the measurement cache, which the\n    // virtualizer mutates; virtualItems changing is the signal that it moved.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [virtualItems, scrollMargin],\n  );\n\n  return {\n    enabled: !!options,\n    setScrollEl,\n    setTbodyEl,\n    virtualizer,\n    virtualItems,\n    spacers,\n  };\n}\n"],"names":["useState","useEffect","useCallback","useVirtualizer","useMemo"],"mappings":";;;;AA8BA,MAAM,mBAAmB;AAGzB,MAAM,8BAA8B;AAE7B,SAAS,yBACd,YAC0B;AAC1B,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,OAAO,OAAO,eAAe,WAAW,aAAa,CAAA;AAC3D,SAAO;AAAA,IACL,UAAU,KAAK,YAAY;AAAA,IAC3B,mBAAmB,KAAK,qBAAqB;AAAA,EAAA;AAEjD;AAMO,SAAS,cACd,OACA,WACA,cACiC;AACjC,QAAM,QAAQ,MAAM,CAAC;AACrB,QAAM,OAAO,MAAM,MAAM,SAAS,CAAC;AACnC,MAAI,CAAC,SAAS,CAAC,aAAa,EAAE,KAAK,GAAG,QAAQ,EAAA;AAC9C,SAAO;AAAA,IACL,KAAK,KAAK,IAAI,GAAG,MAAM,QAAQ,YAAY;AAAA,IAC3C,QAAQ,KAAK,IAAI,GAAG,aAAa,KAAK,MAAM,aAAa;AAAA,EAAA;AAE7D;AASO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIG;AACD,QAAM,CAAC,UAAU,WAAW,IAAIA,MAAAA,SAAgC,IAAI;AACpE,QAAM,CAAC,SAAS,UAAU,IAAIA,MAAAA,SAAyC,IAAI;AAC3E,QAAM,CAAC,cAAc,eAAe,IAAIA,MAAAA,SAAS,CAAC;AAKlDC,QAAAA,UAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,QAAS;AAC1B,UAAM,UAAU,MAAM,gBAAgB,QAAQ,SAAS;AACvD,YAAA;AACA,QAAI,OAAO,mBAAmB,YAAa;AAC3C,UAAM,WAAW,IAAI,eAAe,OAAO;AAC3C,QAAI,QAAQ,cAAe,UAAS,QAAQ,QAAQ,aAAa;AACjE,WAAO,MAAM,SAAS,WAAA;AAAA,EACxB,GAAG,CAAC,SAAS,OAAO,CAAC;AAErB,QAAM,eAAeC,MAAAA;AAAAA,IACnB,OAAM,mCAAS,sBAAqB;AAAA,IACpC,CAAC,mCAAS,iBAAiB;AAAA,EAAA;AAG7B,QAAM,cAAcC,aAAAA,eAAe;AAAA,IACjC,OAAO,UAAU,QAAQ;AAAA,IACzB,kBAAkB,MAAM;AAAA,IACxB;AAAA,IACA,WAAU,mCAAS,aAAY;AAAA,IAC/B;AAAA,IACA;AAAA,EAAA,CACD;AAED,QAAM,eAAe,UAAU,YAAY,gBAAA,IAAoB,CAAA;AAC/D,QAAM,UAAUC,MAAAA;AAAAA,IACd,MAAM,cAAc,cAAc,YAAY,aAAA,GAAgB,YAAY;AAAA;AAAA;AAAA;AAAA,IAI1E,CAAC,cAAc,YAAY;AAAA,EAAA;AAG7B,SAAO;AAAA,IACL,SAAS,CAAC,CAAC;AAAA,IACX;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;;;;"}

package/dist/data/use-data-table-virtual.d.ts

@@ -0,0 +1,40 @@
+/** Resolved form of the `virtualize` prop. */
+export interface VirtualizeOptions {
+    overscan: number;
+    estimateRowHeight: number;
+}
+export declare function resolveVirtualizeOptions(virtualize: boolean | Partial<VirtualizeOptions> | undefined): VirtualizeOptions | null;
+/** Heights of the spacer rows that stand in for the rows outside the window.
+ *  `scrollMargin` is the distance from the scroll container's top to the first
+ *  virtualized row — the sticky `<thead>` occupies real layout space, so
+ *  without subtracting it every offset is shifted by the header's height. */
+export declare function spacerHeights(items: readonly {
+    start: number;
+    end: number;
+}[], totalSize: number, scrollMargin: number): {
+    top: number;
+    bottom: number;
+};
+/**
+ * Wires a virtualizer to DataTable's own scroll container.
+ *
+ * The scroll element is tracked in state rather than a ref because
+ * `getScrollElement` is read during render, before a ref would be attached, and
+ * nothing would re-run the virtualizer once it was.
+ */
+export declare function useDataTableVirtual({ count, options, getItemKey, }: {
+    count: number;
+    options: VirtualizeOptions | null;
+    getItemKey: (index: number) => string;
+}): {
+    enabled: boolean;
+    setScrollEl: import('react').Dispatch<import('react').SetStateAction<HTMLDivElement | null>>;
+    setTbodyEl: import('react').Dispatch<import('react').SetStateAction<HTMLTableSectionElement | null>>;
+    virtualizer: import('@tanstack/react-virtual').ReactVirtualizer<HTMLDivElement, Element>;
+    virtualItems: import('@tanstack/react-virtual').VirtualItem[];
+    spacers: {
+        top: number;
+        bottom: number;
+    };
+};
+//# sourceMappingURL=use-data-table-virtual.d.ts.map

package/dist/data/use-data-table-virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-virtual.d.ts","sourceRoot":"","sources":["../../src/data/use-data-table-virtual.ts"],"names":[],"mappings":"AAqBA,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAUD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,SAAS,GAC3D,iBAAiB,GAAG,IAAI,CAO1B;AAED;;;6EAG6E;AAC7E,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,EAChD,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQjC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,OAAO,EACP,UAAU,GACX,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACvC;;;;;;;aAzBS,MAAM;gBAAU,MAAM;;EA0E/B"}

package/dist/data/use-data-table-virtual.js

@@ -0,0 +1,73 @@
+import { useState, useEffect, useCallback, useMemo } from "react";
+import { useVirtualizer } from "@tanstack/react-virtual";
+const DEFAULT_OVERSCAN = 8;
+const DEFAULT_ESTIMATE_ROW_HEIGHT = 40;
+function resolveVirtualizeOptions(virtualize) {
+  if (!virtualize) return null;
+  const opts = typeof virtualize === "object" ? virtualize : {};
+  return {
+    overscan: opts.overscan ?? DEFAULT_OVERSCAN,
+    estimateRowHeight: opts.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT
+  };
+}
+function spacerHeights(items, totalSize, scrollMargin) {
+  const first = items[0];
+  const last = items[items.length - 1];
+  if (!first || !last) return { top: 0, bottom: 0 };
+  return {
+    top: Math.max(0, first.start - scrollMargin),
+    bottom: Math.max(0, totalSize - (last.end - scrollMargin))
+  };
+}
+function useDataTableVirtual({
+  count,
+  options,
+  getItemKey
+}) {
+  const [scrollEl, setScrollEl] = useState(null);
+  const [tbodyEl, setTbodyEl] = useState(null);
+  const [scrollMargin, setScrollMargin] = useState(0);
+  useEffect(() => {
+    if (!options || !tbodyEl) return;
+    const measure = () => setScrollMargin(tbodyEl.offsetTop);
+    measure();
+    if (typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(measure);
+    if (tbodyEl.parentElement) observer.observe(tbodyEl.parentElement);
+    return () => observer.disconnect();
+  }, [options, tbodyEl]);
+  const estimateSize = useCallback(
+    () => (options == null ? void 0 : options.estimateRowHeight) ?? DEFAULT_ESTIMATE_ROW_HEIGHT,
+    [options == null ? void 0 : options.estimateRowHeight]
+  );
+  const virtualizer = useVirtualizer({
+    count: options ? count : 0,
+    getScrollElement: () => scrollEl,
+    estimateSize,
+    overscan: (options == null ? void 0 : options.overscan) ?? DEFAULT_OVERSCAN,
+    getItemKey,
+    scrollMargin
+  });
+  const virtualItems = options ? virtualizer.getVirtualItems() : [];
+  const spacers = useMemo(
+    () => spacerHeights(virtualItems, virtualizer.getTotalSize(), scrollMargin),
+    // getTotalSize() is derived from the measurement cache, which the
+    // virtualizer mutates; virtualItems changing is the signal that it moved.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [virtualItems, scrollMargin]
+  );
+  return {
+    enabled: !!options,
+    setScrollEl,
+    setTbodyEl,
+    virtualizer,
+    virtualItems,
+    spacers
+  };
+}
+export {
+  resolveVirtualizeOptions,
+  spacerHeights,
+  useDataTableVirtual
+};
+//# sourceMappingURL=use-data-table-virtual.js.map

package/dist/data/use-data-table-virtual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-virtual.js","sources":["../../src/data/use-data-table-virtual.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useState } from \"react\";\nimport { useVirtualizer } from \"@tanstack/react-virtual\";\n\n// Row virtualization for DataTable. A table of a few thousand rows costs tens of\n// thousands of DOM nodes (measured at ~48 per row on a real dashboard), which is\n// enough to stall first paint and make every subsequent re-render expensive.\n// Virtualizing keeps only the rows near the viewport in the DOM and represents\n// the rest with two spacer rows.\n//\n// This replaces an earlier `clientReveal` batch window, which kept a\n// `visibleCount` in component state and reset it whenever the `data` array\n// changed identity — so a parent that rebuilt its rows array (even with\n// identical contents) threw away everything the reader had scrolled to. There is\n// deliberately no window state here: scroll offset lives in the DOM and row\n// measurements are keyed by row id, so a same-content-new-identity array is a\n// no-op.\n//\n// Row heights are measured rather than assumed. Cells are `align-top` with\n// density padding and arbitrary caller-rendered content, so a fixed row height\n// would be wrong for any table with wrapping cells.\n\n/** Resolved form of the `virtualize` prop. */\nexport interface VirtualizeOptions {\n  overscan: number;\n  estimateRowHeight: number;\n}\n\n// Overscan is deliberately higher than the virtualizer's default of 5: a row\n// carrying wrapped text or a tag list can be several times the estimate, so a\n// tight window shows gaps while fast-scrolling.\nconst DEFAULT_OVERSCAN = 8;\n// A comfortable-density single-line row. Only the starting guess — every\n// rendered row is measured and the estimate stops mattering once it has been.\nconst DEFAULT_ESTIMATE_ROW_HEIGHT = 40;\n\nexport function resolveVirtualizeOptions(\n  virtualize: boolean | Partial<VirtualizeOptions> | undefined,\n): VirtualizeOptions | null {\n  if (!virtualize) return null;\n  const opts = typeof virtualize === \"object\" ? virtualize : {};\n  return {\n    overscan: opts.overscan ?? DEFAULT_OVERSCAN,\n    estimateRowHeight: opts.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT,\n  };\n}\n\n/** Heights of the spacer rows that stand in for the rows outside the window.\n *  `scrollMargin` is the distance from the scroll container's top to the first\n *  virtualized row — the sticky `<thead>` occupies real layout space, so\n *  without subtracting it every offset is shifted by the header's height. */\nexport function spacerHeights(\n  items: readonly { start: number; end: number }[],\n  totalSize: number,\n  scrollMargin: number,\n): { top: number; bottom: number } {\n  const first = items[0];\n  const last = items[items.length - 1];\n  if (!first || !last) return { top: 0, bottom: 0 };\n  return {\n    top: Math.max(0, first.start - scrollMargin),\n    bottom: Math.max(0, totalSize - (last.end - scrollMargin)),\n  };\n}\n\n/**\n * Wires a virtualizer to DataTable's own scroll container.\n *\n * The scroll element is tracked in state rather than a ref because\n * `getScrollElement` is read during render, before a ref would be attached, and\n * nothing would re-run the virtualizer once it was.\n */\nexport function useDataTableVirtual({\n  count,\n  options,\n  getItemKey,\n}: {\n  count: number;\n  options: VirtualizeOptions | null;\n  getItemKey: (index: number) => string;\n}) {\n  const [scrollEl, setScrollEl] = useState<HTMLDivElement | null>(null);\n  const [tbodyEl, setTbodyEl] = useState<HTMLTableSectionElement | null>(null);\n  const [scrollMargin, setScrollMargin] = useState(0);\n\n  // The sticky header sits inside the scroll container, so the first row starts\n  // below it. Re-measure when the header can change height: density switches and\n  // a filter bar that wraps at narrow widths both move it.\n  useEffect(() => {\n    if (!options || !tbodyEl) return;\n    const measure = () => setScrollMargin(tbodyEl.offsetTop);\n    measure();\n    if (typeof ResizeObserver === \"undefined\") return;\n    const observer = new ResizeObserver(measure);\n    if (tbodyEl.parentElement) observer.observe(tbodyEl.parentElement);\n    return () => observer.disconnect();\n  }, [options, tbodyEl]);\n\n  const estimateSize = useCallback(\n    () => options?.estimateRowHeight ?? DEFAULT_ESTIMATE_ROW_HEIGHT,\n    [options?.estimateRowHeight],\n  );\n\n  const virtualizer = useVirtualizer({\n    count: options ? count : 0,\n    getScrollElement: () => scrollEl,\n    estimateSize,\n    overscan: options?.overscan ?? DEFAULT_OVERSCAN,\n    getItemKey,\n    scrollMargin,\n  });\n\n  const virtualItems = options ? virtualizer.getVirtualItems() : [];\n  const spacers = useMemo(\n    () => spacerHeights(virtualItems, virtualizer.getTotalSize(), scrollMargin),\n    // getTotalSize() is derived from the measurement cache, which the\n    // virtualizer mutates; virtualItems changing is the signal that it moved.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [virtualItems, scrollMargin],\n  );\n\n  return {\n    enabled: !!options,\n    setScrollEl,\n    setTbodyEl,\n    virtualizer,\n    virtualItems,\n    spacers,\n  };\n}\n"],"names":[],"mappings":";;AA8BA,MAAM,mBAAmB;AAGzB,MAAM,8BAA8B;AAE7B,SAAS,yBACd,YAC0B;AAC1B,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,OAAO,OAAO,eAAe,WAAW,aAAa,CAAA;AAC3D,SAAO;AAAA,IACL,UAAU,KAAK,YAAY;AAAA,IAC3B,mBAAmB,KAAK,qBAAqB;AAAA,EAAA;AAEjD;AAMO,SAAS,cACd,OACA,WACA,cACiC;AACjC,QAAM,QAAQ,MAAM,CAAC;AACrB,QAAM,OAAO,MAAM,MAAM,SAAS,CAAC;AACnC,MAAI,CAAC,SAAS,CAAC,aAAa,EAAE,KAAK,GAAG,QAAQ,EAAA;AAC9C,SAAO;AAAA,IACL,KAAK,KAAK,IAAI,GAAG,MAAM,QAAQ,YAAY;AAAA,IAC3C,QAAQ,KAAK,IAAI,GAAG,aAAa,KAAK,MAAM,aAAa;AAAA,EAAA;AAE7D;AASO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIG;AACD,QAAM,CAAC,UAAU,WAAW,IAAI,SAAgC,IAAI;AACpE,QAAM,CAAC,SAAS,UAAU,IAAI,SAAyC,IAAI;AAC3E,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAKlD,YAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,QAAS;AAC1B,UAAM,UAAU,MAAM,gBAAgB,QAAQ,SAAS;AACvD,YAAA;AACA,QAAI,OAAO,mBAAmB,YAAa;AAC3C,UAAM,WAAW,IAAI,eAAe,OAAO;AAC3C,QAAI,QAAQ,cAAe,UAAS,QAAQ,QAAQ,aAAa;AACjE,WAAO,MAAM,SAAS,WAAA;AAAA,EACxB,GAAG,CAAC,SAAS,OAAO,CAAC;AAErB,QAAM,eAAe;AAAA,IACnB,OAAM,mCAAS,sBAAqB;AAAA,IACpC,CAAC,mCAAS,iBAAiB;AAAA,EAAA;AAG7B,QAAM,cAAc,eAAe;AAAA,IACjC,OAAO,UAAU,QAAQ;AAAA,IACzB,kBAAkB,MAAM;AAAA,IACxB;AAAA,IACA,WAAU,mCAAS,aAAY;AAAA,IAC/B;AAAA,IACA;AAAA,EAAA,CACD;AAED,QAAM,eAAe,UAAU,YAAY,gBAAA,IAAoB,CAAA;AAC/D,QAAM,UAAU;AAAA,IACd,MAAM,cAAc,cAAc,YAAY,aAAA,GAAgB,YAAY;AAAA;AAAA;AAAA;AAAA,IAI1E,CAAC,cAAc,YAAY;AAAA,EAAA;AAG7B,SAAO;AAAA,IACL,SAAS,CAAC,CAAC;AAAA,IACX;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/data/verification/VerificationResults.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from '../../../../../node_modules/@types/react/index.d.ts';
+import { ReactNode } from 'react';
 import { Test, TestFilters, TestNodeAdapterRegistry } from '../test-runner';
 import { VerifyReport } from './verify-report';
 export type VerificationResultsProps = {

package/dist/data/version-info.cjs

@@ -15,9 +15,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "3bff864a", ""),
-    tag: read(() => "clicky-ui@0.3.33", ""),
-    date: read(() => "2026-09-03T18:57:19.779Z", ""),
+    commit: read(() => "58ffac45", ""),
+    tag: read(() => "clicky-ui@0.3.35", ""),
+    date: read(() => "2026-09-09T07:42:58.997Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data/version-info.js

@@ -13,9 +13,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "3bff864a", ""),
-    tag: read(() => "clicky-ui@0.3.33", ""),
-    date: read(() => "2026-09-03T18:56:55.887Z", ""),
+    commit: read(() => "58ffac45", ""),
+    tag: read(() => "clicky-ui@0.3.35", ""),
+    date: read(() => "2026-09-09T07:42:26.563Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data.cjs

@@ -78,6 +78,11 @@ const Timeline = require("./data/Timeline.cjs");
 const debugConsoleSignal = require("./data/debugConsoleSignal.cjs");
 const useDebugAction = require("./data/useDebugAction.cjs");
 const TaskSnapshot = require("./data/TaskSnapshot.cjs");
+const TaskStreamTabs = require("./data/TaskStreamTabs.cjs");
+const TaskHeaderExtras = require("./data/TaskHeaderExtras.cjs");
+const TaskProcessMetadata = require("./data/TaskProcessMetadata.cjs");
+const taskMetadata = require("./data/task-metadata.cjs");
+const taskStreams = require("./data/task-streams.cjs");
 const taskStatus = require("./data/task-status.cjs");
 const taskCopy = require("./data/task-copy.cjs");
 const TaskProgress = require("./data/TaskProgress.cjs");
@@ -607,6 +612,15 @@ exports.subscribeToDebugConsole = debugConsoleSignal.subscribeToDebugConsole;
 exports.useDebugAction = useDebugAction.useDebugAction;
 exports.allGroupsTerminal = TaskSnapshot.allGroupsTerminal;
 exports.isTerminalStatus = TaskSnapshot.isTerminalStatus;
+exports.TaskStreamTabs = TaskStreamTabs.TaskStreamTabs;
+exports.TaskMetadataChips = TaskHeaderExtras.TaskMetadataChips;
+exports.TaskMetadata = TaskProcessMetadata.TaskMetadata;
+exports.isFlatMetadata = taskMetadata.isFlatMetadata;
+exports.isMetadataLink = taskMetadata.isMetadataLink;
+exports.metadataEntries = taskMetadata.metadataEntries;
+exports.applyTaskOutputDelta = taskStreams.applyTaskOutputDelta;
+exports.emptyTaskStreams = taskStreams.emptyTaskStreams;
+exports.withTaskStreams = taskStreams.withTaskStreams;
 exports.bucketTasks = taskStatus.bucketTasks;
 exports.logLevelColor = taskStatus.logLevelColor;
 exports.taskSegments = taskStatus.taskSegments;

package/dist/data.cjs.map

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

package/dist/data.d.ts

@@ -83,7 +83,12 @@ export * from './data/query-browser';
 export { debugCaptureHeaders, debugConsoleAvailable, debugConsoleOpen, DEBUG_CAPTURE_HEADER, registerDebugConsole, revealDebugConsole, DEBUG_REFRESH_INSPECTION_HEADER, setDebugCaptureLevel, setDebugConsoleOpen, setDebugRefreshInspection, subscribeToDebugConsole, type DebugConsoleRequest, } from './data/debugConsoleSignal';
 export { useDebugAction } from './data/useDebugAction';
 export * from './data/clicky-export';
-export { type LogEntry, type TaskControlAction, type TaskExecDetails, type TaskSnapshot, type TaskRunMeta, isTerminalStatus, allGroupsTerminal, } from './data/TaskSnapshot';
+export { type LogEntry, type TaskControlAction, type TaskExecDetails, type TaskProcessDetails, type TaskResourceLimits, type TaskSnapshot, type TaskRunMeta, isTerminalStatus, allGroupsTerminal, } from './data/TaskSnapshot';
+export { TaskStreamTabs, type TaskExtraTabs, type TaskStreamTab, } from './data/TaskStreamTabs';
+export { TaskMetadataChips, type TaskHeaderExtra } from './data/TaskHeaderExtras';
+export { TaskMetadata } from './data/TaskProcessMetadata';
+export { isFlatMetadata, isMetadataLink, metadataEntries, type MetadataEntry, type MetadataScalar, } from './data/task-metadata';
+export { applyTaskOutputDelta, emptyTaskStreams, withTaskStreams, type TaskOutputDelta, type TaskStreams, } from './data/task-streams';
 export { taskStatusColor, taskStatusIcon, taskStatusBg, logLevelColor, taskSegments, bucketTasks, } from './data/task-status';
 export { isFailedOrWarn, taskGroupErrorCount, taskGroupErrors, taskGroupJson, taskGroupMarkdown, taskMarkdown, } from './data/task-copy';
 export { TaskProgress, type TaskProgressProps } from './data/TaskProgress';