@flanksource/clicky-ui 0.3.16 → 0.3.18

package/dist/data/task-query-keys.js

@@ -0,0 +1,26 @@
+const taskQueryKeys = {
+  runs: ({ basePath, kind, status, labels }) => [
+    "tasks",
+    "runs",
+    {
+      basePath: basePath ?? "/api/v1",
+      kind: kind ?? "",
+      status: status ?? "",
+      labels: Object.entries(labels ?? {}).sort(([left], [right]) => left.localeCompare(right))
+    }
+  ],
+  run: ({ basePath, runId }) => [
+    "tasks",
+    "run",
+    { basePath: basePath ?? "/api/v1", runId }
+  ],
+  control: ({ basePath, runId }) => [
+    "tasks",
+    "control",
+    { basePath: basePath ?? "/api/v1", runId }
+  ]
+};
+export {
+  taskQueryKeys
+};
+//# sourceMappingURL=task-query-keys.js.map

package/dist/data/task-query-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-query-keys.js","sources":["../../src/data/task-query-keys.ts"],"sourcesContent":["export interface TaskRunsQueryKeyOptions {\n  basePath?: string | undefined;\n  kind?: string | undefined;\n  status?: string | undefined;\n  labels?: Record<string, string> | undefined;\n}\n\nexport interface TaskRunQueryKeyOptions {\n  basePath?: string | undefined;\n  runId: string;\n}\n\nexport const taskQueryKeys = {\n  runs: ({ basePath, kind, status, labels }: TaskRunsQueryKeyOptions) => [\n    \"tasks\",\n    \"runs\",\n    {\n      basePath: basePath ?? \"/api/v1\",\n      kind: kind ?? \"\",\n      status: status ?? \"\",\n      labels: Object.entries(labels ?? {}).sort(([left], [right]) => left.localeCompare(right)),\n    },\n  ] as const,\n  run: ({ basePath, runId }: TaskRunQueryKeyOptions) => [\n    \"tasks\",\n    \"run\",\n    { basePath: basePath ?? \"/api/v1\", runId },\n  ] as const,\n  control: ({ basePath, runId }: TaskRunQueryKeyOptions) => [\n    \"tasks\",\n    \"control\",\n    { basePath: basePath ?? \"/api/v1\", runId },\n  ] as const,\n};\n"],"names":[],"mappings":"AAYO,MAAM,gBAAgB;AAAA,EAC3B,MAAM,CAAC,EAAE,UAAU,MAAM,QAAQ,aAAsC;AAAA,IACrE;AAAA,IACA;AAAA,IACA;AAAA,MACE,UAAU,YAAY;AAAA,MACtB,MAAM,QAAQ;AAAA,MACd,QAAQ,UAAU;AAAA,MAClB,QAAQ,OAAO,QAAQ,UAAU,CAAA,CAAE,EAAE,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,cAAc,KAAK,CAAC;AAAA,IAAA;AAAA,EAC1F;AAAA,EAEF,KAAK,CAAC,EAAE,UAAU,YAAoC;AAAA,IACpD;AAAA,IACA;AAAA,IACA,EAAE,UAAU,YAAY,WAAW,MAAA;AAAA,EAAM;AAAA,EAE3C,SAAS,CAAC,EAAE,UAAU,YAAoC;AAAA,IACxD;AAAA,IACA;AAAA,IACA,EAAE,UAAU,YAAY,WAAW,MAAA;AAAA,EAAM;AAE7C;"}

package/dist/data/version-info.cjs

@@ -15,9 +15,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "d94d142e", ""),
-    tag: read(() => "clicky-ui@0.3.14", ""),
-    date: read(() => "2026-07-30T10:30:06.156Z", ""),
+    commit: read(() => "1cc7ff53", ""),
+    tag: read(() => "clicky-ui@0.3.17", ""),
+    date: read(() => "2026-08-07T05:49:35.093Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data/version-info.js

@@ -13,9 +13,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "d94d142e", ""),
-    tag: read(() => "clicky-ui@0.3.14", ""),
-    date: read(() => "2026-07-30T10:29:47.240Z", ""),
+    commit: read(() => "1cc7ff53", ""),
+    tag: read(() => "clicky-ui@0.3.17", ""),
+    date: read(() => "2026-08-07T05:49:15.068Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data.cjs

@@ -9,6 +9,8 @@ const CodeBlock = require("./data/CodeBlock.cjs");
 const CodeDiff = require("./data/CodeDiff.cjs");
 const codeDiff = require("./data/code-diff.cjs");
 const dataTableUtils = require("./data/data-table-utils.cjs");
+const dataTableFilterValues = require("./data/data-table-filter-values.cjs");
+const dataTableServerFilters = require("./data/data-table-server-filters.cjs");
 const DataTable = require("./data/DataTable.cjs");
 const DataTable_grouping = require("./data/DataTable.grouping.cjs");
 const StatStrip = require("./data/StatStrip.cjs");
@@ -16,6 +18,7 @@ const EntityCell = require("./data/cells/EntityCell.cjs");
 const Timestamp = require("./data/cells/Timestamp.cjs");
 const timestampFormat = require("./data/cells/timestamp-format.cjs");
 const TagList = require("./data/cells/TagList.cjs");
+const CellFilterActions = require("./data/cells/CellFilterActions.cjs");
 const tagUtils = require("./data/cells/tag-utils.cjs");
 const StatusDot = require("./data/cells/StatusDot.cjs");
 const statusMapping = require("./data/cells/status-mapping.cjs");
@@ -52,6 +55,8 @@ const ProgressBars = require("./data/ProgressBars.cjs");
 const ProgressBars_model = require("./data/ProgressBars.model.cjs");
 const TimeseriesCoreBars = require("./data/TimeseriesCoreBars.cjs");
 const GaugeHoverCard = require("./data/GaugeHoverCard.cjs");
+const ServerTimingBadge = require("./data/ServerTimingBadge.cjs");
+const serverTiming = require("./data/server-timing.cjs");
 const gaugeStats = require("./data/gauge-stats.cjs");
 const WorkloadCard = require("./data/WorkloadCard.cjs");
 const WorkloadCard_model = require("./data/WorkloadCard.model.cjs");
@@ -69,6 +74,7 @@ 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 taskQueryKeys = require("./data/task-query-keys.cjs");
 const TaskManagerButton = require("./data/TaskManagerButton.cjs");
 const PromptDialog = require("./data/PromptDialog.cjs");
 const PromptBanner = require("./data/PromptBanner.cjs");
@@ -425,6 +431,7 @@ const routePath = require("./data/test-runner/routePath.cjs");
 const fixtureFrontmatter = require("./data/FixtureEditor/fixture-frontmatter.cjs");
 const api = require("./data/cache-browser/api.cjs");
 const changeIconAliases = require("./icons/changeIconAliases.cjs");
+const registry = require("./icons/registry.cjs");
 const fixtureBlocks = require("./data/FixtureEditor/fixture-blocks.cjs");
 const filterState = require("./data/test-runner/filterState.cjs");
 const gitDates = require("./data/git/git-dates.cjs");
@@ -440,6 +447,13 @@ exports.CodeDiff = CodeDiff.CodeDiff;
 exports.computeLineDiff = codeDiff.computeLineDiff;
 exports.parseUnifiedDiff = codeDiff.parseUnifiedDiff;
 exports.inferColumns = dataTableUtils.inferColumns;
+exports.parseMultiFilterValue = dataTableFilterValues.parseMultiFilterValue;
+exports.serializeMultiFilterValue = dataTableFilterValues.serializeMultiFilterValue;
+exports.splitCommaValues = dataTableFilterValues.splitCommaValues;
+exports.updateFilterSelection = dataTableFilterValues.updateFilterSelection;
+exports.DATA_TABLE_FILTER_LOOKUP_LIMIT = dataTableServerFilters.DATA_TABLE_FILTER_LOOKUP_LIMIT;
+exports.serverColumnsToDataTableColumns = dataTableServerFilters.serverColumnsToDataTableColumns;
+exports.serverFiltersToFilterBar = dataTableServerFilters.serverFiltersToFilterBar;
 exports.DataTable = DataTable.DataTable;
 exports.groupRecords = DataTable_grouping.groupRecords;
 exports.isGroupCollapsedByDefault = DataTable_grouping.isGroupCollapsedByDefault;
@@ -454,6 +468,7 @@ exports.modeToFormat = timestampFormat.modeToFormat;
 exports.parseTimestamp = timestampFormat.parseTimestamp;
 exports.TagActionsProvider = TagList.TagActionsProvider;
 exports.TagList = TagList.TagList;
+exports.CellFilterActions = CellFilterActions.CellFilterActions;
 exports.normalizeTags = tagUtils.normalizeTags;
 exports.splitTagToken = tagUtils.splitTagToken;
 exports.tagActionsFromRecord = tagUtils.tagActionsFromRecord;
@@ -512,6 +527,11 @@ exports.ProgressBars = ProgressBars.ProgressBars;
 exports.deriveProgressBars = ProgressBars_model.deriveProgressBars;
 exports.TimeseriesCoreBars = TimeseriesCoreBars.TimeseriesCoreBars;
 exports.GaugeHoverCard = GaugeHoverCard.GaugeHoverCard;
+exports.ServerTimingBadge = ServerTimingBadge.ServerTimingBadge;
+exports.formatServerTimingDuration = serverTiming.formatServerTimingDuration;
+exports.parseServerTiming = serverTiming.parseServerTiming;
+exports.serverTimingCounterSummary = serverTiming.serverTimingCounterSummary;
+exports.serverTimingMetricLabel = serverTiming.serverTimingMetricLabel;
 exports.seriesStats = gaugeStats.seriesStats;
 exports.WorkloadCard = WorkloadCard.WorkloadCard;
 exports.formatReplicaCounts = WorkloadCard_model.formatReplicaCounts;
@@ -539,6 +559,7 @@ exports.taskStatusColor = taskStatus.taskStatusColor;
 exports.taskStatusIcon = taskStatus.taskStatusIcon;
 exports.TaskProgress = TaskProgress.TaskProgress;
 exports.TaskManager = TaskManager.TaskManager;
+exports.taskQueryKeys = taskQueryKeys.taskQueryKeys;
 exports.TaskManagerButton = TaskManagerButton.TaskManagerButton;
 exports.PromptDialog = PromptDialog.PromptDialog;
 exports.PromptBanner = PromptBanner.PromptBanner;
@@ -1215,6 +1236,8 @@ exports.cacheQueryKeys = api.cacheQueryKeys;
 exports.createCacheClient = api.createCacheClient;
 exports.changeIconAliases = changeIconAliases.changeIconAliases;
 exports.getChangeIcon = changeIconAliases.getChangeIcon;
+exports.clickyIconProvider = registry.clickyIconProvider;
+exports.iconsByConsumerName = registry.iconsByConsumerName;
 exports.createChecklistMarkdown = fixtureBlocks.createChecklistMarkdown;
 exports.createFenceMarkdown = fixtureBlocks.createFenceMarkdown;
 exports.fixtureFenceKind = fixtureBlocks.fixtureFenceKind;

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

@@ -7,13 +7,16 @@ export { CodeBlock, type CodeBlockProps } from './data/CodeBlock';
 export { CodeDiff, type CodeDiffProps, type CodeDiffView } from './data/CodeDiff';
 export { computeLineDiff, parseUnifiedDiff, type DiffHunk, type DiffLine, type DiffLineType, } from './data/code-diff';
 export { inferColumns } from './data/data-table-utils';
-export { DataTable, type DataTableColumn, type DataTableColumnInput, type DataTableColumnKind, type DataTableFooterContext, type DataTableMenuAction, type DataTableProps, type DataTableRowSelection, type DataTableSelectionContext, type StatusOptions, type TagsOptions, type TimestampOptions, } from './data/DataTable';
+export { parseMultiFilterValue, serializeMultiFilterValue, splitCommaValues, updateFilterSelection, type DataTableFilterSelection, } from './data/data-table-filter-values';
+export { DATA_TABLE_FILTER_LOOKUP_LIMIT, serverColumnsToDataTableColumns, serverFiltersToFilterBar, type DataTableColumnFilter, type DataTableFilterKind, type DataTableFilterLookup, type DataTableFilterLookupRequest, type DataTableFilterLookupResult, type DataTableFilterOption, type DataTableServerColumn, type ServerFilterBarOptions, type ServerFilterConfig, } from './data/data-table-server-filters';
+export { DataTable, type DataTableColumn, type DataTableColumnInput, type DataTableColumnKind, type DataTableCursorPagination, type DataTableFooterContext, type DataTableMenuAction, type DataTablePagination, type DataTableProps, type DataTableRowSelection, type DataTableSelectionContext, type StatusOptions, type TagsOptions, type TimestampOptions, } from './data/DataTable';
 export { groupRecords, isGroupCollapsedByDefault, type DataTableGroup, type DataTableGrouping, } from './data/DataTable.grouping';
 export { StatStrip, type StatStripClassNames, type StatStripItem, type StatStripProps, } from './data/StatStrip';
 export { EntityCell, type EntityCellProps, type EntityCellSize, } from './data/cells/EntityCell';
 export { Timestamp, type TimestampProps } from './data/cells/Timestamp';
 export { chooseTimestampFormat, formatDateTimeRelative, formatRelativeTime, formatTimestamp, parseTimestamp, modeToFormat, type TimestampFormat, type TimestampMode, } from './data/cells/timestamp-format';
 export { TagActionsProvider, TagList, type TagListProps } from './data/cells/TagList';
+export { CellFilterActions, type CellFilterChange, type CellFilterMode, } from './data/cells/CellFilterActions';
 export { normalizeTags, splitTagToken, tagActionsFromRecord, tagFilterTokens, useTagActions, useTagActionsValue, type NormalizedTag, type TagActionsContextValue, type TagFilterMode, type TagInput, type TagsValue, } from './data/cells/tag-utils';
 export { StatusDot, type StatusDotProps, type StatusDotSize } from './data/cells/StatusDot';
 export { normalizeStatus, STATUS_TOKEN_GROUPS } from './data/cells/status-mapping';
@@ -52,6 +55,8 @@ export { ProgressBars, type ProgressBarsOrientation, type ProgressBarsProps, typ
 export { deriveProgressBars, type ProgressBarFill, type ProgressBarsModel, } from './data/ProgressBars.model';
 export { TimeseriesCoreBars, type TimeseriesCoreBarsProps, } from './data/TimeseriesCoreBars';
 export { GaugeHoverCard, type GaugeHoverCardProps, type GaugeHoverRow, } from './data/GaugeHoverCard';
+export { ServerTimingBadge, type ServerTimingBadgeProps, } from './data/ServerTimingBadge';
+export { formatServerTimingDuration, parseServerTiming, serverTimingCounterSummary, serverTimingMetricLabel, type ServerTimingMetric, } from './data/server-timing';
 export { seriesStats, type SeriesStats } from './data/gauge-stats';
 export { WorkloadCard, type WorkloadCardProps, type WorkloadCardSize, type WorkloadCardVariant } from './data/WorkloadCard';
 export { formatReplicaCounts, workloadKindLabel, workloadStatusLabel, workloadStatusTone, type WorkloadCardCpuMetric, type WorkloadCardIcon, type WorkloadCardKind, type WorkloadCardMetrics, type WorkloadCardReplicas, type WorkloadCardResourceMetric, type WorkloadCardStatus, type WorkloadCardWorkload, } from './data/WorkloadCard.model';
@@ -69,10 +74,11 @@ export * from './data/git';
 export * from './data/test-runner';
 export * from './data/cache-browser';
 export * from './data/query-browser';
-export { type LogEntry, type TaskSnapshot, type TaskRunMeta, isTerminalStatus, allGroupsTerminal, } from './data/TaskSnapshot';
+export { type LogEntry, type TaskControlAction, type TaskSnapshot, type TaskRunMeta, isTerminalStatus, allGroupsTerminal, } from './data/TaskSnapshot';
 export { taskStatusColor, taskStatusIcon, taskStatusBg, logLevelColor, taskSegments, bucketTasks, } from './data/task-status';
 export { TaskProgress, type TaskProgressProps } from './data/TaskProgress';
 export { TaskManager, type TaskManagerProps } from './data/TaskManager';
+export { taskQueryKeys, type TaskRunQueryKeyOptions, type TaskRunsQueryKeyOptions, } from './data/task-query-keys';
 export { TaskManagerButton, type TaskManagerButtonProps } from './data/TaskManagerButton';
 export { PromptDialog, type PromptDialogProps } from './data/PromptDialog';
 export { PromptBanner, type PromptBannerProps } from './data/PromptBanner';

package/dist/data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../src/data.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../src/data.ts"],"names":[],"mappings":"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"}

package/dist/data.js

@@ -7,6 +7,8 @@ import { CodeBlock } from "./data/CodeBlock.js";
 import { CodeDiff } from "./data/CodeDiff.js";
 import { computeLineDiff, parseUnifiedDiff } from "./data/code-diff.js";
 import { inferColumns } from "./data/data-table-utils.js";
+import { parseMultiFilterValue, serializeMultiFilterValue, splitCommaValues, updateFilterSelection } from "./data/data-table-filter-values.js";
+import { DATA_TABLE_FILTER_LOOKUP_LIMIT, serverColumnsToDataTableColumns, serverFiltersToFilterBar } from "./data/data-table-server-filters.js";
 import { DataTable } from "./data/DataTable.js";
 import { groupRecords, isGroupCollapsedByDefault } from "./data/DataTable.grouping.js";
 import { StatStrip } from "./data/StatStrip.js";
@@ -14,6 +16,7 @@ import { EntityCell } from "./data/cells/EntityCell.js";
 import { Timestamp } from "./data/cells/Timestamp.js";
 import { chooseTimestampFormat, formatDateTimeRelative, formatRelativeTime, formatTimestamp, modeToFormat, parseTimestamp } from "./data/cells/timestamp-format.js";
 import { TagActionsProvider, TagList } from "./data/cells/TagList.js";
+import { CellFilterActions } from "./data/cells/CellFilterActions.js";
 import { normalizeTags, splitTagToken, tagActionsFromRecord, tagFilterTokens, useTagActions, useTagActionsValue } from "./data/cells/tag-utils.js";
 import { StatusDot } from "./data/cells/StatusDot.js";
 import { STATUS_TOKEN_GROUPS, normalizeStatus } from "./data/cells/status-mapping.js";
@@ -50,6 +53,8 @@ import { ProgressBars } from "./data/ProgressBars.js";
 import { deriveProgressBars } from "./data/ProgressBars.model.js";
 import { TimeseriesCoreBars } from "./data/TimeseriesCoreBars.js";
 import { GaugeHoverCard } from "./data/GaugeHoverCard.js";
+import { ServerTimingBadge } from "./data/ServerTimingBadge.js";
+import { formatServerTimingDuration, parseServerTiming, serverTimingCounterSummary, serverTimingMetricLabel } from "./data/server-timing.js";
 import { seriesStats } from "./data/gauge-stats.js";
 import { WorkloadCard } from "./data/WorkloadCard.js";
 import { formatReplicaCounts, workloadKindLabel, workloadStatusLabel, workloadStatusTone } from "./data/WorkloadCard.model.js";
@@ -67,6 +72,7 @@ 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 { taskQueryKeys } from "./data/task-query-keys.js";
 import { TaskManagerButton } from "./data/TaskManagerButton.js";
 import { PromptDialog } from "./data/PromptDialog.js";
 import { PromptBanner } from "./data/PromptBanner.js";
@@ -423,6 +429,7 @@ import { annotateRoutePaths, findNodeByRoutePath, slugify } from "./data/test-ru
 import { applyFixtureFrontmatterRaw, applyFixtureFrontmatterState, fixtureFrontmatterState, parseFixtureFrontmatter } from "./data/FixtureEditor/fixture-frontmatter.js";
 import { cacheQueryKeys, createCacheClient } from "./data/cache-browser/api.js";
 import { changeIconAliases, getChangeIcon } from "./icons/changeIconAliases.js";
+import { clickyIconProvider, iconsByConsumerName } from "./icons/registry.js";
 import { createChecklistMarkdown, createFenceMarkdown, fixtureFenceKind, fixtureFenceSchemaAliases, fixtureFenceSnippetInfo, parseFixtureYaml, resolveFixtureFenceSchema, schemaKeys, stringifyFixtureYaml } from "./data/FixtureEditor/fixture-blocks.js";
 import { cycleFilterState, decodeFilterState, emptyTestFilters, encodeFilterState, filterStateToRecord, matchesFilterState, recordToFilterState } from "./data/test-runner/filterState.js";
 import { formatGitCommitDateHeader } from "./data/git/git-dates.js";
@@ -440,9 +447,11 @@ export {
   CacheStatsOverview,
   CacheTree,
   CacheValue,
+  CellFilterActions,
   CodeBlock,
   CodeDiff,
   CopyBadge,
+  DATA_TABLE_FILTER_LOOKUP_LIMIT,
   DataTable,
   DiagnosticsDetailPanel,
   DiagnosticsTree,
@@ -491,6 +500,7 @@ export {
   SchemaFieldMetaPanel,
   SchemaViewer2 as SchemaViewer,
   SchemaViewerRow,
+  ServerTimingBadge,
   SignedDeltaBar,
   SortableHeader,
   StackTrace,
@@ -1129,6 +1139,7 @@ export {
   changeIconAliases,
   chooseTimestampFormat,
   clickyFormatForMarkdownPreview,
+  clickyIconProvider,
   collapseSingleChildChains,
   collectFrameworks,
   compactStackPath,
@@ -1162,6 +1173,7 @@ export {
   formatPropertyLabel,
   formatRelativeTime,
   formatReplicaCounts,
+  formatServerTimingDuration,
   formatTestDuration,
   formatTimestamp,
   frameHasSource,
@@ -1173,6 +1185,7 @@ export {
   hasHoverMeta,
   hasPending,
   humanizeName,
+  iconsByConsumerName,
   inferColumns,
   isApplicationStackFrame,
   isGroupCollapsedByDefault,
@@ -1196,6 +1209,8 @@ export {
   parseInlineJsonContextValue,
   parseJavaStackTrace,
   parseJvmThreadDump,
+  parseMultiFilterValue,
+  parseServerTiming,
   parseStackDump,
   parseTimestamp,
   parseUnifiedDiff,
@@ -1209,9 +1224,15 @@ export {
   resolveSeries,
   schemaKeys,
   segment,
+  serializeMultiFilterValue,
   seriesStats,
+  serverColumnsToDataTableColumns,
+  serverFiltersToFilterBar,
+  serverTimingCounterSummary,
+  serverTimingMetricLabel,
   setFallbackIconProvider,
   slugify,
+  splitCommaValues,
   splitTagToken,
   statusIconFor,
   statusToneFor,
@@ -1220,12 +1241,14 @@ export {
   sumNonTaskTests,
   tagActionsFromRecord,
   tagFilterTokens,
+  taskQueryKeys,
   taskSegments,
   taskStatusBg,
   taskStatusColor,
   taskStatusIcon,
   testStatus,
   totalDuration,
+  updateFilterSelection,
   usePrompts,
   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-hotkey.cjs

@@ -48,12 +48,17 @@ function isFormElement(target) {
   if (target.isContentEditable) return true;
   return ["INPUT", "TEXTAREA", "SELECT"].includes(target.tagName);
 }
+function eventOrigin(event) {
+  var _a;
+  return ((_a = event.composedPath) == null ? void 0 : _a.call(event)[0]) ?? event.target;
+}
 function onKeyDown(event) {
   if (event.defaultPrevented || event.isComposing) return;
+  const origin = eventOrigin(event);
   let winner;
   for (const registration of registrations) {
     if (!matches(event, registration.combo)) continue;
-    if (!registration.enableOnFormElements && isFormElement(event.target)) continue;
+    if (!registration.enableOnFormElements && isFormElement(origin)) continue;
     if (!winner || registration.priority >= winner.priority) winner = registration;
   }
   if (!winner) return;

package/dist/hooks/use-hotkey.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-hotkey.cjs","sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\n\n// A process-wide registry of global keyboard shortcuts, modeled on the escape\n// layer in ../overlay/modalStack. Bindings mount independently (no shared\n// provider), so the registry lives at module scope. Exactly ONE binding wins a\n// given key combo — the highest `priority`, breaking ties toward the most\n// recently mounted. Without that discipline every mounted component that binds\n// the same combo fires on one keypress, which is how two ⌘K search fields end\n// up racing to focus themselves.\n//\n// The listener is attached to `document`, matching modalStack, so hotkeys and\n// escape layers agree on event target and ordering.\n\ntype Registration = {\n  id: string;\n  combo: ParsedHotkey;\n  priority: number;\n  enableOnFormElements: boolean;\n  run: (event: KeyboardEvent) => void;\n};\n\nconst registrations: Registration[] = [];\nlet boundDocument: Document | null = null;\n\nexport type ParsedHotkey = {\n  /** Bare key, lower-cased (e.g. \"k\"). */\n  key: string;\n  /** Requires cmd on macOS / ctrl elsewhere. */\n  mod: boolean;\n  shift: boolean;\n  alt: boolean;\n};\n\nfunction isMacPlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  return /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent);\n}\n\n/**\n * Parses a combo string such as `\"mod+k\"` or `\"mod+shift+p\"`. `mod` means ⌘ on\n * macOS and Ctrl elsewhere. The last segment is the key; order is irrelevant.\n */\nexport function parseHotkey(combo: string): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((part) => part.trim().toLowerCase())\n    .filter(Boolean);\n  const key = parts[parts.length - 1];\n  if (!key) throw new Error(`useHotkey: empty combo \"${combo}\"`);\n  return {\n    key,\n    mod: parts.includes(\"mod\") || parts.includes(\"cmd\") || parts.includes(\"ctrl\"),\n    shift: parts.includes(\"shift\"),\n    alt: parts.includes(\"alt\") || parts.includes(\"option\"),\n  };\n}\n\n/**\n * Renders a combo for display — `\"mod+k\"` becomes `\"⌘K\"` on macOS and `\"Ctrl+K\"`\n * elsewhere. Deriving the label from the combo (rather than hand-authoring the\n * label and reverse-engineering the key from it) keeps the two in sync.\n */\nexport function formatHotkey(combo: string, platform?: \"mac\" | \"other\"): string {\n  const parsed = parseHotkey(combo);\n  const mac = platform ? platform === \"mac\" : isMacPlatform();\n  const key = parsed.key.length === 1 ? parsed.key.toUpperCase() : titleCase(parsed.key);\n  if (mac) {\n    return `${parsed.mod ? \"⌘\" : \"\"}${parsed.alt ? \"⌥\" : \"\"}${parsed.shift ? \"⇧\" : \"\"}${key}`;\n  }\n  const segments = [\n    ...(parsed.mod ? [\"Ctrl\"] : []),\n    ...(parsed.alt ? [\"Alt\"] : []),\n    ...(parsed.shift ? [\"Shift\"] : []),\n    key,\n  ];\n  return segments.join(\"+\");\n}\n\nfunction titleCase(value: string): string {\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n\nfunction matches(event: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (event.key.toLowerCase() !== combo.key) return false;\n  if (combo.mod !== (event.metaKey || event.ctrlKey)) return false;\n  if (combo.shift !== event.shiftKey) return false;\n  if (combo.alt !== event.altKey) return false;\n  return true;\n}\n\nfunction isFormElement(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  return [\"INPUT\", \"TEXTAREA\", \"SELECT\"].includes(target.tagName);\n}\n\nfunction onKeyDown(event: KeyboardEvent) {\n  if (event.defaultPrevented || event.isComposing) return;\n\n  // Highest priority wins; ties go to the most recently registered, so a\n  // transient surface layered over the page takes precedence over the chrome.\n  let winner: Registration | undefined;\n  for (const registration of registrations) {\n    if (!matches(event, registration.combo)) continue;\n    if (!registration.enableOnFormElements && isFormElement(event.target)) continue;\n    if (!winner || registration.priority >= winner.priority) winner = registration;\n  }\n  if (!winner) return;\n\n  event.preventDefault();\n  winner.run(event);\n}\n\nfunction ensureListener() {\n  if (boundDocument || typeof document === \"undefined\") return;\n  boundDocument = document;\n  boundDocument.addEventListener(\"keydown\", onKeyDown);\n}\n\nfunction unregister(id: string) {\n  const index = registrations.findIndex((entry) => entry.id === id);\n  if (index !== -1) registrations.splice(index, 1);\n\n  if (registrations.length === 0 && boundDocument) {\n    boundDocument.removeEventListener(\"keydown\", onKeyDown);\n    boundDocument = null;\n  }\n}\n\nexport type UseHotkeyOptions = {\n  /** Register the binding. Defaults to `true`. */\n  enabled?: boolean | undefined;\n  /**\n   * Ordering among bindings for the same combo. Higher wins; ties break toward\n   * the most recently mounted. Defaults to `0`.\n   */\n  priority?: number | undefined;\n  /**\n   * Fire while focus sits in an input, textarea, select, or contenteditable.\n   * Defaults to `true` for combos carrying a modifier (⌘K should work while\n   * typing) and `false` for bare keys (which would swallow ordinary typing).\n   */\n  enableOnFormElements?: boolean | undefined;\n};\n\n/**\n * Binds a global keyboard shortcut for as long as the component is mounted and\n * `enabled`. Pass `null`/`undefined` as the combo to bind nothing. Only the\n * winning registration for a combo runs, so overlapping bindings cannot both\n * fire on a single keypress.\n */\nexport function useHotkey(\n  combo: string | null | undefined,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const id = useId();\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n\n  const { enabled = true, priority = 0, enableOnFormElements } = options;\n\n  useEffect(() => {\n    if (!combo || !enabled) return;\n    const parsed = parseHotkey(combo);\n\n    ensureListener();\n    registrations.push({\n      id,\n      combo: parsed,\n      priority,\n      enableOnFormElements: enableOnFormElements ?? parsed.mod,\n      run: (event) => handlerRef.current(event),\n    });\n\n    return () => unregister(id);\n  }, [combo, enabled, priority, enableOnFormElements, id]);\n}\n"],"names":["useId","useRef","useEffect"],"mappings":"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"}
+{"version":3,"file":"use-hotkey.cjs","sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\n\n// A process-wide registry of global keyboard shortcuts, modeled on the escape\n// layer in ../overlay/modalStack. Bindings mount independently (no shared\n// provider), so the registry lives at module scope. Exactly ONE binding wins a\n// given key combo — the highest `priority`, breaking ties toward the most\n// recently mounted. Without that discipline every mounted component that binds\n// the same combo fires on one keypress, which is how two ⌘K search fields end\n// up racing to focus themselves.\n//\n// The listener is attached to `document`, matching modalStack, so hotkeys and\n// escape layers agree on event target and ordering.\n\ntype Registration = {\n  id: string;\n  combo: ParsedHotkey;\n  priority: number;\n  enableOnFormElements: boolean;\n  run: (event: KeyboardEvent) => void;\n};\n\nconst registrations: Registration[] = [];\nlet boundDocument: Document | null = null;\n\nexport type ParsedHotkey = {\n  /** Bare key, lower-cased (e.g. \"k\"). */\n  key: string;\n  /** Requires cmd on macOS / ctrl elsewhere. */\n  mod: boolean;\n  shift: boolean;\n  alt: boolean;\n};\n\nfunction isMacPlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  return /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent);\n}\n\n/**\n * Parses a combo string such as `\"mod+k\"` or `\"mod+shift+p\"`. `mod` means ⌘ on\n * macOS and Ctrl elsewhere. The last segment is the key; order is irrelevant.\n */\nexport function parseHotkey(combo: string): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((part) => part.trim().toLowerCase())\n    .filter(Boolean);\n  const key = parts[parts.length - 1];\n  if (!key) throw new Error(`useHotkey: empty combo \"${combo}\"`);\n  return {\n    key,\n    mod: parts.includes(\"mod\") || parts.includes(\"cmd\") || parts.includes(\"ctrl\"),\n    shift: parts.includes(\"shift\"),\n    alt: parts.includes(\"alt\") || parts.includes(\"option\"),\n  };\n}\n\n/**\n * Renders a combo for display — `\"mod+k\"` becomes `\"⌘K\"` on macOS and `\"Ctrl+K\"`\n * elsewhere. Deriving the label from the combo (rather than hand-authoring the\n * label and reverse-engineering the key from it) keeps the two in sync.\n */\nexport function formatHotkey(combo: string, platform?: \"mac\" | \"other\"): string {\n  const parsed = parseHotkey(combo);\n  const mac = platform ? platform === \"mac\" : isMacPlatform();\n  const key = parsed.key.length === 1 ? parsed.key.toUpperCase() : titleCase(parsed.key);\n  if (mac) {\n    return `${parsed.mod ? \"⌘\" : \"\"}${parsed.alt ? \"⌥\" : \"\"}${parsed.shift ? \"⇧\" : \"\"}${key}`;\n  }\n  const segments = [\n    ...(parsed.mod ? [\"Ctrl\"] : []),\n    ...(parsed.alt ? [\"Alt\"] : []),\n    ...(parsed.shift ? [\"Shift\"] : []),\n    key,\n  ];\n  return segments.join(\"+\");\n}\n\nfunction titleCase(value: string): string {\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n\nfunction matches(event: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (event.key.toLowerCase() !== combo.key) return false;\n  if (combo.mod !== (event.metaKey || event.ctrlKey)) return false;\n  if (combo.shift !== event.shiftKey) return false;\n  if (combo.alt !== event.altKey) return false;\n  return true;\n}\n\nfunction isFormElement(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  return [\"INPUT\", \"TEXTAREA\", \"SELECT\"].includes(target.tagName);\n}\n\n// Across a shadow boundary `event.target` is retargeted to the shadow HOST, so a\n// key typed into an input inside a shadow root looks like a bare keypress on a\n// <div> and would fire hotkeys that must not fire while typing. The composed\n// path's first entry is the true origin.\nfunction eventOrigin(event: KeyboardEvent): EventTarget | null {\n  return event.composedPath?.()[0] ?? event.target;\n}\n\nfunction onKeyDown(event: KeyboardEvent) {\n  if (event.defaultPrevented || event.isComposing) return;\n\n  // Highest priority wins; ties go to the most recently registered, so a\n  // transient surface layered over the page takes precedence over the chrome.\n  const origin = eventOrigin(event);\n  let winner: Registration | undefined;\n  for (const registration of registrations) {\n    if (!matches(event, registration.combo)) continue;\n    if (!registration.enableOnFormElements && isFormElement(origin)) continue;\n    if (!winner || registration.priority >= winner.priority) winner = registration;\n  }\n  if (!winner) return;\n\n  event.preventDefault();\n  winner.run(event);\n}\n\nfunction ensureListener() {\n  if (boundDocument || typeof document === \"undefined\") return;\n  boundDocument = document;\n  boundDocument.addEventListener(\"keydown\", onKeyDown);\n}\n\nfunction unregister(id: string) {\n  const index = registrations.findIndex((entry) => entry.id === id);\n  if (index !== -1) registrations.splice(index, 1);\n\n  if (registrations.length === 0 && boundDocument) {\n    boundDocument.removeEventListener(\"keydown\", onKeyDown);\n    boundDocument = null;\n  }\n}\n\nexport type UseHotkeyOptions = {\n  /** Register the binding. Defaults to `true`. */\n  enabled?: boolean | undefined;\n  /**\n   * Ordering among bindings for the same combo. Higher wins; ties break toward\n   * the most recently mounted. Defaults to `0`.\n   */\n  priority?: number | undefined;\n  /**\n   * Fire while focus sits in an input, textarea, select, or contenteditable.\n   * Defaults to `true` for combos carrying a modifier (⌘K should work while\n   * typing) and `false` for bare keys (which would swallow ordinary typing).\n   */\n  enableOnFormElements?: boolean | undefined;\n};\n\n/**\n * Binds a global keyboard shortcut for as long as the component is mounted and\n * `enabled`. Pass `null`/`undefined` as the combo to bind nothing. Only the\n * winning registration for a combo runs, so overlapping bindings cannot both\n * fire on a single keypress.\n */\nexport function useHotkey(\n  combo: string | null | undefined,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const id = useId();\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n\n  const { enabled = true, priority = 0, enableOnFormElements } = options;\n\n  useEffect(() => {\n    if (!combo || !enabled) return;\n    const parsed = parseHotkey(combo);\n\n    ensureListener();\n    registrations.push({\n      id,\n      combo: parsed,\n      priority,\n      enableOnFormElements: enableOnFormElements ?? parsed.mod,\n      run: (event) => handlerRef.current(event),\n    });\n\n    return () => unregister(id);\n  }, [combo, enabled, priority, enableOnFormElements, id]);\n}\n"],"names":["useId","useRef","useEffect"],"mappings":"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"}

package/dist/hooks/use-hotkey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-hotkey.d.ts","sourceRoot":"","sources":["../../src/hooks/use-hotkey.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,YAAY,GAAG;IACzB,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAOF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAavD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAc9E;AAqDD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EACvC,OAAO,GAAE,gBAAqB,GAC7B,IAAI,CAsBN"}
+{"version":3,"file":"use-hotkey.d.ts","sourceRoot":"","sources":["../../src/hooks/use-hotkey.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,YAAY,GAAG;IACzB,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAOF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAavD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAc9E;AA8DD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EACvC,OAAO,GAAE,gBAAqB,GAC7B,IAAI,CAsBN"}

package/dist/hooks/use-hotkey.js

@@ -46,12 +46,17 @@ function isFormElement(target) {
   if (target.isContentEditable) return true;
   return ["INPUT", "TEXTAREA", "SELECT"].includes(target.tagName);
 }
+function eventOrigin(event) {
+  var _a;
+  return ((_a = event.composedPath) == null ? void 0 : _a.call(event)[0]) ?? event.target;
+}
 function onKeyDown(event) {
   if (event.defaultPrevented || event.isComposing) return;
+  const origin = eventOrigin(event);
   let winner;
   for (const registration of registrations) {
     if (!matches(event, registration.combo)) continue;
-    if (!registration.enableOnFormElements && isFormElement(event.target)) continue;
+    if (!registration.enableOnFormElements && isFormElement(origin)) continue;
     if (!winner || registration.priority >= winner.priority) winner = registration;
   }
   if (!winner) return;

package/dist/hooks/use-hotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-hotkey.js","sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\n\n// A process-wide registry of global keyboard shortcuts, modeled on the escape\n// layer in ../overlay/modalStack. Bindings mount independently (no shared\n// provider), so the registry lives at module scope. Exactly ONE binding wins a\n// given key combo — the highest `priority`, breaking ties toward the most\n// recently mounted. Without that discipline every mounted component that binds\n// the same combo fires on one keypress, which is how two ⌘K search fields end\n// up racing to focus themselves.\n//\n// The listener is attached to `document`, matching modalStack, so hotkeys and\n// escape layers agree on event target and ordering.\n\ntype Registration = {\n  id: string;\n  combo: ParsedHotkey;\n  priority: number;\n  enableOnFormElements: boolean;\n  run: (event: KeyboardEvent) => void;\n};\n\nconst registrations: Registration[] = [];\nlet boundDocument: Document | null = null;\n\nexport type ParsedHotkey = {\n  /** Bare key, lower-cased (e.g. \"k\"). */\n  key: string;\n  /** Requires cmd on macOS / ctrl elsewhere. */\n  mod: boolean;\n  shift: boolean;\n  alt: boolean;\n};\n\nfunction isMacPlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  return /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent);\n}\n\n/**\n * Parses a combo string such as `\"mod+k\"` or `\"mod+shift+p\"`. `mod` means ⌘ on\n * macOS and Ctrl elsewhere. The last segment is the key; order is irrelevant.\n */\nexport function parseHotkey(combo: string): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((part) => part.trim().toLowerCase())\n    .filter(Boolean);\n  const key = parts[parts.length - 1];\n  if (!key) throw new Error(`useHotkey: empty combo \"${combo}\"`);\n  return {\n    key,\n    mod: parts.includes(\"mod\") || parts.includes(\"cmd\") || parts.includes(\"ctrl\"),\n    shift: parts.includes(\"shift\"),\n    alt: parts.includes(\"alt\") || parts.includes(\"option\"),\n  };\n}\n\n/**\n * Renders a combo for display — `\"mod+k\"` becomes `\"⌘K\"` on macOS and `\"Ctrl+K\"`\n * elsewhere. Deriving the label from the combo (rather than hand-authoring the\n * label and reverse-engineering the key from it) keeps the two in sync.\n */\nexport function formatHotkey(combo: string, platform?: \"mac\" | \"other\"): string {\n  const parsed = parseHotkey(combo);\n  const mac = platform ? platform === \"mac\" : isMacPlatform();\n  const key = parsed.key.length === 1 ? parsed.key.toUpperCase() : titleCase(parsed.key);\n  if (mac) {\n    return `${parsed.mod ? \"⌘\" : \"\"}${parsed.alt ? \"⌥\" : \"\"}${parsed.shift ? \"⇧\" : \"\"}${key}`;\n  }\n  const segments = [\n    ...(parsed.mod ? [\"Ctrl\"] : []),\n    ...(parsed.alt ? [\"Alt\"] : []),\n    ...(parsed.shift ? [\"Shift\"] : []),\n    key,\n  ];\n  return segments.join(\"+\");\n}\n\nfunction titleCase(value: string): string {\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n\nfunction matches(event: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (event.key.toLowerCase() !== combo.key) return false;\n  if (combo.mod !== (event.metaKey || event.ctrlKey)) return false;\n  if (combo.shift !== event.shiftKey) return false;\n  if (combo.alt !== event.altKey) return false;\n  return true;\n}\n\nfunction isFormElement(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  return [\"INPUT\", \"TEXTAREA\", \"SELECT\"].includes(target.tagName);\n}\n\nfunction onKeyDown(event: KeyboardEvent) {\n  if (event.defaultPrevented || event.isComposing) return;\n\n  // Highest priority wins; ties go to the most recently registered, so a\n  // transient surface layered over the page takes precedence over the chrome.\n  let winner: Registration | undefined;\n  for (const registration of registrations) {\n    if (!matches(event, registration.combo)) continue;\n    if (!registration.enableOnFormElements && isFormElement(event.target)) continue;\n    if (!winner || registration.priority >= winner.priority) winner = registration;\n  }\n  if (!winner) return;\n\n  event.preventDefault();\n  winner.run(event);\n}\n\nfunction ensureListener() {\n  if (boundDocument || typeof document === \"undefined\") return;\n  boundDocument = document;\n  boundDocument.addEventListener(\"keydown\", onKeyDown);\n}\n\nfunction unregister(id: string) {\n  const index = registrations.findIndex((entry) => entry.id === id);\n  if (index !== -1) registrations.splice(index, 1);\n\n  if (registrations.length === 0 && boundDocument) {\n    boundDocument.removeEventListener(\"keydown\", onKeyDown);\n    boundDocument = null;\n  }\n}\n\nexport type UseHotkeyOptions = {\n  /** Register the binding. Defaults to `true`. */\n  enabled?: boolean | undefined;\n  /**\n   * Ordering among bindings for the same combo. Higher wins; ties break toward\n   * the most recently mounted. Defaults to `0`.\n   */\n  priority?: number | undefined;\n  /**\n   * Fire while focus sits in an input, textarea, select, or contenteditable.\n   * Defaults to `true` for combos carrying a modifier (⌘K should work while\n   * typing) and `false` for bare keys (which would swallow ordinary typing).\n   */\n  enableOnFormElements?: boolean | undefined;\n};\n\n/**\n * Binds a global keyboard shortcut for as long as the component is mounted and\n * `enabled`. Pass `null`/`undefined` as the combo to bind nothing. Only the\n * winning registration for a combo runs, so overlapping bindings cannot both\n * fire on a single keypress.\n */\nexport function useHotkey(\n  combo: string | null | undefined,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const id = useId();\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n\n  const { enabled = true, priority = 0, enableOnFormElements } = options;\n\n  useEffect(() => {\n    if (!combo || !enabled) return;\n    const parsed = parseHotkey(combo);\n\n    ensureListener();\n    registrations.push({\n      id,\n      combo: parsed,\n      priority,\n      enableOnFormElements: enableOnFormElements ?? parsed.mod,\n      run: (event) => handlerRef.current(event),\n    });\n\n    return () => unregister(id);\n  }, [combo, enabled, priority, enableOnFormElements, id]);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-hotkey.js","sources":["../../src/hooks/use-hotkey.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\n\n// A process-wide registry of global keyboard shortcuts, modeled on the escape\n// layer in ../overlay/modalStack. Bindings mount independently (no shared\n// provider), so the registry lives at module scope. Exactly ONE binding wins a\n// given key combo — the highest `priority`, breaking ties toward the most\n// recently mounted. Without that discipline every mounted component that binds\n// the same combo fires on one keypress, which is how two ⌘K search fields end\n// up racing to focus themselves.\n//\n// The listener is attached to `document`, matching modalStack, so hotkeys and\n// escape layers agree on event target and ordering.\n\ntype Registration = {\n  id: string;\n  combo: ParsedHotkey;\n  priority: number;\n  enableOnFormElements: boolean;\n  run: (event: KeyboardEvent) => void;\n};\n\nconst registrations: Registration[] = [];\nlet boundDocument: Document | null = null;\n\nexport type ParsedHotkey = {\n  /** Bare key, lower-cased (e.g. \"k\"). */\n  key: string;\n  /** Requires cmd on macOS / ctrl elsewhere. */\n  mod: boolean;\n  shift: boolean;\n  alt: boolean;\n};\n\nfunction isMacPlatform(): boolean {\n  if (typeof navigator === \"undefined\") return false;\n  return /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent);\n}\n\n/**\n * Parses a combo string such as `\"mod+k\"` or `\"mod+shift+p\"`. `mod` means ⌘ on\n * macOS and Ctrl elsewhere. The last segment is the key; order is irrelevant.\n */\nexport function parseHotkey(combo: string): ParsedHotkey {\n  const parts = combo\n    .split(\"+\")\n    .map((part) => part.trim().toLowerCase())\n    .filter(Boolean);\n  const key = parts[parts.length - 1];\n  if (!key) throw new Error(`useHotkey: empty combo \"${combo}\"`);\n  return {\n    key,\n    mod: parts.includes(\"mod\") || parts.includes(\"cmd\") || parts.includes(\"ctrl\"),\n    shift: parts.includes(\"shift\"),\n    alt: parts.includes(\"alt\") || parts.includes(\"option\"),\n  };\n}\n\n/**\n * Renders a combo for display — `\"mod+k\"` becomes `\"⌘K\"` on macOS and `\"Ctrl+K\"`\n * elsewhere. Deriving the label from the combo (rather than hand-authoring the\n * label and reverse-engineering the key from it) keeps the two in sync.\n */\nexport function formatHotkey(combo: string, platform?: \"mac\" | \"other\"): string {\n  const parsed = parseHotkey(combo);\n  const mac = platform ? platform === \"mac\" : isMacPlatform();\n  const key = parsed.key.length === 1 ? parsed.key.toUpperCase() : titleCase(parsed.key);\n  if (mac) {\n    return `${parsed.mod ? \"⌘\" : \"\"}${parsed.alt ? \"⌥\" : \"\"}${parsed.shift ? \"⇧\" : \"\"}${key}`;\n  }\n  const segments = [\n    ...(parsed.mod ? [\"Ctrl\"] : []),\n    ...(parsed.alt ? [\"Alt\"] : []),\n    ...(parsed.shift ? [\"Shift\"] : []),\n    key,\n  ];\n  return segments.join(\"+\");\n}\n\nfunction titleCase(value: string): string {\n  return value.charAt(0).toUpperCase() + value.slice(1);\n}\n\nfunction matches(event: KeyboardEvent, combo: ParsedHotkey): boolean {\n  if (event.key.toLowerCase() !== combo.key) return false;\n  if (combo.mod !== (event.metaKey || event.ctrlKey)) return false;\n  if (combo.shift !== event.shiftKey) return false;\n  if (combo.alt !== event.altKey) return false;\n  return true;\n}\n\nfunction isFormElement(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  return [\"INPUT\", \"TEXTAREA\", \"SELECT\"].includes(target.tagName);\n}\n\n// Across a shadow boundary `event.target` is retargeted to the shadow HOST, so a\n// key typed into an input inside a shadow root looks like a bare keypress on a\n// <div> and would fire hotkeys that must not fire while typing. The composed\n// path's first entry is the true origin.\nfunction eventOrigin(event: KeyboardEvent): EventTarget | null {\n  return event.composedPath?.()[0] ?? event.target;\n}\n\nfunction onKeyDown(event: KeyboardEvent) {\n  if (event.defaultPrevented || event.isComposing) return;\n\n  // Highest priority wins; ties go to the most recently registered, so a\n  // transient surface layered over the page takes precedence over the chrome.\n  const origin = eventOrigin(event);\n  let winner: Registration | undefined;\n  for (const registration of registrations) {\n    if (!matches(event, registration.combo)) continue;\n    if (!registration.enableOnFormElements && isFormElement(origin)) continue;\n    if (!winner || registration.priority >= winner.priority) winner = registration;\n  }\n  if (!winner) return;\n\n  event.preventDefault();\n  winner.run(event);\n}\n\nfunction ensureListener() {\n  if (boundDocument || typeof document === \"undefined\") return;\n  boundDocument = document;\n  boundDocument.addEventListener(\"keydown\", onKeyDown);\n}\n\nfunction unregister(id: string) {\n  const index = registrations.findIndex((entry) => entry.id === id);\n  if (index !== -1) registrations.splice(index, 1);\n\n  if (registrations.length === 0 && boundDocument) {\n    boundDocument.removeEventListener(\"keydown\", onKeyDown);\n    boundDocument = null;\n  }\n}\n\nexport type UseHotkeyOptions = {\n  /** Register the binding. Defaults to `true`. */\n  enabled?: boolean | undefined;\n  /**\n   * Ordering among bindings for the same combo. Higher wins; ties break toward\n   * the most recently mounted. Defaults to `0`.\n   */\n  priority?: number | undefined;\n  /**\n   * Fire while focus sits in an input, textarea, select, or contenteditable.\n   * Defaults to `true` for combos carrying a modifier (⌘K should work while\n   * typing) and `false` for bare keys (which would swallow ordinary typing).\n   */\n  enableOnFormElements?: boolean | undefined;\n};\n\n/**\n * Binds a global keyboard shortcut for as long as the component is mounted and\n * `enabled`. Pass `null`/`undefined` as the combo to bind nothing. Only the\n * winning registration for a combo runs, so overlapping bindings cannot both\n * fire on a single keypress.\n */\nexport function useHotkey(\n  combo: string | null | undefined,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {},\n): void {\n  const id = useId();\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n\n  const { enabled = true, priority = 0, enableOnFormElements } = options;\n\n  useEffect(() => {\n    if (!combo || !enabled) return;\n    const parsed = parseHotkey(combo);\n\n    ensureListener();\n    registrations.push({\n      id,\n      combo: parsed,\n      priority,\n      enableOnFormElements: enableOnFormElements ?? parsed.mod,\n      run: (event) => handlerRef.current(event),\n    });\n\n    return () => unregister(id);\n  }, [combo, enabled, priority, enableOnFormElements, id]);\n}\n"],"names":[],"mappings":"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"}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("react");
 const TaskSnapshot = require("../data/TaskSnapshot.cjs");
+const taskQueryKeys = require("../data/task-query-keys.cjs");
 const DEFAULT_BASE = "/api/v1";
 const DEFAULT_POLL_MS = 2e3;
 function streamUrl(base, query) {
@@ -122,7 +123,7 @@ function useTaskRuns(options = {}) {
     pollMs = DEFAULT_POLL_MS,
     forcePoll = false
   } = options;
-  const [runs, setRuns] = react.useState([]);
+  const [received, setReceived] = react.useState({ key: null, runs: [] });
   const [status, setStatus] = react.useState("idle");
   react.useEffect(() => {
     if (!enabled) return;
@@ -131,6 +132,8 @@ function useTaskRuns(options = {}) {
     if (statusFilter) params.set("status", statusFilter);
     for (const [k, v] of Object.entries(labels ?? {})) params.append("label", `${k}=${v}`);
     const query = params.toString();
+    const requestKey = taskQueryKeys.taskQueryKeys.runs({ basePath, kind, status: statusFilter, labels });
+    const receive = (next) => setReceived({ key: requestKey, runs: next });
     if (forcePoll || !hasEventSource()) {
       let stopped = false;
       let timer;
@@ -140,7 +143,7 @@ function useTaskRuns(options = {}) {
             headers: { Accept: "application/json" }
           });
           if (res.ok) {
-            setRuns(await res.json());
+            receive(await res.json());
             setStatus("polling");
           }
         } catch {
@@ -158,14 +161,14 @@ function useTaskRuns(options = {}) {
     setStatus("connected");
     es.addEventListener("runs", (e) => {
       try {
-        setRuns(JSON.parse(e.data));
+        receive(JSON.parse(e.data));
       } catch {
       }
     });
     es.onerror = () => setStatus("connection lost — retrying");
     return () => es.close();
   }, [kind, statusFilter, JSON.stringify(labels ?? {}), basePath, enabled, pollMs, forcePoll]);
-  return { runs, status };
+  return { runs: received.runs, status, runsKey: received.key };
 }
 exports.useTaskRun = useTaskRun;
 exports.useTaskRuns = useTaskRuns;