@flanksource/clicky-ui 0.3.21 → 0.3.22

package/dist/data/query-info/queryInfo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryInfo.cjs","sources":["../../../src/data/query-info/queryInfo.ts"],"sourcesContent":["import type { QueryBrowserDiagnostics } from \"../query-browser/QueryBrowser.types\";\n\n/** Media type a result URL answers with when asked what it runs. */\nexport const QUERY_INFO_CONTENT_TYPE = \"application/info+json\";\n\n/**\n * What a result URL says about itself: the query its backend was actually sent,\n * the arguments bound into it, how long it took and what came back.\n *\n * A table shows rows, never the query behind them — the server renders that from\n * parameters and filters which only exist at execution time. This is the answer\n * to \"what did this actually run\", and it is the same answer whether the run\n * succeeded or failed.\n */\nexport type QueryExecutionInfo = {\n  profile?: string;\n  provider?: string;\n  connection?: string;\n  url?: string;\n  params?: Record<string, unknown>;\n  mode?: string;\n  rows?: number;\n  durationMs?: number;\n  headers?: Record<string, string>;\n  diagnostics?: QueryBrowserDiagnostics;\n  /** Set when the execution failed; its diagnostics still describe the query. */\n  error?: string;\n};\n\n/** Loads the info for one surface — a URL to ask, or a console's own re-run. */\nexport type QueryInfoLoader = () => Promise<QueryExecutionInfo>;\n\n/**\n * buildQueryInfoUrl marks a result URL as a question about itself rather than a\n * request for its rows. The marker rides in the query string so the URL stays\n * one a browser can follow, and every parameter the table sent — filters, paging,\n * the lot — is carried along unchanged: an info request for a different page\n * would describe a different query.\n */\nexport function buildQueryInfoUrl(url: string): string {\n  if (/[?&]__info=/.test(url)) return url;\n  const hashAt = url.indexOf(\"#\");\n  const base = hashAt === -1 ? url : url.slice(0, hashAt);\n  const hash = hashAt === -1 ? \"\" : url.slice(hashAt);\n  return `${base}${base.includes(\"?\") ? \"&\" : \"?\"}__info=true${hash}`;\n}\n\n/**\n * fetchQueryInfo asks a result URL what it runs.\n *\n * A failed execution is not a failed request: the server answers it with the\n * same document plus the error, because a query that broke is the one most worth\n * reading. Only a response that carries no document at all throws.\n */\nexport async function fetchQueryInfo(url: string): Promise<QueryExecutionInfo> {\n  const response = await fetch(buildQueryInfoUrl(url), {\n    headers: { Accept: QUERY_INFO_CONTENT_TYPE },\n  });\n  const body = await response.text();\n  const parsed = parseInfoBody(body);\n  if (response.ok) {\n    if (!parsed) throw new Error(`${url} did not answer with query details`);\n    return parsed;\n  }\n  if (!parsed) {\n    throw new Error(`${url} answered ${response.status} ${response.statusText}`);\n  }\n  return parsed;\n}\n\ntype ExecutionErrorBody = {\n  code?: string;\n  message?: string;\n  error?: string;\n  diagnostics?: QueryBrowserDiagnostics;\n};\n\nfunction parseInfoBody(body: string): QueryExecutionInfo | null {\n  let value: unknown;\n  try {\n    value = JSON.parse(body);\n  } catch {\n    return null;\n  }\n  if (!value || typeof value !== \"object\") return null;\n  const info = value as QueryExecutionInfo & ExecutionErrorBody;\n  const error = info.error ?? info.message;\n  if (!error) return info;\n  return { ...info, error };\n}\n"],"names":[],"mappings":";;AAGO,MAAM,0BAA0B;AAoChC,SAAS,kBAAkB,KAAqB;AACrD,MAAI,cAAc,KAAK,GAAG,EAAG,QAAO;AACpC,QAAM,SAAS,IAAI,QAAQ,GAAG;AAC9B,QAAM,OAAO,WAAW,KAAK,MAAM,IAAI,MAAM,GAAG,MAAM;AACtD,QAAM,OAAO,WAAW,KAAK,KAAK,IAAI,MAAM,MAAM;AAClD,SAAO,GAAG,IAAI,GAAG,KAAK,SAAS,GAAG,IAAI,MAAM,GAAG,cAAc,IAAI;AACnE;AASA,eAAsB,eAAe,KAA0C;AAC7E,QAAM,WAAW,MAAM,MAAM,kBAAkB,GAAG,GAAG;AAAA,IACnD,SAAS,EAAE,QAAQ,wBAAA;AAAA,EAAwB,CAC5C;AACD,QAAM,OAAO,MAAM,SAAS,KAAA;AAC5B,QAAM,SAAS,cAAc,IAAI;AACjC,MAAI,SAAS,IAAI;AACf,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,GAAG,GAAG,oCAAoC;AACvE,WAAO;AAAA,EACT;AACA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,GAAG,GAAG,aAAa,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,EAC7E;AACA,SAAO;AACT;AASA,SAAS,cAAc,MAAyC;AAC9D,MAAI;AACJ,MAAI;AACF,YAAQ,KAAK,MAAM,IAAI;AAAA,EACzB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,OAAO;AACb,QAAM,QAAQ,KAAK,SAAS,KAAK;AACjC,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO,EAAE,GAAG,MAAM,MAAA;AACpB;;;;"}

package/dist/data/query-info/queryInfo.d.ts

@@ -0,0 +1,45 @@
+import { QueryBrowserDiagnostics } from '../query-browser/QueryBrowser.types';
+/** Media type a result URL answers with when asked what it runs. */
+export declare const QUERY_INFO_CONTENT_TYPE = "application/info+json";
+/**
+ * What a result URL says about itself: the query its backend was actually sent,
+ * the arguments bound into it, how long it took and what came back.
+ *
+ * A table shows rows, never the query behind them — the server renders that from
+ * parameters and filters which only exist at execution time. This is the answer
+ * to "what did this actually run", and it is the same answer whether the run
+ * succeeded or failed.
+ */
+export type QueryExecutionInfo = {
+    profile?: string;
+    provider?: string;
+    connection?: string;
+    url?: string;
+    params?: Record<string, unknown>;
+    mode?: string;
+    rows?: number;
+    durationMs?: number;
+    headers?: Record<string, string>;
+    diagnostics?: QueryBrowserDiagnostics;
+    /** Set when the execution failed; its diagnostics still describe the query. */
+    error?: string;
+};
+/** Loads the info for one surface — a URL to ask, or a console's own re-run. */
+export type QueryInfoLoader = () => Promise<QueryExecutionInfo>;
+/**
+ * buildQueryInfoUrl marks a result URL as a question about itself rather than a
+ * request for its rows. The marker rides in the query string so the URL stays
+ * one a browser can follow, and every parameter the table sent — filters, paging,
+ * the lot — is carried along unchanged: an info request for a different page
+ * would describe a different query.
+ */
+export declare function buildQueryInfoUrl(url: string): string;
+/**
+ * fetchQueryInfo asks a result URL what it runs.
+ *
+ * A failed execution is not a failed request: the server answers it with the
+ * same document plus the error, because a query that broke is the one most worth
+ * reading. Only a response that carries no document at all throws.
+ */
+export declare function fetchQueryInfo(url: string): Promise<QueryExecutionInfo>;
+//# sourceMappingURL=queryInfo.d.ts.map

package/dist/data/query-info/queryInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryInfo.d.ts","sourceRoot":"","sources":["../../../src/data/query-info/queryInfo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAEnF,oEAAoE;AACpE,eAAO,MAAM,uBAAuB,0BAA0B,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAc7E"}

package/dist/data/query-info/queryInfo.js

@@ -0,0 +1,42 @@
+const QUERY_INFO_CONTENT_TYPE = "application/info+json";
+function buildQueryInfoUrl(url) {
+  if (/[?&]__info=/.test(url)) return url;
+  const hashAt = url.indexOf("#");
+  const base = hashAt === -1 ? url : url.slice(0, hashAt);
+  const hash = hashAt === -1 ? "" : url.slice(hashAt);
+  return `${base}${base.includes("?") ? "&" : "?"}__info=true${hash}`;
+}
+async function fetchQueryInfo(url) {
+  const response = await fetch(buildQueryInfoUrl(url), {
+    headers: { Accept: QUERY_INFO_CONTENT_TYPE }
+  });
+  const body = await response.text();
+  const parsed = parseInfoBody(body);
+  if (response.ok) {
+    if (!parsed) throw new Error(`${url} did not answer with query details`);
+    return parsed;
+  }
+  if (!parsed) {
+    throw new Error(`${url} answered ${response.status} ${response.statusText}`);
+  }
+  return parsed;
+}
+function parseInfoBody(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const info = value;
+  const error = info.error ?? info.message;
+  if (!error) return info;
+  return { ...info, error };
+}
+export {
+  QUERY_INFO_CONTENT_TYPE,
+  buildQueryInfoUrl,
+  fetchQueryInfo
+};
+//# sourceMappingURL=queryInfo.js.map

package/dist/data/query-info/queryInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryInfo.js","sources":["../../../src/data/query-info/queryInfo.ts"],"sourcesContent":["import type { QueryBrowserDiagnostics } from \"../query-browser/QueryBrowser.types\";\n\n/** Media type a result URL answers with when asked what it runs. */\nexport const QUERY_INFO_CONTENT_TYPE = \"application/info+json\";\n\n/**\n * What a result URL says about itself: the query its backend was actually sent,\n * the arguments bound into it, how long it took and what came back.\n *\n * A table shows rows, never the query behind them — the server renders that from\n * parameters and filters which only exist at execution time. This is the answer\n * to \"what did this actually run\", and it is the same answer whether the run\n * succeeded or failed.\n */\nexport type QueryExecutionInfo = {\n  profile?: string;\n  provider?: string;\n  connection?: string;\n  url?: string;\n  params?: Record<string, unknown>;\n  mode?: string;\n  rows?: number;\n  durationMs?: number;\n  headers?: Record<string, string>;\n  diagnostics?: QueryBrowserDiagnostics;\n  /** Set when the execution failed; its diagnostics still describe the query. */\n  error?: string;\n};\n\n/** Loads the info for one surface — a URL to ask, or a console's own re-run. */\nexport type QueryInfoLoader = () => Promise<QueryExecutionInfo>;\n\n/**\n * buildQueryInfoUrl marks a result URL as a question about itself rather than a\n * request for its rows. The marker rides in the query string so the URL stays\n * one a browser can follow, and every parameter the table sent — filters, paging,\n * the lot — is carried along unchanged: an info request for a different page\n * would describe a different query.\n */\nexport function buildQueryInfoUrl(url: string): string {\n  if (/[?&]__info=/.test(url)) return url;\n  const hashAt = url.indexOf(\"#\");\n  const base = hashAt === -1 ? url : url.slice(0, hashAt);\n  const hash = hashAt === -1 ? \"\" : url.slice(hashAt);\n  return `${base}${base.includes(\"?\") ? \"&\" : \"?\"}__info=true${hash}`;\n}\n\n/**\n * fetchQueryInfo asks a result URL what it runs.\n *\n * A failed execution is not a failed request: the server answers it with the\n * same document plus the error, because a query that broke is the one most worth\n * reading. Only a response that carries no document at all throws.\n */\nexport async function fetchQueryInfo(url: string): Promise<QueryExecutionInfo> {\n  const response = await fetch(buildQueryInfoUrl(url), {\n    headers: { Accept: QUERY_INFO_CONTENT_TYPE },\n  });\n  const body = await response.text();\n  const parsed = parseInfoBody(body);\n  if (response.ok) {\n    if (!parsed) throw new Error(`${url} did not answer with query details`);\n    return parsed;\n  }\n  if (!parsed) {\n    throw new Error(`${url} answered ${response.status} ${response.statusText}`);\n  }\n  return parsed;\n}\n\ntype ExecutionErrorBody = {\n  code?: string;\n  message?: string;\n  error?: string;\n  diagnostics?: QueryBrowserDiagnostics;\n};\n\nfunction parseInfoBody(body: string): QueryExecutionInfo | null {\n  let value: unknown;\n  try {\n    value = JSON.parse(body);\n  } catch {\n    return null;\n  }\n  if (!value || typeof value !== \"object\") return null;\n  const info = value as QueryExecutionInfo & ExecutionErrorBody;\n  const error = info.error ?? info.message;\n  if (!error) return info;\n  return { ...info, error };\n}\n"],"names":[],"mappings":"AAGO,MAAM,0BAA0B;AAoChC,SAAS,kBAAkB,KAAqB;AACrD,MAAI,cAAc,KAAK,GAAG,EAAG,QAAO;AACpC,QAAM,SAAS,IAAI,QAAQ,GAAG;AAC9B,QAAM,OAAO,WAAW,KAAK,MAAM,IAAI,MAAM,GAAG,MAAM;AACtD,QAAM,OAAO,WAAW,KAAK,KAAK,IAAI,MAAM,MAAM;AAClD,SAAO,GAAG,IAAI,GAAG,KAAK,SAAS,GAAG,IAAI,MAAM,GAAG,cAAc,IAAI;AACnE;AASA,eAAsB,eAAe,KAA0C;AAC7E,QAAM,WAAW,MAAM,MAAM,kBAAkB,GAAG,GAAG;AAAA,IACnD,SAAS,EAAE,QAAQ,wBAAA;AAAA,EAAwB,CAC5C;AACD,QAAM,OAAO,MAAM,SAAS,KAAA;AAC5B,QAAM,SAAS,cAAc,IAAI;AACjC,MAAI,SAAS,IAAI;AACf,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,GAAG,GAAG,oCAAoC;AACvE,WAAO;AAAA,EACT;AACA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,GAAG,GAAG,aAAa,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,EAC7E;AACA,SAAO;AACT;AASA,SAAS,cAAc,MAAyC;AAC9D,MAAI;AACJ,MAAI;AACF,YAAQ,KAAK,MAAM,IAAI;AAAA,EACzB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,OAAO;AACb,QAAM,QAAQ,KAAK,SAAS,KAAK;AACjC,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO,EAAE,GAAG,MAAM,MAAA;AACpB;"}

package/dist/data/query-info/useQueryInfo.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const react = require("react");
+const QueryInfoDialog = require("./QueryInfoDialog.cjs");
+const queryInfo = require("./queryInfo.cjs");
+const UiDebug = require("../../icons/components/UiDebug.cjs");
+function useQueryInfo({
+  url,
+  load,
+  title
+}) {
+  const [open, setOpen] = react.useState(false);
+  const loader = react.useMemo(() => {
+    if (load) return load;
+    if (!url) return void 0;
+    return () => queryInfo.fetchQueryInfo(url);
+  }, [load, url]);
+  const close = react.useCallback(() => setOpen(false), []);
+  const action = react.useMemo(
+    () => loader ? {
+      id: "show-query",
+      label: "Debug",
+      icon: UiDebug.UiDebug,
+      // No heading and no description: one word under a "Debug" heading
+      // beside a one-line gloss of itself is three ways of saying the
+      // same thing in a menu with room for one.
+      section: "",
+      onSelect: () => setOpen(true)
+    } : void 0,
+    [loader]
+  );
+  if (!loader) return { action: void 0, dialog: null };
+  return {
+    action,
+    dialog: /* @__PURE__ */ jsxRuntime.jsx(
+      QueryInfoDialog.QueryInfoDialog,
+      {
+        open,
+        onClose: close,
+        load: loader,
+        ...title ? { title } : {}
+      }
+    )
+  };
+}
+exports.useQueryInfo = useQueryInfo;
+//# sourceMappingURL=useQueryInfo.cjs.map

package/dist/data/query-info/useQueryInfo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueryInfo.cjs","sources":["../../../src/data/query-info/useQueryInfo.tsx"],"sourcesContent":["import { useCallback, useMemo, useState, type ReactNode } from \"react\";\nimport { UiDebug } from \"../../icons\";\nimport type { DataTableMenuAction } from \"../DataTable\";\nimport { QueryInfoDialog } from \"./QueryInfoDialog\";\nimport { fetchQueryInfo, type QueryInfoLoader } from \"./queryInfo\";\n\nexport type UseQueryInfoOptions = {\n  /** Result URL to ask what it runs. Ignored when `load` is given. */\n  url?: string | undefined;\n  /** Reads the details some other way — a console re-running its own query. */\n  load?: QueryInfoLoader | undefined;\n  /** Dialog heading. */\n  title?: string | undefined;\n};\n\nexport type UseQueryInfoResult = {\n  /** \"Debug\" for the table's overflow menu; absent with nothing to ask. */\n  action: DataTableMenuAction | undefined;\n  /** Render alongside the table — the dialog the action opens. */\n  dialog: ReactNode;\n};\n\n/**\n * useQueryInfo puts \"Debug\" in a result table's overflow menu.\n *\n * The details are read when the menu item is chosen, never before: asking costs\n * a second execution against the same backend, which is a price only a user who\n * wants the answer should pay.\n */\nexport function useQueryInfo({\n  url,\n  load,\n  title,\n}: UseQueryInfoOptions): UseQueryInfoResult {\n  const [open, setOpen] = useState(false);\n  const loader = useMemo<QueryInfoLoader | undefined>(() => {\n    if (load) return load;\n    if (!url) return undefined;\n    return () => fetchQueryInfo(url);\n  }, [load, url]);\n  const close = useCallback(() => setOpen(false), []);\n  // The action lands in a memoized menu-action list, so a fresh object each\n  // render would rebuild that list — and the table's menu — on every render.\n  const action = useMemo<DataTableMenuAction | undefined>(\n    () =>\n      loader\n        ? {\n            id: \"show-query\",\n            label: \"Debug\",\n            icon: UiDebug,\n            // No heading and no description: one word under a \"Debug\" heading\n            // beside a one-line gloss of itself is three ways of saying the\n            // same thing in a menu with room for one.\n            section: \"\",\n            onSelect: () => setOpen(true),\n          }\n        : undefined,\n    [loader],\n  );\n\n  if (!loader) return { action: undefined, dialog: null };\n\n  return {\n    action,\n    dialog: (\n      <QueryInfoDialog\n        open={open}\n        onClose={close}\n        load={loader}\n        {...(title ? { title } : {})}\n      />\n    ),\n  };\n}\n"],"names":["useState","useMemo","fetchQueryInfo","useCallback","UiDebug","jsx","QueryInfoDialog"],"mappings":";;;;;;;AA6BO,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AACF,GAA4C;AAC1C,QAAM,CAAC,MAAM,OAAO,IAAIA,MAAAA,SAAS,KAAK;AACtC,QAAM,SAASC,MAAAA,QAAqC,MAAM;AACxD,QAAI,KAAM,QAAO;AACjB,QAAI,CAAC,IAAK,QAAO;AACjB,WAAO,MAAMC,UAAAA,eAAe,GAAG;AAAA,EACjC,GAAG,CAAC,MAAM,GAAG,CAAC;AACd,QAAM,QAAQC,MAAAA,YAAY,MAAM,QAAQ,KAAK,GAAG,CAAA,CAAE;AAGlD,QAAM,SAASF,MAAAA;AAAAA,IACb,MACE,SACI;AAAA,MACE,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,MAAMG,QAAAA;AAAAA;AAAAA;AAAAA;AAAAA,MAIN,SAAS;AAAA,MACT,UAAU,MAAM,QAAQ,IAAI;AAAA,IAAA,IAE9B;AAAA,IACN,CAAC,MAAM;AAAA,EAAA;AAGT,MAAI,CAAC,OAAQ,QAAO,EAAE,QAAQ,QAAW,QAAQ,KAAA;AAEjD,SAAO;AAAA,IACL;AAAA,IACA,QACEC,2BAAAA;AAAAA,MAACC,gBAAAA;AAAAA,MAAA;AAAA,QACC;AAAA,QACA,SAAS;AAAA,QACT,MAAM;AAAA,QACL,GAAI,QAAQ,EAAE,UAAU,CAAA;AAAA,MAAC;AAAA,IAAA;AAAA,EAC5B;AAGN;;"}

package/dist/data/query-info/useQueryInfo.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { DataTableMenuAction } from '../DataTable';
+import { QueryInfoLoader } from './queryInfo';
+export type UseQueryInfoOptions = {
+    /** Result URL to ask what it runs. Ignored when `load` is given. */
+    url?: string | undefined;
+    /** Reads the details some other way — a console re-running its own query. */
+    load?: QueryInfoLoader | undefined;
+    /** Dialog heading. */
+    title?: string | undefined;
+};
+export type UseQueryInfoResult = {
+    /** "Debug" for the table's overflow menu; absent with nothing to ask. */
+    action: DataTableMenuAction | undefined;
+    /** Render alongside the table — the dialog the action opens. */
+    dialog: ReactNode;
+};
+/**
+ * useQueryInfo puts "Debug" in a result table's overflow menu.
+ *
+ * The details are read when the menu item is chosen, never before: asking costs
+ * a second execution against the same backend, which is a price only a user who
+ * wants the answer should pay.
+ */
+export declare function useQueryInfo({ url, load, title, }: UseQueryInfoOptions): UseQueryInfoResult;
+//# sourceMappingURL=useQueryInfo.d.ts.map

package/dist/data/query-info/useQueryInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueryInfo.d.ts","sourceRoot":"","sources":["../../../src/data/query-info/useQueryInfo.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG;IAChC,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACnC,sBAAsB;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yEAAyE;IACzE,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACxC,gEAAgE;IAChE,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAC3B,GAAG,EACH,IAAI,EACJ,KAAK,GACN,EAAE,mBAAmB,GAAG,kBAAkB,CAwC1C"}

package/dist/data/query-info/useQueryInfo.js

@@ -0,0 +1,48 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useMemo, useCallback } from "react";
+import { QueryInfoDialog } from "./QueryInfoDialog.js";
+import { fetchQueryInfo } from "./queryInfo.js";
+import { UiDebug } from "../../icons/components/UiDebug.js";
+function useQueryInfo({
+  url,
+  load,
+  title
+}) {
+  const [open, setOpen] = useState(false);
+  const loader = useMemo(() => {
+    if (load) return load;
+    if (!url) return void 0;
+    return () => fetchQueryInfo(url);
+  }, [load, url]);
+  const close = useCallback(() => setOpen(false), []);
+  const action = useMemo(
+    () => loader ? {
+      id: "show-query",
+      label: "Debug",
+      icon: UiDebug,
+      // No heading and no description: one word under a "Debug" heading
+      // beside a one-line gloss of itself is three ways of saying the
+      // same thing in a menu with room for one.
+      section: "",
+      onSelect: () => setOpen(true)
+    } : void 0,
+    [loader]
+  );
+  if (!loader) return { action: void 0, dialog: null };
+  return {
+    action,
+    dialog: /* @__PURE__ */ jsx(
+      QueryInfoDialog,
+      {
+        open,
+        onClose: close,
+        load: loader,
+        ...title ? { title } : {}
+      }
+    )
+  };
+}
+export {
+  useQueryInfo
+};
+//# sourceMappingURL=useQueryInfo.js.map

package/dist/data/query-info/useQueryInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueryInfo.js","sources":["../../../src/data/query-info/useQueryInfo.tsx"],"sourcesContent":["import { useCallback, useMemo, useState, type ReactNode } from \"react\";\nimport { UiDebug } from \"../../icons\";\nimport type { DataTableMenuAction } from \"../DataTable\";\nimport { QueryInfoDialog } from \"./QueryInfoDialog\";\nimport { fetchQueryInfo, type QueryInfoLoader } from \"./queryInfo\";\n\nexport type UseQueryInfoOptions = {\n  /** Result URL to ask what it runs. Ignored when `load` is given. */\n  url?: string | undefined;\n  /** Reads the details some other way — a console re-running its own query. */\n  load?: QueryInfoLoader | undefined;\n  /** Dialog heading. */\n  title?: string | undefined;\n};\n\nexport type UseQueryInfoResult = {\n  /** \"Debug\" for the table's overflow menu; absent with nothing to ask. */\n  action: DataTableMenuAction | undefined;\n  /** Render alongside the table — the dialog the action opens. */\n  dialog: ReactNode;\n};\n\n/**\n * useQueryInfo puts \"Debug\" in a result table's overflow menu.\n *\n * The details are read when the menu item is chosen, never before: asking costs\n * a second execution against the same backend, which is a price only a user who\n * wants the answer should pay.\n */\nexport function useQueryInfo({\n  url,\n  load,\n  title,\n}: UseQueryInfoOptions): UseQueryInfoResult {\n  const [open, setOpen] = useState(false);\n  const loader = useMemo<QueryInfoLoader | undefined>(() => {\n    if (load) return load;\n    if (!url) return undefined;\n    return () => fetchQueryInfo(url);\n  }, [load, url]);\n  const close = useCallback(() => setOpen(false), []);\n  // The action lands in a memoized menu-action list, so a fresh object each\n  // render would rebuild that list — and the table's menu — on every render.\n  const action = useMemo<DataTableMenuAction | undefined>(\n    () =>\n      loader\n        ? {\n            id: \"show-query\",\n            label: \"Debug\",\n            icon: UiDebug,\n            // No heading and no description: one word under a \"Debug\" heading\n            // beside a one-line gloss of itself is three ways of saying the\n            // same thing in a menu with room for one.\n            section: \"\",\n            onSelect: () => setOpen(true),\n          }\n        : undefined,\n    [loader],\n  );\n\n  if (!loader) return { action: undefined, dialog: null };\n\n  return {\n    action,\n    dialog: (\n      <QueryInfoDialog\n        open={open}\n        onClose={close}\n        load={loader}\n        {...(title ? { title } : {})}\n      />\n    ),\n  };\n}\n"],"names":[],"mappings":";;;;;AA6BO,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AACF,GAA4C;AAC1C,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,KAAK;AACtC,QAAM,SAAS,QAAqC,MAAM;AACxD,QAAI,KAAM,QAAO;AACjB,QAAI,CAAC,IAAK,QAAO;AACjB,WAAO,MAAM,eAAe,GAAG;AAAA,EACjC,GAAG,CAAC,MAAM,GAAG,CAAC;AACd,QAAM,QAAQ,YAAY,MAAM,QAAQ,KAAK,GAAG,CAAA,CAAE;AAGlD,QAAM,SAAS;AAAA,IACb,MACE,SACI;AAAA,MACE,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,MAAM;AAAA;AAAA;AAAA;AAAA,MAIN,SAAS;AAAA,MACT,UAAU,MAAM,QAAQ,IAAI;AAAA,IAAA,IAE9B;AAAA,IACN,CAAC,MAAM;AAAA,EAAA;AAGT,MAAI,CAAC,OAAQ,QAAO,EAAE,QAAQ,QAAW,QAAQ,KAAA;AAEjD,SAAO;AAAA,IACL;AAAA,IACA,QACE;AAAA,MAAC;AAAA,MAAA;AAAA,QACC;AAAA,QACA,SAAS;AAAA,QACT,MAAM;AAAA,QACL,GAAI,QAAQ,EAAE,UAAU,CAAA;AAAA,MAAC;AAAA,IAAA;AAAA,EAC5B;AAGN;"}

package/dist/data/use-infinite-rows.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+function useInfiniteRows(infinite, rowCount) {
+  const latest = react.useRef(infinite);
+  latest.current = infinite;
+  const pending = react.useRef(false);
+  const loading = (infinite == null ? void 0 : infinite.loading) ?? false;
+  react.useEffect(() => {
+    pending.current = false;
+  }, [loading, rowCount]);
+  return react.useCallback(() => {
+    const current = latest.current;
+    if (!current || current.loading || !current.hasMore || pending.current) return;
+    pending.current = true;
+    current.onLoadMore();
+  }, []);
+}
+exports.useInfiniteRows = useInfiniteRows;
+//# sourceMappingURL=use-infinite-rows.cjs.map

package/dist/data/use-infinite-rows.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-infinite-rows.cjs","sources":["../../src/data/use-infinite-rows.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport type { DataTableInfinite } from \"./DataTable\";\n\n/**\n * useInfiniteRows turns the trailing sentinel's intersection callbacks into at\n * most one page request, and returns the callback DataTable hands the observer.\n *\n * The `loading` flag on its own is not a sufficient guard. One scroll delivers a\n * burst of intersections inside a single frame, long before the caller has\n * re-rendered with the flag set, so the burst would be spent asking for the same\n * page over and over. A request therefore latches, and the latch is released\n * only by the caller answering: rows arriving, or `loading` moving — which is\n * also what stops a page that legitimately returned nothing from wedging the\n * list closed. Everything else the observer delivers in between is dropped.\n *\n * `infinite` is read through a ref because callers rebuild it inline on every\n * render. Depending on it directly would give the returned callback a new\n * identity each time, and DataTable would tear down and re-create the\n * IntersectionObserver with it.\n */\nexport function useInfiniteRows(\n  infinite: DataTableInfinite | undefined,\n  rowCount: number,\n): () => void {\n  const latest = useRef(infinite);\n  latest.current = infinite;\n  const pending = useRef(false);\n  const loading = infinite?.loading ?? false;\n\n  useEffect(() => {\n    pending.current = false;\n  }, [loading, rowCount]);\n\n  return useCallback(() => {\n    const current = latest.current;\n    if (!current || current.loading || !current.hasMore || pending.current) return;\n    pending.current = true;\n    current.onLoadMore();\n  }, []);\n}\n"],"names":["useRef","useEffect","useCallback"],"mappings":";;;AAoBO,SAAS,gBACd,UACA,UACY;AACZ,QAAM,SAASA,MAAAA,OAAO,QAAQ;AAC9B,SAAO,UAAU;AACjB,QAAM,UAAUA,MAAAA,OAAO,KAAK;AAC5B,QAAM,WAAU,qCAAU,YAAW;AAErCC,QAAAA,UAAU,MAAM;AACd,YAAQ,UAAU;AAAA,EACpB,GAAG,CAAC,SAAS,QAAQ,CAAC;AAEtB,SAAOC,MAAAA,YAAY,MAAM;AACvB,UAAM,UAAU,OAAO;AACvB,QAAI,CAAC,WAAW,QAAQ,WAAW,CAAC,QAAQ,WAAW,QAAQ,QAAS;AACxE,YAAQ,UAAU;AAClB,YAAQ,WAAA;AAAA,EACV,GAAG,CAAA,CAAE;AACP;;"}

package/dist/data/use-infinite-rows.d.ts

@@ -0,0 +1,20 @@
+import { DataTableInfinite } from './DataTable';
+/**
+ * useInfiniteRows turns the trailing sentinel's intersection callbacks into at
+ * most one page request, and returns the callback DataTable hands the observer.
+ *
+ * The `loading` flag on its own is not a sufficient guard. One scroll delivers a
+ * burst of intersections inside a single frame, long before the caller has
+ * re-rendered with the flag set, so the burst would be spent asking for the same
+ * page over and over. A request therefore latches, and the latch is released
+ * only by the caller answering: rows arriving, or `loading` moving — which is
+ * also what stops a page that legitimately returned nothing from wedging the
+ * list closed. Everything else the observer delivers in between is dropped.
+ *
+ * `infinite` is read through a ref because callers rebuild it inline on every
+ * render. Depending on it directly would give the returned callback a new
+ * identity each time, and DataTable would tear down and re-create the
+ * IntersectionObserver with it.
+ */
+export declare function useInfiniteRows(infinite: DataTableInfinite | undefined, rowCount: number): () => void;
+//# sourceMappingURL=use-infinite-rows.d.ts.map

package/dist/data/use-infinite-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-infinite-rows.d.ts","sourceRoot":"","sources":["../../src/data/use-infinite-rows.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,QAAQ,EAAE,MAAM,GACf,MAAM,IAAI,CAgBZ"}

package/dist/data/use-infinite-rows.js

@@ -0,0 +1,20 @@
+import { useRef, useEffect, useCallback } from "react";
+function useInfiniteRows(infinite, rowCount) {
+  const latest = useRef(infinite);
+  latest.current = infinite;
+  const pending = useRef(false);
+  const loading = (infinite == null ? void 0 : infinite.loading) ?? false;
+  useEffect(() => {
+    pending.current = false;
+  }, [loading, rowCount]);
+  return useCallback(() => {
+    const current = latest.current;
+    if (!current || current.loading || !current.hasMore || pending.current) return;
+    pending.current = true;
+    current.onLoadMore();
+  }, []);
+}
+export {
+  useInfiniteRows
+};
+//# sourceMappingURL=use-infinite-rows.js.map

package/dist/data/use-infinite-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-infinite-rows.js","sources":["../../src/data/use-infinite-rows.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport type { DataTableInfinite } from \"./DataTable\";\n\n/**\n * useInfiniteRows turns the trailing sentinel's intersection callbacks into at\n * most one page request, and returns the callback DataTable hands the observer.\n *\n * The `loading` flag on its own is not a sufficient guard. One scroll delivers a\n * burst of intersections inside a single frame, long before the caller has\n * re-rendered with the flag set, so the burst would be spent asking for the same\n * page over and over. A request therefore latches, and the latch is released\n * only by the caller answering: rows arriving, or `loading` moving — which is\n * also what stops a page that legitimately returned nothing from wedging the\n * list closed. Everything else the observer delivers in between is dropped.\n *\n * `infinite` is read through a ref because callers rebuild it inline on every\n * render. Depending on it directly would give the returned callback a new\n * identity each time, and DataTable would tear down and re-create the\n * IntersectionObserver with it.\n */\nexport function useInfiniteRows(\n  infinite: DataTableInfinite | undefined,\n  rowCount: number,\n): () => void {\n  const latest = useRef(infinite);\n  latest.current = infinite;\n  const pending = useRef(false);\n  const loading = infinite?.loading ?? false;\n\n  useEffect(() => {\n    pending.current = false;\n  }, [loading, rowCount]);\n\n  return useCallback(() => {\n    const current = latest.current;\n    if (!current || current.loading || !current.hasMore || pending.current) return;\n    pending.current = true;\n    current.onLoadMore();\n  }, []);\n}\n"],"names":[],"mappings":";AAoBO,SAAS,gBACd,UACA,UACY;AACZ,QAAM,SAAS,OAAO,QAAQ;AAC9B,SAAO,UAAU;AACjB,QAAM,UAAU,OAAO,KAAK;AAC5B,QAAM,WAAU,qCAAU,YAAW;AAErC,YAAU,MAAM;AACd,YAAQ,UAAU;AAAA,EACpB,GAAG,CAAC,SAAS,QAAQ,CAAC;AAEtB,SAAO,YAAY,MAAM;AACvB,UAAM,UAAU,OAAO;AACvB,QAAI,CAAC,WAAW,QAAQ,WAAW,CAAC,QAAQ,WAAW,QAAQ,QAAS;AACxE,YAAQ,UAAU;AAClB,YAAQ,WAAA;AAAA,EACV,GAAG,CAAA,CAAE;AACP;"}

package/dist/data/version-info.cjs

@@ -15,9 +15,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "370d1147", ""),
-    tag: read(() => "clicky-ui@0.3.20", ""),
-    date: read(() => "2026-08-19T08:11:17.385Z", ""),
+    commit: read(() => "624423d8", ""),
+    tag: read(() => "clicky-ui@0.3.21", ""),
+    date: read(() => "2026-08-19T11:27:15.090Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data/version-info.js

@@ -13,9 +13,9 @@ function detectMode() {
 }
 function getVersionInfo() {
   return {
-    commit: read(() => "370d1147", ""),
-    tag: read(() => "clicky-ui@0.3.20", ""),
-    date: read(() => "2026-08-19T08:11:00.856Z", ""),
+    commit: read(() => "624423d8", ""),
+    tag: read(() => "clicky-ui@0.3.21", ""),
+    date: read(() => "2026-08-19T11:27:01.125Z", ""),
     dirty: read(() => true, false),
     mode: detectMode()
   };

package/dist/data.cjs

@@ -37,6 +37,8 @@ const LogViewer = require("./data/LogViewer.cjs");
 const LogsTable = require("./data/LogsTable.cjs");
 const logsNormalize = require("./data/logs-normalize.cjs");
 const MatrixTable = require("./data/MatrixTable.cjs");
+const Callout = require("./data/Callout.cjs");
+const calloutTones = require("./data/callout-tones.cjs");
 const Markdown = require("./data/Markdown.cjs");
 const MarkdownEditor = require("./data/MarkdownEditor.cjs");
 const MarkdownEditor_model = require("./data/MarkdownEditor.model.cjs");
@@ -66,6 +68,7 @@ const Version = require("./data/Version.cjs");
 const versionInfo = require("./data/version-info.cjs");
 const Tree = require("./data/Tree.cjs");
 const ObjectGraph = require("./data/ObjectGraph.cjs");
+const objectGraphNodes = require("./data/object-graph-nodes.cjs");
 const ExecutionTree = require("./data/ExecutionTree.cjs");
 const TreeNode = require("./data/TreeNode.cjs");
 const TreeGroupHeader = require("./data/TreeGroupHeader.cjs");
@@ -98,10 +101,13 @@ const CacheDetailPanel = require("./data/cache-browser/CacheDetailPanel.cjs");
 const CacheTree = require("./data/cache-browser/CacheTree.cjs");
 const CacheStatsOverview = require("./data/cache-browser/CacheStatsOverview.cjs");
 const CacheValue = require("./data/cache-browser/CacheValue.cjs");
+const ClickyExportDialog = require("./data/clicky-export/ClickyExportDialog.cjs");
 const FixtureEditor = require("./data/FixtureEditor/FixtureEditor.cjs");
 const GitChangeList = require("./data/git/GitChangeList.cjs");
+const queryInfo = require("./data/query-info/queryInfo.cjs");
 const QueryBrowser = require("./data/query-browser/QueryBrowser.cjs");
 const QueryBrowser_types = require("./data/query-browser/QueryBrowser.types.cjs");
+const QueryInfoDialog = require("./data/query-info/QueryInfoDialog.cjs");
 const status = require("./data/test-runner/status.cjs");
 const TestFailureDetail = require("./data/test-runner/TestFailureDetail.cjs");
 const TestDetailPanel = require("./data/test-runner/TestDetailPanel.cjs");
@@ -123,6 +129,7 @@ const UiArrowLeft = require("./icons/components/UiArrowLeft.cjs");
 const UiArrowRight = require("./icons/components/UiArrowRight.cjs");
 const UiArrowUp = require("./icons/components/UiArrowUp.cjs");
 const UiArrowUpRight = require("./icons/components/UiArrowUpRight.cjs");
+const UiArrowsCounterClockwise = require("./icons/components/UiArrowsCounterClockwise.cjs");
 const UiAsterisk = require("./icons/components/UiAsterisk.cjs");
 const UiAsyncFn = require("./icons/components/UiAsyncFn.cjs");
 const UiAt = require("./icons/components/UiAt.cjs");
@@ -164,6 +171,7 @@ const UiCircleFilled = require("./icons/components/UiCircleFilled.cjs");
 const UiCircleOutline = require("./icons/components/UiCircleOutline.cjs");
 const UiCircleX = require("./icons/components/UiCircleX.cjs");
 const UiClass = require("./icons/components/UiClass.cjs");
+const UiClipboardText = require("./icons/components/UiClipboardText.cjs");
 const UiClock = require("./icons/components/UiClock.cjs");
 const UiClose = require("./icons/components/UiClose.cjs");
 const UiCloud = require("./icons/components/UiCloud.cjs");
@@ -249,6 +257,7 @@ const UiHistory = require("./icons/components/UiHistory.cjs");
 const UiHome = require("./icons/components/UiHome.cjs");
 const UiHourglass = require("./icons/components/UiHourglass.cjs");
 const UiHubot = require("./icons/components/UiHubot.cjs");
+const UiIdentificationCard = require("./icons/components/UiIdentificationCard.cjs");
 const UiImage = require("./icons/components/UiImage.cjs");
 const UiImport = require("./icons/components/UiImport.cjs");
 const UiInbox = require("./icons/components/UiInbox.cjs");
@@ -283,6 +292,7 @@ const UiListTree = require("./icons/components/UiListTree.cjs");
 const UiLoader = require("./icons/components/UiLoader.cjs");
 const UiLocation = require("./icons/components/UiLocation.cjs");
 const UiLock = require("./icons/components/UiLock.cjs");
+const UiLockKey = require("./icons/components/UiLockKey.cjs");
 const UiLockOpen = require("./icons/components/UiLockOpen.cjs");
 const UiLogoAnthropic = require("./icons/components/UiLogoAnthropic.cjs");
 const UiLogoClaude = require("./icons/components/UiLogoClaude.cjs");
@@ -388,6 +398,7 @@ const UiSquare = require("./icons/components/UiSquare.cjs");
 const UiStack = require("./icons/components/UiStack.cjs");
 const UiStackFrameDot = require("./icons/components/UiStackFrameDot.cjs");
 const UiStar = require("./icons/components/UiStar.cjs");
+const UiSteps = require("./icons/components/UiSteps.cjs");
 const UiStop = require("./icons/components/UiStop.cjs");
 const UiStrategy = require("./icons/components/UiStrategy.cjs");
 const UiString = require("./icons/components/UiString.cjs");
@@ -417,6 +428,8 @@ const UiUpload = require("./icons/components/UiUpload.cjs");
 const UiUser = require("./icons/components/UiUser.cjs");
 const UiUserCircle = require("./icons/components/UiUserCircle.cjs");
 const UiUserCog = require("./icons/components/UiUserCog.cjs");
+const UiUserGear = require("./icons/components/UiUserGear.cjs");
+const UiUsersFour = require("./icons/components/UiUsersFour.cjs");
 const UiUsersThree = require("./icons/components/UiUsersThree.cjs");
 const UiVariable = require("./icons/components/UiVariable.cjs");
 const UiVideo = require("./icons/components/UiVideo.cjs");
@@ -438,6 +451,8 @@ const filterState = require("./data/test-runner/filterState.cjs");
 const gitDates = require("./data/git/git-dates.cjs");
 const frameworkIcon = require("./data/test-runner/frameworkIcon.cjs");
 const types = require("./data/cache-browser/types.cjs");
+const useClickyExport = require("./data/clicky-export/useClickyExport.cjs");
+const useQueryInfo = require("./data/query-info/useQueryInfo.cjs");
 exports.AnsiHtml = AnsiHtml.AnsiHtml;
 exports.Avatar = Avatar.Avatar;
 exports.AvatarBadge = AvatarBadge.AvatarBadge;
@@ -503,6 +518,12 @@ exports.LogViewer = LogViewer.LogViewer;
 exports.LogsTable = LogsTable.LogsTable;
 exports.normalizeLogsTableRows = logsNormalize.normalizeLogsTableRows;
 exports.MatrixTable = MatrixTable.MatrixTable;
+exports.Callout = Callout.Callout;
+exports.CALLOUT_TONES = calloutTones.CALLOUT_TONES;
+exports.CALLOUT_VARIANTS = calloutTones.CALLOUT_VARIANTS;
+exports.CALLOUT_VARIANT_LABELS = calloutTones.CALLOUT_VARIANT_LABELS;
+exports.assertCalloutValue = calloutTones.assertCalloutValue;
+exports.calloutVariantStyles = calloutTones.calloutVariantStyles;
 exports.Markdown = Markdown.Markdown;
 exports.MarkdownEditor = MarkdownEditor.MarkdownEditor;
 exports.MARKDOWN_EDITOR_PREVIEW_FORMATS = MarkdownEditor_model.MARKDOWN_EDITOR_PREVIEW_FORMATS;
@@ -546,6 +567,8 @@ exports.Version = Version.Version;
 exports.getVersionInfo = versionInfo.getVersionInfo;
 exports.Tree = Tree.Tree;
 exports.ObjectGraph = ObjectGraph.ObjectGraph;
+exports.countObjectGraphNodes = objectGraphNodes.countObjectGraphNodes;
+exports.pruneNullNodes = objectGraphNodes.pruneNullNodes;
 exports.ExecutionTree = ExecutionTree.ExecutionTree;
 exports.TreeNode = TreeNode.TreeNode;
 exports.TreeGroupHeader = TreeGroupHeader.TreeGroupHeader;
@@ -604,13 +627,18 @@ exports.CacheNodeRow = CacheTree.CacheNodeRow;
 exports.CacheTree = CacheTree.CacheTree;
 exports.CacheStatsOverview = CacheStatsOverview.CacheStatsOverview;
 exports.CacheValue = CacheValue.CacheValue;
+exports.ClickyExportDialog = ClickyExportDialog.ClickyExportDialog;
 exports.FixtureEditor = FixtureEditor.FixtureEditor;
 exports.GitChangedFilesSummary = GitChangeList.GitChangedFilesSummary;
 exports.GitCommitList = GitChangeList.GitCommitList;
 exports.GitDiffPanel = GitChangeList.GitDiffPanel;
 exports.GitFileList = GitChangeList.GitFileList;
+exports.QUERY_INFO_CONTENT_TYPE = queryInfo.QUERY_INFO_CONTENT_TYPE;
+exports.buildQueryInfoUrl = queryInfo.buildQueryInfoUrl;
+exports.fetchQueryInfo = queryInfo.fetchQueryInfo;
 exports.QueryBrowser = QueryBrowser.QueryBrowser;
 exports.QueryBrowserExecutionError = QueryBrowser_types.QueryBrowserExecutionError;
+exports.QueryInfoDialog = QueryInfoDialog.QueryInfoDialog;
 exports.STATUS_LABELS = status.STATUS_LABELS;
 exports.aggregateStatusCounts = status.aggregateStatusCounts;
 exports.collapseSingleChildChains = status.collapseSingleChildChains;
@@ -658,6 +686,8 @@ exports.UiArrowRightFilled = UiArrowRight.UiArrowRightFilled;
 exports.UiArrowUp = UiArrowUp.UiArrowUp;
 exports.UiArrowUpFilled = UiArrowUp.UiArrowUpFilled;
 exports.UiArrowUpRight = UiArrowUpRight.UiArrowUpRight;
+exports.UiArrowsCounterClockwise = UiArrowsCounterClockwise.UiArrowsCounterClockwise;
+exports.UiArrowsCounterClockwiseFilled = UiArrowsCounterClockwise.UiArrowsCounterClockwiseFilled;
 exports.UiAsterisk = UiAsterisk.UiAsterisk;
 exports.UiAsteriskFilled = UiAsterisk.UiAsteriskFilled;
 exports.UiAsyncFn = UiAsyncFn.UiAsyncFn;
@@ -736,6 +766,8 @@ exports.UiCircleOutlineFilled = UiCircleOutline.UiCircleOutlineFilled;
 exports.UiCircleX = UiCircleX.UiCircleX;
 exports.UiCircleXFilled = UiCircleX.UiCircleXFilled;
 exports.UiClass = UiClass.UiClass;
+exports.UiClipboardText = UiClipboardText.UiClipboardText;
+exports.UiClipboardTextFilled = UiClipboardText.UiClipboardTextFilled;
 exports.UiClock = UiClock.UiClock;
 exports.UiClockFilled = UiClock.UiClockFilled;
 exports.UiClose = UiClose.UiClose;
@@ -897,6 +929,8 @@ exports.UiHourglass = UiHourglass.UiHourglass;
 exports.UiHourglassFilled = UiHourglass.UiHourglassFilled;
 exports.UiHubot = UiHubot.UiHubot;
 exports.UiHubotFilled = UiHubot.UiHubotFilled;
+exports.UiIdentificationCard = UiIdentificationCard.UiIdentificationCard;
+exports.UiIdentificationCardFilled = UiIdentificationCard.UiIdentificationCardFilled;
 exports.UiImage = UiImage.UiImage;
 exports.UiImageFilled = UiImage.UiImageFilled;
 exports.UiImport = UiImport.UiImport;
@@ -956,6 +990,8 @@ exports.UiLocation = UiLocation.UiLocation;
 exports.UiLocationFilled = UiLocation.UiLocationFilled;
 exports.UiLock = UiLock.UiLock;
 exports.UiLockFilled = UiLock.UiLockFilled;
+exports.UiLockKey = UiLockKey.UiLockKey;
+exports.UiLockKeyFilled = UiLockKey.UiLockKeyFilled;
 exports.UiLockOpen = UiLockOpen.UiLockOpen;
 exports.UiLockOpenFilled = UiLockOpen.UiLockOpenFilled;
 exports.UiLogoAnthropic = UiLogoAnthropic.UiLogoAnthropic;
@@ -1140,6 +1176,8 @@ exports.UiStackFilled = UiStack.UiStackFilled;
 exports.UiStackFrameDot = UiStackFrameDot.UiStackFrameDot;
 exports.UiStar = UiStar.UiStar;
 exports.UiStarFilled = UiStar.UiStarFilled;
+exports.UiSteps = UiSteps.UiSteps;
+exports.UiStepsFilled = UiSteps.UiStepsFilled;
 exports.UiStop = UiStop.UiStop;
 exports.UiStrategy = UiStrategy.UiStrategy;
 exports.UiStrategyFilled = UiStrategy.UiStrategyFilled;
@@ -1199,6 +1237,10 @@ exports.UiUserCircleMinusFilled = UiUserCircle.UiUserCircleMinusFilled;
 exports.UiUserCirclePlus = UiUserCircle.UiUserCirclePlus;
 exports.UiUserCirclePlusFilled = UiUserCircle.UiUserCirclePlusFilled;
 exports.UiUserCog = UiUserCog.UiUserCog;
+exports.UiUserGear = UiUserGear.UiUserGear;
+exports.UiUserGearFilled = UiUserGear.UiUserGearFilled;
+exports.UiUsersFour = UiUsersFour.UiUsersFour;
+exports.UiUsersFourFilled = UiUsersFour.UiUsersFourFilled;
 exports.UiUsersThree = UiUsersThree.UiUsersThree;
 exports.UiUsersThreeCheck = UiUsersThree.UiUsersThreeCheck;
 exports.UiUsersThreeCheckFilled = UiUsersThree.UiUsersThreeCheckFilled;
@@ -1259,4 +1301,6 @@ exports.recordToFilterState = filterState.recordToFilterState;
 exports.formatGitCommitDateHeader = gitDates.formatGitCommitDateHeader;
 exports.frameworkIcon = frameworkIcon.frameworkIcon;
 exports.isLeaf = types.isLeaf;
+exports.useClickyExport = useClickyExport.useClickyExport;
+exports.useQueryInfo = useQueryInfo.useQueryInfo;
 //# sourceMappingURL=data.cjs.map

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

@@ -9,8 +9,8 @@ export { computeLineDiff, parseUnifiedDiff, type DiffHunk, type DiffLine, type D
 export { inferColumns } from './data/data-table-utils';
 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 { DataTable, type DataTableColumn, type DataTableColumnInput, type DataTableColumnKind, type DataTableCursorPagination, type DataTableFooterContext, type DataTableInfinite, 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, type DataTableGroupMetaAlign, } 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';
@@ -36,6 +36,8 @@ export { LogViewer, type LogViewerProps } from './data/LogViewer';
 export { LogsTable, type LogsTableInput, type LogsTableProps, type LogsTableRow, } from './data/LogsTable';
 export { normalizeLogsTableRows } from './data/logs-normalize';
 export { MatrixTable, type MatrixTableProps, type MatrixTableRow } from './data/MatrixTable';
+export { Callout, type CalloutProps } from './data/Callout';
+export { assertCalloutValue, CALLOUT_TONES, CALLOUT_VARIANT_LABELS, CALLOUT_VARIANTS, calloutVariantStyles, type CalloutTone, type CalloutVariant, type CalloutVariantStyle, } from './data/callout-tones';
 export { Markdown, type MarkdownProps } from './data/Markdown';
 export { MarkdownEditor, type MarkdownEditorProps } from './data/MarkdownEditor';
 export * from './data/FixtureEditor';
@@ -65,7 +67,8 @@ export { segment } from './data/status-breakdown-utils';
 export { Version, type VersionProps } from './data/Version';
 export { getVersionInfo, type RuntimeMode, type VersionInfo, } from './data/version-info';
 export { Tree, type TreeProps } from './data/Tree';
-export { ObjectGraph, type ObjectGraphNode, type ObjectGraphProps } from './data/ObjectGraph';
+export { ObjectGraph, type ObjectGraphProps } from './data/ObjectGraph';
+export { countObjectGraphNodes, pruneNullNodes, type ObjectGraphNode, } from './data/object-graph-nodes';
 export { ExecutionTree, type ExecutionNode, type ExecutionTreeProps } from './data/ExecutionTree';
 export { TreeNode, type TreeNodeProps, type TreeRowContext } from './data/TreeNode';
 export { TreeGroupHeader, type TreeGroupHeaderProps } from './data/TreeGroupHeader';
@@ -74,6 +77,8 @@ export * from './data/git';
 export * from './data/test-runner';
 export * from './data/cache-browser';
 export * from './data/query-browser';
+export * from './data/query-info';
+export * from './data/clicky-export';
 export { type LogEntry, type TaskControlAction, type TaskExecDetails, 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';